9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin#define CORE_PRIVATE

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin#include "ap_config.h"

30471a4650391f57975f60bbb6e4a90be7b284bfhumbedooh#include "apr_portable.h"

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin#include "apr_file_io.h"

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar#include "httpd.h"

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar#include "http_config.h"

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar#include "http_core.h"

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar#include "http_log.h" /* for errors in parse_htaccess */

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar#include "http_request.h" /* for default_handler (see invoke_handler) */

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar#include "http_main.h"

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar#include "http_vhost.h"

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar

1f1b6bf13313fdd14a45e52e553d3ff28689b717coarHOOK_STRUCT(

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar HOOK_LINK(header_parser)

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar HOOK_LINK(pre_config)

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar HOOK_LINK(post_config)

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar HOOK_LINK(open_logs)

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar HOOK_LINK(child_init)

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar)

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar

1f1b6bf13313fdd14a45e52e553d3ff28689b717coarIMPLEMENT_HOOK_RUN_ALL(int,header_parser,(request_rec *r),(r),OK,DECLINED)

1f1b6bf13313fdd14a45e52e553d3ff28689b717coarIMPLEMENT_HOOK_VOID(pre_config,(ap_context_t *pconf,ap_context_t *plog,ap_context_t *ptemp),

1f1b6bf13313fdd14a45e52e553d3ff28689b717coar (pconf,plog,ptemp))

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrinIMPLEMENT_HOOK_VOID(post_config,

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin (ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp, server_rec *s),

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin (pconf,plog,ptemp,s))

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrinIMPLEMENT_HOOK_VOID(open_logs,

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin (ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp, server_rec *s),

623eebe956d9c2d6d073ed3eae855b56030b40e9noodl (pconf,plog,ptemp,s))

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrinIMPLEMENT_HOOK_VOID(child_init,(ap_context_t *pchild, server_rec *s),(pchild,s))

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin

9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrinstatic int total_modules = 0;

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrinstatic int dynamic_modules = 0;

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrinAPI_VAR_EXPORT module *top_module = NULL;

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrinAPI_VAR_EXPORT module **ap_loaded_modules=NULL;

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrintypedef int (*handler_func) (request_rec *);

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrintypedef void *(*dir_maker_func) (ap_context_t *, char *);

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrintypedef void *(*merger_func) (ap_context_t *, void *, void *);

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin#ifndef ap_get_module_config

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrinAPI_EXPORT(void *) ap_get_module_config(void *conf_vector, module *m)

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin{

9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf void **confv = (void **) conf_vector;

4aa603e6448b99f9371397d439795c91a93637eand return confv[m->module_index];

4aa603e6448b99f9371397d439795c91a93637eand}

e487d6c09669296f94a5190cc34586a98e624a00nd#endif

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin#ifndef ap_set_module_config

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrinAPI_EXPORT(void) ap_set_module_config(void *conf_vector, module *m, void *val)

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin{

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin void **confv = (void **) conf_vector;

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin confv[m->module_index] = val;

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin}

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin#endif

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin

623eebe956d9c2d6d073ed3eae855b56030b40e9noodlstatic void *create_empty_config(ap_context_t *p)

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin{

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin void **conf_vector = (void **) ap_pcalloc(p, sizeof(void *) *

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin (total_modules + DYNAMIC_MODULE_LIMIT));

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin return (void *) conf_vector;

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin}

9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrinstatic void *create_default_per_dir_config(ap_context_t *p)

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin{

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin void **conf_vector = (void **) ap_pcalloc(p, sizeof(void *) * (total_modules + DYNAMIC_MODULE_LIMIT));

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin module *modp;

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin for (modp = top_module; modp; modp = modp->next) {

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin dir_maker_func df = modp->create_dir_config;

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin if (df)

f086b4b402fa9a2fefc7dda85de2a3cc1cd0a654rjung conf_vector[modp->module_index] = (*df) (p, NULL);

727872d18412fc021f03969b8641810d8896820bhumbedooh }

0d0ba3a410038e179b695446bb149cce6264e0abnd

727872d18412fc021f03969b8641810d8896820bhumbedooh return (void *) conf_vector;

cc7e1025de9ac63bd4db6fe7f71c158b2cf09fe4humbedooh}

0d0ba3a410038e179b695446bb149cce6264e0abnd

cc7e1025de9ac63bd4db6fe7f71c158b2cf09fe4humbedoohvoid *

727872d18412fc021f03969b8641810d8896820bhumbedooh ap_merge_per_dir_configs(ap_context_t *p, void *base, void *new)

