/* Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/*

 * http_config.c: once was auxiliary functions for reading httpd's config

 * file and converting filenames into a namespace

 *

 * Rob McCool

 *

 * Wall-to-wall rewrite for Apache... commands which are part of the

 * server core can now be found next door in "http_core.c".  Now contains

 * general command loop, and functions which do bookkeeping for the new

 * Apache config stuff (modules and configuration vectors).

 *

 * rst

 *

 */

#include "apr.h"

#include "apr_strings.h"

#include "apr_portable.h"

#include "apr_file_io.h"

#include "apr_fnmatch.h"

#define APR_WANT_STDIO

#define APR_WANT_STRFUNC

#include "apr_want.h"

#include "ap_config.h"

#include "httpd.h"

#include "http_config.h"

#include "http_protocol.h"

#include "http_core.h"

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

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

#include "http_main.h"

#include "http_vhost.h"

#include "util_cfgtree.h"

#include "util_varbuf.h"

#include "mpm_common.h"

#define APLOG_UNSET   (APLOG_NO_MODULE - 1)

/* we know core's module_index is 0 */

#undef APLOG_MODULE_INDEX

#define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX

AP_DECLARE_DATA const char *ap_server_argv0 = NULL;

AP_DECLARE_DATA const char *ap_server_root = NULL;

AP_DECLARE_DATA const char *ap_runtime_dir = NULL;

AP_DECLARE_DATA server_rec *ap_server_conf = NULL;

AP_DECLARE_DATA apr_pool_t *ap_pglobal = NULL;

AP_DECLARE_DATA apr_array_header_t *ap_server_pre_read_config = NULL;

AP_DECLARE_DATA apr_array_header_t *ap_server_post_read_config = NULL;

AP_DECLARE_DATA apr_array_header_t *ap_server_config_defines = NULL;

AP_DECLARE_DATA ap_directive_t *ap_conftree = NULL;

APR_HOOK_STRUCT(

           APR_HOOK_LINK(header_parser)

           APR_HOOK_LINK(pre_config)

           APR_HOOK_LINK(check_config)

           APR_HOOK_LINK(post_config)

           APR_HOOK_LINK(open_logs)

           APR_HOOK_LINK(child_init)

           APR_HOOK_LINK(handler)

           APR_HOOK_LINK(quick_handler)

           APR_HOOK_LINK(optional_fn_retrieve)

           APR_HOOK_LINK(test_config)

           APR_HOOK_LINK(open_htaccess)

)

AP_IMPLEMENT_HOOK_RUN_ALL(int, header_parser,

                          (request_rec *r), (r), OK, DECLINED)

AP_IMPLEMENT_HOOK_RUN_ALL(int, pre_config,

                          (apr_pool_t *pconf, apr_pool_t *plog,

                           apr_pool_t *ptemp),

                          (pconf, plog, ptemp), OK, DECLINED)

AP_IMPLEMENT_HOOK_RUN_ALL(int, check_config,

                          (apr_pool_t *pconf, apr_pool_t *plog,

                           apr_pool_t *ptemp, server_rec *s),

                          (pconf, plog, ptemp, s), OK, DECLINED)

AP_IMPLEMENT_HOOK_VOID(test_config,

                       (apr_pool_t *pconf, server_rec *s),

                       (pconf, s))

AP_IMPLEMENT_HOOK_RUN_ALL(int, post_config,

                          (apr_pool_t *pconf, apr_pool_t *plog,

                           apr_pool_t *ptemp, server_rec *s),

                          (pconf, plog, ptemp, s), OK, DECLINED)

