Global Namespace

Overview

// typedefs

typedef unsigned char apr_byte_t;
typedef short apr_int16_t;
typedef unsigned short apr_uint16_t;
typedef int apr_int32_t;
typedef unsigned int apr_uint32_t;
typedef long apr_int64_t;
typedef unsigned long apr_uint64_t;
typedef size_t apr_size_t;
typedef ssize_t apr_ssize_t;
typedef off_t apr_off_t;
typedef socklen_t apr_socklen_t;
typedef ino_t apr_ino_t;
typedef apr_uint64_t apr_uintptr_t;
typedef struct apr_allocator_t apr_allocator_t;
typedef struct apr_memnode_t apr_memnode_t;
typedef struct apr_dso_handle_t apr_dso_handle_t;
typedef void* apr_dso_handle_sym_t;
typedef int apr_status_t;
typedef struct apr_dir_t apr_dir_t;
typedef apr_int32_t apr_fileperms_t;
typedef dev_t apr_dev_t;
typedef struct apr_finfo_t apr_finfo_t;
typedef apr_uint32_t apr_fileattrs_t;
typedef int apr_seek_where_t;
typedef struct apr_file_t apr_file_t;
typedef int apr_signum_t;

typedef void() apr_getopt_err_fn_t(
    void *arg,
    const char *err,
    ...
    );

typedef struct apr_getopt_t apr_getopt_t;
typedef struct apr_getopt_option_t apr_getopt_option_t;
typedef struct apr_global_mutex_t apr_global_mutex_t;
typedef struct apr_hash_t apr_hash_t;
typedef struct apr_hash_index_t apr_hash_index_t;

typedef unsigned int (*apr_hashfunc_t)(
    const char *key,
    apr_ssize_t *klen
    );

typedef int() apr_hash_do_callback_fn_t(
    void *rec,
    const void *key,
    apr_ssize_t klen,
    const void *value
    );

typedef struct apr_vformatter_buff_t apr_vformatter_buff_t;
typedef struct apr_mmap_t apr_mmap_t;
typedef struct apr_socket_t apr_socket_t;
typedef struct apr_hdtr_t apr_hdtr_t;
typedef struct in_addr apr_in_addr_t;
typedef struct apr_ipsubnet_t apr_ipsubnet_t;
typedef apr_uint16_t apr_port_t;
typedef struct apr_sockaddr_t apr_sockaddr_t;
typedef struct apr_pollfd_t apr_pollfd_t;
typedef struct apr_pollset_t apr_pollset_t;
typedef struct apr_pollcb_t apr_pollcb_t;

typedef apr_status_t (*apr_pollcb_cb_t)(
    void *baton,
    apr_pollfd_t *descriptor
    );

typedef struct apr_pool_t apr_pool_t;
typedef int (*apr_abortfunc_t)(int retcode);
typedef int apr_os_file_t;
typedef DIR apr_os_dir_t;
typedef int apr_os_sock_t;
typedef struct apr_os_proc_mutex_t apr_os_proc_mutex_t;
typedef pthread_t apr_os_thread_t;
typedef pthread_key_t apr_os_threadkey_t;
typedef pid_t apr_os_proc_t;
typedef struct timeval apr_os_imp_time_t;
typedef struct tm apr_os_exp_time_t;
typedef void* apr_os_dso_handle_t;
typedef void* apr_os_shm_t;
typedef struct apr_os_sock_info_t apr_os_sock_info_t;
typedef struct apr_proc_mutex_t apr_proc_mutex_t;
typedef struct apr_crypto_hash_t apr_crypto_hash_t;
typedef void apr_crypto_hash_init_t(apr_crypto_hash_t *hash);

typedef void apr_crypto_hash_add_t(
    apr_crypto_hash_t *hash,
    const void *data,
    apr_size_t bytes
    );

typedef void apr_crypto_hash_finish_t(
    apr_crypto_hash_t *hash,
    unsigned char *result
    );

typedef struct apr_random_t apr_random_t;
typedef struct apr_shm_t apr_shm_t;
typedef void apr_sigfunc_t(int);

typedef int (*apr_skiplist_compare)(
    void *,
    void *
    );

typedef void (*apr_skiplist_freefunc)(void *);
typedef struct apr_skiplist apr_skiplist;
typedef struct apr_skiplistnode apr_skiplistnode;
typedef struct apr_table_t apr_table_t;
typedef struct apr_array_header_t apr_array_header_t;
typedef struct apr_table_entry_t apr_table_entry_t;

typedef int() apr_table_do_callback_fn_t(
    void *rec,
    const char *key,
    const char *value
    );

typedef struct apr_thread_cond_t apr_thread_cond_t;
typedef struct apr_thread_mutex_t apr_thread_mutex_t;
typedef struct apr_proc_t apr_proc_t;

typedef void() apr_child_errfn_t(
    apr_pool_t *proc,
    apr_status_t err,
    const char *description
    );

typedef struct apr_thread_t apr_thread_t;
typedef struct apr_threadattr_t apr_threadattr_t;
typedef struct apr_procattr_t apr_procattr_t;
typedef struct apr_thread_once_t apr_thread_once_t;
typedef struct apr_threadkey_t apr_threadkey_t;
typedef struct apr_other_child_rec_t apr_other_child_rec_t;

typedef void*(APR_THREAD_FUNC* apr_thread_start_t)(
    apr_thread_t *,
    void *
    );

typedef struct apr_thread_rwlock_t apr_thread_rwlock_t;
typedef apr_int64_t apr_time_t;
typedef apr_int64_t apr_interval_time_t;
typedef apr_int32_t apr_short_interval_time_t;
typedef struct apr_time_exp_t apr_time_exp_t;
typedef uid_t apr_uid_t;
typedef gid_t apr_gid_t;
typedef struct _SHA256_CTX SHA256_CTX;

// enums

enum apr_cmdtype_e;
enum apr_datatype_e;
enum apr_exit_why_e;
enum apr_filetype_e;
enum apr_interface_e;
enum apr_kill_conditions_e;
enum apr_lockmech_e;
enum apr_pollset_method_e;
enum apr_shutdown_how_e;
enum apr_wait_how_e;

// structs

struct _SHA256_CTX;
struct apr_array_header_t;
struct apr_crypto_hash_t;
struct apr_finfo_t;
struct apr_getopt_option_t;
struct apr_getopt_t;
struct apr_hdtr_t;
struct apr_memnode_t;
struct apr_mmap_t;
struct apr_os_proc_mutex_t;
struct apr_os_sock_info_t;
struct apr_pollfd_t;
struct apr_proc_t;
struct apr_sockaddr_t;
struct apr_table_entry_t;
struct apr_time_exp_t;
struct apr_version_t;
struct apr_vformatter_buff_t;

// unions

union apr_descriptor;

// global variables

const char apr_month_snames[12][4];
const char apr_day_snames[7][4];

// global functions

apr_status_t
apr_allocator_create(apr_allocator_t** allocator);

void
apr_allocator_destroy(apr_allocator_t* allocator);

apr_memnode_t*
apr_allocator_alloc(
    apr_allocator_t* allocator,
    apr_size_t size
);

void
apr_allocator_free(
    apr_allocator_t* allocator,
    apr_memnode_t* memnode
);

void
apr_allocator_owner_set(
    apr_allocator_t* allocator,
    apr_pool_t* pool
);

apr_pool_t*
apr_allocator_owner_get(apr_allocator_t* allocator);

void
apr_allocator_max_free_set(
    apr_allocator_t* allocator,
    apr_size_t size
);

void
apr_allocator_mutex_set(
    apr_allocator_t* allocator,
    apr_thread_mutex_t* mutex
);

apr_thread_mutex_t*
apr_allocator_mutex_get(apr_allocator_t* allocator);

apr_status_t
apr_atomic_init(apr_pool_t* p);

apr_uint32_t
apr_atomic_read32(volatile apr_uint32_t* mem);

void
apr_atomic_set32(
    volatile apr_uint32_t* mem,
    apr_uint32_t val
);

apr_uint32_t
apr_atomic_add32(
    volatile apr_uint32_t* mem,
    apr_uint32_t val
);

void
apr_atomic_sub32(
    volatile apr_uint32_t* mem,
    apr_uint32_t val
);

apr_uint32_t
apr_atomic_inc32(volatile apr_uint32_t* mem);

int
apr_atomic_dec32(volatile apr_uint32_t* mem);

apr_uint32_t
apr_atomic_cas32(
    volatile apr_uint32_t* mem,
    apr_uint32_t with,
    apr_uint32_t cmp
);

apr_uint32_t
apr_atomic_xchg32(
    volatile apr_uint32_t* mem,
    apr_uint32_t val
);

void*
apr_atomic_casptr(
    volatile void** mem,
    void* with,
    const void* cmp
);

void*
apr_atomic_xchgptr(
    volatile void** mem,
    void* with
);

apr_status_t
apr_dso_load(
    apr_dso_handle_t** res_handle,
    const char* path,
    apr_pool_t* ctx
);

apr_status_t
apr_dso_unload(apr_dso_handle_t* handle);

apr_status_t
apr_dso_sym(
    apr_dso_handle_sym_t* ressym,
    apr_dso_handle_t* handle,
    const char* symname
);

const char*
apr_dso_error(
    apr_dso_handle_t* dso,
    char* buf,
    apr_size_t bufsize
);

apr_status_t
apr_env_get(
    char** value,
    const char* envvar,
    apr_pool_t* pool
);

apr_status_t
apr_env_set(
    const char* envvar,
    const char* value,
    apr_pool_t* pool
);

apr_status_t
apr_env_delete(
    const char* envvar,
    apr_pool_t* pool
);

char*
apr_strerror(
    apr_status_t statcode,
    char* buf,
    apr_size_t bufsize
);

apr_status_t
apr_escape_shell(
    char* escaped,
    const char* str,
    apr_ssize_t slen,
    apr_size_t* len
);

const char*
apr_pescape_shell(
    apr_pool_t* p,
    const char* str
);

apr_status_t
apr_unescape_url(
    char* escaped,
    const char* url,
    apr_ssize_t slen,
    const char* forbid,
    const char* reserved,
    int plus,
    apr_size_t* len
);

const char*
apr_punescape_url(
    apr_pool_t* p,
    const char* url,
    const char* forbid,
    const char* reserved,
    int plus
);

apr_status_t
apr_escape_path_segment(
    char* escaped,
    const char* str,
    apr_ssize_t slen,
    apr_size_t* len
);

const char*
apr_pescape_path_segment(
    apr_pool_t* p,
    const char* str
);

apr_status_t
apr_escape_path(
    char* escaped,
    const char* path,
    apr_ssize_t slen,
    int partial,
    apr_size_t* len
);

const char*
apr_pescape_path(
    apr_pool_t* p,
    const char* str,
    int partial
);

apr_status_t
apr_escape_urlencoded(
    char* escaped,
    const char* str,
    apr_ssize_t slen,
    apr_size_t* len
);

const char*
apr_pescape_urlencoded(
    apr_pool_t* p,
    const char* str
);

apr_status_t
apr_escape_entity(
    char* escaped,
    const char* str,
    apr_ssize_t slen,
    int toasc,
    apr_size_t* len
);

const char*
apr_pescape_entity(
    apr_pool_t* p,
    const char* str,
    int toasc
);

apr_status_t
apr_unescape_entity(
    char* unescaped,
    const char* str,
    apr_ssize_t slen,
    apr_size_t* len
);

const char*
apr_punescape_entity(
    apr_pool_t* p,
    const char* str
);

apr_status_t
apr_escape_echo(
    char* escaped,
    const char* str,
    apr_ssize_t slen,
    int quote,
    apr_size_t* len
);

