httpd.h revision 8a261a9f7d18d1e862d63f68e93f288d3e1f0d94
/* Define this to be what your per-directory security files are called */ /* Set default for OS/2 file system */ #
endif /* DEFAULT_ACCESS_FNAME *//* The name of the server config file */ /* Whether we should enable rfc1413 identity checking */ /* The default path for CGI scripts if none is currently set */ /* The path to the suExec wrapper, can be overridden in Configuration */ /* The timeout for waiting for messages */ /* The timeout for waiting for keepalive timeout until next request */ /* The number of requests to entertain per connection */ /* The maximum length of the queue of pending connections, as defined * by listen(2). Under some systems, it should be increased if you * are experiencing a heavy TCP SYN flood attack. * It defaults to 511 instead of 512 because some systems store it * as an 8-bit datatype; 512 truncated to 8-bits is 0, while 511 is /* 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. #
endif /* default limit on bytes in Request-Line (Method+URI+HTTP-version) */#
endif /* default limit on bytes in any one header field */#
endif /* default limit on number of request header fields */ * The default default character set name to add if AddDefaultCharset is * enabled. Overridden with AddDefaultCharsetName. * The below defines the base string of the Server: header. Additional * tokens can be added via the ap_add_version_component() API call. * The tokens are listed in order of their significance for identifying the * "Product tokens should be short and to the point -- use of them for * advertizing or other non-essential information is explicitly forbidden." * Example: "Apache/1.1.0 MrWidget/0.1-alpha" /* Define this to 1 if you want fancy indexing, 0 otherwise */ #
endif /* CORE_PRIVATE *//* ------------------ stuff that modules are allowed to look at ----------- */ /* Define this to be what your HTML directory content files are called */ /* Define this to be what type you'd like returned for files with unknown */ /* suffixes. MUST be all lower case. */ /* The name of the MIME types file */ * Define the HTML doctype strings centrally. "DTD HTML 3.2 Final//EN\">\n" "DTD HTML 4.0 Transitional//EN\"\n" \
"DTD HTML 4.0 Frameset//EN\"\n" \
/* -- Internal representation for a HTTP protocol number, e.g., HTTP/1.1 -- */ /* -------------- Port number for server running standalone --------------- */ /* The default string lengths */ /* The size of the server's internal read-write buffers */ * Special Apache error codes. These are basically used * in http_main.c so we can keep track of various errors. * A fatal error arising during the server's init sequence * The child died during it's init sequence * 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. * Get the server version string * @return The server version string * @deffunc const char *ap_get_server_version(void) * Add a component to the version string * @param pconf The pool to allocate the component out of * @param component The string to add * @deffunc 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 /* Numeric release version identifier: MMNNFFRBB: major minor fix final beta * Always increases along the same track as the source branch. * For example, Apache 1.4.2 would be '10402100', 2.5b7 would be '20500007'. #
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. *//* ----------------------- HTTP Status Codes ------------------------- */ * all of the potential response status-lines (a sparse table). * A future version should dynamically generate the apr_table_t at startup. /* 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. * Structure for handling HTTP methods. Methods known to the server are * accessed via a bitmask shortcut; extension methods are handled by /* The bitmask used for known methods */ /* The array used for extension methods */ /* Just in case your linefeed isn't the one the other end is expecting. */ #
else /* CHARSET_EBCDIC *//* For platforms using the EBCDIC charset, the transition ASCII->EBCDIC is done * "native EBCDIC" CR and NL characters. These are therefore #
endif /* CHARSET_EBCDIC *//* Possible values for request_rec.read_body (set by handling module): * REQUEST_NO_BODY Send 413 error if message has any body * REQUEST_CHUNKED_ERROR Send 411 error if body without Content-Length * REQUEST_CHUNKED_DECHUNK If chunked, remove the chunks for me. /* 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 * 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 /** the directory to which this applies */ /** the overrides allowed for the .htaccess file */ /** the configuration directives */ /** the next one, or NULL if no more; N.B. never change this */ /* 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 /** A structure that represents one process */ /** Global pool. Please try to cleared on _all_ exits */ /** aka configuration pool, cleared on restarts */ /** How many command line arguments were pass to the program */ /** The command line arguments */ const char *
const *
argv;
/** The program name used to execute the program */ /** A structure that represents the current request */ /** The pool associated with the request */ /** The connection over which this connection has been read */ /** The virtual host this request is for */ /** If we wind up getting redirected, pointer to the request we /** If this is an internal redirect, pointer to where we redirected /** If this is a sub_request (see request.h) pointer back to the /* Info about the request itself... we begin with stuff that only /** First line of request, so we can log it */ /** HTTP/0.9, "simple" request */ /** HEAD request, as opposed to GET */ /** Protocol, as given to us, or HTTP/0.9 */ /** Number version of protocol; 1.1 = 1001 */ /** Host, as set by full URI or Host: */ /** When the request started */ /** Status line, if set by script */ /* Request method, two ways; also, protocol, etc.. Outside of protocol.c, /** GET, HEAD, POST, etc. */ /** M_GET, M_POST, etc. */ * 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. </PRE> /** Allowed methods - for 405, OPTIONS, etc */ /** Array of extension methods */ /** List of allowed methods */ /** byte count in stream is for body */ /** body byte count, for easy access */ /** Time the resource was last modified */ /* HTTP/1.1 connection-level features */ /** sending chunked transfer-coding */ /** The "real" content length */ /** bytes left to read */ /** bytes that have been read */ /** how the request body should be read */ /** reading chunked transfer-coding */ /** is client waiting for a 100 response? */ /* 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 */ /** MIME header environment for the response */ /** MIME header environment for the response, printed even on errors and * persist across internal redirects */ /** Array of environment variables to be used for sub processes */ /** Notes from one module to another */ /* content_type, handler, content_encoding, content_language, 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 */ /** for back-compat. only -- do not use */ /** array of (char*) representing the content languages */ /** variant list validator (if negotiated) */ /** If an authentication check was made, this gets set to the user name. */ /** If an authentication check was made, this gets set to the auth type. */ /** This response is non-cache-able */ /** There is no local copy of this response */ /* What object is being requested (either directly, or via include * or content-negotiation mapping). /** the uri without any parsing performed */ /** the path portion of the URI */ /** The filename on disk that this response corresponds to */ /** The path_info for this request if there is any. */ /** QUERY_ARGS, if any */ /** ST_MODE set to zero if no such file */ /** components of uri, dismantled */ /* 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. */ /** Notes on *this* request */ * a linked list of the configuration directives in the .htaccess files * 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 * @defvar const htaccess_result *htaccess /** A list of output filters to be used for this request * @defvar ap_filter_t *output_filters */ /** A list of input filters to be used for this request * @defvar ap_filter_t *input_filters */ /** A flag to determine if the eos bucket has been sent yet * @defvar 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. /** Structure to store things which are per connection */ /** Pool associated with this connection */ /** Physical vhost this conn come in on */ /* Information about the connection itself */ /** Connection to the client */ /** Client's IP address */ /** 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 /** Only ever set if doing rfc1413 lookups. N.B. Only access this through * get_remote_logname() */ /** Are we still talking? */ /** Are we using HTTP Keep-Alive? -1 fatal error, 0 undecided, 1 yes */ /** Did we use HTTP Keep-Alive? */ /** have we done double-reverse DNS? -1 yes/failure, 0 not yet, /** How many times have we used it? */ /** used for ap_get_server_name when UseCanonicalName is set to DNS * (ignores setting of HostnameLookups) */ /** ID of this connection; unique at any point in time */ /** Notes on *this* connection */ /** send note from one module to another, must remain valid for all * requests on this conn */ /** A list of input filters to be used for this connection * @defvar ap_filter_t *input_filters */ /** A list of output filters to be used for this connection * @defvar ap_filter_t *filters */ /** The length of the current request body /* 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. /** A structure to be used for Per-vhost config */ /** The next server in the list */ /** The bound address, for this server */ /** The bound port, for this server */ /** The name given in <VirtualHost> */ /** A structure to store information for each virtual server */ /** The process this server is running in */ /** The next server in the list */ /** The name of the server */ /** The line of the config file that the server was defined on */ /* Contact information */ /** The admin's contact information */ /** The server hostname */ /** for redirects, etc. */ /* Log files --- note that transfer log is now in the modules... */ /** The name of the error log */ /** A file descriptor that references the error log */ /** The log level for this server */ /* Module-specific configuration for server, and defaults... */ /** true if this is the virtual server */ /** Config vector containing pointers to modules' per-server config /** MIME type info, etc., before we start checking per-directory info */ /* Transaction handling */ /** I haven't got a clue */ /** Timeout, in seconds, before we give up */ /** Seconds we'll wait for another request */ /** Maximum requests per connection */ /** Use persistent connections? */ /** Pathname for ServerPath */ /** Normal names for ServerAlias servers */ /** Wildcarded names for ServerAlias servers */ /** limit on size of the HTTP request line */ /** limit on size of any request header field */ /** limit on number of request header fields */ /* stuff marked AP_DECLARE is part of the API, and intended for use /* 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. /* modules should not used functions marked AP_CORE_DECLARE * or AP_CORE_DECLARE_NONSTD */ /* On Mac OS X Server, symbols that conflict with loaded dylibs * (eg. System framework) need to be declared as private symbols with * For other systems, make that a no-op. * it sans any parameters; e.g., strip off any ';charset=foo' and the like. * @param p Pool to allocate memory out of * @param intype The field to examine * @return the field minus any parameters * @deffunc 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 out of * @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 * @deffunc 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 * Get the characters until the first occurance of a specified character * @param p The pool to allocate memory out of * @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 * @deffunc 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 out of * @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 * @tip This is the same as ap_getword, except it doesn't use const char **. * @deffunc 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 * @retrn The first word in the line * @deffunc 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 * @retrn The first word in the line * @tip The same as ap_getword_white, except it doesn't use const char **. * @deffunc char *ap_getword_white_nc(apr_pool_t *p, const char **line) * Get all characters from the first occurance of stop to the first '\0' * @param p The pool to allocate memory out of * @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 * @deffunc char *ap_getword_nulls(apr_pool_t *p, const char **line, char stop) * Get all characters from the first occurance of stop to the first '\0' * @param p The pool to allocate memory out of * @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 * @tip The same as ap_getword_nulls, except it doesn't use const char **. * @deffunc 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 out of * @param line The line to traverse * @return A copy of the string * @deffunc 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 out of * @param line The line to traverse * @return A copy of the string * @tip The same as ap_getword_conf, except it doesn't use const char **. * @deffunc 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 * @param p The pool to allocate out of * @param word The string to check * @return The string with the replaced environment variables * @deffunc 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. * @deffunc 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 out of * @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. * @deffunc 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 out of * @param line The field value list to search * @param tok The token to search for * @return 1 if found, 0 if not found. * @deffunc int ap_find_list_item(apr_pool_t *p, const char *line, const char *tok) * Retrieve a token, spacing over it and returning a 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 out of * @param accept_line The line to retrieve the token from * @param accept_white Is it delimited by whitespace * @return the first non-white byte after the token * @deffunc 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 out of * @param line The line to find the token * @param tok The token to find * @return 1 if the token is found, 0 otherwise * @deffunc 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 out of * @param line The line to find the token * @param tok The token to find * @return 1 if the token is found, 0 otherwise * @deffunc 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 * @deffunc int ap_is_url(const char *u) * @param url The url to unescapte * @return 0 on success, non-zero otherwise * @deffunc int ap_unescape_url(char *url) * Remove all double slashes from a string * @param name The string to parse * @deffunc void ap_no2slash(char *name) * Remove all ./ and ../ substrings from a file name * @param name the file name to parse * @deffunc void ap_getparents(char *name) * Escape a path segment, as defined in RFC 1808 * @param p The pool to allocate out of * @param s The path to convert * @return The converted URL * @deffunc 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 out of * @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 * @deffunc char *ap_os_escape_path(apr_pool_t *p, const char *path, int partial) * @param p The pool to allocate out of * @param s The html to escape * @return The escaped string * @deffunc char *ap_escape_html(apr_pool_t *p, const char *s) * Construct a full hostname * @param p The pool to allocate out of * @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 * @deffunc char *ap_construct_server(apr_pool_t *p, const char *hostname, apr_port_t port, const request_rec *r) * @param p The pool to allocate out of * @param s The command to escape * @return The escaped hostname * @deffunc char *ap_escape_shell_cmd(apr_pool_t *p, const char *s) * Count the number of directories in a path * @param The path to count * @return The number of directories * @deffunc int ap_count_dirs(const char *path) * Copy at most n leading directories of s into d d should be at least as * large as 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 * @deffunc char *ap_make_dirstr_prefix(char *d, const char *s, int n) * @tip 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. * return the parent directory name including trailing / of the file s * @param p The pool to allocate out of * @param s The file to get the parent of * @return A copy of the file's parent directory * @deffunc char *ap_make_dirstr_parent(apr_pool_t *p, const char *s) * Given a directory and filename, create a single path out of 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 out of * @param dir The directory name * @return A copy of the full path * @deffunc char *ap_make_full_path(apr_pool_t *a, const char *dir, const char *f) * 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 * @deffunc 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 exp The pattern to match against * @return 1 if the two strings match, 0 otherwise * @deffunc int ap_strcmp_match(const char *str, const char *exp) * Determine if a string matches a patterm containing the wildcards '?' or '*', * @param str The string to check * @param exp The pattern to match against * @return 1 if the two strings match, 0 otherwise * @deffunc int ap_strcasecmp_match(const char *str, const char *exp) * 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 * @deffunc 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 * deffunc const char *ap_stripprefix(const char *bigstring, const char *prefix); * Decode a base64 encoded string into memory allocated out of a pool * @param p The pool to allocate out of * @param bufcoded The encoded string * @return The decoded string * @deffunc char *ap_pbase64decode(apr_pool_t *p, const char *bufcoded) * Encode a string into memory allocated out of a pool in base 64 format * @param p The pool to allocate out of * @param strin The plaintext string * @return The encoded string * @deffunc char *ap_pbase64encode(apr_pool_t *p, char *string) * Compile a regular expression to be used later * @param p The pool to allocate out of * @param pattern the regular expression to compile * @param cflags The bitwise or of one or more of the following: * REG_EXTENDED - Use POSIX extended Regular Expressions * REG_ICASE - Ignore case * REG_NOSUB - Support for substring addressing of matches not required * REG_NEWLINE - Match-any-character operators don't match new-line * @return The compiled regular expression * @deffunc 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 out of * @param reg The regular expression to free * @deffunc 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 one or both of: * REG_NOTBOL - match-beginning-of-line operator always fails to match * REG_NOTEOL - match-end-of-line operator always fails to match * @return 0 for successful match, REG_NOMATCH otherwise * @deffunc 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 errocode 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 * @deffunc 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 out of * @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 * @deffunc 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 * @deffunc void ap_content_type_tolower(char *s) * convert a string to all lowercase * @param s The string to convert to lowercase * @deffunc void ap_str_tolower(char *s) * Search a string from left to right for the first occurrence of a * @param str The string to search * @param c The character to search for * @return The index of the first occurrence of c in str * @deffunc int ap_ind(const char *str, char c) * Search a string from right to left for the first occurrence of a * @param str The string to search * @param c The character to search for * @return The index of the first occurrence of c in str * @deffunc int ap_rind(const char *str, char c) * Given a string, replace any bare " with \" . * @param p The pool to allocate memory out of * @param instring The string to search for " * @return A copy of the string with escaped quotes * @deffunc char * ap_escape_quotes(apr_pool_t *p, const char *instring) /* Misc system hackery */ * Convert a username to a numeric ID * @param name The name to convert * @return The user id corresponding to a name * @deffunc uid_t ap_uname2id(const char *name) * Convert a group name to a numeric ID * @param name The name to convert * @return The group id corresponding to a name * @deffunc gid_t ap_gname2id(const char *name) * Given the name of an object in the file system determine if it is a directory * @param name The name of the object to check * @return 1 if it is a directory, 0 otherwise * @deffunc int ap_is_rdirectory(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 name The name of the object to check * @return 1 if it is a directory, 0 otherwise * @deffunc int ap_is_directory(const char *name) * Given a pathname in file, extract the directory and chdir to that directory * @param file The file who's directory we wish to switch to * @deffunc void ap_chdir_file(const char *file) * Get the maximum number of daemons processes for this version of Apache * @return The maximum number of daemon processes * @deffunc int ap_get_max_daemons(void) * determine the local host name for the current machine * @param p The pool to allocate out of * @return A copy of the local host name * @deffunc char *ap_get_local_host(apr_pool_t *p) * 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 * 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 * @deffunc void ap_log_assert(const char *szExp, const char *szFile, int nLine) /* 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. /* strtoul does not exist on sunos4. */ /* 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 #
endif /* !APACHE_HTTPD_H */