开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Web服务器 > 查看源码
http.c.XX
资源名称：phttpd-1.10.04.tar.gz　[点击查看]
上传用户：ladybrid91
上传日期：2007-01-04
资源大小：287k
文件大小：22k
源码类别：

Web服务器

开发平台：

Unix_Linux

http.c.XX：源码内容
  1. /*
  2. ** http.c
  3. **
  4. ** Copyright (c) 1994-1997 Peter Eriksson <pen@signum.se>
  5. **
  6. ** This program is free software; you can redistribute it and/or modify
  7. ** it under the terms of the GNU General Public License as published by
  8. ** the Free Software Foundation; either version 2 of the License, or
  9. ** (at your option) any later version.
  10. **
  11. ** This program is distributed in the hope that it will be useful,
  12. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. ** GNU General Public License for more details.
  15. ** You should have received a copy of the GNU General Public License
  16. ** along with this program; if not, write to the Free Software
  17. ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <unistd.h>
  23. #include <string.h>
  24. #include <errno.h>
  25. #include <stdarg.h>
  26. #include <limits.h>
  27. #include <time.h>
  28. #include <syslog.h>
  30. #include <sys/types.h>
  31. #include <sys/stat.h>
  33. #define IN_DNS_C
  34. #include "phttpd.h"
  38. int phttpd_call(const char *module,
  39. struct connectioninfo *cip)
  40. {
  41.     struct modinfo *mp;
  42.     void *mkey;
  43.     int status;
  44.     char buf[2048];
  45.     
  46.     
  47.     while (*module && *module == '/')
  48. ++module;
  50.     s_strcpy(buf, sizeof(buf), modules_home);
  51.     s_strcat(buf, sizeof(buf), "/");
  52.     s_strcat(buf, sizeof(buf), module);
  53.     
  54.     mp = md_load(buf, &mkey);
  55.     if (mp == NULL)
  56.     {
  57. return http_error(cip, 500,
  58.   "A system error occured while loading module <B>%s</B>:<BR><PRE>%s</PRE>",
  59.   module, md_error());
  60.     }
  62.     status = mp->pm_request(cip);
  63.     
  64.     md_release(mkey);
  65.     return status;
  66. }
  68. int phttpd_request(struct connectioninfo *cip)
  69. {
  70.     const char *handler;
  71.     
  73.     if (cip->hip == NULL)
  74. return -1;
  75.     
  76.     handler = url_gethandler(cip->hip->url);
  77.     if (handler == NULL)
  78. return -1;
  79.     return phttpd_call(handler, cip);
  81. }
  84. void http_sendlastmodified(int fd, time_t ct)
  85. {
  86.     char buf[64];
  87.     
  88.     fd_puts("Last-Modified: ", fd);
  89.     fd_puts(http_time_r(&ct, buf, sizeof(buf)), fd);
  90. }
  92. char *http_sendheaders(int fd,
  93.        struct connectioninfo *cip,
  94.        int code,
  95.        char *type)
  96. {
  97.     char buf[256];
  98.     time_t ct;
  99.     int keepalive;
  101.     ct = cip->cn_time;
  103.     if (cip->hip && cip->hip->mip)
  104. keepalive = cip->hip->mip->connection_flags & MCF_KEEPALIVE;
  105.     else
  106. keepalive = 0;
  107.     
  108.     if (ct == 0)
  109. time(&ct);
  111.     if (type == NULL)
  112. switch (abs(code))
  113. {
  114.   case 200:
  115.     type = "OK";
  116.     break;
  118.   case 201:
  119.     type = "Created";
  120.     break;
  122.   case 202:
  123.     type = "Accepted";
  124.     break;
  126.   case 203:
  127.     type = "Provisional Information";
  128.     break;
  130.   case 204:
  131.     type = "No Content";
  132.     break;
  134.   case 206:
  135.     type = "Partial Content";
  136.     break;
  138.   case 300:
  139.     type = "Multiple Choices";
  140.     break;
  142.   case 301:
  143.     type = "Moved Permanently";
  144.     break;
  145.     
  146.   case 302:
  147.     type = "Moved Temporarily";
  148.     break;
  150.   case 303:
  151.     type = "Method";
  152.     break;
  153.     
  154.   case 304:
  155.     type = "Not Modified";
  156.     break;
  158.   case 400:
  159.     type = "Bad Request";
  160.     break;
  162.   case 401:
  163.     type = "Unauthorized";
  164.     break;
  166.   case 402:
  167.     type = "Payment Forbidden";
  168.     break;
  170.   case 403:
  171.     type = "Forbidden";
  172.     break;
  174.   case 404:
  175.     type = "Not Found";
  176.     break;
  178.   case 405:
  179.     type = "Method Not Allowed";
  180.     break;
  182.   case 406:
  183.     type = "None Acceptable";
  184.     break;
  185.     
  186.   case 407:
  187.     type = "Proxy Authentication Required";
  188.     break;
  189.     
  190.   case 408:
  191.     type = "Request Timeout";
  192.     break;
  193.     
  194.   case 409:
  195.     type = "Conflict";
  196.     break;
  197.     
  198.   case 410:
  199.     type = "Gone";
  200.     break;
  202.   case 412:
  203.     type = "Precondition Failed";
  204.     break;
  205.     
  206.   case 500:
  207.     type = "Internal Server Error";
  208.     break;
  210.   case 501:
  211.     type = "Not Implemented";
  212.     break;
  213.     
  214.   case 502:
  215.     type = "Bad Gateway";
  216.     break;
  217.     
  218.   case 503:
  219.     type = "Service Unavailable";
  220.     break;
  221.     
  222.   case 504:
  223.     type = "Gateway Timeout";
  224.     break;
  225.     
  226.   default:
  227.     type = "?";
  228. }
  230.     if (cip->hip->version)
  231.     {  if ( strcasecmp(cip->hip->version,"HTTP/1.1") !=0 )
  232.          fd_puts("HTTP/1.0 ", fd);
  233.        else
  234.          fd_puts("HTTP/1.1 ", fd);
  235.     }
  236.     else
  237.          fd_puts("HTTP/1.0 ", fd);
  239.     fd_puti(code, fd);
  240.     fd_putc(' ', fd);
  241.     fd_puts(type, fd);
  242.     fd_putc('n', fd);
  243.     
  244.     fd_puts("MIME-Version: 1.0n", fd);
  245. /* Yes, we can that ! rk@netuse.de  check this, only for FILES.so */
  246. /*    fd_puts("Accept-ranges: bytesn", fd); */
  248.     fd_puts("Date: ", fd);
  249.     fd_puts(http_time_r(&ct, buf, sizeof(buf)), fd);
  250.     
  251.     fd_puts("Server: phttpd/", fd);
  252.     fd_puts(server_version, fd);
  253.     fd_putc('n', fd);
  255.     if (keepalive && (keepalive_timeout > 0 || keepalive_maxreq > 0))
  256.     {
  257. fd_puts("Connection: Keep-Alive", fd);
  258. if (keepalive_timeout > 0)
  259.     fd_printf(fd, ", timeout=%d", keepalive_timeout);
  260. if (keepalive_maxreq > 0)
  261.     fd_printf(fd, ", maxreq=%d", keepalive_maxreq);
  262. fd_putc('n', fd);
  263.     }
  264.     
  265.     return type;
  266. }    
  268. int http_unauthorized(struct connectioninfo *cip, const char *realm)
  269. {
  270.     int result;
  271.     int fd = cip->fd;
  272.     struct httpinfo *hip = cip->hip;
  274.     
  275.     if (debug > 1)
  276. fprintf(stderr, "      Sent UNAUTHORIZED messagen");
  278.     result = 401;
  280.     if (hip->mip != NULL)
  281.     {
  282. http_sendheaders(fd, cip, result, NULL);
  283. fd_printf(fd, "WWW-Authenticate: Basic realm="%s"n", realm);
  284. fd_putc('n', fd);
  285.     }
  287.     if(strcasecmp(hip->method, "HEAD") == 0)
  288.        return result;
  290.     html_sysheader(fd, "H2", "Unauthorized");
  292.     fd_printf(fd, "Please send authorization codes for realm "%s".n",
  293.       realm);
  295.     html_sysfooter(fd);
  296.     
  297.     return result;
  298. }
  302. int http_forbidden(struct connectioninfo *cip)
  303. {
  304.     int result;
  305.     int fd = cip->fd;
  306.     struct httpinfo *hip = cip->hip;
  308.     
  309.     if (debug > 1)
  310. fprintf(stderr, "      Sent FORBIDDEN messagen");
  312.     result = 403;
  314.     if (hip->mip != NULL)
  315.     {
  316. http_sendheaders(fd, cip, result, NULL);
  317. fd_putc('n', fd);
  318.     }
  319.     
  320.     if(strcasecmp(hip->method, "HEAD") == 0)
  321.        return result;
  323.     html_sysheader(fd, "H2", "Access Denied");
  325.     fd_printf(fd, "Your request to ");
  326.     if (hip->orig_url == NULL)
  327. fd_printf(fd, "[null]");
  328.     else
  329. html_href(fd, hip->orig_url, hip->orig_url);
  330.     
  331.     fd_printf(fd, " was denied.n");
  333.     html_sysfooter(fd);
  334.     
  335.     return result;
  336. }
  339. int http_authenticate(struct connectioninfo *cip,
  340.       const char *path,
  341.       const char *realm,
  342.       char *request)
  343. {
  345.    if ( debug > 5 )
  346.      fprintf(stderr,"--x-- PATH: %sn",(path!=NULL) ? path : "<NULL>" );
  347.    if (!access_auth(cip->hip, cip, path))
  348. return http_unauthorized(cip, realm);
  350.    return 0;
  351. }
  354. int http_access(struct connectioninfo *cip,
  355. urlinfo_t *uip,
  356. char *request)
  357. {
  359.     if ( access_check(uip, cip) == 0 )
  360. return error_access(cip);
  362. /* access_check does set uip->source etc and so forces password authentification ! */
  363. /* if wanted -- in http.c http_access MUST be called befor http_authenticate */
  365.     return 0;
  366. }
  369. /*
  370.  *  Extract the request (the part after the first '?') in URL and add
  371.  *  it to the beginning of *REQUESTP.
  372.  */
  373. void
  374. http_extract_request(char *url, char **requestp)
  375. {
  376.     char *cp;
  378.     if (url == NULL)
  379. return;
  380.     
  381.     cp = strchr(url, '?');
  382.     if (cp != NULL)
  383.     {
  384. *cp++ = '';
  385. if (requestp == NULL)
  386.     return;
  388. if (!*requestp)
  389. {
  390.     *requestp = s_strdup(cp);
  391. }
  392. else
  393. {
  394.     char *oldrequest = *requestp;
  395.     size_t oldlen = strlen(oldrequest);
  396.     size_t addlen = strlen(cp);
  398.     *requestp = s_malloc(oldlen + 1 + addlen + 1);
  399.     memcpy(*requestp, oldrequest, oldlen);
  400.     *(*requestp + oldlen) = '?';
  401.     memcpy(*requestp + oldlen + 1, cp, addlen);
  402.     *(*requestp + oldlen + 1 + addlen) = '';
  403.     s_free(oldrequest);
  404. }
  405.     }
  406. }
  410. int http_get_request(struct connectioninfo *cip,
  411.      int *keepalive)
  412. {
  413.     char buf[2048], *lastcp, *url, *req, *rawurl;
  414.     struct httpinfo *hip = NULL;
  415.     int result = -1;
  416.     int headerbytes;
  417.     ucentry_t *ucp;
  418.     urlinfo_t *uip;
  419.     char *realm;
  420.     int len;
  421.     char *mvsxy,*svpath;
  422.     char *slash = "/";
  423.     
  426.     ucp = NULL;
  427.     uip = NULL;
  428.     
  429.     if (debug > 1)
  430. fprintf(stderr, "http_get_request(), fd=%dn", cip->fd);
  431.     
  432.     if ((req = fd_gets(NULL, maxurlsize, cip->fd)) == NULL)
  433.     {
  434. if (debug > 2)
  435.     fprintf(stderr, "t->Returning failed (fd=%d)n", cip->fd);
  436. return -1;
  437.     }
  438.     
  439.     hip = s_malloc(sizeof(struct httpinfo));
  440.     headerbytes=strlen(req);
  441.    
  442.     hip->svsname = NULL;
  443.     hip->method = strtok_r(req, " tnr", &lastcp);
  444.     if (hip->method == NULL)
  445.     {
  446. s_free(hip);
  447. return -1;
  448.     }
  449.     
  450.     url = strtok_r(NULL, " tnr", &lastcp);
  451.     if (url)
  452. hip->version = s_strdup(strtok_r(NULL, " tnr", &lastcp));
  454.     if (url == NULL)
  455.     {
  456. s_free(hip->method);
  457. s_free(hip);
  458. return -1;
  459.     }
  461. /* Clear setup.... */
  462.     hip->prelen=0;
  464. /* Added for Multi-Virtual-Server RK */
  465. /* Some how ugly, might be a nicer way to code this, but it works ! */
  466. /* Maybe one should create differnt global accept code, depending on the
  467. ** mode, we are running. This may look nicer, but more code to maintain. 
  468. ** 23.11.97 rk@netuse.de
  469. */
  471.     if ( rkmultimode != 0 ) /* We are in MULTIMODE */
  472. {
  473.     if ( debug >6 )
  474. fprintf(stderr,"MVS-RK: Adding prefixn");
  475.     len = strlen(url)+10;
  476.     mvsxy=s_malloc(len);
  477. /* notslash will drop *ALL* leading / ..... */
  478.     s_sprintf(mvsxy, len, "/%08lx/%s", cip->server->sin.sin_addr.s_addr, notslash(url));
  479.     
  480.     /* lenght of prefix is 8 + 1 (+1) (still fix !) */
  481.             hip->prelen=9;
  483.     if ( debug >6 )
  484. fprintf(stderr,"MVS-RK: calling freen");
  485.     
  486.     url[strlen(mvsxy)]=0x00; /* wg.logfile */
  487.     s_strcpy(url,strlen(url)+11, mvsxy);
  488.     
  489.     s_free(mvsxy);
  490.     if ( debug >6 )
  491. fprintf(stderr,"MVS-RK: prefix donen");
  492. }
  493.     if ( softvirtserver!=0 && hip->version != NULL )
  494.     { /* working here.......... 1.1 */
  495.       if ( hip->prelen != 0 ) len=hip->prelen+1;
  496.       else len=0;
  497.       if ( debug >6 ) fprintf(stderr,"SVS-http: %s (%d)n",url,len);
  498.       if (    strncasecmp(url+len,"http://",7)== 0 
  499. /* Disabled, since common broser send a HTTP/1.0 and SVS-Information :-( */
  500.         /*   && strcasecmp(hip->version,"HTTP/1.1")==0  */
  501.    && strlen(url+len) > 7 )
  502.       { /* we got CMD http://host/path HTTP/1.x */
  503. rawurl=url;
  504. url=url+len+7;
  505. svpath=strchr(url,'/'); /* add : */
  507.         if ( svpath != NULL ) len=svpath-url;
  508. else                { len=strlen(url); svpath=slash; }
  510.         hip->svsname=s_strndup(url,len);
  511. str_to_lower(hip->svsname);
  513. /* check for :port and DROP !! */
  514. mvsxy=strchr(hip->svsname,':');
  515. if ( mvsxy != NULL ) *mvsxy=0x00;
  518. if ( debug >6 ) fprintf(stderr,"SVS-Host: %s (%d) n",hip->svsname,len);
  519. len = strlen(rawurl);
  520. mvsxy=s_malloc(len);
  521.         if ( rkmultimode )
  522.            s_sprintf(mvsxy, len, "%.9s/%s/%s",rawurl,hip->svsname,notslash(svpath));
  523.         else
  524.             s_sprintf(mvsxy, len, "/%s/%s",hip->svsname,notslash(svpath));
  525.         
  526. hip->prelen=hip->prelen+strlen(hip->svsname)+1;
  527.         if (debug > 6 ) fprintf(stderr, "SVS1: NEWURL: %s (%d)n",mvsxy,hip->prelen);
  528. hip->svstype=SVSINGET;
  529.         s_strcpy(url,strlen(mvsxy)+1, mvsxy);
  530.  
  531.         url[strlen(mvsxy)]=0x00; /* wg.logfile */
  532.         s_free(mvsxy);
  534.       } /* we have softvirtserver set, but no information about that was sent.... */
  535.       else
  536.       if ( debug >6 ) fprintf(stderr,"SVS-Host: -not-1.1-n");
  538.     }
  539.     /* END RK */
  540.     
  541.     if (debug > 4)
  542. fprintf(stderr, "Method = %s, URL = %s PL = %dn",
  543. hip->method, url ? url : "<null>", hip->prelen);
  544.     
  545.     cip->hip = hip;
  546. /* Do not use that new code, seems to be buggy !!!! rk@netuse.de */
  547. #if 0
  548.     hip->orig_url = s_strdup(url);
  549.     hip->orig_request = NULL;
  550.     url_unquote(url, 0);
  551. #else
  552.     http_extract_request(url, &hip->request);
  553.     hip->orig_url = s_strdup(url);
  554.     hip->orig_request = s_strdup(hip->request);
  555.     url_unquote(url, 0);
  557.     if (debug > 2)
  558. fprintf(stderr, "url=%snorig_url=%snreq=%snorig_req=%sn",
  559. url ? url : "<null>",
  560. hip->orig_url ? hip->orig_url : "<null>",
  561. hip->request ? hip->request : "<null>",
  562. hip->orig_request ? hip->orig_request : "<null>");
  563. #endif
  564.     
  565.     if (hip->version != NULL)
  566.     {
  567. hip->mip = mime_getheaders(cip->fd);
  568. if (hip->mip == NULL)
  569. {
  570.     error_bad_request(cip, "Invalid MIME headers");
  571.     goto End;
  572. }
  573. hip->mip->headerbytes=hip->mip->headerbytes+headerbytes;
  575. if (keepalive && hip->mip &&
  576.     (hip->mip->connection_flags & MCF_KEEPALIVE))
  577.     *keepalive = 1;
  579. /* Get the client-supplied authentication information */
  580. hip->aip = auth_get(hip);
  581.     }
  583. /* softvirtserver added here rk */
  584.     if ( softvirtserver!=0 && hip->svsname == NULL ) 
  585.     {
  586.    
  587.        hip->svsname=s_strdup(mime_getheader(hip->mip,"HOST",1));
  588.        if ( hip->svsname == NULL )
  589.          {
  590.    if ( rkmultimode )
  591.    {
  592.      hip->svsname=s_strdup(dns_lookup_servername(cip->server));
  593.      if ( hip->svsname == NULL ) 
  594. hip->svsname=s_strdup(server_host);
  595.    }
  596.    else
  597.              { if ( strcmp(server_host ,"*") == 0 )
  598.  {  
  599.     hip->svsname=s_strdup(dns_lookup_servername(cip->server));
  600.     if ( hip->svsname == NULL ) hip->svsname=s_strdup("err.do.main");
  601.  }
  602.        else
  603.           hip->svsname=s_strdup(server_host);
  604.      }
  605.  }
  607.   str_to_lower(hip->svsname);
  609.           /* check for :port and DROP !! */
  610.           mvsxy=strchr(hip->svsname,':');
  611.           if ( mvsxy != NULL ) *mvsxy=0x00;
  613.           if (debug > 6 ) fprintf(stderr, "SVS: Found: %sn",hip->svsname);
  615.           len = strlen(url)+strlen(hip->svsname)+2;
  616.   mvsxy=s_malloc(len);
  618.           if ( rkmultimode )
  619.     s_sprintf(mvsxy, len, "%.9s/%s/%s",url,hip->svsname,notslash(url+10));
  620.   else
  621.       s_sprintf(mvsxy, len, "/%s/%s",hip->svsname,notslash(url));
  624.   hip->prelen=hip->prelen+strlen(hip->svsname)+1;
  625. /*
  626. ** if (debug > 6 ) fprintf(stderr, "SVS2: NEWURL: %s (%d)n",mvsxy,hip->prelen);
  627. */
  628.           hip->svstype=SVSMIMEHOST;
  629.           s_strcpy(url,strlen(mvsxy)+1, mvsxy);
  631.           url[strlen(mvsxy)]=0x00; /* wg.logfile */
  632.           s_free(mvsxy);
  634.       
  635.     } /* end of softvirtserver! */
  637.     if (strcasecmp(hip->method, "PING") == 0)
  638.     {
  639. if (hip->mip)
  640. {
  641.     http_sendheaders(cip->fd, cip, 200, NULL);
  642.     result = 200;
  643.     fd_putc('n', cip->fd);
  644. }
  645. fd_puts("PONGn", cip->fd);
  646. goto End;
  647.     }
  648.     
  649.     if (hip->mip && (hip->mip->pragma_flags & MPF_NOCACHE))
  650. ucp = urlcache_lookup(url, UCF_ALL+UCF_RELOAD);
  651.     else
  652. ucp = urlcache_lookup(url, UCF_ALL);
  653.       
  654.     if (ucp == NULL)
  655. goto End;
  657. /*  XXXX url is now split into url and request part XXXX */
  658.     
  659.     uip = ucp->uip;
  660.     if (uip == NULL)
  661.     {
  662. urlcache_release(ucp);
  663. goto End;
  664.     }
  666.     hip->url = s_strdup(uip->rewrite.url);
  667.     
  668.     if (uip->rewrite.request)
  669.     {
  670. if (hip->request)
  671.     s_free(hip->request);
  672. hip->request = s_strdup(uip->rewrite.request);
  673.     }
  674.     
  675.     if (uip->redirect.url)
  676.     {
  677. result = http_redirect(cip,
  678.        uip->redirect.url,
  679.        uip->redirect.request,
  680.           hip->request,
  681.        302);
  682. goto End;
  683.     }
  684.     
  685.     if (uip->predirect.url)
  686.     {
  687. result = http_redirect(cip,
  688.        uip->predirect.url,
  689.        uip->predirect.request,
  690.           hip->request,
  691.        301);
  692. goto End;
  693.     }
  694.     
  695.     if (uip->access.path)
  696.     {
  697. result = http_access(cip, uip, hip->request);
  698. if (result != 0)
  699.     goto End;
  700.     }
  701.     
  703.     /* ADDED by RK */
  704.     if (debug > 4)
  705. fprintf(stderr,"Check write ACCESSn");
  706.     
  707.     if (write_needs_auth && 
  708. (strcasecmp(hip->method, "PUT")==0 ||
  709.  strcasecmp(hip->method, "DELETE")==0))
  710.     {
  711. if (debug > 4)
  712.     fprintf(stderr,"We have a write CMD...n");
  714.       if (write_getauthenticate(url, buf, sizeof(buf))) 
  715.       {
  716.           uip->auth.source=s_strdup(buf);
  717.           realm = uip->auth.source;
  718.           if (realm)
  719.           {   
  720.               while (*realm && !s_isspace(*realm))
  721.   ++realm;
  722.               if (s_isspace(*realm))
  723.   *realm++ = '';
  724.               while (*realm && s_isspace(*realm))
  725.   ++realm;
  726.           }
  727.           uip->auth.realm = realm;
  728.           uip->flags |= UCF_AUTH;
  729.   if ( debug > 4 )
  730.       fprintf(stderr,"Using auth for...%sn",uip->auth.source);
  731.       }
  732.       else
  733.       {
  734.           uip->auth.source=NULL;
  735.   result = -403;
  736.   goto End;
  737.       }
  738.     } /* end of write_needs_auth */
  740.     if (uip->auth.source)
  741.     {
  742. result = http_authenticate(cip,
  743.    uip->auth.source,
  744.    uip->auth.realm,
  745.    hip->request);
  746. if (result != 0)
  747.     goto End;
  748.     }
  750.     if (uip->handler)
  751. result = phttpd_call(uip->handler, cip);
  753.     if (debug > 3)
  754. fprintf(stderr, "MAIN-RETURN: Result=%dn", result);
  755.     
  756.   End:
  757.     if (result < 0)
  758. switch (result)
  759. {
  760.   case -1:
  761.     result = error_not_found(cip);
  762.     break;
  764.   case -403:
  765.     result = error_access(cip);
  766.     break;
  767.     
  768.   case -405:
  769.     result = error_method_denied(cip);
  770.     break;
  771.     
  772.   default:
  773.     result = error_bad_request(cip, hip->method);
  774.     syslog(LOG_NOTICE, "bad HTTP request (#%d) method: %s",
  775.    cip->request_no,
  776.    hip->method);
  777. }
  779.     if (ucp)
  780. urlcache_release(ucp);
  781.     
  782.     if (hip->length == 0)
  783. *keepalive = 0;
  784.     
  785.     if (debug > 1)
  786. fprintf(stderr, "http_get_request(), fd=%d, returning %dn",
  787. cip->fd, result);
  788.     
  789.     return result;
  790. }
  793. void http_freeinfo(struct httpinfo *hip)
  794. {
  795.     if (hip == NULL)
  796. return;
  797.     
  798.     s_free(hip->method);
  799.     s_free(hip->url);
  800.     s_free(hip->request);
  801.     s_free(hip->orig_url);
  802.     s_free(hip->orig_request);
  803.     s_free(hip->version);
  804.     s_free(hip->prefix);
  805.     s_free(hip->svsname);
  806.     
  807.     if (hip->mip) mime_freeheaders(hip->mip);
  808.     auth_free(hip->aip);
  809.     
  810.     s_free(hip);
  811. }
  813. int http_error(struct connectioninfo *cip,
  814.        int code,
  815.        const char *format,
  816.        ...)
  817. {
  818.     va_list ap;
  819.     char *type, buf[256];
  820.     struct httpinfo *hip = cip->hip;
  821.     
  823.     if (hip->mip != NULL)
  824.     {
  825. type = http_sendheaders(cip->fd, cip, code, NULL);
  826. fd_puts("Content-Type: text/htmln", cip->fd);
  827. fd_putc('n', cip->fd);
  828.     }
  829.     else
  830.     {
  831.         int blen;
  832.       
  833.         blen = s_strcpy(buf, sizeof(buf), "Error Code #");
  834. s_sprintf(buf+blen, sizeof(buf)-blen, "%d", code);
  835. type = buf;
  836.     }
  838.     if (strcasecmp(hip->method, "HEAD") == 0)
  839. return code;
  840.     
  841.     va_start(ap, format);
  842.     
  843.     html_error(cip->fd, type, format, ap);
  844.     
  845.     va_end(ap);
  846.     hip->length = fd_written(cip->fd);
  847.     
  848.     return code;
  849. }
  851. void http_sendlang(int fd, const char *url)
  852. {
  853.     int i;
  854.     char **pair;
  856.     if(content_language_table == NULL)
  857.         return;
  859.     for(i = 0; i < content_language_table->length; ++i)
  860.     {
  861.         pair = content_language_table->value[i];
  862. if(strmatch(url, pair[0]))
  863. {
  864.     fd_puts("Content-Language: ", fd);
  865.     fd_puts(pair[1], fd);
  866.     fd_putc('n', fd);
  867.     break;
  868. }
  869.     }
  870. }
  872. /* Send a redirect pointer */
  873. int http_redirect(struct connectioninfo *cip,
  874.   const char *url,
  875.   const char *request,
  876.   const char *orig_req,
  877.   int code)
  878. {
  879.     char buf1[2048], buf2[2048], buf3[2048];
  880.     int result, len;
  881.     int fd = cip->fd;
  882.     struct httpinfo *hip = cip->hip;
  885.     url = url_quote(url, buf1, sizeof(buf1), "?", 0);
  886.     if (url == NULL)
  887. return -1;
  888.     
  889.     if (request)
  890.     {
  891. request = url_quote(request, buf2, sizeof(buf2), """, 1);
  892. if (request == NULL)
  893.     return -1;
  894.     }
  896.     if (orig_req)
  897.     {
  898. orig_req = url_quote(orig_req, buf3, sizeof(buf3), """, 1);
  899. if (orig_req == NULL)
  900.     return -1;
  901.     }
  902.     
  903.     if (debug > 1)
  904. fprintf(stderr, "      Sent URL REDIRECT (%s -> %s)n",
  905. hip->url, url);
  907.     result = code;
  908.     
  909.     if (hip->mip != NULL)
  910.     {
  911. http_sendheaders(fd, cip, result, NULL);
  913. fd_printf(fd, "Location: %s%s%s%sn",
  914.   url,
  915.   (orig_req || request) ? "?" : "",
  916.   orig_req ? orig_req : "",
  917.   request ? request : "");
  918.   
  920. http_sendlastmodified(fd, cip->cn_time);
  921. fd_puts("Content-Type: text/htmlnn", fd);
  922.     }
  923.     
  924.     if (strcasecmp(hip->method, "HEAD") == 0)
  925. return result;
  926.     
  927.     len = fd_written(fd);
  929.     html_sysheader(fd, "H2", "Document moved");
  930.     
  931.     fd_puts("The document has moved to this URL:<P>n", fd);
  932.     fd_puts("<UL>n", fd);
  933.     
  934.     fd_printf(fd, "<B><A HREF="%s%s%s%s">%s%s%s%s</A></B>.n",
  935.       url,
  936.       (orig_req || request) ? "?" : "",
  937.       orig_req ? orig_req : "",
  938.       request ? request : "",
  939.       url,
  940.       (orig_req || request) ? "?" : "",
  941.       orig_req ? orig_req : "",
  942.       request ? request : "");
  943.     
  944.     fd_puts("</UL>n", fd);
  945.     
  946.     html_sysfooter(fd);
  948.     if (logheadervolume)
  949. hip->length = fd_written(fd);
  950.     else
  951. hip->length = fd_written(fd) - len; 
  953.     return result;
  954. }
  957. /* Send a 'Not Modified' message */
  958. int http_not_modified(struct connectioninfo *cip)
  959. {
  960.     int result;
  961.     int fd = cip->fd;
  962.     struct httpinfo *hip = cip->hip;
  964.     
  965.     if (debug > 1)
  966. fprintf(stderr, "      Sent NOT MODIFIED messagen");
  968.     result = 304;
  970.     if (hip->mip != NULL)
  971.     {
  972. http_sendheaders(fd, cip, result, NULL);
  973. fd_putc('n', fd);
  974.     }
  975.     hip->length = fd_written(fd);
  976.     return result;
  977. }
  980. /* Send a 'Precondition Failed' message */
  981. int http_precondition_failed(struct connectioninfo *cip)
  982. {
  983.     int result;
  984.     int fd = cip->fd;
  985.     struct httpinfo *hip = cip->hip;
  987.     
  988.     if (debug > 1)
  989. fprintf(stderr, "      Sent PRECONDITION FAILED messagen");
  991.     result = 412;
  993.     if (hip->mip != NULL)
  994.     {
  995. http_sendheaders(fd, cip, result, NULL);
  996. fd_putc('n', fd);
  997.     }
  998.     
  999.     if(strcasecmp(hip->method, "HEAD") == 0)
  1000.        return result;
  1002.     html_sysheader(fd, "H2", "Precondition Failed");
  1004.     fd_printf(fd, "The entity which lives at ");
  1005.     if (hip->orig_url == NULL)
  1006. fd_printf(fd, "[null]");
  1007.     else
  1008. html_href(fd, hip->orig_url, hip->orig_url);
  1009.     
  1010.     fd_printf(fd, " was changed.n");
  1012.     html_sysfooter(fd);
  1013.     hip->length = fd_written(fd);
  1014.     
  1015.     return result;
  1016. }
  1019. static const char *const weekday[] =
  1020. {
  1021.     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
  1022. };
  1024. static const char *const month[] =
  1025. {
  1026.     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  1027.     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  1028. };
  1031. char *http_time_r(const time_t *btp, char *buf, int bufsize)
  1032. {
  1033.     struct tm tpb;
  1035.     
  1036.     if (bufsize < 31)
  1037. return NULL;
  1038.     
  1039.     if (gmtime_r(btp, &tpb) == NULL)
  1040. return NULL;
  1042.     s_sprintf(buf, bufsize, "%s, %02d %s %d %02d:%02d:%02d GMTn",
  1043.     weekday[tpb.tm_wday],
  1044.     tpb.tm_mday,
  1045.     month[tpb.tm_mon],
  1046.     tpb.tm_year + 1900,
  1047.     tpb.tm_hour,
  1048.     tpb.tm_min,
  1049.     tpb.tm_sec);
  1051.     return buf;
  1052. }