const char*
apr_pescape_echo(
    apr_pool_t* p,
    const char* str,
    int quote
);

apr_status_t
apr_escape_hex(
    char* dest,
    const void* src,
    apr_size_t srclen,
    int colon,
    apr_size_t* len
);

const char*
apr_pescape_hex(
    apr_pool_t* p,
    const void* src,
    apr_size_t slen,
    int colon
);

apr_status_t
apr_unescape_hex(
    void* dest,
    const char* str,
    apr_ssize_t slen,
    int colon,
    apr_size_t* len
);

const void*
apr_punescape_hex(
    apr_pool_t* p,
    const char* str,
    int colon,
    apr_size_t* len
);

apr_status_t
apr_stat(
    apr_finfo_t* finfo,
    const char* fname,
    apr_int32_t wanted,
    apr_pool_t* pool
);

apr_status_t
apr_dir_open(
    apr_dir_t** new_dir,
    const char* dirname,
    apr_pool_t* pool
);

apr_status_t
apr_dir_close(apr_dir_t* thedir);

apr_status_t
apr_dir_read(
    apr_finfo_t* finfo,
    apr_int32_t wanted,
    apr_dir_t* thedir
);

apr_status_t
apr_dir_rewind(apr_dir_t* thedir);

apr_status_t
apr_filepath_root(
    const char** rootpath,
    const char** filepath,
    apr_int32_t flags,
    apr_pool_t* p
);

apr_status_t
apr_filepath_merge(
    char** newpath,
    const char* rootpath,
    const char* addpath,
    apr_int32_t flags,
    apr_pool_t* p
);

apr_status_t
apr_filepath_list_split(
    apr_array_header_t** pathelts,
    const char* liststr,
    apr_pool_t* p
);

apr_status_t
apr_filepath_list_merge(
    char** liststr,
    apr_array_header_t* pathelts,
    apr_pool_t* p
);

apr_status_t
apr_filepath_get(
    char** path,
    apr_int32_t flags,
    apr_pool_t* p
);

apr_status_t
apr_filepath_set(
    const char* path,
    apr_pool_t* p
);

apr_status_t
apr_filepath_encoding(
    int* style,
    apr_pool_t* p
);

apr_status_t
apr_file_open(
    apr_file_t** newf,
    const char* fname,
    apr_int32_t flag,
    apr_fileperms_t perm,
    apr_pool_t* pool
);

apr_status_t
apr_file_close(apr_file_t* file);

apr_status_t
apr_file_remove(
    const char* path,
    apr_pool_t* pool
);

apr_status_t
apr_file_rename(
    const char* from_path,
    const char* to_path,
    apr_pool_t* pool
);

apr_status_t
apr_file_link(
    const char* from_path,
    const char* to_path
);

apr_status_t
apr_file_copy(
    const char* from_path,
    const char* to_path,
    apr_fileperms_t perms,
    apr_pool_t* pool
);

apr_status_t
apr_file_append(
    const char* from_path,
    const char* to_path,
    apr_fileperms_t perms,
    apr_pool_t* pool
);

apr_status_t
apr_file_eof(apr_file_t* fptr);

apr_status_t
apr_file_open_stderr(
    apr_file_t** thefile,
    apr_pool_t* pool
);

apr_status_t
apr_file_open_stdout(
    apr_file_t** thefile,
    apr_pool_t* pool
);

apr_status_t
apr_file_open_stdin(
    apr_file_t** thefile,
    apr_pool_t* pool
);

apr_status_t
apr_file_open_flags_stderr(
    apr_file_t** thefile,
    apr_int32_t flags,
    apr_pool_t* pool
);

apr_status_t
apr_file_open_flags_stdout(
    apr_file_t** thefile,
    apr_int32_t flags,
    apr_pool_t* pool
);

apr_status_t
apr_file_open_flags_stdin(
    apr_file_t** thefile,
    apr_int32_t flags,
    apr_pool_t* pool
);

apr_status_t
apr_file_read(
    apr_file_t* thefile,
    void* buf,
    apr_size_t* nbytes
);

apr_status_t
apr_file_write(
    apr_file_t* thefile,
    const void* buf,
    apr_size_t* nbytes
);

apr_status_t
apr_file_writev(
    apr_file_t* thefile,
    const struct iovec* vec,
    apr_size_t nvec,
    apr_size_t* nbytes
);

apr_status_t
apr_file_read_full(
    apr_file_t* thefile,
    void* buf,
    apr_size_t nbytes,
    apr_size_t* bytes_read
);

apr_status_t
apr_file_write_full(
    apr_file_t* thefile,
    const void* buf,
    apr_size_t nbytes,
    apr_size_t* bytes_written
);

apr_status_t
apr_file_writev_full(
    apr_file_t* thefile,
    const struct iovec* vec,
    apr_size_t nvec,
    apr_size_t* nbytes
);

apr_status_t
apr_file_putc(
    char ch,
    apr_file_t* thefile
);

apr_status_t
apr_file_getc(
    char* ch,
    apr_file_t* thefile
);

apr_status_t
apr_file_ungetc(
    char ch,
    apr_file_t* thefile
);

apr_status_t
apr_file_gets(
    char* str,
    int len,
    apr_file_t* thefile
);

apr_status_t
apr_file_puts(
    const char* str,
    apr_file_t* thefile
);

apr_status_t
apr_file_flush(apr_file_t* thefile);

apr_status_t
apr_file_sync(apr_file_t* thefile);

apr_status_t
apr_file_datasync(apr_file_t* thefile);

apr_status_t
apr_file_dup(
    apr_file_t** new_file,
    apr_file_t* old_file,
    apr_pool_t* p
);

apr_status_t
apr_file_dup2(
    apr_file_t* new_file,
    apr_file_t* old_file,
    apr_pool_t* p
);

apr_status_t
apr_file_setaside(
    apr_file_t** new_file,
    apr_file_t* old_file,
    apr_pool_t* p
);

apr_status_t
apr_file_buffer_set(
    apr_file_t* thefile,
    char* buffer,
    apr_size_t bufsize
);

apr_size_t
apr_file_buffer_size_get(apr_file_t* thefile);

apr_status_t
apr_file_seek(
    apr_file_t* thefile,
    apr_seek_where_t where,
    apr_off_t* offset
);

apr_status_t
apr_file_pipe_create(
    apr_file_t** in,
    apr_file_t** out,
    apr_pool_t* pool
);

apr_status_t
apr_file_pipe_create_ex(
    apr_file_t** in,
    apr_file_t** out,
    apr_int32_t blocking,
    apr_pool_t* pool
);

apr_status_t
apr_file_namedpipe_create(
    const char* filename,
    apr_fileperms_t perm,
    apr_pool_t* pool
);

apr_status_t
apr_file_pipe_timeout_get(
    apr_file_t* thepipe,
    apr_interval_time_t* timeout
);

apr_status_t
apr_file_pipe_timeout_set(
    apr_file_t* thepipe,
    apr_interval_time_t timeout
);

apr_status_t
apr_file_lock(
    apr_file_t* thefile,
    int type
);

apr_status_t
apr_file_unlock(apr_file_t* thefile);

apr_status_t
apr_file_name_get(
    const char** new_path,
    apr_file_t* thefile
);

apr_status_t
apr_file_data_get(
    void** data,
    const char* key,
    apr_file_t* file
);

apr_status_t
apr_file_data_set(
    apr_file_t* file,
    void* data,
    const char* key,
    apr_status_t(*)(void*) cleanup
);

int
apr_file_printf(
    apr_file_t* fptr,
    const char* format,
    ...
);

apr_status_t
apr_file_perms_set(
    const char* fname,
    apr_fileperms_t perms
);

apr_status_t
apr_file_attrs_set(
    const char* fname,
    apr_fileattrs_t attributes,
    apr_fileattrs_t attr_mask,
    apr_pool_t* pool
);

apr_status_t
apr_file_mtime_set(
    const char* fname,
    apr_time_t mtime,
    apr_pool_t* pool
);

apr_status_t
apr_dir_make(
    const char* path,
    apr_fileperms_t perm,
    apr_pool_t* pool
);

apr_status_t
apr_dir_make_recursive(
    const char* path,
    apr_fileperms_t perm,
    apr_pool_t* pool
);

apr_status_t
apr_dir_remove(
    const char* path,
    apr_pool_t* pool
);

apr_status_t
apr_file_info_get(
    apr_finfo_t* finfo,
    apr_int32_t wanted,
    apr_file_t* thefile
);

apr_status_t
apr_file_trunc(
    apr_file_t* fp,
    apr_off_t offset
);

apr_int32_t
apr_file_flags_get(apr_file_t* f);

apr_pool_t*
apr_file_pool_get(const apr_file_t* thefile);

apr_status_t
apr_file_inherit_set(apr_file_t* thefile);

apr_status_t
apr_file_inherit_unset(apr_file_t* thefile);

apr_status_t
apr_file_mktemp(
    apr_file_t** fp,
    char* templ,
    apr_int32_t flags,
    apr_pool_t* p
);

apr_status_t
apr_temp_dir_get(
    const char** temp_dir,
    apr_pool_t* p
);

apr_status_t
apr_fnmatch(
    const char* pattern,
    const char* strings,
    int flags
);

int
apr_fnmatch_test(const char* pattern);

apr_status_t
apr_match_glob(
    const char* dir_pattern,
    apr_array_header_t** result,
    apr_pool_t* p
);

apr_status_t
apr_initialize(void);

apr_status_t
apr_app_initialize(
    int* argc,
    char const*const** argv,
    char const*const** env
);

void
apr_terminate(void);

void
apr_terminate2(void);

apr_status_t
apr_generate_random_bytes(
    unsigned char* buf,
    apr_size_t length
);

apr_status_t
apr_getopt_init(
    apr_getopt_t** os,
    apr_pool_t* cont,
    int argc,
    const char*const* argv
);

apr_status_t
apr_getopt(
    apr_getopt_t* os,
    const char* opts,
    char* option_ch,
    const char** option_arg
);

apr_status_t
apr_getopt_long(
    apr_getopt_t* os,
    const apr_getopt_option_t* opts,
    int* option_ch,
    const char** option_arg
);

apr_status_t
apr_global_mutex_create(
    apr_global_mutex_t** mutex,
    const char* fname,
    apr_lockmech_e mech,
    apr_pool_t* pool
);

apr_status_t
apr_global_mutex_child_init(
    apr_global_mutex_t** mutex,
    const char* fname,
    apr_pool_t* pool
);

apr_status_t
apr_global_mutex_lock(apr_global_mutex_t* mutex);

apr_status_t
apr_global_mutex_trylock(apr_global_mutex_t* mutex);

apr_status_t
apr_global_mutex_unlock(apr_global_mutex_t* mutex);

apr_status_t
apr_global_mutex_destroy(apr_global_mutex_t* mutex);

const char*
apr_global_mutex_lockfile(apr_global_mutex_t* mutex);

const char*
apr_global_mutex_name(apr_global_mutex_t* mutex);

apr_pool_t*
apr_global_mutex_pool_get(const apr_global_mutex_t* theglobal_mutex);

unsigned int
apr_hashfunc_default(
    const char* key,
    apr_ssize_t* klen
);

apr_hash_t*
apr_hash_make(apr_pool_t* pool);

apr_hash_t*
apr_hash_make_custom(
    apr_pool_t* pool,
    apr_hashfunc_t hash_func
);

apr_hash_t*
apr_hash_copy(
    apr_pool_t* pool,
    const apr_hash_t* h
);

void
apr_hash_set(
    apr_hash_t* ht,
    const void* key,
    apr_ssize_t klen,
    const void* val
);