0d0ba3a410038e179b695446bb149cce6264e0abnd{

0d0ba3a410038e179b695446bb149cce6264e0abnd void **conf_vector = (void **) ap_palloc(p, sizeof(void *) * total_modules);

0d0ba3a410038e179b695446bb149cce6264e0abnd void **base_vector = (void **) base;

ac082aefa89416cbdc9a1836eaf3bed9698201c8humbedooh void **new_vector = (void **) new;

0d0ba3a410038e179b695446bb149cce6264e0abnd module *modp;

0d0ba3a410038e179b695446bb149cce6264e0abnd

0d0ba3a410038e179b695446bb149cce6264e0abnd for (modp = top_module; modp; modp = modp->next) {

727872d18412fc021f03969b8641810d8896820bhumbedooh merger_func df = modp->merge_dir_config;

0d0ba3a410038e179b695446bb149cce6264e0abnd int i = modp->module_index;

0d0ba3a410038e179b695446bb149cce6264e0abnd

30471a4650391f57975f60bbb6e4a90be7b284bfhumbedooh if (df && new_vector[i])

205f749042ed530040a4f0080dbcb47ceae8a374rjung conf_vector[i] = (*df) (p, base_vector[i], new_vector[i]);

af33a4994ae2ff15bc67d19ff1a7feb906745bf8rbowen else

0d0ba3a410038e179b695446bb149cce6264e0abnd conf_vector[i] = new_vector[i] ? new_vector[i] : base_vector[i];

7fec19672a491661b2fe4b29f685bc7f4efa64d4nd }

7fec19672a491661b2fe4b29f685bc7f4efa64d4nd

7fec19672a491661b2fe4b29f685bc7f4efa64d4nd return (void *) conf_vector;

4277c95b5a9454a5c25f8d8762634fcff37aa840minfrin}

static void *create_server_config(ap_context_t *p, server_rec *s)

{

void **conf_vector = (void **) ap_pcalloc(p, sizeof(void *) * (total_modules + DYNAMIC_MODULE_LIMIT));

module *modp;

for (modp = top_module; modp; modp = modp->next) {

if (modp->create_server_config)

conf_vector[modp->module_index] = (*modp->create_server_config) (p, s);

}

return (void *) conf_vector;

}

static void merge_server_configs(ap_context_t *p, void *base, void *virt)

{

/* Can reuse the 'virt' vector for the spine of it, since we don't

void **base_vector = (void **) base;

void **virt_vector = (void **) virt;

module *modp;

for (modp = top_module; modp; modp = modp->next) {

merger_func df = modp->merge_server_config;

int i = modp->module_index;

if (!virt_vector[i])

virt_vector[i] = base_vector[i];

else if (df)

virt_vector[i] = (*df) (p, base_vector[i], virt_vector[i]);

}

}

void *ap_create_request_config(ap_context_t *p)

{

return create_empty_config(p);

}

void *ap_create_conn_config(ap_context_t *p)

{

return create_empty_config(p);

}

CORE_EXPORT(void *) ap_create_per_dir_config(ap_context_t *p)

{

return create_empty_config(p);

}

typedef struct {

handler_rec hr;

size_t len;

} fast_handler_rec;

static fast_handler_rec *handlers;

static fast_handler_rec *wildhandlers;

static void init_handlers(ap_context_t *p)

{

module *modp;

int nhandlers = 0;

int nwildhandlers = 0;

const handler_rec *handp;

fast_handler_rec *ph, *pw;

char *starp;

for (modp = top_module; modp; modp = modp->next) {

if (!modp->handlers)

continue;

for (handp = modp->handlers; handp->content_type; ++handp) {

if (strchr(handp->content_type, '*')) {

nwildhandlers ++;

} else {

nhandlers ++;

}

}

}

ph = handlers = ap_palloc(p, sizeof(*ph)*(nhandlers + 1));

pw = wildhandlers = ap_palloc(p, sizeof(*pw)*(nwildhandlers + 1));

for (modp = top_module; modp; modp = modp->next) {

if (!modp->handlers)

continue;

for (handp = modp->handlers; handp->content_type; ++handp) {

if ((starp = strchr(handp->content_type, '*'))) {

pw->hr.content_type = handp->content_type;

pw->hr.handler = handp->handler;

pw->len = starp - handp->content_type;

pw ++;

} else {

ph->hr.content_type = handp->content_type;

ph->hr.handler = handp->handler;

ph->len = strlen(handp->content_type);

ph ++;

}

}

}

pw->hr.content_type = NULL;

pw->hr.handler = NULL;

ph->hr.content_type = NULL;

ph->hr.handler = NULL;

}

int ap_invoke_handler(request_rec *r)

{

fast_handler_rec *handp;

const char *handler;

char *p;

size_t handler_len;

int result = HTTP_INTERNAL_SERVER_ERROR;

if (r->handler) {

handler = r->handler;

handler_len = strlen(handler);

}

else {

handler = r->content_type ? r->content_type : ap_default_type(r);

if ((p = strchr(handler, ';')) != NULL) { /* MIME type arguments */

while (p > handler && p[-1] == ' ')

--p; /* strip trailing spaces */

handler_len = p - handler;

}