/* During the course of debugging I expanded this macro out, so

 * rather than remove all the useful information there is in the

 * following lines, I'm going to leave it here in case anyone

 * else finds it useful.

 *

 * Ben has looked at it and thinks it correct :)

 *

AP_DECLARE(int) ap_hook_post_config(ap_HOOK_post_config_t *pf,

                                    const char * const *aszPre,

                                    const char * const *aszSucc,

                                    int nOrder)

{

    ap_LINK_post_config_t *pHook;

    if (!_hooks.link_post_config) {

        _hooks.link_post_config = apr_array_make(apr_hook_global_pool, 1,

                                                 sizeof(ap_LINK_post_config_t));

        apr_hook_sort_register("post_config", &_hooks.link_post_config);

    }

    pHook = apr_array_push(_hooks.link_post_config);

    pHook->pFunc = pf;

    pHook->aszPredecessors = aszPre;

    pHook->aszSuccessors = aszSucc;

    pHook->nOrder = nOrder;

    pHook->szName = apr_hook_debug_current;

    if (apr_hook_debug_enabled)

        apr_hook_debug_show("post_config", aszPre, aszSucc);

}

AP_DECLARE(apr_array_header_t *) ap_hook_get_post_config(void)

{

    return _hooks.link_post_config;

}

AP_DECLARE(int) ap_run_post_config(apr_pool_t *pconf,

                                   apr_pool_t *plog,

                                   apr_pool_t *ptemp,

                                   server_rec *s)

{

    ap_LINK_post_config_t *pHook;

    int n;

    if (!_hooks.link_post_config)

        return;

    pHook = (ap_LINK_post_config_t *)_hooks.link_post_config->elts;

    for (n = 0; n < _hooks.link_post_config->nelts; ++n)

        pHook[n].pFunc (pconf, plog, ptemp, s);

}

 */

AP_IMPLEMENT_HOOK_RUN_ALL(int, open_logs,

                          (apr_pool_t *pconf, apr_pool_t *plog,

                           apr_pool_t *ptemp, server_rec *s),

                          (pconf, plog, ptemp, s), OK, DECLINED)

AP_IMPLEMENT_HOOK_VOID(child_init,

                       (apr_pool_t *pchild, server_rec *s),

                       (pchild, s))

AP_IMPLEMENT_HOOK_RUN_FIRST(int, handler, (request_rec *r),

                            (r), DECLINED)

AP_IMPLEMENT_HOOK_RUN_FIRST(int, quick_handler, (request_rec *r, int lookup),

                            (r, lookup), DECLINED)

AP_IMPLEMENT_HOOK_RUN_FIRST(apr_status_t, open_htaccess,

                            (request_rec *r, const char *dir_name, const char *access_name,

                             ap_configfile_t **conffile, const char **full_name),

                            (r, dir_name, access_name, conffile, full_name),

                            AP_DECLINED)

/* hooks with no args are implemented last, after disabling APR hook probes */

#if defined(APR_HOOK_PROBES_ENABLED)

#undef APR_HOOK_PROBES_ENABLED

#undef APR_HOOK_PROBE_ENTRY

#define APR_HOOK_PROBE_ENTRY(ud,ns,name,args)

#undef APR_HOOK_PROBE_RETURN

#define APR_HOOK_PROBE_RETURN(ud,ns,name,rv,args)

#undef APR_HOOK_PROBE_INVOKE

#define APR_HOOK_PROBE_INVOKE(ud,ns,name,src,args)

#undef APR_HOOK_PROBE_COMPLETE

#define APR_HOOK_PROBE_COMPLETE(ud,ns,name,src,rv,args)

#undef APR_HOOK_INT_DCL_UD

#define APR_HOOK_INT_DCL_UD

#endif

AP_IMPLEMENT_HOOK_VOID(optional_fn_retrieve, (void), ())

/****************************************************************

 *

 * We begin with the functions which deal with the linked list

 * of modules which control just about all of the server operation.

 */

/* total_modules is the number of modules that have been linked

 * into the server.

 */

static int total_modules = 0;

/* dynamic_modules is the number of modules that have been added

 * after the pre-loaded ones have been set up. It shouldn't be larger

 * than DYNAMIC_MODULE_LIMIT.

 */

static int dynamic_modules = 0;

/* The maximum possible value for total_modules, i.e. number of static

 * modules plus DYNAMIC_MODULE_LIMIT.

 */

static int max_modules = 0;

/* The number of elements we need to alloc for config vectors. Before loading

 * of dynamic modules, we must be liberal and set this to max_modules. After

 * loading of dynamic modules, we can trim it down to total_modules. On

 * restart, reset to max_modules.

 */

static int conf_vector_length = 0;

static int reserved_module_slots = 0;

AP_DECLARE_DATA module *ap_top_module = NULL;

AP_DECLARE_DATA module **ap_loaded_modules=NULL;

static apr_hash_t *ap_config_hash = NULL;