void*
apr_hash_get(
    apr_hash_t* ht,
    const void* key,
    apr_ssize_t klen
);

apr_hash_index_t*
apr_hash_first(
    apr_pool_t* p,
    apr_hash_t* ht
);

apr_hash_index_t*
apr_hash_next(apr_hash_index_t* hi);

void
apr_hash_this(
    apr_hash_index_t* hi,
    const void** key,
    apr_ssize_t* klen,
    void** val
);

const void*
apr_hash_this_key(apr_hash_index_t* hi);

apr_ssize_t
apr_hash_this_key_len(apr_hash_index_t* hi);

void*
apr_hash_this_val(apr_hash_index_t* hi);

unsigned int
apr_hash_count(apr_hash_t* ht);

void
apr_hash_clear(apr_hash_t* ht);

apr_hash_t*
apr_hash_overlay(
    apr_pool_t* p,
    const apr_hash_t* overlay,
    const apr_hash_t* base
);

apr_hash_t*
apr_hash_merge(
    apr_pool_t* p,
    const apr_hash_t* h1,
    const apr_hash_t* h2,
    void*(*)(apr_pool_t*p, const void*key, apr_ssize_t klen, const void*h1_val, const void*h2_val, const void*data) merger,
    const void* data
);

int
apr_hash_do(
    apr_hash_do_callback_fn_t* comp,
    void* rec,
    const apr_hash_t* ht
);

apr_pool_t*
apr_hash_pool_get(const apr_hash_t* thehash);

const char*
apr_filepath_name_get(const char* pathname);

int
apr_vformatter(
    int(*)(apr_vformatter_buff_t*b) flush_func,
    apr_vformatter_buff_t* c,
    const char* fmt,
    va_list ap
);

apr_status_t
apr_password_get(
    const char* prompt,
    char* pwbuf,
    apr_size_t* bufsize
);

apr_status_t
apr_mmap_create(
    apr_mmap_t** newmmap,
    apr_file_t* file,
    apr_off_t offset,
    apr_size_t size,
    apr_int32_t flag,
    apr_pool_t* cntxt
);

apr_status_t
apr_mmap_dup(
    apr_mmap_t** new_mmap,
    apr_mmap_t* old_mmap,
    apr_pool_t* p
);

apr_status_t
apr_mmap_delete(apr_mmap_t* mm);

apr_status_t
apr_mmap_offset(
    void** addr,
    apr_mmap_t* mm,
    apr_off_t offset
);

apr_status_t
apr_socket_create(
    apr_socket_t** new_sock,
    int family,
    int type,
    int protocol,
    apr_pool_t* cont
);

apr_status_t
apr_socket_shutdown(
    apr_socket_t* thesocket,
    apr_shutdown_how_e how
);

apr_status_t
apr_socket_close(apr_socket_t* thesocket);

apr_status_t
apr_socket_bind(
    apr_socket_t* sock,
    apr_sockaddr_t* sa
);

apr_status_t
apr_socket_listen(
    apr_socket_t* sock,
    apr_int32_t backlog
);

apr_status_t
apr_socket_accept(
    apr_socket_t** new_sock,
    apr_socket_t* sock,
    apr_pool_t* connection_pool
);

apr_status_t
apr_socket_connect(
    apr_socket_t* sock,
    apr_sockaddr_t* sa
);

apr_status_t
apr_socket_atreadeof(
    apr_socket_t* sock,
    int* atreadeof
);

apr_status_t
apr_sockaddr_info_get(
    apr_sockaddr_t** sa,
    const char* hostname,
    apr_int32_t family,
    apr_port_t port,
    apr_int32_t flags,
    apr_pool_t* p
);

apr_status_t
apr_getnameinfo(
    char** hostname,
    apr_sockaddr_t* sa,
    apr_int32_t flags
);

apr_status_t
apr_parse_addr_port(
    char** addr,
    char** scope_id,
    apr_port_t* port,
    const char* str,
    apr_pool_t* p
);

apr_status_t
apr_gethostname(
    char* buf,
    int len,
    apr_pool_t* cont
);

apr_status_t
apr_socket_data_get(
    void** data,
    const char* key,
    apr_socket_t* sock
);

apr_status_t
apr_socket_data_set(
    apr_socket_t* sock,
    void* data,
    const char* key,
    apr_status_t(*)(void*) cleanup
);

apr_status_t
apr_socket_send(
    apr_socket_t* sock,
    const char* buf,
    apr_size_t* len
);

apr_status_t
apr_socket_sendv(
    apr_socket_t* sock,
    const struct iovec* vec,
    apr_int32_t nvec,
    apr_size_t* len
);

apr_status_t
apr_socket_sendto(
    apr_socket_t* sock,
    apr_sockaddr_t* where,
    apr_int32_t flags,
    const char* buf,
    apr_size_t* len
);

apr_status_t
apr_socket_recvfrom(
    apr_sockaddr_t* from,
    apr_socket_t* sock,
    apr_int32_t flags,
    char* buf,
    apr_size_t* len
);

apr_status_t
apr_socket_sendfile(
    apr_socket_t* sock,
    apr_file_t* file,
    apr_hdtr_t* hdtr,
    apr_off_t* offset,
    apr_size_t* len,
    apr_int32_t flags
);

apr_status_t
apr_socket_recv(
    apr_socket_t* sock,
    char* buf,
    apr_size_t* len
);

apr_status_t
apr_socket_opt_set(
    apr_socket_t* sock,
    apr_int32_t opt,
    apr_int32_t on
);

apr_status_t
apr_socket_timeout_set(
    apr_socket_t* sock,
    apr_interval_time_t t
);

apr_status_t
apr_socket_opt_get(
    apr_socket_t* sock,
    apr_int32_t opt,
    apr_int32_t* on
);

apr_status_t
apr_socket_timeout_get(
    apr_socket_t* sock,
    apr_interval_time_t* t
);

apr_status_t
apr_socket_atmark(
    apr_socket_t* sock,
    int* atmark
);

apr_status_t
apr_socket_addr_get(
    apr_sockaddr_t** sa,
    apr_interface_e which,
    apr_socket_t* sock
);

apr_status_t
apr_sockaddr_ip_get(
    char** addr,
    apr_sockaddr_t* sockaddr
);

apr_status_t
apr_sockaddr_ip_getbuf(
    char* buf,
    apr_size_t buflen,
    apr_sockaddr_t* sockaddr
);

int
apr_sockaddr_equal(
    const apr_sockaddr_t* addr1,
    const apr_sockaddr_t* addr2
);

int
apr_sockaddr_is_wildcard(const apr_sockaddr_t* addr);

apr_status_t
apr_socket_type_get(
    apr_socket_t* sock,
    int* type
);

apr_status_t
apr_getservbyname(
    apr_sockaddr_t* sockaddr,
    const char* servname
);

apr_status_t
apr_ipsubnet_create(
    apr_ipsubnet_t** ipsub,
    const char* ipstr,
    const char* mask_or_numbits,
    apr_pool_t* p
);

int
apr_ipsubnet_test(
    apr_ipsubnet_t* ipsub,
    apr_sockaddr_t* sa
);

apr_status_t
apr_socket_accept_filter(
    apr_socket_t* sock,
    char* name,
    char* args
);

apr_status_t
apr_socket_protocol_get(
    apr_socket_t* sock,
    int* protocol
);

apr_pool_t*
apr_socket_pool_get(const apr_socket_t* thesocket);

apr_status_t
apr_socket_inherit_set(apr_socket_t* thesocket);

apr_status_t
apr_socket_inherit_unset(apr_socket_t* thesocket);

apr_status_t
apr_mcast_join(
    apr_socket_t* sock,
    apr_sockaddr_t* join,
    apr_sockaddr_t* iface,
    apr_sockaddr_t* source
);

apr_status_t
apr_mcast_leave(
    apr_socket_t* sock,
    apr_sockaddr_t* addr,
    apr_sockaddr_t* iface,
    apr_sockaddr_t* source
);

apr_status_t
apr_mcast_hops(
    apr_socket_t* sock,
    apr_byte_t ttl
);

apr_status_t
apr_mcast_loopback(
    apr_socket_t* sock,
    apr_byte_t opt
);

apr_status_t
apr_mcast_interface(
    apr_socket_t* sock,
    apr_sockaddr_t* iface
);

apr_status_t
apr_pollset_create(
    apr_pollset_t** pollset,
    apr_uint32_t size,
    apr_pool_t* p,
    apr_uint32_t flags
);

apr_status_t
apr_pollset_create_ex(
    apr_pollset_t** pollset,
    apr_uint32_t size,
    apr_pool_t* p,
    apr_uint32_t flags,
    apr_pollset_method_e method
);

apr_status_t
apr_pollset_destroy(apr_pollset_t* pollset);

apr_status_t
apr_pollset_add(
    apr_pollset_t* pollset,
    const apr_pollfd_t* descriptor
);

apr_status_t
apr_pollset_remove(
    apr_pollset_t* pollset,
    const apr_pollfd_t* descriptor
);

apr_status_t
apr_pollset_poll(
    apr_pollset_t* pollset,
    apr_interval_time_t timeout,
    apr_int32_t* num,
    const apr_pollfd_t** descriptors
);

apr_status_t
apr_pollset_wakeup(apr_pollset_t* pollset);

apr_status_t
apr_poll(
    apr_pollfd_t* aprset,
    apr_int32_t numsock,
    apr_int32_t* nsds,
    apr_interval_time_t timeout
);

const char*
apr_pollset_method_name(apr_pollset_t* pollset);

const char*
apr_poll_method_defname(void);

apr_status_t
apr_pollcb_create(
    apr_pollcb_t** pollcb,
    apr_uint32_t size,
    apr_pool_t* p,
    apr_uint32_t flags
);

apr_status_t
apr_pollcb_create_ex(
    apr_pollcb_t** pollcb,
    apr_uint32_t size,
    apr_pool_t* p,
    apr_uint32_t flags,
    apr_pollset_method_e method
);

apr_status_t
apr_pollcb_add(
    apr_pollcb_t* pollcb,
    apr_pollfd_t* descriptor
);

apr_status_t
apr_pollcb_remove(
    apr_pollcb_t* pollcb,
    apr_pollfd_t* descriptor
);

apr_status_t
apr_pollcb_poll(
    apr_pollcb_t* pollcb,
    apr_interval_time_t timeout,
    apr_pollcb_cb_t func,
    void* baton
);

apr_status_t
apr_pool_initialize(void);

void
apr_pool_terminate(void);

apr_status_t
apr_pool_create_ex(
    apr_pool_t** newpool,
    apr_pool_t* parent,
    apr_abortfunc_t abort_fn,
    apr_allocator_t* allocator
);

apr_status_t
apr_pool_create_core_ex(
    apr_pool_t** newpool,
    apr_abortfunc_t abort_fn,
    apr_allocator_t* allocator
);

apr_status_t
apr_pool_create_unmanaged_ex(
    apr_pool_t** newpool,
    apr_abortfunc_t abort_fn,
    apr_allocator_t* allocator
);

apr_status_t
apr_pool_create_ex_debug(
    apr_pool_t** newpool,
    apr_pool_t* parent,
    apr_abortfunc_t abort_fn,
    apr_allocator_t* allocator,
    const char* file_line
);

apr_status_t
apr_pool_create_core_ex_debug(
    apr_pool_t** newpool,
    apr_abortfunc_t abort_fn,
    apr_allocator_t* allocator,
    const char* file_line
);

apr_status_t
apr_pool_create_unmanaged_ex_debug(
    apr_pool_t** newpool,
    apr_abortfunc_t abort_fn,
    apr_allocator_t* allocator,
    const char* file_line
);

