home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 9 / CDACTUAL9.iso / share / Os2 / varios / APACHE / HTTP_PRO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-16  |  19.6 KB  |  704 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. /* Handling of conditional gets (if-modified-since); Roy owes Rob beer. 
  75.  * This would be considerably easier if strptime or timegm were portable...
  76.  */
  77.  
  78. static char *months[] = {
  79.     "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
  80. };
  81.  
  82. int find_month(char *mon) {
  83.     register int x;
  84.  
  85.     for(x=0;x<12;x++)
  86.         if(!strcmp(months[x],mon))
  87.             return x;
  88.     return -1;
  89. }
  90.  
  91. int later_than(struct tm *lms, char *ims) {
  92.     char *ip;
  93.     char mname[MAX_STRING_LEN];
  94.     int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0, x;
  95.  
  96.     /* Whatever format we're looking at, it will start with weekday. */
  97.     /* Skip to first space. */
  98.     if(!(ip = strchr(ims,' ')))
  99.         return 0;
  100.     else
  101.         while(isspace(*ip))
  102.             ++ip;
  103.  
  104.     if(isalpha(*ip)) {
  105.         /* ctime */
  106.         sscanf(ip,"%s %d %d:%d:%d %d",mname,&day,&hour,&min,&sec,&year);
  107.     }
  108.     else if(ip[2] == '-') {
  109.         /* RFC 850 (normal HTTP) */
  110.         char t[MAX_STRING_LEN];
  111.         sscanf(ip,"%s %d:%d:%d",t,&hour,&min,&sec);
  112.         t[2] = '\0';
  113.         day = atoi(t);
  114.         t[6] = '\0';
  115.         strcpy(mname,&t[3]);
  116.         x = atoi(&t[7]);
  117.         /* Prevent wraparound from ambiguity */
  118.         if(x < 70)
  119.             x += 100;
  120.         year = 1900 + x;
  121.     }
  122.     else {
  123.         /* RFC 822 */
  124.         sscanf(ip,"%d %s %d %d:%d:%d",&day,mname,&year,&hour,&min,&sec);
  125.     }
  126.     month = find_month(mname);
  127.  
  128.     if((x = (1900+lms->tm_year) - year))
  129.         return x < 0;
  130.     if((x = lms->tm_mon - month))
  131.         return x < 0;
  132.     if((x = lms->tm_mday - day))
  133.         return x < 0;
  134.     if((x = lms->tm_hour - hour))
  135.         return x < 0;
  136.     if((x = lms->tm_min - min))
  137.         return x < 0;
  138.     if((x = lms->tm_sec - sec))
  139.         return x < 0;
  140.  
  141.     return 1;
  142. }
  143.  
  144.  
  145. int set_content_length (request_rec *r, long clength)
  146. {
  147.     char ts[MAX_STRING_LEN];
  148.     
  149.     sprintf (ts, "%ld", (long)r->finfo.st_size);
  150.     table_set (r->headers_out, "Content-length", pstrdup (r->pool, ts));
  151.     return 0;
  152. }
  153.  
  154. int set_last_modified(request_rec *r, time_t mtime)
  155. {
  156.     struct tm *tms;
  157.     char ts[MAX_STRING_LEN];
  158.     char *if_modified_since = table_get (r->headers_in, "If-modified-since");
  159.  
  160.     /* Cacheing proxies use the absence of a Last-modified header
  161.      * to indicate that a document is dynamic and shouldn't be cached.
  162.      * For the moment, we enforce that here, though it would probably
  163.      * work just as well to generate an Expires: header in send_http_header.
  164.      *
  165.      * However, even in that case, if no_cache is set, we would *not*
  166.      * want to send USE_LOCAL_COPY, since the client isn't *supposed*
  167.      * to have it cached.
  168.      */
  169.     
  170.     if (r->no_cache) return OK;
  171.     
  172.     tms = gmtime(&mtime);
  173.     strftime(ts,MAX_STRING_LEN,HTTP_TIME_FORMAT,tms);
  174.     table_set (r->headers_out, "Last-modified", pstrdup (r->pool, ts));
  175.  
  176.     /* Check for conditional GETs --- note that we only want this check
  177.      * to succeed if the GET was successful; ErrorDocuments *always* get sent.
  178.      */
  179.     
  180.     if (r->status == 200 &&
  181.     if_modified_since && later_than(tms, if_modified_since))
  182.       
  183.         return USE_LOCAL_COPY;
  184.     else
  185.         return OK;
  186. }
  187.  
  188. /*
  189.  * Finally, real protocol stuff.
  190.  */
  191.  
  192. char *getline (char *s, int n, FILE *in)
  193. {
  194.     char *retval = fgets (s, n, in);
  195.     char *cp;
  196.  
  197.     if (retval == NULL) return NULL;
  198.  
  199.     cp = s + strlen(s) - 1;
  200.  
  201.     while (cp >= s && (*cp == '\015' || *cp == '\012'))
  202.         *cp-- = '\0';
  203.  
  204.     return s;
  205. }
  206.  
  207. void parse_uri (request_rec *r, char *uri)
  208. {
  209.     /* If we ever want to do byte-ranges a la Netscape & Franks,
  210.      * this is the place to parse them; with proper support in
  211.      * rprintf and rputc, and the sub-request setup and finalizers
  212.      * here, it'll all just work, even for vile cases like
  213.      * inclusion of byte-ranges of the output of CGI scripts, with
  214.      * the client requesting only a byte-range of *that*!
  215.      *
  216.      * But for now...
  217.      */
  218.  
  219.     r->uri = getword (r->pool, &uri, '?');
  220.     if (*uri) r->args= uri;
  221.     else r->args = NULL;
  222. }
  223.  
  224. int read_request_line (request_rec *r)
  225. {
  226.     char l[HUGE_STRING_LEN];
  227.     char *ll = l, *uri;
  228.     conn_rec *conn = r->connection;
  229.     
  230.     l[0] = '\0';
  231.     if(!getline(l, HUGE_STRING_LEN, conn->request_in))
  232.         return 0;
  233.     if(!l[0]) 
  234.         return 0;
  235.  
  236.     r->the_request = pstrdup (r->pool, l);
  237.     r->method = getword(r->pool, &ll,' ');
  238.     uri = getword(r->pool, &ll,' ');
  239.     parse_uri (r, uri);
  240.     
  241.     r->assbackwards = (ll[0] == '\0');
  242.     r->protocol = ll[0] ? pstrdup (r->pool, ll) : "HTTP/0.9";
  243.     return 1;
  244. }
  245.  
  246. void get_mime_headers(request_rec *r)
  247. {
  248.     char w[MAX_STRING_LEN];
  249.     char *t;
  250.     conn_rec *c = r->connection;
  251.  
  252.     while(getline(w, MAX_STRING_LEN-1, c->request_in)) {
  253.         if(!w[0]) 
  254.             return;
  255.         if(!(t = strchr(w,':')))
  256.             continue;
  257.         *t++ = '\0';
  258.         while(isspace(*t)) ++t;
  259.  
  260.     table_merge (r->headers_in, w, t);
  261.     }
  262. }
  263.  
  264. request_rec *read_request (conn_rec *conn)
  265. {
  266.     request_rec *r = (request_rec *)pcalloc (conn->pool, sizeof(request_rec));
  267.   
  268.     r->connection = conn;
  269.     r->server = conn->server;
  270.     r->pool = conn->pool;
  271.  
  272.     r->headers_in = make_table (r->pool, 50);
  273.     r->subprocess_env = make_table (r->pool, 50);
  274.     r->headers_out = make_table (r->pool, 5);
  275.     r->err_headers_out = make_table (r->pool, 5);
  276.     r->notes = make_table (r->pool, 5);
  277.  
  278.     r->request_config = create_request_config (r->pool);
  279.     r->per_dir_config = r->server->lookup_defaults; /* For now. */
  280.  
  281.     r->bytes_sent = -1;
  282.     
  283.     r->status = 200;        /* Until further notice.
  284.                  * Only changed by die(), or (bletch!)
  285.                  * scan_script_header...
  286.                  */
  287.  
  288.     /* Get the request... */
  289.     
  290.     hard_timeout ("read", r);
  291.     if (!read_request_line (r)) return NULL;
  292.     if (!r->assbackwards) get_mime_headers(r);
  293.     kill_timeout (r);
  294.     
  295.     if(!strcmp(r->method, "HEAD")) {
  296.         r->header_only=1;
  297.     r->method_number = M_GET;
  298.     }
  299.     else if(!strcmp(r->method, "GET")) 
  300.     r->method_number = M_GET;
  301.     else if(!strcmp(r->method,"POST")) 
  302.         r->method_number = M_POST;
  303.     else if(!strcmp(r->method,"PUT")) 
  304.         r->method_number = M_PUT;
  305.     else if(!strcmp(r->method,"DELETE")) 
  306.         r->method_number = M_DELETE;
  307.     else 
  308.         r->method_number = M_INVALID; /* Will eventually croak. */
  309.  
  310.     return r;
  311. }
  312.  
  313. /*
  314.  * A couple of other functions which initialize some of the fields of
  315.  * a request structure, as appropriate for adjuncts of one kind or another
  316.  * to a request in progress.  Best here, rather than elsewhere, since
  317.  * *someone* has to set the protocol-specific fields...
  318.  */
  319.  
  320. void set_sub_req_protocol (request_rec *rnew, request_rec *r)
  321. {
  322.     rnew->assbackwards = 1;    /* Don't send headers from this. */
  323.     rnew->no_cache = 1;        /* Don't try to send USE_LOCAL_COPY for a
  324.                  * fragment.
  325.                  */
  326.     rnew->method = "GET"; rnew->method_number = M_GET;
  327.     rnew->protocol = "INCLUDED";
  328.  
  329.     rnew->status = 200;
  330.  
  331.     rnew->headers_in = r->headers_in;
  332.     rnew->subprocess_env = copy_table (rnew->pool, r->subprocess_env);
  333.     rnew->headers_out = make_table (rnew->pool, 5);
  334.     rnew->err_headers_out = make_table (rnew->pool, 5);
  335.     rnew->notes = make_table (rnew->pool, 5);
  336.     
  337.     rnew->main = r;
  338. }
  339.  
  340. void finalize_sub_req_protocol (request_rec *sub)
  341. {
  342.     sub->main->bytes_sent += sub->bytes_sent;
  343. } 
  344.  
  345. /* Support for the Basic authentication protocol.  
  346.  */
  347.  
  348. void note_basic_auth_failure(request_rec *r)
  349. {
  350.     table_set (r->err_headers_out, "WWW-Authenticate",
  351.            pstrcat(r->pool, "Basic realm=\"", auth_name(r), "\"", NULL));
  352. }
  353.  
  354.  
  355. int get_basic_auth_pw (request_rec *r, char **pw)
  356. {
  357.     char *auth_line = table_get (r->headers_in, "Authorization");
  358.     char *t;
  359.     
  360.     if(!(t = auth_type(r)) || strcasecmp(t, "Basic"))
  361.         return DECLINED;
  362.  
  363.     if (!auth_name (r)) {
  364.         log_reason ("need AuthName", r->uri, r);
  365.     return SERVER_ERROR;
  366.     }
  367.     
  368.     if(!auth_line) {
  369.         note_basic_auth_failure (r);
  370.     return AUTH_REQUIRED;
  371.     }
  372.  
  373.     if (strcmp(getword (r->pool, &auth_line, ' '), "Basic")) {
  374.         /* Client tried to authenticate using wrong auth scheme */
  375.         log_reason ("client used wrong authentication scheme", r->uri, r);
  376.         note_basic_auth_failure (r);
  377.     return AUTH_REQUIRED;
  378.     }
  379.  
  380.     t = uudecode (r->pool, auth_line);
  381.     r->connection->user = getword (r->pool, &t, ':');
  382.     r->connection->auth_type = "Basic";
  383.  
  384.     *pw = t;
  385.  
  386.     return OK;
  387. }
  388.  
  389. #define RESPONSE_CODE_LIST " 200 302 304 400 401 403 404 500 503 501 "
  390.  
  391. /* New Apache routine to map error responses into array indicies 
  392.  *  e.g.  400 -> 0,  500 -> 1,  502 -> 2 ...                     
  393.  * the indicies have no significance
  394.  */
  395.  
  396. char *status_lines[] = {
  397.    "200 OK",
  398.    "302 Found",
  399.    "304 Not Modified",
  400.    "400 Bad Request",
  401.    "401 Unauthorized",
  402.    "403 Forbidden",
  403.    "404 Not found",
  404.    "500 Server error",
  405.    "503 Out of resources",
  406.    "501 Not Implemented",
  407. }; 
  408.  
  409. char *response_titles[] = {
  410.    "200 OK",            /* Never actually sent, barring die(200,...) */
  411.    "Document moved",        /* 302 Redirect */
  412.    "304 Not Modified",        /* Never sent... 304 MUST be header only */
  413.    "Bad Request",
  414.    "Authorization Required",
  415.    "Forbidden",
  416.    "File Not found",
  417.    "Server Error",
  418.    "Out of resources",
  419.    "Method not implemented"
  420. };
  421.  
  422. int index_of_response(int err_no) { 
  423.    char *cptr, err_string[10];
  424.    static char *response_codes = RESPONSE_CODE_LIST;
  425.    int index_number;
  426.    
  427.    sprintf(err_string,"%3d",err_no);
  428.    
  429.    cptr = response_codes;
  430.    cptr++;
  431.    index_number = 0;
  432.    while (*cptr && strncmp(cptr, err_string, 3)) { 
  433.       cptr += 4;
  434.       index_number++;
  435.    }
  436.    if (!*cptr) return -1;
  437.    return index_number;
  438. }
  439.  
  440.  
  441. void basic_http_header (request_rec *r)
  442. {
  443.     FILE *fd = r->connection->client;
  444.     
  445.     if (r->assbackwards) return;
  446.     
  447.     if (!r->status_line)
  448.         r->status_line = status_lines[index_of_response(r->status)];
  449.     
  450.     fprintf(fd,"%s %s\015\012", SERVER_PROTOCOL, r->status_line);
  451.     fprintf(fd,"Date: %s\015\012", gm_timestr_822 (r->pool, time(NULL)));
  452.     fprintf(fd,"Server: %s\015\012",SERVER_VERSION);
  453. }
  454.  
  455. char *nuke_mime_parms (pool *p, char *content_type)
  456. {
  457.     /* How marvelous.  Arena doesn't *accept* "text/html; level=3"
  458.      * as a MIME type, so we have to strip off the parms.
  459.      */
  460.  
  461. #ifndef ARENA_BUG_WORKAROUND
  462.     return content_type;
  463. #else
  464.  
  465.     char *cp = strchr(content_type, ';');
  466.  
  467.     if (cp) {
  468.         content_type = pstrdup (p, content_type);
  469.     cp = strchr (content_type, ';');
  470.     
  471.         while (cp > content_type && isspace (cp[-1]))
  472.         --cp;
  473.     *cp = '\0';
  474.     }
  475.  
  476.     return content_type;
  477. #endif
  478. }
  479.  
  480. void send_http_header(request_rec *r)
  481. {
  482.     conn_rec *c = r->connection;
  483.     FILE *fd = c->client;
  484.  
  485.     array_header *hdrs_arr = table_elts (r->headers_out);
  486.     table_entry *hdrs = (table_entry *)hdrs_arr->elts;
  487.  
  488.     array_header *err_hdrs_arr = table_elts (r->err_headers_out);
  489.     table_entry *err_hdrs = (table_entry *)err_hdrs_arr->elts;
  490.     int i;
  491.     
  492.     core_dir_config *dir_conf =
  493.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module);
  494.     char *default_type = dir_conf->default_type;
  495.   
  496.     if (r->assbackwards) {
  497.     r->bytes_sent = 0;
  498.     return;
  499.     }
  500.     
  501.     basic_http_header (r);
  502.     
  503.     if (r->content_type)
  504.         fprintf (fd, "Content-type: %s\015\012",
  505.          nuke_mime_parms (r->pool, r->content_type));
  506.     else
  507.         fprintf (fd, "Content-type: %s\015\012", default_type);
  508.     
  509.     if (r->content_encoding)
  510.         fprintf (fd, "Content-encoding: %s\015\012", r->content_encoding);
  511.     
  512.     if (r->content_language)
  513.         fprintf (fd, "Content-language: %s\015\012", r->content_language);
  514.     
  515.     for (i = 0; i < hdrs_arr->nelts; ++i) {
  516.         if (!hdrs[i].key) continue;
  517.     fprintf (fd, "%s: %s\015\012", hdrs[i].key, hdrs[i].val);
  518.     }
  519.  
  520.     for (i = 0; i < err_hdrs_arr->nelts; ++i) {
  521.         if (!err_hdrs[i].key) continue;
  522.     fprintf (fd, "%s: %s\015\012", err_hdrs[i].key, err_hdrs[i].val);
  523.     }
  524.  
  525.     fputs("\015\012",fd);
  526.  
  527.     r->bytes_sent = 0;        /* Whatever follows is real body stuff... */
  528. }
  529.  
  530. long read_client_block (request_rec *r, char *buffer, int bufsiz)
  531. {
  532.     return fread (buffer, sizeof(char), bufsiz, r->connection->request_in);
  533. }
  534.  
  535. long send_fd(FILE *f, request_rec *r)
  536. {
  537.     char buf[IOBUFSIZE];
  538.     long total_bytes_sent;
  539.     register int n,o,w;
  540.     conn_rec *c = r->connection;
  541.     
  542.     total_bytes_sent = 0;
  543.     while (!r->connection->aborted) {
  544.         while ((n= fread(buf, sizeof(char), IOBUFSIZE, f)) < 1
  545.            && ferror(f) && errno == EINTR)
  546.         continue;
  547.     
  548.     if (n < 1) {
  549.             break;
  550.         }
  551.         o=0;
  552.         if (r->bytes_sent != -1) r->bytes_sent += n;
  553.     total_bytes_sent += n;
  554.     
  555.         while(n && !r->connection->aborted) {
  556.             w=fwrite(&buf[o],sizeof(char),n,c->client);
  557.         if (w)
  558.             reset_timeout(r); /* reset timeout after successfule write */
  559.             n-=w;
  560.             o+=w;
  561.         }
  562.     }
  563.     fflush(c->client);
  564.     
  565.     return total_bytes_sent;
  566. }
  567.  
  568. int rputc (int c, request_rec *r)
  569. {
  570.     if (r->connection->aborted) return EOF;
  571.     putc (c, r->connection->client);
  572.     ++r->bytes_sent;
  573.     return c;
  574. }
  575.  
  576. long rprintf (request_rec *r, char *fmt, ...)
  577. {
  578.     va_list args;
  579.     int retval;
  580.     
  581.     if (r->connection->aborted) return EOF;
  582.     
  583.     va_start (args, fmt);
  584.     retval = vfprintf (r->connection->client, fmt, args);
  585.     va_end (args);
  586.  
  587.     r->bytes_sent += retval;
  588.     return retval;
  589. }
  590.  
  591. void send_error_response (request_rec *r, int recursive_error)
  592. {
  593.     conn_rec *c = r->connection;
  594.     char *custom_response;
  595.     int status = r->status;
  596.     int idx = index_of_response (status);
  597.     char *location = table_get (r->headers_out, "Location");
  598.  
  599.     if (!r->assbackwards) {
  600.     int i;
  601.     table *err_hdrs_arr = r->err_headers_out;
  602.     table_entry *err_hdrs = (table_entry *)err_hdrs_arr->elts;
  603.   
  604.         basic_http_header (r);
  605.     
  606.     /* For conditional get's which didn't send anything, *don't*
  607.      * send a bogus content-type, or any body --- but must still
  608.      * terminate header.
  609.      */
  610.     
  611.     if (status == USE_LOCAL_COPY) {
  612.         fprintf (c->client, "\015\012");
  613.         return;
  614.     }
  615.     
  616.     if (status == REDIRECT)
  617.         fprintf (c->client, "Location: %s\015\012", location);
  618.     
  619.     for (i = 0; i < err_hdrs_arr->nelts; ++i) {
  620.         if (!err_hdrs[i].key) continue;
  621.         fprintf (c->client, "%s: %s\015\012",
  622.              err_hdrs[i].key, err_hdrs[i].val);
  623.     }
  624.  
  625.     fprintf(c->client, "Content-type: text/html\015\012\015\012");
  626.     }
  627.  
  628.     if (r->header_only) return;
  629.     
  630.     if ((custom_response = response_code_string (r, idx)))
  631.         fputs (custom_response, c->client);
  632.     else {
  633.     char *title = response_titles[idx];
  634.     FILE *fd = c->client;
  635.     
  636.         fprintf(fd,"<HEAD><TITLE>%s</TITLE></HEAD>%c",title,LF);
  637.     fprintf(fd,"<BODY><H1>%s</H1>%c",title,LF);
  638.     
  639.         switch (r->status) {
  640.     case REDIRECT:
  641.         fprintf (fd,"The document has moved <A HREF=\"%s\">here</A>.<P>\n",
  642.              escape_html(r->pool, location));
  643.         break;
  644.     case AUTH_REQUIRED:
  645.         fprintf (fd, "This server could not verify that you%c", LF);
  646.         fprintf (fd, "are authorized to access the document you%c", LF);
  647.         fprintf (fd, "requested.  Either you supplied the wrong%c", LF);
  648.         fprintf (fd, "credentials (e.g., bad password), or your%c", LF);
  649.         fprintf (fd, "browser doesn't understand how to supply%c", LF);
  650.         fprintf (fd, "the credentials required.<P>%c", LF);
  651.         break;
  652.     case BAD_REQUEST:
  653.         fprintf (fd, "Your browser sent a query that%c", LF);
  654.         fprintf (fd, "this server could not understand.<P>%c", LF);
  655.         break;
  656.     case FORBIDDEN:
  657.         fprintf (fd, "You don't have permission to access %s\n",
  658.              escape_html(r->pool, r->uri));
  659.         fprintf (fd, "on this server.<P>%c", LF);
  660.         break;
  661.     case NOT_FOUND:
  662.         fprintf (fd,
  663.              "The requested URL %s was not found on this server.<P>\n",
  664.              escape_html(r->pool, r->uri));
  665.         break;
  666.     case SERVER_ERROR:
  667.         fprintf(fd,"The server encountered an internal error or%c",LF);
  668.         fprintf(fd,"misconfiguration and was unable to complete%c",LF);
  669.         fprintf(fd,"your request.<P>%c",LF);
  670.         fprintf(fd,"Please contact the server administrator,%c",LF);
  671.         fprintf(fd," %s ", escape_html(r->pool, r->server->server_admin));
  672.         fprintf(fd,"and inform them of the time the error occurred,%c",LF);
  673.         fprintf(fd,"and anything you might have done that may have%c",LF);
  674.         fprintf(fd,"caused the error.<P>%c",LF);
  675.         break;
  676.     case NOT_IMPLEMENTED:
  677.         fprintf(fd,"%s to %s not supported.<P>\n",
  678.             escape_html(r->pool, r->method),
  679.             escape_html(r->pool, r->uri));
  680.         break;
  681.     }
  682.  
  683.         if (recursive_error) {
  684.         fprintf (fd, "Additionally, an error of type %d was encountered%c",
  685.              recursive_error, LF);
  686.         fprintf (fd, "while trying to use an ErrorDocument to%c", LF);
  687.         fprintf (fd, "handle the request.%c", LF);
  688.     }
  689.     fprintf (fd, "</BODY>%c", LF);
  690.     }
  691.         
  692. }
  693.  
  694. /* Finally, this... it's here to support nph- scripts
  695.  * Now what ever are we going to do about them when HTTP-NG packetization
  696.  * comes along?
  697.  */
  698.  
  699. void client_to_stdout (conn_rec *c)
  700. {
  701.   fflush (c->client);
  702.   dup2 (fileno (c->client), STDOUT_FILENO);
  703. }
  704.