/* 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.

 */

/**

 * @file http_config.h

 * @brief Apache Configuration

 *

 * @defgroup APACHE_CORE_CONFIG Configuration

 * @ingroup  APACHE_CORE

 * @{

 */

#ifndef APACHE_HTTP_CONFIG_H

#define APACHE_HTTP_CONFIG_H

#include "util_cfgtree.h"

#include "ap_config.h"

#include "apr_tables.h"

#ifdef __cplusplus

extern "C" {

#endif

/*

 * The central data structures around here...

 */

/* Command dispatch structures... */

/**

 * How the directives arguments should be parsed.

 * @remark Note that for all of these except RAW_ARGS, the config routine is

 *      passed a freshly allocated string which can be modified or stored

 *      or whatever...

 */

enum cmd_how {

    RAW_ARGS,           /**< cmd_func parses command line itself */

    TAKE1,              /**< one argument only */

    TAKE2,              /**< two arguments only */

    ITERATE,            /**< one argument, occurring multiple times

                         * (e.g., IndexIgnore)

                         */

    ITERATE2,           /**< two arguments, 2nd occurs multiple times

                         * (e.g., AddIcon)

                         */

    FLAG,               /**< One of 'On' or 'Off' */

    NO_ARGS,            /**< No args at all, e.g. </Directory> */

    TAKE12,             /**< one or two arguments */

    TAKE3,              /**< three arguments only */

    TAKE23,             /**< two or three arguments */

    TAKE123,            /**< one, two or three arguments */

    TAKE13,             /**< one or three arguments */

    TAKE_ARGV           /**< an argc and argv are passed */

};

/**

 * This structure is passed to a command which is being invoked,

 * to carry a large variety of miscellaneous data which is all of

 * use to *somebody*...

 */

typedef struct cmd_parms_struct cmd_parms;

#if defined(AP_HAVE_DESIGNATED_INITIALIZER) || defined(DOXYGEN)

/**

 * All the types of functions that can be used in directives

 * @internal

 */

typedef union {

    /** function to call for a no-args */

    const char *(*no_args) (cmd_parms *parms, void *mconfig);

    /** function to call for a raw-args */

    const char *(*raw_args) (cmd_parms *parms, void *mconfig,

                             const char *args);

    /** function to call for a argv/argc */

    const char *(*take_argv) (cmd_parms *parms, void *mconfig,

                             int argc, char *const argv[]);

    /** function to call for a take1 */

    const char *(*take1) (cmd_parms *parms, void *mconfig, const char *w);

    /** function to call for a take2 */

    const char *(*take2) (cmd_parms *parms, void *mconfig, const char *w,

                          const char *w2);

    /** function to call for a take3 */

    const char *(*take3) (cmd_parms *parms, void *mconfig, const char *w,

                          const char *w2, const char *w3);

    /** function to call for a flag */

    const char *(*flag) (cmd_parms *parms, void *mconfig, int on);

} cmd_func;

/** This configuration directive does not take any arguments */

# define AP_NO_ARGS     func.no_args

/** This configuration directive will handle its own parsing of arguments*/

# define AP_RAW_ARGS    func.raw_args

/** This configuration directive will handle its own parsing of arguments*/

# define AP_TAKE_ARGV   func.take_argv

/** This configuration directive takes 1 argument*/

# define AP_TAKE1       func.take1

/** This configuration directive takes 2 arguments */

# define AP_TAKE2       func.take2

/** This configuration directive takes 3 arguments */

# define AP_TAKE3       func.take3

/** This configuration directive takes a flag (on/off) as a argument*/

# define AP_FLAG        func.flag

/** mechanism for declaring a directive with no arguments */

# define AP_INIT_NO_ARGS(directive, func, mconfig, where, help) \

    { directive, { .no_args=func }, mconfig, where, RAW_ARGS, help }

/** mechanism for declaring a directive with raw argument parsing */

# define AP_INIT_RAW_ARGS(directive, func, mconfig, where, help) \

    { directive, { .raw_args=func }, mconfig, where, RAW_ARGS, help }

/** mechanism for declaring a directive with raw argument parsing */

# define AP_INIT_TAKE_ARGV(directive, func, mconfig, where, help) \

    { directive, { .take_argv=func }, mconfig, where, TAKE_ARGV, help }

/** mechanism for declaring a directive which takes 1 argument */

# define AP_INIT_TAKE1(directive, func, mconfig, where, help) \

    { directive, { .take1=func }, mconfig, where, TAKE1, help }

/** mechanism for declaring a directive which takes multiple arguments */

# define AP_INIT_ITERATE(directive, func, mconfig, where, help) \

    { directive, { .take1=func }, mconfig, where, ITERATE, help }

/** mechanism for declaring a directive which takes 2 arguments */

# define AP_INIT_TAKE2(directive, func, mconfig, where, help) \

    { directive, { .take2=func }, mconfig, where, TAKE2, help }

/** mechanism for declaring a directive which takes 1 or 2 arguments */

# define AP_INIT_TAKE12(directive, func, mconfig, where, help) \

    { directive, { .take2=func }, mconfig, where, TAKE12, help }

/** mechanism for declaring a directive which takes multiple 2 arguments */

# define AP_INIT_ITERATE2(directive, func, mconfig, where, help) \

    { directive, { .take2=func }, mconfig, where, ITERATE2, help }

/** mechanism for declaring a directive which takes 1 or 3 arguments */

# define AP_INIT_TAKE13(directive, func, mconfig, where, help) \

    { directive, { .take3=func }, mconfig, where, TAKE13, help }

/** mechanism for declaring a directive which takes 2 or 3 arguments */

# define AP_INIT_TAKE23(directive, func, mconfig, where, help) \

    { directive, { .take3=func }, mconfig, where, TAKE23, help }

/** mechanism for declaring a directive which takes 1 to 3 arguments */

# define AP_INIT_TAKE123(directive, func, mconfig, where, help) \

    { directive, { .take3=func }, mconfig, where, TAKE123, help }

/** mechanism for declaring a directive which takes 3 arguments */

# define AP_INIT_TAKE3(directive, func, mconfig, where, help) \

    { directive, { .take3=func }, mconfig, where, TAKE3, help }

/** mechanism for declaring a directive which takes a flag (on/off) argument */

# define AP_INIT_FLAG(directive, func, mconfig, where, help) \

    { directive, { .flag=func }, mconfig, where, FLAG, help }

#else /* AP_HAVE_DESIGNATED_INITIALIZER */

typedef const char *(*cmd_func) ();

# define AP_NO_ARGS  func

# define AP_RAW_ARGS func

# define AP_TAKE_ARGV func

# define AP_TAKE1    func

# define AP_TAKE2    func

# define AP_TAKE3    func

# define AP_FLAG     func

# define AP_INIT_NO_ARGS(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, RAW_ARGS, help }

# define AP_INIT_RAW_ARGS(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, RAW_ARGS, help }

# define AP_INIT_TAKE_ARGV(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, TAKE_ARGV, help }

# define AP_INIT_TAKE1(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, TAKE1, help }

# define AP_INIT_ITERATE(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, ITERATE, help }

# define AP_INIT_TAKE2(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, TAKE2, help }

# define AP_INIT_TAKE12(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, TAKE12, help }

# define AP_INIT_ITERATE2(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, ITERATE2, help }

# define AP_INIT_TAKE13(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, TAKE13, help }

# define AP_INIT_TAKE23(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, TAKE23, help }

# define AP_INIT_TAKE123(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, TAKE123, help }

# define AP_INIT_TAKE3(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, TAKE3, help }

# define AP_INIT_FLAG(directive, func, mconfig, where, help) \

    { directive, func, mconfig, where, FLAG, help }

#endif /* AP_HAVE_DESIGNATED_INITIALIZER */

/**

 * The command record structure.  Modules can define a table of these

 * to define the directives it will implement.

 */

typedef struct command_struct command_rec;

struct command_struct {

    /** Name of this command */

    const char *name;

    /** The function to be called when this directive is parsed */

    cmd_func func;

    /** Extra data, for functions which implement multiple commands... */

    void *cmd_data;

    /** What overrides need to be allowed to enable this command. */

    int req_override;

    /** What the command expects as arguments */

    enum cmd_how args_how;

    /** 'usage' message, in case of syntax errors */

    const char *errmsg;

};

/**

 * @defgroup ConfigDirectives Allowed locations for configuration directives.

 *

 * The allowed locations for a configuration directive are the union of

 * those indicated by each set bit in the req_override mask.

 *

 * @{

 */

#define OR_NONE 0             /**< *.conf is not available anywhere in this override */

#define OR_LIMIT 1           /**< *.conf inside <Directory> or <Location>

                                and .htaccess when AllowOverride Limit */

#define OR_OPTIONS 2         /**< *.conf anywhere

                                and .htaccess when AllowOverride Options */

#define OR_FILEINFO 4        /**< *.conf anywhere

                                and .htaccess when AllowOverride FileInfo */

#define OR_AUTHCFG 8         /**< *.conf inside <Directory> or <Location>

                                and .htaccess when AllowOverride AuthConfig */

#define OR_INDEXES 16        /**< *.conf anywhere

                                and .htaccess when AllowOverride Indexes */

#define OR_UNSET 32          /**< bit to indicate that AllowOverride has not been set */

#define ACCESS_CONF 64       /**< *.conf inside <Directory> or <Location> */

#define RSRC_CONF 128        /**< *.conf outside <Directory> or <Location> */

#define EXEC_ON_READ 256     /**< force directive to execute a command

                which would modify the configuration (like including another

                file, or IFModule */

/* Flags to determine whether syntax errors in .htaccess should be

 * treated as nonfatal (log and ignore errors)

 */

#define NONFATAL_OVERRIDE 512    /* Violation of AllowOverride rule */

#define NONFATAL_UNKNOWN 1024    /* Unrecognised directive */

#define NONFATAL_ALL (NONFATAL_OVERRIDE|NONFATAL_UNKNOWN)

#define PROXY_CONF 2048      /**< *.conf inside <Proxy> only */

/** this directive can be placed anywhere */

#define OR_ALL (OR_LIMIT|OR_OPTIONS|OR_FILEINFO|OR_AUTHCFG|OR_INDEXES)

/** @} */

/**

 * This can be returned by a function if they don't wish to handle

 * a command. Make it something not likely someone will actually use

 * as an error code.

 */

#define DECLINE_CMD "\a\b"

/** Common structure for reading of config files / passwd files etc. */

typedef struct ap_configfile_t ap_configfile_t;

struct ap_configfile_t {

    /**< an apr_file_getc()-like function */

    apr_status_t (*getch) (char *ch, void *param);

    /**< an apr_file_gets()-like function */

    apr_status_t (*getstr) (void *buf, apr_size_t bufsiz, void *param);

    /**< a close handler function */

    apr_status_t (*close) (void *param);

    /**< the argument passed to getch/getstr/close */

    void *param;

    /**< the filename / description */

    const char *name;

    /**< current line number, starting at 1 */

    unsigned line_number;

};

/**

 * This structure is passed to a command which is being invoked,

 * to carry a large variety of miscellaneous data which is all of

 * use to *somebody*...

 */

struct cmd_parms_struct {

    /** Argument to command from cmd_table */

    void *info;

    /** Which allow-override bits are set */

    int override;

    /** Which allow-override-opts bits are set */

    int override_opts;

    /** Table of directives allowed per AllowOverrideList */

    apr_table_t *override_list;

    /** Which methods are <Limit>ed */

    apr_int64_t limited;

    /** methods which are limited */

    apr_array_header_t *limited_xmethods;

    /** methods which are xlimited */

    ap_method_list_t *xlimited;

    /** Config file structure. */

    ap_configfile_t *config_file;

    /** the directive specifying this command */

    ap_directive_t *directive;

    /** Pool to allocate new storage in */

    apr_pool_t *pool;

    /** Pool for scratch memory; persists during configuration, but

     *  wiped before the first request is served...  */

    apr_pool_t *temp_pool;

    /** Server_rec being configured for */

    server_rec *server;

    /** If configuring for a directory, pathname of that directory.

     *  NOPE!  That's what it meant previous to the existence of <Files>,

     * <Location> and regex matching.  Now the only usefulness that can be

     * derived from this field is whether a command is being called in a

     * server context (path == NULL) or being called in a dir context

     * (path != NULL).  */

    char *path;

    /** configuration command */

    const command_rec *cmd;

    /** per_dir_config vector passed to handle_command */

    struct ap_conf_vector_t *context;

    /** directive with syntax error */

    const ap_directive_t *err_directive;

};

/**

 * Flags associated with a module.

 */

#define AP_MODULE_FLAG_NONE         (0)

#define AP_MODULE_FLAG_ALWAYS_MERGE (1 << 0)

/**

 * Module structures.  Just about everything is dispatched through

 * these, directly or indirectly (through the command and handler

 * tables).

 */

typedef struct module_struct module;

struct module_struct {

    /** API version, *not* module version; check that module is

     * compatible with this version of the server.

     */

    int version;

    /** API minor version. Provides API feature milestones. Not checked

     *  during module init */

    int minor_version;

    /** Index to this modules structures in config vectors.  */

    int module_index;

    /** The name of the module's C file */

    const char *name;

    /** The handle for the DSO.  Internal use only */

    void *dynamic_load_handle;

    /** A pointer to the next module in the list

     *  @var module_struct *next

     */

    struct module_struct *next;

    /** Magic Cookie to identify a module structure;  It's mainly

     *  important for the DSO facility (see also mod_so).  */

    unsigned long magic;

    /** Function to allow MPMs to re-write command line arguments.  This

     *  hook is only available to MPMs.

     *  @param The process that the server is running in.

     */

    void (*rewrite_args) (process_rec *process);

    /** Function to allow all modules to create per directory configuration

     *  structures.

     *  @param p The pool to use for all allocations.

     *  @param dir The directory currently being processed.

     *  @return The per-directory structure created

     */

    void *(*create_dir_config) (apr_pool_t *p, char *dir);

    /** Function to allow all modules to merge the per directory configuration

     *  structures for two directories.

     *  @param p The pool to use for all allocations.

     *  @param base_conf The directory structure created for the parent directory.

     *  @param new_conf The directory structure currently being processed.

     *  @return The new per-directory structure created

     */

    void *(*merge_dir_config) (apr_pool_t *p, void *base_conf, void *new_conf);

    /** Function to allow all modules to create per server configuration

     *  structures.

     *  @param p The pool to use for all allocations.

     *  @param s The server currently being processed.

     *  @return The per-server structure created

     */

    void *(*create_server_config) (apr_pool_t *p, server_rec *s);

    /** Function to allow all modules to merge the per server configuration

     *  structures for two servers.

     *  @param p The pool to use for all allocations.

     *  @param base_conf The directory structure created for the parent directory.

     *  @param new_conf The directory structure currently being processed.

     *  @return The new per-directory structure created

     */

    void *(*merge_server_config) (apr_pool_t *p, void *base_conf,

                                  void *new_conf);

    /** A command_rec table that describes all of the directives this module

     * defines. */

    const command_rec *cmds;

    /** A hook to allow modules to hook other points in the request processing.

     *  In this function, modules should call the ap_hook_*() functions to

     *  register an interest in a specific step in processing the current

     *  request.

     *  @param p the pool to use for all allocations

     */

    void (*register_hooks) (apr_pool_t *p);

    /** A bitmask of AP_MODULE_FLAG_* */

    int flags;

};

/**

 * The AP_MAYBE_UNUSED macro is used for variable declarations that

 * might potentially exhibit "unused var" warnings on some compilers if

 * left untreated.

 * Since static intializers are not part of the C language (C89), making

 * (void) usage is not possible. However many compiler have proprietary 

 * mechanism to suppress those warnings.  

 */

#ifdef AP_MAYBE_UNUSED

#elif defined(__GNUC__)

# define AP_MAYBE_UNUSED(x) x __attribute__((unused)) 

#elif defined(__LCLINT__)

# define AP_MAYBE_UNUSED(x) /*@unused@*/ x  

#else

# define AP_MAYBE_UNUSED(x) x

#endif

/**

 * The APLOG_USE_MODULE macro is used choose which module a file belongs to.

 * This is necessary to allow per-module loglevel configuration.

 *

 * APLOG_USE_MODULE indirectly sets APLOG_MODULE_INDEX and APLOG_MARK.

 *

 * If a module should be backward compatible with versions before 2.3.6,

 * APLOG_USE_MODULE needs to be enclosed in a ifdef APLOG_USE_MODULE block.

 *

 * @param foo name of the module symbol of the current module, without the

 *            trailing "_module" part

 * @see APLOG_MARK

 */

#define APLOG_USE_MODULE(foo) \

    extern module AP_MODULE_DECLARE_DATA foo##_module;                  \

    AP_MAYBE_UNUSED(static int * const aplog_module_index) = &(foo##_module.module_index)

/**

 * AP_DECLARE_MODULE is a convenience macro that combines a call of

 * APLOG_USE_MODULE with the definition of the module symbol.

 *

 * If a module should be backward compatible with versions before 2.3.6,

 * APLOG_USE_MODULE should be used explicitly instead of AP_DECLARE_MODULE.

 */

#define AP_DECLARE_MODULE(foo) \

    APLOG_USE_MODULE(foo);                         \

    module AP_MODULE_DECLARE_DATA foo##_module

/**

 * @defgroup ModuleInit Module structure initializers

 *

 * Initializer for the first few module slots, which are only

 * really set up once we start running.  Note that the first two slots

 * provide a version check; this should allow us to deal with changes to

 * the API. The major number should reflect changes to the API handler table

 * itself or removal of functionality. The minor number should reflect

 * additions of functionality to the existing API. (the server can detect

 * an old-format module, and either handle it back-compatibly, or at least

 * signal an error). See src/include/ap_mmn.h for MMN version history.

 * @{

 */

/** The one used in Apache 1.3, which will deliberately cause an error */

#define STANDARD_MODULE_STUFF   this_module_needs_to_be_ported_to_apache_2_0

/** Use this in all standard modules */

#define STANDARD20_MODULE_STUFF MODULE_MAGIC_NUMBER_MAJOR, \

                                MODULE_MAGIC_NUMBER_MINOR, \

                                -1, \

                                __FILE__, \

                                NULL, \

                                NULL, \

                                MODULE_MAGIC_COOKIE, \

                                NULL      /* rewrite args spot */

/** Use this only in MPMs */

#define MPM20_MODULE_STUFF      MODULE_MAGIC_NUMBER_MAJOR, \

                                MODULE_MAGIC_NUMBER_MINOR, \

                                -1, \

                                __FILE__, \

                                NULL, \

                                NULL, \

                                MODULE_MAGIC_COOKIE

/** @} */

/* CONFIGURATION VECTOR FUNCTIONS */

/** configuration vector structure */

typedef struct ap_conf_vector_t ap_conf_vector_t;

/**

 * Generic accessors for other modules to get at their own module-specific

 * data

 * @param cv The vector in which the modules configuration is stored.

 *        usually r->per_dir_config or s->module_config

 * @param m The module to get the data for.

 * @return The module-specific data

 */

AP_DECLARE(void *) ap_get_module_config(const ap_conf_vector_t *cv,

                                        const module *m);

/**

 * Generic accessors for other modules to set their own module-specific

 * data

 * @param cv The vector in which the modules configuration is stored.

 *        usually r->per_dir_config or s->module_config

 * @param m The module to set the data for.

 * @param val The module-specific data to set

 */

AP_DECLARE(void) ap_set_module_config(ap_conf_vector_t *cv, const module *m,

                                      void *val);

/**

 * When module flags have been introduced, and a way to check this.

 */

#define AP_MODULE_FLAGS_MMN_MAJOR 20120211

#define AP_MODULE_FLAGS_MMN_MINOR 70

#define AP_MODULE_HAS_FLAGS(m) \

        AP_MODULE_MAGIC_AT_LEAST(AP_MODULE_FLAGS_MMN_MAJOR, \

                                 AP_MODULE_FLAGS_MMN_MINOR)

/**

 * Generic accessor for the module's flags

 * @param m The module to get the flags from.

 * @return The module-specific flags

 */

AP_DECLARE(int) ap_get_module_flags(const module *m);

#if !defined(AP_DEBUG)

#define ap_get_module_config(v,m)       \

    (((void **)(v))[(m)->module_index])

#define ap_set_module_config(v,m,val)   \

    ((((void **)(v))[(m)->module_index]) = (val))

#endif /* AP_DEBUG */

/**

 * Generic accessor for modules to get the module-specific loglevel

 * @param s The server from which to get the loglevel.

 * @param index The module_index of the module to get the loglevel for.

 * @return The module-specific loglevel

 */

AP_DECLARE(int) ap_get_server_module_loglevel(const server_rec *s, int index);

/**

 * Generic accessor for modules the module-specific loglevel

 * @param c The connection from which to get the loglevel.

 * @param index The module_index of the module to get the loglevel for.

 * @return The module-specific loglevel

 */

AP_DECLARE(int) ap_get_conn_module_loglevel(const conn_rec *c, int index);

/**

 * Generic accessor for modules the module-specific loglevel

 * @param c The connection from which to get the loglevel.

 * @param s The server from which to get the loglevel if c does not have a

 *          specific loglevel configuration.

 * @param index The module_index of the module to get the loglevel for.

 * @return The module-specific loglevel

 */

AP_DECLARE(int) ap_get_conn_server_module_loglevel(const conn_rec *c,

                                                   const server_rec *s,

                                                   int index);

/**

 * Generic accessor for modules to get the module-specific loglevel

 * @param r The request from which to get the loglevel.

 * @param index The module_index of the module to get the loglevel for.

 * @return The module-specific loglevel

 */

AP_DECLARE(int) ap_get_request_module_loglevel(const request_rec *r, int index);

/**

 * Accessor to set module-specific loglevel

 * @param p A pool

 * @param l The ap_logconf struct to modify.

 * @param index The module_index of the module to set the loglevel for.

 * @param level The new log level

 */

AP_DECLARE(void) ap_set_module_loglevel(apr_pool_t *p, struct ap_logconf *l,

                                        int index, int level);

#if !defined(AP_DEBUG)

#define ap_get_conn_logconf(c)                     \

    ((c)->log             ? (c)->log             : \

     &(c)->base_server->log)

#define ap_get_conn_server_logconf(c,s)                             \

    ( ( (c)->log != &(c)->base_server->log && (c)->log != NULL )  ? \

      (c)->log                                                    : \

      &(s)->log )

#define ap_get_request_logconf(r)                  \

    ((r)->log             ? (r)->log             : \

     (r)->connection->log ? (r)->connection->log : \

     &(r)->server->log)

#define ap_get_module_loglevel(l,i)                                     \

    (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ?  \

     (l)->level :                                                         \

     (l)->module_levels[i])

#define ap_get_server_module_loglevel(s,i)  \

    (ap_get_module_loglevel(&(s)->log,i))

#define ap_get_conn_module_loglevel(c,i)  \

    (ap_get_module_loglevel(ap_get_conn_logconf(c),i))

#define ap_get_conn_server_module_loglevel(c,s,i)  \

    (ap_get_module_loglevel(ap_get_conn_server_logconf(c,s),i))

#define ap_get_request_module_loglevel(r,i)  \

    (ap_get_module_loglevel(ap_get_request_logconf(r),i))

#endif /* AP_DEBUG */

/**

 * Set all module-specific loglevels to val

 * @param l The log config for which to set the loglevels.

 * @param val the value to set all loglevels to

 */

AP_DECLARE(void) ap_reset_module_loglevels(struct ap_logconf *l, int val);

/**

 * Generic command handling function for strings

 * @param cmd The command parameters for this directive

 * @param struct_ptr pointer into a given type

 * @param arg The argument to the directive

 * @return An error string or NULL on success

 */

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

                                                   void *struct_ptr,

                                                   const char *arg);

/**

 * Generic command handling function for integers

 * @param cmd The command parameters for this directive

 * @param struct_ptr pointer into a given type

 * @param arg The argument to the directive

 * @return An error string or NULL on success

 */

AP_DECLARE_NONSTD(const char *) ap_set_int_slot(cmd_parms *cmd,

                                                void *struct_ptr,

                                                const char *arg);

/**

 * Parsing function for log level

 * @param str The string to parse

 * @param val The parsed log level

 * @return An error string or NULL on success

 */

AP_DECLARE(const char *) ap_parse_log_level(const char *str, int *val);

/**

 * Return true if the specified method is limited by being listed in

 * a <Limit> container, or by *not* being listed in a <LimitExcept>

 * container.

 *

 * @param   method  Pointer to a string specifying the method to check.

 * @param   cmd     Pointer to the cmd_parms structure passed to the

 *                  directive handler.

 * @return  0 if the method is not limited in the current scope

 */

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

/**

 * Generic command handling function for strings, always sets the value

 * to a lowercase string

 * @param cmd The command parameters for this directive

 * @param struct_ptr pointer into a given type

 * @param arg The argument to the directive

 * @return An error string or NULL on success

 */

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

                                                         void *struct_ptr,

                                                         const char *arg);

/**

 * Generic command handling function for flags stored in an int

 * @param cmd The command parameters for this directive

 * @param struct_ptr pointer into a given type

 * @param arg The argument to the directive (either 1 or 0)

 * @return An error string or NULL on success

 */

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

                                                 void *struct_ptr,

                                                 int arg);