apr_status_t
apr_pool_create(
    apr_pool_t** newpool,
    apr_pool_t* parent
);

apr_status_t
apr_pool_create_core(apr_pool_t** newpool);

apr_status_t
apr_pool_create_unmanaged(apr_pool_t** newpool);

apr_allocator_t*
apr_pool_allocator_get(apr_pool_t* pool);

void
apr_pool_clear(apr_pool_t* p);

void
apr_pool_clear_debug(
    apr_pool_t* p,
    const char* file_line
);

void
apr_pool_destroy(apr_pool_t* p);

void
apr_pool_destroy_debug(
    apr_pool_t* p,
    const char* file_line
);

void*
apr_palloc(
    apr_pool_t* p,
    apr_size_t size
);

void*
apr_palloc_debug(
    apr_pool_t* p,
    apr_size_t size,
    const char* file_line
);

void*
apr_pcalloc(
    apr_pool_t* p,
    apr_size_t size
);

void*
apr_pcalloc_debug(
    apr_pool_t* p,
    apr_size_t size,
    const char* file_line
);

void
apr_pool_abort_set(
    apr_abortfunc_t abortfunc,
    apr_pool_t* pool
);

apr_abortfunc_t
apr_pool_abort_get(apr_pool_t* pool);

apr_pool_t*
apr_pool_parent_get(apr_pool_t* pool);

int
apr_pool_is_ancestor(
    apr_pool_t* a,
    apr_pool_t* b
);

void
apr_pool_tag(
    apr_pool_t* pool,
    const char* tag
);

apr_status_t
apr_pool_userdata_set(
    const void* data,
    const char* key,
    apr_status_t(*)(void*) cleanup,
    apr_pool_t* pool
);

apr_status_t
apr_pool_userdata_setn(
    const void* data,
    const char* key,
    apr_status_t(*)(void*) cleanup,
    apr_pool_t* pool
);

apr_status_t
apr_pool_userdata_get(
    void** data,
    const char* key,
    apr_pool_t* pool
);

void
apr_pool_cleanup_register(
    apr_pool_t* p,
    const void* data,
    apr_status_t(*)(void*) plain_cleanup,
    apr_status_t(*)(void*) child_cleanup
);

void
apr_pool_pre_cleanup_register(
    apr_pool_t* p,
    const void* data,
    apr_status_t(*)(void*) plain_cleanup
);

void
apr_pool_cleanup_kill(
    apr_pool_t* p,
    const void* data,
    apr_status_t(*)(void*) cleanup
);

void
apr_pool_child_cleanup_set(
    apr_pool_t* p,
    const void* data,
    apr_status_t(*)(void*) plain_cleanup,
    apr_status_t(*)(void*) child_cleanup
);

apr_status_t
apr_pool_cleanup_run(
    apr_pool_t* p,
    void* data,
    apr_status_t(*)(void*) cleanup
);

apr_status_t
apr_pool_cleanup_null(void* data);

void
apr_pool_cleanup_for_exec(void);

void
apr_pool_join(
    apr_pool_t* p,
    apr_pool_t* sub
);

apr_pool_t*
apr_pool_find(const void* mem);

apr_size_t
apr_pool_num_bytes(
    apr_pool_t* p,
    int recurse
);

void
apr_pool_lock(
    apr_pool_t* pool,
    int flag
);

apr_status_t
apr_os_file_get(
    apr_os_file_t* thefile,
    apr_file_t* file
);

apr_status_t
apr_os_dir_get(
    apr_os_dir_t** thedir,
    apr_dir_t* dir
);

apr_status_t
apr_os_sock_get(
    apr_os_sock_t* thesock,
    apr_socket_t* sock
);

apr_status_t
apr_os_proc_mutex_get(
    apr_os_proc_mutex_t* ospmutex,
    apr_proc_mutex_t* pmutex
);

apr_status_t
apr_os_exp_time_get(
    apr_os_exp_time_t** ostime,
    apr_time_exp_t* aprtime
);

apr_status_t
apr_os_imp_time_get(
    apr_os_imp_time_t** ostime,
    apr_time_t* aprtime
);

apr_status_t
apr_os_shm_get(
    apr_os_shm_t* osshm,
    apr_shm_t* shm
);

apr_status_t
apr_os_thread_get(
    apr_os_thread_t** thethd,
    apr_thread_t* thd
);

apr_status_t
apr_os_threadkey_get(
    apr_os_threadkey_t* thekey,
    apr_threadkey_t* key
);

apr_status_t
apr_os_thread_put(
    apr_thread_t** thd,
    apr_os_thread_t* thethd,
    apr_pool_t* cont
);

apr_status_t
apr_os_threadkey_put(
    apr_threadkey_t** key,
    apr_os_threadkey_t* thekey,
    apr_pool_t* cont
);

apr_os_thread_t
apr_os_thread_current(void);

int
apr_os_thread_equal(
    apr_os_thread_t tid1,
    apr_os_thread_t tid2
);

apr_status_t
apr_os_file_put(
    apr_file_t** file,
    apr_os_file_t* thefile,
    apr_int32_t flags,
    apr_pool_t* cont
);

apr_status_t
apr_os_pipe_put(
    apr_file_t** file,
    apr_os_file_t* thefile,
    apr_pool_t* cont
);

apr_status_t
apr_os_pipe_put_ex(
    apr_file_t** file,
    apr_os_file_t* thefile,
    int register_cleanup,
    apr_pool_t* cont
);

apr_status_t
apr_os_dir_put(
    apr_dir_t** dir,
    apr_os_dir_t* thedir,
    apr_pool_t* cont
);

apr_status_t
apr_os_sock_put(
    apr_socket_t** sock,
    apr_os_sock_t* thesock,
    apr_pool_t* cont
);

apr_status_t
apr_os_sock_make(
    apr_socket_t** apr_sock,
    apr_os_sock_info_t* os_sock_info,
    apr_pool_t* cont
);

apr_status_t
apr_os_proc_mutex_put(
    apr_proc_mutex_t** pmutex,
    apr_os_proc_mutex_t* ospmutex,
    apr_pool_t* cont
);

apr_status_t
apr_os_imp_time_put(
    apr_time_t* aprtime,
    apr_os_imp_time_t** ostime,
    apr_pool_t* cont
);

apr_status_t
apr_os_exp_time_put(
    apr_time_exp_t* aprtime,
    apr_os_exp_time_t** ostime,
    apr_pool_t* cont
);

apr_status_t
apr_os_shm_put(
    apr_shm_t** shm,
    apr_os_shm_t* osshm,
    apr_pool_t* cont
);

apr_status_t
apr_os_dso_handle_put(
    apr_dso_handle_t** dso,
    apr_os_dso_handle_t thedso,
    apr_pool_t* pool
);

apr_status_t
apr_os_dso_handle_get(
    apr_os_dso_handle_t* dso,
    apr_dso_handle_t* aprdso
);

apr_status_t
apr_os_uuid_get(unsigned char* uuid_data);

const char*
apr_os_default_encoding(apr_pool_t* pool);

const char*
apr_os_locale_encoding(apr_pool_t* pool);

apr_status_t
apr_proc_mutex_create(
    apr_proc_mutex_t** mutex,
    const char* fname,
    apr_lockmech_e mech,
    apr_pool_t* pool
);

apr_status_t
apr_proc_mutex_child_init(
    apr_proc_mutex_t** mutex,
    const char* fname,
    apr_pool_t* pool
);

apr_status_t
apr_proc_mutex_lock(apr_proc_mutex_t* mutex);

apr_status_t
apr_proc_mutex_trylock(apr_proc_mutex_t* mutex);

apr_status_t
apr_proc_mutex_unlock(apr_proc_mutex_t* mutex);

apr_status_t
apr_proc_mutex_destroy(apr_proc_mutex_t* mutex);

apr_status_t
apr_proc_mutex_cleanup(void* mutex);

const char*
apr_proc_mutex_lockfile(apr_proc_mutex_t* mutex);

const char*
apr_proc_mutex_name(apr_proc_mutex_t* mutex);

const char*
apr_proc_mutex_defname(void);

apr_pool_t*
apr_proc_mutex_pool_get(const apr_proc_mutex_t* theproc_mutex);

apr_crypto_hash_t*
apr_crypto_sha256_new(apr_pool_t* p);

void
apr_random_init(
    apr_random_t* g,
    apr_pool_t* p,
    apr_crypto_hash_t* pool_hash,
    apr_crypto_hash_t* key_hash,
    apr_crypto_hash_t* prng_hash
);

apr_random_t*
apr_random_standard_new(apr_pool_t* p);

void
apr_random_add_entropy(
    apr_random_t* g,
    const void* entropy_,
    apr_size_t bytes
);

apr_status_t
apr_random_insecure_bytes(
    apr_random_t* g,
    void* random,
    apr_size_t bytes
);

apr_status_t
apr_random_secure_bytes(
    apr_random_t* g,
    void* random,
    apr_size_t bytes
);

void
apr_random_barrier(apr_random_t* g);

apr_status_t
apr_random_secure_ready(apr_random_t* r);

apr_status_t
apr_random_insecure_ready(apr_random_t* r);

void
apr_random_after_fork(apr_proc_t* proc);

apr_status_t
apr_shm_create(
    apr_shm_t** m,
    apr_size_t reqsize,
    const char* filename,
    apr_pool_t* pool
);

apr_status_t
apr_shm_create_ex(
    apr_shm_t** m,
    apr_size_t reqsize,
    const char* filename,
    apr_pool_t* pool,
    apr_int32_t flags
);

apr_status_t
apr_shm_remove(
    const char* filename,
    apr_pool_t* pool
);

apr_status_t
apr_shm_destroy(apr_shm_t* m);

apr_status_t
apr_shm_attach(
    apr_shm_t** m,
    const char* filename,
    apr_pool_t* pool
);

apr_status_t
apr_shm_attach_ex(
    apr_shm_t** m,
    const char* filename,
    apr_pool_t* pool,
    apr_int32_t flags
);

apr_status_t
apr_shm_detach(apr_shm_t* m);

void*
apr_shm_baseaddr_get(const apr_shm_t* m);

apr_size_t
apr_shm_size_get(const apr_shm_t* m);

apr_pool_t*
apr_shm_pool_get(const apr_shm_t* theshm);

apr_sigfunc_t*
apr_signal(
    int signo,
    apr_sigfunc_t* func
);

const char*
apr_signal_description_get(int signum);

void
apr_signal_init(apr_pool_t* pglobal);

apr_status_t
apr_signal_block(int signum);

apr_status_t
apr_signal_unblock(int signum);

void*
apr_skiplist_alloc(
    apr_skiplist* sl,
    size_t size
);

void
apr_skiplist_free(
    apr_skiplist* sl,
    void* mem
);

apr_status_t
apr_skiplist_init(
    apr_skiplist** sl,
    apr_pool_t* p
);

void
apr_skiplist_set_compare(
    apr_skiplist* sl,
    apr_skiplist_compare XXX1,
    apr_skiplist_compare XXX2
);

void
apr_skiplist_add_index(
    apr_skiplist* sl,
    apr_skiplist_compare XXX1,
    apr_skiplist_compare XXX2
);

apr_skiplistnode*
apr_skiplist_getlist(apr_skiplist* sl);

void*
apr_skiplist_find_compare(
    apr_skiplist* sl,
    void* data,
    apr_skiplistnode** iter,
    apr_skiplist_compare func
);

void*
apr_skiplist_find(
    apr_skiplist* sl,
    void* data,
    apr_skiplistnode** iter
);

void*
apr_skiplist_next(
    apr_skiplist* sl,
    apr_skiplistnode** iter
);