/* a list of the module symbol names with the trailing "_module"removed */

static char **ap_module_short_names = NULL;

typedef int (*handler_func)(request_rec *);

typedef void *(*dir_maker_func)(apr_pool_t *, char *);

typedef void *(*merger_func)(apr_pool_t *, void *, void *);

/* A list of the merge_dir_config functions of all loaded modules, sorted

 * by module_index.

 * Using this list in ap_merge_per_dir_configs() is faster than following

 * the module->next linked list because of better memory locality (resulting

 * in better cache usage).

 */

static merger_func *merger_func_cache;

/* maximum nesting level for config directories */

#ifndef AP_MAX_INCLUDE_DIR_DEPTH

#define AP_MAX_INCLUDE_DIR_DEPTH (128)

#endif

/* Dealing with config vectors.  These are associated with per-directory,

 * per-server, and per-request configuration, and have a void* pointer for

 * each modules.  The nature of the structure pointed to is private to the

 * module in question... the core doesn't (and can't) know.  However, there

 * are defined interfaces which allow it to create instances of its private

 * per-directory and per-server structures, and to merge the per-directory

 * structures of a directory and its subdirectory (producing a new one in

 * which the defaults applying to the base directory have been properly

 * overridden).

 */

static ap_conf_vector_t *create_empty_config(apr_pool_t *p)

{

    void *conf_vector = apr_pcalloc(p, sizeof(void *) * conf_vector_length);

    return conf_vector;

}

static ap_conf_vector_t *create_default_per_dir_config(apr_pool_t *p)

{

    void **conf_vector = apr_pcalloc(p, sizeof(void *) * conf_vector_length);

    module *modp;

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

        dir_maker_func df = modp->create_dir_config;

        if (df)

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

    }

    return (ap_conf_vector_t *)conf_vector;

}

AP_CORE_DECLARE(ap_conf_vector_t *) ap_merge_per_dir_configs(apr_pool_t *p,

                                           ap_conf_vector_t *base,

                                           ap_conf_vector_t *new_conf)

{

    void **conf_vector = apr_palloc(p, sizeof(void *) * conf_vector_length);

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

    void **new_vector = (void **)new_conf;

    int i;

    for (i = 0; i < total_modules; i++) {

        if (!new_vector[i]) {

            conf_vector[i] = base_vector[i];

        }

        else {

            const merger_func df = merger_func_cache[i];

            if (df && base_vector[i]) {

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

            }

            else

                conf_vector[i] = new_vector[i];

        }

    }

    return (ap_conf_vector_t *)conf_vector;

}

static ap_conf_vector_t *create_server_config(apr_pool_t *p, server_rec *s)

{

    void **conf_vector = apr_pcalloc(p, sizeof(void *) * conf_vector_length);

    module *modp;

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

        if (modp->create_server_config)

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

    }

    return (ap_conf_vector_t *)conf_vector;

}

static void merge_server_configs(apr_pool_t *p, ap_conf_vector_t *base,

                                 server_rec *virt)

{

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

     * have to deal with the moral equivalent of .htaccess files here...

     */

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

    void **virt_vector = (void **)virt->module_config;

    module *modp;

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

        merger_func df = modp->merge_server_config;

        int i = modp->module_index;

        if (!virt_vector[i]) {

            if (df && modp->create_server_config

                   && (ap_get_module_flags(modp) &

                       AP_MODULE_FLAG_ALWAYS_MERGE)) {

                virt_vector[i] = (*modp->create_server_config)(p, virt);

            }

            else {

                virt_vector[i] = base_vector[i];

                df = NULL;

            }

        }

        if (df) {

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

        }

    }

}

AP_CORE_DECLARE(ap_conf_vector_t *) ap_create_request_config(apr_pool_t *p)

{

    return create_empty_config(p);

}

AP_CORE_DECLARE(ap_conf_vector_t *) ap_create_conn_config(apr_pool_t *p)

{

    return create_empty_config(p);

}

AP_CORE_DECLARE(ap_conf_vector_t *) ap_create_per_dir_config(apr_pool_t *p)

{

    return create_empty_config(p);

}

/* Invoke the filter_init_func for all filters with FILTERS where f->r

 * matches R.  Restricting to a matching R avoids re-running init

 * functions for filters configured for r->main where r is a

 * subrequest.  */