/**

 * Generic command handling function for flags stored in a char

 * @param cmd The command parameters for this directive

 * @param struct_ptr pointer into a given type

 * @param arg The argument to the directive (either 1 or 0)

 * @return An error string or NULL on success

 */

AP_DECLARE_NONSTD(const char *) ap_set_flag_slot_char(cmd_parms *cmd,

                                                      void *struct_ptr,

                                                      int arg);

/**

 * Generic command handling function for files

 * @param cmd The command parameters for this directive

 * @param struct_ptr pointer into a given type

 * @param arg The argument to the directive

 * @return An error string or NULL on success

 */

AP_DECLARE_NONSTD(const char *) ap_set_file_slot(cmd_parms *cmd,

                                                 void *struct_ptr,

                                                 const char *arg);

/**

 * Generic command handling function to respond with cmd->help as an error

 * @param cmd The command parameters for this directive

 * @param struct_ptr pointer into a given type

 * @param arg The argument to the directive

 * @return The cmd->help value as the error string

 * @note This allows simple declarations such as:

 * @code

 *     AP_INIT_RAW_ARGS("Foo", ap_set_deprecated, NULL, OR_ALL,

 *         "The Foo directive is no longer supported, use Bar"),

 * @endcode

 */

AP_DECLARE_NONSTD(const char *) ap_set_deprecated(cmd_parms *cmd,

                                                  void *struct_ptr,

                                                  const char *arg);

