home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1999 April / PCO0499.ISO / filesbbs / os2 / apach134.arj / APACH134.ZIP / src / main / http_core.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-01-07  |  84.5 KB  |  2,936 lines
  1. /* ====================================================================
  2.  * Copyright (c) 1995-1999 The Apache Group.  All rights reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer. 
  10.  *
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in
  13.  *    the documentation and/or other materials provided with the
  14.  *    distribution.
  15.  *
  16.  * 3. All advertising materials mentioning features or use of this
  17.  *    software must display the following acknowledgment:
  18.  *    "This product includes software developed by the Apache Group
  19.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  20.  *
  21.  * 4. The names "Apache Server" and "Apache Group" must not be used to
  22.  *    endorse or promote products derived from this software without
  23.  *    prior written permission. For written permission, please contact
  24.  *    apache@apache.org.
  25.  *
  26.  * 5. Products derived from this software may not be called "Apache"
  27.  *    nor may "Apache" appear in their names without prior written
  28.  *    permission of the Apache Group.
  29.  *
  30.  * 6. Redistributions of any form whatsoever must retain the following
  31.  *    acknowledgment:
  32.  *    "This product includes software developed by the Apache Group
  33.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
  36.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  37.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  38.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  41.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  42.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  43.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  44.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  45.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  46.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Group and was originally based
  51.  * on public domain software written at the National Center for
  52.  * Supercomputing Applications, University of Illinois, Urbana-Champaign.
  53.  * For more information on the Apache Group and the Apache HTTP server
  54.  * project, please see <http://www.apache.org/>.
  55.  *
  56.  */
  57.  
  58. #define CORE_PRIVATE
  59. #include "httpd.h"
  60. #include "http_config.h"
  61. #include "http_core.h"
  62. #include "http_protocol.h"    /* For index_of_response().  Grump. */
  63. #include "http_request.h"
  64. #include "http_conf_globals.h"
  65. #include "http_vhost.h"
  66. #include "http_main.h"        /* For the default_handler below... */
  67. #include "http_log.h"
  68. #include "rfc1413.h"
  69. #include "util_md5.h"
  70. #include "scoreboard.h"
  71. #include "fnmatch.h"
  72.  
  73. #ifdef USE_MMAP_FILES
  74. #include <sys/mman.h>
  75.  
  76. /* mmap support for static files based on ideas from John Heidemann's
  77.  * patch against 1.0.5.  See
  78.  * <http://www.isi.edu/~johnh/SOFTWARE/APACHE/index.html>.
  79.  */
  80.  
  81. /* Files have to be at least this big before they're mmap()d.  This is to deal
  82.  * with systems where the expense of doing an mmap() and an munmap() outweighs
  83.  * the benefit for small files.  It shouldn't be set lower than 1.
  84.  */
  85. #ifndef MMAP_THRESHOLD
  86. #ifdef SUNOS4
  87. #define MMAP_THRESHOLD        (8*1024)
  88. #else
  89. #define MMAP_THRESHOLD        1
  90. #endif
  91. #endif
  92. #endif
  93.  
  94. /* Server core module... This module provides support for really basic
  95.  * server operations, including options and commands which control the
  96.  * operation of other modules.  Consider this the bureaucracy module.
  97.  *
  98.  * The core module also defines handlers, etc., do handle just enough
  99.  * to allow a server with the core module ONLY to actually serve documents
  100.  * (though it slaps DefaultType on all of 'em); this was useful in testing,
  101.  * but may not be worth preserving.
  102.  *
  103.  * This file could almost be mod_core.c, except for the stuff which affects
  104.  * the http_conf_globals.
  105.  */
  106.  
  107. static void *create_core_dir_config(pool *a, char *dir)
  108. {
  109.     core_dir_config *conf;
  110.  
  111.     conf = (core_dir_config *)ap_pcalloc(a, sizeof(core_dir_config));
  112.     if (!dir || dir[strlen(dir) - 1] == '/') {
  113.         conf->d = dir;
  114.     }
  115.     else if (strncmp(dir, "proxy:", 6) == 0) {
  116.         conf->d = ap_pstrdup(a, dir);
  117.     }
  118.     else {
  119.         conf->d = ap_pstrcat(a, dir, "/", NULL);
  120.     }
  121.     conf->d_is_fnmatch = conf->d ? (ap_is_fnmatch(conf->d) != 0) : 0;
  122.     conf->d_components = conf->d ? ap_count_dirs(conf->d) : 0;
  123.  
  124.     conf->opts = dir ? OPT_UNSET : OPT_UNSET|OPT_ALL;
  125.     conf->opts_add = conf->opts_remove = OPT_NONE;
  126.     conf->override = dir ? OR_UNSET : OR_UNSET|OR_ALL;
  127.  
  128.     conf->content_md5 = 2;
  129.  
  130.     conf->use_canonical_name = 1 | 2;    /* 2 = unset, default on */
  131.  
  132.     conf->hostname_lookups = HOSTNAME_LOOKUP_UNSET;
  133.     conf->do_rfc1413 = DEFAULT_RFC1413 | 2; /* set bit 1 to indicate default */
  134.     conf->satisfy = SATISFY_NOSPEC;
  135.  
  136. #ifdef RLIMIT_CPU
  137.     conf->limit_cpu = NULL;
  138. #endif
  139. #if defined(RLIMIT_DATA) || defined(RLIMIT_VMEM) || defined(RLIMIT_AS)
  140.     conf->limit_mem = NULL;
  141. #endif
  142. #ifdef RLIMIT_NPROC
  143.     conf->limit_nproc = NULL;
  144. #endif
  145.  
  146.     conf->limit_req_body = 0;
  147.     conf->sec = ap_make_array(a, 2, sizeof(void *));
  148.  
  149.     return (void *)conf;
  150. }
  151.  
  152. static void *merge_core_dir_configs(pool *a, void *basev, void *newv)
  153. {
  154.     core_dir_config *base = (core_dir_config *)basev;
  155.     core_dir_config *new = (core_dir_config *)newv;
  156.     core_dir_config *conf;
  157.     int i;
  158.   
  159.     conf = (core_dir_config *)ap_palloc(a, sizeof(core_dir_config));
  160.     memcpy((char *)conf, (const char *)base, sizeof(core_dir_config));
  161.     if (base->response_code_strings) {
  162.     conf->response_code_strings =
  163.         ap_palloc(a, sizeof(*conf->response_code_strings)
  164.               * RESPONSE_CODES);
  165.     memcpy(conf->response_code_strings, base->response_code_strings,
  166.            sizeof(*conf->response_code_strings) * RESPONSE_CODES);
  167.     }
  168.     
  169.     conf->d = new->d;
  170.     conf->d_is_fnmatch = new->d_is_fnmatch;
  171.     conf->d_components = new->d_components;
  172.     conf->r = new->r;
  173.     
  174.     if (new->opts & OPT_UNSET) {
  175.     /* there was no explicit setting of new->opts, so we merge
  176.      * preserve the invariant (opts_add & opts_remove) == 0
  177.      */
  178.     conf->opts_add = (conf->opts_add & ~new->opts_remove) | new->opts_add;
  179.     conf->opts_remove = (conf->opts_remove & ~new->opts_add)
  180.                         | new->opts_remove;
  181.     conf->opts = (conf->opts & ~conf->opts_remove) | conf->opts_add;
  182.         if ((base->opts & OPT_INCNOEXEC) && (new->opts & OPT_INCLUDES)) {
  183.             conf->opts = (conf->opts & ~OPT_INCNOEXEC) | OPT_INCLUDES;
  184.     }
  185.     }
  186.     else {
  187.     /* otherwise we just copy, because an explicit opts setting
  188.      * overrides all earlier +/- modifiers
  189.      */
  190.     conf->opts = new->opts;
  191.     conf->opts_add = new->opts_add;
  192.     conf->opts_remove = new->opts_remove;
  193.     }
  194.  
  195.     if (!(new->override & OR_UNSET)) {
  196.         conf->override = new->override;
  197.     }
  198.     if (new->ap_default_type) {
  199.         conf->ap_default_type = new->ap_default_type;
  200.     }
  201.     
  202.     if (new->ap_auth_type) {
  203.         conf->ap_auth_type = new->ap_auth_type;
  204.     }
  205.     if (new->ap_auth_name) {
  206.         conf->ap_auth_name = new->ap_auth_name;
  207.     }
  208.     if (new->ap_requires) {
  209.         conf->ap_requires = new->ap_requires;
  210.     }
  211.  
  212.     if (new->response_code_strings) {
  213.     if (conf->response_code_strings == NULL) {
  214.         conf->response_code_strings = ap_palloc(a,
  215.         sizeof(*conf->response_code_strings) * RESPONSE_CODES);
  216.         memcpy(conf->response_code_strings, new->response_code_strings,
  217.            sizeof(*conf->response_code_strings) * RESPONSE_CODES);
  218.     }
  219.     else {
  220.         for (i = 0; i < RESPONSE_CODES; ++i) {
  221.             if (new->response_code_strings[i] != NULL) {
  222.             conf->response_code_strings[i]
  223.                 = new->response_code_strings[i];
  224.         }
  225.         }
  226.     }
  227.     }
  228.     if (new->hostname_lookups != HOSTNAME_LOOKUP_UNSET) {
  229.     conf->hostname_lookups = new->hostname_lookups;
  230.     }
  231.     if ((new->do_rfc1413 & 2) == 0) {
  232.         conf->do_rfc1413 = new->do_rfc1413;
  233.     }
  234.     if ((new->content_md5 & 2) == 0) {
  235.         conf->content_md5 = new->content_md5;
  236.     }
  237.     if ((new->use_canonical_name & 2) == 0) {
  238.     conf->use_canonical_name = new->use_canonical_name;
  239.     }
  240.  
  241. #ifdef RLIMIT_CPU
  242.     if (new->limit_cpu) {
  243.         conf->limit_cpu = new->limit_cpu;
  244.     }
  245. #endif
  246. #if defined(RLIMIT_DATA) || defined(RLIMIT_VMEM) || defined(RLIMIT_AS)
  247.     if (new->limit_mem) {
  248.         conf->limit_mem = new->limit_mem;
  249.     }
  250. #endif
  251. #ifdef RLIMIT_NPROC    
  252.     if (new->limit_nproc) {
  253.         conf->limit_nproc = new->limit_nproc;
  254.     }
  255. #endif
  256.  
  257.     if (new->limit_req_body) {
  258.         conf->limit_req_body = new->limit_req_body;
  259.     }
  260.     conf->sec = ap_append_arrays(a, base->sec, new->sec);
  261.  
  262.     if (new->satisfy != SATISFY_NOSPEC) {
  263.         conf->satisfy = new->satisfy;
  264.     }
  265.     return (void*)conf;
  266. }
  267.  
  268. static void *create_core_server_config(pool *a, server_rec *s)
  269. {
  270.     core_server_config *conf;
  271.     int is_virtual = s->is_virtual;
  272.   
  273.     conf = (core_server_config *)ap_pcalloc(a, sizeof(core_server_config));
  274. #ifdef GPROF
  275.     conf->gprof_dir = NULL;
  276. #endif
  277.     conf->access_name = is_virtual ? NULL : DEFAULT_ACCESS_FNAME;
  278.     conf->ap_document_root = is_virtual ? NULL : DOCUMENT_LOCATION;
  279.     conf->sec = ap_make_array(a, 40, sizeof(void *));
  280.     conf->sec_url = ap_make_array(a, 40, sizeof(void *));
  281.     
  282.     return (void *)conf;
  283. }
  284.  
  285. static void *merge_core_server_configs(pool *p, void *basev, void *virtv)
  286. {
  287.     core_server_config *base = (core_server_config *)basev;
  288.     core_server_config *virt = (core_server_config *)virtv;
  289.     core_server_config *conf;
  290.  
  291.     conf = (core_server_config *)ap_pcalloc(p, sizeof(core_server_config));
  292.     *conf = *virt;
  293.     if (!conf->access_name) {
  294.         conf->access_name = base->access_name;
  295.     }
  296.     if (!conf->ap_document_root) {
  297.         conf->ap_document_root = base->ap_document_root;
  298.     }
  299.     conf->sec = ap_append_arrays(p, base->sec, virt->sec);
  300.     conf->sec_url = ap_append_arrays(p, base->sec_url, virt->sec_url);
  301.  
  302.     return conf;
  303. }
  304.  
  305. /* Add per-directory configuration entry (for <directory> section);
  306.  * these are part of the core server config.
  307.  */
  308.  
  309. CORE_EXPORT(void) ap_add_per_dir_conf(server_rec *s, void *dir_config)
  310. {
  311.     core_server_config *sconf = ap_get_module_config(s->module_config,
  312.                              &core_module);
  313.     void **new_space = (void **)ap_push_array(sconf->sec);
  314.     
  315.     *new_space = dir_config;
  316. }
  317.  
  318. CORE_EXPORT(void) ap_add_per_url_conf(server_rec *s, void *url_config)
  319. {
  320.     core_server_config *sconf = ap_get_module_config(s->module_config,
  321.                              &core_module);
  322.     void **new_space = (void **)ap_push_array(sconf->sec_url);
  323.     
  324.     *new_space = url_config;
  325. }
  326.  
  327. static void add_file_conf(core_dir_config *conf, void *url_config)
  328. {
  329.     void **new_space = (void **)ap_push_array(conf->sec);
  330.     
  331.     *new_space = url_config;
  332. }
  333.  
  334. /* core_reorder_directories reorders the directory sections such that the
  335.  * 1-component sections come first, then the 2-component, and so on, finally
  336.  * followed by the "special" sections.  A section is "special" if it's a regex,
  337.  * or if it doesn't start with / -- consider proxy: matching.  All movements
  338.  * are in-order to preserve the ordering of the sections from the config files.
  339.  * See directory_walk().
  340.  */
  341.  
  342. #if defined(OS2) || defined(WIN32)
  343. #define IS_SPECIAL(entry_core)    \
  344.     ((entry_core)->r != NULL \
  345.     || ((entry_core)->d[0] != '/' && (entry_core)->d[1] != ':'))
  346. #else
  347. #define IS_SPECIAL(entry_core)    \
  348.     ((entry_core)->r != NULL || (entry_core)->d[0] != '/')
  349. #endif
  350.  
  351. /* We need to do a stable sort, qsort isn't stable.  So to make it stable
  352.  * we'll be maintaining the original index into the list, and using it
  353.  * as the minor key during sorting.  The major key is the number of
  354.  * components (where a "special" section has infinite components).
  355.  */
  356. struct reorder_sort_rec {
  357.     void *elt;
  358.     int orig_index;
  359. };
  360.  
  361. static int reorder_sorter(const void *va, const void *vb)
  362. {
  363.     const struct reorder_sort_rec *a = va;
  364.     const struct reorder_sort_rec *b = vb;
  365.     core_dir_config *core_a;
  366.     core_dir_config *core_b;
  367.  
  368.     core_a = (core_dir_config *)ap_get_module_config(a->elt, &core_module);
  369.     core_b = (core_dir_config *)ap_get_module_config(b->elt, &core_module);
  370.     if (IS_SPECIAL(core_a)) {
  371.     if (!IS_SPECIAL(core_b)) {
  372.         return 1;
  373.     }
  374.     }
  375.     else if (IS_SPECIAL(core_b)) {
  376.     return -1;
  377.     }
  378.     else {
  379.     /* we know they're both not special */
  380.     if (core_a->d_components < core_b->d_components) {
  381.         return -1;
  382.     }
  383.     else if (core_a->d_components > core_b->d_components) {
  384.         return 1;
  385.     }
  386.     }
  387.     /* Either they're both special, or they're both not special and have the
  388.      * same number of components.  In any event, we now have to compare
  389.      * the minor key. */
  390.     return a->orig_index - b->orig_index;
  391. }
  392.  
  393. void ap_core_reorder_directories(pool *p, server_rec *s)
  394. {
  395.     core_server_config *sconf;
  396.     array_header *sec;
  397.     struct reorder_sort_rec *sortbin;
  398.     int nelts;
  399.     void **elts;
  400.     int i;
  401.  
  402.     /* XXX: we are about to waste some ram ... we will build a new array
  403.      * and we need some scratch space to do it.  The old array and the
  404.      * scratch space are never freed.
  405.      */
  406.     sconf = ap_get_module_config(s->module_config, &core_module);
  407.     sec = sconf->sec;
  408.     nelts = sec->nelts;
  409.     elts = (void **)sec->elts;
  410.  
  411.     /* build our sorting space */
  412.     sortbin = ap_palloc(p, sec->nelts * sizeof(*sortbin));
  413.     for (i = 0; i < nelts; ++i) {
  414.     sortbin[i].orig_index = i;
  415.     sortbin[i].elt = elts[i];
  416.     }
  417.  
  418.     qsort(sortbin, nelts, sizeof(*sortbin), reorder_sorter);
  419.  
  420.     /* and now build a new array */
  421.     /* XXX: uh I don't see why we can't reuse the old array, what
  422.      * was I thinking? -djg */
  423.     sec = ap_make_array(p, nelts, sizeof(void *));
  424.     for (i = 0; i < nelts; ++i) {
  425.     *(void **)ap_push_array(sec) = sortbin[i].elt;
  426.     }
  427.  
  428.     sconf->sec = sec;
  429. }
  430.  
  431. /*****************************************************************
  432.  *
  433.  * There are some elements of the core config structures in which
  434.  * other modules have a legitimate interest (this is ugly, but necessary
  435.  * to preserve NCSA back-compatibility).  So, we have a bunch of accessors
  436.  * here...
  437.  */
  438.  
  439. API_EXPORT(int) ap_allow_options(request_rec *r)
  440. {
  441.     core_dir_config *conf = 
  442.       (core_dir_config *)ap_get_module_config(r->per_dir_config, &core_module); 
  443.  
  444.     return conf->opts; 
  445. } 
  446.  
  447. API_EXPORT(int) ap_allow_overrides(request_rec *r) 
  448. { 
  449.     core_dir_config *conf;
  450.     conf = (core_dir_config *)ap_get_module_config(r->per_dir_config,
  451.                            &core_module); 
  452.  
  453.     return conf->override; 
  454. } 
  455.  
  456. API_EXPORT(const char *) ap_auth_type(request_rec *r)
  457. {
  458.     core_dir_config *conf;
  459.  
  460.     conf = (core_dir_config *)ap_get_module_config(r->per_dir_config,
  461.                            &core_module); 
  462.     return conf->ap_auth_type;
  463. }
  464.  
  465. API_EXPORT(const char *) ap_auth_name(request_rec *r)
  466. {
  467.     core_dir_config *conf;
  468.  
  469.     conf = (core_dir_config *)ap_get_module_config(r->per_dir_config,
  470.                            &core_module); 
  471.     return conf->ap_auth_name;
  472. }
  473.  
  474. API_EXPORT(const char *) ap_default_type(request_rec *r)
  475. {
  476.     core_dir_config *conf;
  477.  
  478.     conf = (core_dir_config *)ap_get_module_config(r->per_dir_config,
  479.                            &core_module); 
  480.     return conf->ap_default_type 
  481.                ? conf->ap_default_type 
  482.                : DEFAULT_CONTENT_TYPE;
  483. }
  484.  
  485. API_EXPORT(const char *) ap_document_root(request_rec *r) /* Don't use this! */
  486. {
  487.     core_server_config *conf;
  488.  
  489.     conf = (core_server_config *)ap_get_module_config(r->server->module_config,
  490.                               &core_module); 
  491.     return conf->ap_document_root;
  492. }
  493.  
  494. API_EXPORT(const array_header *) ap_requires(request_rec *r)
  495. {
  496.     core_dir_config *conf;
  497.  
  498.     conf = (core_dir_config *)ap_get_module_config(r->per_dir_config,
  499.                            &core_module); 
  500.     return conf->ap_requires;
  501. }
  502.  
  503. API_EXPORT(int) ap_satisfies(request_rec *r)
  504. {
  505.     core_dir_config *conf;
  506.  
  507.     conf = (core_dir_config *)ap_get_module_config(r->per_dir_config,
  508.                            &core_module);
  509.  
  510.     return conf->satisfy;
  511. }
  512.  
  513. /* Should probably just get rid of this... the only code that cares is
  514.  * part of the core anyway (and in fact, it isn't publicised to other
  515.  * modules).
  516.  */
  517.  
  518. char *ap_response_code_string(request_rec *r, int error_index)
  519. {
  520.     core_dir_config *conf;
  521.  
  522.     conf = (core_dir_config *)ap_get_module_config(r->per_dir_config,
  523.                            &core_module); 
  524.  
  525.     if (conf->response_code_strings == NULL) {
  526.     return NULL;
  527.     }
  528.     return conf->response_code_strings[error_index];
  529. }
  530.  
  531.  
  532. /* Code from Harald Hanche-Olsen <hanche@imf.unit.no> */
  533. static ap_inline void do_double_reverse (conn_rec *conn)
  534. {
  535.     struct hostent *hptr;
  536.  
  537.     if (conn->double_reverse) {
  538.     /* already done */
  539.     return;
  540.     }
  541.     if (conn->remote_host == NULL || conn->remote_host[0] == '\0') {
  542.     /* single reverse failed, so don't bother */
  543.     conn->double_reverse = -1;
  544.     return;
  545.     }
  546.     hptr = gethostbyname(conn->remote_host);
  547.     if (hptr) {
  548.     char **haddr;
  549.  
  550.     for (haddr = hptr->h_addr_list; *haddr; haddr++) {
  551.         if (((struct in_addr *)(*haddr))->s_addr
  552.         == conn->remote_addr.sin_addr.s_addr) {
  553.         conn->double_reverse = 1;
  554.         return;
  555.         }
  556.     }
  557.     }
  558.     conn->double_reverse = -1;
  559. }
  560.  
  561. API_EXPORT(const char *) ap_get_remote_host(conn_rec *conn, void *dir_config,
  562.                         int type)
  563. {
  564.     struct in_addr *iaddr;
  565.     struct hostent *hptr;
  566.     int hostname_lookups;
  567.     int old_stat = SERVER_DEAD;    /* we shouldn't ever be in this state */
  568.  
  569.     /* If we haven't checked the host name, and we want to */
  570.     if (dir_config) {
  571.     hostname_lookups =
  572.         ((core_dir_config *)ap_get_module_config(dir_config, &core_module))
  573.         ->hostname_lookups;
  574.     if (hostname_lookups == HOSTNAME_LOOKUP_UNSET) {
  575.         hostname_lookups = HOSTNAME_LOOKUP_OFF;
  576.     }
  577.     }
  578.     else {
  579.     /* the default */
  580.     hostname_lookups = HOSTNAME_LOOKUP_OFF;
  581.     }
  582.  
  583.     if (type != REMOTE_NOLOOKUP
  584.     && conn->remote_host == NULL
  585.     && (type == REMOTE_DOUBLE_REV
  586.         || hostname_lookups != HOSTNAME_LOOKUP_OFF)) {
  587.     old_stat = ap_update_child_status(conn->child_num, SERVER_BUSY_DNS,
  588.                       (request_rec*)NULL);
  589.     iaddr = &(conn->remote_addr.sin_addr);
  590.     hptr = gethostbyaddr((char *)iaddr, sizeof(struct in_addr), AF_INET);
  591.     if (hptr != NULL) {
  592.         conn->remote_host = ap_pstrdup(conn->pool, (void *)hptr->h_name);
  593.         ap_str_tolower(conn->remote_host);
  594.        
  595.         if (hostname_lookups == HOSTNAME_LOOKUP_DOUBLE) {
  596.         do_double_reverse(conn);
  597.         if (conn->double_reverse != 1) {
  598.             conn->remote_host = NULL;
  599.         }
  600.         }
  601.     }
  602.     /* if failed, set it to the NULL string to indicate error */
  603.     if (conn->remote_host == NULL) {
  604.         conn->remote_host = "";
  605.     }
  606.     }
  607.     if (type == REMOTE_DOUBLE_REV) {
  608.     do_double_reverse(conn);
  609.     if (conn->double_reverse == -1) {
  610.         return NULL;
  611.     }
  612.     }
  613.     if (old_stat != SERVER_DEAD) {
  614.     (void)ap_update_child_status(conn->child_num, old_stat,
  615.                      (request_rec*)NULL);
  616.     }
  617.  
  618. /*
  619.  * Return the desired information; either the remote DNS name, if found,
  620.  * or either NULL (if the hostname was requested) or the IP address
  621.  * (if any identifier was requested).
  622.  */
  623.     if (conn->remote_host != NULL && conn->remote_host[0] != '\0') {
  624.     return conn->remote_host;
  625.     }
  626.     else {
  627.     if (type == REMOTE_HOST || type == REMOTE_DOUBLE_REV) {
  628.         return NULL;
  629.     }
  630.     else {
  631.         return conn->remote_ip;
  632.     }
  633.     }
  634. }
  635.  
  636. API_EXPORT(const char *) ap_get_remote_logname(request_rec *r)
  637. {
  638.     core_dir_config *dir_conf;
  639.  
  640.     if (r->connection->remote_logname != NULL) {
  641.     return r->connection->remote_logname;
  642.     }
  643.  
  644. /* If we haven't checked the identity, and we want to */
  645.     dir_conf = (core_dir_config *)ap_get_module_config(r->per_dir_config,
  646.                                &core_module);
  647.  
  648.     if (dir_conf->do_rfc1413 & 1) {
  649.     return ap_rfc1413(r->connection, r->server);
  650.     }
  651.     else {
  652.     return NULL;
  653.     }
  654. }
  655.  
  656. /* There are two options regarding what the "name" of a server is.  The
  657.  * "canonical" name as defined by ServerName and Port, or the "client's
  658.  * name" as supplied by a possible Host: header or full URI.  We never
  659.  * trust the port passed in the client's headers, we always use the
  660.  * port of the actual socket.
  661.  */
  662. API_EXPORT(const char *) ap_get_server_name(const request_rec *r)
  663. {
  664.     core_dir_config *d;
  665.  
  666.     d = (core_dir_config *)ap_get_module_config(r->per_dir_config,
  667.                         &core_module);
  668.     if (d->use_canonical_name & 1) {
  669.     return r->server->server_hostname;
  670.     }
  671.     return r->hostname ? r->hostname : r->server->server_hostname;
  672. }
  673.  
  674. API_EXPORT(unsigned) ap_get_server_port(const request_rec *r)
  675. {
  676.     unsigned port;
  677.     core_dir_config *d =
  678.       (core_dir_config *)ap_get_module_config(r->per_dir_config, &core_module);
  679.     
  680.     port = r->server->port ? r->server->port : ap_default_port(r);
  681.  
  682.     if (d->use_canonical_name & 1) {
  683.     return port;
  684.     }
  685.     return r->hostname ? ntohs(r->connection->local_addr.sin_port)
  686.                : port;
  687. }
  688.  
  689. API_EXPORT(char *) ap_construct_url(pool *p, const char *uri,
  690.                     const request_rec *r)
  691. {
  692.     unsigned port;
  693.     const char *host;
  694.     core_dir_config *d =
  695.       (core_dir_config *)ap_get_module_config(r->per_dir_config, &core_module);
  696.  
  697.     if (d->use_canonical_name & 1) {
  698.     port = r->server->port ? r->server->port : ap_default_port(r);
  699.     host = r->server->server_hostname;
  700.     }
  701.     else {
  702.         if (r->hostname) {
  703.             port = ntohs(r->connection->local_addr.sin_port);
  704.     }
  705.         else if (r->server->port) {
  706.             port = r->server->port;
  707.     }
  708.         else {
  709.             port = ap_default_port(r);
  710.     }
  711.  
  712.     host = r->hostname ? r->hostname : r->server->server_hostname;
  713.     }
  714.     if (ap_is_default_port(port, r)) {
  715.     return ap_pstrcat(p, ap_http_method(r), "://", host, uri, NULL);
  716.     }
  717.     return ap_psprintf(p, "%s://%s:%u%s", ap_http_method(r), host, port, uri);
  718. }
  719.  
  720. API_EXPORT(unsigned long) ap_get_limit_req_body(const request_rec *r)
  721. {
  722.     core_dir_config *d =
  723.       (core_dir_config *)ap_get_module_config(r->per_dir_config, &core_module);
  724.     
  725.     return d->limit_req_body;
  726. }
  727.  
  728. /*****************************************************************
  729.  *
  730.  * Commands... this module handles almost all of the NCSA httpd.conf
  731.  * commands, but most of the old srm.conf is in the the modules.
  732.  */
  733.  
  734. static const char end_directory_section[] = "</Directory>";
  735. static const char end_directorymatch_section[] = "</DirectoryMatch>";
  736. static const char end_location_section[] = "</Location>";
  737. static const char end_locationmatch_section[] = "</LocationMatch>";
  738. static const char end_files_section[] = "</Files>";
  739. static const char end_filesmatch_section[] = "</FilesMatch>";
  740. static const char end_virtualhost_section[] = "</VirtualHost>";
  741. static const char end_ifmodule_section[] = "</IfModule>";
  742. static const char end_ifdefine_section[] = "</IfDefine>";
  743.  
  744.  
  745. API_EXPORT(const char *) ap_check_cmd_context(cmd_parms *cmd,
  746.                           unsigned forbidden)
  747. {
  748.     const char *gt = (cmd->cmd->name[0] == '<'
  749.               && cmd->cmd->name[strlen(cmd->cmd->name)-1] != '>')
  750.                          ? ">" : "";
  751.  
  752.     if ((forbidden & NOT_IN_VIRTUALHOST) && cmd->server->is_virtual) {
  753.     return ap_pstrcat(cmd->pool, cmd->cmd->name, gt,
  754.               " cannot occur within <VirtualHost> section", NULL);
  755.     }
  756.  
  757.     if ((forbidden & NOT_IN_LIMIT) && cmd->limited != -1) {
  758.     return ap_pstrcat(cmd->pool, cmd->cmd->name, gt,
  759.               " cannot occur within <Limit> section", NULL);
  760.     }
  761.  
  762.     if ((forbidden & NOT_IN_DIR_LOC_FILE) == NOT_IN_DIR_LOC_FILE
  763.     && cmd->path != NULL) {
  764.     return ap_pstrcat(cmd->pool, cmd->cmd->name, gt,
  765.               " cannot occur within <Directory/Location/Files> "
  766.               "section", NULL);
  767.     }
  768.     
  769.     if (((forbidden & NOT_IN_DIRECTORY)
  770.      && (cmd->end_token == end_directory_section
  771.          || cmd->end_token == end_directorymatch_section)) 
  772.     || ((forbidden & NOT_IN_LOCATION)
  773.         && (cmd->end_token == end_location_section
  774.         || cmd->end_token == end_locationmatch_section)) 
  775.     || ((forbidden & NOT_IN_FILES)
  776.         && (cmd->end_token == end_files_section
  777.         || cmd->end_token == end_filesmatch_section))) {
  778.     return ap_pstrcat(cmd->pool, cmd->cmd->name, gt,
  779.               " cannot occur within <", cmd->end_token+2,
  780.               " section", NULL);
  781.     }
  782.  
  783.     return NULL;
  784. }
  785.  
  786. static const char *set_access_name(cmd_parms *cmd, void *dummy, char *arg)
  787. {
  788.     void *sconf = cmd->server->module_config;
  789.     core_server_config *conf = ap_get_module_config(sconf, &core_module);
  790.  
  791.     const char *err = ap_check_cmd_context(cmd,
  792.                        NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  793.     if (err != NULL) {
  794.         return err;
  795.     }
  796.  
  797.     conf->access_name = ap_pstrdup(cmd->pool, arg);
  798.     return NULL;
  799. }
  800.  
  801. #ifdef GPROF
  802. static const char *set_gprof_dir(cmd_parms *cmd, void *dummy, char *arg)
  803. {
  804.     void *sconf = cmd->server->module_config;
  805.     core_server_config *conf = ap_get_module_config(sconf, &core_module);
  806.  
  807.     const char *err = ap_check_cmd_context(cmd,
  808.                        NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  809.     if (err != NULL) {
  810.         return err;
  811.     }
  812.  
  813.     conf->gprof_dir = ap_pstrdup(cmd->pool, arg);
  814.     return NULL;
  815. }
  816. #endif /*GPROF*/
  817.  
  818. static const char *set_document_root(cmd_parms *cmd, void *dummy, char *arg)
  819. {
  820.     void *sconf = cmd->server->module_config;
  821.     core_server_config *conf = ap_get_module_config(sconf, &core_module);
  822.   
  823.     const char *err = ap_check_cmd_context(cmd,
  824.                        NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  825.     if (err != NULL) {
  826.         return err;
  827.     }
  828.  
  829.     arg = ap_os_canonical_filename(cmd->pool, arg);
  830.     if (!ap_is_directory(arg)) {
  831.     if (cmd->server->is_virtual) {
  832.         fprintf(stderr, "Warning: DocumentRoot [%s] does not exist\n",
  833.             arg);
  834.     }
  835.     else {
  836.         return "DocumentRoot must be a directory";
  837.     }
  838.     }
  839.     
  840.     conf->ap_document_root = arg;
  841.     return NULL;
  842. }
  843.  
  844. API_EXPORT(void) ap_custom_response(request_rec *r, int status, char *string)
  845. {
  846.     core_dir_config *conf = 
  847.     ap_get_module_config(r->per_dir_config, &core_module);
  848.     int idx;
  849.  
  850.     if(conf->response_code_strings == NULL) {
  851.         conf->response_code_strings = 
  852.         ap_pcalloc(r->pool,
  853.             sizeof(*conf->response_code_strings) * 
  854.             RESPONSE_CODES);
  855.     }
  856.  
  857.     idx = ap_index_of_response(status);
  858.  
  859.     conf->response_code_strings[idx] = 
  860.        ((ap_is_url(string) || (*string == '/')) && (*string != '"')) ? 
  861.        ap_pstrdup(r->pool, string) : ap_pstrcat(r->pool, "\"", string, NULL);
  862. }
  863.  
  864. static const char *set_error_document(cmd_parms *cmd, core_dir_config *conf,
  865.                       char *line)
  866. {
  867.     int error_number, index_number, idx500;
  868.     char *w;
  869.                 
  870.     const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
  871.     if (err != NULL) {
  872.         return err;
  873.     }
  874.  
  875.     /* 1st parameter should be a 3 digit number, which we recognize;
  876.      * convert it into an array index
  877.      */
  878.   
  879.     w = ap_getword_conf_nc(cmd->pool, &line);
  880.     error_number = atoi(w);
  881.  
  882.     idx500 = ap_index_of_response(HTTP_INTERNAL_SERVER_ERROR);
  883.  
  884.     if (error_number == HTTP_INTERNAL_SERVER_ERROR) {
  885.         index_number = idx500;
  886.     }
  887.     else if ((index_number = ap_index_of_response(error_number)) == idx500) {
  888.         return ap_pstrcat(cmd->pool, "Unsupported HTTP response code ",
  889.               w, NULL);
  890.     }
  891.  
  892.     /* The entry should be ignored if it is a full URL for a 401 error */
  893.  
  894.     if (error_number == 401 &&
  895.     line[0] != '/' && line[0] != '"') { /* Ignore it... */
  896.     ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, NULL,
  897.              "cannot use a full URL in a 401 ErrorDocument "
  898.              "directive --- ignoring!");
  899.     }
  900.     else { /* Store it... */
  901.         if (conf->response_code_strings == NULL) {
  902.         conf->response_code_strings =
  903.         ap_pcalloc(cmd->pool,
  904.                sizeof(*conf->response_code_strings) * RESPONSE_CODES);
  905.         }
  906.         conf->response_code_strings[index_number] = ap_pstrdup(cmd->pool, line);
  907.     }   
  908.  
  909.     return NULL;
  910. }
  911.  
  912. /* access.conf commands...
  913.  *
  914.  * The *only* thing that can appear in access.conf at top level is a
  915.  * <Directory> section.  NB we need to have a way to cut the srm_command_loop
  916.  * invoked by dirsection (i.e., <Directory>) short when </Directory> is seen.
  917.  * We do that by returning an error, which dirsection itself recognizes and
  918.  * discards as harmless.  Cheesy, but it works.
  919.  */
  920.  
  921. static const char *set_override(cmd_parms *cmd, core_dir_config *d,
  922.                 const char *l)
  923. {
  924.     char *w;
  925.   
  926.     const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
  927.     if (err != NULL) {
  928.         return err;
  929.     }
  930.  
  931.     d->override = OR_NONE;
  932.     while (l[0]) {
  933.         w = ap_getword_conf(cmd->pool, &l);
  934.     if (!strcasecmp(w, "Limit")) {
  935.         d->override |= OR_LIMIT;
  936.     }
  937.     else if (!strcasecmp(w, "Options")) {
  938.         d->override |= OR_OPTIONS;
  939.     }
  940.     else if (!strcasecmp(w, "FileInfo")) {
  941.             d->override |= OR_FILEINFO;
  942.     }
  943.     else if (!strcasecmp(w, "AuthConfig")) {
  944.         d->override |= OR_AUTHCFG;
  945.     }
  946.     else if (!strcasecmp(w, "Indexes")) {
  947.             d->override |= OR_INDEXES;
  948.     }
  949.     else if (!strcasecmp(w, "None")) {
  950.         d->override = OR_NONE;
  951.     }
  952.     else if (!strcasecmp(w, "All")) {
  953.         d->override = OR_ALL;
  954.     }
  955.     else {
  956.         return ap_pstrcat(cmd->pool, "Illegal override option ", w, NULL);
  957.     }
  958.     d->override &= ~OR_UNSET;
  959.     }
  960.  
  961.     return NULL;
  962. }
  963.  
  964. static const char *set_options(cmd_parms *cmd, core_dir_config *d,
  965.                    const char *l)
  966. {
  967.     allow_options_t opt;
  968.     int first = 1;
  969.     char action;
  970.  
  971.     while (l[0]) {
  972.         char *w = ap_getword_conf(cmd->pool, &l);
  973.     action = '\0';
  974.  
  975.     if (*w == '+' || *w == '-') {
  976.         action = *(w++);
  977.     }
  978.     else if (first) {
  979.           d->opts = OPT_NONE;
  980.             first = 0;
  981.         }
  982.         
  983.     if (!strcasecmp(w, "Indexes")) {
  984.         opt = OPT_INDEXES;
  985.     }
  986.     else if (!strcasecmp(w, "Includes")) {
  987.         opt = OPT_INCLUDES;
  988.     }
  989.     else if (!strcasecmp(w, "IncludesNOEXEC")) {
  990.         opt = (OPT_INCLUDES | OPT_INCNOEXEC);
  991.     }
  992.     else if (!strcasecmp(w, "FollowSymLinks")) {
  993.         opt = OPT_SYM_LINKS;
  994.     }
  995.     else if (!strcasecmp(w, "SymLinksIfOwnerMatch")) {
  996.         opt = OPT_SYM_OWNER;
  997.     }
  998.     else if (!strcasecmp(w, "execCGI")) {
  999.         opt = OPT_EXECCGI;
  1000.     }
  1001.     else if (!strcasecmp(w, "MultiViews")) {
  1002.         opt = OPT_MULTI;
  1003.     }
  1004.     else if (!strcasecmp(w, "RunScripts")) { /* AI backcompat. Yuck */
  1005.         opt = OPT_MULTI|OPT_EXECCGI;
  1006.     }
  1007.     else if (!strcasecmp(w, "None")) {
  1008.         opt = OPT_NONE;
  1009.     }
  1010.     else if (!strcasecmp(w, "All")) {
  1011.         opt = OPT_ALL;
  1012.     }
  1013.     else {
  1014.         return ap_pstrcat(cmd->pool, "Illegal option ", w, NULL);
  1015.     }
  1016.  
  1017.     /* we ensure the invariant (d->opts_add & d->opts_remove) == 0 */
  1018.     if (action == '-') {
  1019.         d->opts_remove |= opt;
  1020.         d->opts_add &= ~opt;
  1021.         d->opts &= ~opt;
  1022.     }
  1023.     else if (action == '+') {
  1024.         d->opts_add |= opt;
  1025.         d->opts_remove &= ~opt;
  1026.         d->opts |= opt;
  1027.     }
  1028.     else {
  1029.         d->opts |= opt;
  1030.     }
  1031.     }
  1032.  
  1033.     return NULL;
  1034. }
  1035.  
  1036. static const char *satisfy(cmd_parms *cmd, core_dir_config *c, char *arg)
  1037. {
  1038.     if (!strcasecmp(arg, "all")) {
  1039.         c->satisfy = SATISFY_ALL;
  1040.     }
  1041.     else if (!strcasecmp(arg, "any")) {
  1042.         c->satisfy = SATISFY_ANY;
  1043.     }
  1044.     else {
  1045.         return "Satisfy either 'any' or 'all'.";
  1046.     }
  1047.     return NULL;
  1048. }
  1049.  
  1050. static const char *require(cmd_parms *cmd, core_dir_config *c, char *arg)
  1051. {
  1052.     require_line *r;
  1053.   
  1054.     if (!c->ap_requires) {
  1055.         c->ap_requires = ap_make_array(cmd->pool, 2, sizeof(require_line));
  1056.     }
  1057.     r = (require_line *)ap_push_array(c->ap_requires);
  1058.     r->requirement = ap_pstrdup(cmd->pool, arg);
  1059.     r->method_mask = cmd->limited;
  1060.     return NULL;
  1061. }
  1062.  
  1063. CORE_EXPORT_NONSTD(const char *) ap_limit_section(cmd_parms *cmd, void *dummy,
  1064.                           const char *arg)
  1065. {
  1066.     const char *limited_methods = ap_getword(cmd->pool, &arg, '>');
  1067.     int limited = 0;
  1068.   
  1069.     const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
  1070.     if (err != NULL) {
  1071.         return err;
  1072.     }
  1073.  
  1074.     /* XXX: NB: Currently, we have no way of checking
  1075.      * whether <Limit> sections are closed properly.
  1076.      * (If we would add a srm_command_loop() here we might...)
  1077.      */
  1078.     
  1079.     while (limited_methods[0]) {
  1080.         char *method = ap_getword_conf(cmd->pool, &limited_methods);
  1081.         int  methnum = ap_method_number_of(method);
  1082.  
  1083.         if (methnum == M_TRACE) {
  1084.             return "TRACE cannot be controlled by <Limit>";
  1085.         }
  1086.         else if (methnum == M_INVALID) {
  1087.             return ap_pstrcat(cmd->pool, "unknown method \"",
  1088.                               method, "\" in <Limit>", NULL);
  1089.         }
  1090.         else {
  1091.             limited |= (1 << methnum);
  1092.         }
  1093.     }
  1094.  
  1095.     cmd->limited = limited;
  1096.     return NULL;
  1097. }
  1098.  
  1099. static const char *endlimit_section(cmd_parms *cmd, void *dummy, void *dummy2)
  1100. {
  1101.     if (cmd->limited == -1) {
  1102.         return "</Limit> unexpected";
  1103.     }
  1104.     
  1105.     cmd->limited = -1;
  1106.     return NULL;
  1107. }
  1108.  
  1109. /*
  1110.  * When a section is not closed properly when end-of-file is reached,
  1111.  * then an error message should be printed:
  1112.  */
  1113. static const char *missing_endsection(cmd_parms *cmd, int nest)
  1114. {
  1115.     if (nest < 2) {
  1116.     return ap_psprintf(cmd->pool, "Missing %s directive at end-of-file",
  1117.                cmd->end_token);
  1118.     }
  1119.     return ap_psprintf(cmd->pool, "%d missing %s directives at end-of-file",
  1120.                nest, cmd->end_token);
  1121. }
  1122.  
  1123. /* We use this in <DirectoryMatch> and <FilesMatch>, to ensure that 
  1124.  * people don't get bitten by wrong-cased regex matches
  1125.  */
  1126.  
  1127. #ifdef WIN32
  1128. #define USE_ICASE REG_ICASE
  1129. #else
  1130. #define USE_ICASE 0
  1131. #endif
  1132.  
  1133. static const char *end_nested_section(cmd_parms *cmd, void *dummy)
  1134. {
  1135.     if (cmd->end_token == NULL) {
  1136.         return ap_pstrcat(cmd->pool, cmd->cmd->name,
  1137.               " without matching <", cmd->cmd->name + 2, 
  1138.               " section", NULL);
  1139.     }
  1140.     /*
  1141.      * This '!=' may look weird on a string comparison, but it's correct --
  1142.      * it's been set up so that checking for two pointers to the same datum
  1143.      * is valid here.  And faster.
  1144.      */
  1145.     if (cmd->cmd->name != cmd->end_token) {
  1146.     return ap_pstrcat(cmd->pool, "Expected ", cmd->end_token, " but saw ",
  1147.               cmd->cmd->name, NULL);
  1148.     }
  1149.     return cmd->end_token;
  1150. }
  1151.  
  1152. /*
  1153.  * Report a missing-'>' syntax error.
  1154.  */
  1155. static char *unclosed_directive(cmd_parms *cmd)
  1156. {
  1157.     return ap_pstrcat(cmd->pool, cmd->cmd->name,
  1158.               "> directive missing closing '>'", NULL);
  1159. }
  1160.  
  1161. static const char *dirsection(cmd_parms *cmd, void *dummy, const char *arg)
  1162. {
  1163.     const char *errmsg;
  1164.     char *endp = strrchr(arg, '>');
  1165.     int old_overrides = cmd->override;
  1166.     char *old_path = cmd->path;
  1167.     core_dir_config *conf;
  1168.     void *new_dir_conf = ap_create_per_dir_config(cmd->pool);
  1169.     regex_t *r = NULL;
  1170.     const char *old_end_token;
  1171.     const command_rec *thiscmd = cmd->cmd;
  1172.  
  1173.     const char *err = ap_check_cmd_context(cmd,
  1174.                        NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1175.     if (err != NULL) {
  1176.         return err;
  1177.     }
  1178.  
  1179.     if (endp == NULL) {
  1180.     return unclosed_directive(cmd);
  1181.     }
  1182.  
  1183.     *endp = '\0';
  1184.  
  1185.     cmd->path = ap_getword_conf(cmd->pool, &arg);
  1186. #ifdef OS2
  1187.     /* Fix OS/2 HPFS filename case problem. */
  1188.     cmd->path = strlwr(cmd->path);
  1189. #endif    
  1190.     cmd->override = OR_ALL|ACCESS_CONF;
  1191.  
  1192.     if (thiscmd->cmd_data) { /* <DirectoryMatch> */
  1193.     r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED|USE_ICASE);
  1194.     }
  1195.     else if (!strcmp(cmd->path, "~")) {
  1196.     cmd->path = ap_getword_conf(cmd->pool, &arg);
  1197.     r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED|USE_ICASE);
  1198.     }
  1199.     else {
  1200.     /* Ensure that the pathname is canonical */
  1201.     cmd->path = ap_os_canonical_filename(cmd->pool, cmd->path);
  1202.     }
  1203.  
  1204.     old_end_token = cmd->end_token;
  1205.     cmd->end_token = thiscmd->cmd_data ? end_directorymatch_section : end_directory_section;
  1206.     errmsg = ap_srm_command_loop(cmd, new_dir_conf);
  1207.     if (errmsg == NULL) {
  1208.     errmsg = missing_endsection(cmd, 1);
  1209.     }
  1210.     cmd->end_token = old_end_token;
  1211.     if (errmsg != (thiscmd->cmd_data 
  1212.                ? end_directorymatch_section 
  1213.            : end_directory_section)) {
  1214.     return errmsg;
  1215.     }
  1216.  
  1217.     conf = (core_dir_config *)ap_get_module_config(new_dir_conf, &core_module);
  1218.     conf->r = r;
  1219.  
  1220.     ap_add_per_dir_conf(cmd->server, new_dir_conf);
  1221.  
  1222.     if (*arg != '\0') {
  1223.     return ap_pstrcat(cmd->pool, "Multiple ", thiscmd->name,
  1224.               "> arguments not (yet) supported.", NULL);
  1225.     }
  1226.  
  1227.     cmd->path = old_path;
  1228.     cmd->override = old_overrides;
  1229.  
  1230.     return NULL;
  1231. }
  1232.  
  1233. static const char *urlsection(cmd_parms *cmd, void *dummy, const char *arg)
  1234. {
  1235.     const char *errmsg;
  1236.     char *endp = strrchr(arg, '>');
  1237.     int old_overrides = cmd->override;
  1238.     char *old_path = cmd->path;
  1239.     core_dir_config *conf;
  1240.     regex_t *r = NULL;
  1241.     const char *old_end_token;
  1242.     const command_rec *thiscmd = cmd->cmd;
  1243.  
  1244.     void *new_url_conf = ap_create_per_dir_config(cmd->pool);
  1245.  
  1246.     const char *err = ap_check_cmd_context(cmd,
  1247.                        NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1248.     if (err != NULL) {
  1249.         return err;
  1250.     }
  1251.  
  1252.     if (endp == NULL) {
  1253.     return unclosed_directive(cmd);
  1254.     }
  1255.  
  1256.     *endp = '\0';
  1257.  
  1258.     cmd->path = ap_getword_conf(cmd->pool, &arg);
  1259.     cmd->override = OR_ALL|ACCESS_CONF;
  1260.  
  1261.     if (thiscmd->cmd_data) { /* <LocationMatch> */
  1262.     r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED);
  1263.     }
  1264.     else if (!strcmp(cmd->path, "~")) {
  1265.     cmd->path = ap_getword_conf(cmd->pool, &arg);
  1266.     r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED);
  1267.     }
  1268.  
  1269.     old_end_token = cmd->end_token;
  1270.     cmd->end_token = thiscmd->cmd_data ? end_locationmatch_section
  1271.                                        : end_location_section;
  1272.     errmsg = ap_srm_command_loop(cmd, new_url_conf);
  1273.     if (errmsg == NULL) {
  1274.     errmsg = missing_endsection(cmd, 1);
  1275.     }
  1276.     cmd->end_token = old_end_token;
  1277.     if (errmsg != (thiscmd->cmd_data 
  1278.                ? end_locationmatch_section 
  1279.                : end_location_section)) {
  1280.     return errmsg;
  1281.     }
  1282.  
  1283.     conf = (core_dir_config *)ap_get_module_config(new_url_conf, &core_module);
  1284.     conf->d = ap_pstrdup(cmd->pool, cmd->path);    /* No mangling, please */
  1285.     conf->d_is_fnmatch = ap_is_fnmatch(conf->d) != 0;
  1286.     conf->r = r;
  1287.  
  1288.     ap_add_per_url_conf(cmd->server, new_url_conf);
  1289.     
  1290.     if (*arg != '\0') {
  1291.     return ap_pstrcat(cmd->pool, "Multiple ", thiscmd->name,
  1292.               "> arguments not (yet) supported.", NULL);
  1293.     }
  1294.  
  1295.     cmd->path = old_path;
  1296.     cmd->override = old_overrides;
  1297.  
  1298.     return NULL;
  1299. }
  1300.  
  1301. static const char *filesection(cmd_parms *cmd, core_dir_config *c,
  1302.                    const char *arg)
  1303. {
  1304.     const char *errmsg;
  1305.     char *endp = strrchr(arg, '>');
  1306.     int old_overrides = cmd->override;
  1307.     char *old_path = cmd->path;
  1308.     core_dir_config *conf;
  1309.     regex_t *r = NULL;
  1310.     const char *old_end_token;
  1311.     const command_rec *thiscmd = cmd->cmd;
  1312.  
  1313.     void *new_file_conf = ap_create_per_dir_config(cmd->pool);
  1314.  
  1315.     const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT|NOT_IN_LOCATION);
  1316.     if (err != NULL) {
  1317.         return err;
  1318.     }
  1319.  
  1320.     if (endp == NULL) {
  1321.     return unclosed_directive(cmd);
  1322.     }
  1323.  
  1324.     *endp = '\0';
  1325.  
  1326.     cmd->path = ap_getword_conf(cmd->pool, &arg);
  1327.     /* Only if not an .htaccess file */
  1328.     if (!old_path) {
  1329.     cmd->override = OR_ALL|ACCESS_CONF;
  1330.     }
  1331.  
  1332.     if (thiscmd->cmd_data) { /* <FilesMatch> */
  1333.         r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED|USE_ICASE);
  1334.     }
  1335.     else if (!strcmp(cmd->path, "~")) {
  1336.     cmd->path = ap_getword_conf(cmd->pool, &arg);
  1337.     r = ap_pregcomp(cmd->pool, cmd->path, REG_EXTENDED|USE_ICASE);
  1338.     }
  1339.     else {
  1340.     /* Ensure that the pathname is canonical */
  1341.     cmd->path = ap_os_canonical_filename(cmd->pool, cmd->path);
  1342.     }
  1343.  
  1344.     old_end_token = cmd->end_token;
  1345.     cmd->end_token = thiscmd->cmd_data ? end_filesmatch_section : end_files_section;
  1346.     errmsg = ap_srm_command_loop(cmd, new_file_conf);
  1347.     if (errmsg == NULL) {
  1348.     errmsg = missing_endsection(cmd, 1);
  1349.     }
  1350.     cmd->end_token = old_end_token;
  1351.     if (errmsg != (thiscmd->cmd_data 
  1352.                ? end_filesmatch_section 
  1353.            : end_files_section)) {
  1354.     return errmsg;
  1355.     }
  1356.  
  1357.     conf = (core_dir_config *)ap_get_module_config(new_file_conf,
  1358.                            &core_module);
  1359.     conf->d = cmd->path;
  1360.     conf->d_is_fnmatch = ap_is_fnmatch(conf->d) != 0;
  1361.     conf->r = r;
  1362.  
  1363.     add_file_conf(c, new_file_conf);
  1364.  
  1365.     if (*arg != '\0') {
  1366.     return ap_pstrcat(cmd->pool, "Multiple ", thiscmd->name,
  1367.               "> arguments not (yet) supported.", NULL);
  1368.     }
  1369.  
  1370.     cmd->path = old_path;
  1371.     cmd->override = old_overrides;
  1372.  
  1373.     return NULL;
  1374. }
  1375.  
  1376. /* XXX: NB: Currently, we have no way of checking
  1377.  * whether <IfModule> sections are closed properly.
  1378.  * Extra (redundant, unpaired) </IfModule> directives are
  1379.  * simply silently ignored.
  1380.  */
  1381. static const char *end_ifmod(cmd_parms *cmd, void *dummy)
  1382. {
  1383.     return NULL;
  1384. }
  1385.  
  1386. static const char *start_ifmod(cmd_parms *cmd, void *dummy, char *arg)
  1387. {
  1388.     char *endp = strrchr(arg, '>');
  1389.     char l[MAX_STRING_LEN];
  1390.     int not = (arg[0] == '!');
  1391.     module *found;
  1392.     int nest = 1;
  1393.  
  1394.     if (endp == NULL) {
  1395.     return unclosed_directive(cmd);
  1396.     }
  1397.  
  1398.     *endp = '\0';
  1399.  
  1400.     if (not) {
  1401.         arg++;
  1402.     }
  1403.  
  1404.     found = ap_find_linked_module(arg);
  1405.  
  1406.     if ((!not && found) || (not && !found)) {
  1407.         return NULL;
  1408.     }
  1409.  
  1410.     while (nest && !(ap_cfg_getline(l, MAX_STRING_LEN, cmd->config_file))) {
  1411.         if (!strncasecmp(l, "<IfModule", 9)) {
  1412.         nest++;
  1413.     }
  1414.     if (!strcasecmp(l, "</IfModule>")) {
  1415.       nest--;
  1416.     }
  1417.     }
  1418.  
  1419.     if (nest) {
  1420.     cmd->end_token = end_ifmodule_section;
  1421.     return missing_endsection(cmd, nest);
  1422.     }
  1423.     return NULL;
  1424. }
  1425.  
  1426. API_EXPORT(int) ap_exists_config_define(char *name)
  1427. {
  1428.     char **defines;
  1429.     int i;
  1430.  
  1431.     defines = (char **)ap_server_config_defines->elts;
  1432.     for (i = 0; i < ap_server_config_defines->nelts; i++) {
  1433.         if (strcmp(defines[i], name) == 0) {
  1434.             return 1;
  1435.     }
  1436.     }
  1437.     return 0;
  1438. }
  1439.  
  1440. static const char *end_ifdefine(cmd_parms *cmd, void *dummy) 
  1441. {
  1442.     return NULL;
  1443. }
  1444.  
  1445. static const char *start_ifdefine(cmd_parms *cmd, void *dummy, char *arg)
  1446. {
  1447.     char *endp;
  1448.     char l[MAX_STRING_LEN];
  1449.     int defined;
  1450.     int not = 0;
  1451.     int nest = 1;
  1452.  
  1453.     endp = strrchr(arg, '>');
  1454.     if (endp == NULL) {
  1455.     return unclosed_directive(cmd);
  1456.     }
  1457.  
  1458.     *endp = '\0';
  1459.  
  1460.     if (arg[0] == '!') {
  1461.         not = 1;
  1462.     arg++;
  1463.     }
  1464.  
  1465.     defined = ap_exists_config_define(arg);
  1466.  
  1467.     if ((!not && defined) || (not && !defined)) {
  1468.     return NULL;
  1469.     }
  1470.  
  1471.     while (nest && !(ap_cfg_getline(l, MAX_STRING_LEN, cmd->config_file))) {
  1472.         if (!strncasecmp(l, "<IfDefine", 9)) {
  1473.         nest++;
  1474.     }
  1475.     if (!strcasecmp(l, "</IfDefine>")) {
  1476.         nest--;
  1477.     }
  1478.     }
  1479.     if (nest) {
  1480.     cmd->end_token = end_ifdefine_section;
  1481.     return missing_endsection(cmd, nest);
  1482.     }
  1483.     return NULL;
  1484. }
  1485.  
  1486. /* httpd.conf commands... beginning with the <VirtualHost> business */
  1487.  
  1488. static const char *virtualhost_section(cmd_parms *cmd, void *dummy, char *arg)
  1489. {
  1490.     server_rec *main_server = cmd->server, *s;
  1491.     const char *errmsg;
  1492.     char *endp = strrchr(arg, '>');
  1493.     pool *p = cmd->pool, *ptemp = cmd->temp_pool;
  1494.     const char *old_end_token;
  1495.  
  1496.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1497.     if (err != NULL) {
  1498.         return err;
  1499.     }
  1500.  
  1501.     if (endp == NULL) {
  1502.     return unclosed_directive(cmd);
  1503.     }
  1504.  
  1505.     *endp = '\0';
  1506.     
  1507.     /* FIXME: There's another feature waiting to happen here -- since you
  1508.     can now put multiple addresses/names on a single <VirtualHost>
  1509.     you might want to use it to group common definitions and then
  1510.     define other "subhosts" with their individual differences.  But
  1511.     personally I'd rather just do it with a macro preprocessor. -djg */
  1512.     if (main_server->is_virtual) {
  1513.     return "<VirtualHost> doesn't nest!";
  1514.     }
  1515.     
  1516.     errmsg = ap_init_virtual_host(p, arg, main_server, &s);
  1517.     if (errmsg) {
  1518.     return errmsg;
  1519.     }
  1520.  
  1521.     s->next = main_server->next;
  1522.     main_server->next = s;
  1523.  
  1524.     s->defn_name = cmd->config_file->name;
  1525.     s->defn_line_number = cmd->config_file->line_number;
  1526.  
  1527.     old_end_token = cmd->end_token;
  1528.     cmd->end_token = end_virtualhost_section;
  1529.     cmd->server = s;
  1530.     errmsg = ap_srm_command_loop(cmd, s->lookup_defaults);
  1531.     cmd->server = main_server;
  1532.     if (errmsg == NULL) {
  1533.     errmsg = missing_endsection(cmd, 1);
  1534.     }
  1535.     cmd->end_token = old_end_token;
  1536.  
  1537.     if (s->srm_confname) {
  1538.     ap_process_resource_config(s, s->srm_confname, p, ptemp);
  1539.     }
  1540.  
  1541.     if (s->access_confname) {
  1542.     ap_process_resource_config(s, s->access_confname, p, ptemp);
  1543.     }
  1544.     
  1545.     if (errmsg == end_virtualhost_section) {
  1546.     return NULL;
  1547.     }
  1548.     return errmsg;
  1549. }
  1550.  
  1551. static const char *set_server_alias(cmd_parms *cmd, void *dummy,
  1552.                     const char *arg)
  1553. {
  1554.     if (!cmd->server->names) {
  1555.     return "ServerAlias only used in <VirtualHost>";
  1556.     }
  1557.     while (*arg) {
  1558.     char **item, *name = ap_getword_conf(cmd->pool, &arg);
  1559.     if (ap_is_matchexp(name)) {
  1560.         item = (char **)ap_push_array(cmd->server->wild_names);
  1561.     }
  1562.     else {
  1563.         item = (char **)ap_push_array(cmd->server->names);
  1564.     }
  1565.     *item = name;
  1566.     }
  1567.     return NULL;
  1568. }
  1569.  
  1570. static const char *add_module_command(cmd_parms *cmd, void *dummy, char *arg)
  1571. {
  1572.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1573.     if (err != NULL) {
  1574.         return err;
  1575.     }
  1576.  
  1577.     if (!ap_add_named_module(arg)) {
  1578.     return ap_pstrcat(cmd->pool, "Cannot add module via name '", arg, 
  1579.               "': not in list of loaded modules", NULL);
  1580.     }
  1581.     return NULL;
  1582. }
  1583.  
  1584. static const char *clear_module_list_command(cmd_parms *cmd, void *dummy)
  1585. {
  1586.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1587.     if (err != NULL) {
  1588.         return err;
  1589.     }
  1590.  
  1591.     ap_clear_module_list();
  1592.     return NULL;
  1593. }
  1594.  
  1595. static const char *set_server_string_slot(cmd_parms *cmd, void *dummy,
  1596.                       char *arg)
  1597. {
  1598.     /* This one's pretty generic... */
  1599.   
  1600.     int offset = (int)(long)cmd->info;
  1601.     char *struct_ptr = (char *)cmd->server;
  1602.     
  1603.     const char *err = ap_check_cmd_context(cmd, 
  1604.                        NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1605.     if (err != NULL) {
  1606.         return err;
  1607.     }
  1608.  
  1609.     *(char **)(struct_ptr + offset) = arg;
  1610.     return NULL;
  1611. }
  1612.  
  1613. static const char *server_type(cmd_parms *cmd, void *dummy, char *arg)
  1614. {
  1615.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1616.     if (err != NULL) {
  1617.         return err;
  1618.     }
  1619.  
  1620.     if (!strcasecmp(arg, "inetd")) {
  1621.         ap_standalone = 0;
  1622.     }
  1623.     else if (!strcasecmp(arg, "standalone")) {
  1624.         ap_standalone = 1;
  1625.     }
  1626.     else {
  1627.         return "ServerType must be either 'inetd' or 'standalone'";
  1628.     }
  1629.  
  1630.     return NULL;
  1631. }
  1632.  
  1633. static const char *server_port(cmd_parms *cmd, void *dummy, char *arg)
  1634. {
  1635.     const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1636.     int port;
  1637.  
  1638.     if (err != NULL) {
  1639.     return err;
  1640.     }
  1641.     port = atoi(arg);
  1642.     if (port <= 0 || port >= 65536) { /* 65536 == 1<<16 */
  1643.     return ap_pstrcat(cmd->temp_pool, "The port number \"", arg, 
  1644.               "\" is outside the appropriate range "
  1645.               "(i.e., 1..65535).", NULL);
  1646.     }
  1647.     cmd->server->port = port;
  1648.     return NULL;
  1649. }
  1650.  
  1651. static const char *set_signature_flag(cmd_parms *cmd, core_dir_config *d, 
  1652.                       char *arg)
  1653. {
  1654.     const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
  1655.     if (err != NULL) {
  1656.         return err;
  1657.     }
  1658.  
  1659.     if (strcasecmp(arg, "On") == 0) {
  1660.     d->server_signature = srv_sig_on;
  1661.     }
  1662.     else if (strcasecmp(arg, "Off") == 0) {
  1663.         d->server_signature = srv_sig_off;
  1664.     }
  1665.     else if (strcasecmp(arg, "EMail") == 0) {
  1666.     d->server_signature = srv_sig_withmail;
  1667.     }
  1668.     else {
  1669.     return "ServerSignature: use one of: off | on | email";
  1670.     }
  1671.     return NULL;
  1672. }
  1673.  
  1674. static const char *set_send_buffer_size(cmd_parms *cmd, void *dummy, char *arg)
  1675. {
  1676.     int s = atoi(arg);
  1677.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1678.     if (err != NULL) {
  1679.         return err;
  1680.     }
  1681.  
  1682.     if (s < 512 && s != 0) {
  1683.         return "SendBufferSize must be >= 512 bytes, or 0 for system default.";
  1684.     }
  1685.     cmd->server->send_buffer_size = s;
  1686.     return NULL;
  1687. }
  1688.  
  1689. static const char *set_user(cmd_parms *cmd, void *dummy, char *arg)
  1690. {
  1691. #ifdef WIN32
  1692.     ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, cmd->server,
  1693.          "User directive has no affect on Win32");
  1694.     cmd->server->server_uid = ap_user_id = 1;
  1695. #else
  1696.     const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1697.     if (err != NULL) {
  1698.         return err;
  1699.     }
  1700.  
  1701.     if (!cmd->server->is_virtual) {
  1702.     ap_user_name = arg;
  1703.     cmd->server->server_uid = ap_user_id = ap_uname2id(arg);
  1704.     }
  1705.     else {
  1706.         if (ap_suexec_enabled) {
  1707.         cmd->server->server_uid = ap_uname2id(arg);
  1708.     }
  1709.     else {
  1710.         cmd->server->server_uid = ap_user_id;
  1711.         fprintf(stderr,
  1712.             "Warning: User directive in <VirtualHost> "
  1713.             "requires SUEXEC wrapper.\n");
  1714.     }
  1715.     }
  1716. #if !defined (BIG_SECURITY_HOLE) && !defined (OS2)
  1717.     if (cmd->server->server_uid == 0) {
  1718.     fprintf(stderr,
  1719.         "Error:\tApache has not been designed to serve pages while\n"
  1720.         "\trunning as root.  There are known race conditions that\n"
  1721.         "\twill allow any local user to read any file on the system.\n"
  1722.         "\tShould you still desire to serve pages as root then\n"
  1723.         "\tadd -DBIG_SECURITY_HOLE to the EXTRA_CFLAGS line in your\n"
  1724.         "\tsrc/Configuration file and rebuild the server.  It is\n"
  1725.         "\tstrongly suggested that you instead modify the User\n"
  1726.         "\tdirective in your httpd.conf file to list a non-root\n"
  1727.         "\tuser.\n");
  1728.     exit (1);
  1729.     }
  1730. #endif
  1731. #endif /* WIN32 */
  1732.  
  1733.     return NULL;
  1734. }
  1735.  
  1736. static const char *set_group(cmd_parms *cmd, void *dummy, char *arg)
  1737. {
  1738.     const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1739.     if (err != NULL) {
  1740.         return err;
  1741.     }
  1742.  
  1743.     if (!cmd->server->is_virtual) {
  1744.     cmd->server->server_gid = ap_group_id = ap_gname2id(arg);
  1745.     }
  1746.     else {
  1747.         if (ap_suexec_enabled) {
  1748.         cmd->server->server_gid = ap_gname2id(arg);
  1749.     }
  1750.     else {
  1751.         cmd->server->server_gid = ap_group_id;
  1752.         fprintf(stderr,
  1753.             "Warning: Group directive in <VirtualHost> requires "
  1754.             "SUEXEC wrapper.\n");
  1755.     }
  1756.     }
  1757.  
  1758.     return NULL;
  1759. }
  1760.  
  1761. static const char *set_server_root(cmd_parms *cmd, void *dummy, char *arg) 
  1762. {
  1763.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1764.  
  1765.     if (err != NULL) {
  1766.         return err;
  1767.     }
  1768.  
  1769.     arg = ap_os_canonical_filename(cmd->pool, arg);
  1770.  
  1771.     if (!ap_is_directory(arg)) {
  1772.         return "ServerRoot must be a valid directory";
  1773.     }
  1774.     ap_cpystrn(ap_server_root, arg,
  1775.            sizeof(ap_server_root));
  1776.     return NULL;
  1777. }
  1778.  
  1779. static const char *set_timeout(cmd_parms *cmd, void *dummy, char *arg)
  1780. {
  1781.     const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1782.     if (err != NULL) {
  1783.         return err;
  1784.     }
  1785.  
  1786.     cmd->server->timeout = atoi(arg);
  1787.     return NULL;
  1788. }
  1789.  
  1790. static const char *set_keep_alive_timeout(cmd_parms *cmd, void *dummy,
  1791.                       char *arg)
  1792. {
  1793.     const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1794.     if (err != NULL) {
  1795.         return err;
  1796.     }
  1797.  
  1798.     cmd->server->keep_alive_timeout = atoi(arg);
  1799.     return NULL;
  1800. }
  1801.  
  1802. static const char *set_keep_alive(cmd_parms *cmd, void *dummy, char *arg) 
  1803. {
  1804.     const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1805.     if (err != NULL) {
  1806.         return err;
  1807.     }
  1808.  
  1809.     /* We've changed it to On/Off, but used to use numbers
  1810.      * so we accept anything but "Off" or "0" as "On"
  1811.      */
  1812.     if (!strcasecmp(arg, "off") || !strcmp(arg, "0")) {
  1813.     cmd->server->keep_alive = 0;
  1814.     }
  1815.     else {
  1816.     cmd->server->keep_alive = 1;
  1817.     }
  1818.     return NULL;
  1819. }
  1820.  
  1821. static const char *set_keep_alive_max(cmd_parms *cmd, void *dummy, char *arg) 
  1822. {
  1823.     const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1824.     if (err != NULL) {
  1825.         return err;
  1826.     }
  1827.  
  1828.     cmd->server->keep_alive_max = atoi(arg);
  1829.     return NULL;
  1830. }
  1831.  
  1832. static const char *set_pidfile(cmd_parms *cmd, void *dummy, char *arg) 
  1833. {
  1834.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1835.     if (err != NULL) {
  1836.         return err;
  1837.     }
  1838.  
  1839.     if (cmd->server->is_virtual) {
  1840.     return "PidFile directive not allowed in <VirtualHost>";
  1841.     }
  1842.     ap_pid_fname = arg;
  1843.     return NULL;
  1844. }
  1845.  
  1846. static const char *set_scoreboard(cmd_parms *cmd, void *dummy, char *arg) 
  1847. {
  1848.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1849.     if (err != NULL) {
  1850.         return err;
  1851.     }
  1852.  
  1853.     ap_scoreboard_fname = arg;
  1854.     return NULL;
  1855. }
  1856.  
  1857. static const char *set_lockfile(cmd_parms *cmd, void *dummy, char *arg) 
  1858. {
  1859.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1860.     if (err != NULL) {
  1861.         return err;
  1862.     }
  1863.  
  1864.     ap_lock_fname = arg;
  1865.     return NULL;
  1866. }
  1867.  
  1868. static const char *set_idcheck(cmd_parms *cmd, core_dir_config *d, int arg) 
  1869. {
  1870.     const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
  1871.     if (err != NULL) {
  1872.         return err;
  1873.     }
  1874.  
  1875.     d->do_rfc1413 = arg != 0;
  1876.     return NULL;
  1877. }
  1878.  
  1879. static const char *set_hostname_lookups(cmd_parms *cmd, core_dir_config *d,
  1880.                     char *arg)
  1881. {
  1882.     const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
  1883.     if (err != NULL) {
  1884.         return err;
  1885.     }
  1886.  
  1887.     if (!strcasecmp(arg, "on")) {
  1888.     d->hostname_lookups = HOSTNAME_LOOKUP_ON;
  1889.     }
  1890.     else if (!strcasecmp(arg, "off")) {
  1891.     d->hostname_lookups = HOSTNAME_LOOKUP_OFF;
  1892.     }
  1893.     else if (!strcasecmp(arg, "double")) {
  1894.     d->hostname_lookups = HOSTNAME_LOOKUP_DOUBLE;
  1895.     }
  1896.     else {
  1897.     return "parameter must be 'on', 'off', or 'double'";
  1898.     }
  1899.     return NULL;
  1900. }
  1901.  
  1902. static const char *set_serverpath(cmd_parms *cmd, void *dummy, char *arg) 
  1903. {
  1904.     const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  1905.     if (err != NULL) {
  1906.         return err;
  1907.     }
  1908.  
  1909.     cmd->server->path = arg;
  1910.     cmd->server->pathlen = strlen(arg);
  1911.     return NULL;
  1912. }
  1913.  
  1914. static const char *set_content_md5(cmd_parms *cmd, core_dir_config *d, int arg)
  1915. {
  1916.     const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
  1917.     if (err != NULL) {
  1918.         return err;
  1919.     }
  1920.  
  1921.     d->content_md5 = arg != 0;
  1922.     return NULL;
  1923. }
  1924.  
  1925. static const char *set_use_canonical_name(cmd_parms *cmd, core_dir_config *d, 
  1926.                       int arg)
  1927. {
  1928.     const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
  1929.  
  1930.     if (err != NULL) {
  1931.     return err;
  1932.     }
  1933.     
  1934.     d->use_canonical_name = arg != 0;
  1935.     return NULL;
  1936. }
  1937.  
  1938. static const char *set_daemons_to_start(cmd_parms *cmd, void *dummy, char *arg) 
  1939. {
  1940. #ifdef WIN32
  1941.     fprintf(stderr, "WARNING: StartServers has no effect on Win32\n");
  1942. #else
  1943.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1944.     if (err != NULL) {
  1945.         return err;
  1946.     }
  1947.  
  1948.     ap_daemons_to_start = atoi(arg);
  1949. #endif
  1950.     return NULL;
  1951. }
  1952.  
  1953. static const char *set_min_free_servers(cmd_parms *cmd, void *dummy, char *arg)
  1954. {
  1955.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1956.     if (err != NULL) {
  1957.         return err;
  1958.     }
  1959.  
  1960.     ap_daemons_min_free = atoi(arg);
  1961.     if (ap_daemons_min_free <= 0) {
  1962.        fprintf(stderr, "WARNING: detected MinSpareServers set to non-positive.\n");
  1963.        fprintf(stderr, "Resetting to 1 to avoid almost certain Apache failure.\n");
  1964.        fprintf(stderr, "Please read the documentation.\n");
  1965.        ap_daemons_min_free = 1;
  1966.     }
  1967.        
  1968.     return NULL;
  1969. }
  1970.  
  1971. static const char *set_max_free_servers(cmd_parms *cmd, void *dummy, char *arg)
  1972. {
  1973.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1974.     if (err != NULL) {
  1975.         return err;
  1976.     }
  1977.  
  1978.     ap_daemons_max_free = atoi(arg);
  1979.     return NULL;
  1980. }
  1981.  
  1982. static const char *set_server_limit (cmd_parms *cmd, void *dummy, char *arg) 
  1983. {
  1984.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  1985.     if (err != NULL) {
  1986.         return err;
  1987.     }
  1988.  
  1989.     ap_daemons_limit = atoi(arg);
  1990.     if (ap_daemons_limit > HARD_SERVER_LIMIT) {
  1991.        fprintf(stderr, "WARNING: MaxClients of %d exceeds compile time limit "
  1992.            "of %d servers,\n", ap_daemons_limit, HARD_SERVER_LIMIT);
  1993.        fprintf(stderr, " lowering MaxClients to %d.  To increase, please "
  1994.            "see the\n", HARD_SERVER_LIMIT);
  1995.        fprintf(stderr, " HARD_SERVER_LIMIT define in src/include/httpd.h.\n");
  1996.        ap_daemons_limit = HARD_SERVER_LIMIT;
  1997.     } 
  1998.     else if (ap_daemons_limit < 1) {
  1999.     fprintf(stderr, "WARNING: Require MaxClients > 0, setting to 1\n");
  2000.     ap_daemons_limit = 1;
  2001.     }
  2002.     return NULL;
  2003. }
  2004.  
  2005. static const char *set_max_requests(cmd_parms *cmd, void *dummy, char *arg) 
  2006. {
  2007.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  2008.     if (err != NULL) {
  2009.         return err;
  2010.     }
  2011.  
  2012.     ap_max_requests_per_child = atoi(arg);
  2013.     return NULL;
  2014. }
  2015.  
  2016. static const char *set_threads(cmd_parms *cmd, void *dummy, char *arg) {
  2017.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  2018.     if (err != NULL) {
  2019.         return err;
  2020.     }
  2021.  
  2022.     ap_threads_per_child = atoi(arg);
  2023.     if (ap_threads_per_child > HARD_SERVER_LIMIT) {
  2024.         fprintf(stderr, "WARNING: ThreadsPerChild of %d exceeds compile time limit "
  2025.                 "of %d threads,\n", ap_threads_per_child, HARD_SERVER_LIMIT);
  2026.         fprintf(stderr, " lowering ThreadsPerChild to %d.  To increase, please "
  2027.                 "see the\n", HARD_SERVER_LIMIT);
  2028.         fprintf(stderr, " HARD_SERVER_LIMIT define in src/include/httpd.h.\n");
  2029.         ap_threads_per_child = HARD_SERVER_LIMIT;
  2030.     } 
  2031.     else if (ap_threads_per_child < 1) {
  2032.     fprintf(stderr, "WARNING: Require ThreadsPerChild > 0, setting to 1\n");
  2033.     ap_threads_per_child = 1;
  2034.     }
  2035.  
  2036.     return NULL;
  2037. }
  2038.  
  2039. static const char *set_excess_requests(cmd_parms *cmd, void *dummy, char *arg) 
  2040. {
  2041.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  2042.     if (err != NULL) {
  2043.         return err;
  2044.     }
  2045.  
  2046.     ap_excess_requests_per_child = atoi(arg);
  2047.     return NULL;
  2048. }
  2049.  
  2050.  
  2051. #if defined(RLIMIT_CPU) || defined(RLIMIT_DATA) || defined(RLIMIT_VMEM) || defined(RLIMIT_NPROC) || defined(RLIMIT_AS)
  2052. static void set_rlimit(cmd_parms *cmd, struct rlimit **plimit, const char *arg,
  2053.                        const char * arg2, int type)
  2054. {
  2055.     char *str;
  2056.     struct rlimit *limit;
  2057.     /* If your platform doesn't define rlim_t then typedef it in ap_config.h */
  2058.     rlim_t cur = 0;
  2059.     rlim_t max = 0;
  2060.  
  2061.     *plimit = (struct rlimit *)ap_pcalloc(cmd->pool, sizeof(**plimit));
  2062.     limit = *plimit;
  2063.     if ((getrlimit(type, limit)) != 0)    {
  2064.     *plimit = NULL;
  2065.     ap_log_error(APLOG_MARK, APLOG_ERR, cmd->server,
  2066.              "%s: getrlimit failed", cmd->cmd->name);
  2067.     return;
  2068.     }
  2069.  
  2070.     if ((str = ap_getword_conf(cmd->pool, &arg))) {
  2071.     if (!strcasecmp(str, "max")) {
  2072.         cur = limit->rlim_max;
  2073.     }
  2074.     else {
  2075.         cur = atol(str);
  2076.     }
  2077.     }
  2078.     else {
  2079.     ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, cmd->server,
  2080.              "Invalid parameters for %s", cmd->cmd->name);
  2081.     return;
  2082.     }
  2083.     
  2084.     if (arg2 && (str = ap_getword_conf(cmd->pool, &arg2))) {
  2085.     max = atol(str);
  2086.     }
  2087.  
  2088.     /* if we aren't running as root, cannot increase max */
  2089.     if (geteuid()) {
  2090.     limit->rlim_cur = cur;
  2091.     if (max) {
  2092.         ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, cmd->server,
  2093.              "Must be uid 0 to raise maximum %s", cmd->cmd->name);
  2094.     }
  2095.     }
  2096.     else {
  2097.         if (cur) {
  2098.         limit->rlim_cur = cur;
  2099.     }
  2100.         if (max) {
  2101.         limit->rlim_max = max;
  2102.     }
  2103.     }
  2104. }
  2105. #endif
  2106.  
  2107. #if !defined (RLIMIT_CPU) || !(defined (RLIMIT_DATA) || defined (RLIMIT_VMEM) || defined(RLIMIT_AS)) || !defined (RLIMIT_NPROC)
  2108. static const char *no_set_limit(cmd_parms *cmd, core_dir_config *conf,
  2109.                 char *arg, char *arg2)
  2110. {
  2111.     ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, cmd->server,
  2112.         "%s not supported on this platform", cmd->cmd->name);
  2113.     return NULL;
  2114. }
  2115. #endif
  2116.  
  2117. #ifdef RLIMIT_CPU
  2118. static const char *set_limit_cpu(cmd_parms *cmd, core_dir_config *conf, 
  2119.                  char *arg, char *arg2)
  2120. {
  2121.     set_rlimit(cmd, &conf->limit_cpu, arg, arg2, RLIMIT_CPU);
  2122.     return NULL;
  2123. }
  2124. #endif
  2125.  
  2126. #if defined (RLIMIT_DATA) || defined (RLIMIT_VMEM) || defined(RLIMIT_AS)
  2127. static const char *set_limit_mem(cmd_parms *cmd, core_dir_config *conf, 
  2128.                  char *arg, char * arg2)
  2129. {
  2130. #if defined(RLIMIT_AS)
  2131.     set_rlimit(cmd, &conf->limit_mem, arg, arg2 ,RLIMIT_AS);
  2132. #elif defined(RLIMIT_DATA)
  2133.     set_rlimit(cmd, &conf->limit_mem, arg, arg2, RLIMIT_DATA);
  2134. #elif defined(RLIMIT_VMEM)
  2135.     set_rlimit(cmd, &conf->limit_mem, arg, arg2, RLIMIT_VMEM);
  2136. #endif
  2137.     return NULL;
  2138. }
  2139. #endif
  2140.  
  2141. #ifdef RLIMIT_NPROC
  2142. static const char *set_limit_nproc(cmd_parms *cmd, core_dir_config *conf,  
  2143.                    char *arg, char * arg2)
  2144. {
  2145.     set_rlimit(cmd, &conf->limit_nproc, arg, arg2, RLIMIT_NPROC);
  2146.     return NULL;
  2147. }
  2148. #endif
  2149.  
  2150. static const char *set_bind_address(cmd_parms *cmd, void *dummy, char *arg) 
  2151. {
  2152.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  2153.     if (err != NULL) {
  2154.         return err;
  2155.     }
  2156.  
  2157.     ap_bind_address.s_addr = ap_get_virthost_addr(arg, NULL);
  2158.     return NULL;
  2159. }
  2160.  
  2161. static const char *set_listener(cmd_parms *cmd, void *dummy, char *ips)
  2162. {
  2163.     listen_rec *new;
  2164.     char *ports;
  2165.     unsigned short port;
  2166.  
  2167.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  2168.     if (err != NULL) {
  2169.         return err;
  2170.     }
  2171.  
  2172.     ports = strchr(ips, ':');
  2173.     if (ports != NULL) {
  2174.     if (ports == ips) {
  2175.         return "Missing IP address";
  2176.     }
  2177.     else if (ports[1] == '\0') {
  2178.         return "Address must end in :<port-number>";
  2179.     }
  2180.     *(ports++) = '\0';
  2181.     }
  2182.     else {
  2183.     ports = ips;
  2184.     }
  2185.  
  2186.     new=ap_pcalloc(cmd->pool, sizeof(listen_rec));
  2187.     new->local_addr.sin_family = AF_INET;
  2188.     if (ports == ips) { /* no address */
  2189.     new->local_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  2190.     }
  2191.     else {
  2192.     new->local_addr.sin_addr.s_addr = ap_get_virthost_addr(ips, NULL);
  2193.     }
  2194.     port = atoi(ports);
  2195.     if (!port) {
  2196.     return "Port must be numeric";
  2197.     }
  2198.     new->local_addr.sin_port = htons(port);
  2199.     new->fd = -1;
  2200.     new->used = 0;
  2201.     new->next = ap_listeners;
  2202.     ap_listeners = new;
  2203.     return NULL;
  2204. }
  2205.  
  2206. static const char *set_listenbacklog(cmd_parms *cmd, void *dummy, char *arg) 
  2207. {
  2208.     int b;
  2209.  
  2210.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  2211.     if (err != NULL) {
  2212.         return err;
  2213.     }
  2214.  
  2215.     b = atoi(arg);
  2216.     if (b < 1) {
  2217.         return "ListenBacklog must be > 0";
  2218.     }
  2219.     ap_listenbacklog = b;
  2220.     return NULL;
  2221. }
  2222.  
  2223. static const char *set_coredumpdir (cmd_parms *cmd, void *dummy, char *arg) 
  2224. {
  2225.     struct stat finfo;
  2226.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  2227.     if (err != NULL) {
  2228.         return err;
  2229.     }
  2230.  
  2231.     arg = ap_server_root_relative(cmd->pool, arg);
  2232.     if ((stat(arg, &finfo) == -1) || !S_ISDIR(finfo.st_mode)) {
  2233.     return ap_pstrcat(cmd->pool, "CoreDumpDirectory ", arg, 
  2234.               " does not exist or is not a directory", NULL);
  2235.     }
  2236.     ap_cpystrn(ap_coredump_dir, arg, sizeof(ap_coredump_dir));
  2237.     return NULL;
  2238. }
  2239.  
  2240. static const char *include_config (cmd_parms *cmd, void *dummy, char *name)
  2241. {
  2242.     name = ap_server_root_relative(cmd->pool, name);
  2243.     
  2244.     ap_process_resource_config(cmd->server, name, cmd->pool, cmd->temp_pool);
  2245.  
  2246.     return NULL;
  2247. }
  2248.  
  2249. static const char *set_loglevel(cmd_parms *cmd, void *dummy, const char *arg) 
  2250. {
  2251.     char *str;
  2252.     
  2253.     const char *err = ap_check_cmd_context(cmd,
  2254.                        NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  2255.     if (err != NULL) {
  2256.         return err;
  2257.     }
  2258.  
  2259.     if ((str = ap_getword_conf(cmd->pool, &arg))) {
  2260.         if (!strcasecmp(str, "emerg")) {
  2261.         cmd->server->loglevel = APLOG_EMERG;
  2262.     }
  2263.     else if (!strcasecmp(str, "alert")) {
  2264.         cmd->server->loglevel = APLOG_ALERT;
  2265.     }
  2266.     else if (!strcasecmp(str, "crit")) {
  2267.         cmd->server->loglevel = APLOG_CRIT;
  2268.     }
  2269.     else if (!strcasecmp(str, "error")) {
  2270.         cmd->server->loglevel = APLOG_ERR;
  2271.     }
  2272.     else if (!strcasecmp(str, "warn")) {
  2273.         cmd->server->loglevel = APLOG_WARNING;
  2274.     }
  2275.     else if (!strcasecmp(str, "notice")) {
  2276.         cmd->server->loglevel = APLOG_NOTICE;
  2277.     }
  2278.     else if (!strcasecmp(str, "info")) {
  2279.         cmd->server->loglevel = APLOG_INFO;
  2280.     }
  2281.     else if (!strcasecmp(str, "debug")) {
  2282.         cmd->server->loglevel = APLOG_DEBUG;
  2283.     }
  2284.     else {
  2285.             return "LogLevel requires level keyword: one of "
  2286.                "emerg/alert/crit/error/warn/notice/info/debug";
  2287.     }
  2288.     }
  2289.     else {
  2290.         return "LogLevel requires level keyword";
  2291.     }
  2292.  
  2293.     return NULL;
  2294. }
  2295.  
  2296. API_EXPORT(const char *) ap_psignature(const char *prefix, request_rec *r)
  2297. {
  2298.     char sport[20];
  2299.     core_dir_config *conf;
  2300.  
  2301.     conf = (core_dir_config *)ap_get_module_config(r->per_dir_config,
  2302.                            &core_module);
  2303.     if (conf->server_signature == srv_sig_off) {
  2304.     return "";
  2305.     }
  2306.  
  2307.     ap_snprintf(sport, sizeof sport, "%u", (unsigned) ap_get_server_port(r));
  2308.  
  2309.     if (conf->server_signature == srv_sig_withmail) {
  2310.     return ap_pstrcat(r->pool, prefix, "<ADDRESS>" SERVER_BASEVERSION
  2311.               " Server at <A HREF=\"mailto:",
  2312.               r->server->server_admin, "\">",
  2313.               ap_get_server_name(r), "</A> Port ", sport,
  2314.               "</ADDRESS>\n", NULL);
  2315.     }
  2316.     return ap_pstrcat(r->pool, prefix, "<ADDRESS>" SERVER_BASEVERSION
  2317.               " Server at ", ap_get_server_name(r), " Port ", sport,
  2318.               "</ADDRESS>\n", NULL);
  2319. }
  2320.  
  2321. /*
  2322.  * Load an authorisation realm into our location configuration, applying the
  2323.  * usual rules that apply to realms.
  2324.  */
  2325. static const char *set_authname(cmd_parms *cmd, void *mconfig, char *word1)
  2326. {
  2327.     core_dir_config *aconfig = (core_dir_config *)mconfig;
  2328.  
  2329.     aconfig->ap_auth_name = ap_escape_quotes(cmd->pool, word1);
  2330.     return NULL;
  2331. }
  2332.  
  2333. #ifdef _OSD_POSIX /* BS2000 Logon Passwd file */
  2334. static const char *set_bs2000_account(cmd_parms *cmd, void *dummy, char *name)
  2335. {
  2336.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  2337.     if (err != NULL) {
  2338.         return err;
  2339.     }
  2340.  
  2341.     return os_set_account(cmd->pool, name);
  2342. }
  2343. #endif /*_OSD_POSIX*/
  2344.  
  2345. /*
  2346.  * Handle a request to include the server's OS platform in the Server
  2347.  * response header field (the ServerTokens directive).  Unfortunately
  2348.  * this requires a new global in order to communicate the setting back to
  2349.  * http_main so it can insert the information in the right place in the
  2350.  * string.
  2351.  */
  2352.  
  2353. static const char *set_serv_tokens(cmd_parms *cmd, void *dummy, char *arg) 
  2354. {
  2355.     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
  2356.     if (err != NULL) {
  2357.         return err;
  2358.     }
  2359.  
  2360.     if (!strcasecmp(arg, "OS")) {
  2361.         ap_server_tokens = SrvTk_OS;
  2362.     }
  2363.     else if (!strcasecmp(arg, "Min") || !strcasecmp(arg, "Minimal")) {
  2364.         ap_server_tokens = SrvTk_MIN;
  2365.     }
  2366.     else {
  2367.         ap_server_tokens = SrvTk_FULL;
  2368.     }
  2369.     return NULL;
  2370. }
  2371.  
  2372. static const char *set_limit_req_line(cmd_parms *cmd, void *dummy, char *arg)
  2373. {
  2374.     const char *err = ap_check_cmd_context(cmd,
  2375.                                            NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  2376.     int lim;
  2377.  
  2378.     if (err != NULL) {
  2379.         return err;
  2380.     }
  2381.     lim = atoi(arg);
  2382.     if (lim < 0) {
  2383.         return ap_pstrcat(cmd->temp_pool, "LimitRequestLine \"", arg, 
  2384.                           "\" must be a non-negative integer", NULL);
  2385.     }
  2386.     if (lim > DEFAULT_LIMIT_REQUEST_LINE) {
  2387.         return ap_psprintf(cmd->temp_pool, "LimitRequestLine \"%s\" "
  2388.                            "must not exceed the precompiled maximum of %d",
  2389.                            arg, DEFAULT_LIMIT_REQUEST_LINE);
  2390.     }
  2391.     cmd->server->limit_req_line = lim;
  2392.     return NULL;
  2393. }
  2394.  
  2395. static const char *set_limit_req_fieldsize(cmd_parms *cmd, void *dummy,
  2396.                                            char *arg)
  2397. {
  2398.     const char *err = ap_check_cmd_context(cmd,
  2399.                                            NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  2400.     int lim;
  2401.  
  2402.     if (err != NULL) {
  2403.         return err;
  2404.     }
  2405.     lim = atoi(arg);
  2406.     if (lim < 0) {
  2407.         return ap_pstrcat(cmd->temp_pool, "LimitRequestFieldsize \"", arg, 
  2408.                           "\" must be a non-negative integer (0 = no limit)",
  2409.                           NULL);
  2410.     }
  2411.     if (lim > DEFAULT_LIMIT_REQUEST_FIELDSIZE) {
  2412.         return ap_psprintf(cmd->temp_pool, "LimitRequestFieldsize \"%s\" "
  2413.                           "must not exceed the precompiled maximum of %d",
  2414.                            arg, DEFAULT_LIMIT_REQUEST_FIELDSIZE);
  2415.     }
  2416.     cmd->server->limit_req_fieldsize = lim;
  2417.     return NULL;
  2418. }
  2419.  
  2420. static const char *set_limit_req_fields(cmd_parms *cmd, void *dummy, char *arg)
  2421. {
  2422.     const char *err = ap_check_cmd_context(cmd,
  2423.                                            NOT_IN_DIR_LOC_FILE|NOT_IN_LIMIT);
  2424.     int lim;
  2425.  
  2426.     if (err != NULL) {
  2427.         return err;
  2428.     }
  2429.     lim = atoi(arg);
  2430.     if (lim < 0) {
  2431.         return ap_pstrcat(cmd->temp_pool, "LimitRequestFields \"", arg, 
  2432.                           "\" must be a non-negative integer (0 = no limit)",
  2433.                           NULL);
  2434.     }
  2435.     cmd->server->limit_req_fields = lim;
  2436.     return NULL;
  2437. }
  2438.  
  2439. static const char *set_limit_req_body(cmd_parms *cmd, core_dir_config *conf,
  2440.                                       char *arg) 
  2441. {
  2442.     const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
  2443.     if (err != NULL) {
  2444.         return err;
  2445.     }
  2446.  
  2447.     /* WTF: If strtoul is not portable, then write a replacement.
  2448.      *      Instead we have an idiotic define in httpd.h that prevents
  2449.      *      it from being used even when it is available. Sheesh.
  2450.      */
  2451.     conf->limit_req_body = (unsigned long)strtol(arg, (char **)NULL, 10);
  2452.     return NULL;
  2453. }
  2454.  
  2455. /* Note --- ErrorDocument will now work from .htaccess files.  
  2456.  * The AllowOverride of Fileinfo allows webmasters to turn it off
  2457.  */
  2458.  
  2459. static const command_rec core_cmds[] = {
  2460.  
  2461. /* Old access config file commands */
  2462.  
  2463. { "<Directory", dirsection, NULL, RSRC_CONF, RAW_ARGS,
  2464.   "Container for directives affecting resources located in the specified "
  2465.   "directories" },
  2466. { end_directory_section, end_nested_section, NULL, ACCESS_CONF, NO_ARGS,
  2467.   "Marks end of <Directory>" },
  2468. { "<Location", urlsection, NULL, RSRC_CONF, RAW_ARGS,
  2469.   "Container for directives affecting resources accessed through the "
  2470.   "specified URL paths" },
  2471. { end_location_section, end_nested_section, NULL, ACCESS_CONF, NO_ARGS,
  2472.   "Marks end of <Location>" },
  2473. { "<VirtualHost", virtualhost_section, NULL, RSRC_CONF, RAW_ARGS,
  2474.   "Container to map directives to a particular virtual host, takes one or "
  2475.   "more host addresses" },
  2476. { end_virtualhost_section, end_nested_section, NULL, RSRC_CONF, NO_ARGS,
  2477.   "Marks end of <VirtualHost>" },
  2478. { "<Files", filesection, NULL, OR_ALL, RAW_ARGS, "Container for directives "
  2479.   "affecting files matching specified patterns" },
  2480. { end_files_section, end_nested_section, NULL, OR_ALL, NO_ARGS,
  2481.   "Marks end of <Files>" },
  2482. { "<Limit", ap_limit_section, NULL, OR_ALL, RAW_ARGS, "Container for "
  2483.   "authentication directives when accessed using specified HTTP methods" },
  2484. { "</Limit>", endlimit_section, NULL, OR_ALL, NO_ARGS,
  2485.   "Marks end of <Limit>" },
  2486. { "<IfModule", start_ifmod, NULL, OR_ALL, TAKE1,
  2487.   "Container for directives based on existance of specified modules" },
  2488. { end_ifmodule_section, end_ifmod, NULL, OR_ALL, NO_ARGS,
  2489.   "Marks end of <IfModule>" },
  2490. { "<IfDefine", start_ifdefine, NULL, OR_ALL, TAKE1,
  2491.   "Container for directives based on existance of command line defines" },
  2492. { end_ifdefine_section, end_ifdefine, NULL, OR_ALL, NO_ARGS,
  2493.   "Marks end of <IfDefine>" },
  2494. { "<DirectoryMatch", dirsection, (void*)1, RSRC_CONF, RAW_ARGS,
  2495.   "Container for directives affecting resources located in the "
  2496.   "specified directories" },
  2497. { end_directorymatch_section, end_nested_section, NULL, ACCESS_CONF, NO_ARGS,
  2498.   "Marks end of <DirectoryMatch>" },
  2499. { "<LocationMatch", urlsection, (void*)1, RSRC_CONF, RAW_ARGS,
  2500.   "Container for directives affecting resources accessed through the "
  2501.   "specified URL paths" },
  2502. { end_locationmatch_section, end_nested_section, NULL, ACCESS_CONF, NO_ARGS,
  2503.   "Marks end of <LocationMatch>" },
  2504. { "<FilesMatch", filesection, (void*)1, OR_ALL, RAW_ARGS,
  2505.   "Container for directives affecting files matching specified patterns" },
  2506. { end_filesmatch_section, end_nested_section, NULL, OR_ALL, NO_ARGS,
  2507.   "Marks end of <FilesMatch>" },
  2508. { "AuthType", ap_set_string_slot,
  2509.   (void*)XtOffsetOf(core_dir_config, ap_auth_type), OR_AUTHCFG, TAKE1,
  2510.   "An HTTP authorization type (e.g., \"Basic\")" },
  2511. { "AuthName", set_authname, NULL, OR_AUTHCFG, TAKE1,
  2512.   "The authentication realm (e.g. \"Members Only\")" },
  2513. { "Require", require, NULL, OR_AUTHCFG, RAW_ARGS,
  2514.   "Selects which authenticated users or groups may access a protected space" },
  2515. { "Satisfy", satisfy, NULL, OR_AUTHCFG, TAKE1,
  2516.   "access policy if both allow and require used ('all' or 'any')" },    
  2517. #ifdef GPROF
  2518. { "GprofDir", set_gprof_dir, NULL, RSRC_CONF, TAKE1,
  2519.   "Directory to plop gmon.out files" },
  2520. #endif
  2521.  
  2522. /* Old resource config file commands */
  2523.   
  2524. { "AccessFileName", set_access_name, NULL, RSRC_CONF, RAW_ARGS,
  2525.   "Name(s) of per-directory config files (default: .htaccess)" },
  2526. { "DocumentRoot", set_document_root, NULL, RSRC_CONF, TAKE1,
  2527.   "Root directory of the document tree"  },
  2528. { "ErrorDocument", set_error_document, NULL, OR_FILEINFO, RAW_ARGS,
  2529.   "Change responses for HTTP errors" },
  2530. { "AllowOverride", set_override, NULL, ACCESS_CONF, RAW_ARGS,
  2531.   "Controls what groups of directives can be configured by per-directory "
  2532.   "config files" },
  2533. { "Options", set_options, NULL, OR_OPTIONS, RAW_ARGS,
  2534.   "Set a number of attributes for a given directory" },
  2535. { "DefaultType", ap_set_string_slot,
  2536.   (void*)XtOffsetOf (core_dir_config, ap_default_type),
  2537.   OR_FILEINFO, TAKE1, "the default MIME type for untypable files" },
  2538.  
  2539. /* Old server config file commands */
  2540.  
  2541. { "ServerType", server_type, NULL, RSRC_CONF, TAKE1,
  2542.   "'inetd' or 'standalone'"},
  2543. { "Port", server_port, NULL, RSRC_CONF, TAKE1, "A TCP port number"},
  2544. { "HostnameLookups", set_hostname_lookups, NULL, ACCESS_CONF|RSRC_CONF, TAKE1,
  2545.   "\"on\" to enable, \"off\" to disable reverse DNS lookups, or \"double\" to "
  2546.   "enable double-reverse DNS lookups" },
  2547. { "User", set_user, NULL, RSRC_CONF, TAKE1,
  2548.   "Effective user id for this server"},
  2549. { "Group", set_group, NULL, RSRC_CONF, TAKE1,
  2550.   "Effective group id for this server"},
  2551. { "ServerAdmin", set_server_string_slot,
  2552.   (void *)XtOffsetOf (server_rec, server_admin), RSRC_CONF, TAKE1,
  2553.   "The email address of the server administrator" },
  2554. { "ServerName", set_server_string_slot,
  2555.   (void *)XtOffsetOf (server_rec, server_hostname), RSRC_CONF, TAKE1,
  2556.   "The hostname of the server" },
  2557. { "ServerSignature", set_signature_flag, NULL, ACCESS_CONF|RSRC_CONF, TAKE1,
  2558.   "En-/disable server signature (on|off|email)" },
  2559. { "ServerRoot", set_server_root, NULL, RSRC_CONF, TAKE1,
  2560.   "Common directory of server-related files (logs, confs, etc.)" },
  2561. { "ErrorLog", set_server_string_slot,
  2562.   (void *)XtOffsetOf (server_rec, error_fname), RSRC_CONF, TAKE1,
  2563.   "The filename of the error log" },
  2564. { "PidFile", set_pidfile, NULL, RSRC_CONF, TAKE1,
  2565.     "A file for logging the server process ID"},
  2566. { "ScoreBoardFile", set_scoreboard, NULL, RSRC_CONF, TAKE1,
  2567.     "A file for Apache to maintain runtime process management information"},
  2568. { "LockFile", set_lockfile, NULL, RSRC_CONF, TAKE1,
  2569.     "The lockfile used when Apache needs to lock the accept() call"},
  2570. { "AccessConfig", set_server_string_slot,
  2571.   (void *)XtOffsetOf (server_rec, access_confname), RSRC_CONF, TAKE1,
  2572.   "The filename of the access config file" },
  2573. { "ResourceConfig", set_server_string_slot,
  2574.   (void *)XtOffsetOf (server_rec, srm_confname), RSRC_CONF, TAKE1,
  2575.   "The filename of the resource config file" },
  2576. { "ServerAlias", set_server_alias, NULL, RSRC_CONF, RAW_ARGS,
  2577.   "A name or names alternately used to access the server" },
  2578. { "ServerPath", set_serverpath, NULL, RSRC_CONF, TAKE1,
  2579.   "The pathname the server can be reached at" },
  2580. { "Timeout", set_timeout, NULL, RSRC_CONF, TAKE1, "Timeout duration (sec)" },
  2581. { "KeepAliveTimeout", set_keep_alive_timeout, NULL, RSRC_CONF, TAKE1,
  2582.   "Keep-Alive timeout duration (sec)"},
  2583. { "MaxKeepAliveRequests", set_keep_alive_max, NULL, RSRC_CONF, TAKE1,
  2584.   "Maximum number of Keep-Alive requests per connection, or 0 for infinite" },
  2585. { "KeepAlive", set_keep_alive, NULL, RSRC_CONF, TAKE1,
  2586.   "Whether persistent connections should be On or Off" },
  2587. { "IdentityCheck", set_idcheck, NULL, RSRC_CONF|ACCESS_CONF, FLAG,
  2588.   "Enable identd (RFC 1413) user lookups - SLOW" },
  2589. { "ContentDigest", set_content_md5, NULL, OR_OPTIONS,
  2590.   FLAG, "whether or not to send a Content-MD5 header with each request" },
  2591. { "UseCanonicalName", set_use_canonical_name, NULL,
  2592.   OR_OPTIONS, FLAG,
  2593.   "Whether or not to always use the canonical ServerName : Port when "
  2594.   "constructing URLs" },
  2595. { "StartServers", set_daemons_to_start, NULL, RSRC_CONF, TAKE1,
  2596.   "Number of child processes launched at server startup" },
  2597. { "MinSpareServers", set_min_free_servers, NULL, RSRC_CONF, TAKE1,
  2598.   "Minimum number of idle children, to handle request spikes" },
  2599. { "MaxSpareServers", set_max_free_servers, NULL, RSRC_CONF, TAKE1,
  2600.   "Maximum number of idle children" },
  2601. { "MaxServers", set_max_free_servers, NULL, RSRC_CONF, TAKE1,
  2602.   "Deprecated equivalent to MaxSpareServers" },
  2603. { "ServersSafetyLimit", set_server_limit, NULL, RSRC_CONF, TAKE1,
  2604.   "Deprecated equivalent to MaxClients" },
  2605. { "MaxClients", set_server_limit, NULL, RSRC_CONF, TAKE1,
  2606.   "Maximum number of children alive at the same time" },
  2607. { "MaxRequestsPerChild", set_max_requests, NULL, RSRC_CONF, TAKE1,
  2608.   "Maximum number of requests a particular child serves before dying." },
  2609. { "RLimitCPU",
  2610. #ifdef RLIMIT_CPU
  2611.   set_limit_cpu, (void*)XtOffsetOf(core_dir_config, limit_cpu),
  2612. #else
  2613.   no_set_limit, NULL,
  2614. #endif
  2615.   OR_ALL, TAKE12, "Soft/hard limits for max CPU usage in seconds" },
  2616. { "RLimitMEM",
  2617. #if defined (RLIMIT_DATA) || defined (RLIMIT_VMEM) || defined (RLIMIT_AS)
  2618.   set_limit_mem, (void*)XtOffsetOf(core_dir_config, limit_mem),
  2619. #else
  2620.   no_set_limit, NULL,
  2621. #endif
  2622.   OR_ALL, TAKE12, "Soft/hard limits for max memory usage per process" },
  2623. { "RLimitNPROC",
  2624. #ifdef RLIMIT_NPROC
  2625.   set_limit_nproc, (void*)XtOffsetOf(core_dir_config, limit_nproc),
  2626. #else
  2627.   no_set_limit, NULL,
  2628. #endif
  2629.    OR_ALL, TAKE12, "soft/hard limits for max number of processes per uid" },
  2630. { "BindAddress", set_bind_address, NULL, RSRC_CONF, TAKE1,
  2631.   "'*', a numeric IP address, or the name of a host with a unique IP address"},
  2632. { "Listen", set_listener, NULL, RSRC_CONF, TAKE1,
  2633.   "A port number or a numeric IP address and a port number"},
  2634. { "SendBufferSize", set_send_buffer_size, NULL, RSRC_CONF, TAKE1,
  2635.   "Send buffer size in bytes"},
  2636. { "AddModule", add_module_command, NULL, RSRC_CONF, ITERATE,
  2637.   "The name of a module" },
  2638. { "ClearModuleList", clear_module_list_command, NULL, RSRC_CONF, NO_ARGS, 
  2639.   NULL },
  2640. { "ThreadsPerChild", set_threads, NULL, RSRC_CONF, TAKE1,
  2641.   "Number of threads a child creates" },
  2642. { "ExcessRequestsPerChild", set_excess_requests, NULL, RSRC_CONF, TAKE1,
  2643.   "Maximum number of requests a particular child serves after it is ready "
  2644.   "to die." },
  2645. { "ListenBacklog", set_listenbacklog, NULL, RSRC_CONF, TAKE1,
  2646.   "Maximum length of the queue of pending connections, as used by listen(2)" },
  2647. { "CoreDumpDirectory", set_coredumpdir, NULL, RSRC_CONF, TAKE1,
  2648.   "The location of the directory Apache changes to before dumping core" },
  2649. { "Include", include_config, NULL, (RSRC_CONF | ACCESS_CONF), TAKE1,
  2650.   "Name of the config file to be included" },
  2651. { "LogLevel", set_loglevel, NULL, RSRC_CONF, TAKE1,
  2652.   "Level of verbosity in error logging" },
  2653. { "NameVirtualHost", ap_set_name_virtual_host, NULL, RSRC_CONF, TAKE1,
  2654.   "A numeric IP address:port, or the name of a host" },
  2655. #ifdef _OSD_POSIX
  2656. { "BS2000Account", set_bs2000_account, NULL, RSRC_CONF, TAKE1,
  2657.   "Name of server User's bs2000 logon account name" },
  2658. #endif
  2659. { "ServerTokens", set_serv_tokens, NULL, RSRC_CONF, TAKE1,
  2660.   "Determine tokens displayed in the Server: header - Min(imal), OS or Full" },
  2661. { "LimitRequestLine", set_limit_req_line, NULL, RSRC_CONF, TAKE1,
  2662.   "Limit on maximum size of an HTTP request line"},
  2663. { "LimitRequestFieldsize", set_limit_req_fieldsize, NULL, RSRC_CONF, TAKE1,
  2664.   "Limit on maximum size of an HTTP request header field"},
  2665. { "LimitRequestFields", set_limit_req_fields, NULL, RSRC_CONF, TAKE1,
  2666.   "Limit (0 = unlimited) on max number of header fields in a request message"},
  2667. { "LimitRequestBody", set_limit_req_body,
  2668.   (void*)XtOffsetOf(core_dir_config, limit_req_body),
  2669.   OR_ALL, TAKE1,
  2670.   "Limit (in bytes) on maximum size of request message body" },
  2671. { NULL },
  2672. };
  2673.  
  2674. /*****************************************************************
  2675.  *
  2676.  * Core handlers for various phases of server operation...
  2677.  */
  2678.  
  2679. static int core_translate(request_rec *r)
  2680. {
  2681.     void *sconf = r->server->module_config;
  2682.     core_server_config *conf = ap_get_module_config(sconf, &core_module);
  2683.   
  2684.     if (r->proxyreq) {
  2685.         return HTTP_FORBIDDEN;
  2686.     }
  2687.     if ((r->uri[0] != '/') && strcmp(r->uri, "*")) {
  2688.     ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, r,
  2689.              "Invalid URI in request %s", r->the_request);
  2690.     return BAD_REQUEST;
  2691.     }
  2692.     
  2693.     if (r->server->path 
  2694.     && !strncmp(r->uri, r->server->path, r->server->pathlen)
  2695.     && (r->server->path[r->server->pathlen - 1] == '/'
  2696.         || r->uri[r->server->pathlen] == '/'
  2697.         || r->uri[r->server->pathlen] == '\0')) {
  2698.         r->filename = ap_pstrcat(r->pool, conf->ap_document_root,
  2699.                  (r->uri + r->server->pathlen), NULL);
  2700.     }
  2701.     else {
  2702.     /*
  2703.          * Make sure that we do not mess up the translation by adding two
  2704.          * /'s in a row.  This happens under windows when the document
  2705.          * root ends with a /
  2706.          */
  2707.         if ((conf->ap_document_root[strlen(conf->ap_document_root)-1] == '/')
  2708.         && (*(r->uri) == '/')) {
  2709.         r->filename = ap_pstrcat(r->pool, conf->ap_document_root, r->uri+1,
  2710.                      NULL);
  2711.     }
  2712.     else {
  2713.         r->filename = ap_pstrcat(r->pool, conf->ap_document_root, r->uri,
  2714.                      NULL);
  2715.     }
  2716.     }
  2717.  
  2718.     return OK;
  2719. }
  2720.  
  2721. static int do_nothing(request_rec *r) { return OK; }
  2722.  
  2723. #ifdef USE_MMAP_FILES
  2724. struct mmap {
  2725.     void *mm;
  2726.     size_t length;
  2727. };
  2728.  
  2729. static void mmap_cleanup(void *mmv)
  2730. {
  2731.     struct mmap *mmd = mmv;
  2732.  
  2733.     munmap(mmd->mm, mmd->length);
  2734. }
  2735. #endif
  2736.  
  2737. /*
  2738.  * Default handler for MIME types without other handlers.  Only GET
  2739.  * and OPTIONS at this point... anyone who wants to write a generic
  2740.  * handler for PUT or POST is free to do so, but it seems unwise to provide
  2741.  * any defaults yet... So, for now, we assume that this will always be
  2742.  * the last handler called and return 405 or 501.
  2743.  */
  2744.  
  2745. static int default_handler(request_rec *r)
  2746. {
  2747.     core_dir_config *d =
  2748.       (core_dir_config *)ap_get_module_config(r->per_dir_config, &core_module);
  2749.     int rangestatus, errstatus;
  2750.     FILE *f;
  2751. #ifdef USE_MMAP_FILES
  2752.     caddr_t mm;
  2753. #endif
  2754.  
  2755.     /* This handler has no use for a request body (yet), but we still
  2756.      * need to read and discard it if the client sent one.
  2757.      */
  2758.     if ((errstatus = ap_discard_request_body(r)) != OK) {
  2759.         return errstatus;
  2760.     }
  2761.  
  2762.     r->allowed |= (1 << M_GET) | (1 << M_OPTIONS);
  2763.  
  2764.     if (r->method_number == M_INVALID) {
  2765.     ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, r,
  2766.             "Invalid method in request %s", r->the_request);
  2767.     return NOT_IMPLEMENTED;
  2768.     }
  2769.     if (r->method_number == M_OPTIONS) {
  2770.         return ap_send_http_options(r);
  2771.     }
  2772.     if (r->method_number == M_PUT) {
  2773.         return METHOD_NOT_ALLOWED;
  2774.     }
  2775.  
  2776.     if (r->finfo.st_mode == 0 || (r->path_info && *r->path_info)) {
  2777.     char *emsg;
  2778.  
  2779.     emsg = "File does not exist: ";
  2780.     if (r->path_info == NULL) {
  2781.         emsg = ap_pstrcat(r->pool, emsg, r->filename, NULL);
  2782.     }
  2783.     else {
  2784.         emsg = ap_pstrcat(r->pool, emsg, r->filename, r->path_info, NULL);
  2785.     }
  2786.     ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, r, "%s", emsg);
  2787.     return HTTP_NOT_FOUND;
  2788.     }
  2789.     if (r->method_number != M_GET) {
  2790.         return METHOD_NOT_ALLOWED;
  2791.     }
  2792.     
  2793. #if defined(OS2) || defined(WIN32)
  2794.     /* Need binary mode for OS/2 */
  2795.     f = ap_pfopen(r->pool, r->filename, "rb");
  2796. #else
  2797.     f = ap_pfopen(r->pool, r->filename, "r");
  2798. #endif
  2799.  
  2800.     if (f == NULL) {
  2801.         ap_log_rerror(APLOG_MARK, APLOG_ERR, r,
  2802.              "file permissions deny server access: %s", r->filename);
  2803.         return FORBIDDEN;
  2804.     }
  2805.     
  2806.     ap_update_mtime(r, r->finfo.st_mtime);
  2807.     ap_set_last_modified(r);
  2808.     ap_set_etag(r);
  2809.     ap_table_setn(r->headers_out, "Accept-Ranges", "bytes");
  2810.     if (((errstatus = ap_meets_conditions(r)) != OK)
  2811.     || (errstatus = ap_set_content_length(r, r->finfo.st_size))) {
  2812.         return errstatus;
  2813.     }
  2814.  
  2815. #ifdef USE_MMAP_FILES
  2816.     ap_block_alarms();
  2817.     if ((r->finfo.st_size >= MMAP_THRESHOLD)
  2818.     && (!r->header_only || (d->content_md5 & 1))) {
  2819.     /* we need to protect ourselves in case we die while we've got the
  2820.       * file mmapped */
  2821.     mm = mmap(NULL, r->finfo.st_size, PROT_READ, MAP_PRIVATE,
  2822.           fileno(f), 0);
  2823.     if (mm == (caddr_t)-1) {
  2824.         ap_log_rerror(APLOG_MARK, APLOG_CRIT, r,
  2825.              "default_handler: mmap failed: %s", r->filename);
  2826.     }
  2827.     }
  2828.     else {
  2829.     mm = (caddr_t)-1;
  2830.     }
  2831.  
  2832.     if (mm == (caddr_t)-1) {
  2833.     ap_unblock_alarms();
  2834. #endif
  2835.  
  2836.     if (d->content_md5 & 1) {
  2837.         ap_table_setn(r->headers_out, "Content-MD5",
  2838.               ap_md5digest(r->pool, f));
  2839.     }
  2840.  
  2841.     rangestatus = ap_set_byterange(r);
  2842. #ifdef CHARSET_EBCDIC
  2843.     /* To make serving of "raw ASCII text" files easy (they serve faster 
  2844.      * since they don't have to be converted from EBCDIC), a new
  2845.      * "magic" type prefix was invented: text/x-ascii-{plain,html,...}
  2846.      * If we detect one of these content types here, we simply correct
  2847.      * the type to the real text/{plain,html,...} type. Otherwise, we
  2848.      * set a flag that translation is required later on.
  2849.      */
  2850.         ap_checkconv(r);
  2851. #endif /*CHARSET_EBCDIC*/
  2852.  
  2853.     ap_send_http_header(r);
  2854.     
  2855.     if (!r->header_only) {
  2856.         if (!rangestatus) {
  2857.         ap_send_fd(f, r);
  2858.         }
  2859.         else {
  2860.         long offset, length;
  2861.         while (ap_each_byterange(r, &offset, &length)) {
  2862.             fseek(f, offset, SEEK_SET);
  2863.             ap_send_fd_length(f, r, length);
  2864.         }
  2865.         }
  2866.     }
  2867.  
  2868. #ifdef USE_MMAP_FILES
  2869.     }
  2870.     else {
  2871.     struct mmap *mmd;
  2872.  
  2873.     mmd = ap_palloc(r->pool, sizeof(*mmd));
  2874.     mmd->mm = mm;
  2875.     mmd->length = r->finfo.st_size;
  2876.     ap_register_cleanup(r->pool, (void *)mmd, mmap_cleanup, mmap_cleanup);
  2877.     ap_unblock_alarms();
  2878.  
  2879.     if (d->content_md5 & 1) {
  2880.         AP_MD5_CTX context;
  2881.         
  2882.         ap_MD5Init(&context);
  2883.         ap_MD5Update(&context, (void *)mm, r->finfo.st_size);
  2884.         ap_table_setn(r->headers_out, "Content-MD5",
  2885.               ap_md5contextTo64(r->pool, &context));
  2886.     }
  2887.  
  2888.     rangestatus = ap_set_byterange(r);
  2889.     ap_send_http_header(r);
  2890.     
  2891.     if (!r->header_only) {
  2892.         if (!rangestatus) {
  2893.         ap_send_mmap(mm, r, 0, r->finfo.st_size);
  2894.         }
  2895.         else {
  2896.         long offset, length;
  2897.         while (ap_each_byterange(r, &offset, &length)) {
  2898.             ap_send_mmap(mm, r, offset, length);
  2899.         }
  2900.         }
  2901.     }
  2902.     }
  2903. #endif
  2904.  
  2905.     ap_pfclose(r->pool, f);
  2906.     return OK;
  2907. }
  2908.  
  2909. static const handler_rec core_handlers[] = {
  2910. { "*/*", default_handler },
  2911. { "default-handler", default_handler },
  2912. { NULL }
  2913. };
  2914.  
  2915. API_VAR_EXPORT module core_module = {
  2916.     STANDARD_MODULE_STUFF,
  2917.     NULL,            /* initializer */
  2918.     create_core_dir_config,    /* create per-directory config structure */
  2919.     merge_core_dir_configs,    /* merge per-directory config structures */
  2920.     create_core_server_config,    /* create per-server config structure */
  2921.     merge_core_server_configs,    /* merge per-server config structures */
  2922.     core_cmds,            /* command table */
  2923.     core_handlers,        /* handlers */
  2924.     core_translate,        /* translate_handler */
  2925.     NULL,            /* check_user_id */
  2926.     NULL,            /* check auth */
  2927.     do_nothing,            /* check access */
  2928.     do_nothing,            /* type_checker */
  2929.     NULL,            /* pre-run fixups */
  2930.     NULL,            /* logger */
  2931.     NULL,            /* header parser */
  2932.     NULL,            /* child_init */
  2933.     NULL,            /* child_exit */
  2934.     NULL            /* post_read_request */
  2935. };
  2936.