static int invoke_filter_init(request_rec *r, ap_filter_t *filters)

{

    while (filters) {

        if (filters->frec->filter_init_func && filters->r == r) {

            int result = filters->frec->filter_init_func(filters);

            if (result != OK) {

                return result;

            }

        }

        filters = filters->next;

    }

    return OK;

}

AP_CORE_DECLARE(int) ap_invoke_handler(request_rec *r)

{

    const char *handler;

    const char *p;

    int result;

    const char *old_handler = r->handler;

    const char *ignore;

    /*

     * The new insert_filter stage makes the most sense here.  We only use

     * it when we are going to run the request, so we must insert filters

     * if any are available.  Since the goal of this phase is to allow all

     * modules to insert a filter if they want to, this filter returns

     * void.  I just can't see any way that this filter can reasonably

     * fail, either your modules inserts something or it doesn't.  rbb

     */

    ap_run_insert_filter(r);

    /* Before continuing, allow each filter that is in the two chains to

     * run their init function to let them do any magic before we could

     * start generating data.

     */

    result = invoke_filter_init(r, r->input_filters);

    if (result != OK) {

        return result;

    }

    result = invoke_filter_init(r, r->output_filters);

    if (result != OK) {

        return result;

    }

    if (!r->handler) {

        if (r->content_type) {

            handler = r->content_type;

            if ((p=ap_strchr_c(handler, ';')) != NULL) {

                char *new_handler = (char *)apr_pmemdup(r->pool, handler,

                                                        p - handler + 1);

                char *p2 = new_handler + (p - handler);

                handler = new_handler;

                /* exclude media type arguments */

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

                    --p2; /* strip trailing spaces */

                *p2='\0';

            }

        }

        else {

            handler = AP_DEFAULT_HANDLER_NAME;

        }

        r->handler = handler;

    }

    result = ap_run_handler(r);

    r->handler = old_handler;

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

        ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(00523)

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

    }

    if ((result != OK) && (result != DONE) && (result != DECLINED) && (result != SUSPENDED)

        && (result != AP_FILTER_ERROR) /* ap_die() knows about this specifically */

        && !ap_is_HTTP_VALID_RESPONSE(result)) {

        /* If a module is deliberately returning something else

         * (request_rec in non-HTTP or proprietary extension?)

         * let it set a note to allow it explicitly.

         * Otherwise, a return code that is neither reserved nor HTTP

         * is a bug, as in PR#31759.

         */

        ignore = apr_table_get(r->notes, "HTTP_IGNORE_RANGE");

        if (!ignore) {

            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00524)

                          "Handler for %s returned invalid result code %d",

                          r->handler, result);

            result = HTTP_INTERNAL_SERVER_ERROR;

        }

    }

    return result == DECLINED ? HTTP_INTERNAL_SERVER_ERROR : result;

}

AP_DECLARE(int) ap_method_is_limited(cmd_parms *cmd, const char *method)

{

    int methnum;

    methnum = ap_method_number_of(method);

    /*

     * A method number either hardcoded into apache or

     * added by a module and registered.

     */

    if (methnum != M_INVALID) {

        return (cmd->limited & (AP_METHOD_BIT << methnum)) ? 1 : 0;

    }

    return 0; /* not found */

}

AP_DECLARE(void) ap_register_hooks(module *m, apr_pool_t *p)

{

    if (m->register_hooks) {

        if (getenv("SHOW_HOOKS")) {

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

            apr_hook_debug_enabled = 1;

        }

        apr_hook_debug_current = m->name;

        m->register_hooks(p);

    }

}

static void ap_add_module_commands(module *m, apr_pool_t *p);

typedef struct ap_mod_list_struct ap_mod_list;

struct ap_mod_list_struct {

    struct ap_mod_list_struct *next;

    module *m;

    const command_rec *cmd;

};

static void rebuild_conf_hash(apr_pool_t *p, int add_prelinked)

{

    module **m;

    ap_config_hash = apr_hash_make(p);

    apr_pool_cleanup_register(p, &ap_config_hash, ap_pool_cleanup_set_null,

                              apr_pool_cleanup_null);

    if (add_prelinked) {

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

            ap_add_module_commands(*m, p);

        }

    }

}

