Annotation of win32/apache22/include/httpd.h, revision 1.1
1.1 ! moko 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 httpd.h
! 19: * @brief HTTP Daemon routines
! 20: *
! 21: * @defgroup APACHE Apache
! 22: *
! 23: * Top level group of which all other groups are a member
! 24: * @{
! 25: *
! 26: * @defgroup APACHE_MODS Apache Modules
! 27: * Top level group for Apache Modules
! 28: * @defgroup APACHE_OS Operating System Specific
! 29: * @defgroup APACHE_CORE Apache Core
! 30: * @{
! 31: * @defgroup APACHE_CORE_DAEMON HTTP Daemon Routine
! 32: * @{
! 33: */
! 34:
! 35: #ifndef APACHE_HTTPD_H
! 36: #define APACHE_HTTPD_H
! 37:
! 38: /* XXX - We need to push more stuff to other .h files, or even .c files, to
! 39: * make this file smaller
! 40: */
! 41:
! 42: /* Headers in which EVERYONE has an interest... */
! 43: #include "ap_config.h"
! 44: #include "ap_mmn.h"
! 45:
! 46: #include "ap_release.h"
! 47:
! 48: #include "apr.h"
! 49: #include "apr_general.h"
! 50: #include "apr_tables.h"
! 51: #include "apr_pools.h"
! 52: #include "apr_time.h"
! 53: #include "apr_network_io.h"
! 54: #include "apr_buckets.h"
! 55: #include "apr_poll.h"
! 56:
! 57: #include "os.h"
! 58:
! 59: #include "ap_regex.h"
! 60:
! 61: #if APR_HAVE_STDLIB_H
! 62: #include <stdlib.h>
! 63: #endif
! 64:
! 65: /* Note: apr_uri.h is also included, see below */
! 66:
! 67: #ifdef __cplusplus
! 68: extern "C" {
! 69: #endif
! 70:
! 71: #ifdef CORE_PRIVATE
! 72:
! 73: /* ----------------------------- config dir ------------------------------ */
! 74:
! 75: /** Define this to be the default server home dir. Most things later in this
! 76: * file with a relative pathname will have this added.
! 77: */
! 78: #ifndef HTTPD_ROOT
! 79: #ifdef OS2
! 80: /** Set default for OS/2 file system */
! 81: #define HTTPD_ROOT "/os2httpd"
! 82: #elif defined(WIN32)
! 83: /** Set default for Windows file system */
! 84: #define HTTPD_ROOT "/apache"
! 85: #elif defined (BEOS)
! 86: /** Set the default for BeOS */
! 87: #define HTTPD_ROOT "/boot/home/apache"
! 88: #elif defined (NETWARE)
! 89: /** Set the default for NetWare */
! 90: #define HTTPD_ROOT "/apache"
! 91: #else
! 92: /** Set for all other OSs */
! 93: #define HTTPD_ROOT "/usr/local/apache"
! 94: #endif
! 95: #endif /* HTTPD_ROOT */
! 96:
! 97: /*
! 98: * --------- You shouldn't have to edit anything below this line ----------
! 99: *
! 100: * Any modifications to any defaults not defined above should be done in the
! 101: * respective configuration file.
! 102: *
! 103: */
! 104:
! 105: /**
! 106: * Default location of documents. Can be overridden by the DocumentRoot
! 107: * directive.
! 108: */
! 109: #ifndef DOCUMENT_LOCATION
! 110: #ifdef OS2
! 111: /* Set default for OS/2 file system */
! 112: #define DOCUMENT_LOCATION HTTPD_ROOT "/docs"
! 113: #else
! 114: /* Set default for non OS/2 file system */
! 115: #define DOCUMENT_LOCATION HTTPD_ROOT "/htdocs"
! 116: #endif
! 117: #endif /* DOCUMENT_LOCATION */
! 118:
! 119: /** Maximum number of dynamically loaded modules */
! 120: #ifndef DYNAMIC_MODULE_LIMIT
! 121: #define DYNAMIC_MODULE_LIMIT 128
! 122: #endif
! 123:
! 124: /** Default administrator's address */
! 125: #define DEFAULT_ADMIN "[no address given]"
! 126:
! 127: /** The name of the log files */
! 128: #ifndef DEFAULT_ERRORLOG
! 129: #if defined(OS2) || defined(WIN32)
! 130: #define DEFAULT_ERRORLOG "logs/error.log"
! 131: #else
! 132: #define DEFAULT_ERRORLOG "logs/error_log"
! 133: #endif
! 134: #endif /* DEFAULT_ERRORLOG */
! 135:
! 136: /** Define this to be what your per-directory security files are called */
! 137: #ifndef DEFAULT_ACCESS_FNAME
! 138: #ifdef OS2
! 139: /* Set default for OS/2 file system */
! 140: #define DEFAULT_ACCESS_FNAME "htaccess"
! 141: #else
! 142: #define DEFAULT_ACCESS_FNAME ".htaccess"
! 143: #endif
! 144: #endif /* DEFAULT_ACCESS_FNAME */
! 145:
! 146: /** The name of the server config file */
! 147: #ifndef SERVER_CONFIG_FILE
! 148: #define SERVER_CONFIG_FILE "conf/httpd.conf"
! 149: #endif
! 150:
! 151: /** The default path for CGI scripts if none is currently set */
! 152: #ifndef DEFAULT_PATH
! 153: #define DEFAULT_PATH "/bin:/usr/bin:/usr/ucb:/usr/bsd:/usr/local/bin"
! 154: #endif
! 155:
! 156: /** The path to the suExec wrapper, can be overridden in Configuration */
! 157: #if !defined(NETWARE) && !defined(WIN32)
! 158: #ifndef SUEXEC_BIN
! 159: #define SUEXEC_BIN HTTPD_ROOT "/bin/suexec"
! 160: #endif
! 161: #endif
! 162:
! 163: /** The timeout for waiting for messages */
! 164: #ifndef DEFAULT_TIMEOUT
! 165: #define DEFAULT_TIMEOUT 300
! 166: #endif
! 167:
! 168: /** The timeout for waiting for keepalive timeout until next request */
! 169: #ifndef DEFAULT_KEEPALIVE_TIMEOUT
! 170: #define DEFAULT_KEEPALIVE_TIMEOUT 5
! 171: #endif
! 172:
! 173: /** The number of requests to entertain per connection */
! 174: #ifndef DEFAULT_KEEPALIVE
! 175: #define DEFAULT_KEEPALIVE 100
! 176: #endif
! 177:
! 178: /*
! 179: * Limits on the size of various request items. These limits primarily
! 180: * exist to prevent simple denial-of-service attacks on a server based
! 181: * on misuse of the protocol. The recommended values will depend on the
! 182: * nature of the server resources -- CGI scripts and database backends
! 183: * might require large values, but most servers could get by with much
! 184: * smaller limits than we use below. The request message body size can
! 185: * be limited by the per-dir config directive LimitRequestBody.
! 186: *
! 187: * Internal buffer sizes are two bytes more than the DEFAULT_LIMIT_REQUEST_LINE
! 188: * and DEFAULT_LIMIT_REQUEST_FIELDSIZE below, which explains the 8190.
! 189: * These two limits can be lowered (but not raised) by the server config
! 190: * directives LimitRequestLine and LimitRequestFieldsize, respectively.
! 191: *
! 192: * DEFAULT_LIMIT_REQUEST_FIELDS can be modified or disabled (set = 0) by
! 193: * the server config directive LimitRequestFields.
! 194: */
! 195:
! 196: /** default limit on bytes in Request-Line (Method+URI+HTTP-version) */
! 197: #ifndef DEFAULT_LIMIT_REQUEST_LINE
! 198: #define DEFAULT_LIMIT_REQUEST_LINE 8190
! 199: #endif
! 200: /** default limit on bytes in any one header field */
! 201: #ifndef DEFAULT_LIMIT_REQUEST_FIELDSIZE
! 202: #define DEFAULT_LIMIT_REQUEST_FIELDSIZE 8190
! 203: #endif
! 204: /** default limit on number of request header fields */
! 205: #ifndef DEFAULT_LIMIT_REQUEST_FIELDS
! 206: #define DEFAULT_LIMIT_REQUEST_FIELDS 100
! 207: #endif
! 208:
! 209: /**
! 210: * The default default character set name to add if AddDefaultCharset is
! 211: * enabled. Overridden with AddDefaultCharsetName.
! 212: */
! 213: #define DEFAULT_ADD_DEFAULT_CHARSET_NAME "iso-8859-1"
! 214:
! 215: #endif /* CORE_PRIVATE */
! 216:
! 217: /** default HTTP Server protocol */
! 218: #define AP_SERVER_PROTOCOL "HTTP/1.1"
! 219:
! 220:
! 221: /* ------------------ stuff that modules are allowed to look at ----------- */
! 222:
! 223: /** Define this to be what your HTML directory content files are called */
! 224: #ifndef AP_DEFAULT_INDEX
! 225: #define AP_DEFAULT_INDEX "index.html"
! 226: #endif
! 227:
! 228:
! 229: /**
! 230: * Define this to be what type you'd like returned for files with unknown
! 231: * suffixes.
! 232: * @warning MUST be all lower case.
! 233: */
! 234: #ifndef DEFAULT_CONTENT_TYPE
! 235: #define DEFAULT_CONTENT_TYPE "text/plain"
! 236: #endif
! 237:
! 238: /**
! 239: * NO_CONTENT_TYPE is an alternative DefaultType value that suppresses
! 240: * setting any default type when there's no information (e.g. a proxy).
! 241: */
! 242: #ifndef NO_CONTENT_TYPE
! 243: #define NO_CONTENT_TYPE "none"
! 244: #endif
! 245:
! 246: /** The name of the MIME types file */
! 247: #ifndef AP_TYPES_CONFIG_FILE
! 248: #define AP_TYPES_CONFIG_FILE "conf/mime.types"
! 249: #endif
! 250:
! 251: /*
! 252: * Define the HTML doctype strings centrally.
! 253: */
! 254: /** HTML 2.0 Doctype */
! 255: #define DOCTYPE_HTML_2_0 "<!DOCTYPE HTML PUBLIC \"-//IETF//" \
! 256: "DTD HTML 2.0//EN\">\n"
! 257: /** HTML 3.2 Doctype */
! 258: #define DOCTYPE_HTML_3_2 "<!DOCTYPE HTML PUBLIC \"-//W3C//" \
! 259: "DTD HTML 3.2 Final//EN\">\n"
! 260: /** HTML 4.0 Strict Doctype */
! 261: #define DOCTYPE_HTML_4_0S "<!DOCTYPE HTML PUBLIC \"-//W3C//" \
! 262: "DTD HTML 4.0//EN\"\n" \
! 263: "\"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"
! 264: /** HTML 4.0 Transitional Doctype */
! 265: #define DOCTYPE_HTML_4_0T "<!DOCTYPE HTML PUBLIC \"-//W3C//" \
! 266: "DTD HTML 4.0 Transitional//EN\"\n" \
! 267: "\"http://www.w3.org/TR/REC-html40/loose.dtd\">\n"
! 268: /** HTML 4.0 Frameset Doctype */
! 269: #define DOCTYPE_HTML_4_0F "<!DOCTYPE HTML PUBLIC \"-//W3C//" \
! 270: "DTD HTML 4.0 Frameset//EN\"\n" \
! 271: "\"http://www.w3.org/TR/REC-html40/frameset.dtd\">\n"
! 272: /** XHTML 1.0 Strict Doctype */
! 273: #define DOCTYPE_XHTML_1_0S "<!DOCTYPE html PUBLIC \"-//W3C//" \
! 274: "DTD XHTML 1.0 Strict//EN\"\n" \
! 275: "\"http://www.w3.org/TR/xhtml1/DTD/" \
! 276: "xhtml1-strict.dtd\">\n"
! 277: /** XHTML 1.0 Transitional Doctype */
! 278: #define DOCTYPE_XHTML_1_0T "<!DOCTYPE html PUBLIC \"-//W3C//" \
! 279: "DTD XHTML 1.0 Transitional//EN\"\n" \
! 280: "\"http://www.w3.org/TR/xhtml1/DTD/" \
! 281: "xhtml1-transitional.dtd\">\n"
! 282: /** XHTML 1.0 Frameset Doctype */
! 283: #define DOCTYPE_XHTML_1_0F "<!DOCTYPE html PUBLIC \"-//W3C//" \
! 284: "DTD XHTML 1.0 Frameset//EN\"\n" \
! 285: "\"http://www.w3.org/TR/xhtml1/DTD/" \
! 286: "xhtml1-frameset.dtd\">"
! 287:
! 288: /** Internal representation for a HTTP protocol number, e.g., HTTP/1.1 */
! 289: #define HTTP_VERSION(major,minor) (1000*(major)+(minor))
! 290: /** Major part of HTTP protocol */
! 291: #define HTTP_VERSION_MAJOR(number) ((number)/1000)
! 292: /** Minor part of HTTP protocol */
! 293: #define HTTP_VERSION_MINOR(number) ((number)%1000)
! 294:
! 295: /* -------------- Port number for server running standalone --------------- */
! 296:
! 297: /** default HTTP Port */
! 298: #define DEFAULT_HTTP_PORT 80
! 299: /** default HTTPS Port */
! 300: #define DEFAULT_HTTPS_PORT 443
! 301: /**
! 302: * Check whether @a port is the default port for the request @a r.
! 303: * @param port The port number
! 304: * @param r The request
! 305: * @see #ap_default_port
! 306: */
! 307: #define ap_is_default_port(port,r) ((port) == ap_default_port(r))
! 308: /**
! 309: * Get the default port for a request (which depends on the scheme).
! 310: * @param r The request
! 311: */
! 312: #define ap_default_port(r) ap_run_default_port(r)
! 313: /**
! 314: * Get the scheme for a request.
! 315: * @param r The request
! 316: */
! 317: #define ap_http_scheme(r) ap_run_http_scheme(r)
! 318:
! 319: /** The default string length */
! 320: #define MAX_STRING_LEN HUGE_STRING_LEN
! 321:
! 322: /** The length of a Huge string */
! 323: #define HUGE_STRING_LEN 8192
! 324:
! 325: /** The size of the server's internal read-write buffers */
! 326: #define AP_IOBUFSIZE 8192
! 327:
! 328: /** The max number of regex captures that can be expanded by ap_pregsub */
! 329: #define AP_MAX_REG_MATCH 10
! 330:
! 331: /**
! 332: * APR_HAS_LARGE_FILES introduces the problem of spliting sendfile into
! 333: * mutiple buckets, no greater than MAX(apr_size_t), and more granular
! 334: * than that in case the brigade code/filters attempt to read it directly.
! 335: * ### 16mb is an invention, no idea if it is reasonable.
! 336: */
! 337: #define AP_MAX_SENDFILE 16777216 /* 2^24 */
! 338:
! 339: /**
! 340: * MPM child process exit status values
! 341: * The MPM parent process may check the status to see if special
! 342: * error handling is required.
! 343: */
! 344: /** a normal exit */
! 345: #define APEXIT_OK 0x0
! 346: /** A fatal error arising during the server's init sequence */
! 347: #define APEXIT_INIT 0x2
! 348: /** The child died during its init sequence */
! 349: #define APEXIT_CHILDINIT 0x3
! 350: /**
! 351: * The child exited due to a resource shortage.
! 352: * The parent should limit the rate of forking until
! 353: * the situation is resolved.
! 354: */
! 355: #define APEXIT_CHILDSICK 0x7
! 356: /**
! 357: * A fatal error, resulting in the whole server aborting.
! 358: * If a child exits with this error, the parent process
! 359: * considers this a server-wide fatal error and aborts.
! 360: */
! 361: #define APEXIT_CHILDFATAL 0xf
! 362:
! 363: #ifndef AP_DECLARE
! 364: /**
! 365: * Stuff marked #AP_DECLARE is part of the API, and intended for use
! 366: * by modules. Its purpose is to allow us to add attributes that
! 367: * particular platforms or compilers require to every exported function.
! 368: */
! 369: # define AP_DECLARE(type) type
! 370: #endif
! 371:
! 372: #ifndef AP_DECLARE_NONSTD
! 373: /**
! 374: * Stuff marked #AP_DECLARE_NONSTD is part of the API, and intended for
! 375: * use by modules. The difference between #AP_DECLARE and
! 376: * #AP_DECLARE_NONSTD is that the latter is required for any functions
! 377: * which use varargs or are used via indirect function call. This
! 378: * is to accomodate the two calling conventions in windows dlls.
! 379: */
! 380: # define AP_DECLARE_NONSTD(type) type
! 381: #endif
! 382: #ifndef AP_DECLARE_DATA
! 383: # define AP_DECLARE_DATA
! 384: #endif
! 385:
! 386: #ifndef AP_MODULE_DECLARE
! 387: # define AP_MODULE_DECLARE(type) type
! 388: #endif
! 389: #ifndef AP_MODULE_DECLARE_NONSTD
! 390: # define AP_MODULE_DECLARE_NONSTD(type) type
! 391: #endif
! 392: #ifndef AP_MODULE_DECLARE_DATA
! 393: # define AP_MODULE_DECLARE_DATA
! 394: #endif
! 395:
! 396: /**
! 397: * @internal
! 398: * modules should not use functions marked AP_CORE_DECLARE
! 399: */
! 400: #ifndef AP_CORE_DECLARE
! 401: # define AP_CORE_DECLARE AP_DECLARE
! 402: #endif
! 403:
! 404: /**
! 405: * @internal
! 406: * modules should not use functions marked AP_CORE_DECLARE_NONSTD
! 407: */
! 408:
! 409: #ifndef AP_CORE_DECLARE_NONSTD
! 410: # define AP_CORE_DECLARE_NONSTD AP_DECLARE_NONSTD
! 411: #endif
! 412:
! 413: /**
! 414: * @brief The numeric version information is broken out into fields within this
! 415: * structure.
! 416: */
! 417: typedef struct {
! 418: int major; /**< major number */
! 419: int minor; /**< minor number */
! 420: int patch; /**< patch number */
! 421: const char *add_string; /**< additional string like "-dev" */
! 422: } ap_version_t;
! 423:
! 424: /**
! 425: * Return httpd's version information in a numeric form.
! 426: *
! 427: * @param version Pointer to a version structure for returning the version
! 428: * information.
! 429: */
! 430: AP_DECLARE(void) ap_get_server_revision(ap_version_t *version);
! 431:
! 432: /**
! 433: * Get the server version string, as controlled by the ServerTokens directive
! 434: * @return The server version string
! 435: * @deprecated @see ap_get_server_banner() and ap_get_server_description()
! 436: */
! 437: AP_DECLARE(const char *) ap_get_server_version(void);
! 438:
! 439: /**
! 440: * Get the server banner in a form suitable for sending over the
! 441: * network, with the level of information controlled by the
! 442: * ServerTokens directive.
! 443: * @return The server banner
! 444: */
! 445: AP_DECLARE(const char *) ap_get_server_banner(void);
! 446:
! 447: /**
! 448: * Get the server description in a form suitable for local displays,
! 449: * status reports, or logging. This includes the detailed server
! 450: * version and information about some modules. It is not affected
! 451: * by the ServerTokens directive.
! 452: * @return The server description
! 453: */
! 454: AP_DECLARE(const char *) ap_get_server_description(void);
! 455:
! 456: /**
! 457: * Add a component to the server description and banner strings
! 458: * (The latter is returned by the deprecated function
! 459: * ap_get_server_version().)
! 460: * @param pconf The pool to allocate the component from
! 461: * @param component The string to add
! 462: */
! 463: AP_DECLARE(void) ap_add_version_component(apr_pool_t *pconf, const char *component);
! 464:
! 465: /**
! 466: * Get the date a time that the server was built
! 467: * @return The server build time string
! 468: */
! 469: AP_DECLARE(const char *) ap_get_server_built(void);
! 470:
! 471: #define DECLINED -1 /**< Module declines to handle */
! 472: #define DONE -2 /**< Module has served the response completely
! 473: * - it's safe to die() with no more output
! 474: */
! 475: #define OK 0 /**< Module has handled this stage. */
! 476:
! 477:
! 478: /**
! 479: * @defgroup HTTP_Status HTTP Status Codes
! 480: * @{
! 481: */
! 482: /**
! 483: * The size of the static array in http_protocol.c for storing
! 484: * all of the potential response status-lines (a sparse table).
! 485: * A future version should dynamically generate the apr_table_t at startup.
! 486: */
! 487: #define RESPONSE_CODES 57
! 488:
! 489: #define HTTP_CONTINUE 100
! 490: #define HTTP_SWITCHING_PROTOCOLS 101
! 491: #define HTTP_PROCESSING 102
! 492: #define HTTP_OK 200
! 493: #define HTTP_CREATED 201
! 494: #define HTTP_ACCEPTED 202
! 495: #define HTTP_NON_AUTHORITATIVE 203
! 496: #define HTTP_NO_CONTENT 204
! 497: #define HTTP_RESET_CONTENT 205
! 498: #define HTTP_PARTIAL_CONTENT 206
! 499: #define HTTP_MULTI_STATUS 207
! 500: #define HTTP_MULTIPLE_CHOICES 300
! 501: #define HTTP_MOVED_PERMANENTLY 301
! 502: #define HTTP_MOVED_TEMPORARILY 302
! 503: #define HTTP_SEE_OTHER 303
! 504: #define HTTP_NOT_MODIFIED 304
! 505: #define HTTP_USE_PROXY 305
! 506: #define HTTP_TEMPORARY_REDIRECT 307
! 507: #define HTTP_BAD_REQUEST 400
! 508: #define HTTP_UNAUTHORIZED 401
! 509: #define HTTP_PAYMENT_REQUIRED 402
! 510: #define HTTP_FORBIDDEN 403
! 511: #define HTTP_NOT_FOUND 404
! 512: #define HTTP_METHOD_NOT_ALLOWED 405
! 513: #define HTTP_NOT_ACCEPTABLE 406
! 514: #define HTTP_PROXY_AUTHENTICATION_REQUIRED 407
! 515: #define HTTP_REQUEST_TIME_OUT 408
! 516: #define HTTP_CONFLICT 409
! 517: #define HTTP_GONE 410
! 518: #define HTTP_LENGTH_REQUIRED 411
! 519: #define HTTP_PRECONDITION_FAILED 412
! 520: #define HTTP_REQUEST_ENTITY_TOO_LARGE 413
! 521: #define HTTP_REQUEST_URI_TOO_LARGE 414
! 522: #define HTTP_UNSUPPORTED_MEDIA_TYPE 415
! 523: #define HTTP_RANGE_NOT_SATISFIABLE 416
! 524: #define HTTP_EXPECTATION_FAILED 417
! 525: #define HTTP_UNPROCESSABLE_ENTITY 422
! 526: #define HTTP_LOCKED 423
! 527: #define HTTP_FAILED_DEPENDENCY 424
! 528: #define HTTP_UPGRADE_REQUIRED 426
! 529: #define HTTP_INTERNAL_SERVER_ERROR 500
! 530: #define HTTP_NOT_IMPLEMENTED 501
! 531: #define HTTP_BAD_GATEWAY 502
! 532: #define HTTP_SERVICE_UNAVAILABLE 503
! 533: #define HTTP_GATEWAY_TIME_OUT 504
! 534: #define HTTP_VERSION_NOT_SUPPORTED 505
! 535: #define HTTP_VARIANT_ALSO_VARIES 506
! 536: #define HTTP_INSUFFICIENT_STORAGE 507
! 537: #define HTTP_NOT_EXTENDED 510
! 538:
! 539: /** is the status code informational */
! 540: #define ap_is_HTTP_INFO(x) (((x) >= 100)&&((x) < 200))
! 541: /** is the status code OK ?*/
! 542: #define ap_is_HTTP_SUCCESS(x) (((x) >= 200)&&((x) < 300))
! 543: /** is the status code a redirect */
! 544: #define ap_is_HTTP_REDIRECT(x) (((x) >= 300)&&((x) < 400))
! 545: /** is the status code a error (client or server) */
! 546: #define ap_is_HTTP_ERROR(x) (((x) >= 400)&&((x) < 600))
! 547: /** is the status code a client error */
! 548: #define ap_is_HTTP_CLIENT_ERROR(x) (((x) >= 400)&&((x) < 500))
! 549: /** is the status code a server error */
! 550: #define ap_is_HTTP_SERVER_ERROR(x) (((x) >= 500)&&((x) < 600))
! 551: /** is the status code a (potentially) valid response code? */
! 552: #define ap_is_HTTP_VALID_RESPONSE(x) (((x) >= 100)&&((x) < 600))
! 553:
! 554: /** should the status code drop the connection */
! 555: #define ap_status_drops_connection(x) \
! 556: (((x) == HTTP_BAD_REQUEST) || \
! 557: ((x) == HTTP_REQUEST_TIME_OUT) || \
! 558: ((x) == HTTP_LENGTH_REQUIRED) || \
! 559: ((x) == HTTP_REQUEST_ENTITY_TOO_LARGE) || \
! 560: ((x) == HTTP_REQUEST_URI_TOO_LARGE) || \
! 561: ((x) == HTTP_INTERNAL_SERVER_ERROR) || \
! 562: ((x) == HTTP_SERVICE_UNAVAILABLE) || \
! 563: ((x) == HTTP_NOT_IMPLEMENTED))
! 564: /** @} */
! 565:
! 566: /**
! 567: * @defgroup Methods List of Methods recognized by the server
! 568: * @ingroup APACHE_CORE_DAEMON
! 569: * @{
! 570: *
! 571: * @brief Methods recognized (but not necessarily handled) by the server.
! 572: *
! 573: * These constants are used in bit shifting masks of size int, so it is
! 574: * unsafe to have more methods than bits in an int. HEAD == M_GET.
! 575: * This list must be tracked by the list in http_protocol.c in routine
! 576: * ap_method_name_of().
! 577: *
! 578: */
! 579:
! 580: #define M_GET 0 /** RFC 2616: HTTP */
! 581: #define M_PUT 1 /* : */
! 582: #define M_POST 2
! 583: #define M_DELETE 3
! 584: #define M_CONNECT 4
! 585: #define M_OPTIONS 5
! 586: #define M_TRACE 6 /** RFC 2616: HTTP */
! 587: #define M_PATCH 7 /** no rfc(!) ### remove this one? */
! 588: #define M_PROPFIND 8 /** RFC 2518: WebDAV */
! 589: #define M_PROPPATCH 9 /* : */
! 590: #define M_MKCOL 10
! 591: #define M_COPY 11
! 592: #define M_MOVE 12
! 593: #define M_LOCK 13
! 594: #define M_UNLOCK 14 /** RFC 2518: WebDAV */
! 595: #define M_VERSION_CONTROL 15 /** RFC 3253: WebDAV Versioning */
! 596: #define M_CHECKOUT 16 /* : */
! 597: #define M_UNCHECKOUT 17
! 598: #define M_CHECKIN 18
! 599: #define M_UPDATE 19
! 600: #define M_LABEL 20
! 601: #define M_REPORT 21
! 602: #define M_MKWORKSPACE 22
! 603: #define M_MKACTIVITY 23
! 604: #define M_BASELINE_CONTROL 24
! 605: #define M_MERGE 25
! 606: #define M_INVALID 26 /** RFC 3253: WebDAV Versioning */
! 607:
! 608: /**
! 609: * METHODS needs to be equal to the number of bits
! 610: * we are using for limit masks.
! 611: */
! 612: #define METHODS 64
! 613:
! 614: /**
! 615: * The method mask bit to shift for anding with a bitmask.
! 616: */
! 617: #define AP_METHOD_BIT ((apr_int64_t)1)
! 618: /** @} */
! 619:
! 620:
! 621: /** @see ap_method_list_t */
! 622: typedef struct ap_method_list_t ap_method_list_t;
! 623:
! 624: /**
! 625: * @struct ap_method_list_t
! 626: * @brief Structure for handling HTTP methods.
! 627: *
! 628: * Methods known to the server are accessed via a bitmask shortcut;
! 629: * extension methods are handled by an array.
! 630: */
! 631: struct ap_method_list_t {
! 632: /** The bitmask used for known methods */
! 633: apr_int64_t method_mask;
! 634: /** the array used for extension methods */
! 635: apr_array_header_t *method_list;
! 636: };
! 637:
! 638: /**
! 639: * @defgroup module_magic Module Magic mime types
! 640: * @{
! 641: */
! 642: /** Magic for mod_cgi[d] */
! 643: #define CGI_MAGIC_TYPE "application/x-httpd-cgi"
! 644: /** Magic for mod_include */
! 645: #define INCLUDES_MAGIC_TYPE "text/x-server-parsed-html"
! 646: /** Magic for mod_include */
! 647: #define INCLUDES_MAGIC_TYPE3 "text/x-server-parsed-html3"
! 648: /** Magic for mod_dir */
! 649: #define DIR_MAGIC_TYPE "httpd/unix-directory"
! 650:
! 651: /** @} */
! 652: /* Just in case your linefeed isn't the one the other end is expecting. */
! 653: #if !APR_CHARSET_EBCDIC
! 654: /** linefeed */
! 655: #define LF 10
! 656: /** carrige return */
! 657: #define CR 13
! 658: /** carrige return /Line Feed Combo */
! 659: #define CRLF "\015\012"
! 660: #else /* APR_CHARSET_EBCDIC */
! 661: /* For platforms using the EBCDIC charset, the transition ASCII->EBCDIC is done
! 662: * in the buff package (bread/bputs/bwrite). Everywhere else, we use
! 663: * "native EBCDIC" CR and NL characters. These are therefore
! 664: * defined as
! 665: * '\r' and '\n'.
! 666: */
! 667: #define CR '\r'
! 668: #define LF '\n'
! 669: #define CRLF "\r\n"
! 670: #endif /* APR_CHARSET_EBCDIC */
! 671: /** Useful for common code with either platform charset. */
! 672: #define CRLF_ASCII "\015\012"
! 673:
! 674: /**
! 675: * @defgroup values_request_rec_body Possible values for request_rec.read_body
! 676: * @{
! 677: * Possible values for request_rec.read_body (set by handling module):
! 678: */
! 679:
! 680: /** Send 413 error if message has any body */
! 681: #define REQUEST_NO_BODY 0
! 682: /** Send 411 error if body without Content-Length */
! 683: #define REQUEST_CHUNKED_ERROR 1
! 684: /** If chunked, remove the chunks for me. */
! 685: #define REQUEST_CHUNKED_DECHUNK 2
! 686: /** @} // values_request_rec_body */
! 687:
! 688: /**
! 689: * @defgroup values_request_rec_used_path_info Possible values for request_rec.used_path_info
! 690: * @ingroup APACHE_CORE_DAEMON
! 691: * @{
! 692: * Possible values for request_rec.used_path_info:
! 693: */
! 694:
! 695: /** Accept the path_info from the request */
! 696: #define AP_REQ_ACCEPT_PATH_INFO 0
! 697: /** Return a 404 error if path_info was given */
! 698: #define AP_REQ_REJECT_PATH_INFO 1
! 699: /** Module may chose to use the given path_info */
! 700: #define AP_REQ_DEFAULT_PATH_INFO 2
! 701:
! 702: /** @} // values_request_rec_used_path_info */
! 703:
! 704:
! 705: /*
! 706: * Things which may vary per file-lookup WITHIN a request ---
! 707: * e.g., state of MIME config. Basically, the name of an object, info
! 708: * about the object, and any other info we may ahve which may need to
! 709: * change as we go poking around looking for it (e.g., overridden by
! 710: * .htaccess files).
! 711: *
! 712: * Note how the default state of almost all these things is properly
! 713: * zero, so that allocating it with pcalloc does the right thing without
! 714: * a whole lot of hairy initialization... so long as we are willing to
! 715: * make the (fairly) portable assumption that the bit pattern of a NULL
! 716: * pointer is, in fact, zero.
! 717: */
! 718:
! 719: /**
! 720: * @brief This represents the result of calling htaccess; these are cached for
! 721: * each request.
! 722: */
! 723: struct htaccess_result {
! 724: /** the directory to which this applies */
! 725: const char *dir;
! 726: /** the overrides allowed for the .htaccess file */
! 727: int override;
! 728: /** the override options allowed for the .htaccess file */
! 729: int override_opts;
! 730: /** the configuration directives */
! 731: struct ap_conf_vector_t *htaccess;
! 732: /** the next one, or NULL if no more; N.B. never change this */
! 733: const struct htaccess_result *next;
! 734: };
! 735:
! 736: /* The following four types define a hierarchy of activities, so that
! 737: * given a request_rec r you can write r->connection->server->process
! 738: * to get to the process_rec. While this reduces substantially the
! 739: * number of arguments that various hooks require beware that in
! 740: * threaded versions of the server you must consider multiplexing
! 741: * issues. */
! 742:
! 743:
! 744: /** A structure that represents one process */
! 745: typedef struct process_rec process_rec;
! 746: /** A structure that represents a virtual server */
! 747: typedef struct server_rec server_rec;
! 748: /** A structure that represents one connection */
! 749: typedef struct conn_rec conn_rec;
! 750: /** A structure that represents the current request */
! 751: typedef struct request_rec request_rec;
! 752: /** A structure that represents the status of the current connection */
! 753: typedef struct conn_state_t conn_state_t;
! 754:
! 755: /* ### would be nice to not include this from httpd.h ... */
! 756: /* This comes after we have defined the request_rec type */
! 757: #include "apr_uri.h"
! 758:
! 759: /**
! 760: * @brief A structure that represents one process
! 761: */
! 762: struct process_rec {
! 763: /** Global pool. Cleared upon normal exit */
! 764: apr_pool_t *pool;
! 765: /** Configuration pool. Cleared upon restart */
! 766: apr_pool_t *pconf;
! 767: /** Number of command line arguments passed to the program */
! 768: int argc;
! 769: /** The command line arguments */
! 770: const char * const *argv;
! 771: /** The program name used to execute the program */
! 772: const char *short_name;
! 773: };
! 774:
! 775: /**
! 776: * @brief A structure that represents the current request
! 777: */
! 778: struct request_rec {
! 779: /** The pool associated with the request */
! 780: apr_pool_t *pool;
! 781: /** The connection to the client */
! 782: conn_rec *connection;
! 783: /** The virtual host for this request */
! 784: server_rec *server;
! 785:
! 786: /** Pointer to the redirected request if this is an external redirect */
! 787: request_rec *next;
! 788: /** Pointer to the previous request if this is an internal redirect */
! 789: request_rec *prev;
! 790:
! 791: /** Pointer to the main request if this is a sub-request
! 792: * (see http_request.h) */
! 793: request_rec *main;
! 794:
! 795: /* Info about the request itself... we begin with stuff that only
! 796: * protocol.c should ever touch...
! 797: */
! 798: /** First line of request */
! 799: char *the_request;
! 800: /** HTTP/0.9, "simple" request (e.g. GET /foo\n w/no headers) */
! 801: int assbackwards;
! 802: /** A proxy request (calculated during post_read_request/translate_name)
! 803: * possible values PROXYREQ_NONE, PROXYREQ_PROXY, PROXYREQ_REVERSE,
! 804: * PROXYREQ_RESPONSE
! 805: */
! 806: int proxyreq;
! 807: /** HEAD request, as opposed to GET */
! 808: int header_only;
! 809: /** Protocol string, as given to us, or HTTP/0.9 */
! 810: char *protocol;
! 811: /** Protocol version number of protocol; 1.1 = 1001 */
! 812: int proto_num;
! 813: /** Host, as set by full URI or Host: */
! 814: const char *hostname;
! 815:
! 816: /** Time when the request started */
! 817: apr_time_t request_time;
! 818:
! 819: /** Status line, if set by script */
! 820: const char *status_line;
! 821: /** Status line */
! 822: int status;
! 823:
! 824: /* Request method, two ways; also, protocol, etc.. Outside of protocol.c,
! 825: * look, but don't touch.
! 826: */
! 827:
! 828: /** Request method (eg. GET, HEAD, POST, etc.) */
! 829: const char *method;
! 830: /** M_GET, M_POST, etc. */
! 831: int method_number;
! 832:
! 833: /**
! 834: * 'allowed' is a bitvector of the allowed methods.
! 835: *
! 836: * A handler must ensure that the request method is one that
! 837: * it is capable of handling. Generally modules should DECLINE
! 838: * any request methods they do not handle. Prior to aborting the
! 839: * handler like this the handler should set r->allowed to the list
! 840: * of methods that it is willing to handle. This bitvector is used
! 841: * to construct the "Allow:" header required for OPTIONS requests,
! 842: * and HTTP_METHOD_NOT_ALLOWED and HTTP_NOT_IMPLEMENTED status codes.
! 843: *
! 844: * Since the default_handler deals with OPTIONS, all modules can
! 845: * usually decline to deal with OPTIONS. TRACE is always allowed,
! 846: * modules don't need to set it explicitly.
! 847: *
! 848: * Since the default_handler will always handle a GET, a
! 849: * module which does *not* implement GET should probably return
! 850: * HTTP_METHOD_NOT_ALLOWED. Unfortunately this means that a Script GET
! 851: * handler can't be installed by mod_actions.
! 852: */
! 853: apr_int64_t allowed;
! 854: /** Array of extension methods */
! 855: apr_array_header_t *allowed_xmethods;
! 856: /** List of allowed methods */
! 857: ap_method_list_t *allowed_methods;
! 858:
! 859: /** byte count in stream is for body */
! 860: apr_off_t sent_bodyct;
! 861: /** body byte count, for easy access */
! 862: apr_off_t bytes_sent;
! 863: /** Last modified time of the requested resource */
! 864: apr_time_t mtime;
! 865:
! 866: /* HTTP/1.1 connection-level features */
! 867:
! 868: /** sending chunked transfer-coding */
! 869: int chunked;
! 870: /** The Range: header */
! 871: const char *range;
! 872: /** The "real" content length */
! 873: apr_off_t clength;
! 874:
! 875: /** Remaining bytes left to read from the request body */
! 876: apr_off_t remaining;
! 877: /** Number of bytes that have been read from the request body */
! 878: apr_off_t read_length;
! 879: /** Method for reading the request body
! 880: * (eg. REQUEST_CHUNKED_ERROR, REQUEST_NO_BODY,
! 881: * REQUEST_CHUNKED_DECHUNK, etc...) */
! 882: int read_body;
! 883: /** reading chunked transfer-coding */
! 884: int read_chunked;
! 885: /** is client waiting for a 100 response? */
! 886: unsigned expecting_100;
! 887:
! 888: /* MIME header environments, in and out. Also, an array containing
! 889: * environment variables to be passed to subprocesses, so people can
! 890: * write modules to add to that environment.
! 891: *
! 892: * The difference between headers_out and err_headers_out is that the
! 893: * latter are printed even on error, and persist across internal redirects
! 894: * (so the headers printed for ErrorDocument handlers will have them).
! 895: *
! 896: * The 'notes' apr_table_t is for notes from one module to another, with no
! 897: * other set purpose in mind...
! 898: */
! 899:
! 900: /** MIME header environment from the request */
! 901: apr_table_t *headers_in;
! 902: /** MIME header environment for the response */
! 903: apr_table_t *headers_out;
! 904: /** MIME header environment for the response, printed even on errors and
! 905: * persist across internal redirects */
! 906: apr_table_t *err_headers_out;
! 907: /** Array of environment variables to be used for sub processes */
! 908: apr_table_t *subprocess_env;
! 909: /** Notes from one module to another */
! 910: apr_table_t *notes;
! 911:
! 912: /* content_type, handler, content_encoding, and all content_languages
! 913: * MUST be lowercased strings. They may be pointers to static strings;
! 914: * they should not be modified in place.
! 915: */
! 916: /** The content-type for the current request */
! 917: const char *content_type; /* Break these out --- we dispatch on 'em */
! 918: /** The handler string that we use to call a handler function */
! 919: const char *handler; /* What we *really* dispatch on */
! 920:
! 921: /** How to encode the data */
! 922: const char *content_encoding;
! 923: /** Array of strings representing the content languages */
! 924: apr_array_header_t *content_languages;
! 925:
! 926: /** variant list validator (if negotiated) */
! 927: char *vlist_validator;
! 928:
! 929: /** If an authentication check was made, this gets set to the user name. */
! 930: char *user;
! 931: /** If an authentication check was made, this gets set to the auth type. */
! 932: char *ap_auth_type;
! 933:
! 934: /** This response can not be cached */
! 935: int no_cache;
! 936: /** There is no local copy of this response */
! 937: int no_local_copy;
! 938:
! 939: /* What object is being requested (either directly, or via include
! 940: * or content-negotiation mapping).
! 941: */
! 942:
! 943: /** The URI without any parsing performed */
! 944: char *unparsed_uri;
! 945: /** The path portion of the URI, or "/" if no path provided */
! 946: char *uri;
! 947: /** The filename on disk corresponding to this response */
! 948: char *filename;
! 949: /* XXX: What does this mean? Please define "canonicalize" -aaron */
! 950: /** The true filename, we canonicalize r->filename if these don't match */
! 951: char *canonical_filename;
! 952: /** The PATH_INFO extracted from this request */
! 953: char *path_info;
! 954: /** The QUERY_ARGS extracted from this request */
! 955: char *args;
! 956: /** finfo.protection (st_mode) set to zero if no such file */
! 957: apr_finfo_t finfo;
! 958: /** A struct containing the components of URI */
! 959: apr_uri_t parsed_uri;
! 960:
! 961: /**
! 962: * Flag for the handler to accept or reject path_info on
! 963: * the current request. All modules should respect the
! 964: * AP_REQ_ACCEPT_PATH_INFO and AP_REQ_REJECT_PATH_INFO
! 965: * values, while AP_REQ_DEFAULT_PATH_INFO indicates they
! 966: * may follow existing conventions. This is set to the
! 967: * user's preference upon HOOK_VERY_FIRST of the fixups.
! 968: */
! 969: int used_path_info;
! 970:
! 971: /* Various other config info which may change with .htaccess files
! 972: * These are config vectors, with one void* pointer for each module
! 973: * (the thing pointed to being the module's business).
! 974: */
! 975:
! 976: /** Options set in config files, etc. */
! 977: struct ap_conf_vector_t *per_dir_config;
! 978: /** Notes on *this* request */
! 979: struct ap_conf_vector_t *request_config;
! 980:
! 981: /**
! 982: * A linked list of the .htaccess configuration directives
! 983: * accessed by this request.
! 984: * N.B. always add to the head of the list, _never_ to the end.
! 985: * that way, a sub request's list can (temporarily) point to a parent's list
! 986: */
! 987: const struct htaccess_result *htaccess;
! 988:
! 989: /** A list of output filters to be used for this request */
! 990: struct ap_filter_t *output_filters;
! 991: /** A list of input filters to be used for this request */
! 992: struct ap_filter_t *input_filters;
! 993:
! 994: /** A list of protocol level output filters to be used for this
! 995: * request */
! 996: struct ap_filter_t *proto_output_filters;
! 997: /** A list of protocol level input filters to be used for this
! 998: * request */
! 999: struct ap_filter_t *proto_input_filters;
! 1000:
! 1001: /** A flag to determine if the eos bucket has been sent yet */
! 1002: int eos_sent;
! 1003:
! 1004: /* Things placed at the end of the record to avoid breaking binary
! 1005: * compatibility. It would be nice to remember to reorder the entire
! 1006: * record to improve 64bit alignment the next time we need to break
! 1007: * binary compatibility for some other reason.
! 1008: */
! 1009: };
! 1010:
! 1011: /**
! 1012: * @defgroup ProxyReq Proxy request types
! 1013: *
! 1014: * Possible values of request_rec->proxyreq. A request could be normal,
! 1015: * proxied or reverse proxied. Normally proxied and reverse proxied are
! 1016: * grouped together as just "proxied", but sometimes it's necessary to
! 1017: * tell the difference between the two, such as for authentication.
! 1018: * @{
! 1019: */
! 1020:
! 1021: #define PROXYREQ_NONE 0 /**< No proxy */
! 1022: #define PROXYREQ_PROXY 1 /**< Standard proxy */
! 1023: #define PROXYREQ_REVERSE 2 /**< Reverse proxy */
! 1024: #define PROXYREQ_RESPONSE 3 /**< Origin response */
! 1025:
! 1026: /* @} */
! 1027:
! 1028: /**
! 1029: * @brief Enumeration of connection keepalive options
! 1030: */
! 1031: typedef enum {
! 1032: AP_CONN_UNKNOWN,
! 1033: AP_CONN_CLOSE,
! 1034: AP_CONN_KEEPALIVE
! 1035: } ap_conn_keepalive_e;
! 1036:
! 1037: /**
! 1038: * @brief Structure to store things which are per connection
! 1039: */
! 1040: struct conn_rec {
! 1041: /** Pool associated with this connection */
! 1042: apr_pool_t *pool;
! 1043: /** Physical vhost this conn came in on */
! 1044: server_rec *base_server;
! 1045: /** used by http_vhost.c */
! 1046: void *vhost_lookup_data;
! 1047:
! 1048: /* Information about the connection itself */
! 1049: /** local address */
! 1050: apr_sockaddr_t *local_addr;
! 1051: /** remote address */
! 1052: apr_sockaddr_t *remote_addr;
! 1053:
! 1054: /** Client's IP address */
! 1055: char *remote_ip;
! 1056: /** Client's DNS name, if known. NULL if DNS hasn't been checked,
! 1057: * "" if it has and no address was found. N.B. Only access this though
! 1058: * get_remote_host() */
! 1059: char *remote_host;
! 1060: /** Only ever set if doing rfc1413 lookups. N.B. Only access this through
! 1061: * get_remote_logname() */
! 1062: char *remote_logname;
! 1063:
! 1064: /** Are we still talking? */
! 1065: unsigned aborted:1;
! 1066:
! 1067: /** Are we going to keep the connection alive for another request?
! 1068: * @see ap_conn_keepalive_e */
! 1069: ap_conn_keepalive_e keepalive;
! 1070:
! 1071: /** have we done double-reverse DNS? -1 yes/failure, 0 not yet,
! 1072: * 1 yes/success */
! 1073: signed int double_reverse:2;
! 1074:
! 1075: /** How many times have we used it? */
! 1076: int keepalives;
! 1077: /** server IP address */
! 1078: char *local_ip;
! 1079: /** used for ap_get_server_name when UseCanonicalName is set to DNS
! 1080: * (ignores setting of HostnameLookups) */
! 1081: char *local_host;
! 1082:
! 1083: /** ID of this connection; unique at any point in time */
! 1084: long id;
! 1085: /** Config vector containing pointers to connections per-server
! 1086: * config structures. */
! 1087: struct ap_conf_vector_t *conn_config;
! 1088: /** Notes on *this* connection: send note from one module to
! 1089: * another. must remain valid for all requests on this conn */
! 1090: apr_table_t *notes;
! 1091: /** A list of input filters to be used for this connection */
! 1092: struct ap_filter_t *input_filters;
! 1093: /** A list of output filters to be used for this connection */
! 1094: struct ap_filter_t *output_filters;
! 1095: /** handle to scoreboard information for this connection */
! 1096: void *sbh;
! 1097: /** The bucket allocator to use for all bucket/brigade creations */
! 1098: struct apr_bucket_alloc_t *bucket_alloc;
! 1099: /** The current state of this connection */
! 1100: conn_state_t *cs;
! 1101: /** Is there data pending in the input filters? */
! 1102: int data_in_input_filters;
! 1103:
! 1104: /** Are there any filters that clogg/buffer the input stream, breaking
! 1105: * the event mpm.
! 1106: */
! 1107: int clogging_input_filters;
! 1108: };
! 1109:
! 1110: /**
! 1111: * Enumeration of connection states
! 1112: */
! 1113: typedef enum {
! 1114: CONN_STATE_CHECK_REQUEST_LINE_READABLE,
! 1115: CONN_STATE_READ_REQUEST_LINE,
! 1116: CONN_STATE_LINGER
! 1117: } conn_state_e;
! 1118:
! 1119: /**
! 1120: * @brief A structure to contain connection state information
! 1121: */
! 1122: struct conn_state_t {
! 1123: /** APR_RING of expiration timeouts */
! 1124: APR_RING_ENTRY(conn_state_t) timeout_list;
! 1125: /** the expiration time of the next keepalive timeout */
! 1126: apr_time_t expiration_time;
! 1127: /** Current state of the connection */
! 1128: conn_state_e state;
! 1129: /** connection record this struct refers to */
! 1130: conn_rec *c;
! 1131: /** memory pool to allocate from */
! 1132: apr_pool_t *p;
! 1133: /** bucket allocator */
! 1134: apr_bucket_alloc_t *bucket_alloc;
! 1135: /** poll file decriptor information */
! 1136: apr_pollfd_t pfd;
! 1137: };
! 1138:
! 1139: /* Per-vhost config... */
! 1140:
! 1141: /**
! 1142: * The address 255.255.255.255, when used as a virtualhost address,
! 1143: * will become the "default" server when the ip doesn't match other vhosts.
! 1144: */
! 1145: #define DEFAULT_VHOST_ADDR 0xfffffffful
! 1146:
! 1147:
! 1148: /**
! 1149: * @struct server_addr_rec
! 1150: * @brief A structure to be used for Per-vhost config
! 1151: */
! 1152: typedef struct server_addr_rec server_addr_rec;
! 1153: struct server_addr_rec {
! 1154: /** The next server in the list */
! 1155: server_addr_rec *next;
! 1156: /** The bound address, for this server */
! 1157: apr_sockaddr_t *host_addr;
! 1158: /** The bound port, for this server */
! 1159: apr_port_t host_port;
! 1160: /** The name given in "<VirtualHost>" */
! 1161: char *virthost;
! 1162: };
! 1163:
! 1164: /**
! 1165: * @brief A structure to store information for each virtual server
! 1166: */
! 1167: struct server_rec {
! 1168: /** The process this server is running in */
! 1169: process_rec *process;
! 1170: /** The next server in the list */
! 1171: server_rec *next;
! 1172:
! 1173: /** The name of the server */
! 1174: const char *defn_name;
! 1175: /** The line of the config file that the server was defined on */
! 1176: unsigned defn_line_number;
! 1177:
! 1178: /* Contact information */
! 1179:
! 1180: /** The admin's contact information */
! 1181: char *server_admin;
! 1182: /** The server hostname */
! 1183: char *server_hostname;
! 1184: /** for redirects, etc. */
! 1185: apr_port_t port;
! 1186:
! 1187: /* Log files --- note that transfer log is now in the modules... */
! 1188:
! 1189: /** The name of the error log */
! 1190: char *error_fname;
! 1191: /** A file descriptor that references the error log */
! 1192: apr_file_t *error_log;
! 1193: /** The log level for this server */
! 1194: int loglevel;
! 1195:
! 1196: /* Module-specific configuration for server, and defaults... */
! 1197:
! 1198: /** true if this is the virtual server */
! 1199: int is_virtual;
! 1200: /** Config vector containing pointers to modules' per-server config
! 1201: * structures. */
! 1202: struct ap_conf_vector_t *module_config;
! 1203: /** MIME type info, etc., before we start checking per-directory info */
! 1204: struct ap_conf_vector_t *lookup_defaults;
! 1205:
! 1206: /* Transaction handling */
! 1207:
! 1208: /** I haven't got a clue */
! 1209: server_addr_rec *addrs;
! 1210: /** Timeout, as an apr interval, before we give up */
! 1211: apr_interval_time_t timeout;
! 1212: /** The apr interval we will wait for another request */
! 1213: apr_interval_time_t keep_alive_timeout;
! 1214: /** Maximum requests per connection */
! 1215: int keep_alive_max;
! 1216: /** Use persistent connections? */
! 1217: int keep_alive;
! 1218:
! 1219: /** Pathname for ServerPath */
! 1220: const char *path;
! 1221: /** Length of path */
! 1222: int pathlen;
! 1223:
! 1224: /** Normal names for ServerAlias servers */
! 1225: apr_array_header_t *names;
! 1226: /** Wildcarded names for ServerAlias servers */
! 1227: apr_array_header_t *wild_names;
! 1228:
! 1229: /** limit on size of the HTTP request line */
! 1230: int limit_req_line;
! 1231: /** limit on size of any request header field */
! 1232: int limit_req_fieldsize;
! 1233: /** limit on number of request header fields */
! 1234: int limit_req_fields;
! 1235:
! 1236: /** The server request scheme for redirect responses */
! 1237: const char *server_scheme;
! 1238: };
! 1239:
! 1240: typedef struct core_output_filter_ctx {
! 1241: apr_bucket_brigade *b;
! 1242: /** subpool of c->pool used for resources
! 1243: * which may outlive the request
! 1244: */
! 1245: apr_pool_t *deferred_write_pool;
! 1246: } core_output_filter_ctx_t;
! 1247:
! 1248: typedef struct core_filter_ctx {
! 1249: apr_bucket_brigade *b;
! 1250: apr_bucket_brigade *tmpbb;
! 1251: } core_ctx_t;
! 1252:
! 1253: typedef struct core_net_rec {
! 1254: /** Connection to the client */
! 1255: apr_socket_t *client_socket;
! 1256:
! 1257: /** connection record */
! 1258: conn_rec *c;
! 1259:
! 1260: core_output_filter_ctx_t *out_ctx;
! 1261: core_ctx_t *in_ctx;
! 1262: } core_net_rec;
! 1263:
! 1264: /**
! 1265: * Examine a field value (such as a media-/content-type) string and return
! 1266: * it sans any parameters; e.g., strip off any ';charset=foo' and the like.
! 1267: * @param p Pool to allocate memory from
! 1268: * @param intype The field to examine
! 1269: * @return A copy of the field minus any parameters
! 1270: */
! 1271: AP_DECLARE(char *) ap_field_noparam(apr_pool_t *p, const char *intype);
! 1272:
! 1273: /**
! 1274: * Convert a time from an integer into a string in a specified format
! 1275: * @param p The pool to allocate memory from
! 1276: * @param t The time to convert
! 1277: * @param fmt The format to use for the conversion
! 1278: * @param gmt Convert the time for GMT?
! 1279: * @return The string that represents the specified time
! 1280: */
! 1281: AP_DECLARE(char *) ap_ht_time(apr_pool_t *p, apr_time_t t, const char *fmt, int gmt);
! 1282:
! 1283: /* String handling. The *_nc variants allow you to use non-const char **s as
! 1284: arguments (unfortunately C won't automatically convert a char ** to a const
! 1285: char **) */
! 1286:
! 1287: /**
! 1288: * Get the characters until the first occurance of a specified character
! 1289: * @param p The pool to allocate memory from
! 1290: * @param line The string to get the characters from
! 1291: * @param stop The character to stop at
! 1292: * @return A copy of the characters up to the first stop character
! 1293: */
! 1294: AP_DECLARE(char *) ap_getword(apr_pool_t *p, const char **line, char stop);
! 1295:
! 1296: /**
! 1297: * Get the characters until the first occurance of a specified character
! 1298: * @param p The pool to allocate memory from
! 1299: * @param line The string to get the characters from
! 1300: * @param stop The character to stop at
! 1301: * @return A copy of the characters up to the first stop character
! 1302: * @note This is the same as ap_getword(), except it doesn't use const char **.
! 1303: */
! 1304: AP_DECLARE(char *) ap_getword_nc(apr_pool_t *p, char **line, char stop);
! 1305:
! 1306: /**
! 1307: * Get the first word from a given string. A word is defined as all characters
! 1308: * up to the first whitespace.
! 1309: * @param p The pool to allocate memory from
! 1310: * @param line The string to traverse
! 1311: * @return The first word in the line
! 1312: */
! 1313: AP_DECLARE(char *) ap_getword_white(apr_pool_t *p, const char **line);
! 1314:
! 1315: /**
! 1316: * Get the first word from a given string. A word is defined as all characters
! 1317: * up to the first whitespace.
! 1318: * @param p The pool to allocate memory from
! 1319: * @param line The string to traverse
! 1320: * @return The first word in the line
! 1321: * @note The same as ap_getword_white(), except it doesn't use const char**
! 1322: */
! 1323: AP_DECLARE(char *) ap_getword_white_nc(apr_pool_t *p, char **line);
! 1324:
! 1325: /**
! 1326: * Get all characters from the first occurance of @a stop to the first "\0"
! 1327: * @param p The pool to allocate memory from
! 1328: * @param line The line to traverse
! 1329: * @param stop The character to start at
! 1330: * @return A copy of all caracters after the first occurance of the specified
! 1331: * character
! 1332: */
! 1333: AP_DECLARE(char *) ap_getword_nulls(apr_pool_t *p, const char **line,
! 1334: char stop);
! 1335:
! 1336: /**
! 1337: * Get all characters from the first occurance of @a stop to the first "\0"
! 1338: * @param p The pool to allocate memory from
! 1339: * @param line The line to traverse
! 1340: * @param stop The character to start at
! 1341: * @return A copy of all caracters after the first occurance of the specified
! 1342: * character
! 1343: * @note The same as ap_getword_nulls(), except it doesn't use const char **.
! 1344: */
! 1345: AP_DECLARE(char *) ap_getword_nulls_nc(apr_pool_t *p, char **line, char stop);
! 1346:
! 1347: /**
! 1348: * Get the second word in the string paying attention to quoting
! 1349: * @param p The pool to allocate from
! 1350: * @param line The line to traverse
! 1351: * @return A copy of the string
! 1352: */
! 1353: AP_DECLARE(char *) ap_getword_conf(apr_pool_t *p, const char **line);
! 1354:
! 1355: /**
! 1356: * Get the second word in the string paying attention to quoting
! 1357: * @param p The pool to allocate from
! 1358: * @param line The line to traverse
! 1359: * @return A copy of the string
! 1360: * @note The same as ap_getword_conf(), except it doesn't use const char **.
! 1361: */
! 1362: AP_DECLARE(char *) ap_getword_conf_nc(apr_pool_t *p, char **line);
! 1363:
! 1364: /**
! 1365: * Check a string for any ${ENV} environment variable construct and replace
! 1366: * each them by the value of that environment variable, if it exists. If the
! 1367: * environment value does not exist, leave the ${ENV} construct alone; it
! 1368: * means something else.
! 1369: * @param p The pool to allocate from
! 1370: * @param word The string to check
! 1371: * @return The string with the replaced environment variables
! 1372: */
! 1373: AP_DECLARE(const char *) ap_resolve_env(apr_pool_t *p, const char * word);
! 1374:
! 1375: /**
! 1376: * Size an HTTP header field list item, as separated by a comma.
! 1377: * @param field The field to size
! 1378: * @param len The length of the field
! 1379: * @return The return value is a pointer to the beginning of the non-empty
! 1380: * list item within the original string (or NULL if there is none) and the
! 1381: * address of field is shifted to the next non-comma, non-whitespace
! 1382: * character. len is the length of the item excluding any beginning whitespace.
! 1383: */
! 1384: AP_DECLARE(const char *) ap_size_list_item(const char **field, int *len);
! 1385:
! 1386: /**
! 1387: * Retrieve an HTTP header field list item, as separated by a comma,
! 1388: * while stripping insignificant whitespace and lowercasing anything not in
! 1389: * a quoted string or comment.
! 1390: * @param p The pool to allocate from
! 1391: * @param field The field to retrieve
! 1392: * @return The return value is a new string containing the converted list
! 1393: * item (or NULL if none) and the address pointed to by field is
! 1394: * shifted to the next non-comma, non-whitespace.
! 1395: */
! 1396: AP_DECLARE(char *) ap_get_list_item(apr_pool_t *p, const char **field);
! 1397:
! 1398: /**
! 1399: * Find an item in canonical form (lowercase, no extra spaces) within
! 1400: * an HTTP field value list.
! 1401: * @param p The pool to allocate from
! 1402: * @param line The field value list to search
! 1403: * @param tok The token to search for
! 1404: * @return 1 if found, 0 if not found.
! 1405: */
! 1406: AP_DECLARE(int) ap_find_list_item(apr_pool_t *p, const char *line, const char *tok);
! 1407:
! 1408: /**
! 1409: * Retrieve a token, spacing over it and adjusting the pointer to
! 1410: * the first non-white byte afterwards. Note that these tokens
! 1411: * are delimited by semis and commas and can also be delimited
! 1412: * by whitespace at the caller's option.
! 1413: * @param p The pool to allocate from
! 1414: * @param accept_line The line to retrieve the token from (adjusted afterwards)
! 1415: * @param accept_white Is it delimited by whitespace
! 1416: * @return the token
! 1417: */
! 1418: AP_DECLARE(char *) ap_get_token(apr_pool_t *p, const char **accept_line, int accept_white);
! 1419:
! 1420: /**
! 1421: * Find http tokens, see the definition of token from RFC2068
! 1422: * @param p The pool to allocate from
! 1423: * @param line The line to find the token
! 1424: * @param tok The token to find
! 1425: * @return 1 if the token is found, 0 otherwise
! 1426: */
! 1427: AP_DECLARE(int) ap_find_token(apr_pool_t *p, const char *line, const char *tok);
! 1428:
! 1429: /**
! 1430: * find http tokens from the end of the line
! 1431: * @param p The pool to allocate from
! 1432: * @param line The line to find the token
! 1433: * @param tok The token to find
! 1434: * @return 1 if the token is found, 0 otherwise
! 1435: */
! 1436: AP_DECLARE(int) ap_find_last_token(apr_pool_t *p, const char *line, const char *tok);
! 1437:
! 1438: /**
! 1439: * Check for an Absolute URI syntax
! 1440: * @param u The string to check
! 1441: * @return 1 if URI, 0 otherwise
! 1442: */
! 1443: AP_DECLARE(int) ap_is_url(const char *u);
! 1444:
! 1445: /**
! 1446: * Unescape a URL
! 1447: * @param url The url to unescape
! 1448: * @return 0 on success, non-zero otherwise
! 1449: */
! 1450: AP_DECLARE(int) ap_unescape_url(char *url);
! 1451:
! 1452: /**
! 1453: * Unescape a URL, including encoded slashes.
! 1454: * @param url The url to unescape
! 1455: * @return 0 on success, non-zero otherwise
! 1456: */
! 1457: AP_DECLARE(int) ap_unescape_url_keep2f(char *url);
! 1458:
! 1459: /**
! 1460: * Unescape a URL, including encoded slashes.
! 1461: * @param url The url to unescape
! 1462: * @param decode_slashes Whether or not slashes should be decoded or not
! 1463: * @return 0 on success, non-zero otherwise
! 1464: */
! 1465: AP_DECLARE(int) ap_unescape_url_keep2f_ex(char *url, int decode_slashes);
! 1466:
! 1467: /**
! 1468: * Convert all double slashes to single slashes
! 1469: * @param name The string to convert
! 1470: */
! 1471: AP_DECLARE(void) ap_no2slash(char *name);
! 1472:
! 1473: /**
! 1474: * Remove all ./ and xx/../ substrings from a file name. Also remove
! 1475: * any leading ../ or /../ substrings.
! 1476: * @param name the file name to parse
! 1477: */
! 1478: AP_DECLARE(void) ap_getparents(char *name);
! 1479:
! 1480: /**
! 1481: * Escape a path segment, as defined in RFC 1808
! 1482: * @param p The pool to allocate from
! 1483: * @param s The path to convert
! 1484: * @return The converted URL
! 1485: */
! 1486: AP_DECLARE(char *) ap_escape_path_segment(apr_pool_t *p, const char *s);
! 1487:
! 1488: /**
! 1489: * convert an OS path to a URL in an OS dependant way.
! 1490: * @param p The pool to allocate from
! 1491: * @param path The path to convert
! 1492: * @param partial if set, assume that the path will be appended to something
! 1493: * with a '/' in it (and thus does not prefix "./")
! 1494: * @return The converted URL
! 1495: */
! 1496: AP_DECLARE(char *) ap_os_escape_path(apr_pool_t *p, const char *path, int partial);
! 1497:
! 1498: /** @see ap_os_escape_path */
! 1499: #define ap_escape_uri(ppool,path) ap_os_escape_path(ppool,path,1)
! 1500:
! 1501: /**
! 1502: * Escape an html string
! 1503: * @param p The pool to allocate from
! 1504: * @param s The html to escape
! 1505: * @return The escaped string
! 1506: */
! 1507: AP_DECLARE(char *) ap_escape_html(apr_pool_t *p, const char *s);
! 1508: /**
! 1509: * Escape an html string
! 1510: * @param p The pool to allocate from
! 1511: * @param s The html to escape
! 1512: * @param toasc Whether to escape all non-ASCII chars to &#nnn;
! 1513: * @return The escaped string
! 1514: */
! 1515: AP_DECLARE(char *) ap_escape_html2(apr_pool_t *p, const char *s, int toasc);
! 1516:
! 1517: /**
! 1518: * Escape a string for logging
! 1519: * @param p The pool to allocate from
! 1520: * @param str The string to escape
! 1521: * @return The escaped string
! 1522: */
! 1523: AP_DECLARE(char *) ap_escape_logitem(apr_pool_t *p, const char *str);
! 1524:
! 1525: /**
! 1526: * Escape a string for logging into the error log (without a pool)
! 1527: * @param dest The buffer to write to
! 1528: * @param source The string to escape
! 1529: * @param buflen The buffer size for the escaped string (including "\0")
! 1530: * @return The len of the escaped string (always < maxlen)
! 1531: */
! 1532: AP_DECLARE(apr_size_t) ap_escape_errorlog_item(char *dest, const char *source,
! 1533: apr_size_t buflen);
! 1534:
! 1535: /**
! 1536: * Construct a full hostname
! 1537: * @param p The pool to allocate from
! 1538: * @param hostname The hostname of the server
! 1539: * @param port The port the server is running on
! 1540: * @param r The current request
! 1541: * @return The server's hostname
! 1542: */
! 1543: AP_DECLARE(char *) ap_construct_server(apr_pool_t *p, const char *hostname,
! 1544: apr_port_t port, const request_rec *r);
! 1545:
! 1546: /**
! 1547: * Escape a shell command
! 1548: * @param p The pool to allocate from
! 1549: * @param s The command to escape
! 1550: * @return The escaped shell command
! 1551: */
! 1552: AP_DECLARE(char *) ap_escape_shell_cmd(apr_pool_t *p, const char *s);
! 1553:
! 1554: /**
! 1555: * Count the number of directories in a path
! 1556: * @param path The path to count
! 1557: * @return The number of directories
! 1558: */
! 1559: AP_DECLARE(int) ap_count_dirs(const char *path);
! 1560:
! 1561: /**
! 1562: * Copy at most @a n leading directories of @a s into @a d. @a d
! 1563: * should be at least as large as @a s plus 1 extra byte
! 1564: *
! 1565: * @param d The location to copy to
! 1566: * @param s The location to copy from
! 1567: * @param n The number of directories to copy
! 1568: * @return value is the ever useful pointer to the trailing "\0" of d
! 1569: * @note on platforms with drive letters, n = 0 returns the "/" root,
! 1570: * whereas n = 1 returns the "d:/" root. On all other platforms, n = 0
! 1571: * returns the empty string. */
! 1572: AP_DECLARE(char *) ap_make_dirstr_prefix(char *d, const char *s, int n);
! 1573:
! 1574: /**
! 1575: * Return the parent directory name (including trailing /) of the file
! 1576: * @a s
! 1577: * @param p The pool to allocate from
! 1578: * @param s The file to get the parent of
! 1579: * @return A copy of the file's parent directory
! 1580: */
! 1581: AP_DECLARE(char *) ap_make_dirstr_parent(apr_pool_t *p, const char *s);
! 1582:
! 1583: /**
! 1584: * Given a directory and filename, create a single path from them. This
! 1585: * function is smart enough to ensure that there is a single '/' between the
! 1586: * directory and file names
! 1587: * @param a The pool to allocate from
! 1588: * @param dir The directory name
! 1589: * @param f The filename
! 1590: * @return A copy of the full path
! 1591: * @note Never consider using this function if you are dealing with filesystem
! 1592: * names that need to remain canonical, unless you are merging an apr_dir_read
! 1593: * path and returned filename. Otherwise, the result is not canonical.
! 1594: */
! 1595: AP_DECLARE(char *) ap_make_full_path(apr_pool_t *a, const char *dir, const char *f);
! 1596:
! 1597: /**
! 1598: * Test if the given path has an an absolute path.
! 1599: * @param p The pool to allocate from
! 1600: * @param dir The directory name
! 1601: * @note The converse is not necessarily true, some OS's (Win32/OS2/Netware) have
! 1602: * multiple forms of absolute paths. This only reports if the path is absolute
! 1603: * in a canonical sense.
! 1604: */
! 1605: AP_DECLARE(int) ap_os_is_path_absolute(apr_pool_t *p, const char *dir);
! 1606:
! 1607: /**
! 1608: * Does the provided string contain wildcard characters? This is useful
! 1609: * for determining if the string should be passed to strcmp_match or to strcmp.
! 1610: * The only wildcard characters recognized are '?' and '*'
! 1611: * @param str The string to check
! 1612: * @return 1 if the string has wildcards, 0 otherwise
! 1613: */
! 1614: AP_DECLARE(int) ap_is_matchexp(const char *str);
! 1615:
! 1616: /**
! 1617: * Determine if a string matches a patterm containing the wildcards '?' or '*'
! 1618: * @param str The string to check
! 1619: * @param expected The pattern to match against
! 1620: * @return 1 if the two strings match, 0 otherwise
! 1621: */
! 1622: AP_DECLARE(int) ap_strcmp_match(const char *str, const char *expected);
! 1623:
! 1624: /**
! 1625: * Determine if a string matches a patterm containing the wildcards '?' or '*',
! 1626: * ignoring case
! 1627: * @param str The string to check
! 1628: * @param expected The pattern to match against
! 1629: * @return 1 if the two strings match, 0 otherwise
! 1630: */
! 1631: AP_DECLARE(int) ap_strcasecmp_match(const char *str, const char *expected);
! 1632:
! 1633: /**
! 1634: * Find the first occurrence of the substring s2 in s1, regardless of case
! 1635: * @param s1 The string to search
! 1636: * @param s2 The substring to search for
! 1637: * @return A pointer to the beginning of the substring
! 1638: * @remark See apr_strmatch() for a faster alternative
! 1639: */
! 1640: AP_DECLARE(char *) ap_strcasestr(const char *s1, const char *s2);
! 1641:
! 1642: /**
! 1643: * Return a pointer to the location inside of bigstring immediately after prefix
! 1644: * @param bigstring The input string
! 1645: * @param prefix The prefix to strip away
! 1646: * @return A pointer relative to bigstring after prefix
! 1647: */
! 1648: AP_DECLARE(const char *) ap_stripprefix(const char *bigstring,
! 1649: const char *prefix);
! 1650:
! 1651: /**
! 1652: * Decode a base64 encoded string into memory allocated from a pool
! 1653: * @param p The pool to allocate from
! 1654: * @param bufcoded The encoded string
! 1655: * @return The decoded string
! 1656: */
! 1657: AP_DECLARE(char *) ap_pbase64decode(apr_pool_t *p, const char *bufcoded);
! 1658:
! 1659: /**
! 1660: * Encode a string into memory allocated from a pool in base 64 format
! 1661: * @param p The pool to allocate from
! 1662: * @param string The plaintext string
! 1663: * @return The encoded string
! 1664: */
! 1665: AP_DECLARE(char *) ap_pbase64encode(apr_pool_t *p, char *string);
! 1666:
! 1667: /**
! 1668: * Compile a regular expression to be used later
! 1669: * @param p The pool to allocate from
! 1670: * @param pattern the regular expression to compile
! 1671: * @param cflags The bitwise or of one or more of the following:
! 1672: * @li REG_EXTENDED - Use POSIX extended Regular Expressions
! 1673: * @li REG_ICASE - Ignore case
! 1674: * @li REG_NOSUB - Support for substring addressing of matches
! 1675: * not required
! 1676: * @li REG_NEWLINE - Match-any-character operators don't match new-line
! 1677: * @return The compiled regular expression
! 1678: */
! 1679: AP_DECLARE(ap_regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern,
! 1680: int cflags);
! 1681:
! 1682: /**
! 1683: * Free the memory associated with a compiled regular expression
! 1684: * @param p The pool the regex was allocated from
! 1685: * @param reg The regular expression to free
! 1686: */
! 1687: AP_DECLARE(void) ap_pregfree(apr_pool_t *p, ap_regex_t *reg);
! 1688:
! 1689: /**
! 1690: * After performing a successful regex match, you may use this function to
! 1691: * perform a series of string substitutions based on subexpressions that were
! 1692: * matched during the call to ap_regexec
! 1693: * @param p The pool to allocate from
! 1694: * @param input An arbitrary string containing $1 through $9. These are
! 1695: * replaced with the corresponding matched sub-expressions
! 1696: * @param source The string that was originally matched to the regex
! 1697: * @param nmatch the nmatch returned from ap_pregex
! 1698: * @param pmatch the pmatch array returned from ap_pregex
! 1699: */
! 1700: AP_DECLARE(char *) ap_pregsub(apr_pool_t *p, const char *input, const char *source,
! 1701: size_t nmatch, ap_regmatch_t pmatch[]);
! 1702:
! 1703: /**
! 1704: * After performing a successful regex match, you may use this function to
! 1705: * perform a series of string substitutions based on subexpressions that were
! 1706: * matched during the call to ap_regexec
! 1707: * @param p The pool to allocate from
! 1708: * @param result where to store the result, will be set to NULL on error
! 1709: * @param input An arbitrary string containing $1 through $9. These are
! 1710: * replaced with the corresponding matched sub-expressions
! 1711: * @param source The string that was originally matched to the regex
! 1712: * @param nmatch the nmatch returned from ap_pregex
! 1713: * @param pmatch the pmatch array returned from ap_pregex
! 1714: * @param maxlen the maximum string length to return, 0 for unlimited
! 1715: * @return APR_SUCCESS if successful, APR_ENOMEM or other error code otherwise.
! 1716: */
! 1717: AP_DECLARE(apr_status_t) ap_pregsub_ex(apr_pool_t *p, char **result,
! 1718: const char *input, const char *source,
! 1719: apr_size_t nmatch,
! 1720: ap_regmatch_t pmatch[],
! 1721: apr_size_t maxlen);
! 1722:
! 1723: /**
! 1724: * We want to downcase the type/subtype for comparison purposes
! 1725: * but nothing else because ;parameter=foo values are case sensitive.
! 1726: * @param s The content-type to convert to lowercase
! 1727: */
! 1728: AP_DECLARE(void) ap_content_type_tolower(char *s);
! 1729:
! 1730: /**
! 1731: * convert a string to all lowercase
! 1732: * @param s The string to convert to lowercase
! 1733: */
! 1734: AP_DECLARE(void) ap_str_tolower(char *s);
! 1735:
! 1736: /**
! 1737: * Search a string from left to right for the first occurrence of a
! 1738: * specific character
! 1739: * @param str The string to search
! 1740: * @param c The character to search for
! 1741: * @return The index of the first occurrence of c in str
! 1742: */
! 1743: AP_DECLARE(int) ap_ind(const char *str, char c); /* Sigh... */
! 1744:
! 1745: /**
! 1746: * Search a string from right to left for the first occurrence of a
! 1747: * specific character
! 1748: * @param str The string to search
! 1749: * @param c The character to search for
! 1750: * @return The index of the first occurrence of c in str
! 1751: */
! 1752: AP_DECLARE(int) ap_rind(const char *str, char c);
! 1753:
! 1754: /**
! 1755: * Given a string, replace any bare " with \" .
! 1756: * @param p The pool to allocate memory from
! 1757: * @param instring The string to search for "
! 1758: * @return A copy of the string with escaped quotes
! 1759: */
! 1760: AP_DECLARE(char *) ap_escape_quotes(apr_pool_t *p, const char *instring);
! 1761:
! 1762: /**
! 1763: * Given a string, append the PID deliminated by delim.
! 1764: * Usually used to create a pid-appended filepath name
! 1765: * (eg: /a/b/foo -> /a/b/foo.6726). A function, and not
! 1766: * a macro, to avoid unistd.h dependency
! 1767: * @param p The pool to allocate memory from
! 1768: * @param string The string to append the PID to
! 1769: * @param delim The string to use to deliminate the string from the PID
! 1770: * @return A copy of the string with the PID appended
! 1771: */
! 1772: AP_DECLARE(char *) ap_append_pid(apr_pool_t *p, const char *string,
! 1773: const char *delim);
! 1774:
! 1775: /**
! 1776: * Parse a given timeout parameter string into an apr_interval_time_t value.
! 1777: * The unit of the time interval is given as postfix string to the numeric
! 1778: * string. Currently the following units are understood:
! 1779: *
! 1780: * ms : milliseconds
! 1781: * s : seconds
! 1782: * mi[n] : minutes
! 1783: * h : hours
! 1784: *
! 1785: * If no unit is contained in the given timeout parameter the default_time_unit
! 1786: * will be used instead.
! 1787: * @param timeout_parameter The string containing the timeout parameter.
! 1788: * @param timeout The timeout value to be returned.
! 1789: * @param default_time_unit The default time unit to use if none is specified
! 1790: * in timeout_parameter.
! 1791: * @return Status value indicating whether the parsing was successful or not.
! 1792: */
! 1793: AP_DECLARE(apr_status_t) ap_timeout_parameter_parse(
! 1794: const char *timeout_parameter,
! 1795: apr_interval_time_t *timeout,
! 1796: const char *default_time_unit);
! 1797:
! 1798: /* Misc system hackery */
! 1799: /**
! 1800: * Given the name of an object in the file system determine if it is a directory
! 1801: * @param p The pool to allocate from
! 1802: * @param name The name of the object to check
! 1803: * @return 1 if it is a directory, 0 otherwise
! 1804: */
! 1805: AP_DECLARE(int) ap_is_rdirectory(apr_pool_t *p, const char *name);
! 1806:
! 1807: /**
! 1808: * Given the name of an object in the file system determine if it is a directory - this version is symlink aware
! 1809: * @param p The pool to allocate from
! 1810: * @param name The name of the object to check
! 1811: * @return 1 if it is a directory, 0 otherwise
! 1812: */
! 1813: AP_DECLARE(int) ap_is_directory(apr_pool_t *p, const char *name);
! 1814:
! 1815: #ifdef _OSD_POSIX
! 1816: extern int os_init_job_environment(server_rec *s, const char *user_name, int one_process);
! 1817: #endif /* _OSD_POSIX */
! 1818:
! 1819: /**
! 1820: * Determine the local host name for the current machine
! 1821: * @param p The pool to allocate from
! 1822: * @return A copy of the local host name
! 1823: */
! 1824: char *ap_get_local_host(apr_pool_t *p);
! 1825:
! 1826: /**
! 1827: * Log an assertion to the error log
! 1828: * @param szExp The assertion that failed
! 1829: * @param szFile The file the assertion is in
! 1830: * @param nLine The line the assertion is defined on
! 1831: */
! 1832: AP_DECLARE(void) ap_log_assert(const char *szExp, const char *szFile, int nLine)
! 1833: __attribute__((noreturn));
! 1834:
! 1835: /**
! 1836: * @internal Internal Assert function
! 1837: */
! 1838: #define ap_assert(exp) ((exp) ? (void)0 : ap_log_assert(#exp,__FILE__,__LINE__))
! 1839:
! 1840: /**
! 1841: * Redefine assert() to something more useful for an Apache...
! 1842: *
! 1843: * Use ap_assert() if the condition should always be checked.
! 1844: * Use AP_DEBUG_ASSERT() if the condition should only be checked when AP_DEBUG
! 1845: * is defined.
! 1846: */
! 1847: #ifdef AP_DEBUG
! 1848: #define AP_DEBUG_ASSERT(exp) ap_assert(exp)
! 1849: #else
! 1850: #define AP_DEBUG_ASSERT(exp) ((void)0)
! 1851: #endif
! 1852:
! 1853: /**
! 1854: * @defgroup stopsignal Flags which indicate places where the sever should stop for debugging.
! 1855: * @{
! 1856: * A set of flags which indicate places where the server should raise(SIGSTOP).
! 1857: * This is useful for debugging, because you can then attach to that process
! 1858: * with gdb and continue. This is important in cases where one_process
! 1859: * debugging isn't possible.
! 1860: */
! 1861: /** stop on a Detach */
! 1862: #define SIGSTOP_DETACH 1
! 1863: /** stop making a child process */
! 1864: #define SIGSTOP_MAKE_CHILD 2
! 1865: /** stop spawning a child process */
! 1866: #define SIGSTOP_SPAWN_CHILD 4
! 1867: /** stop spawning a child process with a piped log */
! 1868: #define SIGSTOP_PIPED_LOG_SPAWN 8
! 1869: /** stop spawning a CGI child process */
! 1870: #define SIGSTOP_CGI_CHILD 16
! 1871:
! 1872: /** Macro to get GDB started */
! 1873: #ifdef DEBUG_SIGSTOP
! 1874: extern int raise_sigstop_flags;
! 1875: #define RAISE_SIGSTOP(x) do { \
! 1876: if (raise_sigstop_flags & SIGSTOP_##x) raise(SIGSTOP);\
! 1877: } while (0)
! 1878: #else
! 1879: #define RAISE_SIGSTOP(x)
! 1880: #endif
! 1881: /** @} */
! 1882: /**
! 1883: * Get HTML describing the address and (optionally) admin of the server.
! 1884: * @param prefix Text which is prepended to the return value
! 1885: * @param r The request_rec
! 1886: * @return HTML describing the server, allocated in @a r's pool.
! 1887: */
! 1888: AP_DECLARE(const char *) ap_psignature(const char *prefix, request_rec *r);
! 1889:
! 1890:
! 1891: /**
! 1892: * Short function to execute a command and return the first line of
! 1893: * output minus \r \n. Useful for "obscuring" passwords via exec calls
! 1894: * @param p the pool to allocate from
! 1895: * @param cmd the command to execute
! 1896: * @param argv the arguments to pass to the cmd
! 1897: * @return ptr to characters or NULL on any error
! 1898: */
! 1899: AP_DECLARE(char *) ap_get_exec_line(apr_pool_t *p,
! 1900: const char *cmd,
! 1901: const char * const *argv);
! 1902:
! 1903: /** strtoul does not exist on sunos4. */
! 1904: #ifdef strtoul
! 1905: #undef strtoul
! 1906: #endif
! 1907: #define strtoul strtoul_is_not_a_portable_function_use_strtol_instead
! 1908:
! 1909: /* The C library has functions that allow const to be silently dropped ...
! 1910: these macros detect the drop in maintainer mode, but use the native
! 1911: methods for normal builds
! 1912:
! 1913: Note that on some platforms (e.g., AIX with gcc, Solaris with gcc), string.h needs
! 1914: to be included before the macros are defined or compilation will fail.
! 1915: */
! 1916: #include <string.h>
! 1917:
! 1918: AP_DECLARE(char *) ap_strchr(char *s, int c);
! 1919: AP_DECLARE(const char *) ap_strchr_c(const char *s, int c);
! 1920: AP_DECLARE(char *) ap_strrchr(char *s, int c);
! 1921: AP_DECLARE(const char *) ap_strrchr_c(const char *s, int c);
! 1922: AP_DECLARE(char *) ap_strstr(char *s, const char *c);
! 1923: AP_DECLARE(const char *) ap_strstr_c(const char *s, const char *c);
! 1924:
! 1925: #ifdef AP_DEBUG
! 1926:
! 1927: #undef strchr
! 1928: # define strchr(s, c) ap_strchr(s,c)
! 1929: #undef strrchr
! 1930: # define strrchr(s, c) ap_strrchr(s,c)
! 1931: #undef strstr
! 1932: # define strstr(s, c) ap_strstr(s,c)
! 1933:
! 1934: #else
! 1935:
! 1936: /** use this instead of strchr */
! 1937: # define ap_strchr(s, c) strchr(s, c)
! 1938: /** use this instead of strchr */
! 1939: # define ap_strchr_c(s, c) strchr(s, c)
! 1940: /** use this instead of strrchr */
! 1941: # define ap_strrchr(s, c) strrchr(s, c)
! 1942: /** use this instead of strrchr */
! 1943: # define ap_strrchr_c(s, c) strrchr(s, c)
! 1944: /** use this instead of strrstr*/
! 1945: # define ap_strstr(s, c) strstr(s, c)
! 1946: /** use this instead of strrstr*/
! 1947: # define ap_strstr_c(s, c) strstr(s, c)
! 1948:
! 1949: #endif
! 1950:
! 1951: #define AP_NORESTART APR_OS_START_USEERR + 1
! 1952:
! 1953: #ifdef __cplusplus
! 1954: }
! 1955: #endif
! 1956:
! 1957: #endif /* !APACHE_HTTPD_H */
! 1958:
! 1959: /** @} //APACHE Daemon */
! 1960: /** @} //APACHE Core */
! 1961: /** @} //APACHE super group */
! 1962:
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to httpd.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / win32 / apache22 / include