void*
apr_skiplist_previous(
    apr_skiplist* sl,
    apr_skiplistnode** iter
);

apr_skiplistnode*
apr_skiplist_insert_compare(
    apr_skiplist* sl,
    void* data,
    apr_skiplist_compare comp
);

apr_skiplistnode*
apr_skiplist_insert(
    apr_skiplist* sl,
    void* data
);

int
apr_skiplist_remove_compare(
    apr_skiplist* sl,
    void* data,
    apr_skiplist_freefunc myfree,
    apr_skiplist_compare comp
);

int
apr_skiplist_remove(
    apr_skiplist* sl,
    void* data,
    apr_skiplist_freefunc myfree
);

void
apr_skiplist_remove_all(
    apr_skiplist* sl,
    apr_skiplist_freefunc myfree
);

void
apr_skiplist_destroy(
    apr_skiplist* sl,
    apr_skiplist_freefunc myfree
);

void*
apr_skiplist_pop(
    apr_skiplist* sl,
    apr_skiplist_freefunc myfree
);

void*
apr_skiplist_peek(apr_skiplist* sl);

apr_skiplist*
apr_skiplist_merge(
    apr_skiplist* sl1,
    apr_skiplist* sl2
);

int
apr_strnatcmp(
    char const* a,
    char const* b
);

int
apr_strnatcasecmp(
    char const* a,
    char const* b
);

char*
apr_pstrdup(
    apr_pool_t* p,
    const char* s
);

char*
apr_pstrmemdup(
    apr_pool_t* p,
    const char* s,
    apr_size_t n
);

char*
apr_pstrndup(
    apr_pool_t* p,
    const char* s,
    apr_size_t n
);

void*
apr_pmemdup(
    apr_pool_t* p,
    const void* m,
    apr_size_t n
);

char*
apr_pstrcat(
    apr_pool_t* p,
    ...
);

char*
apr_pstrcatv(
    apr_pool_t* p,
    const struct iovec* vec,
    apr_size_t nvec,
    apr_size_t* nbytes
);

char*
apr_pvsprintf(
    apr_pool_t* p,
    const char* fmt,
    va_list ap
);

char*
apr_psprintf(
    apr_pool_t* p,
    const char* fmt,
    ...
);

char*
apr_cpystrn(
    char* dst,
    const char* src,
    apr_size_t dst_size
);

char*
apr_collapse_spaces(
    char* dest,
    const char* src
);

apr_status_t
apr_tokenize_to_argv(
    const char* arg_str,
    char*** argv_out,
    apr_pool_t* token_context
);

char*
apr_strtok(
    char* str,
    const char* sep,
    char** last
);

int
apr_snprintf(
    char* buf,
    apr_size_t len,
    const char* format,
    ...
);

int
apr_vsnprintf(
    char* buf,
    apr_size_t len,
    const char* format,
    va_list ap
);

char*
apr_itoa(
    apr_pool_t* p,
    int n
);

char*
apr_ltoa(
    apr_pool_t* p,
    long n
);

char*
apr_off_t_toa(
    apr_pool_t* p,
    apr_off_t n
);

apr_status_t
apr_strtoff(
    apr_off_t* offset,
    const char* buf,
    char** end,
    int base
);

apr_int64_t
apr_strtoi64(
    const char* buf,
    char** end,
    int base
);

apr_int64_t
apr_atoi64(const char* buf);

char*
apr_strfsize(
    apr_off_t size,
    char* buf
);

apr_status_t
apr_wait_for_io_or_timeout(
    apr_file_t* f,
    apr_socket_t* s,
    int for_read
);

const apr_array_header_t*
apr_table_elts(const apr_table_t* t);

int
apr_is_empty_table(const apr_table_t* t);

int
apr_is_empty_array(const apr_array_header_t* a);

apr_array_header_t*
apr_array_make(
    apr_pool_t* p,
    int nelts,
    int elt_size
);

void*
apr_array_push(apr_array_header_t* arr);

void*
apr_array_pop(apr_array_header_t* arr);

void
apr_array_clear(apr_array_header_t* arr);

void
apr_array_cat(
    apr_array_header_t* dst,
    const apr_array_header_t* src
);

apr_array_header_t*
apr_array_copy(
    apr_pool_t* p,
    const apr_array_header_t* arr
);

apr_array_header_t*
apr_array_copy_hdr(
    apr_pool_t* p,
    const apr_array_header_t* arr
);

apr_array_header_t*
apr_array_append(
    apr_pool_t* p,
    const apr_array_header_t* first,
    const apr_array_header_t* second
);

char*
apr_array_pstrcat(
    apr_pool_t* p,
    const apr_array_header_t* arr,
    const char sep
);

apr_table_t*
apr_table_make(
    apr_pool_t* p,
    int nelts
);

apr_table_t*
apr_table_copy(
    apr_pool_t* p,
    const apr_table_t* t
);

apr_table_t*
apr_table_clone(
    apr_pool_t* p,
    const apr_table_t* t
);

void
apr_table_clear(apr_table_t* t);

const char*
apr_table_get(
    const apr_table_t* t,
    const char* key
);

const char*
apr_table_getm(
    apr_pool_t* p,
    const apr_table_t* t,
    const char* key
);

void
apr_table_set(
    apr_table_t* t,
    const char* key,
    const char* val
);

void
apr_table_setn(
    apr_table_t* t,
    const char* key,
    const char* val
);

void
apr_table_unset(
    apr_table_t* t,
    const char* key
);

void
apr_table_merge(
    apr_table_t* t,
    const char* key,
    const char* val
);

void
apr_table_mergen(
    apr_table_t* t,
    const char* key,
    const char* val
);

void
apr_table_add(
    apr_table_t* t,
    const char* key,
    const char* val
);

void
apr_table_addn(
    apr_table_t* t,
    const char* key,
    const char* val
);

apr_table_t*
apr_table_overlay(
    apr_pool_t* p,
    const apr_table_t* overlay,
    const apr_table_t* base
);

int
apr_table_do(
    apr_table_do_callback_fn_t* comp,
    void* rec,
    const apr_table_t* t,
    ...
);

int
apr_table_vdo(
    apr_table_do_callback_fn_t* comp,
    void* rec,
    const apr_table_t* t,
    va_list vp
);

void
apr_table_overlap(
    apr_table_t* a,
    const apr_table_t* b,
    unsigned flags
);

void
apr_table_compress(
    apr_table_t* t,
    unsigned flags
);

apr_status_t
apr_thread_cond_create(
    apr_thread_cond_t** cond,
    apr_pool_t* pool
);

apr_status_t
apr_thread_cond_wait(
    apr_thread_cond_t* cond,
    apr_thread_mutex_t* mutex
);

apr_status_t
apr_thread_cond_timedwait(
    apr_thread_cond_t* cond,
    apr_thread_mutex_t* mutex,
    apr_interval_time_t timeout
);

apr_status_t
apr_thread_cond_signal(apr_thread_cond_t* cond);

apr_status_t
apr_thread_cond_broadcast(apr_thread_cond_t* cond);

apr_status_t
apr_thread_cond_destroy(apr_thread_cond_t* cond);

apr_pool_t*
apr_thread_cond_pool_get(const apr_thread_cond_t* thethread_cond);

apr_status_t
apr_thread_mutex_create(
    apr_thread_mutex_t** mutex,
    unsigned int flags,
    apr_pool_t* pool
);

apr_status_t
apr_thread_mutex_lock(apr_thread_mutex_t* mutex);

apr_status_t
apr_thread_mutex_trylock(apr_thread_mutex_t* mutex);

apr_status_t
apr_thread_mutex_unlock(apr_thread_mutex_t* mutex);

apr_status_t
apr_thread_mutex_destroy(apr_thread_mutex_t* mutex);

apr_pool_t*
apr_thread_mutex_pool_get(const apr_thread_mutex_t* thethread_mutex);

apr_status_t
apr_threadattr_create(
    apr_threadattr_t** new_attr,
    apr_pool_t* cont
);

apr_status_t
apr_threadattr_detach_set(
    apr_threadattr_t* attr,
    apr_int32_t on
);

apr_status_t
apr_threadattr_detach_get(apr_threadattr_t* attr);

apr_status_t
apr_threadattr_stacksize_set(
    apr_threadattr_t* attr,
    apr_size_t stacksize
);

apr_status_t
apr_threadattr_guardsize_set(
    apr_threadattr_t* attr,
    apr_size_t guardsize
);

apr_status_t
apr_thread_create(
    apr_thread_t** new_thread,
    apr_threadattr_t* attr,
    apr_thread_start_t func,
    void* data,
    apr_pool_t* cont
);

apr_status_t
apr_thread_exit(
    apr_thread_t* thd,
    apr_status_t retval
);

apr_status_t
apr_thread_join(
    apr_status_t* retval,
    apr_thread_t* thd
);

void
apr_thread_yield(void);

apr_status_t
apr_thread_once_init(
    apr_thread_once_t** control,
    apr_pool_t* p
);

apr_status_t
apr_thread_once(
    apr_thread_once_t* control,
    void(*)(void) func
);

apr_status_t
apr_thread_detach(apr_thread_t* thd);

apr_status_t
apr_thread_data_get(
    void** data,
    const char* key,
    apr_thread_t* thread
);

apr_status_t
apr_thread_data_set(
    void* data,
    const char* key,
    apr_status_t(*)(void*) cleanup,
    apr_thread_t* thread
);

apr_status_t
apr_threadkey_private_create(
    apr_threadkey_t** key,
    void(*)(void*) dest,
    apr_pool_t* cont
);

apr_status_t
apr_threadkey_private_get(
    void** new_mem,
    apr_threadkey_t* key
);

apr_status_t
apr_threadkey_private_set(
    void* priv,
    apr_threadkey_t* key
);

apr_status_t
apr_threadkey_private_delete(apr_threadkey_t* key);

apr_status_t
apr_threadkey_data_get(
    void** data,
    const char* key,
    apr_threadkey_t* threadkey
);

apr_status_t
apr_threadkey_data_set(
    void* data,
    const char* key,
    apr_status_t(*)(void*) cleanup,
    apr_threadkey_t* threadkey
);

apr_status_t
apr_procattr_create(
    apr_procattr_t** new_attr,
    apr_pool_t* cont
);

apr_status_t
apr_procattr_io_set(
    apr_procattr_t* attr,
    apr_int32_t in,
    apr_int32_t out,
    apr_int32_t err
);

apr_status_t
apr_procattr_child_in_set(
    struct apr_procattr_t* attr,
    apr_file_t* child_in,
    apr_file_t* parent_in
);

apr_status_t
apr_procattr_child_out_set(
    struct apr_procattr_t* attr,
    apr_file_t* child_out,
    apr_file_t* parent_out
);

apr_status_t
apr_procattr_child_err_set(
    struct apr_procattr_t* attr,
    apr_file_t* child_err,
    apr_file_t* parent_err
);

apr_status_t
apr_procattr_dir_set(
    apr_procattr_t* attr,
    const char* dir
);

apr_status_t
apr_procattr_cmdtype_set(
    apr_procattr_t* attr,
    apr_cmdtype_e cmd
);

apr_status_t
apr_procattr_detach_set(
    apr_procattr_t* attr,
    apr_int32_t detach
);

apr_status_t
apr_procattr_limit_set(
    apr_procattr_t* attr,
    apr_int32_t what,
    struct rlimit* limit
);

apr_status_t
apr_procattr_child_errfn_set(
    apr_procattr_t* attr,
    apr_child_errfn_t* errfn
);

apr_status_t
apr_procattr_error_check_set(
    apr_procattr_t* attr,
    apr_int32_t chk
);