static void ap_add_module_commands(module *m, apr_pool_t *p)

{

    apr_pool_t *tpool;

    ap_mod_list *mln;

    const command_rec *cmd;

    char *dir;

    cmd = m->cmds;

    if (ap_config_hash == NULL) {

        rebuild_conf_hash(p, 0);

    }

    tpool = apr_hash_pool_get(ap_config_hash);

    while (cmd && cmd->name) {

        mln = apr_palloc(tpool, sizeof(ap_mod_list));

        mln->cmd = cmd;

        mln->m = m;

        dir = apr_pstrdup(tpool, cmd->name);

        ap_str_tolower(dir);

        mln->next = apr_hash_get(ap_config_hash, dir, APR_HASH_KEY_STRING);

        apr_hash_set(ap_config_hash, dir, APR_HASH_KEY_STRING, mln);

        ++cmd;

    }

}

/* One-time setup for precompiled modules --- NOT to be done on restart */

AP_DECLARE(const char *) ap_add_module(module *m, apr_pool_t *p,

                                       const char *sym_name)

{

    ap_module_symbol_t *sym = ap_prelinked_module_symbols;

    /* This could be called from a LoadModule httpd.conf command,

     * after the file has been linked and the module structure within it

     * teased out...

     */

    if (m->version != MODULE_MAGIC_NUMBER_MAJOR) {

        return apr_psprintf(p, "Module \"%s\" is not compatible with this "

                            "version of Apache (found %d, need %d). Please "

                            "contact the vendor for the correct version.",

                            m->name, m->version, MODULE_MAGIC_NUMBER_MAJOR);

    }

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

        if (dynamic_modules >= DYNAMIC_MODULE_LIMIT) {

            return apr_psprintf(p, "Module \"%s\" could not be loaded, "

                                "because the dynamic module limit was "

                                "reached. Please increase "

                                "DYNAMIC_MODULE_LIMIT and recompile.", m->name);

        }

        /*

         * If this fails some module forgot to call ap_reserve_module_slots*.

         */

        ap_assert(total_modules < conf_vector_length);

        m->module_index = total_modules++;

        dynamic_modules++;

    }

    else if (!sym_name) {

        while (sym->modp != NULL) {

            if (sym->modp == m) {

                sym_name = sym->name;

                break;

            }

            sym++;

        }

    }

    if (m->next == NULL) {

        m->next = ap_top_module;

        ap_top_module = m;

    }

    if (sym_name) {

        int len = strlen(sym_name);

        int slen = strlen("_module");

        if (len > slen && !strcmp(sym_name + len - slen, "_module")) {

            len -= slen;

        }

        ap_module_short_names[m->module_index] = ap_malloc(len + 1);

        memcpy(ap_module_short_names[m->module_index], sym_name, len);

        ap_module_short_names[m->module_index][len] = '\0';

        merger_func_cache[m->module_index] = m->merge_dir_config;

    }

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

     * only the filename (e.g. mod_includes.c). So check for path

     * components (Unix and DOS), and remove them.

     */

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

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

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

        m->name = 1 + ap_strrchr_c(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 = ap_malloc(strlen(m->name)); /* FIXME: memory leak, albeit a small one */

        memcpy(tmp, m->name, strlen(m->name)-1);

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

        m->name = tmp;

    }

#endif /*_OSD_POSIX*/

    ap_add_module_commands(m, p);

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

     *  It doesn't appear to be

     */

    ap_register_hooks(m, p);

    return NULL;

}

/*

 * remove_module undoes what add_module did. There are some caveats:

 * when the module is removed, its slot is lost so all the current

 * per-dir and per-server configurations are invalid. So we should

 * only ever call this function when you are invalidating almost

 * all our current data. I.e. when doing a restart.

 */

AP_DECLARE(void) ap_remove_module(module *m)

{

    module *modp;

    modp = ap_top_module;

    if (modp == m) {

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

        ap_top_module = modp->next;

        m->next = NULL;

    }

    else {

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

         * point to the module _before_ us in the list

         */

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

            modp = modp->next;

        }

        if (!modp) {

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

            ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL, APLOGNO(00525)

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

                         m->name);

            return;

        }

        /* Eliminate us from the module list */

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

    }

    free(ap_module_short_names[m->module_index]);

    ap_module_short_names[m->module_index] = NULL;

    merger_func_cache[m->module_index] = NULL;

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

                           * be unnecessary */

    dynamic_modules--;

    total_modules--;

}