/**

 * For modules which need to read config files, open logs, etc. this returns

 * the canonical form of fname made absolute to ap_server_root.

 * @param p pool to allocate data from

 * @param fname The file name

 */

AP_DECLARE(char *) ap_server_root_relative(apr_pool_t *p, const char *fname);

/**

 * Compute the name of a run-time file (e.g., shared memory "file") relative

 * to the appropriate run-time directory.  Absolute paths are returned as-is.

 * The run-time directory is configured via the DefaultRuntimeDir directive or

 * at build time.

 */

AP_DECLARE(char *) ap_runtime_dir_relative(apr_pool_t *p, const char *fname);

/* Finally, the hook for dynamically loading modules in... */

/**

 * Add a module to the server

 * @param m The module structure of the module to add

 * @param p The pool of the same lifetime as the module

 * @param s The module's symbol name (used for logging)

 */

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

                                       const char *s);

/**

 * Remove a module from the server.  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.

 * @param m the module structure of the module to remove

 */

AP_DECLARE(void) ap_remove_module(module *m);

/**

 * Add a module to the chained modules list and the list of loaded modules

 * @param mod The module structure of the module to add

 * @param p The pool with the same lifetime as the module

 * @param s The module's symbol name (used for logging)

 */

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

                                              const char *s);