apr_status_t
apr_procattr_addrspace_set(
    apr_procattr_t* attr,
    apr_int32_t addrspace
);

apr_status_t
apr_procattr_user_set(
    apr_procattr_t* attr,
    const char* username,
    const char* password
);

apr_status_t
apr_procattr_group_set(
    apr_procattr_t* attr,
    const char* groupname
);

apr_status_t
apr_proc_fork(
    apr_proc_t* proc,
    apr_pool_t* cont
);

apr_status_t
apr_proc_create(
    apr_proc_t* new_proc,
    const char* progname,
    const char*const* args,
    const char*const* env,
    apr_procattr_t* attr,
    apr_pool_t* pool
);

apr_status_t
apr_proc_wait(
    apr_proc_t* proc,
    int* exitcode,
    apr_exit_why_e* exitwhy,
    apr_wait_how_e waithow
);

apr_status_t
apr_proc_wait_all_procs(
    apr_proc_t* proc,
    int* exitcode,
    apr_exit_why_e* exitwhy,
    apr_wait_how_e waithow,
    apr_pool_t* p
);

apr_status_t
apr_proc_detach(int daemonize);

void
apr_proc_other_child_register(
    apr_proc_t* proc,
    void(*)(int reason, void*, int status) maintenance,
    void* data,
    apr_file_t* write_fd,
    apr_pool_t* p
);

void
apr_proc_other_child_unregister(void* data);

apr_status_t
apr_proc_other_child_alert(
    apr_proc_t* proc,
    int reason,
    int status
);

void
apr_proc_other_child_refresh(
    apr_other_child_rec_t* ocr,
    int reason
);

void
apr_proc_other_child_refresh_all(int reason);

apr_status_t
apr_proc_kill(
    apr_proc_t* proc,
    int sig
);

void
apr_pool_note_subprocess(
    apr_pool_t* a,
    apr_proc_t* proc,
    apr_kill_conditions_e how
);

apr_status_t
apr_setup_signal_thread(void);

apr_status_t
apr_signal_thread(int(*)(int signum) signal_handler);

apr_pool_t*
apr_thread_pool_get(const apr_thread_t* thethread);

apr_status_t
apr_thread_rwlock_create(
    apr_thread_rwlock_t** rwlock,
    apr_pool_t* pool
);

apr_status_t
apr_thread_rwlock_rdlock(apr_thread_rwlock_t* rwlock);

apr_status_t
apr_thread_rwlock_tryrdlock(apr_thread_rwlock_t* rwlock);

apr_status_t
apr_thread_rwlock_wrlock(apr_thread_rwlock_t* rwlock);

apr_status_t
apr_thread_rwlock_trywrlock(apr_thread_rwlock_t* rwlock);

apr_status_t
apr_thread_rwlock_unlock(apr_thread_rwlock_t* rwlock);

apr_status_t
apr_thread_rwlock_destroy(apr_thread_rwlock_t* rwlock);

apr_pool_t*
apr_thread_rwlock_pool_get(const apr_thread_rwlock_t* thethread_rwlock);

apr_time_t
apr_time_now(void);

apr_status_t
apr_time_ansi_put(
    apr_time_t* result,
    time_t input
);

apr_status_t
apr_time_exp_tz(
    apr_time_exp_t* result,
    apr_time_t input,
    apr_int32_t offs
);

apr_status_t
apr_time_exp_gmt(
    apr_time_exp_t* result,
    apr_time_t input
);

apr_status_t
apr_time_exp_lt(
    apr_time_exp_t* result,
    apr_time_t input
);

apr_status_t
apr_time_exp_get(
    apr_time_t* result,
    apr_time_exp_t* input
);

apr_status_t
apr_time_exp_gmt_get(
    apr_time_t* result,
    apr_time_exp_t* input
);

void
apr_sleep(apr_interval_time_t t);

apr_status_t
apr_rfc822_date(
    char* date_str,
    apr_time_t t
);

apr_status_t
apr_ctime(
    char* date_str,
    apr_time_t t
);

apr_status_t
apr_strftime(
    char* s,
    apr_size_t* retsize,
    apr_size_t max,
    const char* format,
    apr_time_exp_t* tm
);

void
apr_time_clock_hires(apr_pool_t* p);

apr_status_t
apr_uid_current(
    apr_uid_t* userid,
    apr_gid_t* groupid,
    apr_pool_t* p
);

apr_status_t
apr_uid_name_get(
    char** username,
    apr_uid_t userid,
    apr_pool_t* p
);

apr_status_t
apr_uid_get(
    apr_uid_t* userid,
    apr_gid_t* groupid,
    const char* username,
    apr_pool_t* p
);

apr_status_t
apr_uid_homepath_get(
    char** dirname,
    const char* username,
    apr_pool_t* p
);

apr_status_t
apr_gid_name_get(
    char** groupname,
    apr_gid_t groupid,
    apr_pool_t* p
);

apr_status_t
apr_gid_get(
    apr_gid_t* groupid,
    const char* groupname,
    apr_pool_t* p
);

void
apr_version(apr_version_t* pvsn);

const char*
apr_version_string(void);

void
apr__SHA256_Init(SHA256_CTX*);

void
apr__SHA256_Update(
    SHA256_CTX*,
    const apr_byte_t*,
    size_t
);

void
apr__SHA256_Final(
    apr_byte_t[SHA256_DIGEST_LENGTH],
    SHA256_CTX*
);

char*
apr__SHA256_End(
    SHA256_CTX*,
    char[SHA256_DIGEST_STRING_LENGTH]
);

char*
apr__SHA256_Data(
    const apr_byte_t*,
    size_t,
    char[SHA256_DIGEST_STRING_LENGTH]
);

// macros

#define APRMAXHOSTLEN

#define APR_ALIGN( \
    size, \
    boundary \
)

#define APR_ALIGN_DEFAULT(size)
#define APR_ALLOCATOR_MAX_FREE_UNLIMITED
#define APR_ANONYMOUS
#define APR_ANYADDR
#define APR_APPEND

#define APR_ARRAY_IDX( \
    ary, \
    i, \
    type \
)

#define APR_ARRAY_PUSH( \
    ary, \
    type \
)

