home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 8 / CDACTUAL8.iso / share / os2 / varios / apache / http_pro.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-23  |  25.9 KB  |  961 lines
  1.  
  2. /* ====================================================================
  3.  * Copyright (c) 1995 The Apache Group.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer. 
  11.  *
  12.  * 2. Redistributions in binary form must reproduce the above copyright
  13.  *    notice, this list of conditions and the following disclaimer in
  14.  *    the documentation and/or other materials provided with the
  15.  *    distribution.
  16.  *
  17.  * 3. All advertising materials mentioning features or use of this
  18.  *    software must display the following acknowledgment:
  19.  *    "This product includes software developed by the Apache Group
  20.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  21.  *
  22.  * 4. The names "Apache Server" and "Apache Group" must not be used to
  23.  *    endorse or promote products derived from this software without
  24.  *    prior written permission.
  25.  *
  26.  * 5. Redistributions of any form whatsoever must retain the following
  27.  *    acknowledgment:
  28.  *    "This product includes software developed by the Apache Group
  29.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  30.  *
  31.  * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
  32.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  34.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR
  35.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  36.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  37.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  38.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  41.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  42.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  43.  * ====================================================================
  44.  *
  45.  * This software consists of voluntary contributions made by many
  46.  * individuals on behalf of the Apache Group and was originally based
  47.  * on public domain software written at the National Center for
  48.  * Supercomputing Applications, University of Illinois, Urbana-Champaign.
  49.  * For more information on the Apache Group and the Apache HTTP server
  50.  * project, please see <http://www.apache.org/>.
  51.  *
  52.  */
  53.  
  54.  
  55. /*
  56.  * http_protocol.c --- routines which directly communicate with the
  57.  * client.
  58.  *
  59.  * Code originally by Rob McCool; much redone by rst.
  60.  */
  61.  
  62. #define CORE_PRIVATE
  63. #include "httpd.h"
  64. #include "http_config.h"
  65. #include "http_core.h"
  66. #include "http_protocol.h"
  67. #include "http_main.h"
  68. #include "http_log.h"        /* For errors detected in basic auth
  69.                  * common support code...
  70.                  */
  71.  
  72. #include <stdarg.h>
  73.  
  74. #define SET_BYTES_SENT(r) \
  75.   do { if (r->sent_bodyct) \
  76.       bgetopt (r->connection->client, BO_BYTECT, &r->bytes_sent); \
  77.   } while (0)
  78.  
  79. /* Handling of conditional gets (if-modified-since); Roy owes Rob beer. 
  80.  * This would be considerably easier if strptime or timegm were portable...
  81.  */
  82.  
  83. const char month_snames[12][4] = {
  84.     "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
  85. };
  86.  
  87. int find_month(char *mon) {
  88.     register int x;
  89.  
  90.     for(x=0;x<12;x++)
  91.         if(!strcmp(month_snames[x],mon))
  92.             return x;
  93.     return -1;
  94. }
  95.  
  96. int later_than(struct tm *lms, char *ims) {
  97.     char *ip;
  98.     char mname[MAX_STRING_LEN];
  99.     int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0, x;
  100.  
  101.     /* Whatever format we're looking at, it will start with weekday. */
  102.     /* Skip to first space. */
  103.     if(!(ip = strchr(ims,' ')))
  104.         return 0;
  105.     else
  106.         while(isspace(*ip))
  107.             ++ip;
  108.  
  109.     if(isalpha(*ip)) {
  110.         /* ctime */
  111.         sscanf(ip,"%s %d %d:%d:%d %d",mname,&day,&hour,&min,&sec,&year);
  112.     }
  113.     else if(ip[2] == '-') {
  114.         /* RFC 850 (normal HTTP) */
  115.         char t[MAX_STRING_LEN];
  116.         sscanf(ip,"%s %d:%d:%d",t,&hour,&min,&sec);
  117.         t[2] = '\0';
  118.         day = atoi(t);
  119.         t[6] = '\0';
  120.         strcpy(mname,&t[3]);
  121.         x = atoi(&t[7]);
  122.         /* Prevent wraparound from ambiguity */
  123.         if(x < 70)
  124.             x += 100;
  125.         year = 1900 + x;
  126.     }
  127.     else {
  128.         /* RFC 822 */
  129.         sscanf(ip,"%d %s %d %d:%d:%d",&day,mname,&year,&hour,&min,&sec);
  130.     }
  131.     month = find_month(mname);
  132.  
  133.     if((x = (1900+lms->tm_year) - year))
  134.         return x < 0;
  135.     if((x = lms->tm_mon - month))
  136.         return x < 0;
  137.     if((x = lms->tm_mday - day))
  138.         return x < 0;
  139.     if((x = lms->tm_hour - hour))
  140.         return x < 0;
  141.     if((x = lms->tm_min - min))
  142.         return x < 0;
  143.     if((x = lms->tm_sec - sec))
  144.         return x < 0;
  145.  
  146.     return 1;
  147. }
  148.  
  149.  
  150. int set_content_length (request_rec *r, long clength)
  151. {
  152.     char ts[MAX_STRING_LEN];
  153.     
  154.     sprintf (ts, "%ld", (long)r->finfo.st_size);
  155.     table_set (r->headers_out, "Content-length", pstrdup (r->pool, ts));
  156.     return 0;
  157. }
  158.  
  159. int set_keepalive(request_rec *r)
  160. {
  161.   char *conn = table_get (r->headers_in, "Connection");
  162.   char *length = table_get (r->headers_out, "Content-length");
  163.  
  164.   if (conn && length && !strncasecmp(conn, "Keep-Alive", 10) &&
  165.       r->server->keep_alive_timeout &&
  166.       (r->server->keep_alive > r->connection->keepalives)) {
  167.     char header[26];
  168.     int left = r->server->keep_alive - r->connection->keepalives;
  169.  
  170.     r->connection->keepalive = 1;
  171.     r->connection->keepalives++;
  172.     sprintf(header, "timeout=%d, max=%d", r->server->keep_alive_timeout,
  173.         left);
  174.     table_set (r->headers_out, "Connection", "Keep-Alive");
  175.     table_set (r->headers_out, "Keep-Alive", pstrdup(r->pool, header));
  176.  
  177.     return 1;
  178.   }
  179.  
  180.       return 0;
  181. }
  182.  
  183. int set_last_modified(request_rec *r, time_t mtime)
  184. {
  185.     char *ts;
  186.     char *if_modified_since = table_get (r->headers_in, "If-modified-since");
  187.  
  188.     /* Cacheing proxies use the absence of a Last-modified header
  189.      * to indicate that a document is dynamic and shouldn't be cached.
  190.      * For the moment, we enforce that here, though it would probably
  191.      * work just as well to generate an Expires: header in send_http_header.
  192.      *
  193.      * However, even in that case, if no_cache is set, we would *not*
  194.      * want to send USE_LOCAL_COPY, since the client isn't *supposed*
  195.      * to have it cached.
  196.      */
  197.     
  198.     if (r->no_cache) return OK;
  199.     
  200.     ts = gm_timestr_822(r->pool, mtime);
  201.     table_set (r->headers_out, "Last-modified", ts);
  202.  
  203.     /* Check for conditional GETs --- note that we only want this check
  204.      * to succeed if the GET was successful; ErrorDocuments *always* get sent.
  205.      */
  206.     
  207.     if (r->status == 200 &&
  208.     if_modified_since && later_than(gmtime(&mtime), if_modified_since))
  209.       
  210.         return USE_LOCAL_COPY;
  211.     else
  212.         return OK;
  213. }
  214.  
  215. /*
  216.  * Finally, real protocol stuff.
  217.  */
  218.  
  219. static char *
  220. getline(char *s, int n, BUFF *in)
  221. {
  222.     int retval = bgets (s, n, in);
  223.  
  224.     if (retval == -1) return NULL;
  225.  
  226.     if (retval > 0 && s[retval-1] == '\n') s[retval-1] = '\0';
  227.  
  228.     return s;
  229. }
  230.  
  231. void parse_uri (request_rec *r, char *uri)
  232. {
  233.     const char *s;
  234.     /* If we ever want to do byte-ranges a la Netscape & Franks,
  235.      * this is the place to parse them; with proper support in
  236.      * rprintf and rputc, and the sub-request setup and finalizers
  237.      * here, it'll all just work, even for vile cases like
  238.      * inclusion of byte-ranges of the output of CGI scripts, with
  239.      * the client requesting only a byte-range of *that*!
  240.      *
  241.      * But for now...
  242.      */
  243.  
  244. #ifdef __EMX__
  245.     /* Variable for OS/2 fix below. */
  246.     int loop;
  247. #endif
  248.  
  249. /* A proxy request contains a ':' early on, but not as first character */
  250.     for (s=uri; s != '\0'; s++)
  251.     if (!isalnum(*s) && *s != '+' && *s != '-' && *s != '.') break;
  252.  
  253.     if (*s == ':' && s != uri)
  254.     {
  255.     r->proxyreq = 1;
  256.     r->uri = uri;
  257.     r->args = NULL;
  258.     } else
  259.     {
  260.     r->proxyreq = 0;
  261.     r->uri = getword (r->pool, &uri, '?');
  262.  
  263. #ifdef __EMX__
  264.     /* Handle path translations for OS/2 and plug security hole. */
  265.     /* This will prevent "http://www.wherever.com/..\..\/" from
  266.        returning a directory for the root drive. */
  267.     for (loop = 0; loop <= strlen(r->uri); ++loop) {
  268.         if (r->uri[loop] == '\\')
  269.             r->uri[loop] = '/';
  270. };
  271. #endif
  272.  
  273.     if (*uri) r->args= uri;
  274.     else r->args = NULL;
  275.     }
  276. }
  277.  
  278. char *check_fulluri (request_rec *r, char *uri) {
  279.   char *name, *host;
  280.   int i, port;
  281.  
  282.   /* This routine parses full URLs, if they match the server */
  283.   if (strncmp(uri, "http://", 7)) return uri;
  284.   name = pstrdup(r->pool, uri + 7);
  285.   
  286.   /* Find the hostname, assuming a valid request */
  287.   i = ind(name, '/');
  288.   name[i] = '\0';
  289.  
  290.   /* Find the port */
  291.   host = getword(r->pool, &name, ':');
  292.   if (*name) port = atoi(name);
  293.   else port = 80;
  294.  
  295.   /* Make sure ports patch */
  296.   if (port != r->server->port) return uri;
  297.  
  298.   /* Save it for later use */
  299.   r->hostname = pstrdup(r->pool, host);
  300.   r->hostlen = 7 + i;
  301.  
  302.   /* The easy cases first */
  303.   if (!strcasecmp(host, r->server->server_hostname)) {
  304.     return (uri + r->hostlen);
  305.   }
  306.   else if (!strcmp(host, inet_ntoa(r->connection->local_addr.sin_addr))) {
  307.     return (uri + r->hostlen);
  308.   }
  309.  
  310.   /* Now things get a bit trickier - check the IP address(es) of the host */
  311.   /* they gave, see if it matches ours.                                   */
  312.   else {
  313.     struct hostent *hp;
  314.     int n;
  315.  
  316.     if ((hp = gethostbyname(host))) {
  317.       for (n = 0; hp->h_addr_list[n] != NULL; n++) {
  318.     if (r->connection->local_addr.sin_addr.s_addr ==
  319.         (((struct in_addr *)(hp->h_addr_list[n]))->s_addr)) {
  320.       return (uri + r->hostlen);
  321.     }
  322.       }
  323.     }
  324.   }
  325.   
  326.   return uri;
  327. }
  328.  
  329. int read_request_line (request_rec *r)
  330. {
  331.     char l[HUGE_STRING_LEN];
  332.     char *ll = l, *uri;
  333.     conn_rec *conn = r->connection;
  334.     int major = 1, minor = 0;    /* Assume HTTP/1.0 if non-"HTTP" protocol*/
  335.     
  336.     l[0] = '\0';
  337.     if(!getline(l, HUGE_STRING_LEN, conn->client))
  338.         return 0;
  339.     if(!l[0]) 
  340.         return 0;
  341.  
  342.     r->the_request = pstrdup (r->pool, l);
  343.     r->method = getword(r->pool, &ll,' ');
  344.     uri = getword(r->pool, &ll,' ');
  345.     uri = check_fulluri(r, uri);
  346.     parse_uri (r, uri);
  347.     
  348.     r->assbackwards = (ll[0] == '\0');
  349.     r->protocol = pstrdup (r->pool, ll[0] ? ll : "HTTP/0.9");
  350.     sscanf(r->protocol, "HTTP/%d.%d", &major, &minor);
  351.     r->proto_num = 1000*major + minor;
  352.  
  353.     return 1;
  354. }
  355.  
  356. void get_mime_headers(request_rec *r)
  357. {
  358.     char w[MAX_STRING_LEN];
  359.     char *t;
  360.     conn_rec *c = r->connection;
  361.  
  362.     while(getline(w, MAX_STRING_LEN-1, c->client)) {
  363.         if(!w[0]) 
  364.             return;
  365.         if(!(t = strchr(w,':')))
  366.             continue;
  367.         *t++ = '\0';
  368.         while(isspace(*t)) ++t;
  369.  
  370.     table_merge (r->headers_in, w, t);
  371.     }
  372. }
  373.  
  374. void check_hostalias (request_rec *r) {
  375.   char *host = getword(r->pool, &r->hostname, ':');    /* Get rid of port */
  376.   int port = (*r->hostname) ? atoi(r->hostname) : 0;
  377.   server_rec *s;
  378.  
  379.   if (port && (port != r->server->port))
  380.     return;
  381.  
  382.   if ((host[strlen(host)-1]) == '.') {
  383.     host[strlen(host)-1] = '\0';
  384.   }
  385.  
  386.   r->hostname = host;
  387.  
  388.   for (s = r->server->next; s; s = s->next) {
  389.     char *names = s->names;
  390.     
  391.     if ((!strcasecmp(host, s->server_hostname)) &&
  392.     (!port || (port == s->port))) {
  393.       r->server = r->connection->server = s;
  394.       if (r->hostlen && !strncmp(r->uri, "http://", 7)) {
  395.     r->uri += r->hostlen;
  396.     parse_uri(r, r->uri);
  397.       }
  398.     }
  399.  
  400.     if (!names) continue;
  401.  
  402.     while (*names) {
  403.       char *name = getword_conf (r->pool, &names);
  404.  
  405.       if ((is_matchexp(name) && !strcasecmp_match(host, name)) ||
  406.       (!strcasecmp(host, name))) {
  407.     r->server = r->connection->server = s;
  408.     if (r->hostlen && !strncmp(r->uri, "http://", 7)) {
  409.       r->uri += r->hostlen;
  410.       r->proxyreq = 0;
  411.     }
  412.       }
  413.     }
  414.   }
  415. }
  416.  
  417. void check_serverpath (request_rec *r) {
  418.   server_rec *s;
  419.  
  420.   /* This is in conjunction with the ServerPath code in
  421.    * http_core, so we get the right host attached to a non-
  422.    * Host-sending request.
  423.    */
  424.  
  425.   for (s = r->server->next; s; s = s->next) {
  426.     if (s->path && !strncmp(r->uri, s->path, s->pathlen))
  427.       r->server = r->connection->server = s;
  428.   }
  429. }
  430.  
  431. request_rec *read_request (conn_rec *conn)
  432. {
  433.     request_rec *r = (request_rec *)pcalloc (conn->pool, sizeof(request_rec));
  434.   
  435.     r->connection = conn;
  436.     r->server = conn->server;
  437.     r->pool = make_sub_pool(conn->pool);
  438.  
  439.     conn->keptalive = conn->keepalive;
  440.     conn->keepalive = 0;
  441.  
  442.     conn->user = NULL;
  443.     conn->auth_type = NULL;
  444.  
  445.     r->headers_in = make_table (r->pool, 50);
  446.     r->subprocess_env = make_table (r->pool, 50);
  447.     r->headers_out = make_table (r->pool, 5);
  448.     r->err_headers_out = make_table (r->pool, 5);
  449.     r->notes = make_table (r->pool, 5);
  450.  
  451.     r->request_config = create_request_config (r->pool);
  452.     r->per_dir_config = r->server->lookup_defaults; /* For now. */
  453.  
  454.     r->sent_bodyct = 0; /* bytect isn't for body */
  455.     
  456.     r->status = 200;        /* Until further notice.
  457.                  * Only changed by die(), or (bletch!)
  458.                  * scan_script_header...
  459.                  */
  460.  
  461.     /* Get the request... */
  462.     
  463.     hard_timeout ("read", r);
  464.     if (!read_request_line (r)) return NULL;
  465.     if (!r->assbackwards) get_mime_headers(r);
  466.  
  467. /* handle Host header here, to get virtual server */
  468.  
  469.     if (r->hostname || (r->hostname = table_get(r->headers_in, "Host")))
  470.       check_hostalias(r);
  471.     else
  472.       check_serverpath(r);
  473.  
  474.     kill_timeout (r);
  475.     conn->keptalive = 0;   /* We now have a request - so no more short timeouts */
  476.     
  477.     if(!strcmp(r->method, "HEAD")) {
  478.         r->header_only=1;
  479.     r->method_number = M_GET;
  480.     }
  481.     else if(!strcmp(r->method, "GET")) 
  482.     r->method_number = M_GET;
  483.     else if(!strcmp(r->method,"POST")) 
  484.         r->method_number = M_POST;
  485.     else if(!strcmp(r->method,"PUT")) 
  486.         r->method_number = M_PUT;
  487.     else if(!strcmp(r->method,"DELETE")) 
  488.         r->method_number = M_DELETE;
  489.     else if(!strcmp(r->method,"CONNECT"))
  490.         r->method_number = M_CONNECT;
  491.     else 
  492.         r->method_number = M_INVALID; /* Will eventually croak. */
  493.  
  494.     return r;
  495. }
  496.  
  497. /*
  498.  * A couple of other functions which initialize some of the fields of
  499.  * a request structure, as appropriate for adjuncts of one kind or another
  500.  * to a request in progress.  Best here, rather than elsewhere, since
  501.  * *someone* has to set the protocol-specific fields...
  502.  */
  503.  
  504. void set_sub_req_protocol (request_rec *rnew, request_rec *r)
  505. {
  506.     rnew->assbackwards = 1;    /* Don't send headers from this. */
  507.     rnew->no_cache = 1;        /* Don't try to send USE_LOCAL_COPY for a
  508.                  * fragment.
  509.                  */
  510.     rnew->method = "GET"; rnew->method_number = M_GET;
  511.     rnew->protocol = "INCLUDED";
  512.  
  513.     rnew->status = 200;
  514.  
  515.     rnew->headers_in = r->headers_in;
  516.     rnew->subprocess_env = copy_table (rnew->pool, r->subprocess_env);
  517.     rnew->headers_out = make_table (rnew->pool, 5);
  518.     rnew->err_headers_out = make_table (rnew->pool, 5);
  519.     rnew->notes = make_table (rnew->pool, 5);
  520.     
  521.     rnew->main = r;
  522. }
  523.  
  524. void finalize_sub_req_protocol (request_rec *sub)
  525. {
  526.     SET_BYTES_SENT (sub->main);
  527. } 
  528.  
  529. /* Support for the Basic authentication protocol, and a bit for Digest.
  530.  */
  531.  
  532. void note_auth_failure(request_rec *r)
  533. {
  534.     if (!strcasecmp(auth_type(r), "Basic"))
  535.       note_basic_auth_failure(r);
  536.     else if(!strcasecmp(auth_type(r), "Digest"))
  537.       note_digest_auth_failure(r);
  538. }
  539.  
  540. void note_basic_auth_failure(request_rec *r)
  541. {
  542.     if (strcasecmp(auth_type(r), "Basic"))
  543.       note_auth_failure(r);
  544.     else
  545.       table_set (r->err_headers_out, "WWW-Authenticate",
  546.          pstrcat(r->pool, "Basic realm=\"", auth_name(r), "\"", NULL));
  547. }
  548.  
  549. void note_digest_auth_failure(request_rec *r)
  550. {
  551.     char nonce[10];
  552.  
  553.     sprintf(nonce, "%lu", time(NULL));
  554.     table_set (r->err_headers_out, "WWW-Authenticate",
  555.                pstrcat(r->pool, "Digest realm=\"", auth_name(r),
  556.                        "\", nonce=\"", nonce, "\"", NULL));
  557. }
  558.  
  559. int get_basic_auth_pw (request_rec *r, char **pw)
  560. {
  561.     char *auth_line = table_get (r->headers_in, "Authorization");
  562.     char *t;
  563.     
  564.     if(!(t = auth_type(r)) || strcasecmp(t, "Basic"))
  565.         return DECLINED;
  566.  
  567.     if (!auth_name (r)) {
  568.         log_reason ("need AuthName", r->uri, r);
  569.     return SERVER_ERROR;
  570.     }
  571.     
  572.     if(!auth_line) {
  573.         note_basic_auth_failure (r);
  574.     return AUTH_REQUIRED;
  575.     }
  576.  
  577.     if (strcmp(getword (r->pool, &auth_line, ' '), "Basic")) {
  578.         /* Client tried to authenticate using wrong auth scheme */
  579.         log_reason ("client used wrong authentication scheme", r->uri, r);
  580.         note_basic_auth_failure (r);
  581.     return AUTH_REQUIRED;
  582.     }
  583.  
  584.     t = uudecode (r->pool, auth_line);
  585.     r->connection->user = getword_nulls (r->pool, &t, ':');
  586.     r->connection->auth_type = "Basic";
  587.  
  588.     *pw = t;
  589.  
  590.     return OK;
  591. }
  592.  
  593. #define RESPONSE_CODE_LIST " 200 302 304 400 401 403 404 500 503 501 502 "
  594.  
  595. /* New Apache routine to map error responses into array indicies 
  596.  *  e.g.  400 -> 0,  500 -> 1,  502 -> 2 ...                     
  597.  * the indicies have no significance
  598.  */
  599.  
  600. char *status_lines[] = {
  601.    "200 OK",
  602.    "302 Found",
  603.    "304 Not Modified",
  604.    "400 Bad Request",
  605.    "401 Unauthorized",
  606.    "403 Forbidden",
  607.    "404 Not found",
  608.    "500 Server error",
  609.    "503 Out of resources",
  610.    "501 Not Implemented",
  611.    "502 Bad Gateway"
  612. }; 
  613.  
  614. char *response_titles[] = {
  615.    "200 OK",            /* Never actually sent, barring die(200,...) */
  616.    "Document moved",        /* 302 Redirect */
  617.    "304 Not Modified",        /* Never sent... 304 MUST be header only */
  618.    "Bad Request",
  619.    "Authorization Required",
  620.    "Forbidden",
  621.    "File Not found",
  622.    "Server Error",
  623.    "Out of resources",
  624.    "Method not implemented",
  625.    "Bad Gateway"
  626. };
  627.  
  628. int index_of_response(int err_no) {
  629.    char *cptr, err_string[10];
  630.    static char *response_codes = RESPONSE_CODE_LIST;
  631.    int index_number;
  632.    
  633.    sprintf(err_string,"%3d",err_no);
  634.    
  635.    cptr = response_codes;
  636.    cptr++;
  637.    index_number = 0;
  638.    while (*cptr && strncmp(cptr, err_string, 3)) { 
  639.       cptr += 4;
  640.       index_number++;
  641.    }
  642.    if (!*cptr) return -1;
  643.    return index_number;
  644. }
  645.  
  646.  
  647. void basic_http_header (request_rec *r)
  648. {
  649.     BUFF *fd = r->connection->client;
  650.     
  651.     if (r->assbackwards) return;
  652.     
  653.     if (!r->status_line)
  654.         r->status_line = status_lines[index_of_response(r->status)];
  655.     
  656.     bvputs(fd, SERVER_PROTOCOL, " ", r->status_line, "\015\012", NULL);
  657.     bvputs(fd,"Date: ",gm_timestr_822 (r->pool, time(NULL)), "\015\012", NULL);
  658.     bvputs(fd,"Server: ", SERVER_VERSION, "\015\012", NULL);
  659. }
  660.  
  661. char *nuke_mime_parms (pool *p, char *content_type)
  662. {
  663.     /* How marvelous.  Arena doesn't *accept* "text/html; level=3"
  664.      * as a MIME type, so we have to strip off the parms.
  665.      */
  666.  
  667. #ifndef ARENA_BUG_WORKAROUND
  668.     return content_type;
  669. #else
  670.  
  671.     char *cp = strchr(content_type, ';');
  672.  
  673.     if (cp) {
  674.         content_type = pstrdup (p, content_type);
  675.     cp = strchr (content_type, ';');
  676.     
  677.         while (cp > content_type && isspace (cp[-1]))
  678.         --cp;
  679.     *cp = '\0';
  680.     }
  681.  
  682.     return content_type;
  683. #endif
  684. }
  685.  
  686. void send_http_header(request_rec *r)
  687. {
  688.     conn_rec *c = r->connection;
  689.     BUFF *fd = c->client;
  690.     const long int zero=0L;
  691.     array_header *hdrs_arr;
  692.     table_entry *hdrs;
  693.     int i;
  694.     
  695.     core_dir_config *dir_conf =
  696.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module);
  697.     char *default_type = dir_conf->default_type;
  698.   
  699.     if (r->assbackwards) {
  700.     bsetopt(fd, BO_BYTECT, &zero);
  701.     r->sent_bodyct = 1;
  702.     return;
  703.     }
  704.     
  705.     basic_http_header (r);
  706.  
  707.     set_keepalive (r);
  708.     
  709.     if (r->content_type)
  710.         bvputs(fd, "Content-type: ", 
  711.          nuke_mime_parms (r->pool, r->content_type), "\015\012", NULL);
  712.     else if(default_type)
  713.         bvputs(fd, "Content-type: ", default_type, "\015\012", NULL);
  714.     
  715.     if (r->content_encoding)
  716.         bvputs(fd,"Content-encoding: ", r->content_encoding, "\015\012", NULL);
  717.     
  718.     if (r->content_language)
  719.         bvputs(fd,"Content-language: ", r->content_language, "\015\012", NULL);
  720.     
  721.     hdrs_arr = table_elts(r->headers_out);
  722.     hdrs = (table_entry *)hdrs_arr->elts;
  723.     for (i = 0; i < hdrs_arr->nelts; ++i) {
  724.         if (!hdrs[i].key) continue;
  725.     bvputs(fd, hdrs[i].key, ": ", hdrs[i].val, "\015\012", NULL);
  726.     }
  727.  
  728.     hdrs_arr = table_elts(r->err_headers_out);
  729.     hdrs = (table_entry *)hdrs_arr->elts;
  730.     for (i = 0; i < hdrs_arr->nelts; ++i) {
  731.         if (!hdrs[i].key) continue;
  732.     bvputs(fd, hdrs[i].key, ": ", hdrs[i].val, "\015\012", NULL);
  733.     }
  734.  
  735.     bputs("\015\012",fd);
  736.  
  737.     if (c->keepalive)
  738.     bflush(r->connection->client);  /* For bugs in Netscape, perhaps */
  739.  
  740.     bsetopt(fd, BO_BYTECT, &zero);
  741.     r->sent_bodyct = 1;        /* Whatever follows is real body stuff... */
  742. }
  743.  
  744. long read_client_block (request_rec *r, char *buffer, int bufsiz)
  745. {
  746.     return bread(r->connection->client, buffer, bufsiz);
  747. }
  748.  
  749. long send_fd(FILE *f, request_rec *r)
  750. {
  751.     char buf[IOBUFSIZE];
  752.     long total_bytes_sent;
  753.     register int n,o,w;
  754.     conn_rec *c = r->connection;
  755.     
  756.     total_bytes_sent = 0;
  757.     while (!r->connection->aborted) {
  758.         while ((n= fread(buf, sizeof(char), IOBUFSIZE, f)) < 1
  759.            && ferror(f) && errno == EINTR)
  760.         continue;
  761.     
  762.     if (n < 1) {
  763.             break;
  764.         }
  765.         o=0;
  766.     total_bytes_sent += n;
  767.     
  768.         while(n && !r->connection->aborted) {
  769.             w=bwrite(c->client, &buf[o], n);
  770.         if(w <= 0)
  771.         break;
  772.         reset_timeout(r); /* reset timeout after successfule write */
  773.             n-=w;
  774.             o+=w;
  775.         }
  776.     }
  777.     bflush(c->client);
  778.     
  779.     SET_BYTES_SENT(r);
  780.     return total_bytes_sent;
  781. }
  782.  
  783. int rputc (int c, request_rec *r)
  784. {
  785.     if (r->connection->aborted) return EOF;
  786.     bputc(c, r->connection->client);
  787.     SET_BYTES_SENT(r);
  788.     return c;
  789. }
  790.  
  791. int
  792. rputs(const char *str, request_rec *r)
  793. {
  794.     if (r->connection->aborted) return EOF;
  795.     SET_BYTES_SENT(r);
  796.     return bputs(str, r->connection->client);
  797. }
  798.  
  799. int rprintf(request_rec *r,const char *fmt,...)
  800.     {
  801.     va_list vlist;
  802.     int n;
  803.  
  804.     if(r->connection->aborted) return EOF;
  805.     va_start(vlist,fmt);
  806.     n=vbprintf(r->connection->client,fmt,vlist);
  807.     va_end(vlist);
  808.     SET_BYTES_SENT(r);
  809.     return n;
  810.     }
  811.  
  812. int
  813. rvputs(request_rec *r, ...)
  814. {
  815.     va_list args;
  816.     int i, j, k;
  817.     const char *x;
  818.     BUFF *fb=r->connection->client;
  819.     
  820.     if (r->connection->aborted) return EOF;
  821.     
  822.     va_start (args, r);
  823.     for (k=0;;)
  824.     {
  825.     x = va_arg(args, const char *);
  826.     if (x == NULL) break;
  827.     j = strlen(x);
  828.     i = bwrite(fb, x, j);
  829.     if (i != j)
  830.     {
  831.         va_end(args);
  832.         return -1;
  833.     }
  834.     k += i;
  835.     }
  836.     va_end(args);
  837.  
  838.     SET_BYTES_SENT(r);
  839.     return k;
  840. }
  841.  
  842. void send_error_response (request_rec *r, int recursive_error)
  843. {
  844.     conn_rec *c = r->connection;
  845.     char *custom_response;
  846.     int status = r->status;
  847.     int idx = index_of_response (status);
  848.     char *location = table_get (r->headers_out, "Location");
  849.  
  850.     if (!r->assbackwards) {
  851.     int i;
  852.     table *err_hdrs_arr = r->err_headers_out;
  853.     table_entry *err_hdrs = (table_entry *)err_hdrs_arr->elts;
  854.   
  855.         basic_http_header (r);
  856.     
  857.     /* For conditional get's which didn't send anything, *don't*
  858.      * send a bogus content-type, or any body --- but must still
  859.      * terminate header.
  860.      */
  861.     
  862.     if (status == USE_LOCAL_COPY) {
  863.         if (set_keepalive(r))
  864.         bputs("Connection: Keep-Alive\015\012", c->client);
  865.         bputs("\015\012", c->client);
  866.         return;
  867.     }
  868.     
  869.     if (status == REDIRECT)
  870.         bvputs(c->client, "Location: ", location, "\015\012", NULL);
  871.     
  872.     for (i = 0; i < err_hdrs_arr->nelts; ++i) {
  873.         if (!err_hdrs[i].key) continue;
  874.         bvputs(c->client, err_hdrs[i].key, ": ", err_hdrs[i].val,
  875.            "\015\012", NULL);
  876.     }
  877.  
  878.     bputs("Content-type: text/html\015\012\015\012", c->client);
  879.     }
  880.  
  881.     if (r->header_only) return;
  882.     
  883.     if ((custom_response = response_code_string (r, idx)))
  884.         bputs(custom_response, c->client);
  885.     else {
  886.     char *title = response_titles[idx];
  887.     BUFF *fd = c->client;
  888.     
  889.         bvputs(fd,"<HEAD><TITLE>", title, "</TITLE></HEAD>\n<BODY><H1>", title,
  890.            "</H1>\n", NULL);
  891.     
  892.         switch (r->status) {
  893.     case REDIRECT:
  894.         bvputs(fd, "The document has moved <A HREF=\"",
  895.             escape_html(r->pool, location), "\">here</A>.<P>\n", NULL);
  896.         break;
  897.     case AUTH_REQUIRED:
  898.         bputs("This server could not verify that you\n", fd);
  899.         bputs("are authorized to access the document you\n", fd);
  900.         bputs("requested.  Either you supplied the wrong\n", fd);
  901.         bputs("credentials (e.g., bad password), or your\n", fd);
  902.         bputs("browser doesn't understand how to supply\n", fd);
  903.         bputs("the credentials required.<P>\n", fd);
  904.         break;
  905.     case BAD_REQUEST:
  906.         bputs("Your browser sent a query that\n", fd);
  907.         bputs("this server could not understand.<P>\n", fd);
  908.         break;
  909.     case FORBIDDEN:
  910.         bvputs(fd, "You don't have permission to access ",
  911.              escape_html(r->pool, r->uri), "\non this server.<P>\n",
  912.            NULL);
  913.         break;
  914.     case NOT_FOUND:
  915.          bvputs(fd, "The requested URL ", escape_html(r->pool, r->uri),
  916.             " was not found on this server.<P>\n", NULL);
  917.         break;
  918.     case SERVER_ERROR:
  919.         bputs("The server encountered an internal error or\n", fd);
  920.         bputs("misconfiguration and was unable to complete\n", fd);
  921.         bputs("your request.<P>\n", fd);
  922.         bputs("Please contact the server administrator,\n ", fd);
  923.         bputs(escape_html(r->pool, r->server->server_admin), fd);
  924.         bputs(" and inform them of the time the error occurred,\n", fd);
  925.         bputs("and anything you might have done that may have\n", fd);
  926.         bputs("caused the error.<P>\n", fd);
  927.         break;
  928.     case NOT_IMPLEMENTED:
  929.         bvputs(fd, escape_html(r->pool, r->method), " to ",
  930.            escape_html(r->pool, r->uri), " not supported.<P>\n", NULL);
  931.         break;
  932.     case BAD_GATEWAY:
  933.         bputs("The proxy server received an invalid\015\012", fd);
  934.         bputs("response from an upstream server.<P>\015\012", fd);
  935.         break;
  936.     }
  937.  
  938.         if (recursive_error) {
  939.         char x[80];
  940.         sprintf (x, "Additionally, an error of type %d was encountered\n",
  941.              recursive_error);
  942.         bputs(x, fd);
  943.         bputs("while trying to use an ErrorDocument to\n", fd);
  944.         bputs("handle the request.\n", fd);
  945.     }
  946.     bputs("</BODY>\n", fd);
  947.     }
  948.         
  949. }
  950.  
  951. /* Finally, this... it's here to support nph- scripts
  952.  * Now what ever are we going to do about them when HTTP-NG packetization
  953.  * comes along?
  954.  */
  955.  
  956. void client_to_stdout (conn_rec *c)
  957. {
  958.     bflush(c->client);
  959.     dup2(c->client->fd, STDOUT_FILENO);
  960. }
  961.