-/* ====================================================================
- * The Apache Software License, Version 1.1
+/* 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
*
- * Copyright (c) 2000-2001 The Apache Software Foundation. All rights
- * reserved.
+ * http://www.apache.org/licenses/LICENSE-2.0
*
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- *
- * 3. The end-user documentation included with the redistribution,
- * if any, must include the following acknowledgment:
- * "This product includes software developed by the
- * Apache Software Foundation (http://www.apache.org/)."
- * Alternately, this acknowledgment may appear in the software itself,
- * if and wherever such third-party acknowledgments normally appear.
- *
- * 4. The names "Apache" and "Apache Software Foundation" must
- * not be used to endorse or promote products derived from this
- * software without prior written permission. For written
- * permission, please contact apache@apache.org.
- *
- * 5. Products derived from this software may not be called "Apache",
- * nor may "Apache" appear in their name, without prior written
- * permission of the Apache Software Foundation.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
- * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
- * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * ====================================================================
- *
- * This software consists of voluntary contributions made by many
- * individuals on behalf of the Apache Software Foundation. For more
- * information on the Apache Software Foundation, please see
- * <http://www.apache.org/>.
+ * 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
*
- * Portions of this software are based upon public domain software
- * originally written at the National Center for Supercomputing Applications,
- * University of Illinois, Urbana-Champaign.
+ * @defgroup APACHE_CORE_CONFIG Configuration
+ * @ingroup APACHE_CORE
+ * @{
*/
#ifndef APACHE_HTTP_CONFIG_H
extern "C" {
#endif
-/**
- * @file http_config.h
- * @brief Apache Configuration
- */
-
/*
* The central data structures around here...
*/
TAKE3, /**< three arguments only */
TAKE23, /**< two or three arguments */
TAKE123, /**< one, two or three arguments */
- TAKE13 /**< one 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 */
+/**
+ * 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 it's own parsing of arguments*/
# define AP_RAW_ARGS func.raw_args
+/** This configuration directive will handle it's 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
+/** method of 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 }
+/** method of 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 }
+/** method of 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 }
+/** method of declaring a directive which takes 1 argument */
# define AP_INIT_TAKE1(directive, func, mconfig, where, help) \
{ directive, { .take1=func }, mconfig, where, TAKE1, help }
+/** method of declaring a directive which takes multiple arguments */
# define AP_INIT_ITERATE(directive, func, mconfig, where, help) \
{ directive, { .take1=func }, mconfig, where, ITERATE, help }
+/** method of declaring a directive which takes 2 arguments */
# define AP_INIT_TAKE2(directive, func, mconfig, where, help) \
{ directive, { .take2=func }, mconfig, where, TAKE2, help }
+/** method of 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 }
+/** method of declaring a directive which takes multiple 2 arguments */
# define AP_INIT_ITERATE2(directive, func, mconfig, where, help) \
{ directive, { .take2=func }, mconfig, where, ITERATE2, help }
+/** method of 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 }
+/** method of 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 }
+/** method of 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 }
+/** method of declaring a directive which takes 3 arguments */
# define AP_INIT_TAKE3(directive, func, mconfig, where, help) \
{ directive, { .take3=func }, mconfig, where, TAKE3, help }
+/** method of declaring a directive which takes a flag (on/off) as a argument*/
# define AP_INIT_FLAG(directive, func, mconfig, where, help) \
{ directive, { .flag=func }, mconfig, where, FLAG, help }
# 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
{ 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, 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) \
#endif /* AP_HAVE_DESIGNATED_INITIALIZER */
-typedef struct command_struct command_rec;
/**
* The command record structure. Each 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;
*
* @{
*/
-#define OR_NONE 0
+#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 AuthConfig */
#define OR_INDEXES 16 /**< *.conf anywhere
and .htaccess when AllowOverride Indexes */
-#define OR_UNSET 32
+#define OR_UNSET 32 /**< unset a directive (in Allow) */
#define ACCESS_CONF 64 /**< *.conf inside <Directory> or <Location> */
#define RSRC_CONF 128 /**< *.conf outside <Directory> or <Location> */
-#define EXEC_ON_READ 256
+#define EXEC_ON_READ 256 /**< force directive to execute a command
+ which would modify the configuration (like including another
+ file, or IFModule */
+/** this directive can be placed anywhere */
#define OR_ALL (OR_LIMIT|OR_OPTIONS|OR_FILEINFO|OR_AUTHCFG|OR_INDEXES)
/** @} */
*/
#define DECLINE_CMD "\a\b"
-typedef struct ap_configfile_t ap_configfile_t;
/** Common structure for reading of config files / passwd files etc. */
+typedef struct ap_configfile_t ap_configfile_t;
struct ap_configfile_t {
int (*getch) (void *param); /**< a getc()-like function */
void *(*getstr) (void *buf, size_t bufsiz, void *param);
int override;
/** 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. */
struct ap_conf_vector_t *context;
/** directive with syntax error */
const ap_directive_t *err_directive;
+
+ /** Which allow-override-opts bits are set */
+ int override_opts;
};
-typedef struct module_struct module;
/**
* 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.
* @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);
+ 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. */
/* CONFIGURATION VECTOR FUNCTIONS */
+/** configuration vector structure */
typedef struct ap_conf_vector_t ap_conf_vector_t;
-#if defined(AP_DEBUG) || defined(DOXYGEN)
/**
* Generic accessors for other modules to get at their own module-specific
* data
AP_DECLARE(void) ap_set_module_config(ap_conf_vector_t *cv, const module *m,
void *val);
-#else /* AP_DEBUG */
+#if !defined(AP_DEBUG)
#define ap_get_module_config(v,m) \
(((void **)(v))[(m)->module_index])
* @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);
+AP_DECLARE_NONSTD(const char *) ap_set_string_slot(cmd_parms *cmd,
+ void *struct_ptr,
+ const char *arg);
/**
* Generic command handling function for integers
* @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);
+ void *struct_ptr,
+ const char *arg);
/**
* Generic command handling function for flags
* @param cmd The command parameters for this directive
* @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);
+AP_DECLARE_NONSTD(const char *) ap_set_flag_slot(cmd_parms *cmd,
+ void *struct_ptr,
+ int arg);
/**
* Generic command handling function for files
* @param cmd The command parameters for this directive
* @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);
+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
* "The Foo directive is no longer supported, use Bar"),
* </pre>
*/
-AP_DECLARE_NONSTD(const char *) ap_set_deprecated(cmd_parms *cmd, void *struct_ptr, const char *arg);
+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 fname argument if it begins with '/'; otherwise
- * it relativizes it wrt server_root.
+ * 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(const char *) ap_server_root_relative(apr_pool_t *p, const char *fname);
+AP_DECLARE(char *) ap_server_root_relative(apr_pool_t *p, const char *fname);
/* Finally, the hook for dynamically loading modules in... */
* @param m The module structure of the module to add
* @param p The pool of the same lifetime as the module
*/
-AP_DECLARE(void) ap_add_module(module *m, apr_pool_t *p);
+AP_DECLARE(const char *) ap_add_module(module *m, apr_pool_t *p);
/**
* Remove a module from the server. There are some caveats:
* @param m The module structure of the module to add
* @param p The pool with the same lifetime as the module
*/
-AP_DECLARE(void) ap_add_loaded_module(module *mod, apr_pool_t *p);
+AP_DECLARE(const char *) ap_add_loaded_module(module *mod, apr_pool_t *p);
/**
* Remove a module fromthe chained modules list and the list of loaded modules
* @param m the module structure of the module to remove
*/
AP_DECLARE(void) ap_remove_loaded_module(module *mod);
-/**
- * Add a module to the list of loaded module based on the name of the
- * module
- * @param name The name of the module
- * @param p The pool valid for the lifetime of the module
- * @return 1 on success, 0 on failure
- */
-AP_DECLARE(int) ap_add_named_module(const char *name, apr_pool_t *p);
/**
* Find the name of the specified module
* @param m The module to get the name for
* @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);
+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 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,
+AP_DECLARE(ap_configfile_t *) ap_pcfg_open_custom(apr_pool_t *p,
+ const char *descr,
void *param,
int(*getc_func)(void*),
void *(*gets_func) (void *buf, size_t bufsiz, void *param),
* @return Error string on failure, NULL on success
*/
AP_DECLARE(const char *) ap_build_cont_config(apr_pool_t *p,
- apr_pool_t *temp_pool,
- cmd_parms *parms,
- ap_directive_t **current,
- ap_directive_t **curr_parent,
- char *orig_directive);
+ apr_pool_t *temp_pool,
+ cmd_parms *parms,
+ ap_directive_t **current,
+ ap_directive_t **curr_parent,
+ char *orig_directive);
/**
* Build a config tree from a config file
* @return Error string on erro, NULL otherwise
*/
AP_DECLARE(const char *) ap_build_config(cmd_parms *parms,
- apr_pool_t *conf_pool,
- apr_pool_t *temp_pool,
- ap_directive_t **conftree);
+ apr_pool_t *conf_pool,
+ apr_pool_t *temp_pool,
+ ap_directive_t **conftree);
/**
* Walk a config tree and setup the server's internal structures
* @return Error string on error, NULL otherwise
*/
AP_DECLARE(const char *) ap_walk_config(ap_directive_t *conftree,
- cmd_parms *parms,
+ cmd_parms *parms,
ap_conf_vector_t *section_vector);
/**
- * @defgroup ap_check_cmd_context ap_check_cmd_context
+ * @defgroup ap_check_cmd_context Check command context
* @{
+ */
+/**
* Check the context a command is used in.
* @param cmd The command to check
* @param forbidden Where the command is forbidden.
* @return Error string on error, NULL on success
*/
-AP_DECLARE(const char *) ap_check_cmd_context(cmd_parms *cmd, unsigned forbidden);
+AP_DECLARE(const char *) ap_check_cmd_context(cmd_parms *cmd,
+ unsigned forbidden);
#define NOT_IN_VIRTUALHOST 0x01 /**< Forbidden in <Virtualhost> */
#define NOT_IN_LIMIT 0x02 /**< Forbidden in <Limit> */
#define NOT_IN_DIRECTORY 0x04 /**< Forbidden in <Directory> */
#define NOT_IN_LOCATION 0x08 /**< Forbidden in <Location> */
#define NOT_IN_FILES 0x10 /**< Forbidden in <Files> */
-#define NOT_IN_DIR_LOC_FILE (NOT_IN_DIRECTORY|NOT_IN_LOCATION|NOT_IN_FILES) /**< Forbidden in <Directory>/<Location>/<Files>*/
-#define GLOBAL_ONLY (NOT_IN_VIRTUALHOST|NOT_IN_LIMIT|NOT_IN_DIR_LOC_FILE)
+/** Forbidden in <Directory>/<Location>/<Files>*/
+#define NOT_IN_DIR_LOC_FILE (NOT_IN_DIRECTORY|NOT_IN_LOCATION|NOT_IN_FILES)
+/** Forbidden in <VirtualHost>/<Limit>/<Directory>/<Location>/<Files> */
+#define GLOBAL_ONLY (NOT_IN_VIRTUALHOST|NOT_IN_LIMIT|NOT_IN_DIR_LOC_FILE)
/** @} */
#ifdef CORE_PRIVATE
+/**
+ * @brief This structure is used to assign symbol names to module pointers
+ */
+typedef struct {
+ const char *name;
+ module *modp;
+} ap_module_symbol_t;
+
/**
* The topmost module in the list
* @defvar module *ap_top_module
* @defvar module *ap_prelinked_modules[]
*/
AP_DECLARE_DATA extern module *ap_prelinked_modules[];
+/**
+ * Array of all statically linked modulenames (symbols)
+ * @defvar ap_module_symbol_t ap_prelinked_modulenames[]
+ */
+AP_DECLARE_DATA extern ap_module_symbol_t ap_prelinked_module_symbols[];
/**
* Array of all preloaded modules
* @defvar module *ap_preloaded_modules[]
* Add all of the prelinked modules into the loaded module list
* @param process The process that is currently running the server
*/
-AP_DECLARE(void) ap_setup_prelinked_modules(process_rec *process);
+AP_DECLARE(const char *) ap_setup_prelinked_modules(process_rec *process);
/**
* Show the preloaded configuration directives, the help string explaining
* @param conftree Place to store the root of the config tree
* @return The setup server_rec list.
*/
-AP_DECLARE(server_rec *) ap_read_config(process_rec *process, apr_pool_t *temp_pool, const char *config_name, ap_directive_t **conftree);
+AP_DECLARE(server_rec *) ap_read_config(process_rec *process,
+ apr_pool_t *temp_pool,
+ const char *config_name,
+ ap_directive_t **conftree);
/**
* Run all rewrite args hooks for loaded modules
* @param p The pool to allocate from
* @param main_server The head of the server_rec list
*/
-AP_DECLARE(void) ap_fixup_virtual_hosts(apr_pool_t *p, server_rec *main_server);
+AP_DECLARE(void) ap_fixup_virtual_hosts(apr_pool_t *p,
+ server_rec *main_server);
/* For http_request.c... */
* int The status of the current request
*/
AP_CORE_DECLARE(int) ap_parse_htaccess(ap_conf_vector_t **result,
- request_rec *r, int override,
- const char *path, const char *access_name);
+ request_rec *r, int override,
+ int override_opts,
+ const char *path,
+ const char *access_name);
/**
* Setup a virtual host
* @param ps Place to store the new server_rec
* return Error string on error, NULL on success
*/
-AP_CORE_DECLARE(const char *) ap_init_virtual_host(apr_pool_t *p, const char *hostname,
- server_rec *main_server, server_rec **);
+AP_CORE_DECLARE(const char *) ap_init_virtual_host(apr_pool_t *p,
+ const char *hostname,
+ server_rec *main_server,
+ server_rec **ps);
/**
* Process the config file for Apache
* @param p Pool for general allocation
* @param ptem Pool for temporary allocation
*/
-AP_DECLARE(void) ap_process_resource_config(server_rec *s, const char *fname,
- ap_directive_t **conftree, apr_pool_t *p, apr_pool_t *ptemp);
+AP_DECLARE(const char *) ap_process_resource_config(server_rec *s,
+ const char *fname,
+ ap_directive_t **conftree,
+ apr_pool_t *p,
+ apr_pool_t *ptemp);
/**
* Process all directives in the config tree
* @param conftree The config tree to process
* @param p The pool for general allocation
* @param ptemp The pool for temporary allocations
+ * @return OK if no problems
*/
-AP_DECLARE(void) ap_process_config_tree(server_rec *s, ap_directive_t *conftree,
- apr_pool_t *p, apr_pool_t *ptemp);
+AP_DECLARE(int) ap_process_config_tree(server_rec *s,
+ ap_directive_t *conftree,
+ apr_pool_t *p,
+ apr_pool_t *ptemp);
/* Module-method dispatchers, also for http_request.c */
/**
* @param cmds The table to search
* @return The directive definition of the specified directive
*/
-AP_CORE_DECLARE(const command_rec *) ap_find_command(const char *name, const command_rec *cmds);
+AP_CORE_DECLARE(const command_rec *) ap_find_command(const char *name,
+ const command_rec *cmds);
/**
* Find a given directive in a list module
* @param mod The module list to search
* @return The directive definition of the specified directive
*/
-AP_CORE_DECLARE(const command_rec *) ap_find_command_in_modules(const char *cmd_name, module **mod);
+AP_CORE_DECLARE(const command_rec *) ap_find_command_in_modules(const char *cmd_name,
+ module **mod);
/**
* Ask a module to create per-server and per-section (dir/loc/file) configs
* @param pconf The config pool
* @param plog The logging streams pool
* @param ptemp The temporary pool
+ * @return OK or DECLINED on success anything else is a error
+ */
+AP_DECLARE_HOOK(int,pre_config,(apr_pool_t *pconf,apr_pool_t *plog,
+ apr_pool_t *ptemp))
+
+/**
+ * Run the check_config function for each module
+ * @param pconf The config pool
+ * @param plog The logging streams pool
+ * @param ptemp The temporary pool
+ * @return OK or DECLINED on success anything else is a error
*/
-AP_DECLARE_HOOK(void,pre_config,(apr_pool_t *pconf,apr_pool_t *plog,apr_pool_t *ptemp))
+AP_DECLARE_HOOK(int,check_config,(apr_pool_t *pconf, apr_pool_t *plog,
+ apr_pool_t *ptemp, server_rec *s))
+
+/**
+ * Run the test_config function for each module; this hook is run
+ * only if the server was invoked to test the configuration syntax.
+ * @param pconf The config pool
+ * @param s The list of server_recs
+ */
+AP_DECLARE_HOOK(void,test_config,(apr_pool_t *pconf, server_rec *s))
/**
* Run the post_config function for each module
* @param plog The logging streams pool
* @param ptemp The temporary pool
* @param s The list of server_recs
+ * @return OK or DECLINED on success anything else is a error
*/
-AP_DECLARE_HOOK(void,post_config,(apr_pool_t *pconf,apr_pool_t *plog,apr_pool_t *ptemp,server_rec *s))
+AP_DECLARE_HOOK(int,post_config,(apr_pool_t *pconf,apr_pool_t *plog,
+ apr_pool_t *ptemp,server_rec *s))
/**
* Run the open_logs functions for each module
* @param plog The logging streams pool
* @param ptemp The temporary pool
* @param s The list of server_recs
+ * @return OK or DECLINED on success anything else is a error
*/
-AP_DECLARE_HOOK(void,open_logs,(apr_pool_t *pconf,apr_pool_t *plog,apr_pool_t *ptemp,server_rec *s))
+AP_DECLARE_HOOK(int,open_logs,(apr_pool_t *pconf,apr_pool_t *plog,
+ apr_pool_t *ptemp,server_rec *s))
/**
* Run the child_init functions for each module
* is run before any other requests hooks are called (location_walk,
* directory_walk, access checking, et. al.). This hook was added
* to provide a quick way to serve content from a URI keyed cache.
+ *
* @param r The request_rec
+ * @param lookup_uri Controls whether the caller actually wants content or not.
+ * lookup is set when the quick_handler is called out of
+ * ap_sub_req_lookup_uri()
*/
-AP_DECLARE_HOOK(int,quick_handler,(request_rec *r))
+AP_DECLARE_HOOK(int,quick_handler,(request_rec *r, int lookup_uri))
/**
* Retrieve the optional functions for each module.
#endif
#endif /* !APACHE_HTTP_CONFIG_H */
+/** @} */
projects / apache / blobdiff