#define APR_ASCII_BLANK
#define APR_ASCII_CR
#define APR_ASCII_LF
#define APR_ASCII_TAB
#define APR_BADARG
#define APR_BADCH
#define APR_BEGIN_DECLS
#define APR_BINARY
#define APR_BUFFERED
#define APR_CHARSET_EBCDIC
#define APR_CHILD_BLOCK
#define APR_CHILD_DONE
#define APR_CHILD_NOTDONE
#define APR_COPYRIGHT
#define APR_CREATE
#define APR_CTIME_LEN
#define APR_CUR
#define APR_DECLARE(type)
#define APR_DECLARE_DATA
#define APR_DECLARE_INHERIT_SET(type)
#define APR_DECLARE_INHERIT_UNSET(type)
#define APR_DECLARE_NONSTD(type)
#define APR_DELONCLOSE
#define APR_DETACH
#define APR_DSOPATH
#define APR_EABOVEROOT
#define APR_EABSOLUTE
#define APR_EACCES
#define APR_EAFNOSUPPORT
#define APR_EAGAIN
#define APR_EBADDATE
#define APR_EBADF
#define APR_EBADIP
#define APR_EBADMASK
#define APR_EBADPATH
#define APR_EBUSY
#define APR_ECONNABORTED
#define APR_ECONNREFUSED
#define APR_ECONNRESET
#define APR_EDSOOPEN
#define APR_EEXIST
#define APR_EFTYPE
#define APR_EGENERAL
#define APR_EHOSTUNREACH
#define APR_EINCOMPLETE
#define APR_EINIT
#define APR_EINPROGRESS
#define APR_EINTR
#define APR_EINVAL
#define APR_EINVALSOCK
#define APR_EMFILE
#define APR_EMISMATCH
#define APR_ENAMETOOLONG
#define APR_END
#define APR_END_DECLS
#define APR_ENETUNREACH
#define APR_ENFILE
#define APR_ENODIR
#define APR_ENOENT
#define APR_ENOLOCK
#define APR_ENOMEM
#define APR_ENOPOLL
#define APR_ENOPOOL
#define APR_ENOPROC
#define APR_ENOSHMAVAIL
#define APR_ENOSOCKET
#define APR_ENOSPC
#define APR_ENOSTAT
#define APR_ENOTDIR
#define APR_ENOTEMPTY
#define APR_ENOTENOUGHENTROPY
#define APR_ENOTHDKEY
#define APR_ENOTHREAD
#define APR_ENOTIME
#define APR_ENOTIMPL
#define APR_ENOTSOCK
#define APR_EOF
#define APR_EOL_STR
#define APR_EPATHWILD
#define APR_EPIPE
#define APR_EPROC_UNKNOWN
#define APR_ERELATIVE
#define APR_ESCAPE_STRING
#define APR_ESPIPE
#define APR_ESYMNOTFOUND
#define APR_ETIMEDOUT
#define APR_EXCL
#define APR_EXDEV
#define APR_FILEBASED
#define APR_FILEPATH_ENCODING_LOCALE
#define APR_FILEPATH_ENCODING_UNKNOWN
#define APR_FILEPATH_ENCODING_UTF8
#define APR_FILEPATH_NATIVE
#define APR_FILEPATH_NOTABOVEROOT
#define APR_FILEPATH_NOTABSOLUTE
#define APR_FILEPATH_NOTRELATIVE
#define APR_FILEPATH_SECUREROOT
#define APR_FILEPATH_SECUREROOTTEST
#define APR_FILEPATH_TRUENAME
#define APR_FILES_AS_SOCKETS
#define APR_FILE_ATTR_EXECUTABLE
#define APR_FILE_ATTR_HIDDEN
#define APR_FILE_ATTR_READONLY
#define APR_FILE_NOCLEANUP
#define APR_FILE_SOURCE_PERMS
#define APR_FINFO_ATIME
#define APR_FINFO_CSIZE
#define APR_FINFO_CTIME
#define APR_FINFO_DEV
#define APR_FINFO_DIRENT
#define APR_FINFO_GPROT
#define APR_FINFO_GROUP
#define APR_FINFO_ICASE
#define APR_FINFO_IDENT
#define APR_FINFO_INODE
#define APR_FINFO_LINK
#define APR_FINFO_MIN
#define APR_FINFO_MTIME
#define APR_FINFO_NAME
#define APR_FINFO_NLINK
#define APR_FINFO_NORM
#define APR_FINFO_OWNER
#define APR_FINFO_PROT
#define APR_FINFO_SIZE
#define APR_FINFO_TYPE
#define APR_FINFO_UPROT
#define APR_FINFO_USER
#define APR_FINFO_WPROT
#define APR_FLOCK_EXCLUSIVE
#define APR_FLOCK_NONBLOCK
#define APR_FLOCK_SHARED
#define APR_FLOCK_TYPEMASK
#define APR_FNM_CASE_BLIND
#define APR_FNM_NOESCAPE
#define APR_FNM_NOMATCH
#define APR_FNM_PATHNAME
#define APR_FNM_PERIOD
#define APR_FOPEN_APPEND
#define APR_FOPEN_BINARY
#define APR_FOPEN_BUFFERED
#define APR_FOPEN_CREATE
#define APR_FOPEN_DELONCLOSE
#define APR_FOPEN_EXCL
#define APR_FOPEN_LARGEFILE
#define APR_FOPEN_NOCLEANUP
#define APR_FOPEN_NONBLOCK
#define APR_FOPEN_READ
#define APR_FOPEN_SENDFILE_ENABLED
#define APR_FOPEN_SHARELOCK
#define APR_FOPEN_SPARSE
#define APR_FOPEN_TRUNCATE
#define APR_FOPEN_WRITE
#define APR_FOPEN_XTHREAD
#define APR_FPROT_FILE_SOURCE_PERMS
#define APR_FPROT_GEXECUTE
#define APR_FPROT_GREAD
#define APR_FPROT_GSETID
#define APR_FPROT_GWRITE
#define APR_FPROT_OS_DEFAULT
#define APR_FPROT_UEXECUTE
#define APR_FPROT_UREAD
#define APR_FPROT_USETID
#define APR_FPROT_UWRITE
#define APR_FPROT_WEXECUTE
#define APR_FPROT_WREAD
#define APR_FPROT_WSTICKY
#define APR_FPROT_WWRITE
#define APR_FROM_OS_ERROR(e)
#define APR_FULL_BLOCK
#define APR_FULL_NONBLOCK
#define APR_GEXECUTE
#define APR_GREAD
#define APR_GSETID
#define APR_GWRITE
#define APR_HASH_KEY_STRING
#define APR_HAS_DSO
#define APR_HAS_FCNTL_SERIALIZE
#define APR_HAS_FLOCK_SERIALIZE
#define APR_HAS_FORK
#define APR_HAS_INLINE
#define APR_HAS_LARGE_FILES
#define APR_HAS_MMAP
#define APR_HAS_OS_UUID
#define APR_HAS_OTHER_CHILD
#define APR_HAS_POSIXSEM_SERIALIZE
#define APR_HAS_PROC_INVOKED
#define APR_HAS_PROC_PTHREAD_SERIALIZE
#define APR_HAS_RANDOM
#define APR_HAS_SENDFILE
#define APR_HAS_SHARED_MEMORY
#define APR_HAS_SO_ACCEPTFILTER
#define APR_HAS_SYSVSEM_SERIALIZE
#define APR_HAS_THREADS
#define APR_HAS_UNICODE_FS
#define APR_HAS_USER
#define APR_HAS_XTHREAD_FILES
#define APR_HAVE_ARPA_INET_H
#define APR_HAVE_CONIO_H
#define APR_HAVE_CORKABLE_TCP
#define APR_HAVE_CRYPT_H
#define APR_HAVE_CTYPE_H
#define APR_HAVE_DIRENT_H
#define APR_HAVE_ERRNO_H
#define APR_HAVE_FCNTL_H
#define APR_HAVE_GETRLIMIT
#define APR_HAVE_INET_ADDR
#define APR_HAVE_INET_NETWORK
#define APR_HAVE_IN_ADDR
#define APR_HAVE_IOVEC
#define APR_HAVE_IO_H
#define APR_HAVE_IPV6
#define APR_HAVE_LIMITS_H
#define APR_HAVE_MEMCHR
#define APR_HAVE_MEMMOVE
#define APR_HAVE_NETDB_H
#define APR_HAVE_NETINET_IN_H
#define APR_HAVE_NETINET_SCTP_H
#define APR_HAVE_NETINET_SCTP_UIO_H
#define APR_HAVE_NETINET_TCP_H
#define APR_HAVE_PROCESS_H
#define APR_HAVE_PTHREAD_H
#define APR_HAVE_SA_STORAGE
#define APR_HAVE_SCTP
#define APR_HAVE_SEMAPHORE_H
#define APR_HAVE_SETRLIMIT
#define APR_HAVE_SHMEM_BEOS
#define APR_HAVE_SHMEM_MMAP_ANON
#define APR_HAVE_SHMEM_MMAP_SHM
#define APR_HAVE_SHMEM_MMAP_TMP
#define APR_HAVE_SHMEM_MMAP_ZERO
#define APR_HAVE_SHMEM_SHMGET
#define APR_HAVE_SHMEM_SHMGET_ANON
#define APR_HAVE_SIGACTION
#define APR_HAVE_SIGNAL_H
#define APR_HAVE_SIGSUSPEND
#define APR_HAVE_SIGWAIT
#define APR_HAVE_STDARG_H
#define APR_HAVE_STDINT_H
#define APR_HAVE_STDIO_H
#define APR_HAVE_STDLIB_H
#define APR_HAVE_STRCASECMP
#define APR_HAVE_STRDUP
#define APR_HAVE_STRICMP
#define APR_HAVE_STRINGS_H
#define APR_HAVE_STRING_H
#define APR_HAVE_STRNCASECMP
#define APR_HAVE_STRNICMP
#define APR_HAVE_STRSTR
#define APR_HAVE_STRUCT_RLIMIT
#define APR_HAVE_SYS_IOCTL_H
#define APR_HAVE_SYS_SENDFILE_H
#define APR_HAVE_SYS_SIGNAL_H
#define APR_HAVE_SYS_SOCKET_H
#define APR_HAVE_SYS_SOCKIO_H
#define APR_HAVE_SYS_SYSLIMITS_H
#define APR_HAVE_SYS_TIME_H
#define APR_HAVE_SYS_TYPES_H
#define APR_HAVE_SYS_UIO_H
#define APR_HAVE_SYS_UN_H
#define APR_HAVE_SYS_WAIT_H
#define APR_HAVE_TIME_H
#define APR_HAVE_UNION_SEMUN
#define APR_HAVE_UNISTD_H
#define APR_HAVE_WINDOWS_H
#define APR_HAVE_WINSOCK2_H
#define APR_INADDR_NONE
#define APR_INCHILD
#define APR_INCOMPLETE
#define APR_INCOMPLETE_READ
#define APR_INCOMPLETE_WRITE
#define APR_INET
#define APR_INET6
#define APR_INLINE
#define APR_INPARENT
#define APR_INT16_MAX
#define APR_INT16_MIN
#define APR_INT32_MAX
#define APR_INT32_MIN
#define APR_INT64_C(val)
#define APR_INT64_MAX
#define APR_INT64_MIN
#define APR_INT64_T_FMT
#define APR_IPV4_ADDR_OK
#define APR_IPV6_ADDR_OK
#define APR_IPV6_V6ONLY
#define APR_IS_BIGENDIAN
#define APR_IS_DEV_STRING
#define APR_KEYBASED
#define APR_LARGEFILE
#define APR_LIMIT_CPU
#define APR_LIMIT_MEM
#define APR_LIMIT_NOFILE
#define APR_LIMIT_NPROC
#define APR_MAJOR_VERSION
#define APR_MAX_IOVEC_SIZE
#define APR_MAX_SECS_TO_LINGER
#define APR_MEMNODE_T_SIZE
#define APR_MINOR_VERSION
#define APR_MMAP_CANDIDATE(filelength)
#define APR_MMAP_LIMIT
#define APR_MMAP_READ
#define APR_MMAP_THRESHOLD
#define APR_MMAP_WRITE
#define APR_NOTDETACH
#define APR_NOTFOUND
#define APR_NO_FILE
#define APR_NO_PIPE
#define APR_OC_REASON_DEATH
#define APR_OC_REASON_LOST
#define APR_OC_REASON_RESTART
#define APR_OC_REASON_RUNNING
#define APR_OC_REASON_UNREGISTER
#define APR_OC_REASON_UNWRITABLE

#define APR_OFFSET( \
    p_type, \
    field \
)

#define APR_OFFSETOF( \
    s_type, \
    field \
)

#define APR_OFF_T_FMT
#define APR_OS_DEFAULT
#define APR_OS_ERRSPACE_SIZE
#define APR_OS_START_CANONERR
#define APR_OS_START_EAIERR
#define APR_OS_START_ERROR
#define APR_OS_START_STATUS
#define APR_OS_START_SYSERR
#define APR_OS_START_USEERR
#define APR_OS_START_USERERR
#define APR_OVERLAP_TABLES_MERGE
#define APR_OVERLAP_TABLES_SET
#define APR_O_NONBLOCK_INHERITED
#define APR_PARENT_BLOCK
#define APR_PATCH_VERSION
#define APR_PID_T_FMT
#define APR_POLLERR
#define APR_POLLHUP
#define APR_POLLIN
#define APR_POLLNVAL
#define APR_POLLOUT
#define APR_POLLPRI
#define APR_POLLSET_NOCOPY
#define APR_POLLSET_NODEFAULT
#define APR_POLLSET_THREADSAFE
#define APR_POLLSET_WAKEABLE
#define APR_POOL_DECLARE_ACCESSOR(type)
#define APR_POOL_IMPLEMENT_ACCESSOR(type)
#define APR_POOL__FILE_LINE__
#define APR_PROCATTR_USER_SET_REQUIRES_PASSWORD
#define APR_PROCESS_LOCK_IS_GLOBAL
#define APR_PROC_CHECK_CORE_DUMP(x)
#define APR_PROC_CHECK_EXIT(x)
#define APR_PROC_CHECK_SIGNALED(x)
#define APR_PROC_DETACH_DAEMONIZE
#define APR_PROC_DETACH_FOREGROUND
#define APR_PROC_MUTEX_IS_GLOBAL
#define APR_PROTO_SCTP
#define APR_PROTO_TCP
#define APR_PROTO_UDP
#define APR_READ
#define APR_READ_BLOCK
#define APR_RESET_NODELAY
#define APR_RFC822_DATE_LEN

#define APR_RING_CHECK( \
    hp, \
    elem, \
    link, \
    msg \
)

#define APR_RING_CHECK_CONSISTENCY( \
    hp, \
    elem, \
    link \
)

#define APR_RING_CHECK_ELEM( \
    ep, \
    elem, \
    link, \
    msg \
)

#define APR_RING_CHECK_ELEM_CONSISTENCY( \
    ep, \
    elem, \
    link \
)

#define APR_RING_CHECK_ONE( \
    msg, \
    ptr \
)

#define APR_RING_CONCAT( \
    h1, \
    h2, \
    elem, \
    link \
)

#define APR_RING_ELEM_INIT( \
    ep, \
    link \
)

#define APR_RING_EMPTY( \
    hp, \
    elem, \
    link \
)

#define APR_RING_ENTRY(elem)
#define APR_RING_FIRST(hp)

#define APR_RING_FOREACH( \
    ep, \
    head, \
    elem, \
    link \
)

#define APR_RING_FOREACH_SAFE( \
    ep1, \
    ep2, \
    head, \
    elem, \
    link \
)

#define APR_RING_HEAD( \
    head, \
    elem \
)

#define APR_RING_INIT( \
    hp, \
    elem, \
    link \
)

#define APR_RING_INSERT_AFTER( \
    lep, \
    nep, \
    link \
)

#define APR_RING_INSERT_BEFORE( \
    lep, \
    nep, \
    link \
)

#define APR_RING_INSERT_HEAD( \
    hp, \
    nep, \
    elem, \
    link \
)

#define APR_RING_INSERT_TAIL( \
    hp, \
    nep, \
    elem, \
    link \
)

#define APR_RING_LAST(hp)

#define APR_RING_NEXT( \
    ep, \
    link \
)

#define APR_RING_PREPEND( \
    h1, \
    h2, \
    elem, \
    link \
)

#define APR_RING_PREV( \
    ep, \
    link \
)

#define APR_RING_REMOVE( \
    ep, \
    link \
)

#define APR_RING_SENTINEL( \
    hp, \
    elem, \
    link \
)

#define APR_RING_SPLICE_AFTER( \
    lep, \
    ep1, \
    epN, \
    link \
)

#define APR_RING_SPLICE_BEFORE( \
    lep, \
    ep1, \
    epN, \
    link \
)

#define APR_RING_SPLICE_HEAD( \
    hp, \
    ep1, \
    epN, \
    elem, \
    link \
)

#define APR_RING_SPLICE_TAIL( \
    hp, \
    ep1, \
    epN, \
    elem, \
    link \
)