else {

handler_len = strlen(handler);

}

}

/* Pass one --- direct matches */

for (handp = handlers; handp->hr.content_type; ++handp) {

if (handler_len == handp->len

&& !strncmp(handler, handp->hr.content_type, handler_len)) {

result = (*handp->hr.handler) (r);

if (result != DECLINED)

return result;

}

}

/* Pass two --- wildcard matches */

for (handp = wildhandlers; handp->hr.content_type; ++handp) {

if (handler_len >= handp->len

&& !strncmp(handler, handp->hr.content_type, handp->len)) {

result = (*handp->hr.handler) (r);

if (result != DECLINED)

return result;

}

}

if (result == HTTP_INTERNAL_SERVER_ERROR && r->handler && r->filename) {

ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r,

"handler \"%s\" not found for: %s", r->handler, r->filename);

}

return HTTP_INTERNAL_SERVER_ERROR;

}

int g_bDebugHooks;

const char *g_szCurrentHookName;

static void register_hooks(module *m)

{

if(m->register_hooks)

{

if(getenv("SHOW_HOOKS"))

{

printf("Registering hooks for %s\n",m->name);

g_bDebugHooks=1;

}

g_szCurrentHookName=m->name;

m->register_hooks();

}

}

API_EXPORT(void) ap_add_module(module *m)

{

/* This could be called from an AddModule httpd.conf command,

if (m->version != MODULE_MAGIC_NUMBER_MAJOR) {

ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL,

"%s: module \"%s\" is not compatible with this "

"version of Apache.", ap_server_argv0, m->name);

ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL, "Please contact the vendor for the correct version.");

exit(1);

}

if (m->next == NULL) {

m->next = top_module;

top_module = m;

}

if (m->module_index == -1) {

m->module_index = total_modules++;

dynamic_modules++;

if (dynamic_modules > DYNAMIC_MODULE_LIMIT) {

ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL,

"%s: module \"%s\" could not be loaded, because"

" the dynamic", ap_server_argv0, m->name);

ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL,

"module limit was reached. Please increase "

"DYNAMIC_MODULE_LIMIT and recompile.");

exit(1);

}

}

/* Some C compilers put a complete path into __FILE__, but we want

if (strrchr(m->name, '/'))

m->name = 1 + strrchr(m->name, '/');

if (strrchr(m->name, '\\'))

m->name = 1 + strrchr(m->name, '\\');

#ifdef _OSD_POSIX /* __FILE__="*POSIX(/home/martin/apache/src/modules/standard/mod_info.c)" */

/* We cannot fix the string in-place, because it's const */

if (m->name[strlen(m->name)-1]==')') {

char *tmp = strdup(m->name); /* FIXME:memory leak, albeit a small one */

tmp[strlen(tmp)-1] = '\0';

m->name = tmp;

}

#endif /*_OSD_POSIX*/

/* FIXME: is this the right place to call this? */

register_hooks(m);

}

API_EXPORT(void) ap_remove_module(module *m)

{

module *modp;

modp = top_module;

if (modp == m) {

/* We are the top module, special case */

top_module = modp->next;

m->next = NULL;

}

else {

/* Not the top module, find use. When found modp will

while (modp && modp->next != m) {

modp = modp->next;

}

if (!modp) {

/* Uh-oh, this module doesn't exist */

ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, NULL,

"Cannot remove module %s: not found in module list",

m->name);

return;

}

/* Eliminate us from the module list */

modp->next = modp->next->next;

}

