home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 8 / CDACTUAL8.iso / share / os2 / varios / apache / http_cor.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-12  |  30.0 KB  |  951 lines
  1.  
  2. /* ====================================================================
  3.  * Copyright (c) 1995 The Apache Group.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer. 
  11.  *
  12.  * 2. Redistributions in binary form must reproduce the above copyright
  13.  *    notice, this list of conditions and the following disclaimer in
  14.  *    the documentation and/or other materials provided with the
  15.  *    distribution.
  16.  *
  17.  * 3. All advertising materials mentioning features or use of this
  18.  *    software must display the following acknowledgment:
  19.  *    "This product includes software developed by the Apache Group
  20.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  21.  *
  22.  * 4. The names "Apache Server" and "Apache Group" must not be used to
  23.  *    endorse or promote products derived from this software without
  24.  *    prior written permission.
  25.  *
  26.  * 5. Redistributions of any form whatsoever must retain the following
  27.  *    acknowledgment:
  28.  *    "This product includes software developed by the Apache Group
  29.  *    for use in the Apache HTTP server project (http://www.apache.org/)."
  30.  *
  31.  * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
  32.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  34.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR
  35.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  36.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  37.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  38.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  41.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  42.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  43.  * ====================================================================
  44.  *
  45.  * This software consists of voluntary contributions made by many
  46.  * individuals on behalf of the Apache Group and was originally based
  47.  * on public domain software written at the National Center for
  48.  * Supercomputing Applications, University of Illinois, Urbana-Champaign.
  49.  * For more information on the Apache Group and the Apache HTTP server
  50.  * project, please see <http://www.apache.org/>.
  51.  *
  52.  */
  53.  
  54.  
  55. #define CORE_PRIVATE
  56. #include "httpd.h"
  57. #include "http_config.h"
  58. #include "http_core.h"
  59. #include "http_protocol.h"    /* For index_of_response().  Grump. */
  60. #include "http_conf_globals.h"
  61.  
  62. #include "http_main.h"        /* For the default_handler below... */
  63. #include "http_log.h"
  64. #include "rfc1413.h"
  65. #include "util_md5.h"
  66. #include "scoreboard.h"
  67.  
  68. /* Server core module... This module provides support for really basic
  69.  * server operations, including options and commands which control the
  70.  * operation of other modules.  Consider this the bureaucracy module.
  71.  *
  72.  * The core module also defines handlers, etc., do handle just enough
  73.  * to allow a server with the core module ONLY to actually serve documents
  74.  * (though it slaps DefaultType on all of 'em); this was useful in testing,
  75.  * but may not be worth preserving.
  76.  *
  77.  * This file could almost be mod_core.c, except for the stuff which affects
  78.  * the http_conf_globals.
  79.  */
  80.  
  81. void *create_core_dir_config (pool *a, char *dir)
  82. {
  83.     core_dir_config *conf =
  84.       (core_dir_config *)pcalloc(a, sizeof(core_dir_config));
  85.   
  86.     if (!dir || dir[strlen(dir) - 1] == '/') conf->d = dir;
  87.     else conf->d = pstrcat (a, dir, "/", NULL);
  88.  
  89.     conf->opts = dir ? OPT_UNSET : OPT_ALL;
  90.     conf->override = dir ? OR_UNSET : OR_ALL;
  91.  
  92.     conf->content_md5 = 2;
  93.  
  94.     conf->hostname_lookups = 2;/* binary, but will use 2 as an "unset = on" */
  95.     conf->do_rfc1413 = DEFAULT_RFC1413 | 2;  /* set bit 1 to indicate default */
  96.     return (void *)conf;
  97. }
  98.  
  99. void *merge_core_dir_configs (pool *a, void *basev, void *newv)
  100. {
  101.     core_dir_config *base = (core_dir_config *)basev;
  102.     core_dir_config *new = (core_dir_config *)newv;
  103.     core_dir_config *conf =
  104.       (core_dir_config *)pcalloc (a, sizeof(core_dir_config));
  105.     int i;
  106.   
  107.     memcpy ((char *)conf, (const char *)base, sizeof(core_dir_config));
  108.     
  109.     conf->d = new->d;
  110.     
  111.     if (new->opts != OPT_UNSET) conf->opts = new->opts;
  112.     if (new->override != OR_UNSET) conf->override = new->override;
  113.     if (new->default_type) conf->default_type = new->default_type;
  114.     
  115.     if (new->auth_type) conf->auth_type = new->auth_type;
  116.     if (new->auth_name) conf->auth_name = new->auth_name;
  117.     if (new->requires) conf->requires = new->requires;
  118.  
  119.     for (i = 0; i <= RESPONSE_CODES; ++i)
  120.         if (new->response_code_strings[i] != NULL)
  121.        conf->response_code_strings[i] = new->response_code_strings[i];
  122.     if (new->hostname_lookups != 2)
  123.     conf->hostname_lookups = new->hostname_lookups;
  124.     if ((new->do_rfc1413 & 2) == 0) conf->do_rfc1413 = new->do_rfc1413;
  125.     if ((new->content_md5 & 2) == 0) conf->content_md5 = new->content_md5;
  126.  
  127.     return (void*)conf;
  128. }
  129.  
  130. void *create_core_server_config (pool *a, server_rec *s)
  131. {
  132.     core_server_config *conf =
  133.       (core_server_config *)pcalloc(a, sizeof(core_server_config));
  134.     int is_virtual = s->is_virtual;
  135.   
  136.     conf->access_name = is_virtual ? NULL : DEFAULT_ACCESS_FNAME;
  137.     conf->document_root = is_virtual ? NULL : DOCUMENT_LOCATION;
  138.     conf->sec = make_array (a, 40, sizeof(void *));
  139.     conf->sec_url = make_array (a, 40, sizeof(void *));
  140.     
  141.     return (void *)conf;
  142. }
  143.  
  144. void *merge_core_server_configs (pool *p, void *basev, void *virtv)
  145. {
  146.     core_server_config *base = (core_server_config *)basev;
  147.     core_server_config *virt = (core_server_config *)virtv;
  148.     core_server_config *conf = 
  149.     (core_server_config *)pcalloc(p, sizeof(core_server_config));
  150.  
  151.     *conf = *virt;
  152.     if (!conf->access_name) conf->access_name = base->access_name;
  153.     if (!conf->document_root) conf->document_root = base->document_root;
  154.     conf->sec = append_arrays (p, virt->sec, base->sec);
  155.     conf->sec_url = append_arrays (p, virt->sec_url, base->sec_url);
  156.  
  157.     return conf;
  158. }
  159.  
  160. /* Add per-directory configuration entry (for <directory> section);
  161.  * these are part of the core server config.
  162.  */
  163.  
  164. void add_per_dir_conf (server_rec *s, void *dir_config)
  165. {
  166.     core_server_config *sconf = get_module_config (s->module_config,
  167.                            &core_module);
  168.     void **new_space = (void **) push_array (sconf->sec);
  169.     
  170.     *new_space = dir_config;
  171. }
  172.  
  173. void add_per_url_conf (server_rec *s, void *url_config)
  174. {
  175.     core_server_config *sconf = get_module_config (s->module_config,
  176.                            &core_module);
  177.     void **new_space = (void **) push_array (sconf->sec_url);
  178.     
  179.     *new_space = url_config;
  180. }
  181.  
  182. /*****************************************************************
  183.  *
  184.  * There are some elements of the core config structures in which
  185.  * other modules have a legitimate interest (this is ugly, but necessary
  186.  * to preserve NCSA back-compatibility).  So, we have a bunch of accessors
  187.  * here...
  188.  */
  189.  
  190. int allow_options (request_rec *r)
  191. {
  192.     core_dir_config *conf = 
  193.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  194.  
  195.     return conf->opts; 
  196. } 
  197.  
  198. int allow_overrides (request_rec *r) 
  199. { 
  200.     core_dir_config *conf = 
  201.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  202.  
  203.     return conf->override; 
  204. } 
  205.  
  206. char *auth_type (request_rec *r)
  207. {
  208.     core_dir_config *conf = 
  209.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  210.  
  211.     return conf->auth_type;
  212. }
  213.  
  214. char *auth_name (request_rec *r)
  215. {
  216.     core_dir_config *conf = 
  217.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  218.  
  219.     return conf->auth_name;
  220. }
  221.  
  222. char *default_type (request_rec *r)
  223. {
  224.     core_dir_config *conf = 
  225.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  226.  
  227.     return conf->default_type ? conf->default_type : DEFAULT_TYPE;
  228. }
  229.  
  230. char *document_root (request_rec *r) /* Don't use this!!! */
  231. {
  232.     core_server_config *conf = 
  233.       (core_server_config *)get_module_config(r->server->module_config,
  234.                           &core_module); 
  235.  
  236.     return conf->document_root;
  237. }
  238.  
  239. array_header *requires (request_rec *r)
  240. {
  241.     core_dir_config *conf = 
  242.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  243.  
  244.     return conf->requires;
  245. }
  246.  
  247.  
  248. /* Should probably just get rid of this... the only code that cares is
  249.  * part of the core anyway (and in fact, it isn't publicised to other
  250.  * modules).
  251.  */
  252.  
  253. char *response_code_string (request_rec *r, int error_index)
  254. {
  255.     core_dir_config *conf = 
  256.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module); 
  257.  
  258.     return conf->response_code_strings[error_index];
  259. }
  260.  
  261. const char *
  262. get_remote_host(conn_rec *conn, void *dir_config, int type)
  263. {
  264.     struct in_addr *iaddr;
  265.     struct hostent *hptr;
  266. #ifdef MAXIMUM_DNS
  267.     char **haddr;
  268. #endif
  269.     core_dir_config *dir_conf;
  270.  
  271. /* If we haven't checked the host name, and we want to */
  272.     dir_conf = (core_dir_config *)get_module_config(dir_config, &core_module);
  273.  
  274.     if (conn->remote_host == NULL && dir_conf->hostname_lookups)
  275.     {
  276. #ifdef STATUS
  277.     int old_stat = update_child_status(conn->child_num,
  278.                         SERVER_BUSY_DNS,
  279.                         (request_rec*)NULL);
  280. #endif /* STATUS */
  281.     iaddr = &(conn->remote_addr.sin_addr);
  282.     hptr = gethostbyaddr((char *)iaddr, sizeof(struct in_addr), AF_INET);
  283.     if (hptr != NULL)
  284.     {
  285.         conn->remote_host = pstrdup(conn->pool, (void *)hptr->h_name);
  286.         str_tolower (conn->remote_host);
  287.        
  288. #ifdef MAXIMUM_DNS
  289.     /* Grrr. Check THAT name to make sure it's really the name of the addr. */
  290.     /* Code from Harald Hanche-Olsen <hanche@imf.unit.no> */
  291.  
  292.         hptr = gethostbyname(conn->remote_host);
  293.         if (hptr)
  294.         {
  295.         for(haddr=hptr->h_addr_list; *haddr; haddr++)
  296.             if(((struct in_addr *)(*haddr))->s_addr == iaddr->s_addr)
  297.             break;
  298.         }
  299.         if((!hptr) || (!(*haddr)))
  300.         conn->remote_host = NULL;
  301. #endif
  302.     }
  303. /* if failed, set it to the NULL string to indicate error */
  304.     if (conn->remote_host == NULL) conn->remote_host = "";
  305. #ifdef STATUS
  306.     (void)update_child_status(conn->child_num,old_stat,(request_rec*)NULL);
  307. #endif /* STATUS */
  308.     }
  309.  
  310. /*
  311.  * Return the desired information; either the remote DNS name, if found,
  312.  * or either NULL (if the hostname was requested) or the IP address
  313.  * (if any identifier was requested).
  314.  */
  315.     if (conn->remote_host != NULL && conn->remote_host[0] != '\0')
  316.     return conn->remote_host;
  317.     else
  318.     {
  319.     if (type == REMOTE_HOST) return NULL;
  320.     else return conn->remote_ip;
  321.     }
  322. }
  323.  
  324. const char *
  325. get_remote_logname(request_rec *r)
  326. {
  327.     core_dir_config *dir_conf;
  328.  
  329.     if (r->connection->remote_logname != NULL)
  330.     return r->connection->remote_logname;
  331.  
  332. /* If we haven't checked the identity, and we want to */
  333.     dir_conf = (core_dir_config *)
  334.     get_module_config(r->per_dir_config, &core_module);
  335.  
  336.     if (dir_conf->do_rfc1413 & 1)
  337.     return rfc1413(r->connection, r->server);
  338.     else
  339.     return NULL;
  340. }
  341.  
  342. /*****************************************************************
  343.  *
  344.  * Commands... this module handles almost all of the NCSA httpd.conf
  345.  * commands, but most of the old srm.conf is in the the modules.
  346.  */
  347.  
  348. char *set_access_name (cmd_parms *cmd, void *dummy, char *arg)
  349. {
  350.     void *sconf = cmd->server->module_config;
  351.     core_server_config *conf = get_module_config (sconf, &core_module);
  352.   
  353.     conf->access_name = arg;
  354.     return NULL;
  355. }
  356.  
  357. char *set_document_root (cmd_parms *cmd, void *dummy, char *arg)
  358. {
  359.     void *sconf = cmd->server->module_config;
  360.     core_server_config *conf = get_module_config (sconf, &core_module);
  361.   
  362.     if (!is_directory (arg))
  363.     if (cmd->server->is_virtual)
  364.         fprintf (stderr, "Warning: DocumentRoot [%s] does not exist\n", arg);
  365.     else
  366.         return "DocumentRoot must be a directory";
  367.     
  368.     conf->document_root = arg;
  369.     return NULL;
  370. }
  371.  
  372. char *set_error_document (cmd_parms *cmd, core_dir_config *conf, char *line)
  373. {
  374.     int error_number, index_number;
  375.     char *w;
  376.                 
  377.     /* 1st parameter should be a 3 digit number, which we recognize;
  378.      * convert it into an array index
  379.      */
  380.   
  381.     w = getword_conf (cmd->pool, &line);
  382.     error_number = atoi(w);
  383.     index_number = index_of_response(error_number);
  384.   
  385.     if (index_number < 0)
  386.         return pstrcat (cmd->pool, "Illegal HTTP response code ", w, NULL);
  387.                 
  388.     /* Nuke trailing '"', if present */
  389.     
  390.     if (line[strlen(line) - 1] == '"') line[strlen(line) - 1] = '\0';
  391.   
  392.     /* Store it... */
  393.  
  394.     conf->response_code_strings[index_number] = pstrdup (cmd->pool, line);
  395.  
  396.     return NULL;
  397. }
  398.  
  399. /* access.conf commands...
  400.  *
  401.  * The *only* thing that can appear in access.conf at top level is a
  402.  * <Directory> section.  NB we need to have a way to cut the srm_command_loop
  403.  * invoked by dirsection (i.e., <Directory>) short when </Directory> is seen.
  404.  * We do that by returning an error, which dirsection itself recognizes and
  405.  * discards as harmless.  Cheesy, but it works.
  406.  */
  407.  
  408. char *set_override (cmd_parms *cmd, core_dir_config *d, char *l)
  409. {
  410.     char *w;
  411.   
  412.     d->override = OR_NONE;
  413.     while(l[0]) {
  414.         w = getword_conf (cmd->pool, &l);
  415.     if(!strcasecmp(w,"Limit"))
  416.         d->override |= OR_LIMIT;
  417.     else if(!strcasecmp(w,"Options"))
  418.         d->override |= OR_OPTIONS;
  419.     else if(!strcasecmp(w,"FileInfo"))
  420.             d->override |= OR_FILEINFO;
  421.     else if(!strcasecmp(w,"AuthConfig"))
  422.         d->override |= OR_AUTHCFG;
  423.     else if(!strcasecmp(w,"Indexes"))
  424.             d->override |= OR_INDEXES;
  425.     else if(!strcasecmp(w,"None"))
  426.         d->override = OR_NONE;
  427.     else if(!strcasecmp(w,"All")) 
  428.         d->override = OR_ALL;
  429.     else 
  430.         return pstrcat (cmd->pool, "Illegal override option ", w, NULL);
  431.     }
  432.  
  433.     return NULL;
  434. }
  435.  
  436. char *set_options (cmd_parms *cmd, core_dir_config *d, char *l)
  437. {
  438.     d->opts = OPT_NONE;
  439.     while(l[0]) {
  440.         char *w = getword_conf(cmd->pool, &l);
  441.     if(!strcasecmp(w,"Indexes"))
  442.         d->opts |= OPT_INDEXES;
  443.     else if(!strcasecmp(w,"Includes"))
  444.         d->opts |= OPT_INCLUDES;
  445.     else if(!strcasecmp(w,"IncludesNOEXEC"))
  446.         d->opts |= (OPT_INCLUDES | OPT_INCNOEXEC);
  447.     else if(!strcasecmp(w,"FollowSymLinks"))
  448.         d->opts |= OPT_SYM_LINKS;
  449.     else if(!strcasecmp(w,"SymLinksIfOwnerMatch"))
  450.         d->opts |= OPT_SYM_OWNER;
  451.     else if(!strcasecmp(w,"execCGI"))
  452.         d->opts |= OPT_EXECCGI;
  453.     else if (!strcasecmp(w,"MultiViews"))
  454.         d->opts |= OPT_MULTI;
  455.     else if (!strcasecmp(w,"RunScripts")) /* AI backcompat. Yuck */
  456.         d->opts |= OPT_MULTI|OPT_EXECCGI;
  457.     else if(!strcasecmp(w,"None")) 
  458.         d->opts = OPT_NONE;
  459.     else if(!strcasecmp(w,"All")) 
  460.         d->opts = OPT_ALL;
  461.     else 
  462.         return pstrcat (cmd->pool, "Illegal option ", w, NULL);
  463.     }
  464.  
  465.     return NULL;
  466. }
  467.  
  468. char *require (cmd_parms *cmd, core_dir_config *c, char *arg)
  469. {
  470.     require_line *r;
  471.   
  472.     if (!c->requires)
  473.         c->requires = make_array (cmd->pool, 2, sizeof(require_line));
  474.     
  475.     r = (require_line *)push_array (c->requires);
  476.     r->requirement = pstrdup (cmd->pool, arg);
  477.     r->method_mask = cmd->limited;
  478.     return NULL;
  479. }
  480.  
  481. char *limit (cmd_parms *cmd, void *dummy, char *arg)
  482. {
  483.     char *limited_methods = getword(cmd->pool,&arg,'>');
  484.     int limited = 0;
  485.   
  486.     if (cmd->limited > 0) return "Can't nest <Limit> sections";
  487.     
  488.     while(limited_methods[0]) {
  489.         char *method = getword_conf (cmd->pool, &limited_methods);
  490.     if(!strcasecmp(method,"GET")) limited |= (1 << M_GET);
  491.     else if(!strcasecmp(method,"PUT")) limited |= (1 << M_PUT);
  492.     else if(!strcasecmp(method,"POST")) limited |= (1 << M_POST);
  493.     else if(!strcasecmp(method,"DELETE")) limited |= (1 << M_DELETE);
  494.         else if(!strcasecmp(method,"CONNECT")) limited |= (1 << M_CONNECT);
  495.     else return "unknown method in <Limit>";
  496.     }
  497.  
  498.     cmd->limited = limited;
  499.     return NULL;
  500. }
  501.  
  502. char *endlimit (cmd_parms *cmd, void *dummy, void *dummy2)
  503. {
  504.     if (cmd->limited == -1) return "</Limit> unexpected";
  505.     
  506.     cmd->limited = -1;
  507.     return NULL;
  508. }
  509.  
  510. static char *end_dir_magic = "</Directory> outside of any <Directory> section";
  511.  
  512. char *end_dirsection (cmd_parms *cmd, void *dummy) {
  513.     return end_dir_magic;
  514. }
  515.  
  516. char *dirsection (cmd_parms *cmd, void *dummy, char *arg)
  517. {
  518.     char *errmsg, *endp = strrchr (arg, '>');
  519.     int old_overrides = cmd->override;
  520.     char *old_path = cmd->path;
  521.     void *new_dir_conf = create_per_dir_config (cmd->pool);
  522.  
  523.     if (endp) *endp = '\0';
  524.  
  525.     if (cmd->path) return "<Directory> sections don't nest";
  526.     if (cmd->limited != -1) return "Can't have <Directory> within <Limit>";
  527.     
  528.     cmd->path = getword_conf (cmd->pool, &arg);
  529.     cmd->override = OR_ALL|ACCESS_CONF;
  530.  
  531.     errmsg = srm_command_loop (cmd, new_dir_conf);
  532.     add_per_dir_conf (cmd->server, new_dir_conf);
  533.     
  534.     cmd->path = old_path;
  535.     cmd->override = old_overrides;
  536.  
  537.     if (errmsg == end_dir_magic) return NULL;
  538.     return errmsg;
  539. }
  540.  
  541. static char *end_url_magic = "</Location> outside of any <Location> section";
  542.  
  543. char *end_urlsection (cmd_parms *cmd, void *dummy) {
  544.     return end_url_magic;
  545. }
  546.  
  547. char *urlsection (cmd_parms *cmd, void *dummy, char *arg)
  548. {
  549.     char *errmsg, *endp = strrchr (arg, '>');
  550.     int old_overrides = cmd->override;
  551.     char *old_path = cmd->path;
  552.     core_dir_config *conf;
  553.  
  554.     void *new_url_conf = create_per_dir_config (cmd->pool);
  555.  
  556.     if (endp) *endp = '\0';
  557.  
  558.     if (cmd->path) return "<Location> sections don't nest";
  559.     if (cmd->limited != -1) return "Can't have <Location> within <Limit>";
  560.     
  561.     cmd->path = getword_conf (cmd->pool, &arg);
  562.     cmd->override = OR_ALL|ACCESS_CONF;
  563.  
  564.     errmsg = srm_command_loop (cmd, new_url_conf);
  565.     if (errmsg != end_url_magic) return errmsg;
  566.  
  567.     conf = (core_dir_config *)get_module_config(new_url_conf, &core_module);
  568.     conf->d = pstrdup(cmd->pool, cmd->path);    /* No mangling, please */
  569.  
  570.     add_per_url_conf (cmd->server, new_url_conf);
  571.     
  572.     cmd->path = old_path;
  573.     cmd->override = old_overrides;
  574.  
  575.     return NULL;
  576. }
  577.  
  578. /* httpd.conf commands... beginning with the <VirtualHost> business */
  579.  
  580. char *end_virthost_magic = "</Virtualhost> out of place";
  581.  
  582. char *end_virtualhost_section (cmd_parms *cmd, void *dummy) {
  583.     return end_virthost_magic;
  584. }
  585.  
  586. char *virtualhost_section (cmd_parms *cmd, void *dummy, char *arg)
  587. {
  588.     server_rec *main_server = cmd->server, *s;
  589.     char *errmsg, *endp = strrchr (arg, '>');
  590.     pool *p = cmd->pool, *ptemp = cmd->temp_pool;
  591.  
  592.     if (endp) *endp = '\0';
  593.     
  594.     if (main_server->is_virtual)
  595.     return "<VirtualHost> doesn't nest!";
  596.     
  597.     s = init_virtual_host (p, arg);
  598.     s->next = main_server->next;
  599.     main_server->next = s;
  600.     
  601.     cmd->server = s;
  602.     errmsg = srm_command_loop (cmd, s->lookup_defaults);
  603.     cmd->server = main_server;
  604.  
  605.     if (s->srm_confname)
  606.     process_resource_config (s, s->srm_confname, p, ptemp);
  607.  
  608.     if (s->access_confname)
  609.     process_resource_config (s, s->access_confname, p, ptemp);
  610.     
  611.     if (errmsg == end_virthost_magic) return NULL;
  612.     return errmsg;
  613. }
  614.  
  615. char *set_server_string_slot (cmd_parms *cmd, void *dummy, char *arg)
  616. {
  617.     /* This one's pretty generic... */
  618.   
  619.     int offset = (int)cmd->info;
  620.     char *struct_ptr = (char *)cmd->server;
  621.     
  622.     *(char **)(struct_ptr + offset) = pstrdup (cmd->pool, arg);
  623.     return NULL;
  624. }
  625.  
  626. char *server_type (cmd_parms *cmd, void *dummy, char *arg)
  627. {
  628.     if (!strcasecmp (arg, "inetd")) standalone = 0;
  629.     else if (!strcasecmp (arg, "standalone")) standalone = 1;
  630.     else return "ServerType must be either 'inetd' or 'standalone'";
  631.  
  632.     return NULL;
  633. }
  634.  
  635. char *server_port (cmd_parms *cmd, void *dummy, char *arg) {
  636.     cmd->server->port = atoi (arg);
  637.     return NULL;
  638. }
  639.  
  640. char *set_user (cmd_parms *cmd, void *dummy, char *arg) {
  641.     user_name = pstrdup (cmd->pool, arg);
  642.     user_id = uname2id (user_name);
  643.     return NULL;
  644. }
  645.  
  646. char *set_group (cmd_parms *cmd, void *dummy, char *arg) {
  647.     group_id = gname2id(arg);
  648.     return NULL;
  649. }
  650.  
  651. char *set_server_root (cmd_parms *cmd, void *dummy, char *arg) {
  652.     if (!is_directory (arg)) return "ServerRoot must be a valid directory";
  653.     strcpy (server_root, arg);
  654.     return NULL;
  655. }
  656.  
  657. char *set_timeout (cmd_parms *cmd, void *dummy, char *arg) {
  658.     cmd->server->timeout = atoi (arg);
  659.     return NULL;
  660. }
  661.  
  662. char *set_keep_alive_timeout (cmd_parms *cmd, void *dummy, char *arg) {
  663.     cmd->server->keep_alive_timeout = atoi (arg);
  664.     return NULL;
  665. }
  666.  
  667. char *set_keep_alive (cmd_parms *cmd, void *dummy, char *arg) {
  668.     cmd->server->keep_alive = atoi (arg);
  669.     return NULL;
  670. }
  671.  
  672. char *set_pidfile (cmd_parms *cmd, void *dummy, char *arg) {
  673.     pid_fname = pstrdup (cmd->pool, arg);
  674.     return NULL;
  675. }
  676.  
  677. char *set_scoreboard (cmd_parms *cmd, void *dummy, char *arg) {
  678.     scoreboard_fname = pstrdup (cmd->pool, arg);
  679.     return NULL;
  680. }
  681.  
  682. char *set_idcheck (cmd_parms *cmd, core_dir_config *d, int arg) {
  683.     d->do_rfc1413 = arg;
  684.     return NULL;
  685. }
  686.  
  687. char *set_hostname_lookups (cmd_parms *cmd, core_dir_config *d, int arg) {
  688.     d->hostname_lookups = arg;
  689.     return NULL;
  690. }
  691.  
  692. char *set_serverpath (cmd_parms *cmd, void *dummy, char *arg) {
  693.     cmd->server->path = pstrdup (cmd->pool, arg);
  694.     cmd->server->pathlen = strlen (arg);
  695.     return NULL;
  696. }
  697.  
  698. char *set_content_md5 (cmd_parms *cmd, core_dir_config *d, int arg) {
  699.     d->content_md5 = arg;
  700.     return NULL;
  701. }
  702.  
  703. char *set_daemons_to_start (cmd_parms *cmd, void *dummy, char *arg) {
  704.     daemons_to_start = atoi (arg);
  705.     return NULL;
  706. }
  707.  
  708. char *set_min_free_servers (cmd_parms *cmd, void *dummy, char *arg) {
  709.     daemons_min_free = atoi (arg);
  710.     if (daemons_min_free <= 0) {
  711.        fprintf(stderr, "WARNING: detected MinSpareServers set to non-positive.\n");
  712.        fprintf(stderr, "Resetting to 1 to avoid almost certain Apache failure.\n");
  713.        fprintf(stderr, "Please read the documentation.\n");
  714.        daemons_min_free = 1;
  715.     }
  716.        
  717.     return NULL;
  718. }
  719.  
  720. char *set_max_free_servers (cmd_parms *cmd, void *dummy, char *arg) {
  721.     daemons_max_free = atoi (arg);
  722.     return NULL;
  723. }
  724.  
  725. char *set_server_limit (cmd_parms *cmd, void *dummy, char *arg) {
  726.     daemons_limit = atoi (arg);
  727.     if (daemons_limit > HARD_SERVER_LIMIT)
  728.         daemons_limit = HARD_SERVER_LIMIT;
  729.     return NULL;
  730. }
  731.  
  732. char *set_max_requests (cmd_parms *cmd, void *dummy, char *arg) {
  733.     max_requests_per_child = atoi (arg);
  734.     return NULL;
  735. }
  736.  
  737. char *set_bind_address (cmd_parms *cmd, void *dummy, char *arg) {
  738.     bind_address.s_addr = get_virthost_addr (arg, NULL);
  739.     return NULL;
  740. }
  741.  
  742. char *set_listener(cmd_parms *cmd, void *dummy, char *ips)
  743. {
  744.     listen_rec *new;
  745.     char *ports;
  746.  
  747.     if (cmd->server->is_virtual) return "Listen not allowed in <VirtualHost>";
  748.     ports=strchr(ips, ':');
  749.     if (ports != NULL)
  750.     {
  751.     if (ports == ips) return "Missing IP address";
  752.     else if (ports[0] == '\0')
  753.         return "Address must end in :<port-number>";
  754.     *(ports++) = '\0';
  755.     } else
  756.     ports = ips;
  757.  
  758.     new=palloc(cmd->pool, sizeof(listen_rec));
  759.     new->local_addr.sin_family = AF_INET;
  760.     if (ports == ips) /* no address */
  761.     new->local_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  762.     else
  763.     new->local_addr.sin_addr.s_addr = get_virthost_addr(ips, NULL);
  764.     new->local_addr.sin_port = htons(atoi(ports));
  765.     new->next = listeners;
  766.     listeners = new;
  767.     return NULL;
  768. }
  769.  
  770. /* Note --- ErrorDocument will now work from .htaccess files.  
  771.  * The AllowOverride of Fileinfo allows webmasters to turn it off
  772.  */
  773.  
  774. command_rec core_cmds[] = {
  775.  
  776. /* Old access config file commands */
  777.  
  778. { "<Directory", dirsection, NULL, RSRC_CONF, RAW_ARGS, NULL },
  779. { "</Directory>", end_dirsection, NULL, ACCESS_CONF, NO_ARGS, NULL },
  780. { "<Location", urlsection, NULL, RSRC_CONF, RAW_ARGS, NULL },
  781. { "</Location>", end_urlsection, NULL, ACCESS_CONF, NO_ARGS, NULL },
  782. { "<Limit", limit, NULL, OR_ALL, RAW_ARGS, NULL },
  783. { "</Limit>", endlimit, NULL, OR_ALL, RAW_ARGS, NULL },
  784. { "AuthType", set_string_slot, (void*)XtOffsetOf(core_dir_config, auth_type),
  785.     OR_AUTHCFG, TAKE1, "an HTTP authorization type (e.g., \"Basic\")" },
  786. { "AuthName", set_string_slot, (void*)XtOffsetOf(core_dir_config, auth_name),
  787.     OR_AUTHCFG, RAW_ARGS, NULL },
  788. { "Require", require, NULL, OR_AUTHCFG, RAW_ARGS, NULL },
  789.     
  790. /* Old resource config file commands */
  791.   
  792. { "AccessFileName", set_access_name, NULL, RSRC_CONF, TAKE1, NULL },
  793. { "DocumentRoot", set_document_root, NULL, RSRC_CONF, TAKE1, NULL },
  794. { "ErrorDocument", set_error_document, NULL, OR_FILEINFO, RAW_ARGS, NULL },
  795. { "AllowOverride", set_override, NULL, ACCESS_CONF, RAW_ARGS, NULL },
  796. { "Options", set_options, NULL, OR_OPTIONS, RAW_ARGS, NULL },
  797. { "DefaultType", set_string_slot,
  798.     (void*)XtOffsetOf (core_dir_config, default_type),
  799.     OR_FILEINFO, TAKE1, "the default MIME type for untypable files" },
  800.  
  801. /* Old server config file commands */
  802.  
  803. { "ServerType", server_type, NULL, RSRC_CONF, TAKE1,"'inetd' or 'standalone'"},
  804. { "Port", server_port, NULL, RSRC_CONF, TAKE1, "a TCP port number"},
  805. { "HostnameLookups", set_hostname_lookups, NULL, ACCESS_CONF|RSRC_CONF, FLAG, NULL },
  806. { "User", set_user, NULL, RSRC_CONF, TAKE1, "a username"},
  807. { "Group", set_group, NULL, RSRC_CONF, TAKE1, "a group name"},
  808. { "ServerAdmin", set_server_string_slot,
  809.   (void *)XtOffsetOf (server_rec, server_admin), RSRC_CONF, TAKE1,
  810.   "The email address of the server administrator" },
  811. { "ServerName", set_server_string_slot,
  812.   (void *)XtOffsetOf (server_rec, server_hostname), RSRC_CONF, TAKE1,
  813.   "The hostname of the server" },
  814. { "ServerRoot", set_server_root, NULL, RSRC_CONF, TAKE1, "a directory"},
  815. { "ErrorLog", set_server_string_slot,
  816.   (void *)XtOffsetOf (server_rec, error_fname), RSRC_CONF, TAKE1,
  817.   "the filename of the error log" },
  818. { "PidFile", set_pidfile, NULL, RSRC_CONF, TAKE1,
  819.     "a file for logging the server process ID"},
  820. { "ScoreBoardFile", set_scoreboard, NULL, RSRC_CONF, TAKE1,
  821.     "a file for apache to maintain runtime process management information"},
  822. { "AccessConfig", set_server_string_slot,
  823.   (void *)XtOffsetOf (server_rec, access_confname), RSRC_CONF, TAKE1,
  824.   "the filename of the access config file" },
  825. { "ResourceConfig", set_server_string_slot,
  826.   (void *)XtOffsetOf (server_rec, srm_confname), RSRC_CONF, TAKE1,
  827.   "the filename of the resource config file" },
  828. { "ServerAlias", set_server_string_slot,
  829.    (void *)XtOffsetOf (server_rec, names), RSRC_CONF, RAW_ARGS,
  830.    "a name or names alternately used to access the server" },
  831. { "ServerPath", set_serverpath, NULL, RSRC_CONF, TAKE1,
  832.   "The pathname the server can be reached at" },
  833. { "Timeout", set_timeout, NULL, RSRC_CONF, TAKE1, "timeout duration (sec)"},
  834. { "KeepAliveTimeout", set_keep_alive_timeout, NULL, RSRC_CONF, TAKE1, "Keep-Alive timeout duration (sec)"},
  835. { "KeepAlive", set_keep_alive, NULL, RSRC_CONF, TAKE1, "Maximum Keep-Alive requests per connection (0 to disable)" },
  836. { "IdentityCheck", set_idcheck, NULL, RSRC_CONF|ACCESS_CONF, FLAG, NULL },
  837. { "ContentDigest", set_content_md5, NULL, RSRC_CONF|ACCESS_CONF|OR_AUTHCFG, FLAG, "whether or not to send a Content-MD5 header with each request" },
  838. { "CacheNegotiatedDocs", },
  839. { "StartServers", set_daemons_to_start, NULL, RSRC_CONF, TAKE1, NULL },
  840. { "MinSpareServers", set_min_free_servers, NULL, RSRC_CONF, TAKE1, NULL },
  841. { "MaxSpareServers", set_max_free_servers, NULL, RSRC_CONF, TAKE1, NULL },
  842. { "MaxServers", set_max_free_servers, NULL, RSRC_CONF, TAKE1, NULL },
  843. { "ServersSafetyLimit", set_server_limit, NULL, RSRC_CONF, TAKE1, NULL },
  844. { "MaxClients", set_server_limit, NULL, RSRC_CONF, TAKE1, NULL },
  845. { "MaxRequestsPerChild", set_max_requests, NULL, RSRC_CONF, TAKE1, NULL },
  846. { "BindAddress", set_bind_address, NULL, RSRC_CONF, TAKE1,
  847.   "'*', a numeric IP address, or the name of a host with a unique IP address"},
  848. { "Listen", set_listener, NULL, RSRC_CONF, TAKE1,
  849.       "a port number or a numeric IP address and a port number"},
  850. { "<VirtualHost", virtualhost_section, NULL, RSRC_CONF, RAW_ARGS, NULL },
  851. { "</VirtualHost>", end_virtualhost_section, NULL, RSRC_CONF, NO_ARGS, NULL },
  852. { NULL },
  853. };
  854.  
  855. /*****************************************************************
  856.  *
  857.  * Core handlers for various phases of server operation...
  858.  */
  859.  
  860. int core_translate (request_rec *r)
  861. {
  862.     void *sconf = r->server->module_config;
  863.     core_server_config *conf = get_module_config (sconf, &core_module);
  864.   
  865.     if (r->proxyreq) return NOT_IMPLEMENTED;
  866.     if (r->uri[0] != '/') return BAD_REQUEST;
  867.     
  868.     if (r->server->path &&
  869.     !strncmp(r->uri, r->server->path, r->server->pathlen))
  870.       r->filename = pstrcat (r->pool, conf->document_root,
  871.                  (r->uri + r->server->pathlen), NULL);
  872.     else
  873.       r->filename = pstrcat (r->pool, conf->document_root, r->uri, NULL);
  874.  
  875.     return OK;
  876. }
  877.  
  878. int do_nothing (request_rec *r) { return OK; }
  879.  
  880. /*
  881.  * Default handler for MIME types without other handlers.  Only GET
  882.  * at this point... anyone who wants to write a generic handler for
  883.  * PUT or POST is free to do so, but it seems unwise to provide any
  884.  * defaults yet...
  885.  */
  886.  
  887. int default_handler (request_rec *r)
  888. {
  889.     core_dir_config *d =
  890.       (core_dir_config *)get_module_config(r->per_dir_config, &core_module);
  891.     int errstatus;
  892.     FILE *f;
  893.     
  894.     if (r->method_number != M_GET) return DECLINED;
  895.  
  896.     if (r->finfo.st_mode == 0 || (r->path_info && *r->path_info)) {
  897.     log_reason("File does not exist", r->filename, r);
  898.     return NOT_FOUND;
  899.     }
  900.     
  901.     if ((errstatus = set_content_length (r, r->finfo.st_size))
  902.     || (errstatus = set_last_modified (r, r->finfo.st_mtime)))
  903.         return errstatus;
  904.     
  905. #ifdef __EMX__
  906.     /* Need binary mode for OS/2 */
  907.     f = fopen (r->filename, "rb");
  908. #else
  909.     f = fopen (r->filename, "r");
  910. #endif
  911.  
  912.     if (f == NULL) {
  913.         log_reason("file permissions deny server access", r->filename, r);
  914.         return FORBIDDEN;
  915.     }
  916.  
  917.     if (d->content_md5 & 1) {
  918.       table_set (r->headers_out, "Content-MD5", md5digest(r->pool, f));
  919.     }
  920.  
  921.     soft_timeout ("send", r);
  922.     
  923.     send_http_header (r);
  924.     if (!r->header_only) send_fd (f, r);
  925.     fclose (f);
  926.     return OK;
  927. }
  928.  
  929. handler_rec core_handlers[] = {
  930. { "*/*", default_handler },
  931. { NULL }
  932. };
  933.  
  934. module core_module = {
  935.    STANDARD_MODULE_STUFF,
  936.    NULL,            /* initializer */
  937.    create_core_dir_config,    /* create per-directory config structure */
  938.    merge_core_dir_configs,    /* merge per-directory config structures */
  939.    create_core_server_config,    /* create per-server config structure */
  940.    merge_core_server_configs,    /* merge per-server config structures */
  941.    core_cmds,            /* command table */
  942.    core_handlers,        /* handlers */
  943.    core_translate,        /* translate_handler */
  944.    NULL,            /* check_user_id */
  945.    NULL,            /* check auth */
  946.    do_nothing,            /* check access */
  947.    do_nothing,            /* type_checker */
  948.    NULL,            /* pre-run fixups */
  949.    NULL                /* logger */
  950. };
  951.