#define APR_RING_UNSPLICE( \
    ep1, \
    epN, \
    link \
)

#define APR_SENDFILE_DISCONNECT_SOCKET
#define APR_SENDFILE_ENABLED
#define APR_SET
#define APR_SHARELOCK
#define APR_SHM_NS_GLOBAL
#define APR_SHM_NS_LOCAL
#define APR_SIZEOF_VOIDP
#define APR_SIZE_MAX
#define APR_SIZE_T_FMT
#define APR_SO_BROADCAST
#define APR_SO_DEBUG
#define APR_SO_DISCONNECTED
#define APR_SO_KEEPALIVE
#define APR_SO_LINGER
#define APR_SO_NONBLOCK
#define APR_SO_RCVBUF
#define APR_SO_REUSEADDR
#define APR_SO_SNDBUF
#define APR_SSIZE_T_FMT
#define APR_STATUS_IS_ANONYMOUS(s)
#define APR_STATUS_IS_BADARG(s)
#define APR_STATUS_IS_BADCH(s)
#define APR_STATUS_IS_CHILD_DONE(s)
#define APR_STATUS_IS_CHILD_NOTDONE(s)
#define APR_STATUS_IS_DETACH(s)
#define APR_STATUS_IS_EABOVEROOT(s)
#define APR_STATUS_IS_EABSOLUTE(s)
#define APR_STATUS_IS_EACCES(s)
#define APR_STATUS_IS_EAFNOSUPPORT(s)
#define APR_STATUS_IS_EAGAIN(s)
#define APR_STATUS_IS_EBADDATE(s)
#define APR_STATUS_IS_EBADF(s)
#define APR_STATUS_IS_EBADIP(s)
#define APR_STATUS_IS_EBADMASK(s)
#define APR_STATUS_IS_EBADPATH(s)
#define APR_STATUS_IS_EBUSY(s)
#define APR_STATUS_IS_ECONNABORTED(s)
#define APR_STATUS_IS_ECONNREFUSED(s)
#define APR_STATUS_IS_ECONNRESET(s)
#define APR_STATUS_IS_EDSOOPEN(s)
#define APR_STATUS_IS_EEXIST(s)
#define APR_STATUS_IS_EFTYPE(s)
#define APR_STATUS_IS_EGENERAL(s)
#define APR_STATUS_IS_EHOSTUNREACH(s)
#define APR_STATUS_IS_EINCOMPLETE(s)
#define APR_STATUS_IS_EINIT(s)
#define APR_STATUS_IS_EINPROGRESS(s)
#define APR_STATUS_IS_EINTR(s)
#define APR_STATUS_IS_EINVAL(s)
#define APR_STATUS_IS_EINVALSOCK(s)
#define APR_STATUS_IS_EMFILE(s)
#define APR_STATUS_IS_EMISMATCH(s)
#define APR_STATUS_IS_ENAMETOOLONG(s)
#define APR_STATUS_IS_ENETUNREACH(s)
#define APR_STATUS_IS_ENFILE(s)
#define APR_STATUS_IS_ENODIR(s)
#define APR_STATUS_IS_ENOENT(s)
#define APR_STATUS_IS_ENOLOCK(s)
#define APR_STATUS_IS_ENOMEM(s)
#define APR_STATUS_IS_ENOPOLL(s)
#define APR_STATUS_IS_ENOPOOL(s)
#define APR_STATUS_IS_ENOPROC(s)
#define APR_STATUS_IS_ENOSHMAVAIL(s)
#define APR_STATUS_IS_ENOSOCKET(s)
#define APR_STATUS_IS_ENOSPC(s)
#define APR_STATUS_IS_ENOSTAT(s)
#define APR_STATUS_IS_ENOTDIR(s)
#define APR_STATUS_IS_ENOTEMPTY(s)
#define APR_STATUS_IS_ENOTENOUGHENTROPY(s)
#define APR_STATUS_IS_ENOTHDKEY(s)
#define APR_STATUS_IS_ENOTHREAD(s)
#define APR_STATUS_IS_ENOTIME(s)
#define APR_STATUS_IS_ENOTIMPL(s)
#define APR_STATUS_IS_ENOTSOCK(s)
#define APR_STATUS_IS_EOF(s)
#define APR_STATUS_IS_EPATHWILD(s)
#define APR_STATUS_IS_EPIPE(s)
#define APR_STATUS_IS_EPROC_UNKNOWN(s)
#define APR_STATUS_IS_ERELATIVE(s)
#define APR_STATUS_IS_ESPIPE(s)
#define APR_STATUS_IS_ESYMNOTFOUND(s)
#define APR_STATUS_IS_ETIMEDOUT(s)
#define APR_STATUS_IS_EXDEV(s)
#define APR_STATUS_IS_FILEBASED(s)
#define APR_STATUS_IS_INCHILD(s)
#define APR_STATUS_IS_INCOMPLETE(s)
#define APR_STATUS_IS_INPARENT(s)
#define APR_STATUS_IS_KEYBASED(s)
#define APR_STATUS_IS_NOTDETACH(s)
#define APR_STATUS_IS_NOTFOUND(s)
#define APR_STATUS_IS_TIMEUP(s)
#define APR_STRINGIFY(n)
#define APR_STRINGIFY_HELPER(n)
#define APR_SUCCESS
#define APR_TCP_DEFER_ACCEPT
#define APR_TCP_NODELAY
#define APR_TCP_NODELAY_INHERITED
#define APR_TCP_NOPUSH
#define APR_TCP_NOPUSH_FLAG
#define APR_THREAD_FUNC
#define APR_THREAD_MUTEX_DEFAULT
#define APR_THREAD_MUTEX_NESTED
#define APR_THREAD_MUTEX_UNNESTED
#define APR_TIMEUP
#define APR_TIME_C(val)
#define APR_TIME_T_FMT
#define APR_TO_OS_ERROR(e)
#define APR_TRUNCATE
#define APR_UEXECUTE
#define APR_UINT16_MAX
#define APR_UINT32_MAX
#define APR_UINT64_C(val)
#define APR_UINT64_MAX
#define APR_UINT64_T_FMT
#define APR_UINT64_T_HEX_FMT
#define APR_UNSPEC
#define APR_UREAD
#define APR_USEC_PER_SEC
#define APR_USETID
#define APR_USE_FCNTL_SERIALIZE
#define APR_USE_FLOCK_SERIALIZE
#define APR_USE_POSIXSEM_SERIALIZE
#define APR_USE_PROC_PTHREAD_SERIALIZE
#define APR_USE_PTHREAD_SERIALIZE
#define APR_USE_SHMEM_BEOS
#define APR_USE_SHMEM_MMAP_ANON
#define APR_USE_SHMEM_MMAP_SHM
#define APR_USE_SHMEM_MMAP_TMP
#define APR_USE_SHMEM_MMAP_ZERO
#define APR_USE_SHMEM_SHMGET
#define APR_USE_SHMEM_SHMGET_ANON
#define APR_USE_SYSVSEM_SERIALIZE
#define APR_UTIL_ERRSPACE_SIZE
#define APR_UTIL_START_STATUS
#define APR_UWRITE

#define APR_VERSION_AT_LEAST( \
    major, \
    minor, \
    patch \
)

#define APR_VERSION_STRING
#define APR_VERSION_STRING_CSV
#define APR_WANT_IOVEC
#define APR_WANT_IOVEC
#define APR_WANT_MEMFUNC
#define APR_WANT_MEMFUNC
#define APR_WANT_STDIO
#define APR_WEXECUTE
#define APR_WREAD
#define APR_WRITE
#define APR_WRITE_BLOCK
#define APR_WSTICKY
#define APR_WWRITE
#define APR_XTHREAD
#define HUGE_STRING_LEN
#define SHA256_BLOCK_LENGTH
#define SHA256_DIGEST_LENGTH
#define SHA256_DIGEST_STRING_LENGTH
#define WEXITSTATUS(status)
#define WTERMSIG(status)
#define apr_get_netos_error()
#define apr_get_os_error()

#define apr_gid_compare( \
    left, \
    right \
)

#define apr_inet_addr
#define apr_isalnum(c)
#define apr_isalpha(c)
#define apr_isascii(c)
#define apr_iscntrl(c)
#define apr_isdigit(c)
#define apr_isgraph(c)
#define apr_islower(c)
#define apr_isprint(c)
#define apr_ispunct(c)
#define apr_isspace(c)
#define apr_isupper(c)
#define apr_isxdigit(c)

#define apr_killpg( \
    x, \
    y \
)

#define apr_os_global_mutex_get
#define apr_os_global_mutex_t
#define apr_set_netos_error(e)
#define apr_set_os_error(e)
#define apr_time_as_msec(time)
#define apr_time_from_msec(msec)
#define apr_time_from_sec(sec)

#define apr_time_make( \
    sec, \
    usec \
)

#define apr_time_msec(time)
#define apr_time_sec(time)
#define apr_time_usec(time)
#define apr_tolower(c)
#define apr_toupper(c)

#define apr_uid_compare( \
    left, \
    right \
)

#define apr_wait_t

Detailed Documentation

Global Functions

void
apr_version(apr_version_t* pvsn)

Return APR’s version information information in a numeric form.

Parameters:

pvsn	Pointer to a version structure for returning the version information.

const char*
apr_version_string(void)

Return APR’s version information as a string.

Macros

#define APR_DECLARE_INHERIT_SET(type)

Prototype for type-specific declarations of apr_foo_inherit_set functions. Doxygen unwraps this macro (via doxygen.conf) to provide actual help for each specific occurrence of apr_foo_inherit_set.

the linkage is specified for APR. It would be possible to expand the macros to support other linkages.

#define APR_DECLARE_INHERIT_UNSET(type)

Prototype for type-specific declarations of apr_foo_inherit_unset functions. Doxygen unwraps this macro (via doxygen.conf) to provide actual help for each specific occurrence of apr_foo_inherit_unset.

the linkage is specified for APR. It would be possible to expand the macros to support other linkages.

#define APR_IS_DEV_STRING

Internal: string form of the “is dev” flag

#define APR_MAJOR_VERSION

major version Major API changes that could cause compatibility problems for older programs such as structure size changes. No binary compatibility is possible across a change in the major version.

#define APR_MINOR_VERSION

minor version Minor API changes that do not cause binary compatibility problems. Reset to 0 when upgrading APR_MAJOR_VERSION

#define APR_PATCH_VERSION

patch level The Patch Level never includes API changes, simply bug fixes. Reset to 0 when upgrading APR_MINOR_VERSION

#define APR_STRINGIFY(n)

Properly quote a value as a string in the C preprocessor

#define APR_STRINGIFY_HELPER(n)

Helper macro for APR_STRINGIFY

#define APR_VERSION_AT_LEAST( \
    major, \
    minor, \
    patch \
)

The symbol APR_IS_DEV_VERSION is only defined for internal, “development” copies of APR. It is undefined for released versions of APR. Check at compile time if the APR version is at least a certain level. This macro is available with APR versions starting with 1.3.0.

Parameters:

major	The major version component of the version checked for (e.g., the “1” of “1.3.0”).
minor	The minor version component of the version checked for (e.g., the “3” of “1.3.0”).
patch	The patch level component of the version checked for (e.g., the “0” of “1.3.0”).

#define APR_VERSION_STRING

The formatted string of APR’s version

#define APR_VERSION_STRING_CSV

An alternative formatted string of APR’s version

#define APR_WANT_IOVEC

for apr_file_writev

#define APR_WANT_MEMFUNC

For no good reason?

#define APR_WANT_MEMFUNC

for no good reason?

#define APR_WANT_STDIO

for SEEK_*