m->module_index = -1; /* simulate being unloaded, should

dynamic_modules--;

total_modules--;

}

API_EXPORT(void) ap_add_loaded_module(module *mod)

{

module **m;

/*

ap_add_module(mod);

/*

for (m = ap_loaded_modules; *m != NULL; m++)

;

*m++ = mod;

*m = NULL;

}

API_EXPORT(void) ap_remove_loaded_module(module *mod)

{

module **m;

module **m2;

int done;

/*

ap_remove_module(mod);

/*

for (m = m2 = ap_loaded_modules, done = 0; *m2 != NULL; m2++) {

if (*m2 == mod && done == 0)

done = 1;

else

*m++ = *m2;

}

*m = NULL;

}

void ap_setup_prelinked_modules(process_rec *process)

{

module **m;

module **m2;

/*

total_modules = 0;

for (m = ap_preloaded_modules; *m != NULL; m++)

(*m)->module_index = total_modules++;

/*

ap_loaded_modules = (module **)ap_palloc(process->pool,

sizeof(module *)*(total_modules+DYNAMIC_MODULE_LIMIT+1));

if (ap_loaded_modules == NULL) {

ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL,

"Ouch! Out of memory in ap_setup_prelinked_modules()!");

}

for (m = ap_preloaded_modules, m2 = ap_loaded_modules; *m != NULL; )

*m2++ = *m++;

*m2 = NULL;

/*

for (m = ap_prelinked_modules; *m != NULL; m++)

ap_add_module(*m);

ap_sort_hooks();

}

API_EXPORT(const char *) ap_find_module_name(module *m)

{

return m->name;

}

API_EXPORT(module *) ap_find_linked_module(const char *name)

{

module *modp;

for (modp = top_module; modp; modp = modp->next) {

if (strcmp(modp->name, name) == 0)

return modp;

}

return NULL;

}

API_EXPORT(int) ap_add_named_module(const char *name)

{

module *modp;

int i = 0;

for (modp = ap_loaded_modules[i]; modp; modp = ap_loaded_modules[++i]) {

if (strcmp(modp->name, name) == 0) {

/* Only add modules that are not already enabled. */

if (modp->next == NULL) {

ap_add_module(modp);

}

return 1;

}

}

return 0;

}

API_EXPORT(void) ap_clear_module_list()

{

module **m = &top_module;

module **next_m;

while (*m) {

next_m = &((*m)->next);

*m = NULL;

m = next_m;

}

/* This is required; so we add it always. */

ap_add_named_module("http_core.c");

}

static const char *invoke_cmd(const command_rec *cmd, cmd_parms *parms,

void *mconfig, const char *args)

