Apache2
|
Modules | |
Flags which indicate places where the server should stop for debugging. | |
Data Structures | |
struct | conn_rec |
Structure to store things which are per connection. More... | |
struct | conn_slave_rec |
struct | conn_state_t |
A structure to contain connection state information. More... | |
struct | server_addr_rec |
A structure to be used for Per-vhost config. More... | |
struct | ap_logconf |
struct | server_rec |
A structure to store information for each virtual server. More... | |
struct | ap_sload_t |
A structure to hold server load params. More... | |
struct | ap_loadavg_t |
A structure to hold various server loadavg. More... | |
struct | ap_form_pair_t |
struct | ap_dir_match_t |
Macros | |
#define | PROXYREQ_NONE 0 |
#define | PROXYREQ_PROXY 1 |
#define | PROXYREQ_REVERSE 2 |
#define | PROXYREQ_RESPONSE 3 |
#define | DEFAULT_VHOST_ADDR 0xfffffffful |
#define | AP_UNESCAPE_URL_KEEP_UNRESERVED (1u << 0) |
#define | AP_UNESCAPE_URL_FORBID_SLASHES (1u << 1) |
#define | AP_UNESCAPE_URL_KEEP_SLASHES (1u << 2) |
#define | AP_NORMALIZE_ALLOW_RELATIVE (1u << 0) |
#define | AP_NORMALIZE_NOT_ABOVE_ROOT (1u << 1) |
#define | AP_NORMALIZE_DECODE_UNRESERVED (1u << 2) |
#define | AP_NORMALIZE_MERGE_SLASHES (1u << 3) |
#define | AP_NORMALIZE_DROP_PARAMETERS (0) /* deprecated */ |
#define | ap_escape_uri(ppool, path) ap_os_escape_path(ppool,path,1) |
#define | ap_escape_html(p, s) ap_escape_html2(p,s,0) |
#define | AP_TAINT_HTACCESS 0x1 |
#define | ap_assert(exp) ((exp) ? (void)0 : ap_log_assert(#exp,__FILE__,__LINE__)) |
#define | AP_DEBUG_ASSERT(exp) ((void)0) |
#define | ap_strchr(s, c) strchr(s, c) |
#define | ap_strchr_c(s, c) strchr(s, c) |
#define | ap_strrchr(s, c) strrchr(s, c) |
#define | ap_strrchr_c(s, c) strrchr(s, c) |
#define | ap_strstr(s, c) strstr(s, c) |
#define | ap_strstr_c(s, c) strstr(s, c) |
#define | AP_HAS_THREAD_LOCAL 0 |
#define | AP_NORESTART APR_OS_START_USEERR + 1 |
#define | AP_DIR_FLAG_NONE 0 |
#define | AP_DIR_FLAG_OPTIONAL 1 |
#define | AP_DIR_FLAG_RECURSIVE 2 |
Typedefs | |
typedef struct server_addr_rec | server_addr_rec |
typedef struct ap_sload_t | ap_sload_t |
typedef struct ap_loadavg_t | ap_loadavg_t |
typedef struct ap_dir_match_t | ap_dir_match_t |
Enumerations | |
enum | ap_conn_keepalive_e { AP_CONN_UNKNOWN , AP_CONN_CLOSE , AP_CONN_KEEPALIVE } |
Enumeration of connection keepalive options. More... | |
enum | conn_state_e { CONN_STATE_CHECK_REQUEST_LINE_READABLE , CONN_STATE_READ_REQUEST_LINE , CONN_STATE_HANDLER , CONN_STATE_WRITE_COMPLETION , CONN_STATE_SUSPENDED , CONN_STATE_LINGER , CONN_STATE_LINGER_NORMAL , CONN_STATE_LINGER_SHORT , CONN_STATE_NUM } |
enum | conn_sense_e { CONN_SENSE_DEFAULT , CONN_SENSE_WANT_READ , CONN_SENSE_WANT_WRITE } |
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 ap_assert | ( | exp | ) | ((exp) ? (void)0 : ap_log_assert(#exp,__FILE__,__LINE__)) |
Internal Assert function
#define AP_DEBUG_ASSERT | ( | exp | ) | ((void)0) |
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.
#define AP_DIR_FLAG_NONE 0 |
Default flags for ap_dir_*fnmatch().
#define AP_DIR_FLAG_OPTIONAL 1 |
If set, wildcards that match no files or directories will be ignored, otherwise an error is triggered.
#define AP_DIR_FLAG_RECURSIVE 2 |
If set, and the wildcard resolves to a directory, recursively find all files below that directory, otherwise return the directory.
#define ap_escape_html | ( | p, | |
s | |||
) | ap_escape_html2(p,s,0) |
Escape an html string
p | The pool to allocate from |
s | The html to escape |
#define ap_escape_uri | ( | ppool, | |
path | |||
) | ap_os_escape_path(ppool,path,1) |
#define AP_HAS_THREAD_LOCAL 0 |
#define AP_NORESTART APR_OS_START_USEERR + 1 |
#define AP_NORMALIZE_ALLOW_RELATIVE (1u << 0) |
#define AP_NORMALIZE_DECODE_UNRESERVED (1u << 2) |
#define AP_NORMALIZE_DROP_PARAMETERS (0) /* deprecated */ |
#define AP_NORMALIZE_MERGE_SLASHES (1u << 3) |
#define AP_NORMALIZE_NOT_ABOVE_ROOT (1u << 1) |
#define AP_TAINT_HTACCESS 0x1 |
Request taint flags. Only .htaccess defined.
#define AP_UNESCAPE_URL_FORBID_SLASHES (1u << 1) |
#define AP_UNESCAPE_URL_KEEP_SLASHES (1u << 2) |
#define AP_UNESCAPE_URL_KEEP_UNRESERVED (1u << 0) |
#define DEFAULT_VHOST_ADDR 0xfffffffful |
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 PROXYREQ_NONE 0 |
No proxy
#define PROXYREQ_PROXY 1 |
Standard proxy
#define PROXYREQ_RESPONSE 3 |
Origin response
#define PROXYREQ_REVERSE 2 |
Reverse proxy
typedef struct ap_dir_match_t ap_dir_match_t |
Structure to provide the state of a directory match.
typedef struct ap_loadavg_t ap_loadavg_t |
typedef struct ap_sload_t ap_sload_t |
typedef struct server_addr_rec server_addr_rec |
enum ap_conn_keepalive_e |
enum conn_sense_e |
enum conn_state_e |
Enumeration of connection states The two states CONN_STATE_LINGER_NORMAL and CONN_STATE_LINGER_SHORT may only be set by the MPM. Use CONN_STATE_LINGER outside of the MPM.
void ap_abort_on_oom | ( | void | ) |
Abort with a error message signifying out of memory
char* ap_append_pid | ( | apr_pool_t * | p, |
const char * | string, | ||
const char * | delim | ||
) |
Given a string, append the PID deliminated by delim. Usually used to create a pid-appended filepath name (eg: /a/b/foo -> /a/b/foo.6726). A function, and not a macro, to avoid unistd.h dependency
p | The pool to allocate memory from |
string | The string to append the PID to |
delim | The string to use to deliminate the string from the PID |
int ap_array_str_contains | ( | const apr_array_header_t * | array, |
const char * | s | ||
) |
Check if the string is member of the given array by strcmp.
array | The array the check |
s | The string to find |
int ap_array_str_index | ( | const apr_array_header_t * | array, |
const char * | s, | ||
int | start | ||
) |
Get the first index of the string in the array or -1 if not found. Start searching a start.
array | The array the check |
s | The string to find |
start | Start index for search. If start is out of bounds (negative or equal to array length or greater), -1 will be returned. |
void ap_bin2hex | ( | const void * | src, |
apr_size_t | srclen, | ||
char * | dest | ||
) |
Convert binary data into a hex string
src | pointer to the data |
srclen | length of the data |
dest | pointer to buffer of length (2 * srclen + 1). The resulting string will be NUL-terminated. |
void* ap_calloc | ( | size_t | nelem, |
size_t | size | ||
) |
Wrapper for calloc() that calls ap_abort_on_oom() if out of memory
nelem | number of elements to allocate memory for |
size | size of a single element |
char* ap_construct_server | ( | apr_pool_t * | p, |
const char * | hostname, | ||
apr_port_t | port, | ||
const request_rec * | r | ||
) |
Construct a full hostname
p | The pool to allocate from |
hostname | The hostname of the server |
port | The port the server is running on |
r | The current request |
void ap_content_type_tolower | ( | char * | s | ) |
We want to downcase the type/subtype for comparison purposes but nothing else because ;parameter=foo values are case sensitive.
s | The content-type to convert to lowercase |
const char* ap_context_document_root | ( | request_rec * | r | ) |
Get the context_document_root for a request. This is a generalization of the document root, which is too limited in the presence of mappers like mod_userdir and mod_alias. The context_document_root is the directory on disk that maps to the context_prefix URI prefix.
r | The request |
const char* ap_context_prefix | ( | request_rec * | r | ) |
Get the context_prefix for a request. The context_prefix URI prefix maps to the context_document_root on disk.
r | The request |
int ap_count_dirs | ( | const char * | path | ) |
Count the number of directories in a path
path | The path to count |
int ap_cstr_casecmp | ( | const char * | s1, |
const char * | s2 | ||
) |
Perform a case-insensitive comparison of two strings str1 and str2, treating upper and lower case values of the 26 standard C/POSIX alphabetic characters as equivalent. Extended latin characters outside of this set are treated as unique octets, irrespective of the current locale.
Returns in integer greater than, equal to, or less than 0, according to whether str1 is considered greater than, equal to, or less than str2.
int ap_cstr_casecmpn | ( | const char * | s1, |
const char * | s2, | ||
apr_size_t | n | ||
) |
Perform a case-insensitive comparison of two strings str1 and str2, treating upper and lower case values of the 26 standard C/POSIX alphabetic characters as equivalent. Extended latin characters outside of this set are treated as unique octets, irrespective of the current locale.
Returns in integer greater than, equal to, or less than 0, according to whether str1 is considered greater than, equal to, or less than str2.
const char const char* ap_dir_fnmatch | ( | ap_dir_match_t * | w, |
const char * | path, | ||
const char * | fname | ||
) |
Search for files given a wildcard filename with non native separators.
If the filename contains a wildcard, all files and directories that match the wildcard will be returned.
ap_dir_nofnmatch() is called for each directory and file found, and the callback within ap_dir_match_t triggered as described above.
Wildcards may appear in both directory and file components in the path, and wildcards may appear more than once.
w | Directory match structure containing callback and context. |
path | Path prefix for search, with non native separators and no wildcards. |
fname | The name of the file or directory, with non native separators and optional wildcards. |
const char* ap_dir_nofnmatch | ( | ap_dir_match_t * | w, |
const char * | fname | ||
) |
Search for files given a non wildcard filename with non native separators.
If the provided filename points at a file, the callback within ap_dir_match_t is triggered for that file, and this function returns the result of the callback.
If the provided filename points at a directory, and recursive within ap_dir_match_t is true, the callback will be triggered for every file found recursively beneath that directory, otherwise the callback is triggered once for the directory itself. This function returns the result of the callback.
If the provided path points to neither a file nor a directory, and optional within ap_dir_match_t is true, this function returns NULL. If optional within ap_dir_match_t is false, this function will return an error string indicating that the path does not exist.
w | Directory match structure containing callback and context. |
fname | The name of the file or directory, with non native separators. |
apr_size_t ap_escape_errorlog_item | ( | char * | dest, |
const char * | source, | ||
apr_size_t | buflen | ||
) |
Escape a string for logging into the error log (without a pool)
dest | The buffer to write to |
source | The string to escape |
buflen | The buffer size for the escaped string (including "\0") |
char* ap_escape_html2 | ( | apr_pool_t * | p, |
const char * | s, | ||
int | toasc | ||
) |
Escape an html string
p | The pool to allocate from |
s | The html to escape |
toasc | Whether to escape all non-ASCII chars to &#nnn; |
char* ap_escape_logitem | ( | apr_pool_t * | p, |
const char * | str | ||
) |
Escape a string for logging
p | The pool to allocate from |
str | The string to escape |
char* ap_escape_path_segment | ( | apr_pool_t * | p, |
const char * | s | ||
) |
Escape a path segment, as defined in RFC 1808
p | The pool to allocate from |
s | The path to convert |
char* ap_escape_path_segment_buffer | ( | char * | c, |
const char * | s | ||
) |
Escape a path segment, as defined in RFC 1808, to a preallocated buffer.
c | The preallocated buffer to write to |
s | The path to convert |
char* ap_escape_quotes | ( | apr_pool_t * | p, |
const char * | instring | ||
) |
Given a string, replace any bare " with \" .
p | The pool to allocate memory from |
instring | The string to search for " |
char char* ap_escape_shell_cmd | ( | apr_pool_t * | p, |
const char * | s | ||
) |
Escape a shell command
p | The pool to allocate from |
s | The command to escape |
char* ap_escape_urlencoded | ( | apr_pool_t * | p, |
const char * | s | ||
) |
Escape a string as application/x-www-form-urlencoded
p | The pool to allocate from |
s | The path to convert |
char* ap_escape_urlencoded_buffer | ( | char * | c, |
const char * | s | ||
) |
Escape a string as application/x-www-form-urlencoded, to a preallocated buffer
c | The preallocated buffer to write to |
s | The path to convert |
char* ap_field_noparam | ( | apr_pool_t * | p, |
const char * | intype | ||
) |
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.
p | Pool to allocate memory from |
intype | The field to examine |
int ap_find_etag_strong | ( | apr_pool_t * | p, |
const char * | line, | ||
const char * | tok | ||
) |
Do a strong ETag comparison within an HTTP field value list.
p | The pool to allocate from |
line | The field value list to search |
tok | The token to search for |
int ap_find_etag_weak | ( | apr_pool_t * | p, |
const char * | line, | ||
const char * | tok | ||
) |
Do a weak ETag comparison within an HTTP field value list.
p | The pool to allocate from |
line | The field value list to search |
tok | The token to search for |
int ap_find_last_token | ( | apr_pool_t * | p, |
const char * | line, | ||
const char * | tok | ||
) |
find http tokens from the end of the line
p | The pool to allocate from |
line | The line to find the token |
tok | The token to find |
int ap_find_list_item | ( | apr_pool_t * | p, |
const char * | line, | ||
const char * | tok | ||
) |
Find an item in canonical form (lowercase, no extra spaces) within an HTTP field value list.
p | The pool to allocate from |
line | The field value list to search |
tok | The token to search for |
int ap_find_token | ( | apr_pool_t * | p, |
const char * | line, | ||
const char * | tok | ||
) |
Find http tokens, see the definition of token from RFC2068
p | The pool to allocate from |
line | The line to find the token |
tok | The token to find |
char* ap_get_exec_line | ( | apr_pool_t * | p, |
const char * | cmd, | ||
const char *const * | argv | ||
) |
Short function to execute a command and return the first line of output minus \r \n. Useful for "obscuring" passwords via exec calls
p | the pool to allocate from |
cmd | the command to execute |
argv | the arguments to pass to the cmd |
char* ap_get_list_item | ( | apr_pool_t * | p, |
const char ** | field | ||
) |
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.
p | The pool to allocate from |
field | The field to retrieve |
void ap_get_loadavg | ( | ap_loadavg_t * | ld | ) |
Get server load averages (ala getloadavg)
ld | struct to populate: -1 in fields means error |
char* ap_get_local_host | ( | apr_pool_t * | p | ) |
Determine the local host name for the current machine
p | The pool to allocate from |
void ap_get_sload | ( | ap_sload_t * | ld | ) |
Get server load params
ld | struct to populate: -1 in fields means error |
char* ap_get_token | ( | apr_pool_t * | p, |
const char ** | accept_line, | ||
int | accept_white | ||
) |
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.
p | The pool to allocate from |
accept_line | The line to retrieve the token from (adjusted afterwards) |
accept_white | Is it delimited by whitespace |
void ap_getparents | ( | char * | name | ) |
Remove all ./ and xx/../ substrings from a file name. Also remove any leading ../ or /../ substrings.
name | the file name to parse |
char* ap_getword | ( | apr_pool_t * | p, |
const char ** | line, | ||
char | stop | ||
) |
Get the characters until the first occurrence of a specified character
p | The pool to allocate memory from |
line | The string to get the characters from |
stop | The character to stop at |
char* ap_getword_conf | ( | apr_pool_t * | p, |
const char ** | line | ||
) |
Get the second word in the string paying attention to quoting
p | The pool to allocate from |
line | The line to traverse |
char* ap_getword_conf2 | ( | apr_pool_t * | p, |
const char ** | line | ||
) |
Get the second word in the string paying attention to quoting, with {...} supported as well as "..." and '...'
p | The pool to allocate from |
line | The line to traverse |
char* ap_getword_conf2_nc | ( | apr_pool_t * | p, |
char ** | line | ||
) |
Get the second word in the string paying attention to quoting, with {...} supported as well as "..." and '...'
p | The pool to allocate from |
line | The line to traverse |
char* ap_getword_conf_nc | ( | apr_pool_t * | p, |
char ** | line | ||
) |
Get the second word in the string paying attention to quoting
p | The pool to allocate from |
line | The line to traverse |
char* ap_getword_nc | ( | apr_pool_t * | p, |
char ** | line, | ||
char | stop | ||
) |
Get the characters until the first occurrence of a specified character
p | The pool to allocate memory from |
line | The string to get the characters from |
stop | The character to stop at |
char* ap_getword_nulls | ( | apr_pool_t * | p, |
const char ** | line, | ||
char | stop | ||
) |
Get all characters from the first occurrence of stop to the first "\0"
p | The pool to allocate memory from |
line | The line to traverse |
stop | The character to start at |
char* ap_getword_nulls_nc | ( | apr_pool_t * | p, |
char ** | line, | ||
char | stop | ||
) |
Get all characters from the first occurrence of stop to the first "\0"
p | The pool to allocate memory from |
line | The line to traverse |
stop | The character to start at |
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.
p | The pool to allocate memory from |
line | The string to traverse |
char* ap_getword_white_nc | ( | apr_pool_t * | p, |
char ** | line | ||
) |
Get the first word from a given string. A word is defined as all characters up to the first whitespace.
p | The pool to allocate memory from |
line | The string to traverse |
char* ap_ht_time | ( | apr_pool_t * | p, |
apr_time_t | t, | ||
const char * | fmt, | ||
int | gmt | ||
) |
Convert a time from an integer into a string in a specified format
p | The pool to allocate memory from |
t | The time to convert |
fmt | The format to use for the conversion |
gmt | Convert the time for GMT? |
int ap_ind | ( | const char * | str, |
char | c | ||
) |
Search a string from left to right for the first occurrence of a specific character
str | The string to search |
c | The character to search for |
const char const char int ap_is_chunked | ( | apr_pool_t * | p, |
const char * | line | ||
) |
Determine if the final Transfer-Encoding is "chunked".
p | The pool to allocate from |
line | the header field-value to scan |
int ap_is_directory | ( | 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
p | The pool to allocate from |
name | The name of the object to check |
int ap_is_matchexp | ( | const char * | str | ) |
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 '*'
str | The string to check |
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
p | The pool to allocate from |
name | The name of the object to check |
int ap_is_url | ( | const char * | u | ) |
Check for an Absolute URI syntax
u | The string to check |
void ap_log_assert | ( | const char * | szExp, |
const char * | szFile, | ||
int | nLine | ||
) |
Log an assertion to the error log
szExp | The assertion that failed |
szFile | The file the assertion is in |
nLine | The line the assertion is defined on |
char* ap_make_dirstr_parent | ( | apr_pool_t * | p, |
const char * | s | ||
) |
Return the parent directory name (including trailing /) of the file s
p | The pool to allocate from |
s | The file to get the parent of |
char* ap_make_dirstr_prefix | ( | char * | d, |
const char * | s, | ||
int | n | ||
) |
Copy at most n leading directories of s into d. d should be at least as large as s plus 1 extra byte
d | The location to copy to |
s | The location to copy from |
n | The number of directories to copy |
char* ap_make_full_path | ( | apr_pool_t * | a, |
const char * | dir, | ||
const char * | f | ||
) |
Given a directory and filename, create a single path from them. This function is smart enough to ensure that there is a single '/' between the directory and file names
a | The pool to allocate from |
dir | The directory name |
f | The filename |
void* ap_malloc | ( | size_t | size | ) |
Wrapper for malloc() that calls ap_abort_on_oom() if out of memory
size | size of the memory block |
void ap_no2slash | ( | char * | name | ) |
Convert all double slashes to single slashes, except where significant to the filesystem on the current platform.
name | The string to convert, assumed to be a filesystem path |
void ap_no2slash_ex | ( | char * | name, |
int | is_fs_path | ||
) |
Convert all double slashes to single slashes, except where significant to the filesystem on the current platform.
name | The string to convert |
is_fs_path | if set to 0, the significance of any double-slashes is ignored. |
Remove all ////, /./ and /xx/../ substrings from a path, and more depending on passed in flags.
path | The path to normalize |
flags | bitmask of AP_NORMALIZE_* flags |
char* ap_os_escape_path | ( | apr_pool_t * | p, |
const char * | path, | ||
int | partial | ||
) |
convert an OS path to a URL in an OS dependent way.
p | The pool to allocate from |
path | The path to convert |
partial | if set, assume that the path will be appended to something with a '/' in it (and thus does not prefix "./"). |
int ap_os_is_path_absolute | ( | apr_pool_t * | p, |
const char * | dir | ||
) |
Test if the given path has an absolute path.
p | The pool to allocate from |
dir | The directory name |
void* ap_palloc_debug | ( | apr_pool_t * | p, |
apr_size_t | size | ||
) |
int ap_parse_form_data | ( | request_rec * | r, |
struct ap_filter_t * | f, | ||
apr_array_header_t ** | ptr, | ||
apr_size_t | num, | ||
apr_size_t | size | ||
) |
Read the body and parse any form found, which must be of the type application/x-www-form-urlencoded.
r | request containing POSTed form data |
f | filter |
ptr | returned array of ap_form_pair_t |
num | max num of params or -1 for unlimited |
size | max size allowed for parsed data |
Parse a length string with decimal characters only, no leading sign nor trailing character, like Content-Length or (Content-)Range headers.
len | The parsed length (apr_off_t) |
str | The string to parse |
const char* ap_parse_token_list_strict | ( | apr_pool_t * | p, |
const char * | tok, | ||
apr_array_header_t ** | tokens, | ||
int | skip_invalid | ||
) |
Retrieve an array of tokens in the format "1#token" defined in RFC2616. Only accepts ',' as a delimiter, does not accept quoted strings, and errors on any separator.
p | The pool to allocate from |
tok | The line to read tokens from |
tokens | Pointer to an array of tokens. If not NULL, must be an array of char*, otherwise it will be allocated on p when a token is found |
skip_invalid | If true, when an invalid separator is encountered, it will be ignored. |
apr_status_t ap_password_validate | ( | request_rec * | r, |
const char * | username, | ||
const char * | passwd, | ||
const char * | hash | ||
) |
Wrapper for apr_password_validate() to cache expensive calculations
r | the current request |
username | username of the user |
passwd | password string |
hash | hash string to be passwd to apr_password_validate() |
char* ap_pbase64decode | ( | apr_pool_t * | p, |
const char * | bufcoded | ||
) |
Decode a base64 encoded string into memory allocated from a pool
p | The pool to allocate from |
bufcoded | The encoded string |
apr_status_t ap_pbase64decode_strict | ( | apr_pool_t * | p, |
const char * | encoded, | ||
char ** | decoded, | ||
apr_size_t * | len | ||
) |
Decode a base64 encoded string into memory allocated from a pool, while ensuring that the input string is in fact valid base64.
Unlike ap_pbase64decode(), this function allows encoded NULLs in the input to be retained by the caller, by inspecting the len argument after the call instead of using strlen(). A NULL terminator is still appended to the buffer to facilitate string use (it is not included in len).
p | The pool to allocate from |
encoded | The encoded string |
decoded | On success, set to the decoded buffer, which is allocated from p |
len | On success, set to the length of the decoded buffer (not including the terminating NULL byte) |
char* ap_pbase64encode | ( | apr_pool_t * | p, |
char * | string | ||
) |
Encode a string into memory allocated from a pool in base 64 format
p | The pool to allocate from |
string | The plaintext string |
void* ap_pcalloc_debug | ( | apr_pool_t * | p, |
apr_size_t | size | ||
) |
ap_regex_t* ap_pregcomp | ( | apr_pool_t * | p, |
const char * | pattern, | ||
int | cflags | ||
) |
Compile a regular expression to be used later. The regex is freed when the pool is destroyed.
p | The pool to allocate from |
pattern | the regular expression to compile |
cflags | The bitwise or of one or more of the following:
|
void ap_pregfree | ( | apr_pool_t * | p, |
ap_regex_t * | reg | ||
) |
Free the memory associated with a compiled regular expression
p | The pool the regex was allocated from |
reg | The regular expression to free |
char* ap_pregsub | ( | apr_pool_t * | p, |
const char * | input, | ||
const char * | source, | ||
apr_size_t | nmatch, | ||
ap_regmatch_t | pmatch[] | ||
) |
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. This function is limited to result strings of 64K. Consider using ap_pregsub_ex() instead.
p | The pool to allocate from |
input | An arbitrary string containing $1 through $9. These are replaced with the corresponding matched sub-expressions |
source | The string that was originally matched to the regex |
nmatch | the nmatch returned from ap_pregex |
pmatch | the pmatch array returned from ap_pregex |
apr_status_t ap_pregsub_ex | ( | apr_pool_t * | p, |
char ** | result, | ||
const char * | input, | ||
const char * | source, | ||
apr_size_t | nmatch, | ||
ap_regmatch_t | pmatch[], | ||
apr_size_t | maxlen | ||
) |
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
p | The pool to allocate from |
result | where to store the result, will be set to NULL on error |
input | An arbitrary string containing $1 through $9. These are replaced with the corresponding matched sub-expressions |
source | The string that was originally matched to the regex |
nmatch | the nmatch returned from ap_pregex |
pmatch | the pmatch array returned from ap_pregex |
maxlen | the maximum string length to return, 0 for unlimited |
const char* ap_psignature | ( | const char * | prefix, |
request_rec * | r | ||
) |
Get HTML describing the address and (optionally) admin of the server.
prefix | Text which is prepended to the return value |
r | The request_rec |
apr_status_t ap_pstr2_alnum | ( | apr_pool_t * | p, |
const char * | src, | ||
const char ** | dest | ||
) |
Cleanup a string (mainly to be filesystem safe) We only allow '_' and alphanumeric chars. Non-printable map to 'x' and all others map to '_'
p | pool to use to allocate dest |
src | string to clean up |
dest | cleaned up, allocated string |
void ap_random_insecure_bytes | ( | void * | buf, |
apr_size_t | size | ||
) |
Generate pseudo random bytes. This is a convenience interface to apr_random. It is cheaper but less secure than apr_generate_random_bytes().
buf | where to store the bytes |
size | number of bytes to generate |
apr_uint32_t ap_random_pick | ( | apr_uint32_t | min, |
apr_uint32_t | max | ||
) |
Get a pseudo random number in a range.
min | low end of range |
max | high end of range |
void void* ap_realloc | ( | void * | ptr, |
size_t | size | ||
) |
Wrapper for realloc() that calls ap_abort_on_oom() if out of memory
ptr | pointer to the old memory block (or NULL) |
size | new size of the memory block |
int ap_request_has_body | ( | request_rec * | r | ) |
Determine if a request has a request body or not.
r | the request_rec of the request |
int ap_request_tainted | ( | request_rec * | r, |
int | flags | ||
) |
Check whether a request is tainted by potentially-untrusted sources.
r | the request |
flags | Taint flags to check |
const char* ap_resolve_env | ( | apr_pool_t * | p, |
const char * | word | ||
) |
Check a string for any config define or environment variable construct and replace each of them by the value of that variable, if it exists. The default syntax of the constructs is ${ENV} but can be changed by setting the define::* config defines. If the variable does not exist, leave the ${ENV} construct alone but print a warning.
p | The pool to allocate from |
word | The string to check |
int ap_rind | ( | const char * | str, |
char | c | ||
) |
Search a string from right to left for the first occurrence of a specific character
str | The string to search |
c | The character to search for |
const char* ap_scan_http_field_content | ( | const char * | ptr | ) |
const char* ap_scan_http_token | ( | const char * | ptr | ) |
const char* ap_scan_vchar_obstext | ( | const char * | ptr | ) |
void ap_set_context_info | ( | request_rec * | r, |
const char * | prefix, | ||
const char * | document_root | ||
) |
Set context_prefix and context_document_root for a request.
r | The request |
prefix | the URI prefix, without trailing slash |
document_root | the corresponding directory on disk, without trailing slash |
void ap_set_document_root | ( | request_rec * | r, |
const char * | document_root | ||
) |
Set per-request document root. This is for mass virtual hosting modules that want to provide the correct DOCUMENT_ROOT value to scripts.
r | The request |
document_root | the document root for the request. |
const char* ap_size_list_item | ( | const char ** | field, |
int * | len | ||
) |
Size an HTTP header field list item, as separated by a comma.
field | The field to size |
len | The length of the field |
apr_status_t ap_str2_alnum | ( | const char * | src, |
char * | dest | ||
) |
Cleanup a string (mainly to be filesystem safe) We only allow '_' and alphanumeric chars. Non-printable map to 'x' and all others map to '_'
src | string to clean up |
dest | cleaned up, pre-allocated string |
void ap_str_tolower | ( | char * | s | ) |
convert a string to all lowercase
s | The string to convert to lowercase |
void ap_str_toupper | ( | char * | s | ) |
convert a string to all uppercase
s | The string to convert to uppercase |
int ap_strcasecmp_match | ( | const char * | str, |
const char * | expected | ||
) |
Determine if a string matches a pattern containing the wildcards '?' or '*', ignoring case
str | The string to check |
expected | The pattern to match against |
char* ap_strcasestr | ( | const char * | s1, |
const char * | s2 | ||
) |
Find the first occurrence of the substring s2 in s1, regardless of case
s1 | The string to search |
s2 | The substring to search for |
char* ap_strchr | ( | char * | s, |
int | c | ||
) |
const char* ap_strchr_c | ( | const char * | s, |
int | c | ||
) |
int ap_strcmp_match | ( | const char * | str, |
const char * | expected | ||
) |
Determine if a string matches a pattern containing the wildcards '?' or '*'
str | The string to check |
expected | The pattern to match against |
const char* ap_stripprefix | ( | const char * | bigstring, |
const char * | prefix | ||
) |
Return a pointer to the location inside of bigstring immediately after prefix
bigstring | The input string |
prefix | The prefix to strip away |
char* ap_strrchr | ( | char * | s, |
int | c | ||
) |
const char* ap_strrchr_c | ( | const char * | s, |
int | c | ||
) |
char* ap_strstr | ( | char * | s, |
const char * | c | ||
) |
const char* ap_strstr_c | ( | const char * | s, |
const char * | c | ||
) |
apr_status_t ap_thread_create | ( | apr_thread_t ** | thread, |
apr_threadattr_t * | attr, | ||
apr_thread_start_t | func, | ||
void * | data, | ||
apr_pool_t * | pool | ||
) |
apr_thread_t* ap_thread_current | ( | void | ) |
void ap_thread_current_after_fork | ( | void | ) |
apr_status_t ap_thread_current_create | ( | apr_thread_t ** | current, |
apr_threadattr_t * | attr, | ||
apr_pool_t * | pool | ||
) |
AP_THREAD_LOCAL keyword aliases the compiler's.
apr_status_t ap_thread_main_create | ( | apr_thread_t ** | thread, |
apr_pool_t * | pool | ||
) |
apr_status_t ap_timeout_parameter_parse | ( | const char * | timeout_parameter, |
apr_interval_time_t * | timeout, | ||
const char * | default_time_unit | ||
) |
Parse a given timeout parameter string into an apr_interval_time_t value. The unit of the time interval is given as postfix string to the numeric string. Currently the following units are understood (case insensitive):
ms : milliseconds s : seconds mi[n] : minutes h : hours
If no unit is contained in the given timeout parameter the default_time_unit will be used instead.
timeout_parameter | The string containing the timeout parameter. |
timeout | The timeout value to be returned. |
default_time_unit | The default time unit to use if none is specified in timeout_parameter. |
int ap_unescape_all | ( | char * | url | ) |
Unescape a string
url | The string to unescape |
int ap_unescape_url | ( | char * | url | ) |
Unescape a URL
url | The url to unescape |
Unescape a URL, with options
url | The url to unescape |
flags | Bitmask of AP_UNESCAPE_URL_* flags |
Unescape a URL, but leaving %2f (slashes) escaped
url | The url to unescape |
decode_slashes | Whether or not slashes should be decoded |
int ap_unescape_urlencoded | ( | char * | query | ) |
Unescape an application/x-www-form-urlencoded string
query | The query to unescape |