/**

 * Remove a module fromthe chained modules list and the list of loaded modules

 * @param mod the module structure of the module to remove

 */

AP_DECLARE(void) ap_remove_loaded_module(module *mod);

/**

 * Find the name of the specified module

 * @param m The module to get the name for

 * @return the name of the module

 */

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

/**

 * Find the short name of the module identified by the specified module index

 * @param module_index The module index to get the name for

 * @return the name of the module, NULL if not found

 */

AP_DECLARE(const char *) ap_find_module_short_name(int module_index);

/**

 * Find a module based on the name of the module

 * @param name the name of the module

 * @return the module structure if found, NULL otherwise

 */

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

/**

 * Open a ap_configfile_t as apr_file_t

 * @param ret_cfg open ap_configfile_t struct pointer

 * @param p The pool to allocate the structure from

 * @param name the name of the file to open

 */

AP_DECLARE(apr_status_t) ap_pcfg_openfile(ap_configfile_t **ret_cfg,

                                          apr_pool_t *p, const char *name);

/**

 * Allocate a ap_configfile_t handle with user defined functions and params

 * @param p The pool to allocate from

 * @param descr The name of the file

 * @param param The argument passed to getch/getstr/close

 * @param getc_func The getch function

 * @param gets_func The getstr function

 * @param close_func The close function

 */