{

char *w, *w2, *w3;

const char *errmsg;

if ((parms->override & cmd->req_override) == 0)

return ap_pstrcat(parms->pool, cmd->name, " not allowed here", NULL);

parms->info = cmd->cmd_data;

parms->cmd = cmd;

switch (cmd->args_how) {

case RAW_ARGS:

return ((const char *(*)(cmd_parms *, void *, const char *))

(cmd->func)) (parms, mconfig, args);

case NO_ARGS:

if (*args != 0)

return ap_pstrcat(parms->pool, cmd->name, " takes no arguments",

NULL);

return ((const char *(*)(cmd_parms *, void *))

(cmd->func)) (parms, mconfig);

case TAKE1:

w = ap_getword_conf(parms->pool, &args);

if (*w == '\0' || *args != 0)

return ap_pstrcat(parms->pool, cmd->name, " takes one argument",

cmd->errmsg ? ", " : NULL, cmd->errmsg, NULL);

return ((const char *(*)(cmd_parms *, void *, const char *))

(cmd->func)) (parms, mconfig, w);

case TAKE2:

w = ap_getword_conf(parms->pool, &args);

w2 = ap_getword_conf(parms->pool, &args);

if (*w == '\0' || *w2 == '\0' || *args != 0)

return ap_pstrcat(parms->pool, cmd->name, " takes two arguments",

cmd->errmsg ? ", " : NULL, cmd->errmsg, NULL);

return ((const char *(*)(cmd_parms *, void *, const char *,

const char *)) (cmd->func)) (parms, mconfig, w, w2);

case TAKE12:

w = ap_getword_conf(parms->pool, &args);

w2 = ap_getword_conf(parms->pool, &args);

if (*w == '\0' || *args != 0)

return ap_pstrcat(parms->pool, cmd->name, " takes 1-2 arguments",

cmd->errmsg ? ", " : NULL, cmd->errmsg, NULL);

return ((const char *(*)(cmd_parms *, void *, const char *,

const char *)) (cmd->func)) (parms, mconfig, w,

*w2 ? w2 : NULL);

case TAKE3:

w = ap_getword_conf(parms->pool, &args);

w2 = ap_getword_conf(parms->pool, &args);

w3 = ap_getword_conf(parms->pool, &args);

if (*w == '\0' || *w2 == '\0' || *w3 == '\0' || *args != 0)

return ap_pstrcat(parms->pool, cmd->name, " takes three arguments",

cmd->errmsg ? ", " : NULL, cmd->errmsg, NULL);

return ((const char *(*)(cmd_parms *, void *, const char *,

const char *, const char *)) (cmd->func)) (parms,

mconfig, w, w2, w3);

case TAKE23:

w = ap_getword_conf(parms->pool, &args);

w2 = ap_getword_conf(parms->pool, &args);

w3 = *args ? ap_getword_conf(parms->pool, &args) : NULL;

if (*w == '\0' || *w2 == '\0' || *args != 0)

return ap_pstrcat(parms->pool, cmd->name,

" takes two or three arguments",

cmd->errmsg ? ", " : NULL, cmd->errmsg, NULL);

return ((const char *(*)(cmd_parms *, void *, const char *,

const char *, const char *)) (cmd->func)) (parms,

mconfig, w, w2, w3);

case TAKE123:

w = ap_getword_conf(parms->pool, &args);

w2 = *args ? ap_getword_conf(parms->pool, &args) : NULL;

w3 = *args ? ap_getword_conf(parms->pool, &args) : NULL;

if (*w == '\0' || *args != 0)

return ap_pstrcat(parms->pool, cmd->name,

" takes one, two or three arguments",

cmd->errmsg ? ", " : NULL, cmd->errmsg, NULL);

return ((const char *(*)(cmd_parms *, void *, const char *,

const char *, const char *)) (cmd->func)) (parms,

mconfig, w, w2, w3);

case TAKE13:

w = ap_getword_conf(parms->pool, &args);

w2 = *args ? ap_getword_conf(parms->pool, &args) : NULL;

w3 = *args ? ap_getword_conf(parms->pool, &args) : NULL;

if (*w == '\0' || (*w2 && !w3) || *args != 0)

return ap_pstrcat(parms->pool, cmd->name,

" takes one or three arguments",

cmd->errmsg ? ", " : NULL, cmd->errmsg, NULL);

return ((const char *(*)(cmd_parms *, void *, const char *,

const char *, const char *)) (cmd->func)) (parms,

mconfig, w, w2, w3);

case ITERATE:

while (*(w = ap_getword_conf(parms->pool, &args)) != '\0')

if ((errmsg = ((const char *(*)(cmd_parms *, void *,

const char *)) (cmd->func)) (parms, mconfig, w)))

return errmsg;

return NULL;

case ITERATE2:

w = ap_getword_conf(parms->pool, &args);

if (*w == '\0' || *args == 0)

return ap_pstrcat(parms->pool, cmd->name,

" requires at least two arguments",

cmd->errmsg ? ", " : NULL, cmd->errmsg, NULL);

while (*(w2 = ap_getword_conf(parms->pool, &args)) != '\0')

if ((errmsg = ((const char *(*)(cmd_parms *, void *,

const char *, const char *)) (cmd->func)) (parms,

mconfig, w, w2)))

return errmsg;

return NULL;

case FLAG:

w = ap_getword_conf(parms->pool, &args);

if (*w == '\0' || (strcasecmp(w, "on") && strcasecmp(w, "off")))

return ap_pstrcat(parms->pool, cmd->name, " must be On or Off",

NULL);

return ((const char *(*)(cmd_parms *, void *, int))

(cmd->func)) (parms, mconfig, strcasecmp(w, "off") != 0);

default:

return ap_pstrcat(parms->pool, cmd->name,

" is improperly configured internally (server bug)",

NULL);

}

}

CORE_EXPORT(const command_rec *) ap_find_command(const char *name, const command_rec *cmds)

{

while (cmds->name)

if (!strcasecmp(name, cmds->name))

return cmds;

else

++cmds;

return NULL;

}

CORE_EXPORT(const command_rec *) ap_find_command_in_modules(const char *cmd_name, module **mod)

{

const command_rec *cmdp;

module *modp;

for (modp = *mod; modp; modp = modp->next)

if (modp->cmds && (cmdp = ap_find_command(cmd_name, modp->cmds))) {

*mod = modp;

return cmdp;

}

return NULL;

}

CORE_EXPORT(void *) ap_set_config_vectors(cmd_parms *parms, void *config, module *mod)

{

void *mconfig = ap_get_module_config(config, mod);

void *sconfig = ap_get_module_config(parms->server->module_config, mod);

if (!mconfig && mod->create_dir_config) {

mconfig = (*mod->create_dir_config) (parms->pool, parms->path);

ap_set_module_config(config, mod, mconfig);

}

if (!sconfig && mod->create_server_config) {

sconfig = (*mod->create_server_config) (parms->pool, parms->server);

ap_set_module_config(parms->server->module_config, mod, sconfig);

}

return mconfig;

}

CORE_EXPORT(const char *) ap_handle_command(cmd_parms *parms, void *config, const char *l)

