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

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

Web服务器

开发平台：

Unix_Linux

http.c：源码内容
  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, *realurl;
  414.     char ipnrbuf[18];
  415.     struct httpinfo *hip = NULL;
  416.     int result = -1;
  417.     int headerbytes;
  418.     ucentry_t *ucp;
  419.     urlinfo_t *uip;
  420.     char *realm;
  421.     int len;
  422.     char *p1,*p2,*svpath=NULL, *svport=NULL;
  423.     char *xurl=NULL;
  424.     
  425.     ucp = NULL;
  426.     uip = NULL;
  427.     
  428.     if (debug > 1)
  429. fprintf(stderr, "http_get_request(), fd=%dn", cip->fd);
  430.     
  431.     if ((req = fd_gets(NULL, maxurlsize, cip->fd)) == NULL)
  432.     {
  433. if (debug > 2)
  434.     fprintf(stderr, "t->Returning failed (fd=%d)n", cip->fd);
  435. return -1;
  436.     }
  437.     
  438.     hip = s_malloc(sizeof(struct httpinfo));
  439.     headerbytes=strlen(req);
  440.    
  441.     hip->svsname = NULL;
  442.     hip->prefix = NULL;
  443.     hip->method = strtok_r(req, " tnr", &lastcp);
  444.     if (hip->method == NULL)
  445.     {
  446. http_freeinfo(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.         http_freeinfo(hip);
  457. return -1;
  458.     }
  460. /* Get the mimeheader first !! */
  461.     if (hip->version != NULL)
  462.     {
  463. hip->mip = mime_getheaders(cip->fd);
  464. if (hip->mip == NULL)
  465. {
  466.     error_bad_request(cip, "Invalid MIME headers");
  467.     goto End;
  468. }
  469. hip->mip->headerbytes=hip->mip->headerbytes+headerbytes;
  471. if (  keepalive && hip->mip &&
  472.       (hip->mip->connection_flags & MCF_KEEPALIVE)  )
  473.     *keepalive = 1;
  475. /* Get the client-supplied authentication information */
  476. hip->aip = auth_get(hip);
  477.     }
  479. /* Clear setup.... */
  480.     hip->prelen=0;
  482. /* Added for Multi-Virtual-Server RK */
  483. /* Some how ugly, might be a nicer way to code this, but it works ! */
  484. /* Maybe one should create differnt global accept code, depending on the
  485. ** mode, we are running. This may look nicer, but more code to maintain. 
  486. ** 23.11.97 rk@netuse.de
  487. */
  489. /* We do allways store the ip number of the incoming interface ! */
  490. if ( mode_dotted == 1 )
  491. s_sprintf(ipnrbuf, 18, "/%s", inet_ntoa(*(struct in_addr *) &(cip->server->sin.sin_addr.s_addr)));
  492. else
  493. s_sprintf(ipnrbuf, 18, "/%08lx", cip->server->sin.sin_addr.s_addr );
  494. hip->vs_ipnr=s_strdup(ipnrbuf);
  496. /* Next we will check, if we get the incoming hostname (like to be used for svs !) */
  497. p1=mime_getheader(hip->mip,"HOST",1);
  498. if ( p1 )
  499. {
  500. p2=strchr(p1,':');
  501. if ( p2 )
  502. hip->svsname=s_strndup(p1,p2-p1);
  503. else
  504. hip->svsname=s_strdup(p1);
  506. }
  508. /* In case, we do NOT get a mime-header-host, we will try to analyze the incoming url for a host[:port] */
  509. if ( hip->svsname == NULL && hip->version != NULL )
  510. {
  511.          if ( strncasecmp(url,"http://",7)== 0 && strlen(url) > 7 )
  512. { /* we got request like ... http://host/path HTTP/1.x */
  513. realurl=url+7; /* now we are the hostposition */
  514. svpath=strchr(realurl,'/'); /* Now find the / after host or host:port
  515.    or we have a NULL, if no host */
  516. svport=strchr(realurl,':'); /* Do we have a port ? */
  517. if ( svport == NULL ) svport=svpath;
  518. if ( svport < svpath ) svpath=svport;
  520. if ( svpath != NULL && realurl != svpath )
  521. {
  522. hip->svstype=SVSINGET;
  523. hip->svsname=s_strndup(realurl,svpath-realurl); /* Store the hostname without the optional port */
  524. }
  525. }
  526. }
  528. if ( svpath == NULL ) svpath=url;
  530. /* In case we cannot retrieve any value, set interface or name */
  531. /* TODO: If not set but needed, we should use some global default: vs_master_name       */
  533.    if ( hip->svsname == NULL )
  534.    {
  535. if ( strcmp(server_host ,"*") == 0 )
  536. hip->svsname=s_strdup(dns_lookup_servername(cip->server));
  537. else
  538. hip->svsname=s_strdup(server_host);
  539. if ( debug > 6 )
  540. fprintf(stderr,"Forced SVS default(hip->svsname) to %sn",hip->svsname);
  541.    }
  543. if ( debug > 6 )
  544. fprintf(stderr,"VirtServer GOT: H: %s SV-Host: %sn",hip->vs_ipnr,(hip->svsname!=NULL)?hip->svsname:"<NULL>");
  546. /* Now we have set: "/aaxxyyzz" or "/a.b.c.d" in ipnrbuf .
  547.    And hip->svsname is set.
  548.    Now we need to put those parts together, depending on the values of rkmultimode and svs
  549.    Here we also take care of sub_server_home, which is only honored in any virtual
  550.    hosting mode. This make it easier to put ftp-chroot together with docroot.
  551.    subserverhome MUST be like /path or "" .
  552.  */
  553. xurl=NULL;
  554. hip->prelen=0;
  556. str_to_lower(hip->svsname);
  558. /* We need to build xurl !  */
  559. /* Format is [rkmultimode]/[softvirtserver]/path */
  560. if ( debug > 8 )
  561. {
  562. fprintf(stderr,"Values:t ipnrbuf=%sn",ipnrbuf);
  563. fprintf(stderr,"       t svsname=%sn",hip->svsname);
  564. fprintf(stderr,"       t sub_s_h=%sn",sub_server_home);
  565. fprintf(stderr,"       t svpath=%sn",svpath?svpath:"<NULL>");
  566. fprintf(stderr,"       t >svpath=%sn",svpath?notslash(svpath):"<NULL>");
  567. }
  569. if ( rkmultimode && softvirtserver )
  570. {
  571. hip->prelen=1+strlen(ipnrbuf)+strlen(hip->svsname)+strlen(sub_server_home);
  572. len=1+hip->prelen+strlen(svpath);
  573. xurl=s_malloc(len);
  574. s_sprintf(xurl, len, "%s/%s%s/%s",ipnrbuf,hip->svsname,sub_server_home,notslash(svpath));
  575. }
  576. if ( rkmultimode && ! softvirtserver )
  577. {
  578. hip->prelen=strlen(ipnrbuf)+strlen(sub_server_home);
  579. len=1+hip->prelen+strlen(svpath);
  580. xurl=s_malloc(len);
  581. s_sprintf(xurl, len, "%s%s/%s",ipnrbuf,sub_server_home,notslash(svpath));
  582. }
  583. if ( ! rkmultimode && softvirtserver )
  584. {
  585. hip->prelen=1+strlen(hip->svsname)+strlen(sub_server_home);
  586. len=1+hip->prelen+strlen(svpath);
  587. xurl=s_malloc(len);
  588. s_sprintf(xurl, len, "/%s%s/%s",hip->svsname,sub_server_home,notslash(svpath));
  589. }
  590. if ( ! rkmultimode && ! softvirtserver )
  591. {
  592. hip->prelen=strlen(sub_server_home);
  593. len=1+hip->prelen+strlen(svpath);
  594. xurl=s_malloc(len);
  595. s_sprintf(xurl, len, "%s/%s",sub_server_home,notslash(svpath));
  596. }
  598. if ( xurl[0] != '/' )
  599. {
  600. fprintf(stderr,"SERVER INTERNAL ERROR ON xurl BUILD (%s)[%s] !n",url ? url : "<null>",xurl);
  601. }
  602.     
  603.     if (debug > 2 )
  604. fprintf(stderr, "Virtualserver: NEWURL: %s (%d)n",(xurl!=NULL)?xurl:"-NONE-",hip->prelen);
  606.     /* if we have some virtual hosting mode, save the prefix to the requests hip-> struct. */
  607.     if ( xurl && hip->prelen > 0 ) hip->prefix=s_strndup(xurl,hip->prelen);
  609.     if (debug > 4)
  610. fprintf(stderr, "Method = %s, URL = %s PL = %dn",
  611. hip->method, url ? url : "<null>", hip->prelen);
  613. /* If we had any kind of virtual hosting, xurl now has the expanded URL-Path with host etc
  614.    stripped off. Otherwise xurl==NULL and we will copy url and continue to work with xurl,
  615.    which gives us a simple cleanup...
  616.  */
  617.     if ( xurl == NULL && url != NULL ) xurl=s_strdup(url);
  618.    
  619. /* we have a memleak somewhere........ maybe here */
  620.     if ( cip->hip )
  621. {  http_freeinfo(cip->hip); 
  622.    fprintf(stderr,"memleak found: pos 1n");
  623. }
  625.     cip->hip = hip;
  627. /* Do not use that new code, seems to be buggy !!!! rk@netuse.de */
  628. #if 0
  629.     hip->orig_url = s_strdup(url);
  630.     hip->orig_request = NULL;
  631.     url_unquote(url, 0);
  632. #else
  633.     http_extract_request(xurl, &hip->request);
  634.     hip->orig_url = s_strdup(xurl);
  635.     hip->orig_request = s_strdup(hip->request);
  636.     url_unquote(xurl, 0);
  637. /* we need to cleanup the url to strip multiple / to a single / 
  638.    we also drop /./ to / and try to handle /../ to move one up, like a unix path.
  639.  */
  640.     url_cleanup(xurl);
  642.     if (debug > 1)
  643. fprintf(stderr, "(x)url=%snorig_url=%snreq=%snorig_req=%sn",
  644. xurl ? xurl : "<null>",
  645. hip->orig_url ? hip->orig_url : "<null>",
  646. hip->request ? hip->request : "<null>",
  647. hip->orig_request ? hip->orig_request : "<null>");
  648. #endif
  649.     
  650.     if (strcasecmp(hip->method, "PING") == 0)
  651.     {
  652. if (hip->mip)
  653. {
  654.     http_sendheaders(cip->fd, cip, 200, NULL);
  655.     result = 200;
  656.     fd_putc('n', cip->fd);
  657. }
  658. fd_puts("PONGn", cip->fd);
  659. goto End;
  660.     }
  661.     
  662.     if (hip->mip && (hip->mip->pragma_flags & MPF_NOCACHE))
  663. ucp = urlcache_lookup(xurl, UCF_ALL+UCF_RELOAD);
  664.     else
  665. ucp = urlcache_lookup(xurl, UCF_ALL);
  666.       
  667.     if (ucp == NULL)
  668. goto End;
  670. /*  XXXX URL (xurl) is now split into url and request part XXXX */
  671.     
  672.     uip = ucp->uip;
  673.     if (uip == NULL)
  674.     {
  675. urlcache_release(ucp);
  676. goto End;
  677.     }
  679.     hip->url = s_strdup(uip->rewrite.url);
  680.     
  681.     if (uip->rewrite.request)
  682.     {
  683. if (hip->request)
  684.     s_free(hip->request);
  685. hip->request = s_strdup(uip->rewrite.request);
  686.     }
  687.     
  688.     if (uip->redirect.url)
  689.     {
  690. result = http_redirect(cip,
  691.        uip->redirect.url,
  692.        uip->redirect.request,
  693.           hip->request,
  694.        302);
  695. goto End;
  696.     }
  697.     
  698.     if (uip->predirect.url)
  699.     {
  700. result = http_redirect(cip,
  701.        uip->predirect.url,
  702.        uip->predirect.request,
  703.           hip->request,
  704.        301);
  705. goto End;
  706.     }
  707.     
  708.     if (uip->access.path)
  709.     {
  710. result = http_access(cip, uip, hip->request);
  711. if (result != 0)
  712.     goto End;
  713.     }
  714.     
  716.     /* ADDED by RK */
  718.     if (debug > 4)
  719. fprintf(stderr,"Check write ACCESSn");
  720.     
  721.     if (write_needs_auth && 
  722. (strcasecmp(hip->method, "PUT")==0 ||
  723.  strcasecmp(hip->method, "DELETE")==0))
  724.     {
  725. if (debug > 4)
  726.     fprintf(stderr,"We have a write CMD...n");
  728.       if (write_getauthenticate(xurl, buf, sizeof(buf))) 
  729.       {
  730.           uip->auth.source=s_strdup(buf);
  731.           realm = uip->auth.source;
  732.           if (realm)
  733.           {   
  734.               while (*realm && !s_isspace(*realm))
  735.   ++realm;
  736.               if (s_isspace(*realm))
  737.   *realm++ = '';
  738.               while (*realm && s_isspace(*realm))
  739.   ++realm;
  740.           }
  741.           uip->auth.realm = realm;
  742.           uip->flags |= UCF_AUTH;
  743.   if ( debug > 4 )
  744.       fprintf(stderr,"Using auth for...%sn",uip->auth.source);
  745.       }
  746.       else
  747.       {
  748.           uip->auth.source=NULL;
  749.   result = -403;
  750.   goto End;
  751.       }
  752.     } /* end of write_needs_auth */
  754.     if (uip->auth.source)
  755.     {
  756. result = http_authenticate(cip,
  757.    uip->auth.source,
  758.    uip->auth.realm,
  759.    hip->request);
  760. if (result != 0)
  761.     goto End;
  762.     }
  764.     if (uip->handler)
  765. result = phttpd_call(uip->handler, cip);
  767.     if (debug > 3)
  768. fprintf(stderr, "MAIN-RETURN: Result=%dn", result);
  770.   End:
  772.     if ( xurl ) s_free(xurl); /* clean up */
  774.     if (result < 0)
  775. switch (result)
  776. {
  777.   case -1:
  778.     result = error_not_found(cip);
  779.     break;
  781.   case -403:
  782.     result = error_access(cip);
  783.     break;
  784.     
  785.   case -405:
  786.     result = error_method_denied(cip);
  787.     break;
  788.     
  789.   default:
  790.     result = error_bad_request(cip, hip->method);
  791.     syslog(LOG_NOTICE, "bad HTTP request (#%d) method: %s",
  792.    cip->request_no,
  793.    hip->method);
  794. }
  796.     if (ucp)
  797. urlcache_release(ucp);
  798.     
  799.     if (hip->length == 0)
  800. *keepalive = 0;
  801.     
  802.     if (debug > 1)
  803. fprintf(stderr, "http_get_request(), fd=%d, returning %dn",
  804. cip->fd, result);
  805.     
  806.     return result;
  807. }
  810. void http_freeinfo(struct httpinfo *hip)
  811. {
  812.     if (hip == NULL)
  813. return;
  814.     
  815.     s_free(hip->method);
  816.     s_free(hip->url);
  817.     s_free(hip->request);
  818.     s_free(hip->orig_url);
  819.     s_free(hip->orig_request);
  820.     s_free(hip->version);
  821.     s_free(hip->prefix);
  822.     s_free(hip->svsname);
  823.     s_free(hip->vs_ipnr);
  824.     
  825.     if (hip->mip) mime_freeheaders(hip->mip);
  826.     auth_free(hip->aip);
  827.     
  828.     s_free(hip);
  829. }
  831. int http_error(struct connectioninfo *cip,
  832.        int code,
  833.        const char *format,
  834.        ...)
  835. {
  836.     va_list ap;
  837.     char *type, buf[256];
  838.     struct httpinfo *hip = cip->hip;
  839.     char *servername=NULL;
  840.     
  842.     if (hip->mip != NULL)
  843.     {
  844. type = http_sendheaders(cip->fd, cip, code, NULL);
  845. fd_puts("Content-Type: text/htmln", cip->fd);
  846. fd_putc('n', cip->fd);
  847.     }
  848.     else
  849.     {
  850.         int blen;
  851.       
  852.         blen = s_strcpy(buf, sizeof(buf), "Error Code #");
  853. s_sprintf(buf+blen, sizeof(buf)-blen, "%d", code);
  854. type = buf;
  855.     }
  857.     if (strcasecmp(hip->method, "HEAD") == 0)
  858. return code;
  859.     
  860.     va_start(ap, format);
  861.   
  862. /* TODO ??? Might be buggy due to new svs-creation code...... */ 
  863.     if ( softvirtserver )   servername=s_strdup(hip->svsname);
  864.     else if ( rkmultimode ) servername=s_strdup(dns_lookup_servername(cip->server));
  866.     html_error(cip->fd, servername, type, format, ap);
  867.     
  868.     va_end(ap);
  869.     hip->length = fd_written(cip->fd);
  870.    
  871.     if ( servername != NULL ) s_free(servername); 
  873.     return code;
  874. }
  876. void http_sendlang(int fd, const char *url)
  877. {
  878.     int i;
  879.     char **pair;
  881.     if(content_language_table == NULL)
  882.         return;
  884.     for(i = 0; i < content_language_table->length; ++i)
  885.     {
  886.         pair = content_language_table->value[i];
  887. if(strmatch(url, pair[0]))
  888. {
  889.     fd_puts("Content-Language: ", fd);
  890.     fd_puts(pair[1], fd);
  891.     fd_putc('n', fd);
  892.     break;
  893. }
  894.     }
  895. }
  897. /* Send a redirect pointer */
  898. int http_redirect(struct connectioninfo *cip,
  899.   const char *url,
  900.   const char *request,
  901.   const char *orig_req,
  902.   int code)
  903. {
  904.     char buf1[2048], buf2[2048], buf3[2048];
  905.     int result, len;
  906.     int fd = cip->fd;
  907.     struct httpinfo *hip = cip->hip;
  910.     url = url_quote(url, buf1, sizeof(buf1), "?", 0);
  911.     if (url == NULL)
  912. return -1;
  913.     
  914.     if (request)
  915.     {
  916. request = url_quote(request, buf2, sizeof(buf2), """, 1);
  917. if (request == NULL)
  918.     return -1;
  919.     }
  921.     if (orig_req)
  922.     {
  923. orig_req = url_quote(orig_req, buf3, sizeof(buf3), """, 1);
  924. if (orig_req == NULL)
  925.     return -1;
  926.     }
  927.     
  928.     if (debug > 1)
  929. fprintf(stderr, "      Sent URL REDIRECT (%s -> %s)n",
  930. hip->url, url);
  932.     result = code;
  933.     
  934.     if (hip->mip != NULL)
  935.     {
  936. http_sendheaders(fd, cip, result, NULL);
  938. fd_printf(fd, "Location: %s%s%s%sn",
  939.   url,
  940.   (orig_req || request) ? "?" : "",
  941.   orig_req ? orig_req : "",
  942.   request ? request : "");
  943.   
  945. http_sendlastmodified(fd, cip->cn_time);
  946. fd_puts("Content-Type: text/htmlnn", fd);
  947.     }
  948.     
  949.     if (strcasecmp(hip->method, "HEAD") == 0)
  950. return result;
  951.     
  952.     len = fd_written(fd);
  954.     html_sysheader(fd, "H2", "Document moved");
  955.     
  956.     fd_puts("The document has moved to this URL:<P>n", fd);
  957.     fd_puts("<UL>n", fd);
  958.     
  959.     fd_printf(fd, "<B><A HREF="%s%s%s%s">%s%s%s%s</A></B>.n",
  960.       url,
  961.       (orig_req || request) ? "?" : "",
  962.       orig_req ? orig_req : "",
  963.       request ? request : "",
  964.       url,
  965.       (orig_req || request) ? "?" : "",
  966.       orig_req ? orig_req : "",
  967.       request ? request : "");
  968.     
  969.     fd_puts("</UL>n", fd);
  970.     
  971.     html_sysfooter(fd);
  973.     if (logheadervolume)
  974. hip->length = fd_written(fd);
  975.     else
  976. hip->length = fd_written(fd) - len; 
  978.     return result;
  979. }
  982. /* Send a 'Not Modified' message */
  983. int http_not_modified(struct connectioninfo *cip)
  984. {
  985.     int result;
  986.     int fd = cip->fd;
  987.     struct httpinfo *hip = cip->hip;
  989.     
  990.     if (debug > 1)
  991. fprintf(stderr, "      Sent NOT MODIFIED messagen");
  993.     result = 304;
  995.     if (hip->mip != NULL)
  996.     {
  997. http_sendheaders(fd, cip, result, NULL);
  998. fd_putc('n', fd);
  999.     }
  1000.     hip->length = fd_written(fd);
  1001.     return result;
  1002. }
  1005. /* Send a 'Precondition Failed' message */
  1006. int http_precondition_failed(struct connectioninfo *cip)
  1007. {
  1008.     int result;
  1009.     int fd = cip->fd;
  1010.     struct httpinfo *hip = cip->hip;
  1012.     
  1013.     if (debug > 1)
  1014. fprintf(stderr, "      Sent PRECONDITION FAILED messagen");
  1016.     result = 412;
  1018.     if (hip->mip != NULL)
  1019.     {
  1020. http_sendheaders(fd, cip, result, NULL);
  1021. fd_putc('n', fd);
  1022.     }
  1023.     
  1024.     if(strcasecmp(hip->method, "HEAD") == 0)
  1025.        return result;
  1027.     html_sysheader(fd, "H2", "Precondition Failed");
  1029.     fd_printf(fd, "The entity which lives at ");
  1030.     if (hip->orig_url == NULL)
  1031. fd_printf(fd, "[null]");
  1032.     else
  1033. html_href(fd, hip->orig_url, hip->orig_url);
  1034.     
  1035.     fd_printf(fd, " was changed.n");
  1037.     html_sysfooter(fd);
  1038.     hip->length = fd_written(fd);
  1039.     
  1040.     return result;
  1041. }
  1044. static const char *const weekday[] =
  1045. {
  1046.     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
  1047. };
  1049. static const char *const month[] =
  1050. {
  1051.     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  1052.     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  1053. };
  1056. char *http_time_r(const time_t *btp, char *buf, int bufsize)
  1057. {
  1058.     struct tm tpb;
  1060.     
  1061.     if (bufsize < 31)
  1062. return NULL;
  1063.     
  1064.     if (gmtime_r(btp, &tpb) == NULL)
  1065. return NULL;
  1067.     s_sprintf(buf, bufsize, "%s, %02d %s %d %02d:%02d:%02d GMTn",
  1068.     weekday[tpb.tm_wday],
  1069.     tpb.tm_mday,
  1070.     month[tpb.tm_mon],
  1071.     tpb.tm_year + 1900,
  1072.     tpb.tm_hour,
  1073.     tpb.tm_min,
  1074.     tpb.tm_sec);
  1076.     return buf;
  1077. }