AP_DECLARE(ap_configfile_t *) ap_pcfg_open_custom(apr_pool_t *p,

    const char *descr,

    void *param,

    apr_status_t (*getc_func) (char *ch, void *param),

    apr_status_t (*gets_func) (void *buf, apr_size_t bufsiz, void *param),

    apr_status_t (*close_func) (void *param));

/**

 * Read one line from open ap_configfile_t, strip leading and trailing

 * whitespace, increase line number

 * @param buf place to store the line read

 * @param bufsize size of the buffer

 * @param cfp File to read from

 * @return error status, APR_ENOSPC if bufsize is too small for the line

 */

AP_DECLARE(apr_status_t) ap_cfg_getline(char *buf, apr_size_t bufsize, ap_configfile_t *cfp);

/**

 * Read one char from open configfile_t, increase line number upon LF

 * @param ch place to store the char read

 * @param cfp The file to read from

 * @return error status

 */

AP_DECLARE(apr_status_t) ap_cfg_getc(char *ch, ap_configfile_t *cfp);

/**

 * Detach from open ap_configfile_t, calling the close handler

 * @param cfp The file to close

 * @return 1 on success, 0 on failure

 */

AP_DECLARE(int) ap_cfg_closefile(ap_configfile_t *cfp);

/**

 * Convert a return value from ap_cfg_getline or ap_cfg_getc to a user friendly

 * string.

 * @param p The pool to allocate the string from

 * @param cfp The config file

 * @param rc The return value to convert

 * @return The error string, NULL if rc == APR_SUCCESS

 */

AP_DECLARE(const char *) ap_pcfg_strerror(apr_pool_t *p, ap_configfile_t *cfp,

                                          apr_status_t rc);

/**

 * Read all data between the current <foo> and the matching </foo>.  All

 * of this data is forgotten immediately.

 * @param cmd The cmd_parms to pass to the directives inside the container

 * @param directive The directive name to read until

 * @return Error string on failure, NULL on success

 * @note If cmd->pool == cmd->temp_pool, ap_soak_end_container() will assume

 *       .htaccess context and use a lower maximum line length.