{

void *oldconfig;

const char *args, *cmd_name, *retval;

const command_rec *cmd;

module *mod = top_module;

if ((l[0] == '#') || (!l[0]))

return NULL;

args = l;

cmd_name = ap_getword_conf(parms->temp_pool, &args);

if (*cmd_name == '\0')

return NULL;

oldconfig = parms->context;

parms->context = config;

do {

if (!(cmd = ap_find_command_in_modules(cmd_name, &mod))) {

errno = EINVAL;

return ap_pstrcat(parms->pool, "Invalid command '", cmd_name,

"', perhaps mis-spelled or defined by a module "

"not included in the server configuration", NULL);

}

else {

void *mconfig = ap_set_config_vectors(parms,config, mod);

retval = invoke_cmd(cmd, parms, mconfig, args);

mod = mod->next; /* Next time around, skip this one */

}

} while (retval && !strcmp(retval, DECLINE_CMD));

parms->context = oldconfig;

return retval;

}

API_EXPORT(const char *) ap_srm_command_loop(cmd_parms *parms, void *config)

{

char l[MAX_STRING_LEN];

while (!(ap_cfg_getline(l, MAX_STRING_LEN, parms->config_file))) {

const char *errmsg = ap_handle_command(parms, config, l);

if (errmsg) {

return errmsg;

}

}

return NULL;

}

API_EXPORT_NONSTD(const char *) ap_set_string_slot(cmd_parms *cmd,

char *struct_ptr, char *arg)

{

/* This one's pretty generic... */

int offset = (int) (long) cmd->info;

*(char **) (struct_ptr + offset) = arg;

return NULL;

}

API_EXPORT_NONSTD(const char *) ap_set_string_slot_lower(cmd_parms *cmd,

char *struct_ptr, char *arg)

{

/* This one's pretty generic... */

int offset = (int) (long) cmd->info;

ap_str_tolower(arg);

*(char **) (struct_ptr + offset) = arg;

return NULL;

}

API_EXPORT_NONSTD(const char *) ap_set_flag_slot(cmd_parms *cmd,

char *struct_ptr, int arg)

{

/* This one's pretty generic too... */

int offset = (int) (long) cmd->info;

*(int *) (struct_ptr + offset) = arg ? 1 : 0;

return NULL;

}

API_EXPORT_NONSTD(const char *) ap_set_file_slot(cmd_parms *cmd, char *struct_ptr, char *arg)

{

/* Prepend server_root to relative arg.

char *p;

int offset = (int) (long) cmd->info;

if (ap_os_is_path_absolute(arg))

p = arg;

else

p = ap_make_full_path(cmd->pool, ap_server_root, arg);

*(char **) (struct_ptr + offset) = p;

return NULL;

}

static cmd_parms default_parms =

{NULL, 0, -1, NULL, NULL, NULL, NULL, NULL, NULL, NULL};

API_EXPORT(const char *) ap_server_root_relative(ap_context_t *p, const char *file)

{

if(ap_os_is_path_absolute(file))

return file;

return ap_make_full_path(p, ap_server_root, file);

}

typedef struct {

ap_array_header_t *array;

int curr_idx;

} arr_elts_param_t;

static void *arr_elts_getstr(void *buf, size_t bufsiz, void *param)

{

arr_elts_param_t *arr_param = (arr_elts_param_t *) param;

/* End of array reached? */

if (++arr_param->curr_idx > arr_param->array->nelts)

return NULL;

/* return the line */

ap_cpystrn(buf, ((char **) arr_param->array->elts)[arr_param->curr_idx - 1], bufsiz);

return buf;

}

static int arr_elts_close(void *param)

{

arr_elts_param_t *arr_param = (arr_elts_param_t *) param;

arr_param->curr_idx = arr_param->array->nelts;

return 0;

}

static void process_command_config(server_rec *s, ap_array_header_t *arr, ap_context_t *p,

ap_context_t *ptemp)

{

const char *errmsg;

cmd_parms parms;

arr_elts_param_t arr_parms;

arr_parms.curr_idx = 0;

arr_parms.array = arr;

parms = default_parms;

parms.pool = p;

parms.temp_pool = ptemp;

parms.server = s;

parms.override = (RSRC_CONF | OR_ALL) & ~(OR_AUTHCFG | OR_LIMIT);

parms.config_file = ap_pcfg_open_custom(p, "-c/-C directives",

&arr_parms, NULL,

arr_elts_getstr, arr_elts_close);

errmsg = ap_srm_command_loop(&parms, s->lookup_defaults);

if (errmsg) {

ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL,

"Syntax error in -C/-c directive:\n%s", errmsg);

exit(1);

}

