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

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

Web服务器

开发平台：

Unix_Linux

http.c.X：源码内容
  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);
  80. }
  83. void http_sendlastmodified(int fd, time_t ct)
  84. {
  85.     char buf[64];
  86.     
  87.     fd_puts("Last-Modified: ", fd);
  88.     fd_puts(http_time_r(&ct, buf, sizeof(buf)), fd);
  89. }
  91. char *http_sendheaders(int fd,
  92.        struct connectioninfo *cip,
  93.        int code,
  94.        char *type)
  95. {
  96.     char buf[256];
  97.     time_t ct;
  98.     int keepalive;
  100.     
  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 (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 ( strcasecmp(cip->hip->version,"HTTP/1.1")!=0)
  231.       fd_puts("HTTP/1.0 ", fd);
  232.     else
  233.       fd_puts("HTTP/1.1 ", fd);
  234.     fd_puti(code, fd);
  235.     fd_putc(' ', fd);
  236.     fd_puts(type, fd);
  237.     fd_putc('n', fd);
  238.     
  239.     fd_puts("MIME-Version: 1.0n", fd);
  241.     fd_puts("Date: ", fd);
  242.     fd_puts(http_time_r(&ct, buf, sizeof(buf)), fd);
  243.     
  244.     fd_puts("Server: phttpd/", fd);
  245.     fd_puts(server_version, fd);
  246.     fd_putc('n', fd);
  248.     if (keepalive && (keepalive_timeout > 0 || keepalive_maxreq > 0))
  249.     {
  250. fd_puts("Connection: Keep-Alive", fd);
  251. if (keepalive_timeout > 0)
  252.     fd_printf(fd, ", timeout=%d", keepalive_timeout);
  253. if (keepalive_maxreq > 0)
  254.     fd_printf(fd, ", maxreq=%d", keepalive_maxreq);
  255. fd_putc('n', fd);
  256.     }
  257.     
  258.     return type;
  259. }    
  261. int http_unauthorized(struct connectioninfo *cip, const char *realm)
  262. {
  263.     int result;
  264.     int fd = cip->fd;
  265.     struct httpinfo *hip = cip->hip;
  267.     
  268.     if (debug > 1)
  269. fprintf(stderr, "      Sent UNAUTHORIZED messagen");
  271.     result = 401;
  273.     if (hip->mip != NULL)
  274.     {
  275. http_sendheaders(fd, cip, result, NULL);
  276. fd_printf(fd, "WWW-Authenticate: Basic realm="%s"n", realm);
  277. fd_putc('n', fd);
  278.     }
  280.     if(strcasecmp(hip->method, "HEAD") == 0)
  281.        return result;
  283.     html_sysheader(fd, "H2", "Unauthorized");
  285.     fd_printf(fd, "Please send authorization codes for realm "%s".n",
  286.       realm);
  288.     html_sysfooter(fd);
  289.     
  290.     return result;
  291. }
  295. int http_forbidden(struct connectioninfo *cip)
  296. {
  297.     int result;
  298.     int fd = cip->fd;
  299.     struct httpinfo *hip = cip->hip;
  301.     
  302.     if (debug > 1)
  303. fprintf(stderr, "      Sent FORBIDDEN messagen");
  305.     result = 403;
  307.     if (hip->mip != NULL)
  308.     {
  309. http_sendheaders(fd, cip, result, NULL);
  310. fd_putc('n', fd);
  311.     }
  312.     
  313.     if(strcasecmp(hip->method, "HEAD") == 0)
  314.        return result;
  316.     html_sysheader(fd, "H2", "Access Denied");
  318.     fd_printf(fd, "Your request to ");
  319.     if (hip->orig_url == NULL)
  320. fd_printf(fd, "[null]");
  321.     else
  322. html_href(fd, hip->orig_url, hip->orig_url);
  323.     
  324.     fd_printf(fd, " was denied.n");
  326.     html_sysfooter(fd);
  327.     
  328.     return result;
  329. }
  332. int http_authenticate(struct connectioninfo *cip,
  333.       const char *path,
  334.       const char *realm,
  335.       char *request)
  336. {
  337.     if (!access_auth(cip->hip, path))
  338. return http_unauthorized(cip, realm);
  340.     return 0;
  341. }
  344. int http_access(struct connectioninfo *cip,
  345. const char *auth_path,
  346. char *request)
  347. {
  348.     if (!access_check(auth_path, cip))
  349. return error_access(cip);
  351.     return 0;
  352. }
  355. /*
  356.  *  Extract the request (the part after the first '?') in URL and add
  357.  *  it to the beginning of *REQUESTP.
  358.  */
  359. void
  360. http_extract_request(char *url, char **requestp)
  361. {
  362.     char *cp;
  364.     if (url == NULL)
  365. return;
  366.     
  367.     cp = strchr(url, '?');
  368.     if (cp != NULL)
  369.     {
  370. *cp++ = '';
  371. if (requestp == NULL)
  372.     return;
  374. if (!*requestp)
  375. {
  376.     *requestp = s_strdup(cp);
  377. }
  378. else
  379. {
  380.     char *oldrequest = *requestp;
  381.     size_t oldlen = strlen(oldrequest);
  382.     size_t addlen = strlen(cp);
  384.     *requestp = s_malloc(oldlen + 1 + addlen + 1);
  385.     memcpy(*requestp, oldrequest, oldlen);
  386.     *(*requestp + oldlen) = '?';
  387.     memcpy(*requestp + oldlen + 1, cp, addlen);
  388.     *(*requestp + oldlen + 1 + addlen) = '';
  389.     s_free(oldrequest);
  390. }
  391.     }
  392. }
  396. int http_get_request(struct connectioninfo *cip,
  397.      int *keepalive)
  398. {
  399.     char buf[2048], *lastcp, *url, *req, *rawurl;
  400.     struct httpinfo *hip = NULL;
  401.     int result = -1;
  402.     int headerbytes;
  403.     ucentry_t *ucp;
  404.     urlinfo_t *uip;
  405.     char *realm;
  406.     int len;
  407.     char *mvsxy,*svpath;
  408.     char *slash = "/";
  409.     
  412.     ucp = NULL;
  413.     uip = NULL;
  414.     
  415.     if (debug > 1)
  416. fprintf(stderr, "http_get_request(), fd=%dn", cip->fd);
  417.     
  418.     if ((req = fd_gets(NULL, maxurlsize, cip->fd)) == NULL)
  419.     {
  420. if (debug > 2)
  421.     fprintf(stderr, "t->Returning failed (fd=%d)n", cip->fd);
  422. return -1;
  423.     }
  424.     
  425.     hip = s_malloc(sizeof(struct httpinfo));
  426.     headerbytes=strlen(req);
  427.    
  428.     hip->svsname = NULL;
  429.     hip->method = strtok_r(req, " tnr", &lastcp);
  430.     if (hip->method == NULL)
  431.     {
  432. s_free(hip);
  433. return -1;
  434.     }
  435.     
  436.     url = strtok_r(NULL, " tnr", &lastcp);
  437.     if (url)
  438. hip->version = s_strdup(strtok_r(NULL, " tnr", &lastcp));
  440.     if (url == NULL)
  441.     {
  442. s_free(hip->method);
  443. s_free(hip);
  444. return -1;
  445.     }
  447. /* Clear setup.... */
  448.     hip->prelen=0;
  450. /* Added for Multi-Virtual-Server RK */
  451. /* Some how ugly, might be a nicer way to code this, but it works ! */
  452. /* Maybe one should create differnt global accept code, depending on the
  453. ** mode, we are running. This may look nicer, but more code to maintain. 
  454. ** 23.11.97 rk@netuse.de
  455. */
  457.     if ( rkmultimode != 0 ) /* We are in MULTIMODE */
  458. {
  459.     if ( debug >6 )
  460. fprintf(stderr,"MVS-RK: Adding prefixn");
  461.     len = strlen(url)+10;
  462.     mvsxy=s_malloc(len);
  463.     if ( url[0]=='/' )
  464. s_sprintf(mvsxy, len, "/%08lx%s", cip->server->sin.sin_addr.s_addr, url);
  465.     else
  466. s_sprintf(mvsxy, len, "/%08lx/%s", cip->server->sin.sin_addr.s_addr, url);
  467.     
  468.     /* lenght of prefix is 8 + 1 (+1) (still fix !) */
  469.             hip->prelen=9;
  471.     if ( debug >6 )
  472. fprintf(stderr,"MVS-RK: calling freen");
  473.     
  474.     url[strlen(mvsxy)]=0x00; /* wg.logfile */
  475.     s_strcpy(url,strlen(url)+11, mvsxy);
  476.     
  477.     s_free(mvsxy);
  478.     if ( debug >6 )
  479. fprintf(stderr,"MVS-RK: prefix donen");
  480. }
  481.     if ( softvirtserver!=0 && hip->version != NULL )
  482.     { /* working here.......... 1.1 */
  483.       if ( hip->prelen != 0 ) len=hip->prelen+1;
  484.       else len=0;
  485.       if ( debug >6 ) fprintf(stderr,"SVS-http: %s (%d)n",url,len);
  486.       if (    strncasecmp(url+len,"http://",7)== 0 
  487. /* Disabled, since common broser send a HTTP/1.0 and SVS-Information :-( */
  488.         /*   && strcasecmp(hip->version,"HTTP/1.1")==0  */
  489.    && strlen(url+len) > 7 )
  490.       { /* we got CMD http://host/path HTTP/1.x */
  491. rawurl=url;
  492. url=url+len+7;
  493. svpath=strchr(url,'/'); /* add : */
  495.         if ( svpath != NULL ) len=svpath-url;
  496. else                { len=strlen(url); svpath=slash; }
  498.         hip->svsname=s_strndup(url,len);
  499. str_to_lower(hip->svsname);
  501. /* check for :port and DROP !! */
  502. mvsxy=strchr(hip->svsname,':');
  503. if ( mvsxy != NULL ) *mvsxy=0x00;
  506. if ( debug >6 ) fprintf(stderr,"SVS-Host: %s (%d) n",hip->svsname,len);
  507. len = strlen(rawurl);
  508. mvsxy=s_malloc(len);
  509.         if ( rkmultimode )
  510.            s_sprintf(mvsxy, len, "%.9s/%s%s",rawurl,hip->svsname,svpath);
  511.         else
  512.             s_sprintf(mvsxy, len, "/%s%s",hip->svsname,svpath);
  513.         
  514. hip->prelen=hip->prelen+strlen(hip->svsname)+1;
  515.         if (debug > 6 ) fprintf(stderr, "SVS1: NEWURL: %s (%d)n",mvsxy,hip->prelen);
  516. hip->svstype=SVSINGET;
  517.         s_strcpy(url,strlen(mvsxy)+1, mvsxy);
  518.  
  519.         url[strlen(mvsxy)]=0x00; /* wg.logfile */
  520.         s_free(mvsxy);
  522.       } /* we have softvirtserver set, but no information about that was sent.... */
  523.       else
  524.       if ( debug >6 ) fprintf(stderr,"SVS-Host: -not-1.1-n");
  526.     }
  527.     /* END RK */
  528.     
  529.     if (debug > 4)
  530. fprintf(stderr, "Method = %s, URL = %s PL = %dn",
  531. hip->method, url ? url : "<null>", hip->prelen);
  532.     
  533.     cip->hip = hip;
  534. #if 1
  535.     hip->orig_url = s_strdup(url);
  536.     hip->orig_request = NULL;
  537.     url_unquote(url, 0);
  538. #else
  539.     http_extract_request(url, &hip->request);
  540.     hip->orig_url = s_strdup(url);
  541.     hip->orig_request = s_strdup(hip->request);
  542.     url_unquote(url, 0);
  544.     if (debug > 2)
  545. fprintf(stderr, "url=%snorig_url=%snreq=%snorig_req=%sn",
  546. url ? url : "<null>",
  547. hip->orig_url ? hip->orig_url : "<null>",
  548. hip->request ? hip->request : "<null>",
  549. hip->orig_request ? hip->orig_request : "<null>");
  550. #endif
  551.     
  552.     if (hip->version != NULL)
  553.     {
  554. hip->mip = mime_getheaders(cip->fd);
  555. if (hip->mip == NULL)
  556. {
  557.     error_bad_request(cip, "Invalid MIME headers");
  558.     goto End;
  559. }
  560. hip->mip->headerbytes=hip->mip->headerbytes+headerbytes;
  562. if (keepalive && hip->mip &&
  563.     (hip->mip->connection_flags & MCF_KEEPALIVE))
  564.     *keepalive = 1;
  566. /* Get the client-supplied authentication information */
  567. hip->aip = auth_get(hip);
  568.     }
  570. /* softvirtserver added here rk */
  571.     if ( softvirtserver!=0 && hip->svsname == NULL ) 
  572.     {
  573.    
  574.        hip->svsname=s_strdup(mime_getheader(hip->mip,"HOST",1));
  575.        if ( hip->svsname == NULL )
  576.          {
  577.    if ( rkmultimode )
  578.    {
  579.      hip->svsname=s_strdup(dns_lookup_servername(cip->server));
  580.      if ( hip->svsname == NULL ) 
  581. hip->svsname=s_strdup(server_host);
  582.    }
  583.    else
  584.      hip->svsname=s_strdup(server_host);
  585.  }
  587.   str_to_lower(hip->svsname);
  589.           /* check for :port and DROP !! */
  590.           mvsxy=strchr(hip->svsname,':');
  591.           if ( mvsxy != NULL ) *mvsxy=0x00;
  593.           if (debug > 6 ) fprintf(stderr, "SVS: Found: %sn",hip->svsname);
  595.           len = strlen(url)+strlen(hip->svsname)+2;
  596.   mvsxy=s_malloc(len);
  598.           if ( rkmultimode )
  599.     s_sprintf(mvsxy, len, "%.9s/%s/%s",url,hip->svsname,url+10);
  600.   else
  601.             if ( url[0]=='/' )
  602.       s_sprintf(mvsxy, len, "/%s%s",hip->svsname,url);
  603.     else
  604.       s_sprintf(mvsxy, len, "/%s/%s",hip->svsname,url);
  607.   hip->prelen=hip->prelen+strlen(hip->svsname)+1;
  608. /*
  609. ** if (debug > 6 ) fprintf(stderr, "SVS2: NEWURL: %s (%d)n",mvsxy,hip->prelen);
  610. */
  611.           hip->svstype=SVSMIMEHOST;
  612.           s_strcpy(url,strlen(mvsxy)+1, mvsxy);
  614.           url[strlen(mvsxy)]=0x00; /* wg.logfile */
  615.           s_free(mvsxy);
  617.       
  618.     } /* end of softvirtserver! */
  620.     if (strcasecmp(hip->method, "PING") == 0)
  621.     {
  622. if (hip->mip)
  623. {
  624.     http_sendheaders(cip->fd, cip, 200, NULL);
  625.     result = 200;
  626.     fd_putc('n', cip->fd);
  627. }
  628. fd_puts("PONGn", cip->fd);
  629. goto End;
  630.     }
  631.     
  632.     if (hip->mip && (hip->mip->pragma_flags & MPF_NOCACHE))
  633. ucp = urlcache_lookup(url, UCF_ALL+UCF_RELOAD);
  634.     else
  635. ucp = urlcache_lookup(url, UCF_ALL);
  636.       
  637.     if (ucp == NULL)
  638. goto End;
  640. /*  XXXX url is now split into url and request part XXXX */
  641.     
  642.     uip = ucp->uip;
  643.     if (uip == NULL)
  644.     {
  645. urlcache_release(ucp);
  646. goto End;
  647.     }
  649.     hip->url = s_strdup(uip->rewrite.url);
  650.     
  651.     if (uip->rewrite.request)
  652.     {
  653. if (hip->request)
  654.     s_free(hip->request);
  655. hip->request = s_strdup(uip->rewrite.request);
  656.     }
  657.     
  658.     if (uip->redirect.url)
  659.     {
  660. result = http_redirect(cip,
  661.        uip->redirect.url,
  662.        uip->redirect.request,
  663.           hip->request,
  664.        302);
  665. goto End;
  666.     }
  667.     
  668.     if (uip->predirect.url)
  669.     {
  670. result = http_redirect(cip,
  671.        uip->predirect.url,
  672.        uip->predirect.request,
  673.           hip->request,
  674.        301);
  675. goto End;
  676.     }
  677.     
  678.     if (uip->access.path)
  679.     {
  680. result = http_access(cip, uip->access.path, hip->request);
  681. if (result != 0)
  682.     goto End;
  683.     }
  684.     
  686.     /* ADDED by RK */
  687.     if (debug > 4)
  688. fprintf(stderr,"Check write ACCESSn");
  689.     
  690.     if (write_needs_auth && 
  691. (strcasecmp(hip->method, "PUT")==0 ||
  692.  strcasecmp(hip->method, "DELETE")==0))
  693.     {
  694. if (debug > 4)
  695.     fprintf(stderr,"We have a write CMD...n");
  697.       if (write_getauthenticate(url, buf, sizeof(buf))) 
  698.       {
  699.           uip->auth.source=s_strdup(buf);
  700.           realm = uip->auth.source;
  701.           if (realm)
  702.           {   
  703.               while (*realm && !s_isspace(*realm))
  704.   ++realm;
  705.               if (s_isspace(*realm))
  706.   *realm++ = '';
  707.               while (*realm && s_isspace(*realm))
  708.   ++realm;
  709.           }
  710.           uip->auth.realm = realm;
  711.           uip->flags |= UCF_AUTH;
  712.   if ( debug > 4 )
  713.       fprintf(stderr,"Using auth for...%sn",uip->auth.source);
  714.       }
  715.       else
  716.       {
  717.           uip->auth.source=NULL;
  718.   result = -403;
  719.   goto End;
  720.       }
  721.     } /* end of write_needs_auth */
  723.     if (uip->auth.source)
  724.     {
  725. result = http_authenticate(cip,
  726.    uip->auth.source,
  727.    uip->auth.realm,
  728.    hip->request);
  729. if (result != 0)
  730.     goto End;
  731.     }
  733.     if (uip->handler)
  734. result = phttpd_call(uip->handler, cip);
  736.     if (debug > 3)
  737. fprintf(stderr, "MAIN-RETURN: Result=%dn", result);
  738.     
  739.   End:
  740.     if (result < 0)
  741. switch (result)
  742. {
  743.   case -1:
  744.     result = error_not_found(cip);
  745.     break;
  747.   case -403:
  748.     result = error_access(cip);
  749.     break;
  750.     
  751.   case -405:
  752.     result = error_method_denied(cip);
  753.     break;
  754.     
  755.   default:
  756.     result = error_bad_request(cip, hip->method);
  757.     syslog(LOG_NOTICE, "bad HTTP request (#%d) method: %s",
  758.    cip->request_no,
  759.    hip->method);
  760. }
  762.     if (ucp)
  763. urlcache_release(ucp);
  764.     
  765.     if (hip->length == 0)
  766. *keepalive = 0;
  767.     
  768.     if (debug > 1)
  769. fprintf(stderr, "http_get_request(), fd=%d, returning %dn",
  770. cip->fd, result);
  771.     
  772.     return result;
  773. }
  776. void http_freeinfo(struct httpinfo *hip)
  777. {
  778.     if (hip == NULL)
  779. return;
  780.     
  781.     s_free(hip->method);
  782.     s_free(hip->url);
  783.     s_free(hip->request);
  784.     s_free(hip->orig_url);
  785.     s_free(hip->orig_request);
  786.     s_free(hip->version);
  787.     s_free(hip->svsname);
  788.     
  789.     if (hip->mip) mime_freeheaders(hip->mip);
  790.     auth_free(hip->aip);
  791.     
  792.     s_free(hip);
  793. }
  795. int http_error(struct connectioninfo *cip,
  796.        int code,
  797.        const char *format,
  798.        ...)
  799. {
  800.     va_list ap;
  801.     char *type, buf[256];
  802.     struct httpinfo *hip = cip->hip;
  803.     
  805.     if (hip->mip != NULL)
  806.     {
  807. type = http_sendheaders(cip->fd, cip, code, NULL);
  808. fd_puts("Content-Type: text/htmln", cip->fd);
  809. fd_putc('n', cip->fd);
  810.     }
  811.     else
  812.     {
  813.         int blen;
  814.       
  815.         blen = s_strcpy(buf, sizeof(buf), "Error Code #");
  816. s_sprintf(buf+blen, sizeof(buf)-blen, "%d", code);
  817. type = buf;
  818.     }
  820.     if (strcasecmp(hip->method, "HEAD") == 0)
  821. return code;
  822.     
  823.     va_start(ap, format);
  824.     
  825.     html_error(cip->fd, type, format, ap);
  826.     
  827.     va_end(ap);
  828.     hip->length = fd_written(cip->fd);
  829.     
  830.     return code;
  831. }
  833. void http_sendlang(int fd, const char *url)
  834. {
  835.     int i;
  836.     char **pair;
  838.     if(content_language_table == NULL)
  839.         return;
  841.     for(i = 0; i < content_language_table->length; ++i)
  842.     {
  843.         pair = content_language_table->value[i];
  844. if(strmatch(url, pair[0]))
  845. {
  846.     fd_puts("Content-Language: ", fd);
  847.     fd_puts(pair[1], fd);
  848.     fd_putc('n', fd);
  849.     break;
  850. }
  851.     }
  852. }
  855. /* Send a redirect pointer */
  856. int http_redirect(struct connectioninfo *cip,
  857.   const char *url,
  858.   const char *request,
  859.   const char *orig_req,
  860.   int code)
  861. {
  862.     char buf1[2048], buf2[2048], buf3[2048];
  863.     int result, len;
  864.     int fd = cip->fd;
  865.     struct httpinfo *hip = cip->hip;
  868.     url = url_quote(url, buf1, sizeof(buf1), "?", 0);
  869.     if (url == NULL)
  870. return -1;
  871.     
  872.     if (request)
  873.     {
  874. request = url_quote(request, buf2, sizeof(buf2), """, 1);
  875. if (request == NULL)
  876.     return -1;
  877.     }
  879.     if (orig_req)
  880.     {
  881. orig_req = url_quote(orig_req, buf3, sizeof(buf3), """, 1);
  882. if (orig_req == NULL)
  883.     return -1;
  884.     }
  885.     
  886.     if (debug > 1)
  887. fprintf(stderr, "      Sent URL REDIRECT (%s -> %s)n",
  888. hip->url, url);
  890.     result = code;
  891.     
  892.     if (hip->mip != NULL)
  893.     {
  894. http_sendheaders(fd, cip, result, NULL);
  896. fd_printf(fd, "Location: %s%s%s%sn",
  897.   url,
  898.   (orig_req || request) ? "?" : "",
  899.   orig_req ? orig_req : "",
  900.   request ? request : "");
  901.   
  903. http_sendlastmodified(fd, cip->cn_time);
  904. fd_puts("Content-Type: text/htmlnn", fd);
  905.     }
  906.     
  907.     if (strcasecmp(hip->method, "HEAD") == 0)
  908. return result;
  909.     
  910.     len = fd_written(fd);
  912.     html_sysheader(fd, "H2", "Document moved");
  913.     
  914.     fd_puts("The document has moved to this URL:<P>n", fd);
  915.     fd_puts("<UL>n", fd);
  916.     
  917.     fd_printf(fd, "<B><A HREF="%s%s%s%s">%s%s%s%s</A></B>.n",
  918.       url,
  919.       (orig_req || request) ? "?" : "",
  920.       orig_req ? orig_req : "",
  921.       request ? request : "",
  922.       url,
  923.       (orig_req || request) ? "?" : "",
  924.       orig_req ? orig_req : "",
  925.       request ? request : "");
  926.     
  927.     fd_puts("</UL>n", fd);
  928.     
  929.     html_sysfooter(fd);
  931.     if (logheadervolume)
  932. hip->length = fd_written(fd);
  933.     else
  934. hip->length = fd_written(fd) - len; 
  936.     return result;
  937. }
  940. /* Send a 'Not Modified' message */
  941. int http_not_modified(struct connectioninfo *cip)
  942. {
  943.     int result;
  944.     int fd = cip->fd;
  945.     struct httpinfo *hip = cip->hip;
  947.     
  948.     if (debug > 1)
  949. fprintf(stderr, "      Sent NOT MODIFIED messagen");
  951.     result = 304;
  953.     if (hip->mip != NULL)
  954.     {
  955. http_sendheaders(fd, cip, result, NULL);
  956. fd_putc('n', fd);
  957.     }
  958.     hip->length = fd_written(fd);
  959.     return result;
  960. }
  963. /* Send a 'Precondition Failed' message */
  964. int http_precondition_failed(struct connectioninfo *cip)
  965. {
  966.     int result;
  967.     int fd = cip->fd;
  968.     struct httpinfo *hip = cip->hip;
  970.     
  971.     if (debug > 1)
  972. fprintf(stderr, "      Sent PRECONDITION FAILED messagen");
  974.     result = 412;
  976.     if (hip->mip != NULL)
  977.     {
  978. http_sendheaders(fd, cip, result, NULL);
  979. fd_putc('n', fd);
  980.     }
  981.     
  982.     if(strcasecmp(hip->method, "HEAD") == 0)
  983.        return result;
  985.     html_sysheader(fd, "H2", "Precondition Failed");
  987.     fd_printf(fd, "The entity which lives at ");
  988.     if (hip->orig_url == NULL)
  989. fd_printf(fd, "[null]");
  990.     else
  991. html_href(fd, hip->orig_url, hip->orig_url);
  992.     
  993.     fd_printf(fd, " was changed.n");
  995.     html_sysfooter(fd);
  996.     hip->length = fd_written(fd);
  997.     
  998.     return result;
  999. }
  1002. static const char *const weekday[] =
  1003. {
  1004.     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
  1005. };
  1007. static const char *const month[] =
  1008. {
  1009.     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  1010.     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  1011. };
  1014. char *http_time_r(const time_t *btp, char *buf, int bufsize)
  1015. {
  1016.     struct tm tpb;
  1018.     
  1019.     if (bufsize < 31)
  1020. return NULL;
  1021.     
  1022.     if (gmtime_r(btp, &tpb) == NULL)
  1023. return NULL;
  1025.     s_sprintf(buf, bufsize, "%s, %02d %s %d %02d:%02d:%02d GMTn",
  1026.     weekday[tpb.tm_wday],
  1027.     tpb.tm_mday,
  1028.     month[tpb.tm_mon],
  1029.     tpb.tm_year + 1900,
  1030.     tpb.tm_hour,
  1031.     tpb.tm_min,
  1032.     tpb.tm_sec);
  1034.     return buf;
  1035. }