AP_DECLARE(const char *) ap_add_loaded_module(module *mod, apr_pool_t *p,

                                              const char *short_name)

{

    module **m;

    const char *error;

    /*

     *  Add module pointer to top of chained module list

     */

    error = ap_add_module(mod, p, short_name);

    if (error) {

        return error;

    }

    /*

     *  And module pointer to list of loaded modules

     *

     *  Notes: 1. ap_add_module() would already complain if no more space

     *            exists for adding a dynamically loaded module

     *         2. ap_add_module() accepts double inclusion, so we have

     *            to accept this, too.

     */

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

        ;

    *m++ = mod;

    *m = NULL;

    return NULL;

}

AP_DECLARE(void) ap_remove_loaded_module(module *mod)

{

    module **m;

    module **m2;

    int done;

    /*

     *  Remove module pointer from chained module list

     */

    ap_remove_module(mod);

    /*

     *  Remove module pointer from list of loaded modules

     *

     *  Note: 1. We cannot determine if the module was successfully

     *           removed by ap_remove_module().

     *        2. We have not to complain explicitly when the module

     *           is not found because ap_remove_module() did it

     *           for us already.

     */

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

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

            done = 1;

        else

            *m++ = *m2;

    }

    *m = NULL;

}

AP_DECLARE(const char *) ap_setup_prelinked_modules(process_rec *process)

{

    module **m;

    module **m2;

    const char *error;

    apr_hook_global_pool=process->pconf;

    rebuild_conf_hash(process->pconf, 0);

    /*

     *  Initialise total_modules variable and module indices

     */

    total_modules = 0;

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

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

    max_modules = total_modules + DYNAMIC_MODULE_LIMIT + 1;

    conf_vector_length = max_modules;

    /*

     *  Initialise list of loaded modules and short names

     */

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

        sizeof(module *) * conf_vector_length);

    if (!ap_module_short_names)

        ap_module_short_names = ap_calloc(sizeof(char *), conf_vector_length);

    if (!merger_func_cache)

        merger_func_cache = ap_calloc(sizeof(merger_func), conf_vector_length);

    if (ap_loaded_modules == NULL || ap_module_short_names == NULL

        || merger_func_cache == NULL)

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

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

        *m2++ = *m++;

    *m2 = NULL;

    /*

     *   Initialize chain of linked (=activate) modules

     */

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

        error = ap_add_module(*m, process->pconf, NULL);

        if (error) {

            return error;

        }

    }

    apr_hook_sort_all();

    return NULL;

}

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

{

    return m->name;

}

AP_DECLARE(const char *) ap_find_module_short_name(int module_index)

{

        if (module_index < 0 || module_index >= conf_vector_length)

                return NULL;

        return ap_module_short_names[module_index];

}

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

{

    module *modp;

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

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

            return modp;

    }

    return NULL;

}

/*****************************************************************

 *

 * Resource, access, and .htaccess config files now parsed by a common

 * command loop.

 *

 * Let's begin with the basics; parsing the line and

 * invoking the function...

 */

#define AP_MAX_ARGC 64

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

                              void *mconfig, const char *args)

{

    int override_list_ok = 0;

    char *w, *w2, *w3;

    const char *errmsg = NULL;

    /* Have we been provided a list of acceptable directives? */

    if (parms->override_list != NULL) { 

         if (apr_table_get(parms->override_list, cmd->name) != NULL) { 

              override_list_ok = 1;

         }

    }

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

        if (parms->override & NONFATAL_OVERRIDE) {

            ap_log_perror(APLOG_MARK, APLOG_WARNING, 0, parms->temp_pool,

                          APLOGNO(02295)

                          "%s in .htaccess forbidden by AllowOverride",

                          cmd->name);

            return NULL;

        }

        else if (parms->directive && parms->directive->parent) {

            return apr_pstrcat(parms->pool, cmd->name, " not allowed in ",

                               parms->directive->parent->directive, ">",

                               " context", NULL);

        }