ap_cfg_closefile(parms.config_file);

}

void ap_process_resource_config(server_rec *s, const char *fname, ap_context_t *p, ap_context_t *ptemp)

{

const char *errmsg;

cmd_parms parms;

ap_finfo_t finfo;

fname = ap_server_root_relative(p, fname);

if (!(strcmp(fname, ap_server_root_relative(p, RESOURCE_CONFIG_FILE))) ||

!(strcmp(fname, ap_server_root_relative(p, ACCESS_CONFIG_FILE)))) {

if (ap_stat(&finfo, fname, p) != APR_SUCCESS)

return;

}

/* don't require conf/httpd.conf if we have a -C or -c switch */

if((ap_server_pre_read_config->nelts || ap_server_post_read_config->nelts) &&

!(strcmp(fname, ap_server_root_relative(p, SERVER_CONFIG_FILE)))) {

if (ap_stat(&finfo, fname, p) != APR_SUCCESS)

return;

}

/* GCC's initialization extensions are soooo nice here... */

parms = default_parms;

parms.pool = p;

parms.temp_pool = ptemp;

parms.server = s;

parms.override = (RSRC_CONF | OR_ALL) & ~(OR_AUTHCFG | OR_LIMIT);

if (ap_pcfg_openfile(&parms.config_file, p, fname) != APR_SUCCESS) {

ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL,

"%s: could not open document config file %s",

ap_server_argv0, fname);

exit(1);

}

errmsg = ap_srm_command_loop(&parms, s->lookup_defaults);

if (errmsg) {

ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL,

"Syntax error on line %d of %s:",

parms.config_file->line_number, parms.config_file->name);

ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL,

"%s", errmsg);

exit(1);

}

ap_cfg_closefile(parms.config_file);

}

int ap_parse_htaccess(void **result, request_rec *r, int override,

const char *d, const char *access_name)

{

configfile_t *f = NULL;

cmd_parms parms;

const char *errmsg;

char *filename = NULL;

const struct htaccess_result *cache;

struct htaccess_result *new;

void *dc = NULL;

ap_status_t status;

for (cache = r->htaccess; cache != NULL; cache = cache->next)

if (cache->override == override && strcmp(cache->dir, d) == 0) {

if (cache->htaccess != NULL)

*result = cache->htaccess;

return OK;

}

parms = default_parms;

parms.override = override;

parms.pool = r->pool;

parms.temp_pool = r->pool;

parms.server = r->server;

parms.path = ap_pstrdup(r->pool, d);

/* loop through the access names and find the first one */

while (access_name[0]) {

filename = ap_make_full_path(r->pool, d,

ap_getword_conf(r->pool, &access_name));

status = ap_pcfg_openfile(&f, r->pool, filename);

if (status == APR_SUCCESS) {

dc = ap_create_per_dir_config(r->pool);

parms.config_file = f;

errmsg = ap_srm_command_loop(&parms, dc);

ap_cfg_closefile(f);

if (errmsg) {

ap_log_rerror(APLOG_MARK, APLOG_ALERT|APLOG_NOERRNO, 0, r,

"%s: %s", filename, errmsg);

return HTTP_INTERNAL_SERVER_ERROR;

}

*result = dc;

break;

}

else if (status != APR_ENOENT && status != APR_ENOTDIR) {

ap_log_rerror(APLOG_MARK, APLOG_CRIT, errno, r,

"%s pcfg_openfile: unable to check htaccess file, "

"ensure it is readable",

filename);

ap_table_setn(r->notes, "error-notes",

"Server unable to read htaccess file, denying "

"access to be safe");

return HTTP_FORBIDDEN;

}

}

new = ap_palloc(r->pool, sizeof(struct htaccess_result));

new->dir = parms.path;

new->override = override;

new->htaccess = dc;

new->next = r->htaccess;

r->htaccess = new;

return OK;

}

CORE_EXPORT(const char *) ap_init_virtual_host(ap_context_t *p, const char *hostname,

server_rec *main_server, server_rec **ps)

{

server_rec *s = (server_rec *) ap_pcalloc(p, sizeof(server_rec));

#ifdef RLIMIT_NOFILE

struct rlimit limits;

getrlimit(RLIMIT_NOFILE, &limits);

if (limits.rlim_cur < limits.rlim_max) {

limits.rlim_cur += 2;

if (setrlimit(RLIMIT_NOFILE, &limits) < 0) {

perror("setrlimit(RLIMIT_NOFILE)");

ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL,

"Cannot exceed hard limit for open files");

}

}

#endif

/* TODO: this crap belongs in http_core */

