| /* Copyright 1999-2004 The Apache Software Foundation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef APACHE_HTTPD_H |
| #define APACHE_HTTPD_H |
| |
| /** |
| * @file httpd.h |
| * @brief HTTP Daemon routines |
| */ |
| |
| /* XXX - We need to push more stuff to other .h files, or even .c files, to |
| * make this file smaller |
| */ |
| |
| /* Headers in which EVERYONE has an interest... */ |
| #include "ap_config.h" |
| #include "ap_mmn.h" |
| |
| #include "ap_release.h" |
| |
| #include "apr_general.h" |
| #include "apr_tables.h" |
| #include "apr_pools.h" |
| #include "apr_time.h" |
| #include "apr_network_io.h" |
| #include "apr_buckets.h" |
| |
| #include "os.h" |
| |
| #include "pcreposix.h" |
| |
| /* Note: util_uri.h is also included, see below */ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #ifdef CORE_PRIVATE |
| |
| /* ----------------------------- config dir ------------------------------ */ |
| |
| /* Define this to be the default server home dir. Most things later in this |
| * file with a relative pathname will have this added. |
| */ |
| #ifndef HTTPD_ROOT |
| #ifdef OS2 |
| /* Set default for OS/2 file system */ |
| #define HTTPD_ROOT "/os2httpd" |
| #elif defined(WIN32) |
| /* Set default for Windows file system */ |
| #define HTTPD_ROOT "/apache" |
| #elif defined (BEOS) |
| /* Set the default for BeOS */ |
| #define HTTPD_ROOT "/boot/home/apache" |
| #elif defined (NETWARE) |
| /* Set the default for NetWare */ |
| #define HTTPD_ROOT "/apache" |
| #else |
| #define HTTPD_ROOT "/usr/local/apache" |
| #endif |
| #endif /* HTTPD_ROOT */ |
| |
| /* |
| * --------- You shouldn't have to edit anything below this line ---------- |
| * |
| * Any modifications to any defaults not defined above should be done in the |
| * respective configuration file. |
| * |
| */ |
| |
| /* Default location of documents. Can be overridden by the DocumentRoot |
| * directive. |
| */ |
| #ifndef DOCUMENT_LOCATION |
| #ifdef OS2 |
| /* Set default for OS/2 file system */ |
| #define DOCUMENT_LOCATION HTTPD_ROOT "/docs" |
| #else |
| #define DOCUMENT_LOCATION HTTPD_ROOT "/htdocs" |
| #endif |
| #endif /* DOCUMENT_LOCATION */ |
| |
| /* Maximum number of dynamically loaded modules */ |
| #ifndef DYNAMIC_MODULE_LIMIT |
| #define DYNAMIC_MODULE_LIMIT 128 |
| #endif |
| |
| /* Default administrator's address */ |
| #define DEFAULT_ADMIN "[no address given]" |
| |
| /* The name of the log files */ |
| #ifndef DEFAULT_ERRORLOG |
| #if defined(OS2) || defined(WIN32) |
| #define DEFAULT_ERRORLOG "logs/error.log" |
| #else |
| #define DEFAULT_ERRORLOG "logs/error_log" |
| #endif |
| #endif /* DEFAULT_ERRORLOG */ |
| |
| /* Define this to be what your per-directory security files are called */ |
| #ifndef DEFAULT_ACCESS_FNAME |
| #ifdef OS2 |
| /* Set default for OS/2 file system */ |
| #define DEFAULT_ACCESS_FNAME "htaccess" |
| #else |
| #define DEFAULT_ACCESS_FNAME ".htaccess" |
| #endif |
| #endif /* DEFAULT_ACCESS_FNAME */ |
| |
| /* The name of the server config file */ |
| #ifndef SERVER_CONFIG_FILE |
| #define SERVER_CONFIG_FILE "conf/httpd.conf" |
| #endif |
| |
| /* The default path for CGI scripts if none is currently set */ |
| #ifndef DEFAULT_PATH |
| #define DEFAULT_PATH "/bin:/usr/bin:/usr/ucb:/usr/bsd:/usr/local/bin" |
| #endif |
| |
| /* The path to the suExec wrapper, can be overridden in Configuration */ |
| #ifndef SUEXEC_BIN |
| #define SUEXEC_BIN HTTPD_ROOT "/bin/suexec" |
| #endif |
| |
| /* The timeout for waiting for messages */ |
| #ifndef DEFAULT_TIMEOUT |
| #define DEFAULT_TIMEOUT 300 |
| #endif |
| |
| /* The timeout for waiting for keepalive timeout until next request */ |
| #ifndef DEFAULT_KEEPALIVE_TIMEOUT |
| #define DEFAULT_KEEPALIVE_TIMEOUT 15 |
| #endif |
| |
| /* The number of requests to entertain per connection */ |
| #ifndef DEFAULT_KEEPALIVE |
| #define DEFAULT_KEEPALIVE 100 |
| #endif |
| |
| /* Limits on the size of various request items. These limits primarily |
| * exist to prevent simple denial-of-service attacks on a server based |
| * on misuse of the protocol. The recommended values will depend on the |
| * nature of the server resources -- CGI scripts and database backends |
| * might require large values, but most servers could get by with much |
| * smaller limits than we use below. The request message body size can |
| * be limited by the per-dir config directive LimitRequestBody. |
| * |
| * Internal buffer sizes are two bytes more than the DEFAULT_LIMIT_REQUEST_LINE |
| * and DEFAULT_LIMIT_REQUEST_FIELDSIZE below, which explains the 8190. |
| * These two limits can be lowered (but not raised) by the server config |
| * directives LimitRequestLine and LimitRequestFieldsize, respectively. |
| * |
| * DEFAULT_LIMIT_REQUEST_FIELDS can be modified or disabled (set = 0) by |
| * the server config directive LimitRequestFields. |
| */ |
| #ifndef DEFAULT_LIMIT_REQUEST_LINE |
| #define DEFAULT_LIMIT_REQUEST_LINE 8190 |
| #endif /* default limit on bytes in Request-Line (Method+URI+HTTP-version) */ |
| #ifndef DEFAULT_LIMIT_REQUEST_FIELDSIZE |
| #define DEFAULT_LIMIT_REQUEST_FIELDSIZE 8190 |
| #endif /* default limit on bytes in any one header field */ |
| #ifndef DEFAULT_LIMIT_REQUEST_FIELDS |
| #define DEFAULT_LIMIT_REQUEST_FIELDS 100 |
| #endif /* default limit on number of request header fields */ |
| |
| |
| /** |
| * The default default character set name to add if AddDefaultCharset is |
| * enabled. Overridden with AddDefaultCharsetName. |
| */ |
| #define DEFAULT_ADD_DEFAULT_CHARSET_NAME "iso-8859-1" |
| |
| #endif /* CORE_PRIVATE */ |
| |
| /** default HTTP Server protocol */ |
| #define AP_SERVER_PROTOCOL "HTTP/1.1" |
| |
| |
| /* ------------------ stuff that modules are allowed to look at ----------- */ |
| |
| /** Define this to be what your HTML directory content files are called */ |
| #ifndef AP_DEFAULT_INDEX |
| #define AP_DEFAULT_INDEX "index.html" |
| #endif |
| |
| |
| /** |
| * Define this to be what type you'd like returned for files with unknown |
| * suffixes. |
| * @warning MUST be all lower case. |
| */ |
| #ifndef DEFAULT_CONTENT_TYPE |
| #define DEFAULT_CONTENT_TYPE "text/plain" |
| #endif |
| |
| /** The name of the MIME types file */ |
| #ifndef AP_TYPES_CONFIG_FILE |
| #define AP_TYPES_CONFIG_FILE "conf/mime.types" |
| #endif |
| |
| /* |
| * Define the HTML doctype strings centrally. |
| */ |
| /** HTML 2.0 Doctype */ |
| #define DOCTYPE_HTML_2_0 "<!DOCTYPE HTML PUBLIC \"-//IETF//" \ |
| "DTD HTML 2.0//EN\">\n" |
| /** HTML 3.2 Doctype */ |
| #define DOCTYPE_HTML_3_2 "<!DOCTYPE HTML PUBLIC \"-//W3C//" \ |
| "DTD HTML 3.2 Final//EN\">\n" |
| /** HTML 4.0 Strict Doctype */ |
| #define DOCTYPE_HTML_4_0S "<!DOCTYPE HTML PUBLIC \"-//W3C//" \ |
| "DTD HTML 4.0//EN\"\n" \ |
| "\"http://www.w3.org/TR/REC-html40/strict.dtd\">\n" |
| /** HTML 4.0 Transitional Doctype */ |
| #define DOCTYPE_HTML_4_0T "<!DOCTYPE HTML PUBLIC \"-//W3C//" \ |
| "DTD HTML 4.0 Transitional//EN\"\n" \ |
| "\"http://www.w3.org/TR/REC-html40/loose.dtd\">\n" |
| /** HTML 4.0 Frameset Doctype */ |
| #define DOCTYPE_HTML_4_0F "<!DOCTYPE HTML PUBLIC \"-//W3C//" \ |
| "DTD HTML 4.0 Frameset//EN\"\n" \ |
| "\"http://www.w3.org/TR/REC-html40/frameset.dtd\">\n" |
| /** XHTML 1.0 Strict Doctype */ |
| #define DOCTYPE_XHTML_1_0S "<!DOCTYPE html PUBLIC \"-//W3C//" \ |
| "DTD XHTML 1.0 Strict//EN\"\n" \ |
| "\"http://www.w3.org/TR/xhtml1/DTD/" \ |
| "xhtml1-strict.dtd\">\n" |
| /** XHTML 1.0 Transitional Doctype */ |
| #define DOCTYPE_XHTML_1_0T "<!DOCTYPE html PUBLIC \"-//W3C//" \ |
| "DTD XHTML 1.0 Transitional//EN\"\n" \ |
| "\"http://www.w3.org/TR/xhtml1/DTD/" \ |
| "xhtml1-transitional.dtd\">\n" |
| /** XHTML 1.0 Frameset Doctype */ |
| #define DOCTYPE_XHTML_1_0F "<!DOCTYPE html PUBLIC \"-//W3C//" \ |
| "DTD XHTML 1.0 Frameset//EN\"\n" \ |
| "\"http://www.w3.org/TR/xhtml1/DTD/" \ |
| "xhtml1-frameset.dtd\">" |
| |
| /** Internal representation for a HTTP protocol number, e.g., HTTP/1.1 */ |
| |
| #define HTTP_VERSION(major,minor) (1000*(major)+(minor)) |
| /** Major part of HTTP protocol */ |
| #define HTTP_VERSION_MAJOR(number) ((number)/1000) |
| /** Minor part of HTTP protocol */ |
| #define HTTP_VERSION_MINOR(number) ((number)%1000) |
| |
| /* -------------- Port number for server running standalone --------------- */ |
| |
| /** default HTTP Port */ |
| #define DEFAULT_HTTP_PORT 80 |
| /** default HTTPS Port */ |
| #define DEFAULT_HTTPS_PORT 443 |
| /** |
| * Check whether @a port is the default port for the request @a r. |
| * @param port The port number |
| * @param r The request |
| * @see #ap_default_port |
| */ |
| #define ap_is_default_port(port,r) ((port) == ap_default_port(r)) |
| /** |
| * Get the default port for a request (which depends on the scheme). |
| * @param r The request |
| */ |
| #define ap_default_port(r) ap_run_default_port(r) |
| /** |
| * Get the scheme for a request. |
| * @param r The request |
| * @bug This should be called ap_http_scheme! |
| */ |
| #define ap_http_method(r) ap_run_http_method(r) |
| |
| /** The default string lengths */ |
| #define MAX_STRING_LEN HUGE_STRING_LEN |
| #define HUGE_STRING_LEN 8192 |
| |
| /** The size of the server's internal read-write buffers */ |
| #define AP_IOBUFSIZE 8192 |
| |
| /** The max number of regex captures that can be expanded by ap_pregsub */ |
| #define AP_MAX_REG_MATCH 10 |
| |
| /** |
| * APR_HAS_LARGE_FILES introduces the problem of spliting sendfile into |
| * mutiple buckets, no greater than MAX(apr_size_t), and more granular |
| * than that in case the brigade code/filters attempt to read it directly. |
| * ### 16mb is an invention, no idea if it is reasonable. |
| */ |
| #define AP_MAX_SENDFILE 16777216 /* 2^24 */ |
| |
| /** |
| * Special Apache error codes. These are basically used |
| * in http_main.c so we can keep track of various errors. |
| * |
| */ |
| /** a normal exit */ |
| #define APEXIT_OK 0x0 |
| /** A fatal error arising during the server's init sequence */ |
| #define APEXIT_INIT 0x2 |
| /** The child died during its init sequence */ |
| #define APEXIT_CHILDINIT 0x3 |
| /** |
| * The child exited due to a resource shortage. |
| * The parent should limit the rate of forking until |
| * the situation is resolved. |
| */ |
| #define APEXIT_CHILDSICK 0x7 |
| /** |
| * A fatal error, resulting in the whole server aborting. |
| * If a child exits with this error, the parent process |
| * considers this a server-wide fatal error and aborts. |
| */ |
| #define APEXIT_CHILDFATAL 0xf |
| |
| #ifndef AP_DECLARE |
| /** |
| * Stuff marked #AP_DECLARE is part of the API, and intended for use |
| * by modules. Its purpose is to allow us to add attributes that |
| * particular platforms or compilers require to every exported function. |
| */ |
| # define AP_DECLARE(type) type |
| #endif |
| |
| #ifndef AP_DECLARE_NONSTD |
| /** |
| * Stuff marked #AP_DECLARE_NONSTD is part of the API, and intended for |
| * use by modules. The difference between #AP_DECLARE and |
| * #AP_DECLARE_NONSTD is that the latter is required for any functions |
| * which use varargs or are used via indirect function call. This |
| * is to accomodate the two calling conventions in windows dlls. |
| */ |
| # define AP_DECLARE_NONSTD(type) type |
| #endif |
| #ifndef AP_DECLARE_DATA |
| # define AP_DECLARE_DATA |
| #endif |
| |
| #ifndef AP_MODULE_DECLARE |
| # define AP_MODULE_DECLARE(type) type |
| #endif |
| #ifndef AP_MODULE_DECLARE_NONSTD |
| # define AP_MODULE_DECLARE_NONSTD(type) type |
| #endif |
| #ifndef AP_MODULE_DECLARE_DATA |
| # define AP_MODULE_DECLARE_DATA |
| #endif |
| |
| /** |
| * @internal |
| * modules should not used functions marked AP_CORE_DECLARE |
| */ |
| #ifndef AP_CORE_DECLARE |
| # define AP_CORE_DECLARE AP_DECLARE |
| #endif |
| /** |
| * @internal |
| * modules should not used functions marked AP_CORE_DECLARE_NONSTD |
| */ |
| |
| #ifndef AP_CORE_DECLARE_NONSTD |
| # define AP_CORE_DECLARE_NONSTD AP_DECLARE_NONSTD |
| #endif |
| |
| /** |
| * The numeric version information is broken out into fields within this |
| * structure. |
| */ |
| typedef struct { |
| int major; /**< major number */ |
| int minor; /**< minor number */ |
| int patch; /**< patch number */ |
| const char *add_string; /**< additional string like "-dev" */ |
| } ap_version_t; |
| |
| /** |
| * Return httpd's version information in a numeric form. |
| * |
| * @param version Pointer to a version structure for returning the version |
| * information. |
| */ |
| AP_DECLARE(void) ap_get_server_revision(ap_version_t *version); |
| |
| /** |
| * Get the server version string |
| * @return The server version string |
| */ |
| AP_DECLARE(const char *) ap_get_server_version(void); |
| |
| /** |
| * Add a component to the version string |
| * @param pconf The pool to allocate the component from |
| * @param component The string to add |
| */ |
| AP_DECLARE(void) ap_add_version_component(apr_pool_t *pconf, const char *component); |
| |
| /** |
| * Get the date a time that the server was built |
| * @return The server build time string |
| */ |
| AP_DECLARE(const char *) ap_get_server_built(void); |
| |
| #define DECLINED -1 /**< Module declines to handle */ |
| #define DONE -2 /**< Module has served the response completely |
| * - it's safe to die() with no more output |
| */ |
| #define OK 0 /**< Module has handled this stage. */ |
| |
| |
| /** |
| * @defgroup HTTP_Status HTTP Status Codes |
| * @{ |
| */ |
| /** |
| * The size of the static array in http_protocol.c for storing |
| * all of the potential response status-lines (a sparse table). |
| * A future version should dynamically generate the apr_table_t at startup. |
| */ |
| #define RESPONSE_CODES 57 |
| |
| #define HTTP_CONTINUE 100 |
| #define HTTP_SWITCHING_PROTOCOLS 101 |
| #define HTTP_PROCESSING 102 |
| #define HTTP_OK 200 |
| #define HTTP_CREATED 201 |
| #define HTTP_ACCEPTED 202 |
| #define HTTP_NON_AUTHORITATIVE 203 |
| #define HTTP_NO_CONTENT 204 |
| #define HTTP_RESET_CONTENT 205 |
| #define HTTP_PARTIAL_CONTENT 206 |
| #define HTTP_MULTI_STATUS 207 |
| #define HTTP_MULTIPLE_CHOICES 300 |
| #define HTTP_MOVED_PERMANENTLY 301 |
| #define HTTP_MOVED_TEMPORARILY 302 |
| #define HTTP_SEE_OTHER 303 |
| #define HTTP_NOT_MODIFIED 304 |
| #define HTTP_USE_PROXY 305 |
| #define HTTP_TEMPORARY_REDIRECT 307 |
| #define HTTP_BAD_REQUEST 400 |
| #define HTTP_UNAUTHORIZED 401 |
| #define HTTP_PAYMENT_REQUIRED 402 |
| #define HTTP_FORBIDDEN 403 |
| #define HTTP_NOT_FOUND 404 |
| #define HTTP_METHOD_NOT_ALLOWED 405 |
| #define HTTP_NOT_ACCEPTABLE 406 |
| #define HTTP_PROXY_AUTHENTICATION_REQUIRED 407 |
| #define HTTP_REQUEST_TIME_OUT 408 |
| #define HTTP_CONFLICT 409 |
| #define HTTP_GONE 410 |
| #define HTTP_LENGTH_REQUIRED 411 |
| #define HTTP_PRECONDITION_FAILED 412 |
| #define HTTP_REQUEST_ENTITY_TOO_LARGE 413 |
| #define HTTP_REQUEST_URI_TOO_LARGE 414 |
| #define HTTP_UNSUPPORTED_MEDIA_TYPE 415 |
| #define HTTP_RANGE_NOT_SATISFIABLE 416 |
| #define HTTP_EXPECTATION_FAILED 417 |
| #define HTTP_UNPROCESSABLE_ENTITY 422 |
| #define HTTP_LOCKED 423 |
| #define HTTP_FAILED_DEPENDENCY 424 |
| #define HTTP_UPGRADE_REQUIRED 426 |
| #define HTTP_INTERNAL_SERVER_ERROR 500 |
| #define HTTP_NOT_IMPLEMENTED 501 |
| #define HTTP_BAD_GATEWAY 502 |
| #define HTTP_SERVICE_UNAVAILABLE 503 |
| #define HTTP_GATEWAY_TIME_OUT 504 |
| #define HTTP_VERSION_NOT_SUPPORTED 505 |
| #define HTTP_VARIANT_ALSO_VARIES 506 |
| #define HTTP_INSUFFICIENT_STORAGE 507 |
| #define HTTP_NOT_EXTENDED 510 |
| |
| /** is the status code informational */ |
| #define ap_is_HTTP_INFO(x) (((x) >= 100)&&((x) < 200)) |
| /** is the status code OK ?*/ |
| #define ap_is_HTTP_SUCCESS(x) (((x) >= 200)&&((x) < 300)) |
| /** is the status code a redirect */ |
| #define ap_is_HTTP_REDIRECT(x) (((x) >= 300)&&((x) < 400)) |
| /** is the status code a error (client or server) */ |
| #define ap_is_HTTP_ERROR(x) (((x) >= 400)&&((x) < 600)) |
| /** is the status code a client error */ |
| #define ap_is_HTTP_CLIENT_ERROR(x) (((x) >= 400)&&((x) < 500)) |
| /** is the status code a server error */ |
| #define ap_is_HTTP_SERVER_ERROR(x) (((x) >= 500)&&((x) < 600)) |
| |
| /** should the status code drop the connection */ |
| #define ap_status_drops_connection(x) \ |
| (((x) == HTTP_BAD_REQUEST) || \ |
| ((x) == HTTP_REQUEST_TIME_OUT) || \ |
| ((x) == HTTP_LENGTH_REQUIRED) || \ |
| ((x) == HTTP_REQUEST_ENTITY_TOO_LARGE) || \ |
| ((x) == HTTP_REQUEST_URI_TOO_LARGE) || \ |
| ((x) == HTTP_INTERNAL_SERVER_ERROR) || \ |
| ((x) == HTTP_SERVICE_UNAVAILABLE) || \ |
| ((x) == HTTP_NOT_IMPLEMENTED)) |
| /** @} */ |
| /** |
| * @defgroup Methods List of Methods recognized by the server |
| * @{ |
| */ |
| /** |
| * Methods recognized (but not necessarily handled) by the server. |
| * These constants are used in bit shifting masks of size int, so it is |
| * unsafe to have more methods than bits in an int. HEAD == M_GET. |
| * This list must be tracked by the list in http_protocol.c in routine |
| * ap_method_name_of(). |
| */ |
| #define M_GET 0 /* RFC 2616: HTTP */ |
| #define M_PUT 1 /* : */ |
| #define M_POST 2 |
| #define M_DELETE 3 |
| #define M_CONNECT 4 |
| #define M_OPTIONS 5 |
| #define M_TRACE 6 /* RFC 2616: HTTP */ |
| #define M_PATCH 7 /* no rfc(!) ### remove this one? */ |
| #define M_PROPFIND 8 /* RFC 2518: WebDAV */ |
| #define M_PROPPATCH 9 /* : */ |
| #define M_MKCOL 10 |
| #define M_COPY 11 |
| #define M_MOVE 12 |
| #define M_LOCK 13 |
| #define M_UNLOCK 14 /* RFC 2518: WebDAV */ |
| #define M_VERSION_CONTROL 15 /* RFC 3253: WebDAV Versioning */ |
| #define M_CHECKOUT 16 /* : */ |
| #define M_UNCHECKOUT 17 |
| #define M_CHECKIN 18 |
| #define M_UPDATE 19 |
| #define M_LABEL 20 |
| #define M_REPORT 21 |
| #define M_MKWORKSPACE 22 |
| #define M_MKACTIVITY 23 |
| #define M_BASELINE_CONTROL 24 |
| #define M_MERGE 25 |
| #define M_INVALID 26 /* RFC 3253: WebDAV Versioning */ |
| |
| /** |
| * METHODS needs to be equal to the number of bits |
| * we are using for limit masks. |
| */ |
| #define METHODS 64 |
| |
| /** |
| * The method mask bit to shift for anding with a bitmask. |
| */ |
| #define AP_METHOD_BIT ((apr_int64_t)1) |
| /** @} */ |
| |
| |
| /** |
| * Structure for handling HTTP methods. Methods known to the server are |
| * accessed via a bitmask shortcut; extension methods are handled by |
| * an array. |
| */ |
| typedef struct ap_method_list_t ap_method_list_t; |
| struct ap_method_list_t { |
| /* The bitmask used for known methods */ |
| apr_int64_t method_mask; |
| /* the array used for extension methods */ |
| apr_array_header_t *method_list; |
| }; |
| /** |
| * @defgroup module_magic Module Magic mime types |
| * @{ |
| */ |
| /** Magic for mod_cgi[d] */ |
| #define CGI_MAGIC_TYPE "application/x-httpd-cgi" |
| /** Magic for mod_include */ |
| #define INCLUDES_MAGIC_TYPE "text/x-server-parsed-html" |
| /** Magic for mod_include */ |
| #define INCLUDES_MAGIC_TYPE3 "text/x-server-parsed-html3" |
| /** Magic for mod_dir */ |
| #define DIR_MAGIC_TYPE "httpd/unix-directory" |
| |
| /** @} */ |
| /* Just in case your linefeed isn't the one the other end is expecting. */ |
| #if !APR_CHARSET_EBCDIC |
| /** linefeed */ |
| #define LF 10 |
| /** carrige return */ |
| #define CR 13 |
| /** carrige return /Line Feed Combo */ |
| #define CRLF "\015\012" |
| #else /* APR_CHARSET_EBCDIC */ |
| /* For platforms using the EBCDIC charset, the transition ASCII->EBCDIC is done |
| * in the buff package (bread/bputs/bwrite). Everywhere else, we use |
| * "native EBCDIC" CR and NL characters. These are therefore |
| * defined as |
| * '\r' and '\n'. |
| */ |
| #define CR '\r' |
| #define LF '\n' |
| #define CRLF "\r\n" |
| #endif /* APR_CHARSET_EBCDIC */ |
| |
| /** |
| * @defgroup values_request_rec_body Possible values for request_rec.read_body |
| * @{ |
| * Possible values for request_rec.read_body (set by handling module): |
| */ |
| |
| /** Send 413 error if message has any body */ |
| #define REQUEST_NO_BODY 0 |
| /** Send 411 error if body without Content-Length */ |
| #define REQUEST_CHUNKED_ERROR 1 |
| /** If chunked, remove the chunks for me. */ |
| #define REQUEST_CHUNKED_DECHUNK 2 |
| /** @} */ |
| |
| /** |
| * @defgroup values_request_rec_used_path_info Possible values for request_rec.used_path_info |
| * @{ |
| * Possible values for request_rec.used_path_info: |
| */ |
| |
| /** Accept the path_info from the request */ |
| #define AP_REQ_ACCEPT_PATH_INFO 0 |
| /** Return a 404 error if path_info was given */ |
| #define AP_REQ_REJECT_PATH_INFO 1 |
| /** Module may chose to use the given path_info */ |
| #define AP_REQ_DEFAULT_PATH_INFO 2 |
| /** @} */ |
| |
| /* |
| * Things which may vary per file-lookup WITHIN a request --- |
| * e.g., state of MIME config. Basically, the name of an object, info |
| * about the object, and any other info we may ahve which may need to |
| * change as we go poking around looking for it (e.g., overridden by |
| * .htaccess files). |
| * |
| * Note how the default state of almost all these things is properly |
| * zero, so that allocating it with pcalloc does the right thing without |
| * a whole lot of hairy initialization... so long as we are willing to |
| * make the (fairly) portable assumption that the bit pattern of a NULL |
| * pointer is, in fact, zero. |
| */ |
| |
| /** |
| * This represents the result of calling htaccess; these are cached for |
| * each request. |
| */ |
| struct htaccess_result { |
| /** the directory to which this applies */ |
| const char *dir; |
| /** the overrides allowed for the .htaccess file */ |
| int override; |
| /** the override options allowed for the .htaccess file */ |
| int override_opts; |
| /** the configuration directives */ |
| struct ap_conf_vector_t *htaccess; |
| /** the next one, or NULL if no more; N.B. never change this */ |
| const struct htaccess_result *next; |
| }; |
| |
| /* The following four types define a hierarchy of activities, so that |
| * given a request_rec r you can write r->connection->server->process |
| * to get to the process_rec. While this reduces substantially the |
| * number of arguments that various hooks require beware that in |
| * threaded versions of the server you must consider multiplexing |
| * issues. */ |
| |
| |
| /** A structure that represents one process */ |
| typedef struct process_rec process_rec; |
| /** A structure that represents a virtual server */ |
| typedef struct server_rec server_rec; |
| /** A structure that represents one connection */ |
| typedef struct conn_rec conn_rec; |
| /** A structure that represents the current request */ |
| typedef struct request_rec request_rec; |
| |
| /* ### would be nice to not include this from httpd.h ... */ |
| /* This comes after we have defined the request_rec type */ |
| #include "apr_uri.h" |
| |
| /** A structure that represents one process */ |
| struct process_rec { |
| /** Global pool. Cleared upon normal exit */ |
| apr_pool_t *pool; |
| /** Configuration pool. Cleared upon restart */ |
| apr_pool_t *pconf; |
| /** Number of command line arguments passed to the program */ |
| int argc; |
| /** The command line arguments */ |
| const char * const *argv; |
| /** The program name used to execute the program */ |
| const char *short_name; |
| }; |
| |
| /** A structure that represents the current request */ |
| struct request_rec { |
| /** The pool associated with the request */ |
| apr_pool_t *pool; |
| /** The connection to the client */ |
| conn_rec *connection; |
| /** The virtual host for this request */ |
| server_rec *server; |
| |
| /** Pointer to the redirected request if this is an external redirect */ |
| request_rec *next; |
| /** Pointer to the previous request if this is an internal redirect */ |
| request_rec *prev; |
| |
| /** Pointer to the main request if this is a sub-request |
| * (see http_request.h) */ |
| request_rec *main; |
| |
| /* Info about the request itself... we begin with stuff that only |
| * protocol.c should ever touch... |
| */ |
| /** First line of request */ |
| char *the_request; |
| /** HTTP/0.9, "simple" request (e.g. GET /foo\n w/no headers) */ |
| int assbackwards; |
| /** A proxy request (calculated during post_read_request/translate_name) |
| * possible values PROXYREQ_NONE, PROXYREQ_PROXY, PROXYREQ_REVERSE, |
| * PROXYREQ_RESPONSE |
| */ |
| int proxyreq; |
| /** HEAD request, as opposed to GET */ |
| int header_only; |
| /** Protocol string, as given to us, or HTTP/0.9 */ |
| char *protocol; |
| /** Protocol version number of protocol; 1.1 = 1001 */ |
| int proto_num; |
| /** Host, as set by full URI or Host: */ |
| const char *hostname; |
| |
| /** Time when the request started */ |
| apr_time_t request_time; |
| |
| /** Status line, if set by script */ |
| const char *status_line; |
| /** Status line */ |
| int status; |
| |
| /* Request method, two ways; also, protocol, etc.. Outside of protocol.c, |
| * look, but don't touch. |
| */ |
| |
| /** Request method (eg. GET, HEAD, POST, etc.) */ |
| const char *method; |
| /** M_GET, M_POST, etc. */ |
| int method_number; |
| |
| /** |
| * 'allowed' is a bitvector of the allowed methods. |
| * |
| * A handler must ensure that the request method is one that |
| * it is capable of handling. Generally modules should DECLINE |
| * any request methods they do not handle. Prior to aborting the |
| * handler like this the handler should set r->allowed to the list |
| * of methods that it is willing to handle. This bitvector is used |
| * to construct the "Allow:" header required for OPTIONS requests, |
| * and HTTP_METHOD_NOT_ALLOWED and HTTP_NOT_IMPLEMENTED status codes. |
| * |
| * Since the default_handler deals with OPTIONS, all modules can |
| * usually decline to deal with OPTIONS. TRACE is always allowed, |
| * modules don't need to set it explicitly. |
| * |
| * Since the default_handler will always handle a GET, a |
| * module which does *not* implement GET should probably return |
| * HTTP_METHOD_NOT_ALLOWED. Unfortunately this means that a Script GET |
| * handler can't be installed by mod_actions. |
| */ |
| apr_int64_t allowed; |
| /** Array of extension methods */ |
| apr_array_header_t *allowed_xmethods; |
| /** List of allowed methods */ |
| ap_method_list_t *allowed_methods; |
| |
| /** byte count in stream is for body */ |
| apr_off_t sent_bodyct; |
| /** body byte count, for easy access */ |
| apr_off_t bytes_sent; |
| /** Last modified time of the requested resource */ |
| apr_time_t mtime; |
| |
| /* HTTP/1.1 connection-level features */ |
| |
| /** sending chunked transfer-coding */ |
| int chunked; |
| /** The Range: header */ |
| const char *range; |
| /** The "real" content length */ |
| apr_off_t clength; |
| |
| /** Remaining bytes left to read from the request body */ |
| apr_off_t remaining; |
| /** Number of bytes that have been read from the request body */ |
| apr_off_t read_length; |
| /** Method for reading the request body |
| * (eg. REQUEST_CHUNKED_ERROR, REQUEST_NO_BODY, |
| * REQUEST_CHUNKED_DECHUNK, etc...) */ |
| int read_body; |
| /** reading chunked transfer-coding */ |
| int read_chunked; |
| /** is client waiting for a 100 response? */ |
| unsigned expecting_100; |
| |
| /* MIME header environments, in and out. Also, an array containing |
| * environment variables to be passed to subprocesses, so people can |
| * write modules to add to that environment. |
| * |
| * The difference between headers_out and err_headers_out is that the |
| * latter are printed even on error, and persist across internal redirects |
| * (so the headers printed for ErrorDocument handlers will have them). |
| * |
| * The 'notes' apr_table_t is for notes from one module to another, with no |
| * other set purpose in mind... |
| */ |
| |
| /** MIME header environment from the request */ |
| apr_table_t *headers_in; |
| /** MIME header environment for the response */ |
| apr_table_t *headers_out; |
| /** MIME header environment for the response, printed even on errors and |
| * persist across internal redirects */ |
| apr_table_t *err_headers_out; |
| /** Array of environment variables to be used for sub processes */ |
| apr_table_t *subprocess_env; |
| /** Notes from one module to another */ |
| apr_table_t *notes; |
| |
| /* content_type, handler, content_encoding, and all content_languages |
| * MUST be lowercased strings. They may be pointers to static strings; |
| * they should not be modified in place. |
| */ |
| /** The content-type for the current request */ |
| const char *content_type; /* Break these out --- we dispatch on 'em */ |
| /** The handler string that we use to call a handler function */ |
| const char *handler; /* What we *really* dispatch on */ |
| |
| /** How to encode the data */ |
| const char *content_encoding; |
| /** Array of strings representing the content languages */ |
| apr_array_header_t *content_languages; |
| |
| /** variant list validator (if negotiated) */ |
| char *vlist_validator; |
| |
| /** If an authentication check was made, this gets set to the user name. */ |
| char *user; |
| /** If an authentication check was made, this gets set to the auth type. */ |
| char *ap_auth_type; |
| |
| /** This response can not be cached */ |
| int no_cache; |
| /** There is no local copy of this response */ |
| int no_local_copy; |
| |
| /* What object is being requested (either directly, or via include |
| * or content-negotiation mapping). |
| */ |
| |
| /** The URI without any parsing performed */ |
| char *unparsed_uri; |
| /** The path portion of the URI */ |
| char *uri; |
| /** The filename on disk corresponding to this response */ |
| char *filename; |
| /* XXX: What does this mean? Please define "canonicalize" -aaron */ |
| /** The true filename, we canonicalize r->filename if these don't match */ |
| char *canonical_filename; |
| /** The PATH_INFO extracted from this request */ |
| char *path_info; |
| /** The QUERY_ARGS extracted from this request */ |
| char *args; |
| /** ST_MODE set to zero if no such file */ |
| apr_finfo_t finfo; |
| /** A struct containing the components of URI */ |
| apr_uri_t parsed_uri; |
| |
| /** |
| * Flag for the handler to accept or reject path_info on |
| * the current request. All modules should respect the |
| * AP_REQ_ACCEPT_PATH_INFO and AP_REQ_REJECT_PATH_INFO |
| * values, while AP_REQ_DEFAULT_PATH_INFO indicates they |
| * may follow existing conventions. This is set to the |
| * user's preference upon HOOK_VERY_FIRST of the fixups. |
| */ |
| int used_path_info; |
| |
| /* Various other config info which may change with .htaccess files |
| * These are config vectors, with one void* pointer for each module |
| * (the thing pointed to being the module's business). |
| */ |
| |
| /** Options set in config files, etc. */ |
| struct ap_conf_vector_t *per_dir_config; |
| /** Notes on *this* request */ |
| struct ap_conf_vector_t *request_config; |
| |
| /** |
| * A linked list of the .htaccess configuration directives |
| * accessed by this request. |
| * N.B. always add to the head of the list, _never_ to the end. |
| * that way, a sub request's list can (temporarily) point to a parent's list |
| */ |
| const struct htaccess_result *htaccess; |
| |
| /** A list of output filters to be used for this request */ |
| struct ap_filter_t *output_filters; |
| /** A list of input filters to be used for this request */ |
| struct ap_filter_t *input_filters; |
| |
| /** A list of protocol level output filters to be used for this |
| * request */ |
| struct ap_filter_t *proto_output_filters; |
| /** A list of protocol level input filters to be used for this |
| * request */ |
| struct ap_filter_t *proto_input_filters; |
| |
| /** A flag to determine if the eos bucket has been sent yet */ |
| int eos_sent; |
| |
| /* Things placed at the end of the record to avoid breaking binary |
| * compatibility. It would be nice to remember to reorder the entire |
| * record to improve 64bit alignment the next time we need to break |
| * binary compatibility for some other reason. |
| */ |
| }; |
| |
| /** |
| * @defgroup ProxyReq Proxy request types |
| * |
| * Possible values of request_rec->proxyreq. A request could be normal, |
| * proxied or reverse proxied. Normally proxied and reverse proxied are |
| * grouped together as just "proxied", but sometimes it's necessary to |
| * tell the difference between the two, such as for authentication. |
| * @{ |
| */ |
| |
| #define PROXYREQ_NONE 0 /**< No proxy */ |
| #define PROXYREQ_PROXY 1 /**< Standard proxy */ |
| #define PROXYREQ_REVERSE 2 /**< Reverse proxy */ |
| #define PROXYREQ_RESPONSE 3 /**< Origin response */ |
| |
| /* @} */ |
| |
| typedef enum { |
| AP_CONN_UNKNOWN, |
| AP_CONN_CLOSE, |
| AP_CONN_KEEPALIVE |
| } ap_conn_keepalive_e; |
| |
| /** Structure to store things which are per connection */ |
| struct conn_rec { |
| /** Pool associated with this connection */ |
| apr_pool_t *pool; |
| /** Physical vhost this conn came in on */ |
| server_rec *base_server; |
| /** used by http_vhost.c */ |
| void *vhost_lookup_data; |
| |
| /* Information about the connection itself */ |
| /** local address */ |
| apr_sockaddr_t *local_addr; |
| /** remote address */ |
| apr_sockaddr_t *remote_addr; |
| |
| /** Client's IP address */ |
| char *remote_ip; |
| /** Client's DNS name, if known. NULL if DNS hasn't been checked, |
| * "" if it has and no address was found. N.B. Only access this though |
| * get_remote_host() */ |
| char *remote_host; |
| /** Only ever set if doing rfc1413 lookups. N.B. Only access this through |
| * get_remote_logname() */ |
| char *remote_logname; |
| |
| /** Are we still talking? */ |
| unsigned aborted:1; |
| |
| /** Are we going to keep the connection alive for another request? |
| * @see ap_conn_keepalive_e */ |
| ap_conn_keepalive_e keepalive; |
| |
| /** have we done double-reverse DNS? -1 yes/failure, 0 not yet, |
| * 1 yes/success */ |
| signed int double_reverse:2; |
| |
| /** How many times have we used it? */ |
| int keepalives; |
| /** server IP address */ |
| char *local_ip; |
| /** used for ap_get_server_name when UseCanonicalName is set to DNS |
| * (ignores setting of HostnameLookups) */ |
| char *local_host; |
| |
| /** ID of this connection; unique at any point in time */ |
| long id; |
| /** Notes on *this* connection */ |
| struct ap_conf_vector_t *conn_config; |
| /** send note from one module to another, must remain valid for all |
| * requests on this conn */ |
| apr_table_t *notes; |
| /** A list of input filters to be used for this connection */ |
| struct ap_filter_t *input_filters; |
| /** A list of output filters to be used for this connection */ |
| struct ap_filter_t *output_filters; |
| /** handle to scoreboard information for this connection */ |
| void *sbh; |
| /** The bucket allocator to use for all bucket/brigade creations */ |
| struct apr_bucket_alloc_t *bucket_alloc; |
| }; |
| |
| /* Per-vhost config... */ |
| |
| /** |
| * The address 255.255.255.255, when used as a virtualhost address, |
| * will become the "default" server when the ip doesn't match other vhosts. |
| */ |
| #define DEFAULT_VHOST_ADDR 0xfffffffful |
| |
| |
| /** A structure to be used for Per-vhost config */ |
| typedef struct server_addr_rec server_addr_rec; |
| struct server_addr_rec { |
| /** The next server in the list */ |
| server_addr_rec *next; |
| /** The bound address, for this server */ |
| apr_sockaddr_t *host_addr; |
| /** The bound port, for this server */ |
| apr_port_t host_port; |
| /** The name given in <VirtualHost> */ |
| char *virthost; |
| }; |
| |
| /** A structure to store information for each virtual server */ |
| struct server_rec { |
| /** The process this server is running in */ |
| process_rec *process; |
| /** The next server in the list */ |
| server_rec *next; |
| |
| /** The name of the server */ |
| const char *defn_name; |
| /** The line of the config file that the server was defined on */ |
| unsigned defn_line_number; |
| |
| /* Contact information */ |
| |
| /** The admin's contact information */ |
| char *server_admin; |
| /** The server hostname */ |
| char *server_hostname; |
| /** for redirects, etc. */ |
| apr_port_t port; |
| |
| /* Log files --- note that transfer log is now in the modules... */ |
| |
| /** The name of the error log */ |
| char *error_fname; |
| /** A file descriptor that references the error log */ |
| apr_file_t *error_log; |
| /** The log level for this server */ |
| int loglevel; |
| |
| /* Module-specific configuration for server, and defaults... */ |
| |
| /** true if this is the virtual server */ |
| int is_virtual; |
| /** Config vector containing pointers to modules' per-server config |
| * structures. */ |
| struct ap_conf_vector_t *module_config; |
| /** MIME type info, etc., before we start checking per-directory info */ |
| struct ap_conf_vector_t *lookup_defaults; |
| |
| /* Transaction handling */ |
| |
| /** I haven't got a clue */ |
| server_addr_rec *addrs; |
| /** Timeout, as an apr interval, before we give up */ |
| apr_interval_time_t timeout; |
| /** The apr interval we will wait for another request */ |
| apr_interval_time_t keep_alive_timeout; |
| /** Maximum requests per connection */ |
| int keep_alive_max; |
| /** Use persistent connections? */ |
| int keep_alive; |
| |
| /** Pathname for ServerPath */ |
| const char *path; |
| /** Length of path */ |
| int pathlen; |
| |
| /** Normal names for ServerAlias servers */ |
| apr_array_header_t *names; |
| /** Wildcarded names for ServerAlias servers */ |
| apr_array_header_t *wild_names; |
| |
| /** limit on size of the HTTP request line */ |
| int limit_req_line; |
| /** limit on size of any request header field */ |
| int limit_req_fieldsize; |
| /** limit on number of request header fields */ |
| int limit_req_fields; |
| }; |
| |
| typedef struct core_output_filter_ctx { |
| apr_bucket_brigade *b; |
| apr_pool_t *deferred_write_pool; /* subpool of c->pool used for resources |
| * which may outlive the request |
| */ |
| } core_output_filter_ctx_t; |
| |
| typedef struct core_filter_ctx { |
| apr_bucket_brigade *b; |
| } core_ctx_t; |
| |
| typedef struct core_net_rec { |
| /** Connection to the client */ |
| apr_socket_t *client_socket; |
| |
| /** connection record */ |
| conn_rec *c; |
| |
| core_output_filter_ctx_t *out_ctx; |
| core_ctx_t *in_ctx; |
| } core_net_rec; |
| |
| /** |
| * Examine a field value (such as a media-/content-type) string and return |
| * it sans any parameters; e.g., strip off any ';charset=foo' and the like. |
| * @param p Pool to allocate memory from |
| * @param intype The field to examine |
| * @return A copy of the field minus any parameters |
| */ |
| AP_DECLARE(char *) ap_field_noparam(apr_pool_t *p, const char *intype); |
| |
| /** |
| * Convert a time from an integer into a string in a specified format |
| * @param p The pool to allocate memory from |
| * @param t The time to convert |
| * @param fmt The format to use for the conversion |
| * @param gmt Convert the time for GMT? |
| * @return The string that represents the specified time |
| */ |
| AP_DECLARE(char *) ap_ht_time(apr_pool_t *p, apr_time_t t, const char *fmt, int gmt); |
| |
| /* String handling. The *_nc variants allow you to use non-const char **s as |
| arguments (unfortunately C won't automatically convert a char ** to a const |
| char **) */ |
| |
| /** |
| * Get the characters until the first occurance of a specified character |
| * @param p The pool to allocate memory from |
| * @param line The string to get the characters from |
| * @param stop The character to stop at |
| * @return A copy of the characters up to the first stop character |
| */ |
| AP_DECLARE(char *) ap_getword(apr_pool_t *p, const char **line, char stop); |
| /** |
| * Get the characters until the first occurance of a specified character |
| * @param p The pool to allocate memory from |
| * @param line The string to get the characters from |
| * @param stop The character to stop at |
| * @return A copy of the characters up to the first stop character |
| * @note This is the same as ap_getword(), except it doesn't use const char **. |
| */ |
| AP_DECLARE(char *) ap_getword_nc(apr_pool_t *p, char **line, char stop); |
| |
| /** |
| * Get the first word from a given string. A word is defined as all characters |
| * up to the first whitespace. |
| * @param p The pool to allocate memory from |
| * @param line The string to traverse |
| * @return The first word in the line |
| */ |
| AP_DECLARE(char *) ap_getword_white(apr_pool_t *p, const char **line); |
| /** |
| * Get the first word from a given string. A word is defined as all characters |
| * up to the first whitespace. |
| * @param p The pool to allocate memory from |
| * @param line The string to traverse |
| * @return The first word in the line |
| * @note The same as ap_getword_white(), except it doesn't use const char **. |
| */ |
| AP_DECLARE(char *) ap_getword_white_nc(apr_pool_t *p, char **line); |
| |
| /** |
| * Get all characters from the first occurance of @a stop to the first '\0' |
| * @param p The pool to allocate memory from |
| * @param line The line to traverse |
| * @param stop The character to start at |
| * @return A copy of all caracters after the first occurance of the specified |
| * character |
| */ |
| AP_DECLARE(char *) ap_getword_nulls(apr_pool_t *p, const char **line, |
| char stop); |
| /** |
| * Get all characters from the first occurance of @a stop to the first '\0' |
| * @param p The pool to allocate memory from |
| * @param line The line to traverse |
| * @param stop The character to start at |
| * @return A copy of all caracters after the first occurance of the specified |
| * character |
| * @note The same as ap_getword_nulls(), except it doesn't use const char **. |
| */ |
| AP_DECLARE(char *) ap_getword_nulls_nc(apr_pool_t *p, char **line, char stop); |
| |
| /** |
| * Get the second word in the string paying attention to quoting |
| * @param p The pool to allocate from |
| * @param line The line to traverse |
| * @return A copy of the string |
| */ |
| AP_DECLARE(char *) ap_getword_conf(apr_pool_t *p, const char **line); |
| /** |
| * Get the second word in the string paying attention to quoting |
| * @param p The pool to allocate from |
| * @param line The line to traverse |
| * @return A copy of the string |
| * @note The same as ap_getword_conf(), except it doesn't use const char **. |
| */ |
| AP_DECLARE(char *) ap_getword_conf_nc(apr_pool_t *p, char **line); |
| |
| /** |
| * Check a string for any ${ENV} environment variable construct and replace |
| * each them by the value of that environment variable, if it exists. If the |
| * environment value does not exist, leave the ${ENV} construct alone; it |
| * means something else. |
| * @param p The pool to allocate from |
| * @param word The string to check |
| * @return The string with the replaced environment variables |
| */ |
| AP_DECLARE(const char *) ap_resolve_env(apr_pool_t *p, const char * word); |
| |
| /** |
| * Size an HTTP header field list item, as separated by a comma. |
| * @param field The field to size |
| * @param len The length of the field |
| * @return The return value is a pointer to the beginning of the non-empty |
| * list item within the original string (or NULL if there is none) and the |
| * address of field is shifted to the next non-comma, non-whitespace |
| * character. len is the length of the item excluding any beginning whitespace. |
| */ |
| AP_DECLARE(const char *) ap_size_list_item(const char **field, int *len); |
| |
| /** |
| * Retrieve an HTTP header field list item, as separated by a comma, |
| * while stripping insignificant whitespace and lowercasing anything not in |
| * a quoted string or comment. |
| * @param p The pool to allocate from |
| * @param field The field to retrieve |
| * @return The return value is a new string containing the converted list |
| * item (or NULL if none) and the address pointed to by field is |
| * shifted to the next non-comma, non-whitespace. |
| */ |
| AP_DECLARE(char *) ap_get_list_item(apr_pool_t *p, const char **field); |
| |
| /** |
| * Find an item in canonical form (lowercase, no extra spaces) within |
| * an HTTP field value list. |
| * @param p The pool to allocate from |
| * @param line The field value list to search |
| * @param tok The token to search for |
| * @return 1 if found, 0 if not found. |
| */ |
| AP_DECLARE(int) ap_find_list_item(apr_pool_t *p, const char *line, const char *tok); |
| |
| /** |
| * Retrieve a token, spacing over it and adjusting the pointer to |
| * the first non-white byte afterwards. Note that these tokens |
| * are delimited by semis and commas and can also be delimited |
| * by whitespace at the caller's option. |
| * @param p The pool to allocate from |
| * @param accept_line The line to retrieve the token from (adjusted afterwards) |
| * @param accept_white Is it delimited by whitespace |
| * @return the token |
| */ |
| AP_DECLARE(char *) ap_get_token(apr_pool_t *p, const char **accept_line, int accept_white); |
| |
| /** |
| * Find http tokens, see the definition of token from RFC2068 |
| * @param p The pool to allocate from |
| * @param line The line to find the token |
| * @param tok The token to find |
| * @return 1 if the token is found, 0 otherwise |
| */ |
| AP_DECLARE(int) ap_find_token(apr_pool_t *p, const char *line, const char *tok); |
| |
| /** |
| * find http tokens from the end of the line |
| * @param p The pool to allocate from |
| * @param line The line to find the token |
| * @param tok The token to find |
| * @return 1 if the token is found, 0 otherwise |
| */ |
| AP_DECLARE(int) ap_find_last_token(apr_pool_t *p, const char *line, const char *tok); |
| |
| /** |
| * Check for an Absolute URI syntax |
| * @param u The string to check |
| * @return 1 if URI, 0 otherwise |
| */ |
| AP_DECLARE(int) ap_is_url(const char *u); |
| |
| /** |
| * Unescape a URL |
| * @param url The url to unescape |
| * @return 0 on success, non-zero otherwise |
| */ |
| AP_DECLARE(int) ap_unescape_url(char *url); |
| /** |
| * Unescape a URL, but leaving %2f (slashes) escaped |
| * @param url The url to unescape |
| * @return 0 on success, non-zero otherwise |
| */ |
| AP_DECLARE(int) ap_unescape_url_keep2f(char *url); |
| /** |
| * Convert all double slashes to single slashes |
| * @param name The string to convert |
| */ |
| AP_DECLARE(void) ap_no2slash(char *name); |
| |
| /** |
| * Remove all ./ and xx/../ substrings from a file name. Also remove |
| * any leading ../ or /../ substrings. |
| * @param name the file name to parse |
| */ |
| AP_DECLARE(void) ap_getparents(char *name); |
| |
| /** |
| * Escape a path segment, as defined in RFC 1808 |
| * @param p The pool to allocate from |
| * @param s The path to convert |
| * @return The converted URL |
| */ |
| AP_DECLARE(char *) ap_escape_path_segment(apr_pool_t *p, const char *s); |
| /** |
| * convert an OS path to a URL in an OS dependant way. |
| * @param p The pool to allocate from |
| * @param path The path to convert |
| * @param partial if set, assume that the path will be appended to something |
| * with a '/' in it (and thus does not prefix "./") |
| * @return The converted URL |
| */ |
| AP_DECLARE(char *) ap_os_escape_path(apr_pool_t *p, const char *path, int partial); |
| /** @see ap_os_escape_path */ |
| #define ap_escape_uri(ppool,path) ap_os_escape_path(ppool,path,1) |
| |
| /** |
| * Escape an html string |
| * @param p The pool to allocate from |
| * @param s The html to escape |
| * @return The escaped string |
| */ |
| AP_DECLARE(char *) ap_escape_html(apr_pool_t *p, const char *s); |
| |
| /** |
| * Escape a string for logging |
| * @param p The pool to allocate from |
| * @param str The string to escape |
| * @return The escaped string |
| */ |
| AP_DECLARE(char *) ap_escape_logitem(apr_pool_t *p, const char *str); |
| |
| /** |
| * Escape a string for logging into the error log (without a pool) |
| * @param dest The buffer to write to |
| * @param source The string to escape |
| * @param buflen The buffer size for the escaped string (including \0) |
| * @return The len of the escaped string (always < maxlen) |
| */ |
| AP_DECLARE(apr_size_t) ap_escape_errorlog_item(char *dest, const char *source, |
| apr_size_t buflen); |
| |
| /** |
| * Construct a full hostname |
| * @param p The pool to allocate from |
| * @param hostname The hostname of the server |
| * @param port The port the server is running on |
| * @param r The current request |
| * @return The server's hostname |
| */ |
| AP_DECLARE(char *) ap_construct_server(apr_pool_t *p, const char *hostname, |
| apr_port_t port, const request_rec *r); |
| /** |
| * Escape a shell command |
| * @param p The pool to allocate from |
| * @param s The command to escape |
| * @return The escaped shell command |
| */ |
| AP_DECLARE(char *) ap_escape_shell_cmd(apr_pool_t *p, const char *s); |
| |
| /** |
| * Count the number of directories in a path |
| * @param path The path to count |
| * @return The number of directories |
| */ |
| AP_DECLARE(int) ap_count_dirs(const char *path); |
| |
| /** |
| * Copy at most @a n leading directories of @a s into @a d. @a d |
| * should be at least as large as @a s plus 1 extra byte |
| * |
| * @param d The location to copy to |
| * @param s The location to copy from |
| * @param n The number of directories to copy |
| * @return value is the ever useful pointer to the trailing \0 of d |
| * @note on platforms with drive letters, n = 0 returns the "/" root, |
| * whereas n = 1 returns the "d:/" root. On all other platforms, n = 0 |
| * returns the empty string. */ |
| AP_DECLARE(char *) ap_make_dirstr_prefix(char *d, const char *s, int n); |
| |
| /** |
| * Return the parent directory name (including trailing /) of the file |
| * @a s |
| * @param p The pool to allocate from |
| * @param s The file to get the parent of |
| * @return A copy of the file's parent directory |
| */ |
| AP_DECLARE(char *) ap_make_dirstr_parent(apr_pool_t *p, const char *s); |
| |
| /** |
| * Given a directory and filename, create a single path from them. This |
| * function is smart enough to ensure that there is a sinlge '/' between the |
| * directory and file names |
| * @param a The pool to allocate from |
| * @param dir The directory name |
| * @param f The filename |
| * @return A copy of the full path |
| * @tip Never consider using this function if you are dealing with filesystem |
| * names that need to remain canonical, unless you are merging an apr_dir_read |
| * path and returned filename. Otherwise, the result is not canonical. |
| */ |
| AP_DECLARE(char *) ap_make_full_path(apr_pool_t *a, const char *dir, const char *f); |
| |
| /** |
| * Test if the given path has an an absolute path. |
| * @param p The pool to allocate from |
| * @param dir The directory name |
| * @tip The converse is not necessarily true, some OS's (Win32/OS2/Netware) have |
| * multiple forms of absolute paths. This only reports if the path is absolute |
| * in a canonical sense. |
| */ |
| AP_DECLARE(int) ap_os_is_path_absolute(apr_pool_t *p, const char *dir); |
| |
| /** |
| * Does the provided string contain wildcard characters? This is useful |
| * for determining if the string should be passed to strcmp_match or to strcmp. |
| * The only wildcard characters recognized are '?' and '*' |
| * @param str The string to check |
| * @return 1 if the string has wildcards, 0 otherwise |
| */ |
| AP_DECLARE(int) ap_is_matchexp(const char *str); |
| |
| /** |
| * Determine if a string matches a patterm containing the wildcards '?' or '*' |
| * @param str The string to check |
| * @param expected The pattern to match against |
| * @return 1 if the two strings match, 0 otherwise |
| */ |
| AP_DECLARE(int) ap_strcmp_match(const char *str, const char *expected); |
| /** |
| * Determine if a string matches a patterm containing the wildcards '?' or '*', |
| * ignoring case |
| * @param str The string to check |
| * @param expected The pattern to match against |
| * @return 1 if the two strings match, 0 otherwise |
| */ |
| AP_DECLARE(int) ap_strcasecmp_match(const char *str, const char *expected); |
| |
| /** |
| * Find the first occurrence of the substring s2 in s1, regardless of case |
| * @param s1 The string to search |
| * @param s2 The substring to search for |
| * @return A pointer to the beginning of the substring |
| * @remark See apr_strmatch() for a faster alternative |
| */ |
| AP_DECLARE(char *) ap_strcasestr(const char *s1, const char *s2); |
| |
| /** |
| * Return a pointer to the location inside of bigstring immediately after prefix |
| * @param bigstring The input string |
| * @param prefix The prefix to strip away |
| * @return A pointer relative to bigstring after prefix |
| */ |
| AP_DECLARE(const char *) ap_stripprefix(const char *bigstring, |
| const char *prefix); |
| |
| /** |
| * Decode a base64 encoded string into memory allocated from a pool |
| * @param p The pool to allocate from |
| * @param bufcoded The encoded string |
| * @return The decoded string |
| */ |
| AP_DECLARE(char *) ap_pbase64decode(apr_pool_t *p, const char *bufcoded); |
| |
| /** |
| * Encode a string into memory allocated from a pool in base 64 format |
| * @param p The pool to allocate from |
| * @param strin The plaintext string |
| * @return The encoded string |
| */ |
| AP_DECLARE(char *) ap_pbase64encode(apr_pool_t *p, char *string); |
| |
| |
| /** |
| * Compile a regular expression to be used later |
| * @param p The pool to allocate from |
| * @param pattern the regular expression to compile |
| * @param cflags The bitwise or of one or more of the following: |
| * @li #REG_EXTENDED - Use POSIX extended Regular Expressions |
| * @li #REG_ICASE - Ignore case |
| * @li #REG_NOSUB - Support for substring addressing of matches |
| * not required |
| * @li #REG_NEWLINE - Match-any-character operators don't match new-line |
| * @return The compiled regular expression |
| */ |
| AP_DECLARE(regex_t *) ap_pregcomp(apr_pool_t *p, const char *pattern, |
| int cflags); |
| |
| /** |
| * Free the memory associated with a compiled regular expression |
| * @param p The pool the regex was allocated from |
| * @param reg The regular expression to free |
| */ |
| AP_DECLARE(void) ap_pregfree(apr_pool_t *p, regex_t *reg); |
| |
| /** |
| * Match a null-terminated string against a pre-compiled regex. |
| * @param preg The pre-compiled regex |
| * @param string The string to match |
| * @param nmatch Provide information regarding the location of any matches |
| * @param pmatch Provide information regarding the location of any matches |
| * @param eflags Bitwise or of any of: |
| * @li #REG_NOTBOL - match-beginning-of-line operator always |
| * fails to match |
| * @li #REG_NOTEOL - match-end-of-line operator always fails to match |
| * @return 0 for successful match, #REG_NOMATCH otherwise |
| */ |
| AP_DECLARE(int) ap_regexec(regex_t *preg, const char *string, |
| size_t nmatch, regmatch_t pmatch[], int eflags); |
| |
| /** |
| * Return the error code returned by regcomp or regexec into error messages |
| * @param errcode the error code returned by regexec or regcomp |
| * @param preg The precompiled regex |
| * @param errbuf A buffer to store the error in |
| * @param errbuf_size The size of the buffer |
| */ |
| AP_DECLARE(size_t) ap_regerror(int errcode, const regex_t *preg, |
| char *errbuf, size_t errbuf_size); |
| |
| /** |
| * After performing a successful regex match, you may use this function to |
| * perform a series of string substitutions based on subexpressions that were |
| * matched during the call to ap_regexec |
| * @param p The pool to allocate from |
| * @param input An arbitrary string containing $1 through $9. These are |
| * replaced with the corresponding matched sub-expressions |
| * @param source The string that was originally matched to the regex |
| * @param nmatch the nmatch returned from ap_pregex |
| * @param pmatch the pmatch array returned from ap_pregex |
| */ |
| AP_DECLARE(char *) ap_pregsub(apr_pool_t *p, const char *input, const char *source, |
| size_t nmatch, regmatch_t pmatch[]); |
| |
| /** |
| * We want to downcase the type/subtype for comparison purposes |
| * but nothing else because ;parameter=foo values are case sensitive. |
| * @param s The content-type to convert to lowercase |
| */ |
| AP_DECLARE(void) ap_content_type_tolower(char *s); |
| |
| /** |
| * convert a string to all lowercase |
| * @param s The string to convert to lowercase |
| */ |
| AP_DECLARE(void) ap_str_tolower(char *s); |
| |
| /** |
| * Search a string from left to right for the first occurrence of a |
| * specific character |
| * @param str The string to search |
| * @param c The character to search for |
| * @return The index of the first occurrence of c in str |
| */ |
| AP_DECLARE(int) ap_ind(const char *str, char c); /* Sigh... */ |
| |
| /** |
| * Search a string from right to left for the first occurrence of a |
| * specific character |
| * @param str The string to search |
| * @param c The character to search for |
| * @return The index of the first occurrence of c in str |
| */ |
| AP_DECLARE(int) ap_rind(const char *str, char c); |
| |
| /** |
| * Given a string, replace any bare " with \" . |
| * @param p The pool to allocate memory from |
| * @param instring The string to search for " |
| * @return A copy of the string with escaped quotes |
| */ |
| AP_DECLARE(char *) ap_escape_quotes(apr_pool_t *p, const char *instring); |
| |
| /* Misc system hackery */ |
| /** |
| * Given the name of an object in the file system determine if it is a directory |
| * @param p The pool to allocate from |
| * @param name The name of the object to check |
| * @return 1 if it is a directory, 0 otherwise |
| */ |
| AP_DECLARE(int) ap_is_rdirectory(apr_pool_t *p, const char *name); |
| |
| /** |
| * Given the name of an object in the file system determine if it is a directory - this version is symlink aware |
| * @param p The pool to allocate from |
| * @param name The name of the object to check |
| * @return 1 if it is a directory, 0 otherwise |
| */ |
| AP_DECLARE(int) ap_is_directory(apr_pool_t *p, const char *name); |
| |
| #ifdef _OSD_POSIX |
| extern int os_init_job_environment(server_rec *s, const char *user_name, int one_process); |
| #endif /* _OSD_POSIX */ |
| |
| /** |
| * Determine the local host name for the current machine |
| * @param p The pool to allocate from |
| * @return A copy of the local host name |
| */ |
| char *ap_get_local_host(apr_pool_t *p); |
| |
| /** |
| * Log an assertion to the error log |
| * @param szExp The assertion that failed |
| * @param szFile The file the assertion is in |
| * @param nLine The line the assertion is defined on |
| */ |
| AP_DECLARE(void) ap_log_assert(const char *szExp, const char *szFile, int nLine) |
| __attribute__((noreturn)); |
| |
| /** @internal */ |
| #define ap_assert(exp) ((exp) ? (void)0 : ap_log_assert(#exp,__FILE__,__LINE__)) |
| |
| /** |
| * Redefine assert() to something more useful for an Apache... |
| * |
| * Use ap_assert() if the condition should always be checked. |
| * Use AP_DEBUG_ASSERT() if the condition should only be checked when AP_DEBUG |
| * is defined. |
| */ |
| |
| #ifdef AP_DEBUG |
| #define AP_DEBUG_ASSERT(exp) ap_assert(exp) |
| #else |
| #define AP_DEBUG_ASSERT(exp) ((void)0) |
| #endif |
| |
| /** |
| * @defgroup stopsignal flags which indicate places where the sever should stop for debugging. |
| * @{ |
| * A set of flags which indicate places where the server should raise(SIGSTOP). |
| * This is useful for debugging, because you can then attach to that process |
| * with gdb and continue. This is important in cases where one_process |
| * debugging isn't possible. |
| */ |
| /** stop on a Detach */ |
| #define SIGSTOP_DETACH 1 |
| /** stop making a child process */ |
| #define SIGSTOP_MAKE_CHILD 2 |
| /** stop spawning a child process */ |
| #define SIGSTOP_SPAWN_CHILD 4 |
| /** stop spawning a child process with a piped log */ |
| #define SIGSTOP_PIPED_LOG_SPAWN 8 |
| /** stop spawning a CGI child process */ |
| #define SIGSTOP_CGI_CHILD 16 |
| |
| /** Macro to get GDB started */ |
| #ifdef DEBUG_SIGSTOP |
| extern int raise_sigstop_flags; |
| #define RAISE_SIGSTOP(x) do { \ |
| if (raise_sigstop_flags & SIGSTOP_##x) raise(SIGSTOP);\ |
| } while (0) |
| #else |
| #define RAISE_SIGSTOP(x) |
| #endif |
| /** @} */ |
| /** |
| * Get HTML describing the address and (optionally) admin of the server. |
| * @param prefix Text which is prepended to the return value |
| * @param r The request_rec |
| * @return HTML describing the server, allocated in @a r's pool. |
| */ |
| AP_DECLARE(const char *) ap_psignature(const char *prefix, request_rec *r); |
| |
| /** strtoul does not exist on sunos4. */ |
| #ifdef strtoul |
| #undef strtoul |
| #endif |
| #define strtoul strtoul_is_not_a_portable_function_use_strtol_instead |
| |
| /* The C library has functions that allow const to be silently dropped ... |
| these macros detect the drop in maintainer mode, but use the native |
| methods for normal builds |
| |
| Note that on some platforms (e.g., AIX with gcc, Solaris with gcc), string.h needs |
| to be included before the macros are defined or compilation will fail. |
| */ |
| #include <string.h> |
| |
| AP_DECLARE(char *) ap_strchr(char *s, int c); |
| AP_DECLARE(const char *) ap_strchr_c(const char *s, int c); |
| AP_DECLARE(char *) ap_strrchr(char *s, int c); |
| AP_DECLARE(const char *) ap_strrchr_c(const char *s, int c); |
| AP_DECLARE(char *) ap_strstr(char *s, const char *c); |
| AP_DECLARE(const char *) ap_strstr_c(const char *s, const char *c); |
| |
| #ifdef AP_DEBUG |
| |
| #undef strchr |
| # define strchr(s, c) ap_strchr(s,c) |
| #undef strrchr |
| # define strrchr(s, c) ap_strrchr(s,c) |
| #undef strstr |
| # define strstr(s, c) ap_strstr(s,c) |
| |
| #else |
| |
| /** use this instead of strchr */ |
| # define ap_strchr(s, c) strchr(s, c) |
| /** use this instead of strchr */ |
| # define ap_strchr_c(s, c) strchr(s, c) |
| /** use this instead of strrchr */ |
| # define ap_strrchr(s, c) strrchr(s, c) |
| /** use this instead of strrchr */ |
| # define ap_strrchr_c(s, c) strrchr(s, c) |
| /** use this instead of strrstr*/ |
| # define ap_strstr(s, c) strstr(s, c) |
| /** use this instead of strrstr*/ |
| # define ap_strstr_c(s, c) strstr(s, c) |
| |
| #endif |
| |
| #define AP_NORESTART APR_OS_START_USEERR + 1 |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* !APACHE_HTTPD_H */ |