1/* Licensed to the Apache Software Foundation (ASF) under one or more 2 * contributor license agreements. See the NOTICE file distributed with 3 * this work for additional information regarding copyright ownership. 4 * The ASF licenses this file to You under the Apache License, Version 2.0 5 * (the "License"); you may not use this file except in compliance with 6 * the License. You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17/** 18 * @file http_config.h 19 * @brief Apache Configuration 20 * 21 * @defgroup APACHE_CORE_CONFIG Configuration 22 * @ingroup APACHE_CORE 23 * @{ 24 */ 25 26#ifndef APACHE_HTTP_CONFIG_H 27#define APACHE_HTTP_CONFIG_H 28 29#include "util_cfgtree.h" 30#include "ap_config.h" 31#include "apr_tables.h" 32 33#ifdef __cplusplus 34extern "C" { 35#endif 36 37/* 38 * The central data structures around here... 39 */ 40 41/* Command dispatch structures... */ 42 43/** 44 * How the directives arguments should be parsed. 45 * @remark Note that for all of these except RAW_ARGS, the config routine is 46 * passed a freshly allocated string which can be modified or stored 47 * or whatever... 48 */ 49enum cmd_how { 50 RAW_ARGS, /**< cmd_func parses command line itself */ 51 TAKE1, /**< one argument only */ 52 TAKE2, /**< two arguments only */ 53 ITERATE, /**< one argument, occuring multiple times 54 * (e.g., IndexIgnore) 55 */ 56 ITERATE2, /**< two arguments, 2nd occurs multiple times 57 * (e.g., AddIcon) 58 */ 59 FLAG, /**< One of 'On' or 'Off' */ 60 NO_ARGS, /**< No args at all, e.g. </Directory> */ 61 TAKE12, /**< one or two arguments */ 62 TAKE3, /**< three arguments only */ 63 TAKE23, /**< two or three arguments */ 64 TAKE123, /**< one, two or three arguments */ 65 TAKE13, /**< one or three arguments */ 66 TAKE_ARGV /**< an argc and argv are passed */ 67}; 68 69/** 70 * This structure is passed to a command which is being invoked, 71 * to carry a large variety of miscellaneous data which is all of 72 * use to *somebody*... 73 */ 74typedef struct cmd_parms_struct cmd_parms; 75 76#if defined(AP_HAVE_DESIGNATED_INITIALIZER) || defined(DOXYGEN) 77 78/** 79 * All the types of functions that can be used in directives 80 * @internal 81 */ 82typedef union { 83 /** function to call for a no-args */ 84 const char *(*no_args) (cmd_parms *parms, void *mconfig); 85 /** function to call for a raw-args */ 86 const char *(*raw_args) (cmd_parms *parms, void *mconfig, 87 const char *args); 88 /** function to call for a argv/argc */ 89 const char *(*take_argv) (cmd_parms *parms, void *mconfig, 90 int argc, char *const argv[]); 91 /** function to call for a take1 */ 92 const char *(*take1) (cmd_parms *parms, void *mconfig, const char *w); 93 /** function to call for a take2 */ 94 const char *(*take2) (cmd_parms *parms, void *mconfig, const char *w, 95 const char *w2); 96 /** function to call for a take3 */ 97 const char *(*take3) (cmd_parms *parms, void *mconfig, const char *w, 98 const char *w2, const char *w3); 99 /** function to call for a flag */ 100 const char *(*flag) (cmd_parms *parms, void *mconfig, int on); 101} cmd_func; 102 103/** This configuration directive does not take any arguments */ 104# define AP_NO_ARGS func.no_args 105/** This configuration directive will handle its own parsing of arguments*/ 106# define AP_RAW_ARGS func.raw_args 107/** This configuration directive will handle its own parsing of arguments*/ 108# define AP_TAKE_ARGV func.take_argv 109/** This configuration directive takes 1 argument*/ 110# define AP_TAKE1 func.take1 111/** This configuration directive takes 2 arguments */ 112# define AP_TAKE2 func.take2 113/** This configuration directive takes 3 arguments */ 114# define AP_TAKE3 func.take3 115/** This configuration directive takes a flag (on/off) as a argument*/ 116# define AP_FLAG func.flag 117 118/** mechanism for declaring a directive with no arguments */ 119# define AP_INIT_NO_ARGS(directive, func, mconfig, where, help) \ 120 { directive, { .no_args=func }, mconfig, where, RAW_ARGS, help } 121/** mechanism for declaring a directive with raw argument parsing */ 122# define AP_INIT_RAW_ARGS(directive, func, mconfig, where, help) \ 123 { directive, { .raw_args=func }, mconfig, where, RAW_ARGS, help } 124/** mechanism for declaring a directive with raw argument parsing */ 125# define AP_INIT_TAKE_ARGV(directive, func, mconfig, where, help) \ 126 { directive, { .take_argv=func }, mconfig, where, TAKE_ARGV, help } 127/** mechanism for declaring a directive which takes 1 argument */ 128# define AP_INIT_TAKE1(directive, func, mconfig, where, help) \ 129 { directive, { .take1=func }, mconfig, where, TAKE1, help } 130/** mechanism for declaring a directive which takes multiple arguments */ 131# define AP_INIT_ITERATE(directive, func, mconfig, where, help) \ 132 { directive, { .take1=func }, mconfig, where, ITERATE, help } 133/** mechanism for declaring a directive which takes 2 arguments */ 134# define AP_INIT_TAKE2(directive, func, mconfig, where, help) \ 135 { directive, { .take2=func }, mconfig, where, TAKE2, help } 136/** mechanism for declaring a directive which takes 1 or 2 arguments */ 137# define AP_INIT_TAKE12(directive, func, mconfig, where, help) \ 138 { directive, { .take2=func }, mconfig, where, TAKE12, help } 139/** mechanism for declaring a directive which takes multiple 2 arguments */ 140# define AP_INIT_ITERATE2(directive, func, mconfig, where, help) \ 141 { directive, { .take2=func }, mconfig, where, ITERATE2, help } 142/** mechanism for declaring a directive which takes 1 or 3 arguments */ 143# define AP_INIT_TAKE13(directive, func, mconfig, where, help) \ 144 { directive, { .take3=func }, mconfig, where, TAKE13, help } 145/** mechanism for declaring a directive which takes 2 or 3 arguments */ 146# define AP_INIT_TAKE23(directive, func, mconfig, where, help) \ 147 { directive, { .take3=func }, mconfig, where, TAKE23, help } 148/** mechanism for declaring a directive which takes 1 to 3 arguments */ 149# define AP_INIT_TAKE123(directive, func, mconfig, where, help) \ 150 { directive, { .take3=func }, mconfig, where, TAKE123, help } 151/** mechanism for declaring a directive which takes 3 arguments */ 152# define AP_INIT_TAKE3(directive, func, mconfig, where, help) \ 153 { directive, { .take3=func }, mconfig, where, TAKE3, help } 154/** mechanism for declaring a directive which takes a flag (on/off) argument */ 155# define AP_INIT_FLAG(directive, func, mconfig, where, help) \ 156 { directive, { .flag=func }, mconfig, where, FLAG, help } 157 158#else /* AP_HAVE_DESIGNATED_INITIALIZER */ 159 160typedef const char *(*cmd_func) (); 161 162# define AP_NO_ARGS func 163# define AP_RAW_ARGS func 164# define AP_TAKE_ARGV func 165# define AP_TAKE1 func 166# define AP_TAKE2 func 167# define AP_TAKE3 func 168# define AP_FLAG func 169 170# define AP_INIT_NO_ARGS(directive, func, mconfig, where, help) \ 171 { directive, func, mconfig, where, RAW_ARGS, help } 172# define AP_INIT_RAW_ARGS(directive, func, mconfig, where, help) \ 173 { directive, func, mconfig, where, RAW_ARGS, help } 174# define AP_INIT_TAKE_ARGV(directive, func, mconfig, where, help) \ 175 { directive, func, mconfig, where, TAKE_ARGV, help } 176# define AP_INIT_TAKE1(directive, func, mconfig, where, help) \ 177 { directive, func, mconfig, where, TAKE1, help } 178# define AP_INIT_ITERATE(directive, func, mconfig, where, help) \ 179 { directive, func, mconfig, where, ITERATE, help } 180# define AP_INIT_TAKE2(directive, func, mconfig, where, help) \ 181 { directive, func, mconfig, where, TAKE2, help } 182# define AP_INIT_TAKE12(directive, func, mconfig, where, help) \ 183 { directive, func, mconfig, where, TAKE12, help } 184# define AP_INIT_ITERATE2(directive, func, mconfig, where, help) \ 185 { directive, func, mconfig, where, ITERATE2, help } 186# define AP_INIT_TAKE13(directive, func, mconfig, where, help) \ 187 { directive, func, mconfig, where, TAKE13, help } 188# define AP_INIT_TAKE23(directive, func, mconfig, where, help) \ 189 { directive, func, mconfig, where, TAKE23, help } 190# define AP_INIT_TAKE123(directive, func, mconfig, where, help) \ 191 { directive, func, mconfig, where, TAKE123, help } 192# define AP_INIT_TAKE3(directive, func, mconfig, where, help) \ 193 { directive, func, mconfig, where, TAKE3, help } 194# define AP_INIT_FLAG(directive, func, mconfig, where, help) \ 195 { directive, func, mconfig, where, FLAG, help } 196 197#endif /* AP_HAVE_DESIGNATED_INITIALIZER */ 198 199/** 200 * The command record structure. Modules can define a table of these 201 * to define the directives it will implement. 202 */ 203typedef struct command_struct command_rec; 204struct command_struct { 205 /** Name of this command */ 206 const char *name; 207 /** The function to be called when this directive is parsed */ 208 cmd_func func; 209 /** Extra data, for functions which implement multiple commands... */ 210 void *cmd_data; 211 /** What overrides need to be allowed to enable this command. */ 212 int req_override; 213 /** What the command expects as arguments */ 214 enum cmd_how args_how; 215 216 /** 'usage' message, in case of syntax errors */ 217 const char *errmsg; 218}; 219 220/** 221 * @defgroup ConfigDirectives Allowed locations for configuration directives. 222 * 223 * The allowed locations for a configuration directive are the union of 224 * those indicated by each set bit in the req_override mask. 225 * 226 * @{ 227 */ 228#define OR_NONE 0 /**< *.conf is not available anywhere in this override */ 229#define OR_LIMIT 1 /**< *.conf inside <Directory> or <Location> 230 and .htaccess when AllowOverride Limit */ 231#define OR_OPTIONS 2 /**< *.conf anywhere 232 and .htaccess when AllowOverride Options */ 233#define OR_FILEINFO 4 /**< *.conf anywhere 234 and .htaccess when AllowOverride FileInfo */ 235#define OR_AUTHCFG 8 /**< *.conf inside <Directory> or <Location> 236 and .htaccess when AllowOverride AuthConfig */ 237#define OR_INDEXES 16 /**< *.conf anywhere 238 and .htaccess when AllowOverride Indexes */ 239#define OR_UNSET 32 /**< bit to indicate that AllowOverride has not been set */ 240#define ACCESS_CONF 64 /**< *.conf inside <Directory> or <Location> */ 241#define RSRC_CONF 128 /**< *.conf outside <Directory> or <Location> */ 242#define EXEC_ON_READ 256 /**< force directive to execute a command 243 which would modify the configuration (like including another 244 file, or IFModule */ 245/* Flags to determine whether syntax errors in .htaccess should be 246 * treated as nonfatal (log and ignore errors) 247 */ 248#define NONFATAL_OVERRIDE 512 /* Violation of AllowOverride rule */ 249#define NONFATAL_UNKNOWN 1024 /* Unrecognised directive */ 250#define NONFATAL_ALL (NONFATAL_OVERRIDE|NONFATAL_UNKNOWN) 251 252/** this directive can be placed anywhere */ 253#define OR_ALL (OR_LIMIT|OR_OPTIONS|OR_FILEINFO|OR_AUTHCFG|OR_INDEXES) 254 255/** @} */ 256 257/** 258 * This can be returned by a function if they don't wish to handle 259 * a command. Make it something not likely someone will actually use 260 * as an error code. 261 */ 262#define DECLINE_CMD "\a\b" 263 264/** Common structure for reading of config files / passwd files etc. */ 265typedef struct ap_configfile_t ap_configfile_t; 266struct ap_configfile_t { 267 /**< an apr_file_getc()-like function */ 268 apr_status_t (*getch) (char *ch, void *param); 269 /**< an apr_file_gets()-like function */ 270 apr_status_t (*getstr) (void *buf, apr_size_t bufsiz, void *param); 271 /**< a close handler function */ 272 apr_status_t (*close) (void *param); 273 /**< the argument passed to getch/getstr/close */ 274 void *param; 275 /**< the filename / description */ 276 const char *name; 277 /**< current line number, starting at 1 */ 278 unsigned line_number; 279}; 280 281/** 282 * This structure is passed to a command which is being invoked, 283 * to carry a large variety of miscellaneous data which is all of 284 * use to *somebody*... 285 */ 286struct cmd_parms_struct { 287 /** Argument to command from cmd_table */ 288 void *info; 289 /** Which allow-override bits are set */ 290 int override; 291 /** Which allow-override-opts bits are set */ 292 int override_opts; 293 /** Table of directives allowed per AllowOverrideList */ 294 apr_table_t *override_list; 295 /** Which methods are <Limit>ed */ 296 apr_int64_t limited; 297 /** methods which are limited */ 298 apr_array_header_t *limited_xmethods; 299 /** methods which are xlimited */ 300 ap_method_list_t *xlimited; 301 302 /** Config file structure. */ 303 ap_configfile_t *config_file; 304 /** the directive specifying this command */ 305 ap_directive_t *directive; 306 307 /** Pool to allocate new storage in */ 308 apr_pool_t *pool; 309 /** Pool for scratch memory; persists during configuration, but 310 * wiped before the first request is served... */ 311 apr_pool_t *temp_pool; 312 /** Server_rec being configured for */ 313 server_rec *server; 314 /** If configuring for a directory, pathname of that directory. 315 * NOPE! That's what it meant previous to the existence of <Files>, 316 * <Location> and regex matching. Now the only usefulness that can be 317 * derived from this field is whether a command is being called in a 318 * server context (path == NULL) or being called in a dir context 319 * (path != NULL). */ 320 char *path; 321 /** configuration command */ 322 const command_rec *cmd; 323 324 /** per_dir_config vector passed to handle_command */ 325 struct ap_conf_vector_t *context; 326 /** directive with syntax error */ 327 const ap_directive_t *err_directive; 328 329}; 330 331/** 332 * Module structures. Just about everything is dispatched through 333 * these, directly or indirectly (through the command and handler 334 * tables). 335 */ 336typedef struct module_struct module; 337struct module_struct { 338 /** API version, *not* module version; check that module is 339 * compatible with this version of the server. 340 */ 341 int version; 342 /** API minor version. Provides API feature milestones. Not checked 343 * during module init */ 344 int minor_version; 345 /** Index to this modules structures in config vectors. */ 346 int module_index; 347 348 /** The name of the module's C file */ 349 const char *name; 350 /** The handle for the DSO. Internal use only */ 351 void *dynamic_load_handle; 352 353 /** A pointer to the next module in the list 354 * @var module_struct *next 355 */ 356 struct module_struct *next; 357 358 /** Magic Cookie to identify a module structure; It's mainly 359 * important for the DSO facility (see also mod_so). */ 360 unsigned long magic; 361 362 /** Function to allow MPMs to re-write command line arguments. This 363 * hook is only available to MPMs. 364 * @param The process that the server is running in. 365 */ 366 void (*rewrite_args) (process_rec *process); 367 /** Function to allow all modules to create per directory configuration 368 * structures. 369 * @param p The pool to use for all allocations. 370 * @param dir The directory currently being processed. 371 * @return The per-directory structure created 372 */ 373 void *(*create_dir_config) (apr_pool_t *p, char *dir); 374 /** Function to allow all modules to merge the per directory configuration 375 * structures for two directories. 376 * @param p The pool to use for all allocations. 377 * @param base_conf The directory structure created for the parent directory. 378 * @param new_conf The directory structure currently being processed. 379 * @return The new per-directory structure created 380 */ 381 void *(*merge_dir_config) (apr_pool_t *p, void *base_conf, void *new_conf); 382 /** Function to allow all modules to create per server configuration 383 * structures. 384 * @param p The pool to use for all allocations. 385 * @param s The server currently being processed. 386 * @return The per-server structure created 387 */ 388 void *(*create_server_config) (apr_pool_t *p, server_rec *s); 389 /** Function to allow all modules to merge the per server configuration 390 * structures for two servers. 391 * @param p The pool to use for all allocations. 392 * @param base_conf The directory structure created for the parent directory. 393 * @param new_conf The directory structure currently being processed. 394 * @return The new per-directory structure created 395 */ 396 void *(*merge_server_config) (apr_pool_t *p, void *base_conf, 397 void *new_conf); 398 399 /** A command_rec table that describes all of the directives this module 400 * defines. */ 401 const command_rec *cmds; 402 403 /** A hook to allow modules to hook other points in the request processing. 404 * In this function, modules should call the ap_hook_*() functions to 405 * register an interest in a specific step in processing the current 406 * request. 407 * @param p the pool to use for all allocations 408 */ 409 void (*register_hooks) (apr_pool_t *p); 410}; 411 412/** 413 * The APLOG_USE_MODULE macro is used choose which module a file belongs to. 414 * This is necessary to allow per-module loglevel configuration. 415 * 416 * APLOG_USE_MODULE indirectly sets APLOG_MODULE_INDEX and APLOG_MARK. 417 * 418 * If a module should be backward compatible with versions before 2.3.6, 419 * APLOG_USE_MODULE needs to be enclosed in a ifdef APLOG_USE_MODULE block. 420 * 421 * @param foo name of the module symbol of the current module, without the 422 * trailing "_module" part 423 * @see APLOG_MARK 424 */ 425#define APLOG_USE_MODULE(foo) \ 426 extern module AP_MODULE_DECLARE_DATA foo##_module; \ 427 static int * const aplog_module_index = &(foo##_module.module_index) 428 429/** 430 * AP_DECLARE_MODULE is a convenience macro that combines a call of 431 * APLOG_USE_MODULE with the definition of the module symbol. 432 * 433 * If a module should be backward compatible with versions before 2.3.6, 434 * APLOG_USE_MODULE should be used explicitly instead of AP_DECLARE_MODULE. 435 */ 436#define AP_DECLARE_MODULE(foo) \ 437 APLOG_USE_MODULE(foo); \ 438 module AP_MODULE_DECLARE_DATA foo##_module 439 440/** 441 * @defgroup ModuleInit Module structure initializers 442 * 443 * Initializer for the first few module slots, which are only 444 * really set up once we start running. Note that the first two slots 445 * provide a version check; this should allow us to deal with changes to 446 * the API. The major number should reflect changes to the API handler table 447 * itself or removal of functionality. The minor number should reflect 448 * additions of functionality to the existing API. (the server can detect 449 * an old-format module, and either handle it back-compatibly, or at least 450 * signal an error). See src/include/ap_mmn.h for MMN version history. 451 * @{ 452 */ 453 454/** The one used in Apache 1.3, which will deliberately cause an error */ 455#define STANDARD_MODULE_STUFF this_module_needs_to_be_ported_to_apache_2_0 456 457/** Use this in all standard modules */ 458#define STANDARD20_MODULE_STUFF MODULE_MAGIC_NUMBER_MAJOR, \ 459 MODULE_MAGIC_NUMBER_MINOR, \ 460 -1, \ 461 __FILE__, \ 462 NULL, \ 463 NULL, \ 464 MODULE_MAGIC_COOKIE, \ 465 NULL /* rewrite args spot */ 466 467/** Use this only in MPMs */ 468#define MPM20_MODULE_STUFF MODULE_MAGIC_NUMBER_MAJOR, \ 469 MODULE_MAGIC_NUMBER_MINOR, \ 470 -1, \ 471 __FILE__, \ 472 NULL, \ 473 NULL, \ 474 MODULE_MAGIC_COOKIE 475 476/** @} */ 477 478/* CONFIGURATION VECTOR FUNCTIONS */ 479 480/** configuration vector structure */ 481typedef struct ap_conf_vector_t ap_conf_vector_t; 482 483/** 484 * Generic accessors for other modules to get at their own module-specific 485 * data 486 * @param cv The vector in which the modules configuration is stored. 487 * usually r->per_dir_config or s->module_config 488 * @param m The module to get the data for. 489 * @return The module-specific data 490 */ 491AP_DECLARE(void *) ap_get_module_config(const ap_conf_vector_t *cv, 492 const module *m); 493 494/** 495 * Generic accessors for other modules to set their own module-specific 496 * data 497 * @param cv The vector in which the modules configuration is stored. 498 * usually r->per_dir_config or s->module_config 499 * @param m The module to set the data for. 500 * @param val The module-specific data to set 501 */ 502AP_DECLARE(void) ap_set_module_config(ap_conf_vector_t *cv, const module *m, 503 void *val); 504 505#if !defined(AP_DEBUG) 506 507#define ap_get_module_config(v,m) \ 508 (((void **)(v))[(m)->module_index]) 509#define ap_set_module_config(v,m,val) \ 510 ((((void **)(v))[(m)->module_index]) = (val)) 511 512#endif /* AP_DEBUG */ 513 514 515/** 516 * Generic accessor for modules to get the module-specific loglevel 517 * @param s The server from which to get the loglevel. 518 * @param index The module_index of the module to get the loglevel for. 519 * @return The module-specific loglevel 520 */ 521AP_DECLARE(int) ap_get_server_module_loglevel(const server_rec *s, int index); 522 523/** 524 * Generic accessor for modules the module-specific loglevel 525 * @param c The connection from which to get the loglevel. 526 * @param index The module_index of the module to get the loglevel for. 527 * @return The module-specific loglevel 528 */ 529AP_DECLARE(int) ap_get_conn_module_loglevel(const conn_rec *c, int index); 530 531/** 532 * Generic accessor for modules the module-specific loglevel 533 * @param c The connection from which to get the loglevel. 534 * @param s The server from which to get the loglevel if c does not have a 535 * specific loglevel configuration. 536 * @param index The module_index of the module to get the loglevel for. 537 * @return The module-specific loglevel 538 */ 539AP_DECLARE(int) ap_get_conn_server_module_loglevel(const conn_rec *c, 540 const server_rec *s, 541 int index); 542 543/** 544 * Generic accessor for modules to get the module-specific loglevel 545 * @param r The request from which to get the loglevel. 546 * @param index The module_index of the module to get the loglevel for. 547 * @return The module-specific loglevel 548 */ 549AP_DECLARE(int) ap_get_request_module_loglevel(const request_rec *r, int index); 550 551/** 552 * Accessor to set module-specific loglevel 553 * @param p A pool 554 * @param l The ap_logconf struct to modify. 555 * @param index The module_index of the module to set the loglevel for. 556 * @param level The new log level 557 */ 558AP_DECLARE(void) ap_set_module_loglevel(apr_pool_t *p, struct ap_logconf *l, 559 int index, int level); 560 561#if !defined(AP_DEBUG) 562 563#define ap_get_conn_logconf(c) \ 564 ((c)->log ? (c)->log : \ 565 &(c)->base_server->log) 566 567#define ap_get_conn_server_logconf(c,s) \ 568 ( ( (c)->log != &(c)->base_server->log && (c)->log != NULL ) ? \ 569 (c)->log : \ 570 &(s)->log ) 571 572#define ap_get_request_logconf(r) \ 573 ((r)->log ? (r)->log : \ 574 (r)->connection->log ? (r)->connection->log : \ 575 &(r)->server->log) 576 577#define ap_get_module_loglevel(l,i) \ 578 (((i) < 0 || (l)->module_levels == NULL || (l)->module_levels[i] < 0) ? \ 579 (l)->level : \ 580 (l)->module_levels[i]) 581 582#define ap_get_server_module_loglevel(s,i) \ 583 (ap_get_module_loglevel(&(s)->log,i)) 584 585#define ap_get_conn_module_loglevel(c,i) \ 586 (ap_get_module_loglevel(ap_get_conn_logconf(c),i)) 587 588#define ap_get_conn_server_module_loglevel(c,s,i) \ 589 (ap_get_module_loglevel(ap_get_conn_server_logconf(c,s),i)) 590 591#define ap_get_request_module_loglevel(r,i) \ 592 (ap_get_module_loglevel(ap_get_request_logconf(r),i)) 593 594#endif /* AP_DEBUG */ 595 596/** 597 * Set all module-specific loglevels to val 598 * @param l The log config for which to set the loglevels. 599 * @param val the value to set all loglevels to 600 */ 601AP_DECLARE(void) ap_reset_module_loglevels(struct ap_logconf *l, int val); 602 603/** 604 * Generic command handling function for strings 605 * @param cmd The command parameters for this directive 606 * @param struct_ptr pointer into a given type 607 * @param arg The argument to the directive 608 * @return An error string or NULL on success 609 */ 610AP_DECLARE_NONSTD(const char *) ap_set_string_slot(cmd_parms *cmd, 611 void *struct_ptr, 612 const char *arg); 613 614/** 615 * Generic command handling function for integers 616 * @param cmd The command parameters for this directive 617 * @param struct_ptr pointer into a given type 618 * @param arg The argument to the directive 619 * @return An error string or NULL on success 620 */ 621AP_DECLARE_NONSTD(const char *) ap_set_int_slot(cmd_parms *cmd, 622 void *struct_ptr, 623 const char *arg); 624 625/** 626 * Parsing function for log level 627 * @param str The string to parse 628 * @param val The parsed log level 629 * @return An error string or NULL on success 630 */ 631AP_DECLARE(const char *) ap_parse_log_level(const char *str, int *val); 632 633/** 634 * Return true if the specified method is limited by being listed in 635 * a <Limit> container, or by *not* being listed in a <LimitExcept> 636 * container. 637 * 638 * @param method Pointer to a string specifying the method to check. 639 * @param cmd Pointer to the cmd_parms structure passed to the 640 * directive handler. 641 * @return 0 if the method is not limited in the current scope 642 */ 643AP_DECLARE(int) ap_method_is_limited(cmd_parms *cmd, const char *method); 644 645/** 646 * Generic command handling function for strings, always sets the value 647 * to a lowercase string 648 * @param cmd The command parameters for this directive 649 * @param struct_ptr pointer into a given type 650 * @param arg The argument to the directive 651 * @return An error string or NULL on success 652 */ 653AP_DECLARE_NONSTD(const char *) ap_set_string_slot_lower(cmd_parms *cmd, 654 void *struct_ptr, 655 const char *arg); 656/** 657 * Generic command handling function for flags stored in an int 658 * @param cmd The command parameters for this directive 659 * @param struct_ptr pointer into a given type 660 * @param arg The argument to the directive (either 1 or 0) 661 * @return An error string or NULL on success 662 */ 663AP_DECLARE_NONSTD(const char *) ap_set_flag_slot(cmd_parms *cmd, 664 void *struct_ptr, 665 int arg); 666/** 667 * Generic command handling function for flags stored in a char 668 * @param cmd The command parameters for this directive 669 * @param struct_ptr pointer into a given type 670 * @param arg The argument to the directive (either 1 or 0) 671 * @return An error string or NULL on success 672 */ 673AP_DECLARE_NONSTD(const char *) ap_set_flag_slot_char(cmd_parms *cmd, 674 void *struct_ptr, 675 int arg); 676/** 677 * Generic command handling function for files 678 * @param cmd The command parameters for this directive 679 * @param struct_ptr pointer into a given type 680 * @param arg The argument to the directive 681 * @return An error string or NULL on success 682 */ 683AP_DECLARE_NONSTD(const char *) ap_set_file_slot(cmd_parms *cmd, 684 void *struct_ptr, 685 const char *arg); 686/** 687 * Generic command handling function to respond with cmd->help as an error 688 * @param cmd The command parameters for this directive 689 * @param struct_ptr pointer into a given type 690 * @param arg The argument to the directive 691 * @return The cmd->help value as the error string 692 * @note This allows simple declarations such as: 693 * @code 694 * AP_INIT_RAW_ARGS("Foo", ap_set_deprecated, NULL, OR_ALL, 695 * "The Foo directive is no longer supported, use Bar"), 696 * @endcode 697 */ 698AP_DECLARE_NONSTD(const char *) ap_set_deprecated(cmd_parms *cmd, 699 void *struct_ptr, 700 const char *arg); 701/** 702 * For modules which need to read config files, open logs, etc. this returns 703 * the canonical form of fname made absolute to ap_server_root. 704 * @param p pool to allocate data from 705 * @param fname The file name 706 */ 707AP_DECLARE(char *) ap_server_root_relative(apr_pool_t *p, const char *fname); 708 709/** 710 * Compute the name of a run-time file (e.g., shared memory "file") relative 711 * to the appropriate run-time directory. Absolute paths are returned as-is. 712 * The run-time directory is configured via the DefaultRuntimeDir directive or 713 * at build time. 714 */ 715AP_DECLARE(char *) ap_runtime_dir_relative(apr_pool_t *p, const char *fname); 716 717/* Finally, the hook for dynamically loading modules in... */ 718 719/** 720 * Add a module to the server 721 * @param m The module structure of the module to add 722 * @param p The pool of the same lifetime as the module 723 * @param s The module's symbol name (used for logging) 724 */ 725AP_DECLARE(const char *) ap_add_module(module *m, apr_pool_t *p, 726 const char *s); 727 728/** 729 * Remove a module from the server. There are some caveats: 730 * when the module is removed, its slot is lost so all the current 731 * per-dir and per-server configurations are invalid. So we should 732 * only ever call this function when you are invalidating almost 733 * all our current data. I.e. when doing a restart. 734 * @param m the module structure of the module to remove 735 */ 736AP_DECLARE(void) ap_remove_module(module *m); 737/** 738 * Add a module to the chained modules list and the list of loaded modules 739 * @param mod The module structure of the module to add 740 * @param p The pool with the same lifetime as the module 741 * @param s The module's symbol name (used for logging) 742 */ 743AP_DECLARE(const char *) ap_add_loaded_module(module *mod, apr_pool_t *p, 744 const char *s); 745/** 746 * Remove a module fromthe chained modules list and the list of loaded modules 747 * @param mod the module structure of the module to remove 748 */ 749AP_DECLARE(void) ap_remove_loaded_module(module *mod); 750/** 751 * Find the name of the specified module 752 * @param m The module to get the name for 753 * @return the name of the module 754 */ 755AP_DECLARE(const char *) ap_find_module_name(module *m); 756/** 757 * Find the short name of the module identified by the specified module index 758 * @param module_index The module index to get the name for 759 * @return the name of the module, NULL if not found 760 */ 761AP_DECLARE(const char *) ap_find_module_short_name(int module_index); 762/** 763 * Find a module based on the name of the module 764 * @param name the name of the module 765 * @return the module structure if found, NULL otherwise 766 */ 767AP_DECLARE(module *) ap_find_linked_module(const char *name); 768 769/** 770 * Open a ap_configfile_t as apr_file_t 771 * @param ret_cfg open ap_configfile_t struct pointer 772 * @param p The pool to allocate the structure from 773 * @param name the name of the file to open 774 */ 775AP_DECLARE(apr_status_t) ap_pcfg_openfile(ap_configfile_t **ret_cfg, 776 apr_pool_t *p, const char *name); 777 778/** 779 * Allocate a ap_configfile_t handle with user defined functions and params 780 * @param p The pool to allocate from 781 * @param descr The name of the file 782 * @param param The argument passed to getch/getstr/close 783 * @param getc_func The getch function 784 * @param gets_func The getstr function 785 * @param close_func The close function 786 */ 787AP_DECLARE(ap_configfile_t *) ap_pcfg_open_custom(apr_pool_t *p, 788 const char *descr, 789 void *param, 790 apr_status_t (*getc_func) (char *ch, void *param), 791 apr_status_t (*gets_func) (void *buf, apr_size_t bufsiz, void *param), 792 apr_status_t (*close_func) (void *param)); 793 794/** 795 * Read one line from open ap_configfile_t, strip leading and trailing 796 * whitespace, increase line number 797 * @param buf place to store the line read 798 * @param bufsize size of the buffer 799 * @param cfp File to read from 800 * @return error status, APR_ENOSPC if bufsize is too small for the line 801 */ 802AP_DECLARE(apr_status_t) ap_cfg_getline(char *buf, apr_size_t bufsize, ap_configfile_t *cfp); 803 804/** 805 * Read one char from open configfile_t, increase line number upon LF 806 * @param ch place to store the char read 807 * @param cfp The file to read from 808 * @return error status 809 */ 810AP_DECLARE(apr_status_t) ap_cfg_getc(char *ch, ap_configfile_t *cfp); 811 812/** 813 * Detach from open ap_configfile_t, calling the close handler 814 * @param cfp The file to close 815 * @return 1 on sucess, 0 on failure 816 */ 817AP_DECLARE(int) ap_cfg_closefile(ap_configfile_t *cfp); 818 819/** 820 * Convert a return value from ap_cfg_getline or ap_cfg_getc to a user friendly 821 * string. 822 * @param p The pool to allocate the string from 823 * @param cfp The config file 824 * @param rc The return value to convert 825 * @return The error string, NULL if rc == APR_SUCCESS 826 */ 827AP_DECLARE(const char *) ap_pcfg_strerror(apr_pool_t *p, ap_configfile_t *cfp, 828 apr_status_t rc); 829 830/** 831 * Read all data between the current <foo> and the matching </foo>. All 832 * of this data is forgotten immediately. 833 * @param cmd The cmd_parms to pass to the directives inside the container 834 * @param directive The directive name to read until 835 * @return Error string on failure, NULL on success 836 * @note If cmd->pool == cmd->temp_pool, ap_soak_end_container() will assume 837 * .htaccess context and use a lower maximum line length. 838 */ 839AP_DECLARE(const char *) ap_soak_end_container(cmd_parms *cmd, char *directive); 840 841/** 842 * Read all data between the current <foo> and the matching </foo> and build 843 * a config tree from it 844 * @param p pool to allocate from 845 * @param temp_pool Temporary pool to allocate from 846 * @param parms The cmd_parms to pass to all directives read 847 * @param current The current node in the tree 848 * @param curr_parent The current parent node 849 * @param orig_directive The directive to read until hit. 850 * @return Error string on failure, NULL on success 851 * @note If p == temp_pool, ap_build_cont_config() will assume .htaccess 852 * context and use a lower maximum line length. 853*/ 854AP_DECLARE(const char *) ap_build_cont_config(apr_pool_t *p, 855 apr_pool_t *temp_pool, 856 cmd_parms *parms, 857 ap_directive_t **current, 858 ap_directive_t **curr_parent, 859 char *orig_directive); 860 861/** 862 * Build a config tree from a config file 863 * @param parms The cmd_parms to pass to all of the directives in the file 864 * @param conf_pool The pconf pool 865 * @param temp_pool The temporary pool 866 * @param conftree Place to store the root node of the config tree 867 * @return Error string on erro, NULL otherwise 868 * @note If conf_pool == temp_pool, ap_build_config() will assume .htaccess 869 * context and use a lower maximum line length. 870 */ 871AP_DECLARE(const char *) ap_build_config(cmd_parms *parms, 872 apr_pool_t *conf_pool, 873 apr_pool_t *temp_pool, 874 ap_directive_t **conftree); 875 876/** 877 * Walk a config tree and setup the server's internal structures 878 * @param conftree The config tree to walk 879 * @param parms The cmd_parms to pass to all functions 880 * @param section_vector The per-section config vector. 881 * @return Error string on error, NULL otherwise 882 */ 883AP_DECLARE(const char *) ap_walk_config(ap_directive_t *conftree, 884 cmd_parms *parms, 885 ap_conf_vector_t *section_vector); 886 887/** 888 * @defgroup ap_check_cmd_context Check command context 889 * @{ 890 */ 891/** 892 * Check the context a command is used in. 893 * @param cmd The command to check 894 * @param forbidden Where the command is forbidden. 895 * @return Error string on error, NULL on success 896 */ 897AP_DECLARE(const char *) ap_check_cmd_context(cmd_parms *cmd, 898 unsigned forbidden); 899 900#define NOT_IN_VIRTUALHOST 0x01 /**< Forbidden in <VirtualHost> */ 901#define NOT_IN_LIMIT 0x02 /**< Forbidden in <Limit> */ 902#define NOT_IN_DIRECTORY 0x04 /**< Forbidden in <Directory> */ 903#define NOT_IN_LOCATION 0x08 /**< Forbidden in <Location> */ 904#define NOT_IN_FILES 0x10 /**< Forbidden in <Files> or <If>*/ 905#define NOT_IN_HTACCESS 0x20 /**< Forbidden in .htaccess files */ 906/** Forbidden in <Directory>/<Location>/<Files><If>*/ 907#define NOT_IN_DIR_LOC_FILE (NOT_IN_DIRECTORY|NOT_IN_LOCATION|NOT_IN_FILES) 908/** Forbidden in <VirtualHost>/<Limit>/<Directory>/<Location>/<Files>/<If> */ 909#define GLOBAL_ONLY (NOT_IN_VIRTUALHOST|NOT_IN_LIMIT|NOT_IN_DIR_LOC_FILE) 910 911/** @} */ 912 913/** 914 * @brief This structure is used to assign symbol names to module pointers 915 */ 916typedef struct { 917 const char *name; 918 module *modp; 919} ap_module_symbol_t; 920 921/** 922 * The topmost module in the list 923 * @var module *ap_top_module 924 */ 925AP_DECLARE_DATA extern module *ap_top_module; 926 927/** 928 * Array of all statically linked modules 929 * @var module *ap_prelinked_modules[] 930 */ 931AP_DECLARE_DATA extern module *ap_prelinked_modules[]; 932/** 933 * Array of all statically linked modulenames (symbols) 934 * @var ap_module_symbol_t ap_prelinked_module_symbols[] 935 */ 936AP_DECLARE_DATA extern ap_module_symbol_t ap_prelinked_module_symbols[]; 937/** 938 * Array of all preloaded modules 939 * @var module *ap_preloaded_modules[] 940 */ 941AP_DECLARE_DATA extern module *ap_preloaded_modules[]; 942/** 943 * Array of all loaded modules 944 * @var module **ap_loaded_modules 945 */ 946AP_DECLARE_DATA extern module **ap_loaded_modules; 947 948/* For mod_so.c... */ 949/** Run a single module's two create_config hooks 950 * @param p the pool to allocate from 951 * @param s The server to configure for. 952 * @param m The module to configure 953 */ 954AP_DECLARE(void) ap_single_module_configure(apr_pool_t *p, server_rec *s, 955 module *m); 956 957/* For http_main.c... */ 958/** 959 * Add all of the prelinked modules into the loaded module list 960 * @param process The process that is currently running the server 961 */ 962AP_DECLARE(const char *) ap_setup_prelinked_modules(process_rec *process); 963 964/** 965 * Show the preloaded configuration directives, the help string explaining 966 * the directive arguments, in what module they are handled, and in 967 * what parts of the configuration they are allowed. Used for httpd -h. 968 */ 969AP_DECLARE(void) ap_show_directives(void); 970 971/** 972 * Show the preloaded module names. Used for httpd -l. 973 */ 974AP_DECLARE(void) ap_show_modules(void); 975 976/** 977 * Show the MPM name. Used in reporting modules such as mod_info to 978 * provide extra information to the user 979 */ 980AP_DECLARE(const char *) ap_show_mpm(void); 981 982/** 983 * Read all config files and setup the server 984 * @param process The process running the server 985 * @param temp_pool A pool to allocate temporary data from. 986 * @param config_name The name of the config file 987 * @param conftree Place to store the root of the config tree 988 * @return The setup server_rec list. 989 */ 990AP_DECLARE(server_rec *) ap_read_config(process_rec *process, 991 apr_pool_t *temp_pool, 992 const char *config_name, 993 ap_directive_t **conftree); 994 995/** 996 * Run all rewrite args hooks for loaded modules 997 * @param process The process currently running the server 998 */ 999AP_DECLARE(void) ap_run_rewrite_args(process_rec *process); 1000 1001/** 1002 * Run the register hooks function for a specified module 1003 * @param m The module to run the register hooks function fo 1004 * @param p The pool valid for the lifetime of the module 1005 */ 1006AP_DECLARE(void) ap_register_hooks(module *m, apr_pool_t *p); 1007 1008/** 1009 * Setup all virtual hosts 1010 * @param p The pool to allocate from 1011 * @param main_server The head of the server_rec list 1012 */ 1013AP_DECLARE(void) ap_fixup_virtual_hosts(apr_pool_t *p, 1014 server_rec *main_server); 1015 1016/** 1017 * Reserve some modules slots for modules loaded by other means than 1018 * EXEC_ON_READ directives. 1019 * Relevant modules should call this in the pre_config stage. 1020 * @param count The number of slots to reserve. 1021 */ 1022AP_DECLARE(void) ap_reserve_module_slots(int count); 1023 1024/** 1025 * Reserve some modules slots for modules loaded by a specific 1026 * non-EXEC_ON_READ config directive. 1027 * This counts how often the given directive is used in the config and calls 1028 * ap_reserve_module_slots() accordingly. 1029 * @param directive The name of the directive 1030 */ 1031AP_DECLARE(void) ap_reserve_module_slots_directive(const char *directive); 1032 1033/* For http_request.c... */ 1034 1035/** 1036 * Setup the config vector for a request_rec 1037 * @param p The pool to allocate the config vector from 1038 * @return The config vector 1039 */ 1040AP_DECLARE(ap_conf_vector_t*) ap_create_request_config(apr_pool_t *p); 1041 1042/** 1043 * Setup the config vector for per dir module configs 1044 * @param p The pool to allocate the config vector from 1045 * @return The config vector 1046 */ 1047AP_CORE_DECLARE(ap_conf_vector_t *) ap_create_per_dir_config(apr_pool_t *p); 1048 1049/** 1050 * Run all of the modules merge per dir config functions 1051 * @param p The pool to pass to the merge functions 1052 * @param base The base directory config structure 1053 * @param new_conf The new directory config structure 1054 */ 1055AP_CORE_DECLARE(ap_conf_vector_t*) ap_merge_per_dir_configs(apr_pool_t *p, 1056 ap_conf_vector_t *base, 1057 ap_conf_vector_t *new_conf); 1058 1059/** 1060 * Allocate new ap_logconf and make (deep) copy of old ap_logconf 1061 * @param p The pool to alloc from 1062 * @param old The ap_logconf to copy (may be NULL) 1063 * @return The new ap_logconf struct 1064 */ 1065AP_DECLARE(struct ap_logconf *) ap_new_log_config(apr_pool_t *p, 1066 const struct ap_logconf *old); 1067 1068/** 1069 * Merge old ap_logconf into new ap_logconf. 1070 * old and new must have the same life time. 1071 * @param old_conf The ap_logconf to merge from 1072 * @param new_conf The ap_logconf to merge into 1073 */ 1074AP_DECLARE(void) ap_merge_log_config(const struct ap_logconf *old_conf, 1075 struct ap_logconf *new_conf); 1076 1077/* For http_connection.c... */ 1078/** 1079 * Setup the config vector for a connection_rec 1080 * @param p The pool to allocate the config vector from 1081 * @return The config vector 1082 */ 1083AP_CORE_DECLARE(ap_conf_vector_t*) ap_create_conn_config(apr_pool_t *p); 1084 1085/* For http_core.c... (<Directory> command and virtual hosts) */ 1086 1087/** 1088 * parse an htaccess file 1089 * @param result htaccess_result 1090 * @param r The request currently being served 1091 * @param override Which overrides are active 1092 * @param override_opts Which allow-override-opts bits are set 1093 * @param override_list Table of directives allowed for override 1094 * @param path The path to the htaccess file 1095 * @param access_name The list of possible names for .htaccess files 1096 * int The status of the current request 1097 */ 1098AP_CORE_DECLARE(int) ap_parse_htaccess(ap_conf_vector_t **result, 1099 request_rec *r, 1100 int override, 1101 int override_opts, 1102 apr_table_t *override_list, 1103 const char *path, 1104 const char *access_name); 1105 1106/** 1107 * Setup a virtual host 1108 * @param p The pool to allocate all memory from 1109 * @param hostname The hostname of the virtual hsot 1110 * @param main_server The main server for this Apache configuration 1111 * @param ps Place to store the new server_rec 1112 * return Error string on error, NULL on success 1113 */ 1114AP_CORE_DECLARE(const char *) ap_init_virtual_host(apr_pool_t *p, 1115 const char *hostname, 1116 server_rec *main_server, 1117 server_rec **ps); 1118 1119/** 1120 * Process a config file for Apache 1121 * @param s The server rec to use for the command parms 1122 * @param fname The name of the config file 1123 * @param conftree The root node of the created config tree 1124 * @param p Pool for general allocation 1125 * @param ptemp Pool for temporary allocation 1126 */ 1127AP_DECLARE(const char *) ap_process_resource_config(server_rec *s, 1128 const char *fname, 1129 ap_directive_t **conftree, 1130 apr_pool_t *p, 1131 apr_pool_t *ptemp); 1132 1133/** 1134 * Process all matching files as Apache configs 1135 * @param s The server rec to use for the command parms 1136 * @param fname The filename pattern of the config file 1137 * @param conftree The root node of the created config tree 1138 * @param p Pool for general allocation 1139 * @param ptemp Pool for temporary allocation 1140 * @param optional Whether a no-match wildcard is allowed 1141 * @see apr_fnmatch for pattern handling 1142 */ 1143AP_DECLARE(const char *) ap_process_fnmatch_configs(server_rec *s, 1144 const char *fname, 1145 ap_directive_t **conftree, 1146 apr_pool_t *p, 1147 apr_pool_t *ptemp, 1148 int optional); 1149 1150/** 1151 * Process all directives in the config tree 1152 * @param s The server rec to use in the command parms 1153 * @param conftree The config tree to process 1154 * @param p The pool for general allocation 1155 * @param ptemp The pool for temporary allocations 1156 * @return OK if no problems 1157 */ 1158AP_DECLARE(int) ap_process_config_tree(server_rec *s, 1159 ap_directive_t *conftree, 1160 apr_pool_t *p, 1161 apr_pool_t *ptemp); 1162 1163/** 1164 * Store data which will be retained across unload/load of modules 1165 * @param key The unique key associated with this module's retained data 1166 * @param size in bytes of the retained data (to be allocated) 1167 * @return Address of new retained data structure, initially cleared 1168 */ 1169AP_DECLARE(void *) ap_retained_data_create(const char *key, apr_size_t size); 1170 1171/** 1172 * Retrieve data which was stored by ap_retained_data_create() 1173 * @param key The unique key associated with this module's retained data 1174 * @return Address of previously retained data structure, or NULL if not yet saved 1175 */ 1176AP_DECLARE(void *) ap_retained_data_get(const char *key); 1177 1178/* Module-method dispatchers, also for http_request.c */ 1179/** 1180 * Run the handler phase of each module until a module accepts the 1181 * responsibility of serving the request 1182 * @param r The current request 1183 * @return The status of the current request 1184 */ 1185AP_CORE_DECLARE(int) ap_invoke_handler(request_rec *r); 1186 1187/* for mod_perl */ 1188 1189/** 1190 * Find a given directive in a command_rec table 1191 * @param name The directive to search for 1192 * @param cmds The table to search 1193 * @return The directive definition of the specified directive 1194 */ 1195AP_CORE_DECLARE(const command_rec *) ap_find_command(const char *name, 1196 const command_rec *cmds); 1197 1198/** 1199 * Find a given directive in a list of modules. 1200 * @param cmd_name The directive to search for 1201 * @param mod Pointer to the first module in the linked list; will be set to 1202 * the module providing cmd_name 1203 * @return The directive definition of the specified directive. 1204 * *mod will be changed to point to the module containing the 1205 * directive. 1206 */ 1207AP_CORE_DECLARE(const command_rec *) ap_find_command_in_modules(const char *cmd_name, 1208 module **mod); 1209 1210/** 1211 * Ask a module to create per-server and per-section (dir/loc/file) configs 1212 * (if it hasn't happened already). The results are stored in the server's 1213 * config, and the specified per-section config vector. 1214 * @param server The server to operate upon. 1215 * @param section_vector The per-section config vector. 1216 * @param section Which section to create a config for. 1217 * @param mod The module which is defining the config data. 1218 * @param pconf A pool for all configuration allocations. 1219 * @return The (new) per-section config data. 1220 */ 1221AP_CORE_DECLARE(void *) ap_set_config_vectors(server_rec *server, 1222 ap_conf_vector_t *section_vector, 1223 const char *section, 1224 module *mod, apr_pool_t *pconf); 1225 1226 /* Hooks */ 1227 1228/** 1229 * Run the header parser functions for each module 1230 * @param r The current request 1231 * @return OK or DECLINED 1232 */ 1233AP_DECLARE_HOOK(int,header_parser,(request_rec *r)) 1234 1235/** 1236 * Run the pre_config function for each module 1237 * @param pconf The config pool 1238 * @param plog The logging streams pool 1239 * @param ptemp The temporary pool 1240 * @return OK or DECLINED on success anything else is a error 1241 */ 1242AP_DECLARE_HOOK(int,pre_config,(apr_pool_t *pconf,apr_pool_t *plog, 1243 apr_pool_t *ptemp)) 1244 1245/** 1246 * Run the check_config function for each module 1247 * @param pconf The config pool 1248 * @param plog The logging streams pool 1249 * @param ptemp The temporary pool 1250 * @param s the server to operate upon 1251 * @return OK or DECLINED on success anything else is a error 1252 */ 1253AP_DECLARE_HOOK(int,check_config,(apr_pool_t *pconf, apr_pool_t *plog, 1254 apr_pool_t *ptemp, server_rec *s)) 1255 1256/** 1257 * Run the test_config function for each module; this hook is run 1258 * only if the server was invoked to test the configuration syntax. 1259 * @param pconf The config pool 1260 * @param s The list of server_recs 1261 * @note To avoid reordering problems due to different buffering, hook 1262 * functions should only apr_file_*() to print to stdout/stderr and 1263 * not simple printf()/fprintf(). 1264 * 1265 */ 1266AP_DECLARE_HOOK(void,test_config,(apr_pool_t *pconf, server_rec *s)) 1267 1268/** 1269 * Run the post_config function for each module 1270 * @param pconf The config pool 1271 * @param plog The logging streams pool 1272 * @param ptemp The temporary pool 1273 * @param s The list of server_recs 1274 * @return OK or DECLINED on success anything else is a error 1275 */ 1276AP_DECLARE_HOOK(int,post_config,(apr_pool_t *pconf,apr_pool_t *plog, 1277 apr_pool_t *ptemp,server_rec *s)) 1278 1279/** 1280 * Run the open_logs functions for each module 1281 * @param pconf The config pool 1282 * @param plog The logging streams pool 1283 * @param ptemp The temporary pool 1284 * @param s The list of server_recs 1285 * @return OK or DECLINED on success anything else is a error 1286 */ 1287AP_DECLARE_HOOK(int,open_logs,(apr_pool_t *pconf,apr_pool_t *plog, 1288 apr_pool_t *ptemp,server_rec *s)) 1289 1290/** 1291 * Run the child_init functions for each module 1292 * @param pchild The child pool 1293 * @param s The list of server_recs in this server 1294 */ 1295AP_DECLARE_HOOK(void,child_init,(apr_pool_t *pchild, server_rec *s)) 1296 1297/** 1298 * Run the handler functions for each module 1299 * @param r The request_rec 1300 * @remark non-wildcard handlers should HOOK_MIDDLE, wildcard HOOK_LAST 1301 */ 1302AP_DECLARE_HOOK(int,handler,(request_rec *r)) 1303 1304/** 1305 * Run the quick handler functions for each module. The quick_handler 1306 * is run before any other requests hooks are called (location_walk, 1307 * directory_walk, access checking, et. al.). This hook was added 1308 * to provide a quick way to serve content from a URI keyed cache. 1309 * 1310 * @param r The request_rec 1311 * @param lookup_uri Controls whether the caller actually wants content or not. 1312 * lookup is set when the quick_handler is called out of 1313 * ap_sub_req_lookup_uri() 1314 */ 1315AP_DECLARE_HOOK(int,quick_handler,(request_rec *r, int lookup_uri)) 1316 1317/** 1318 * Retrieve the optional functions for each module. 1319 * This is run immediately before the server starts. Optional functions should 1320 * be registered during the hook registration phase. 1321 */ 1322AP_DECLARE_HOOK(void,optional_fn_retrieve,(void)) 1323 1324/** 1325 * Allow modules to open htaccess files or perform operations before doing so 1326 * @param r The current request 1327 * @param dir_name The directory for which the htaccess file should be opened 1328 * @param access_name The filename for which the htaccess file should be opened 1329 * @param conffile Where the pointer to the opened ap_configfile_t must be 1330 * stored 1331 * @param full_name Where the full file name of the htaccess file must be 1332 * stored. 1333 * @return APR_SUCCESS on success, 1334 * APR_ENOENT or APR_ENOTDIR if no htaccess file exists, 1335 * AP_DECLINED to let later modules do the opening, 1336 * any other error code on error. 1337 */ 1338AP_DECLARE_HOOK(apr_status_t,open_htaccess, 1339 (request_rec *r, const char *dir_name, const char *access_name, 1340 ap_configfile_t **conffile, const char **full_name)) 1341 1342/** 1343 * Core internal function, use ap_run_open_htaccess() instead. 1344 */ 1345apr_status_t ap_open_htaccess(request_rec *r, const char *dir_name, 1346 const char *access_name, ap_configfile_t **conffile, 1347 const char **full_name); 1348 1349/** 1350 * A generic pool cleanup that will reset a pointer to NULL. For use with 1351 * apr_pool_cleanup_register. 1352 * @param data The address of the pointer 1353 * @return APR_SUCCESS 1354 */ 1355AP_DECLARE_NONSTD(apr_status_t) ap_pool_cleanup_set_null(void *data); 1356 1357#ifdef __cplusplus 1358} 1359#endif 1360 1361#endif /* !APACHE_HTTP_CONFIG_H */ 1362/** @} */ 1363