s->process = main_server->process;

s->server_admin = NULL;

s->server_hostname = NULL;

s->error_fname = NULL;

s->srm_confname = NULL;

s->access_confname = NULL;

s->timeout = 0;

s->keep_alive_timeout = 0;

s->keep_alive = -1;

s->keep_alive_max = -1;

s->error_log = main_server->error_log;

s->loglevel = main_server->loglevel;

/* useful default, otherwise we get a port of 0 on redirects */

s->port = main_server->port;

s->next = NULL;

s->is_virtual = 1;

s->names = ap_make_array(p, 4, sizeof(char **));

s->wild_names = ap_make_array(p, 4, sizeof(char **));

s->module_config = create_empty_config(p);

s->lookup_defaults = ap_create_per_dir_config(p);

#if 0

s->server_uid = ap_user_id;

s->server_gid = ap_group_id;

#endif

s->limit_req_line = main_server->limit_req_line;

s->limit_req_fieldsize = main_server->limit_req_fieldsize;

s->limit_req_fields = main_server->limit_req_fields;

*ps = s;

return ap_parse_vhost_addrs(p, hostname, s);

}

static void fixup_virtual_hosts(ap_context_t *p, server_rec *main_server)

{

server_rec *virt;

for (virt = main_server->next; virt; virt = virt->next) {

merge_server_configs(p, main_server->module_config,

virt->module_config);

virt->lookup_defaults =

ap_merge_per_dir_configs(p, main_server->lookup_defaults,

virt->lookup_defaults);

if (virt->server_admin == NULL)

virt->server_admin = main_server->server_admin;

if (virt->srm_confname == NULL)

virt->srm_confname = main_server->srm_confname;

if (virt->access_confname == NULL)

virt->access_confname = main_server->access_confname;

if (virt->timeout == 0)

virt->timeout = main_server->timeout;

if (virt->keep_alive_timeout == 0)

virt->keep_alive_timeout = main_server->keep_alive_timeout;

if (virt->keep_alive == -1)

virt->keep_alive = main_server->keep_alive;

if (virt->keep_alive_max == -1)

virt->keep_alive_max = main_server->keep_alive_max;

/* XXX: this is really something that should be dealt with by a

ap_core_reorder_directories(p, virt);

}

ap_core_reorder_directories(p, main_server);

}

static void init_config_globals(ap_context_t *p)

{

/* Global virtual host hash bucket pointers. Init to null. */

ap_init_vhost_config(p);

}

static server_rec *init_server_config(process_rec *process, ap_context_t *p)

{

server_rec *s = (server_rec *) ap_pcalloc(p, sizeof(server_rec));

ap_open_stderr(&s->error_log, p);

s->process = process;

s->port = 0;

s->server_admin = DEFAULT_ADMIN;

s->server_hostname = NULL;

s->error_fname = DEFAULT_ERRORLOG;

s->loglevel = DEFAULT_LOGLEVEL;

s->srm_confname = RESOURCE_CONFIG_FILE;

s->access_confname = ACCESS_CONFIG_FILE;

s->limit_req_line = DEFAULT_LIMIT_REQUEST_LINE;

s->limit_req_fieldsize = DEFAULT_LIMIT_REQUEST_FIELDSIZE;

s->limit_req_fields = DEFAULT_LIMIT_REQUEST_FIELDS;

s->timeout = DEFAULT_TIMEOUT;

s->keep_alive_timeout = DEFAULT_KEEPALIVE_TIMEOUT;

s->keep_alive_max = DEFAULT_KEEPALIVE;

s->keep_alive = 1;

s->next = NULL;

s->addrs = ap_pcalloc(p, sizeof(server_addr_rec));

/* NOT virtual host; don't match any real network interface */

s->addrs->host_addr.s_addr = htonl(INADDR_ANY);

s->addrs->host_port = 0; /* matches any port */

s->addrs->virthost = ""; /* must be non-NULL */

s->names = s->wild_names = NULL;

s->module_config = create_server_config(p, s);

s->lookup_defaults = create_default_per_dir_config(p);

return s;

}

server_rec *ap_read_config(process_rec *process, ap_context_t *ptemp, const char *confname)

{

ap_context_t *p = process->pconf;

server_rec *s = init_server_config(process, p);

init_config_globals(p);

/* All server-wide config files now have the SAME syntax... */

process_command_config(s, ap_server_pre_read_config, p, ptemp);

ap_process_resource_config(s, confname, p, ptemp);

ap_process_resource_config(s, s->srm_confname, p, ptemp);

ap_process_resource_config(s, s->access_confname, p, ptemp);