However the MPM may choose to terminate processes when the user
requests a non-graceful restart/stop. When this occurs, the MPM kills
all threads with extreme prejudice, and destroys the pchild pool.
- User cleanups registered in the pchild ap_context_t will be invoked at
+ User cleanups registered in the pchild ap_pool_t will be invoked at
this point. (This can pose some complications, the user cleanups
are asynchronous behaviour not unlike longjmp/signal... but if the
admin is asking for a non-graceful shutdown, how much effort should
/* run until a restart/shutdown is indicated, return 1 for shutdown
0 otherwise */
-API_EXPORT(int) ap_mpm_run(ap_context_t *pconf, ap_context_t *plog, server_rec *server_conf);
+API_EXPORT(int) ap_mpm_run(ap_pool_t *pconf, ap_pool_t *plog, server_rec *server_conf);
/* predicate indicating if a graceful stop has been requested ...
used by the connection loop */
/*
* ap_signal_parent() - used to send a signal to the parent process.
*/
-void ap_signal_parent(ap_context_t *p, const char* signal, const char* server_root);
+void ap_signal_parent(ap_pool_t *p, const char* signal, const char* server_root);
#ifdef HAS_OTHER_CHILD
/*
configfile_t *config_file; /* Config file structure from pcfg_openfile() */
- ap_context_t *pool; /* Pool to allocate new storage in */
- ap_context_t *temp_pool; /* Pool for scratch memory; persists during
+ ap_pool_t *pool; /* Pool to allocate new storage in */
+ ap_pool_t *temp_pool; /* Pool for scratch memory; persists during
* configuration, but wiped before the first
* request is served...
*/
* It's mainly important for the DSO facility
* (see also mod_so).
*/
- void (*pre_config) (ap_context_t *p, ap_context_t *plog, ap_context_t *ptemp);
- void *(*create_dir_config) (ap_context_t *p, char *dir);
- void *(*merge_dir_config) (ap_context_t *p, void *base_conf, void *new_conf);
- void *(*create_server_config) (ap_context_t *p, server_rec *s);
- void *(*merge_server_config) (ap_context_t *p, void *base_conf, void *new_conf);
+ void (*pre_config) (ap_pool_t *p, ap_pool_t *plog, ap_pool_t *ptemp);
+ void *(*create_dir_config) (ap_pool_t *p, char *dir);
+ void *(*merge_dir_config) (ap_pool_t *p, void *base_conf, void *new_conf);
+ void *(*create_server_config) (ap_pool_t *p, server_rec *s);
+ void *(*merge_server_config) (ap_pool_t *p, void *base_conf, void *new_conf);
const command_rec *cmds;
const handler_rec *handlers;
* it relativizes it wrt server_root.
*/
-API_EXPORT(const char *) ap_server_root_relative(ap_context_t *p, const char *fname);
+API_EXPORT(const char *) ap_server_root_relative(ap_pool_t *p, const char *fname);
/* Finally, the hook for dynamically loading modules in... */
/* For mod_so.c... */
-void ap_single_module_configure(ap_context_t *p, server_rec *s, module *m);
+void ap_single_module_configure(ap_pool_t *p, server_rec *s, module *m);
/* For http_main.c... */
void ap_setup_prelinked_modules(process_rec *process);
void ap_show_directives(void);
void ap_show_modules(void);
-server_rec *ap_read_config(process_rec *process, ap_context_t *temp_pool, const char *config_name);
-void ap_run_pre_config(ap_context_t *p, ap_context_t *plog, ap_context_t *ptemp);
-void ap_post_config_hook(ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp, server_rec *s);
-void ap_child_init_hook(ap_context_t *pchild, server_rec *s);
+server_rec *ap_read_config(process_rec *process, ap_pool_t *temp_pool, const char *config_name);
+void ap_post_config_hook(ap_pool_t *pconf, ap_pool_t *plog, ap_pool_t *ptemp, server_rec *s);
+void ap_child_init_hook(ap_pool_t *pchild, server_rec *s);
+
void ap_register_hooks(module *m);
void ap_hook_deregister_all(void);
/* For http_request.c... */
-void *ap_create_request_config(ap_context_t *p);
-CORE_EXPORT(void *) ap_create_per_dir_config(ap_context_t *p);
-void *ap_merge_per_dir_configs(ap_context_t *p, void *base, void *new);
+void *ap_create_request_config(ap_pool_t *p);
+CORE_EXPORT(void *) ap_create_per_dir_config(ap_pool_t *p);
+void *ap_merge_per_dir_configs(ap_pool_t *p, void *base, void *new);
/* For http_connection.c... */
-void *ap_create_conn_config(ap_context_t *p);
+void *ap_create_conn_config(ap_pool_t *p);
/* For http_core.c... (<Directory> command and virtual hosts) */
int ap_parse_htaccess(void **result, request_rec *r, int override,
const char *path, const char *access_name);
-CORE_EXPORT(const char *) ap_init_virtual_host(ap_context_t *p, const char *hostname,
+CORE_EXPORT(const char *) ap_init_virtual_host(ap_pool_t *p, const char *hostname,
server_rec *main_server, server_rec **);
-void ap_process_resource_config(server_rec *s, const char *fname, ap_context_t *p, ap_context_t *ptemp);
+void ap_process_resource_config(server_rec *s, const char *fname, ap_pool_t *p, ap_pool_t *ptemp);
/* Module-method dispatchers, also for http_request.c */
/* Hooks */
DECLARE_HOOK(int,header_parser,(request_rec *))
DECLARE_HOOK(void,post_config,
- (ap_context_t *pconf,ap_context_t *plog,ap_context_t *ptemp,server_rec *s))
+ (ap_pool_t *pconf,ap_pool_t *plog,ap_pool_t *ptemp,server_rec *s))
DECLARE_HOOK(void,open_logs,
- (ap_context_t *pconf,ap_context_t *plog,ap_context_t *ptemp,server_rec *s))
-DECLARE_HOOK(void,child_init,(ap_context_t *pchild, server_rec *s))
+ (ap_pool_t *pconf,ap_pool_t *plog,ap_pool_t *ptemp,server_rec *s))
+DECLARE_HOOK(void,child_init,(ap_pool_t *pchild, server_rec *s))
#ifdef __cplusplus
}
#endif
#ifdef CORE_PRIVATE
-conn_rec *ap_new_connection(ap_context_t *p, server_rec *server, BUFF *inout,
+conn_rec *ap_new_connection(ap_pool_t *p, server_rec *server, BUFF *inout,
const struct sockaddr_in *remaddr,
const struct sockaddr_in *saddr, long id);
-conn_rec *ap_new_apr_connection(ap_context_t *p, server_rec *server, BUFF *inout,
+conn_rec *ap_new_apr_connection(ap_pool_t *p, server_rec *server, BUFF *inout,
const ap_socket_t *conn_socket, long id);
CORE_EXPORT(void) ap_process_connection(conn_rec *);
int ap_process_http_connection(conn_rec *);
/* Used for constructing self-referencing URLs, and things like SERVER_PORT,
* and SERVER_NAME.
*/
-API_EXPORT(char *) ap_construct_url(ap_context_t *p, const char *uri, request_rec *r);
+API_EXPORT(char *) ap_construct_url(ap_pool_t *p, const char *uri, request_rec *r);
API_EXPORT(const char *) ap_get_server_name(request_rec *r);
API_EXPORT(unsigned) ap_get_server_port(const request_rec *r);
API_EXPORT(unsigned long) ap_get_limit_req_body(const request_rec *r);
} core_server_config;
/* for http_config.c */
-void ap_core_reorder_directories(ap_context_t *, server_rec *);
+void ap_core_reorder_directories(ap_pool_t *, server_rec *);
/* for mod_perl */
CORE_EXPORT(void) ap_add_per_dir_conf (server_rec *s, void *dir_config);
#define APLOG_MARK __FILE__,__LINE__
-void ap_open_logs (server_rec *, ap_context_t *p);
+void ap_open_logs (server_rec *, ap_pool_t *p);
/* The two primary logging functions, ap_log_error and ap_log_rerror,
* use a printf style format string to build the log message. It is
__attribute__((format(printf,6,7)));
API_EXPORT(void) ap_error_log2stderr (server_rec *);
-void ap_log_pid (ap_context_t *p, const char *fname);
+void ap_log_pid (ap_pool_t *p, const char *fname);
/* These are for legacy code, new code should use ap_log_error,
* or ap_log_rerror.
*/
request_rec *r);
typedef struct piped_log {
- ap_context_t *p;
+ ap_pool_t *p;
ap_file_t *fds[2];
/* XXX - an #ifdef that needs to be eliminated from public view. Shouldn't
* be hard */
#endif
} piped_log;
-API_EXPORT(piped_log *) ap_open_piped_log (ap_context_t *p, const char *program);
+API_EXPORT(piped_log *) ap_open_piped_log (ap_pool_t *p, const char *program);
API_EXPORT(void) ap_close_piped_log (piped_log *);
#define ap_piped_log_read_fd(pl) ((pl)->fds[0])
#define ap_piped_log_write_fd(pl) ((pl)->fds[1])
* (e.g., for includes), a module may call for the request to be run
* by calling run_sub_req. The space allocated to create sub_reqs can be
* reclaimed by calling destroy_sub_req --- be sure to copy anything you care
- * about which was allocated in its ap_context_t elsewhere before doing this.
+ * about which was allocated in its ap_pool_t elsewhere before doing this.
*/
API_EXPORT(request_rec *) ap_sub_req_lookup_uri(const char *new_file,
#endif
/* called before any config is read */
-void ap_init_vhost_config(ap_context_t *p);
+void ap_init_vhost_config(ap_pool_t *p);
/* called after the config has been read */
-void ap_fini_vhost_config(ap_context_t *p, server_rec *main_server);
+void ap_fini_vhost_config(ap_pool_t *p, server_rec *main_server);
/* handle addresses in <VirtualHost> statement */
-const char *ap_parse_vhost_addrs(ap_context_t *p, const char *hostname, server_rec *s);
+const char *ap_parse_vhost_addrs(ap_pool_t *p, const char *hostname, server_rec *s);
/* handle NameVirtualHost directive */
const char *ap_set_name_virtual_host (cmd_parms *cmd, void *dummy, char *arg);
#include "util_uri.h"
struct process_rec {
- ap_context_t *pool; /* Global pool. Please try to cleared on _all_ exits */
- ap_context_t *pconf; /* aka configuration pool, cleared on restarts */
+ ap_pool_t *pool; /* Global pool. Please try to cleared on _all_ exits */
+ ap_pool_t *pconf; /* aka configuration pool, cleared on restarts */
int argc;
const char **argv;
const char *short_name;
struct request_rec {
- ap_context_t *pool;
+ ap_pool_t *pool;
conn_rec *connection;
server_rec *server;
struct conn_rec {
- ap_context_t *pool;
+ ap_pool_t *pool;
server_rec *base_server; /* Physical vhost this conn come in on */
void *vhost_lookup_data; /* used by http_vhost.c */
/* Time */
-API_EXPORT(char *) ap_field_noparam(ap_context_t *p, const char *intype);
-API_EXPORT(char *) ap_ht_time(ap_context_t *p, ap_time_t t, const char *fmt, int gmt);
+API_EXPORT(char *) ap_field_noparam(ap_pool_t *p, const char *intype);
+API_EXPORT(char *) ap_ht_time(ap_pool_t *p, ap_time_t t, const char *fmt, int gmt);
/* String handling. The *_nc variants allow you to use non-const char **s as
arguments (unfortunately C won't automatically convert a char ** to a const
char **) */
-API_EXPORT(char *) ap_getword(ap_context_t *p, const char **line, char stop);
-API_EXPORT(char *) ap_getword_nc(ap_context_t *p, char **line, char stop);
-API_EXPORT(char *) ap_getword_white(ap_context_t *p, const char **line);
-API_EXPORT(char *) ap_getword_white_nc(ap_context_t *p, char **line);
-API_EXPORT(char *) ap_getword_nulls(ap_context_t *p, const char **line, char stop);
-API_EXPORT(char *) ap_getword_nulls_nc(ap_context_t *p, char **line, char stop);
-API_EXPORT(char *) ap_getword_conf(ap_context_t *p, const char **line);
-API_EXPORT(char *) ap_getword_conf_nc(ap_context_t *p, char **line);
-API_EXPORT(char *) ap_resolve_env(ap_context_t *p, const char * word);
+API_EXPORT(char *) ap_getword(ap_pool_t *p, const char **line, char stop);
+API_EXPORT(char *) ap_getword_nc(ap_pool_t *p, char **line, char stop);
+API_EXPORT(char *) ap_getword_white(ap_pool_t *p, const char **line);
+API_EXPORT(char *) ap_getword_white_nc(ap_pool_t *p, char **line);
+API_EXPORT(char *) ap_getword_nulls(ap_pool_t *p, const char **line, char stop);
+API_EXPORT(char *) ap_getword_nulls_nc(ap_pool_t *p, char **line, char stop);
+API_EXPORT(char *) ap_getword_conf(ap_pool_t *p, const char **line);
+API_EXPORT(char *) ap_getword_conf_nc(ap_pool_t *p, char **line);
+API_EXPORT(char *) ap_resolve_env(ap_pool_t *p, const char * word);
API_EXPORT(const char *) ap_size_list_item(const char **field, int *len);
-API_EXPORT(char *) ap_get_list_item(ap_context_t *p, const char **field);
-API_EXPORT(int) ap_find_list_item(ap_context_t *p, const char *line, const char *tok);
+API_EXPORT(char *) ap_get_list_item(ap_pool_t *p, const char **field);
+API_EXPORT(int) ap_find_list_item(ap_pool_t *p, const char *line, const char *tok);
-API_EXPORT(char *) ap_get_token(ap_context_t *p, const char **accept_line, int accept_white);
-API_EXPORT(int) ap_find_token(ap_context_t *p, const char *line, const char *tok);
-API_EXPORT(int) ap_find_last_token(ap_context_t *p, const char *line, const char *tok);
+API_EXPORT(char *) ap_get_token(ap_pool_t *p, const char **accept_line, int accept_white);
+API_EXPORT(int) ap_find_token(ap_pool_t *p, const char *line, const char *tok);
+API_EXPORT(int) ap_find_last_token(ap_pool_t *p, const char *line, const char *tok);
API_EXPORT(int) ap_is_url(const char *u);
API_EXPORT(int) ap_unescape_url(char *url);
API_EXPORT(void) ap_no2slash(char *name);
API_EXPORT(void) ap_getparents(char *name);
-API_EXPORT(char *) ap_escape_path_segment(ap_context_t *p, const char *s);
-API_EXPORT(char *) ap_os_escape_path(ap_context_t *p, const char *path, int partial);
+API_EXPORT(char *) ap_escape_path_segment(ap_pool_t *p, const char *s);
+API_EXPORT(char *) ap_os_escape_path(ap_pool_t *p, const char *path, int partial);
#define ap_escape_uri(ppool,path) ap_os_escape_path(ppool,path,1)
-API_EXPORT(char *) ap_escape_html(ap_context_t *p, const char *s);
-API_EXPORT(char *) ap_construct_server(ap_context_t *p, const char *hostname,
+API_EXPORT(char *) ap_escape_html(ap_pool_t *p, const char *s);
+API_EXPORT(char *) ap_construct_server(ap_pool_t *p, const char *hostname,
unsigned port, const request_rec *r);
-API_EXPORT(char *) ap_escape_shell_cmd(ap_context_t *p, const char *s);
+API_EXPORT(char *) ap_escape_shell_cmd(ap_pool_t *p, const char *s);
API_EXPORT(int) ap_count_dirs(const char *path);
API_EXPORT(char *) ap_make_dirstr_prefix(char *d, const char *s, int n);
-API_EXPORT(char *) ap_make_dirstr_parent(ap_context_t *p, const char *s);
+API_EXPORT(char *) ap_make_dirstr_parent(ap_pool_t *p, const char *s);
/* deprecated. The previous two routines are preferred. */
-API_EXPORT(char *) ap_make_dirstr(ap_context_t *a, const char *s, int n);
-API_EXPORT(char *) ap_make_full_path(ap_context_t *a, const char *dir, const char *f);
+API_EXPORT(char *) ap_make_dirstr(ap_pool_t *a, const char *s, int n);
+API_EXPORT(char *) ap_make_full_path(ap_pool_t *a, const char *dir, const char *f);
API_EXPORT(int) ap_is_matchexp(const char *str);
API_EXPORT(int) ap_strcmp_match(const char *str, const char *exp);
API_EXPORT(int) ap_strcasecmp_match(const char *str, const char *exp);
API_EXPORT(char *) ap_strcasestr(const char *s1, const char *s2);
-API_EXPORT(char *) ap_pbase64decode(ap_context_t *p, const char *bufcoded);
-API_EXPORT(char *) ap_pbase64encode(ap_context_t *p, char *string);
-API_EXPORT(char *) ap_uudecode(ap_context_t *p, const char *bufcoded);
-API_EXPORT(char *) ap_uuencode(ap_context_t *p, char *string);
+API_EXPORT(char *) ap_pbase64decode(ap_pool_t *p, const char *bufcoded);
+API_EXPORT(char *) ap_pbase64encode(ap_pool_t *p, char *string);
+API_EXPORT(char *) ap_uudecode(ap_pool_t *p, const char *bufcoded);
+API_EXPORT(char *) ap_uuencode(ap_pool_t *p, char *string);
/* Regexes */
#if defined(AP_USE_HSREGEX) || defined(WIN32)
#include <regex.h>
#endif
-API_EXPORT(regex_t *) ap_pregcomp(ap_context_t *p, const char *pattern,
+API_EXPORT(regex_t *) ap_pregcomp(ap_pool_t *p, const char *pattern,
int cflags);
-API_EXPORT(void) ap_pregfree(ap_context_t *p, regex_t *reg);
+API_EXPORT(void) ap_pregfree(ap_pool_t *p, regex_t *reg);
API_EXPORT(int) ap_regexec(const regex_t *preg, const char *string,
size_t nmatch, regmatch_t pmatch[], int eflags);
API_EXPORT(size_t) ap_regerror(int errcode, const regex_t *preg,
char *errbuf, size_t errbuf_size);
-API_EXPORT(char *) ap_pregsub(ap_context_t *p, const char *input, const char *source,
+API_EXPORT(char *) ap_pregsub(ap_pool_t *p, const char *input, const char *source,
size_t nmatch, regmatch_t pmatch[]);
API_EXPORT(void) ap_content_type_tolower(char *);
API_EXPORT(int) ap_ind(const char *, char); /* Sigh... */
API_EXPORT(int) ap_rind(const char *, char);
-API_EXPORT(char *) ap_escape_quotes (ap_context_t *p, const char *instring);
+API_EXPORT(char *) ap_escape_quotes (ap_pool_t *p, const char *instring);
/* Common structure for reading of config files / passwd files etc. */
typedef struct {
} configfile_t;
/* Open a configfile_t as FILE, return open configfile_t struct pointer */
-API_EXPORT(ap_status_t) ap_pcfg_openfile(configfile_t **, ap_context_t *p, const char *name);
+API_EXPORT(ap_status_t) ap_pcfg_openfile(configfile_t **, ap_pool_t *p, const char *name);
/* Allocate a configfile_t handle with user defined functions and params */
-API_EXPORT(configfile_t *) ap_pcfg_open_custom(ap_context_t *p, const char *descr,
+API_EXPORT(configfile_t *) ap_pcfg_open_custom(ap_pool_t *p, const char *descr,
void *param,
int(*getc_func)(void*),
void *(*gets_func) (void *buf, size_t bufsiz, void *param),
API_EXPORT(const server_rec *) ap_get_server_conf(void);
#ifdef _OSD_POSIX
-extern const char *os_set_account(ap_context_t *p, const char *account);
+extern const char *os_set_account(ap_pool_t *p, const char *account);
extern int os_init_job_environment(server_rec *s, const char *user_name, int one_process);
#endif /* _OSD_POSIX */
-char *ap_get_local_host(ap_context_t *);
+char *ap_get_local_host(ap_pool_t *);
unsigned long ap_get_virthost_addr(char *hostname, unsigned short *port);
-API_EXPORT(char *) ap_escape_quotes(ap_context_t *p, const char *instr);
+API_EXPORT(char *) ap_escape_quotes(ap_pool_t *p, const char *instr);
/*
* Redefine assert() to something more useful for an Apache...
* Get an array of current connection IDs.
*
*/
-API_EXPORT(ap_array_header_t *) ap_get_connections(ap_context_t *p);
+API_EXPORT(ap_array_header_t *) ap_get_connections(ap_pool_t *p);
/**
* Get an array of keys from a given connection.
* conn_id = Connection ID
*
*/
-API_EXPORT(ap_array_header_t *) ap_get_connection_keys(ap_context_t *p,
+API_EXPORT(ap_array_header_t *) ap_get_connection_keys(ap_pool_t *p,
long conn_id);
/**
* p = context, generally of the request
*
*/
-API_EXPORT(ap_array_header_t *) ap_get_status_table(ap_context_t *p);
+API_EXPORT(ap_array_header_t *) ap_get_status_table(ap_pool_t *p);
#endif /* APACHE_SERVER_STATS_H */
#include "ap_md5.h"
-API_EXPORT(char *) ap_md5(ap_context_t *a, const unsigned char *string);
-API_EXPORT(char *) ap_md5_binary(ap_context_t *a, const unsigned char *buf, int len);
-API_EXPORT(char *) ap_md5contextTo64(ap_context_t *p, AP_MD5_CTX * context);
-API_EXPORT(char *) ap_md5digest(ap_context_t *p, ap_file_t *infile);
+API_EXPORT(char *) ap_md5(ap_pool_t *a, const unsigned char *string);
+API_EXPORT(char *) ap_md5_binary(ap_pool_t *a, const unsigned char *buf, int len);
+API_EXPORT(char *) ap_md5contextTo64(ap_pool_t *p, AP_MD5_CTX * context);
+API_EXPORT(char *) ap_md5digest(ap_pool_t *p, ap_file_t *infile);
#ifdef __cplusplus
}
#endif
#endif
-API_EXPORT(char **) ap_create_environment(ap_context_t *p, ap_table_t *t);
+API_EXPORT(char **) ap_create_environment(ap_pool_t *p, ap_table_t *t);
API_EXPORT(int) ap_find_path_info(const char *uri, const char *path_info);
API_EXPORT(void) ap_add_cgi_vars(request_rec *r);
API_EXPORT(void) ap_add_common_vars(request_rec *r);
/* util_uri.c */
API_EXPORT(unsigned short) ap_default_port_for_scheme(const char *scheme_str);
API_EXPORT(unsigned short) ap_default_port_for_request(const request_rec *r);
-API_EXPORT(struct hostent *) ap_pduphostent(ap_context_t *p, const struct hostent *hp);
-API_EXPORT(struct hostent *) ap_pgethostbyname(ap_context_t *p, const char *hostname);
-API_EXPORT(char *) ap_unparse_uri_components(ap_context_t *p, const uri_components *uptr,
+API_EXPORT(struct hostent *) ap_pduphostent(ap_pool_t *p, const struct hostent *hp);
+API_EXPORT(struct hostent *) ap_pgethostbyname(ap_pool_t *p, const char *hostname);
+API_EXPORT(char *) ap_unparse_uri_components(ap_pool_t *p, const uri_components *uptr,
unsigned flags);
-API_EXPORT(int) ap_parse_uri_components(ap_context_t *p, const char *uri, uri_components *uptr);
-API_EXPORT(int) ap_parse_hostinfo_components(ap_context_t *p, const char *hostinfo, uri_components *uptr);
+API_EXPORT(int) ap_parse_uri_components(ap_pool_t *p, const char *uri, uri_components *uptr);
+API_EXPORT(int) ap_parse_hostinfo_components(ap_pool_t *p, const char *hostinfo, uri_components *uptr);
/* called by the core in main() */
extern void ap_util_uri_init(void);
module MODULE_VAR_EXPORT access_module;
-static void *create_access_dir_config(ap_context_t *p, char *dummy)
+static void *create_access_dir_config(ap_pool_t *p, char *dummy)
{
access_dir_conf *conf =
(access_dir_conf *) ap_pcalloc(p, sizeof(access_dir_conf));
int auth_authoritative;
} auth_config_rec;
-static void *create_auth_dir_config(ap_context_t *p, char *d)
+static void *create_auth_dir_config(ap_pool_t *p, char *d)
{
auth_config_rec *sec =
(auth_config_rec *) ap_pcalloc(p, sizeof(auth_config_rec));
return NULL;
}
-static ap_table_t *groups_for_user(ap_context_t *p, char *user, char *grpfile)
+static ap_table_t *groups_for_user(ap_pool_t *p, char *user, char *grpfile)
{
configfile_t *f;
ap_table_t *grps = ap_make_table(p, 15);
- ap_context_t *sp;
+ ap_pool_t *sp;
char l[MAX_STRING_LEN];
const char *group_name, *ll, *w;
ap_status_t status;
return NULL;
}
- ap_create_context(&sp, p);
+ ap_create_pool(&sp, p);
while (!(ap_cfg_getline(l, MAX_STRING_LEN, f))) {
if ((l[0] == '#') || (!l[0]))
} anon_auth_config_rec;
-static void *create_anon_auth_dir_config(ap_context_t *p, char *d)
+static void *create_anon_auth_dir_config(ap_pool_t *p, char *d)
{
anon_auth_config_rec *sec = (anon_auth_config_rec *)
ap_pcalloc(p, sizeof(anon_auth_config_rec));
int auth_dbauthoritative;
} db_auth_config_rec;
-static void *create_db_auth_dir_config(ap_context_t *p, char *d)
+static void *create_db_auth_dir_config(ap_pool_t *p, char *d)
{
db_auth_config_rec *sec
= (db_auth_config_rec *) ap_pcalloc(p, sizeof(db_auth_config_rec));
} dbm_auth_config_rec;
-static void *create_dbm_auth_dir_config(ap_context_t *p, char *d)
+static void *create_dbm_auth_dir_config(ap_pool_t *p, char *d)
{
dbm_auth_config_rec *sec
= (dbm_auth_config_rec *) ap_pcalloc(p, sizeof(dbm_auth_config_rec));
}
#endif /* HAVE_SHMEM_MM */
-static void initialize_module(ap_context_t *p, ap_context_t *plog,
- ap_context_t *ptemp, server_rec *s)
+static void initialize_module(ap_pool_t *p, ap_pool_t *plog,
+ ap_pool_t *ptemp, server_rec *s)
{
/* keep from doing the init more than once at startup, and delay
* the init until the second round
* configuration code
*/
-static void *create_digest_dir_config(ap_context_t *p, char *dir)
+static void *create_digest_dir_config(ap_pool_t *p, char *dir)
{
digest_config_rec *conf;
/* The nonce has the format b64(time)+hash .
*/
-static const char *gen_nonce(ap_context_t *p, time_t now, const char *opaque,
+static const char *gen_nonce(ap_pool_t *p, time_t now, const char *opaque,
const server_rec *server,
const digest_config_rec *conf)
{
* Authorization challenge generation code (for WWW-Authenticate)
*/
-static const char *guess_domain(ap_context_t *p, const char *uri,
+static const char *guess_domain(ap_pool_t *p, const char *uri,
const char *filename, const char *dir)
{
size_t u_len = strlen(uri), f_len = strlen(filename), d_len = strlen(dir);
}
-static const char *ltox(ap_context_t *p, unsigned long num)
+static const char *ltox(ap_pool_t *p, unsigned long num)
{
if (num != 0)
return ap_psprintf(p, "%lx", num);
{
configfile_t *f;
ap_table_t *grps = ap_make_table(r->pool, 15);
- ap_context_t *sp;
+ ap_pool_t *sp;
char l[MAX_STRING_LEN];
const char *group_name, *ll, *w;
ap_status_t sts;
return NULL;
}
- if (ap_create_context(&sp, r->pool) != APR_SUCCESS)
+ if (ap_create_pool(&sp, r->pool) != APR_SUCCESS)
return NULL;
while (!(ap_cfg_getline(l, MAX_STRING_LEN, f))) {
int bEnabled;
} EchoConfig;
-static void *create_echo_server_config(ap_context_t *p,server_rec *s)
+static void *create_echo_server_config(ap_pool_t *p,server_rec *s)
{
EchoConfig *pConfig=ap_pcalloc(p,sizeof *pConfig);
* freed each time we modify the trace. That way previous layers of trace
* data don't get lost.
*/
-static ap_context_t *example_pool = NULL;
-static ap_context_t *example_subpool = NULL;
+static ap_pool_t *example_pool = NULL;
+static ap_pool_t *example_subpool = NULL;
/*
* Declare ourselves so the configuration routines can find and know us.
* If we haven't already allocated our module-private pool, do so now.
*/
if (example_pool == NULL) {
- ap_create_context(&example_pool, NULL);
+ ap_create_pool(&example_pool, NULL);
};
/*
* Likewise for the ap_table_t of routine/environment pairs we visit outside of
* The list can be displayed by the example_handler() routine.
*
* If the call occurs within a request context (i.e., we're passed a request
- * record), we put the trace into the request ap_context_t and attach it to the
+ * record), we put the trace into the request ap_pool_t and attach it to the
* request via the notes mechanism. Otherwise, the trace gets added
* to the static (non-request-specific) list.
*
const char *sofar;
char *addon;
char *where;
- ap_context_t *p;
+ ap_pool_t *p;
const char *trace_copy;
/*
* Make a new sub-pool and copy any existing trace to it. Point the
* trace cell at the copied value.
*/
- ap_create_context(&p, example_pool);
+ ap_create_pool(&p, example_pool);
if (trace != NULL) {
trace = ap_pstrdup(p, trace);
}
/*
* All our module initialiser does is add its trace to the log.
*/
-static void example_init(ap_context_t *p, ap_context_t *ptemp,
- ap_context_t *plog, server_rec *s)
+static void example_init(ap_pool_t *p, ap_pool_t *ptemp,
+ ap_pool_t *plog, server_rec *s)
{
char *note;
/*
* All our process initialiser does is add its trace to the log.
*/
-static void example_child_init(ap_context_t *p, server_rec *s)
+static void example_child_init(ap_pool_t *p, server_rec *s)
{
char *note;
/*
* All our process-death routine does is add its trace to the log.
*/
-static void example_child_exit(server_rec *s, ap_context_t *p)
+static void example_child_exit(server_rec *s, ap_pool_t *p)
{
char *note;
* The return value is a pointer to the created module-specific
* structure.
*/
-static void *example_create_dir_config(ap_context_t *p, char *dirspec)
+static void *example_create_dir_config(ap_pool_t *p, char *dirspec)
{
excfg *cfg;
* The return value is a pointer to the created module-specific structure
* containing the merged values.
*/
-static void *example_merge_dir_config(ap_context_t *p, void *parent_conf,
+static void *example_merge_dir_config(ap_pool_t *p, void *parent_conf,
void *newloc_conf)
{
* The return value is a pointer to the created module-specific
* structure.
*/
-static void *example_create_server_config(ap_context_t *p, server_rec *s)
+static void *example_create_server_config(ap_pool_t *p, server_rec *s)
{
excfg *cfg;
* The return value is a pointer to the created module-specific structure
* containing the merged values.
*/
-static void *example_merge_server_config(ap_context_t *p, void *server1_conf,
+static void *example_merge_server_config(ap_pool_t *p, void *server1_conf,
void *server2_conf)
{
* the tag value is html decoded if dodecode is non-zero
*/
-static char *get_tag(ap_context_t *p, ap_file_t *in, char *tag, int tagbuf_len, int dodecode)
+static char *get_tag(ap_pool_t *p, ap_file_t *in, char *tag, int tagbuf_len, int dodecode)
{
char *t = tag, *tag_val, c, term;
return ap_pstrdup(p, tag_val);
}
-static int get_directive(ap_file_t *in, char *dest, size_t len, ap_context_t *p)
+static int get_directive(ap_file_t *in, char *dest, size_t len, ap_pool_t *p)
{
char *d = dest;
char c;
-static ap_status_t build_argv_list(char ***argv, request_rec *r, ap_context_t *p)
+static ap_status_t build_argv_list(char ***argv, request_rec *r, ap_pool_t *p)
{
int numwords, x, idx;
char *w;
} *root, *current, *new;
const char *parse;
char buffer[MAX_STRING_LEN];
- ap_context_t *expr_pool;
+ ap_pool_t *expr_pool;
int retval = 0;
if ((parse = expr) == (char *) NULL) {
return (0);
}
root = current = (struct parse_node *) NULL;
- if (ap_create_context(&expr_pool, r->pool) != APR_SUCCESS)
+ if (ap_create_pool(&expr_pool, r->pool) != APR_SUCCESS)
return 0;
/* Create Parse Tree */
#define DEFAULT_XBITHACK xbithack_off
#endif
-static void *create_includes_dir_config(ap_context_t *p, char *dummy)
+static void *create_includes_dir_config(ap_pool_t *p, char *dummy)
{
enum xbithack *result = (enum xbithack *) ap_palloc(p, sizeof(enum xbithack));
*result = DEFAULT_XBITHACK;
{NULL}
};
-static void *create_autoindex_config(ap_context_t *p, char *dummy)
+static void *create_autoindex_config(ap_pool_t *p, char *dummy)
{
autoindex_config_rec *new =
(autoindex_config_rec *) ap_pcalloc(p, sizeof(autoindex_config_rec));
return (void *) new;
}
-static void *merge_autoindex_configs(ap_context_t *p, void *basev, void *addv)
+static void *merge_autoindex_configs(ap_pool_t *p, void *basev, void *addv)
{
autoindex_config_rec *new;
autoindex_config_rec *base = (autoindex_config_rec *) basev;
char *name = r->uri;
char *tp;
int static_columns = (autoindex_opts & SUPPRESS_COLSORT);
- ap_context_t *scratch;
+ ap_pool_t *scratch;
int name_width;
char *name_scratch;
char *pad_scratch;
- ap_create_context(&scratch, r->pool);
+ ap_create_pool(&scratch, r->pool);
if (name[0] == '\0') {
name = "/";
}
int bufbytes;
} cgi_server_conf;
-static void *create_cgi_config(ap_context_t *p, server_rec *s)
+static void *create_cgi_config(ap_pool_t *p, server_rec *s)
{
cgi_server_conf *c =
(cgi_server_conf *) ap_pcalloc(p, sizeof(cgi_server_conf));
return c;
}
-static void *merge_cgi_config(ap_context_t *p, void *basev, void *overridesv)
+static void *merge_cgi_config(ap_pool_t *p, void *basev, void *overridesv)
{
cgi_server_conf *base = (cgi_server_conf *) basev, *overrides = (cgi_server_conf *) overridesv;
return ret;
}
static ap_status_t run_cgi_child(BUFF **script_out, BUFF **script_in, BUFF **script_err,
- char *command, char *const argv[], request_rec *r, ap_context_t *p)
+ char *command, char *const argv[], request_rec *r, ap_pool_t *p)
{
char **env;
ap_procattr_t *procattr;
ap_unblock_alarms();
return (rc);
}
-static ap_status_t build_argv_list(char ***argv, request_rec *r, ap_context_t *p)
+static ap_status_t build_argv_list(char ***argv, request_rec *r, ap_pool_t *p)
{
int numwords, x, idx;
char *w;
return APR_SUCCESS;
}
-static ap_status_t build_command_line(char **c, request_rec *r, ap_context_t *p)
+static ap_status_t build_command_line(char **c, request_rec *r, ap_pool_t *p)
{
#ifdef WIN32
char *quoted_filename = NULL;
char argsbuffer[HUGE_STRING_LEN];
int is_included = !strcmp(r->protocol, "INCLUDED");
void *sconf = r->server->module_config;
- ap_context_t *p;
+ ap_pool_t *p;
cgi_server_conf *conf =
(cgi_server_conf *) ap_get_module_config(sconf, &cgi_module);
module MODULE_VAR_EXPORT cgid_module;
-static void cgid_init(ap_context_t *p, ap_context_t *plog, ap_context_t *ptemp, server_rec *main_server);
+static void cgid_init(ap_pool_t *p, ap_pool_t *plog, ap_pool_t *ptemp, server_rec *main_server);
static int once_through = 0;
-static ap_context_t *pcgi;
+static ap_pool_t *pcgi;
/* KLUDGE --- for back-combatibility, we don't have to check Execcgid
* in ScriptAliased directories, which means we need to know if this
* are handled in create_argv.
*
*/
-static char **create_argv(ap_context_t *p, char *path, char *user, char *group,
+static char **create_argv(ap_pool_t *p, char *path, char *user, char *group,
char *av0, const char *args)
{
int x, numwords;
char *argv0;
char *filename;
char **env;
- ap_context_t *p;
+ ap_pool_t *p;
request_rec *r;
- ap_create_context(&p, pcgi);
+ ap_create_pool(&p, pcgi);
r = ap_pcalloc(p, sizeof(request_rec));
r->pool = p;
dup2(sd, STDIN_FILENO);
return -1;
}
-static void cgid_init(ap_context_t *p, ap_context_t *plog, ap_context_t *ptemp, server_rec *main_server)
+static void cgid_init(ap_pool_t *p, ap_pool_t *plog, ap_pool_t *ptemp, server_rec *main_server)
{
int pid;
int tempfd;
main_server->module_config, &cgid_module);
if (once_through > 0) {
- ap_create_context(&pcgi, p);
+ ap_create_pool(&pcgi, p);
tempfd = creat(sconf->sockname, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
close(tempfd);
else once_through++;
}
-static void *create_cgid_config(ap_context_t *p, server_rec *s)
+static void *create_cgid_config(ap_pool_t *p, server_rec *s)
{
cgid_server_conf *c =
(cgid_server_conf *) ap_pcalloc(p, sizeof(cgid_server_conf));
return c;
}
-static void *merge_cgid_config(ap_context_t *p, void *basev, void *overridesv)
+static void *merge_cgid_config(ap_pool_t *p, void *basev, void *overridesv)
{
cgid_server_conf *base = (cgid_server_conf *) basev, *overrides = (cgid_server_conf *) overridesv;
module MODULE_VAR_EXPORT info_module;
extern module *top_module;
-static void *create_info_config(ap_context_t *p, server_rec *s)
+static void *create_info_config(ap_pool_t *p, server_rec *s)
{
info_svr_conf *conf = (info_svr_conf *) ap_pcalloc(p, sizeof(info_svr_conf));
return conf;
}
-static void *merge_info_config(ap_context_t *p, void *basev, void *overridesv)
+static void *merge_info_config(ap_pool_t *p, void *basev, void *overridesv)
{
info_svr_conf *new = (info_svr_conf *) ap_pcalloc(p, sizeof(info_svr_conf));
info_svr_conf *base = (info_svr_conf *) basev;
return (buf);
}
-static info_cfg_lines *mod_info_load_config(ap_context_t *p, const char *filename,
+static info_cfg_lines *mod_info_load_config(ap_pool_t *p, const char *filename,
request_rec *r)
{
char s[MAX_STRING_LEN];
* the http_conf_globals.
*/
-static void *create_core_dir_config(ap_context_t *a, char *dir)
+static void *create_core_dir_config(ap_pool_t *a, char *dir)
{
core_dir_config *conf;
return (void *)conf;
}
-static void *merge_core_dir_configs(ap_context_t *a, void *basev, void *newv)
+static void *merge_core_dir_configs(ap_pool_t *a, void *basev, void *newv)
{
core_dir_config *base = (core_dir_config *)basev;
core_dir_config *new = (core_dir_config *)newv;
return (void*)conf;
}
-static void *create_core_server_config(ap_context_t *a, server_rec *s)
+static void *create_core_server_config(ap_pool_t *a, server_rec *s)
{
core_server_config *conf;
int is_virtual = s->is_virtual;
return (void *)conf;
}
-static void *merge_core_server_configs(ap_context_t *p, void *basev, void *virtv)
+static void *merge_core_server_configs(ap_pool_t *p, void *basev, void *virtv)
{
core_server_config *base = (core_server_config *)basev;
core_server_config *virt = (core_server_config *)virtv;
return a->orig_index - b->orig_index;
}
-void ap_core_reorder_directories(ap_context_t *p, server_rec *s)
+void ap_core_reorder_directories(ap_pool_t *p, server_rec *s)
{
core_server_config *sconf;
ap_array_header_t *sec;
int nelts;
void **elts;
int i;
- ap_context_t *tmp;
+ ap_pool_t *tmp;
sconf = ap_get_module_config(s->module_config, &core_module);
sec = sconf->sec;
elts = (void **)sec->elts;
/* we have to allocate tmp space to do a stable sort */
- ap_create_context(&tmp, p);
+ ap_create_pool(&tmp, p);
sortbin = ap_palloc(tmp, sec->nelts * sizeof(*sortbin));
for (i = 0; i < nelts; ++i) {
sortbin[i].orig_index = i;
return port;
}
-API_EXPORT(char *) ap_construct_url(ap_context_t *p, const char *uri,
+API_EXPORT(char *) ap_construct_url(ap_pool_t *p, const char *uri,
request_rec *r)
{
unsigned port = ap_get_server_port(r);
}
#ifdef WIN32
-static char* get_interpreter_from_win32_registry(ap_context_t *p, const char* ext)
+static char* get_interpreter_from_win32_registry(ap_pool_t *p, const char* ext)
{
char extension_path[] = "SOFTWARE\\Classes\\";
char executable_path[] = "\\SHELL\\OPEN\\COMMAND";
server_rec *main_server = cmd->server, *s;
const char *errmsg;
char *endp = strrchr(arg, '>');
- ap_context_t *p = cmd->pool;
+ ap_pool_t *p = cmd->pool;
const char *old_end_token;
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
{ NULL, NULL }
};
-static void core_open_logs(ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp, server_rec *s)
+static void core_open_logs(ap_pool_t *pconf, ap_pool_t *plog, ap_pool_t *ptemp, server_rec *s)
{
ap_open_logs(s, pconf);
}
request_rec *ap_read_request(conn_rec *conn)
{
request_rec *r;
- ap_context_t *p;
+ ap_pool_t *p;
const char *expect;
int access_status;
- ap_create_context(&p, conn->pool);
+ ap_create_pool(&p, conn->pool);
r = ap_pcalloc(p, sizeof(request_rec));
r->pool = p;
r->connection = conn;
static request_rec *make_sub_request(const request_rec *r)
{
- ap_context_t *rrp;
+ ap_pool_t *rrp;
request_rec *rr;
- ap_create_context(&rrp, r->pool);
+ ap_create_pool(&rrp, r->pool);
rr = ap_pcalloc(rrp, sizeof(request_rec));
rr->pool = rrp;
return rr;
ap_run_log_transaction(r);
}
-static ap_table_t *rename_original_env(ap_context_t *p, ap_table_t *t)
+static ap_table_t *rename_original_env(ap_pool_t *p, ap_table_t *t)
{
ap_array_header_t *env_arr = ap_table_elts(t);
ap_table_entry_t *elts = (ap_table_entry_t *) env_arr->elts;
module MODULE_VAR_EXPORT mime_module;
-static void *create_mime_dir_config(ap_context_t *p, char *dummy)
+static void *create_mime_dir_config(ap_pool_t *p, char *dummy)
{
mime_dir_config *new =
(mime_dir_config *) ap_palloc(p, sizeof(mime_dir_config));
return new;
}
-static void *merge_mime_dir_configs(ap_context_t *p, void *basev, void *addv)
+static void *merge_mime_dir_configs(ap_pool_t *p, void *basev, void *addv)
{
mime_dir_config *base = (mime_dir_config *) basev;
mime_dir_config *add = (mime_dir_config *) addv;
static ap_table_t *hash_buckets[MIME_HASHSIZE];
-static void mime_post_config(ap_context_t *p, ap_context_t *plog, ap_context_t *ptemp, server_rec *s)
+static void mime_post_config(ap_pool_t *p, ap_pool_t *plog, ap_pool_t *ptemp, server_rec *s)
{
configfile_t *f;
char l[MAX_STRING_LEN];
char *attribute, *value;
int quoted = 0;
server_rec * ss = r->server;
- ap_context_t * p = r->pool;
+ ap_pool_t * p = r->pool;
content_type *ctp;
param *pp, *npp;
ap_array_header_t *conditions;
} log_format_item;
-static char *format_integer(ap_context_t *p, int i)
+static char *format_integer(ap_pool_t *p, int i)
{
return ap_psprintf(p, "%d", i);
}
-static char *pfmt(ap_context_t *p, int i)
+static char *pfmt(ap_pool_t *p, int i)
{
if (i <= 0) {
return "-";
return NULL;
}
-static char *parse_log_misc_string(ap_context_t *p, log_format_item *it,
+static char *parse_log_misc_string(ap_pool_t *p, log_format_item *it,
const char **sa)
{
const char *s;
return NULL;
}
-static char *parse_log_item(ap_context_t *p, log_format_item *it, const char **sa)
+static char *parse_log_item(ap_pool_t *p, log_format_item *it, const char **sa)
{
const char *s = *sa;
return "Ran off end of LogFormat parsing args to some directive";
}
-static ap_array_header_t *parse_log_string(ap_context_t *p, const char *s, const char **err)
+static ap_array_header_t *parse_log_string(ap_pool_t *p, const char *s, const char **err)
{
ap_array_header_t *a = ap_make_array(p, 30, sizeof(log_format_item));
char *res;
* Module glue...
*/
-static void *make_config_log_state(ap_context_t *p, server_rec *s)
+static void *make_config_log_state(ap_pool_t *p, server_rec *s)
{
multi_log_state *mls;
* vhosts inherit any globally-defined format names.
*/
-static void *merge_config_log_state(ap_context_t *p, void *basev, void *addv)
+static void *merge_config_log_state(ap_pool_t *p, void *basev, void *addv)
{
multi_log_state *base = (multi_log_state *) basev;
multi_log_state *add = (multi_log_state *) addv;
{NULL}
};
-static config_log_state *open_config_log(server_rec *s, ap_context_t *p,
+static config_log_state *open_config_log(server_rec *s, ap_pool_t *p,
config_log_state *cls,
ap_array_header_t *default_format)
{
return cls;
}
-static config_log_state *open_multi_logs(server_rec *s, ap_context_t *p)
+static config_log_state *open_multi_logs(server_rec *s, ap_pool_t *p)
{
int i;
multi_log_state *mls = ap_get_module_config(s->module_config,
return NULL;
}
-static void init_config_log(ap_context_t *pc, ap_context_t *p, ap_context_t *pt, server_rec *s)
+static void init_config_log(ap_pool_t *pc, ap_pool_t *p, ap_pool_t *pt, server_rec *s)
{
/* First, do "physical" server, which gets default log fd and format
* for the virtual servers, if they don't override...
module action_module;
-static void *create_action_dir_config(ap_context_t *p, char *dummy)
+static void *create_action_dir_config(ap_pool_t *p, char *dummy)
{
action_dir_config *new =
(action_dir_config *) ap_palloc(p, sizeof(action_dir_config));
return new;
}
-static void *merge_action_dir_configs(ap_context_t *p, void *basev, void *addv)
+static void *merge_action_dir_configs(ap_pool_t *p, void *basev, void *addv)
{
action_dir_config *base = (action_dir_config *) basev;
action_dir_config *add = (action_dir_config *) addv;
module MODULE_VAR_EXPORT alias_module;
-static void *create_alias_config(ap_context_t *p, server_rec *s)
+static void *create_alias_config(ap_pool_t *p, server_rec *s)
{
alias_server_conf *a =
(alias_server_conf *) ap_pcalloc(p, sizeof(alias_server_conf));
return a;
}
-static void *create_alias_dir_config(ap_context_t *p, char *d)
+static void *create_alias_dir_config(ap_pool_t *p, char *d)
{
alias_dir_conf *a =
(alias_dir_conf *) ap_pcalloc(p, sizeof(alias_dir_conf));
return a;
}
-static void *merge_alias_config(ap_context_t *p, void *basev, void *overridesv)
+static void *merge_alias_config(ap_pool_t *p, void *basev, void *overridesv)
{
alias_server_conf *a =
(alias_server_conf *) ap_pcalloc(p, sizeof(alias_server_conf));
return a;
}
-static void *merge_alias_dir_config(ap_context_t *p, void *basev, void *overridesv)
+static void *merge_alias_dir_config(ap_pool_t *p, void *basev, void *overridesv)
{
alias_dir_conf *a =
(alias_dir_conf *) ap_pcalloc(p, sizeof(alias_dir_conf));
{NULL}
};
-static void *create_dir_config(ap_context_t *p, char *dummy)
+static void *create_dir_config(ap_pool_t *p, char *dummy)
{
dir_config_rec *new =
(dir_config_rec *) ap_pcalloc(p, sizeof(dir_config_rec));
return (void *) new;
}
-static void *merge_dir_configs(ap_context_t *p, void *basev, void *addv)
+static void *merge_dir_configs(ap_pool_t *p, void *basev, void *addv)
{
dir_config_rec *new = (dir_config_rec *) ap_pcalloc(p, sizeof(dir_config_rec));
dir_config_rec *base = (dir_config_rec *) basev;
char *imap_base;
} imap_conf_rec;
-static void *create_imap_dir_config(ap_context_t *p, char *dummy)
+static void *create_imap_dir_config(ap_pool_t *p, char *dummy)
{
imap_conf_rec *icr =
(imap_conf_rec *) ap_palloc(p, sizeof(imap_conf_rec));
return icr;
}
-static void *merge_imap_dir_configs(ap_context_t *p, void *basev, void *addv)
+static void *merge_imap_dir_configs(ap_pool_t *p, void *basev, void *addv)
{
imap_conf_rec *new = (imap_conf_rec *) ap_pcalloc(p, sizeof(imap_conf_rec));
imap_conf_rec *base = (imap_conf_rec *) basev;
module MODULE_VAR_EXPORT negotiation_module;
-static void *create_neg_dir_config(ap_context_t *p, char *dummy)
+static void *create_neg_dir_config(ap_pool_t *p, char *dummy)
{
neg_dir_config *new = (neg_dir_config *) ap_palloc(p, sizeof(neg_dir_config));
return new;
}
-static void *merge_neg_dir_configs(ap_context_t *p, void *basev, void *addv)
+static void *merge_neg_dir_configs(ap_pool_t *p, void *basev, void *addv)
{
neg_dir_config *base = (neg_dir_config *) basev;
neg_dir_config *add = (neg_dir_config *) addv;
*/
typedef struct {
- ap_context_t *pool;
+ ap_pool_t *pool;
request_rec *r;
char *dir_name;
int accept_q; /* 1 if an Accept item has a q= param */
* enter the values we recognize into the argument accept_rec
*/
-static const char *get_entry(ap_context_t *p, accept_rec *result,
+static const char *get_entry(ap_pool_t *p, accept_rec *result,
const char *accept_line)
{
result->quality = 1.0f;
* where charset is only valid in Accept.
*/
-static ap_array_header_t *do_header_line(ap_context_t *p, const char *accept_line)
+static ap_array_header_t *do_header_line(ap_pool_t *p, const char *accept_line)
{
ap_array_header_t *accept_recs;
* return an array containing the languages of this variant
*/
-static ap_array_header_t *do_languages_line(ap_context_t *p, const char **lang_line)
+static ap_array_header_t *do_languages_line(ap_pool_t *p, const char **lang_line)
{
ap_array_header_t *lang_recs = ap_make_array(p, 2, sizeof(char *));
**
*/
-static void *config_server_create(ap_context_t *p, server_rec *s)
+static void *config_server_create(ap_pool_t *p, server_rec *s)
{
rewrite_server_conf *a;
return (void *)a;
}
-static void *config_server_merge(ap_context_t *p, void *basev, void *overridesv)
+static void *config_server_merge(ap_pool_t *p, void *basev, void *overridesv)
{
rewrite_server_conf *a, *base, *overrides;
**
*/
-static void *config_perdir_create(ap_context_t *p, char *path)
+static void *config_perdir_create(ap_pool_t *p, char *path)
{
rewrite_perdir_conf *a;
return (void *)a;
}
-static void *config_perdir_merge(ap_context_t *p, void *basev, void *overridesv)
+static void *config_perdir_merge(ap_pool_t *p, void *basev, void *overridesv)
{
rewrite_perdir_conf *a, *base, *overrides;
return err;
}
-static const char *cmd_rewriteoptions_setoption(ap_context_t *p, int *options,
+static const char *cmd_rewriteoptions_setoption(ap_pool_t *p, int *options,
char *name)
{
if (strcasecmp(name, "inherit") == 0) {
return NULL;
}
-static const char *cmd_rewritecond_parseflagfield(ap_context_t *p,
+static const char *cmd_rewritecond_parseflagfield(ap_pool_t *p,
rewritecond_entry *cfg,
char *str)
{
return NULL;
}
-static const char *cmd_rewritecond_setflag(ap_context_t *p, rewritecond_entry *cfg,
+static const char *cmd_rewritecond_setflag(ap_pool_t *p, rewritecond_entry *cfg,
char *key, char *val)
{
if ( strcasecmp(key, "nocase") == 0
return NULL;
}
-static const char *cmd_rewriterule_parseflagfield(ap_context_t *p,
+static const char *cmd_rewriterule_parseflagfield(ap_pool_t *p,
rewriterule_entry *cfg,
char *str)
{
return NULL;
}
-static const char *cmd_rewriterule_setflag(ap_context_t *p, rewriterule_entry *cfg,
+static const char *cmd_rewriterule_setflag(ap_pool_t *p, rewriterule_entry *cfg,
char *key, char *val)
{
int status = 0;
**
*/
-static void init_module(ap_context_t *p,
- ap_context_t *plog,
- ap_context_t *ptemp,
+static void init_module(ap_pool_t *p,
+ ap_pool_t *plog,
+ ap_pool_t *ptemp,
server_rec *s)
{
/* check if proxy module is available */
**
*/
-static void init_child(ap_context_t *p, server_rec *s)
+static void init_child(ap_pool_t *p, server_rec *s)
{
if (lockname != NULL && *(lockname) != '\0')
**
*/
-static void expand_backref_inbuffer(ap_context_t *p, char *buf, int nbuf,
+static void expand_backref_inbuffer(ap_pool_t *p, char *buf, int nbuf,
backrefinfo *bri, char c)
{
register int i;
*/
-static void open_rewritelog(server_rec *s, ap_context_t *p)
+static void open_rewritelog(server_rec *s, ap_pool_t *p)
{
rewrite_server_conf *conf;
const char *fname;
#define REWRITELOCK_MODE ( APR_UREAD | APR_UWRITE | APR_GREAD | APR_WREAD )
-static void rewritelock_create(server_rec *s, ap_context_t *p)
+static void rewritelock_create(server_rec *s, ap_pool_t *p)
{
ap_status_t rc;
** +-------------------------------------------------------+
*/
-static void run_rewritemap_programs(server_rec *s, ap_context_t *p)
+static void run_rewritemap_programs(server_rec *s, ap_pool_t *p)
{
rewrite_server_conf *conf;
ap_file_t *fpin = NULL;
}
/* child process code */
-static int rewritemap_program_child(ap_context_t *p, char *progname,
+static int rewritemap_program_child(ap_pool_t *p, char *progname,
ap_file_t **fpout, ap_file_t **fpin,
ap_file_t **fperr)
{
rsub = subrecfunc(r->filename, r); \
/* now recursively lookup the variable in the sub_req */ \
result = lookup_variable(rsub, var+5); \
- /* copy it up to our scope before we destroy sub_req's ap_context_t */ \
+ /* copy it up to our scope before we destroy sub_req's ap_pool_t */ \
result = ap_pstrdup(r->pool, result); \
/* cleanup by destroying the subrequest */ \
ap_destroy_sub_req(rsub); \
*/
-static cache *init_cache(ap_context_t *p)
+static cache *init_cache(ap_pool_t *p)
{
cache *c;
c = (cache *)ap_palloc(p, sizeof(cache));
- if (ap_create_context(&c->pool, p) != APR_SUCCESS)
+ if (ap_create_pool(&c->pool, p) != APR_SUCCESS)
return NULL;
c->lists = ap_make_array(c->pool, 2, sizeof(cachelist));
return c;
} cachelist;
typedef struct cache {
- ap_context_t *pool;
+ ap_pool_t *pool;
ap_array_header_t *lists;
} cache;
*/
/* config structure handling */
-static void *config_server_create(ap_context_t *p, server_rec *s);
-static void *config_server_merge (ap_context_t *p, void *basev, void *overridesv);
-static void *config_perdir_create(ap_context_t *p, char *path);
-static void *config_perdir_merge (ap_context_t *p, void *basev, void *overridesv);
+static void *config_server_create(ap_pool_t *p, server_rec *s);
+static void *config_server_merge (ap_pool_t *p, void *basev, void *overridesv);
+static void *config_perdir_create(ap_pool_t *p, char *path);
+static void *config_perdir_merge (ap_pool_t *p, void *basev, void *overridesv);
/* config directive handling */
static const char *cmd_rewriteengine(cmd_parms *cmd,
static const char *cmd_rewriteoptions(cmd_parms *cmd,
rewrite_perdir_conf *dconf,
char *option);
-static const char *cmd_rewriteoptions_setoption(ap_context_t *p, int *options,
+static const char *cmd_rewriteoptions_setoption(ap_pool_t *p, int *options,
char *name);
static const char *cmd_rewritelog (cmd_parms *cmd, void *dconf, char *a1);
static const char *cmd_rewriteloglevel(cmd_parms *cmd, void *dconf, char *a1);
char *a1);
static const char *cmd_rewritecond(cmd_parms *cmd, rewrite_perdir_conf *dconf,
char *str);
-static const char *cmd_rewritecond_parseflagfield(ap_context_t *p,
+static const char *cmd_rewritecond_parseflagfield(ap_pool_t *p,
rewritecond_entry *new,
char *str);
-static const char *cmd_rewritecond_setflag(ap_context_t *p, rewritecond_entry *cfg,
+static const char *cmd_rewritecond_setflag(ap_pool_t *p, rewritecond_entry *cfg,
char *key, char *val);
static const char *cmd_rewriterule(cmd_parms *cmd, rewrite_perdir_conf *dconf,
char *str);
-static const char *cmd_rewriterule_parseflagfield(ap_context_t *p,
+static const char *cmd_rewriterule_parseflagfield(ap_pool_t *p,
rewriterule_entry *new,
char *str);
-static const char *cmd_rewriterule_setflag(ap_context_t *p, rewriterule_entry *cfg,
+static const char *cmd_rewriterule_setflag(ap_pool_t *p, rewriterule_entry *cfg,
char *key, char *val);
/* initialisation */
-static void init_module(ap_context_t *p,
- ap_context_t *plog,
- ap_context_t *ptemp,
+static void init_module(ap_pool_t *p,
+ ap_pool_t *plog,
+ ap_pool_t *ptemp,
server_rec *s);
-static void init_child(ap_context_t *p, server_rec *s);
+static void init_child(ap_pool_t *p, server_rec *s);
/* runtime hooks */
static int hook_uri2file (request_rec *r);
static void splitout_queryargs(request_rec *r, int qsappend);
static void fully_qualify_uri(request_rec *r);
static void reduce_uri(request_rec *r);
-static void expand_backref_inbuffer(ap_context_t *p, char *buf, int nbuf,
+static void expand_backref_inbuffer(ap_pool_t *p, char *buf, int nbuf,
backrefinfo *bri, char c);
static char *expand_tildepaths(request_rec *r, char *uri);
static void expand_map_lookups(request_rec *r, char *uri, int uri_len);
static int rewrite_rand(int l, int h);
/* rewriting logfile support */
-static void open_rewritelog(server_rec *s, ap_context_t *p);
+static void open_rewritelog(server_rec *s, ap_pool_t *p);
static void rewritelog(request_rec *r, int level, const char *text, ...)
__attribute__((format(printf,3,4)));
static char *current_logtime(request_rec *r);
/* rewriting lockfile support */
-static void rewritelock_create(server_rec *s, ap_context_t *p);
+static void rewritelock_create(server_rec *s, ap_pool_t *p);
static ap_status_t rewritelock_remove(void *data);
/* program map support */
-static void run_rewritemap_programs(server_rec *s, ap_context_t *p);
-static int rewritemap_program_child(ap_context_t *p, char *progname,
+static void run_rewritemap_programs(server_rec *s, ap_pool_t *p);
+static int rewritemap_program_child(ap_pool_t *p, char *progname,
ap_file_t **fpout, ap_file_t **fpin,
ap_file_t **fperr);
static char *lookup_header(request_rec *r, const char *name);
/* caching functions */
-static cache *init_cache(ap_context_t *p);
+static cache *init_cache(ap_pool_t *p);
static char *get_cache_string(cache *c, char *res, int mode, time_t mtime,
char *key);
static void set_cache_string(cache *c, char *res, int mode, time_t mtime,
ap_array_header_t *loaded_modules;
} so_server_conf;
-static void *so_sconf_create(ap_context_t *p, server_rec *s)
+static void *so_sconf_create(ap_pool_t *p, server_rec *s)
{
so_server_conf *soc;
ap_add_loaded_module(modp);
/*
- * Register a cleanup in the config ap_context_t (normally pconf). When
+ * Register a cleanup in the config ap_pool_t (normally pconf). When
* we do a restart (or shutdown) this cleanup will cause the
* shared object to be unloaded.
*/
* bother to have such a function.
*/
-static void *mkconfig(ap_context_t *p)
+static void *mkconfig(ap_pool_t *p)
{
spconfig *cfg = ap_pcalloc(p, sizeof(spconfig));
* Respond to a callback to create configuration record for a server or
* vhost environment.
*/
-static void *create_mconfig_for_server(ap_context_t *p, server_rec *s)
+static void *create_mconfig_for_server(ap_pool_t *p, server_rec *s)
{
return mkconfig(p);
}
/*
* Respond to a callback to create a config record for a specific directory.
*/
-static void *create_mconfig_for_directory(ap_context_t *p, char *dir)
+static void *create_mconfig_for_directory(ap_pool_t *p, char *dir)
{
return mkconfig(p);
}
* returned.
*/
else {
- ap_context_t *p;
+ ap_pool_t *p;
ap_table_t *notes;
- ap_context_t *sub_pool;
+ ap_pool_t *sub_pool;
ap_array_header_t *t;
ap_array_header_t *v;
notes = r->main->notes;
}
- if (ap_create_context(&sub_pool, p) != APR_SUCCESS)
+ if (ap_create_pool(&sub_pool, p) != APR_SUCCESS)
return DECLINED;
t = ap_make_array(sub_pool, candidates->nelts * 8 + 8,
* explicit) disablement, and the replacement string for all others.
*/
-static void *create_userdir_config(ap_context_t *p, server_rec *s)
+static void *create_userdir_config(ap_pool_t *p, server_rec *s)
{
userdir_config
* newcfg = (userdir_config *) ap_pcalloc(p, sizeof(userdir_config));
mva_mode_e cgi_root_mode;
} mva_sconf_t;
-static void *mva_create_server_config(ap_context_t *p, server_rec *s)
+static void *mva_create_server_config(ap_pool_t *p, server_rec *s)
{
mva_sconf_t *conf;
return conf;
}
-static void *mva_merge_server_config(ap_context_t *p, void *parentv, void *childv)
+static void *mva_merge_server_config(ap_pool_t *p, void *parentv, void *childv)
{
mva_sconf_t *parent = (mva_sconf_t *) parentv;
mva_sconf_t *child = (mva_sconf_t *) childv;
char *metafiles;
} cern_meta_dir_config;
-static void *create_cern_meta_dir_config(ap_context_t *p, char *dummy)
+static void *create_cern_meta_dir_config(ap_pool_t *p, char *dummy)
{
cern_meta_dir_config *new =
(cern_meta_dir_config *) ap_palloc(p, sizeof(cern_meta_dir_config));
return new;
}
-static void *merge_cern_meta_dir_configs(ap_context_t *p, void *basev, void *addv)
+static void *merge_cern_meta_dir_configs(ap_pool_t *p, void *basev, void *addv)
{
cern_meta_dir_config *base = (cern_meta_dir_config *) basev;
cern_meta_dir_config *add = (cern_meta_dir_config *) addv;
module MODULE_VAR_EXPORT env_module;
-static void *create_env_dir_config(ap_context_t *p, char *dummy)
+static void *create_env_dir_config(ap_pool_t *p, char *dummy)
{
env_dir_config_rec *new =
(env_dir_config_rec *) ap_palloc(p, sizeof(env_dir_config_rec));
return (void *) new;
}
-static void *merge_env_dir_configs(ap_context_t *p, void *basev, void *addv)
+static void *merge_env_dir_configs(ap_pool_t *p, void *basev, void *addv)
{
env_dir_config_rec *base = (env_dir_config_rec *) basev;
env_dir_config_rec *add = (env_dir_config_rec *) addv;
module MODULE_VAR_EXPORT expires_module;
-static void *create_dir_expires_config(ap_context_t *p, char *dummy)
+static void *create_dir_expires_config(ap_pool_t *p, char *dummy)
{
expires_dir_config *new =
(expires_dir_config *) ap_pcalloc(p, sizeof(expires_dir_config));
* string. If we return NULL then real_code contains code converted
* to the cnnnn format.
*/
-static char *check_code(ap_context_t *p, const char *code, char **real_code)
+static char *check_code(ap_pool_t *p, const char *code, char **real_code)
{
char *word;
char base = 'X';
{NULL}
};
-static void *merge_expires_dir_configs(ap_context_t *p, void *basev, void *addv)
+static void *merge_expires_dir_configs(ap_pool_t *p, void *basev, void *addv)
{
expires_dir_config *new = (expires_dir_config *) ap_pcalloc(p, sizeof(expires_dir_config));
expires_dir_config *base = (expires_dir_config *) basev;
module MODULE_VAR_EXPORT headers_module;
-static void *create_headers_config(ap_context_t *p, server_rec *s)
+static void *create_headers_config(ap_pool_t *p, server_rec *s)
{
headers_conf *a =
(headers_conf *) ap_pcalloc(p, sizeof(headers_conf));
return a;
}
-static void *create_headers_dir_config(ap_context_t *p, char *d)
+static void *create_headers_dir_config(ap_pool_t *p, char *d)
{
return (headers_conf *) create_headers_config(p, NULL);
}
-static void *merge_headers_config(ap_context_t *p, void *basev, void *overridesv)
+static void *merge_headers_config(ap_pool_t *p, void *basev, void *overridesv)
{
headers_conf *a =
(headers_conf *) ap_pcalloc(p, sizeof(headers_conf));
* modified from the free "file" command.
* - all-in-one file for compilation convenience when moving from one
* version of Apache to the next.
- * - Memory allocation is done through the Apache API's ap_context_t structure.
+ * - Memory allocation is done through the Apache API's ap_pool_t structure.
* - All functions have had necessary Apache API request or server
* structures passed to them where necessary to call other Apache API
* routines. (i.e. usually for logging, files, or memory allocation in
static int getvalue(server_rec *, struct magic *, char **);
static int hextoint(int);
static char *getstr(server_rec *, char *, char *, int, int *);
-static int parse(server_rec *, ap_context_t *p, char *, int);
+static int parse(server_rec *, ap_pool_t *p, char *, int);
static int match(request_rec *, unsigned char *, int);
static int mget(request_rec *, union VALUETYPE *, unsigned char *,
module mime_magic_module;
-static void *create_magic_server_config(ap_context_t *p, server_rec *d)
+static void *create_magic_server_config(ap_pool_t *p, server_rec *d)
{
/* allocate the config - use pcalloc because it needs to be zeroed */
return ap_pcalloc(p, sizeof(magic_server_config_rec));
}
-static void *merge_magic_server_config(ap_context_t *p, void *basev, void *addv)
+static void *merge_magic_server_config(ap_pool_t *p, void *basev, void *addv)
{
magic_server_config_rec *base = (magic_server_config_rec *) basev;
magic_server_config_rec *add = (magic_server_config_rec *) addv;
* apprentice - load configuration from the magic file r
* API request record
*/
-static int apprentice(server_rec *s, ap_context_t *p)
+static int apprentice(server_rec *s, ap_pool_t *p)
{
ap_file_t *f = NULL;
ap_status_t result;
/*
* parse one line from magic file, put into magic[index++] if valid
*/
-static int parse(server_rec *serv, ap_context_t *p, char *l, int lineno)
+static int parse(server_rec *serv, ap_pool_t *p, char *l, int lineno)
{
struct magic *m;
char *t, *s;
int method;
};
-static int uncompress_child(struct uncompress_parms *parm, ap_context_t *cntxt,
+static int uncompress_child(struct uncompress_parms *parm, ap_pool_t *cntxt,
BUFF **script_in)
{
int rc = 1;
char *new_argv[4];
char **env;
request_rec *r = parm->r;
- ap_context_t *child_context = cntxt;
+ ap_pool_t *child_context = cntxt;
ap_procattr_t *procattr;
ap_proc_t *procnew = NULL;
ap_file_t *file = NULL;
{
struct uncompress_parms parm;
BUFF *bout = NULL;
- ap_context_t *sub_context;
+ ap_pool_t *sub_context;
ap_status_t rv;
parm.r = r;
* there are cases (i.e. generating directory indicies with mod_autoindex)
* where we would end up with LOTS of zombies.
*/
- if (ap_create_context(&sub_context, r->pool) != APR_SUCCESS)
+ if (ap_create_pool(&sub_context, r->pool) != APR_SUCCESS)
return -1;
if ((rv = uncompress_child(&parm, sub_context, &bout)) != APR_SUCCESS) {
/*
* initialize the module
*/
-static void magic_init(ap_context_t *p, ap_context_t *plog, ap_context_t *ptemp, server_rec *main_server)
+static void magic_init(ap_pool_t *p, ap_pool_t *plog, ap_pool_t *ptemp, server_rec *main_server)
{
int result;
magic_server_config_rec *conf;
module MODULE_VAR_EXPORT setenvif_module;
-static void *create_setenvif_config(ap_context_t *p, server_rec *dummy)
+static void *create_setenvif_config(ap_pool_t *p, server_rec *dummy)
{
sei_cfg_rec *new = (sei_cfg_rec *) ap_palloc(p, sizeof(sei_cfg_rec));
return (void *) new;
}
-static void *merge_setenvif_config(ap_context_t *p, void *basev, void *overridesv)
+static void *merge_setenvif_config(ap_pool_t *p, void *basev, void *overridesv)
{
sei_cfg_rec *a = ap_pcalloc(p, sizeof(sei_cfg_rec));
sei_cfg_rec *base = basev, *overrides = overridesv;
unique_id_rec_total_size,
unique_id_rec_size_uu;
-static void unique_id_global_init(ap_context_t *p, ap_context_t *plog, ap_context_t *ptemp, server_rec *main_server)
+static void unique_id_global_init(ap_pool_t *p, ap_pool_t *plog, ap_pool_t *ptemp, server_rec *main_server)
{
#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN 256
#endif
}
-static void unique_id_child_init(ap_context_t *p, server_rec *s)
+static void unique_id_child_init(ap_pool_t *p, server_rec *s)
{
pid_t pid;
#ifdef HAVE_GETTIMEOFDAY
return OK; /* We set our cookie */
}
-static void *make_cookie_log_state(ap_context_t *p, server_rec *s)
+static void *make_cookie_log_state(ap_pool_t *p, server_rec *s)
{
cookie_log_state *cls =
(cookie_log_state *) ap_palloc(p, sizeof(cookie_log_state));
return (void *) cls;
}
-static void *make_cookie_dir(ap_context_t *p, char *d)
+static void *make_cookie_dir(ap_pool_t *p, char *d)
{
cookie_dir_rec *dcfg;
return OK; /* otherwise; we've done the best we can */
}
-static void proxy_init(server_rec *r, ap_context_t *p)
+static void proxy_init(server_rec *r, ap_pool_t *p)
{
ap_proxy_garbage_init(r, p);
}
/* Setup configurable data */
static void *
- create_proxy_config(ap_context_t *p, server_rec *s)
+ create_proxy_config(ap_pool_t *p, server_rec *s)
{
proxy_server_conf *ps = ap_pcalloc(p, sizeof(proxy_server_conf));
int ap_proxy_hex2c(const char *x);
void ap_proxy_c2hex(int ch, char *x);
-char *ap_proxy_canonenc(ap_context_t *p, const char *x, int len, enum enctype t,
+char *ap_proxy_canonenc(ap_pool_t *p, const char *x, int len, enum enctype t,
int isenc);
-char *ap_proxy_canon_netloc(ap_context_t *p, char **const urlp, char **userp,
+char *ap_proxy_canon_netloc(ap_pool_t *p, char **const urlp, char **userp,
char **passwordp, char **hostp, int *port);
-const char *ap_proxy_date_canon(ap_context_t *p, const char *x);
+const char *ap_proxy_date_canon(ap_pool_t *p, const char *x);
table *ap_proxy_read_headers(request_rec *r, char *buffer, int size, BUFF *f);
long int ap_proxy_send_fb(BUFF *f, request_rec *r, cache_req *c);
void ap_proxy_send_headers(request_rec *r, const char *respline, ap_table_t *hdrs);
cache_req *ap_proxy_cache_error(cache_req *r);
int ap_proxyerror(request_rec *r, int statuscode, const char *message);
const char *ap_proxy_host2addr(const char *host, struct hostent *reqhp);
-int ap_proxy_is_ipaddr(struct dirconn_entry *This, ap_context_t *p);
-int ap_proxy_is_domainname(struct dirconn_entry *This, ap_context_t *p);
-int ap_proxy_is_hostname(struct dirconn_entry *This, ap_context_t *p);
-int ap_proxy_is_word(struct dirconn_entry *This, ap_context_t *p);
+int ap_proxy_is_ipaddr(struct dirconn_entry *This, ap_pool_t *p);
+int ap_proxy_is_domainname(struct dirconn_entry *This, ap_pool_t *p);
+int ap_proxy_is_hostname(struct dirconn_entry *This, ap_pool_t *p);
+int ap_proxy_is_word(struct dirconn_entry *This, ap_pool_t *p);
int ap_proxy_doconnect(int sock, struct sockaddr_in *addr, request_rec *r);
-int ap_proxy_garbage_init(server_rec *, ap_context_t *);
+int ap_proxy_garbage_init(server_rec *, ap_pool_t *);
/* This function is called by ap_table_do() for all header lines */
int ap_proxy_send_hdr_line(void *p, const char *key, const char *value);
unsigned ap_proxy_bputs2(const char *data, BUFF *client, cache_req *cache);
int ap_proxy_ftp_canon(request_rec *r, char *url)
{
char *user, *password, *host, *path, *parms, *strp, sport[7];
- ap_context_t *p = r->pool;
+ ap_pool_t *p = r->pool;
const char *err;
int port;
ap_table_t *resp_hdrs;
BUFF *f;
BUFF *data = NULL;
- ap_context_t *p = r->pool;
+ ap_pool_t *p = r->pool;
int one = 1;
const long int zero = 0L;
NET_SIZE_T clen;
}
/* Clear all connection-based headers from the incoming headers ap_table_t */
-static void clear_connection(ap_context_t *p, ap_table_t *headers)
+static void clear_connection(ap_pool_t *p, ap_table_t *headers)
{
const char *name;
char *next = ap_pstrdup(p, ap_table_get(headers, "Connection"));
BUFF *f;
char buffer[HUGE_STRING_LEN];
char portstr[32];
- ap_context_t *p = r->pool;
+ ap_pool_t *p = r->pool;
const long int zero = 0L;
int destport = 0;
char *destportstr = NULL;
* those which must not be touched.
*/
char *
- ap_proxy_canonenc(ap_context_t *p, const char *x, int len, enum enctype t, int isenc)
+ ap_proxy_canonenc(ap_pool_t *p, const char *x, int len, enum enctype t, int isenc)
{
int i, j, ch;
char *y;
* Returns an error string.
*/
char *
- ap_proxy_canon_netloc(ap_context_t *p, char **const urlp, char **userp,
+ ap_proxy_canon_netloc(ap_pool_t *p, char **const urlp, char **userp,
char **passwordp, char **hostp, int *port)
{
int i;
* formatted, then it exits very quickly.
*/
const char *
- ap_proxy_date_canon(ap_context_t *p, const char *x)
+ ap_proxy_date_canon(ap_pool_t *p, const char *x)
{
int wk, mday, year, hour, min, sec, mon;
char *q, month[4], zone[4], week[4];
}
/* Return TRUE if addr represents an IP address (or an IP network address) */
-int ap_proxy_is_ipaddr(struct dirconn_entry *This, ap_context_t *p)
+int ap_proxy_is_ipaddr(struct dirconn_entry *This, ap_pool_t *p)
{
const char *addr = This->name;
long ip_addr[4];
}
/* Return TRUE if addr represents a domain name */
-int ap_proxy_is_domainname(struct dirconn_entry *This, ap_context_t *p)
+int ap_proxy_is_domainname(struct dirconn_entry *This, ap_pool_t *p)
{
char *addr = This->name;
int i;
}
/* Return TRUE if addr represents a host name */
-int ap_proxy_is_hostname(struct dirconn_entry *This, ap_context_t *p)
+int ap_proxy_is_hostname(struct dirconn_entry *This, ap_pool_t *p)
{
struct hostent host;
char *addr = This->name;
}
/* Return TRUE if addr is to be matched as a word */
-int ap_proxy_is_word(struct dirconn_entry *This, ap_context_t *p)
+int ap_proxy_is_word(struct dirconn_entry *This, ap_pool_t *p)
{
This->matcher = proxy_match_word;
return 1;
static unsigned iterate_pieces(request_rec *r, const test_uri_t *pieces, int row)
{
unsigned u;
- ap_context_t *sub;
+ ap_pool_t *sub;
char *input_uri;
char *strp;
uri_components result;
/* This routine is called by http_core for the BS2000Account directive */
/* It stores the account name for later use */
-const char *os_set_account(ap_context_t *p, const char *account)
+const char *os_set_account(ap_pool_t *p, const char *account)
{
char account_temp[ACCT_LEN+1];
extern int ap_os_is_path_absolute(const char *file);
#endif
-char *ap_os_canonical_filename(ap_context_t *p, const char *file);
-char *ap_os_case_canonical_filename(ap_context_t *p, const char *szFile);
-char *ap_os_systemcase_filename(ap_context_t *p, const char *szFile);
+char *ap_os_canonical_filename(ap_pool_t *p, const char *file);
+char *ap_os_case_canonical_filename(ap_pool_t *p, const char *szFile);
+char *ap_os_systemcase_filename(ap_pool_t *p, const char *szFile);
/* FIXME: the following should be implemented on this platform */
#define ap_os_is_filename_valid(f) (1)
#include <string.h>
-API_EXPORT(char *)ap_os_case_canonical_filename(ap_context_t *pPool, const char *szFile)
+API_EXPORT(char *)ap_os_case_canonical_filename(ap_pool_t *pPool, const char *szFile)
{
char buf[HUGE_STRING_LEN];
char buf2[HUGE_STRING_LEN];
-char *ap_os_systemcase_canonical_filename(ap_context_t *pPool, const char *szFile)
+char *ap_os_systemcase_canonical_filename(ap_pool_t *pPool, const char *szFile)
{
char *szCanonicalFile = ap_os_case_canonical_filename(pPool, szFile);
int startslash = 2, slashnum=0;
-char *ap_os_canonical_filename(ap_context_t *pPool, const char *szFile)
+char *ap_os_canonical_filename(ap_pool_t *pPool, const char *szFile)
{
char *szCanonicalFile = ap_os_systemcase_canonical_filename(pPool, szFile);
strlwr(szCanonicalFile);
-int ap_tpf_spawn_child(ap_context_t *p, int (*func) (void *, child_info *),
+int ap_tpf_spawn_child(ap_pool_t *p, int (*func) (void *, child_info *),
void *data, enum kill_conditions kill_how,
int *pipe_in, int *pipe_out, int *pipe_err,
int out_fds[], int in_fds[], int err_fds[])
return 0;
}
-void os_note_additional_cleanups(ap_context_t *p, int sd) {
+void os_note_additional_cleanups(ap_pool_t *p, int sd) {
char sockfilename[50];
/* write the socket to file so that TPF socket device driver will close socket in case
we happen to abend. */
}
/* OS-dependent filename routines in util_win32.c */
-API_EXPORT(char *) ap_os_canonical_filename(ap_context_t *p, const char *file);
-API_EXPORT(char *) ap_os_case_canonical_filename(ap_context_t *pPool, const char *szFile);
-API_EXPORT(char *) ap_os_systemcase_filename(ap_context_t *pPool, const char *szFile);
+API_EXPORT(char *) ap_os_canonical_filename(ap_pool_t *p, const char *file);
+API_EXPORT(char *) ap_os_case_canonical_filename(ap_pool_t *pPool, const char *szFile);
+API_EXPORT(char *) ap_os_systemcase_filename(ap_pool_t *pPool, const char *szFile);
int ap_os_is_filename_valid(const char *file);
int os_strftime(char *, size_t , const char *, const struct tm *);
* is present on the existing path. This routine also
* converts alias names to long names.
*/
-API_EXPORT(char *) ap_os_systemcase_filename(ap_context_t *pPool,
+API_EXPORT(char *) ap_os_systemcase_filename(ap_pool_t *pPool,
const char *szFile)
{
char buf[HUGE_STRING_LEN];
/* Perform canonicalization with the exception that the
* input case is preserved.
*/
-API_EXPORT(char *) ap_os_case_canonical_filename(ap_context_t *pPool,
+API_EXPORT(char *) ap_os_case_canonical_filename(ap_pool_t *pPool,
const char *szFile)
{
char *pNewStr;
/* Perform complete canonicalization.
*/
-API_EXPORT(char *) ap_os_canonical_filename(ap_context_t *pPool, const char *szFile)
+API_EXPORT(char *) ap_os_canonical_filename(ap_pool_t *pPool, const char *szFile)
{
char *pNewName;
pNewName = ap_os_case_canonical_filename(pPool, szFile);
IMPLEMENT_HOOK_RUN_ALL(int,header_parser,(request_rec *r),(r),OK,DECLINED)
IMPLEMENT_HOOK_VOID(post_config,
- (ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp, server_rec *s),
+ (ap_pool_t *pconf, ap_pool_t *plog, ap_pool_t *ptemp, server_rec *s),
(pconf,plog,ptemp,s))
IMPLEMENT_HOOK_VOID(open_logs,
- (ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp, server_rec *s),
+ (ap_pool_t *pconf, ap_pool_t *plog, ap_pool_t *ptemp, server_rec *s),
(pconf,plog,ptemp,s))
-IMPLEMENT_HOOK_VOID(child_init,(ap_context_t *pchild, server_rec *s),(pchild,s))
+IMPLEMENT_HOOK_VOID(child_init,(ap_pool_t *pchild, server_rec *s),(pchild,s))
/****************************************************************
*
API_VAR_EXPORT module **ap_loaded_modules=NULL;
typedef int (*handler_func) (request_rec *);
-typedef void *(*dir_maker_func) (ap_context_t *, char *);
-typedef void *(*merger_func) (ap_context_t *, void *, void *);
+typedef void *(*dir_maker_func) (ap_pool_t *, char *);
+typedef void *(*merger_func) (ap_pool_t *, void *, void *);
/* Dealing with config vectors. These are associated with per-directory,
* per-server, and per-request configuration, and have a void* pointer for
}
#endif
-static void *create_empty_config(ap_context_t *p)
+static void *create_empty_config(ap_pool_t *p)
{
void **conf_vector = (void **) ap_pcalloc(p, sizeof(void *) *
(total_modules + DYNAMIC_MODULE_LIMIT));
return (void *) conf_vector;
}
-static void *create_default_per_dir_config(ap_context_t *p)
+static void *create_default_per_dir_config(ap_pool_t *p)
{
void **conf_vector = (void **) ap_pcalloc(p, sizeof(void *) * (total_modules + DYNAMIC_MODULE_LIMIT));
module *modp;
}
void *
- ap_merge_per_dir_configs(ap_context_t *p, void *base, void *new)
+ ap_merge_per_dir_configs(ap_pool_t *p, void *base, void *new)
{
void **conf_vector = (void **) ap_palloc(p, sizeof(void *) * total_modules);
void **base_vector = (void **) base;
return (void *) conf_vector;
}
-static void *create_server_config(ap_context_t *p, server_rec *s)
+static void *create_server_config(ap_pool_t *p, server_rec *s)
{
void **conf_vector = (void **) ap_pcalloc(p, sizeof(void *) * (total_modules + DYNAMIC_MODULE_LIMIT));
module *modp;
return (void *) conf_vector;
}
-static void merge_server_configs(ap_context_t *p, void *base, void *virt)
+static void merge_server_configs(ap_pool_t *p, void *base, void *virt)
{
/* Can reuse the 'virt' vector for the spine of it, since we don't
* have to deal with the moral equivalent of .htaccess files here...
}
}
-void *ap_create_request_config(ap_context_t *p)
+void *ap_create_request_config(ap_pool_t *p)
{
return create_empty_config(p);
}
-void *ap_create_conn_config(ap_context_t *p)
+void *ap_create_conn_config(ap_pool_t *p)
{
return create_empty_config(p);
}
-CORE_EXPORT(void *) ap_create_per_dir_config(ap_context_t *p)
+CORE_EXPORT(void *) ap_create_per_dir_config(ap_pool_t *p)
{
return create_empty_config(p);
}
static fast_handler_rec *handlers;
static fast_handler_rec *wildhandlers;
-static void init_handlers(ap_context_t *p)
+static void init_handlers(ap_pool_t *p)
{
module *modp;
int nhandlers = 0;
static cmd_parms default_parms =
{NULL, 0, -1, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
-API_EXPORT(const char *) ap_server_root_relative(ap_context_t *p, const char *file)
+API_EXPORT(const char *) ap_server_root_relative(ap_pool_t *p, const char *file)
{
if(ap_os_is_path_absolute(file))
return file;
return 0;
}
-static void process_command_config(server_rec *s, ap_array_header_t *arr, ap_context_t *p,
- ap_context_t *ptemp)
+static void process_command_config(server_rec *s, ap_array_header_t *arr, ap_pool_t *p,
+ ap_pool_t *ptemp)
{
const char *errmsg;
cmd_parms parms;
ap_cfg_closefile(parms.config_file);
}
-void ap_process_resource_config(server_rec *s, const char *fname, ap_context_t *p, ap_context_t *ptemp)
+void ap_process_resource_config(server_rec *s, const char *fname, ap_pool_t *p, ap_pool_t *ptemp)
{
const char *errmsg;
cmd_parms parms;
}
-CORE_EXPORT(const char *) ap_init_virtual_host(ap_context_t *p, const char *hostname,
+CORE_EXPORT(const char *) ap_init_virtual_host(ap_pool_t *p, const char *hostname,
server_rec *main_server, server_rec **ps)
{
server_rec *s = (server_rec *) ap_pcalloc(p, sizeof(server_rec));
}
-static void fixup_virtual_hosts(ap_context_t *p, server_rec *main_server)
+static void fixup_virtual_hosts(ap_pool_t *p, server_rec *main_server)
{
server_rec *virt;
* Getting *everything* configured...
*/
-static void init_config_globals(ap_context_t *p)
+static void init_config_globals(ap_pool_t *p)
{
/* Global virtual host hash bucket pointers. Init to null. */
ap_init_vhost_config(p);
}
-static server_rec *init_server_config(process_rec *process, ap_context_t *p)
+static server_rec *init_server_config(process_rec *process, ap_pool_t *p)
{
server_rec *s = (server_rec *) ap_pcalloc(p, sizeof(server_rec));
}
-server_rec *ap_read_config(process_rec *process, ap_context_t *ptemp, const char *confname)
+server_rec *ap_read_config(process_rec *process, ap_pool_t *ptemp, const char *confname)
{
- ap_context_t *p = process->pconf;
+ ap_pool_t *p = process->pconf;
server_rec *s = init_server_config(process, p);
init_config_globals(p);
return s;
}
-void ap_single_module_configure(ap_context_t *p, server_rec *s, module *m)
+void ap_single_module_configure(ap_pool_t *p, server_rec *s, module *m)
{
if (m->create_server_config)
ap_set_module_config(s->module_config, m,
(*m->create_dir_config)(p, NULL));
}
-void ap_run_pre_config(ap_context_t *p, ap_context_t *plog, ap_context_t *ptemp)
+void ap_run_pre_config(ap_pool_t *p, ap_pool_t *plog, ap_pool_t *ptemp)
{
module *m;
init_handlers(p);
}
-void ap_post_config_hook(ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp, server_rec *s)
+void ap_post_config_hook(ap_pool_t *pconf, ap_pool_t *plog, ap_pool_t *ptemp, server_rec *s)
{
ap_run_post_config(pconf,plog,ptemp,s);
init_handlers(pconf);
}
-void ap_child_init_hook(ap_context_t *pchild, server_rec *s)
+void ap_child_init_hook(ap_pool_t *pchild, server_rec *s)
{
/* TODO: uh this seems ugly, is there a better way? */
/*ap_child_init_alloc(); PUT THIS BACK IN XXXXX */
structure, but for now...
*/
-conn_rec *ap_new_connection(ap_context_t *p, server_rec *server, BUFF *inout,
+conn_rec *ap_new_connection(ap_pool_t *p, server_rec *server, BUFF *inout,
const struct sockaddr_in *remaddr,
const struct sockaddr_in *saddr, long id)
{
-conn_rec *ap_new_apr_connection(ap_context_t *p, server_rec *server, BUFF *inout,
+conn_rec *ap_new_apr_connection(ap_pool_t *p, server_rec *server, BUFF *inout,
const ap_socket_t *conn_socket, long id)
{
struct sockaddr_in *sa_local, *sa_remote;
static int send_buffer_size;
/* TODO: make_sock is just begging and screaming for APR abstraction */
-static ap_status_t make_sock(ap_context_t *p, ap_listen_rec *server)
+static ap_status_t make_sock(ap_pool_t *p, ap_listen_rec *server)
{
ap_socket_t *s = server->sd;
int one = 1;
int ap_listen_open(process_rec *process, unsigned port)
{
- ap_context_t *pconf = process->pconf;
+ ap_pool_t *pconf = process->pconf;
ap_listen_rec *lr;
ap_listen_rec *next;
int num_open;
{NULL, -1},
};
-static int log_child(ap_context_t *p, const char *progname,
+static int log_child(ap_pool_t *p, const char *progname,
ap_file_t **fpin)
{
/* Child process code for 'ErrorLog "|..."';
return(rc);
}
-static void open_error_log(server_rec *s, ap_context_t *p)
+static void open_error_log(server_rec *s, ap_pool_t *p)
{
const char *fname;
int rc;
}
}
-void ap_open_logs(server_rec *s_main, ap_context_t *p)
+void ap_open_logs(server_rec *s_main, ap_pool_t *p)
{
ap_status_t rc = APR_SUCCESS;
server_rec *virt, *q;
va_end(args);
}
-void ap_log_pid(ap_context_t *p, const char *fname)
+void ap_log_pid(ap_pool_t *p, const char *fname)
{
ap_file_t *pid_file = NULL;
ap_finfo_t finfo;
return APR_SUCCESS;
}
-API_EXPORT(piped_log *) ap_open_piped_log(ap_context_t *p, const char *program)
+API_EXPORT(piped_log *) ap_open_piped_log(ap_pool_t *p, const char *program)
{
piped_log *pl;
return APR_SUCCESS;
}
-API_EXPORT(piped_log *) ap_open_piped_log(ap_context_t *p, const char *program)
+API_EXPORT(piped_log *) ap_open_piped_log(ap_pool_t *p, const char *program)
{
piped_log *pl;
ap_file_t *dummy = NULL;
process_rec *process;
{
- ap_context_t *cntx;
+ ap_pool_t *cntx;
ap_status_t stat;
- stat = ap_create_context(&cntx, NULL);
+ stat = ap_create_pool(&cntx, NULL);
if (stat != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, NULL,
- "ap_create_context() failed to create "
+ "ap_create_pool() failed to create "
"initial context");
ap_terminate();
exit(1);
process = ap_palloc(cntx, sizeof(process_rec));
process->pool = cntx;
}
- ap_create_context(&process->pconf, process->pool);
+ ap_create_pool(&process->pconf, process->pool);
process->argc = argc;
process->argv = argv;
process->short_name = ap_filename_of_pathname(argv[0]);
destroy_and_exit_process(process, 1);
}
-ap_context_t *g_pHookPool;
+ap_pool_t *g_pHookPool;
#ifdef WIN32
API_EXPORT_NONSTD(int) apache_main(int argc, char *argv[])
const char *def_server_root = HTTPD_ROOT;
process_rec *process;
server_rec *server_conf;
- ap_context_t *pglobal;
- ap_context_t *pconf;
- ap_context_t *plog; /* Pool of log streams, reset _after_ each read of conf */
- ap_context_t *ptemp; /* Pool for temporary config stuff, reset often */
- ap_context_t *pcommands; /* Pool for -C and -c switches */
+ ap_pool_t *pglobal;
+ ap_pool_t *pconf;
+ ap_pool_t *plog; /* Pool of log streams, reset _after_ each read of conf */
+ ap_pool_t *ptemp; /* Pool for temporary config stuff, reset often */
+ ap_pool_t *pcommands; /* Pool for -C and -c switches */
module **mod;
#ifndef WIN32 /* done in main_win32.c */
ap_setup_prelinked_modules(process);
- ap_create_context(&pcommands, pglobal);
+ ap_create_pool(&pcommands, pglobal);
ap_server_pre_read_config = ap_make_array(pcommands, 1, sizeof(char *));
ap_server_post_read_config = ap_make_array(pcommands, 1, sizeof(char *));
ap_server_config_defines = ap_make_array(pcommands, 1, sizeof(char *));
}
}
- ap_create_context(&plog, pglobal);
- ap_create_context(&ptemp, pconf);
+ ap_create_pool(&plog, pglobal);
+ ap_create_pool(&ptemp, pconf);
/* Note that we preflight the config file once
before reading it _again_ in the main loop.
for (mod = ap_prelinked_modules; *mod != NULL; mod++) {
ap_register_hooks(*mod);
}
- ap_create_context(&ptemp, pconf);
+ ap_create_pool(&ptemp, pconf);
ap_server_root = def_server_root;
ap_run_pre_config(pconf, plog, ptemp);
server_conf = ap_read_config(process, ptemp, confname);
int raise_sigstop_flags;
#endif
-static ap_context_t *pconf; /* Pool for config stuff */
-static ap_context_t *pchild; /* Pool for httpd child stuff */
-static ap_context_t *thread_pool_parent; /* Parent of per-thread pools */
+static ap_pool_t *pconf; /* Pool for config stuff */
+static ap_pool_t *pchild; /* Pool for httpd child stuff */
+static ap_pool_t *thread_pool_parent; /* Parent of per-thread pools */
static pthread_mutex_t thread_pool_parent_mutex;
static int child_num;
* Child process main loop.
*/
-static void process_socket(ap_context_t *p, ap_socket_t *sock, long conn_id)
+static void process_socket(ap_pool_t *p, ap_socket_t *sock, long conn_id)
{
BUFF *conn_io;
conn_rec *current_conn;
static void *worker_thread(void *arg)
{
ap_socket_t *csd = NULL;
- ap_context_t *tpool; /* Pool for this thread */
- ap_context_t *ptrans; /* Pool for per-transaction stuff */
+ ap_pool_t *tpool; /* Pool for this thread */
+ ap_pool_t *ptrans; /* Pool for per-transaction stuff */
ap_socket_t *sd = NULL;
int srv;
int curr_pollfd, last_pollfd = 0;
ap_status_t rv;
pthread_mutex_lock(&thread_pool_parent_mutex);
- ap_create_context(&tpool, thread_pool_parent);
+ ap_create_pool(&tpool, thread_pool_parent);
pthread_mutex_unlock(&thread_pool_parent_mutex);
- ap_create_context(&ptrans, tpool);
+ ap_create_pool(&ptrans, tpool);
while (!workers_may_exit) {
workers_may_exit |= (max_requests_per_child != 0) && (requests_this_child <= 0);
my_pid = getpid();
child_num = child_num_arg;
- ap_create_context(&pchild, pconf);
+ ap_create_pool(&pchild, pconf);
/*stuff to do before we switch id's, so we have permissions.*/
for (i = 0; i < max_threads; i++) {
worker_thread_free_ids[i] = i;
}
- ap_create_context(&thread_pool_parent, pchild);
+ ap_create_pool(&thread_pool_parent, pchild);
pthread_mutex_init(&thread_pool_parent_mutex, NULL);
pthread_mutex_init(&idle_thread_count_mutex, NULL);
pthread_mutex_init(&worker_thread_count_mutex, NULL);
return APR_SUCCESS;
}
-int ap_mpm_run(ap_context_t *_pconf, ap_context_t *plog, server_rec *s)
+int ap_mpm_run(ap_pool_t *_pconf, ap_pool_t *plog, server_rec *s)
{
int remaining_children_to_start;
int i;
return 0;
}
-static void dexter_pre_config(ap_context_t *p, ap_context_t *plog, ap_context_t *ptemp)
+static void dexter_pre_config(ap_pool_t *p, ap_pool_t *plog, ap_pool_t *ptemp)
{
static int restart_num = 0;
return BaseAddress;
}
-static void setup_shared_mem(ap_context_t *p)
+static void setup_shared_mem(ap_pool_t *p)
{
caddr_t m;
ap_scoreboard_image = (scoreboard *) m;
}
-API_EXPORT(void) reopen_scoreboard(ap_context_t *p)
+API_EXPORT(void) reopen_scoreboard(ap_pool_t *p)
{
caddr_t m;
int rc;
shm_unlink(ap_scoreboard_fname);
}
-static void setup_shared_mem(ap_context_t *p)
+static void setup_shared_mem(ap_pool_t *p)
{
char buf[512];
caddr_t m;
ap_scoreboard_image = (scoreboard *) m;
}
-API_EXPORT(void) reopen_scoreboard(ap_context_t *p)
+API_EXPORT(void) reopen_scoreboard(ap_pool_t *p)
{
}
#elif defined(USE_MMAP_SCOREBOARD)
-static void setup_shared_mem(ap_context_t *p)
+static void setup_shared_mem(ap_pool_t *p)
{
caddr_t m;
ap_scoreboard_image = (scoreboard *) m;
}
-API_EXPORT(void) reopen_scoreboard(ap_context_t *p)
+API_EXPORT(void) reopen_scoreboard(ap_pool_t *p)
{
}
static key_t shmkey = IPC_PRIVATE;
static int shmid = -1;
-static void setup_shared_mem(ap_context_t *p)
+static void setup_shared_mem(ap_pool_t *p)
{
struct shmid_ds shmbuf;
const server_rec * server_conf = ap_get_server_conf();
#endif
}
-API_EXPORT(void) reopen_scoreboard(ap_context_t *p)
+API_EXPORT(void) reopen_scoreboard(ap_pool_t *p)
{
}
#endif
/* Called by parent process */
-void reinit_scoreboard(ap_context_t *p)
+void reinit_scoreboard(ap_pool_t *p)
{
if (ap_scoreboard_image == NULL) {
setup_shared_mem(p);
return NULL;
}
-ap_array_header_t *ap_get_connections(ap_context_t *p)
+ap_array_header_t *ap_get_connections(ap_pool_t *p)
{
int i;
ap_array_header_t *connection_list;
return connection_list;
}
-ap_array_header_t *ap_get_connection_keys(ap_context_t *p, long conn_id)
+ap_array_header_t *ap_get_connection_keys(ap_pool_t *p, long conn_id)
{
int i = 0;
status_table_entry *ss;
return;
}
-ap_array_header_t *ap_get_status_table(ap_context_t *p)
+ap_array_header_t *ap_get_status_table(ap_pool_t *p)
{
int i, j;
ap_array_header_t *server_status;
#include "mpm_default.h" /* For HARD_.*_LIMIT */
/* The generic shared memory chunk code */
-void reinit_scoreboard(ap_context_t *p);
+void reinit_scoreboard(ap_pool_t *p);
#if defined(USE_OS2_SCOREBOARD)
caddr_t create_shared_heap(const char *name, size_t size);
caddr_t get_shared_heap(const char *Name);
#endif
-API_EXPORT(void) reopen_scoreboard(ap_context_t *p);
+API_EXPORT(void) reopen_scoreboard(ap_pool_t *p);
/* The stuff for Dexter's status table */
static struct pollfd *listenfds;
ap_lock_t *accept_mutex = NULL;
-static ap_context_t *pconf; /* Pool for config stuff */
-static ap_context_t *pchild; /* Pool for httpd child stuff */
+static ap_pool_t *pconf; /* Pool for config stuff */
+static ap_pool_t *pchild; /* Pool for httpd child stuff */
static int my_pid; /* Linux getpid() doesn't work except in main thread. Use
this instead */
int pid;
thread_id tid;
int sd;
- ap_context_t *tpool; /* "pthread" would be confusing */
+ ap_pool_t *tpool; /* "pthread" would be confusing */
} proc_info;
#define SERVER_DEAD 0
* Child process main loop.
*/
-static void process_socket(ap_context_t *p, ap_socket_t *sock, int my_child_num, int my_thread_num)
+static void process_socket(ap_pool_t *p, ap_socket_t *sock, int my_child_num, int my_thread_num)
{
BUFF *conn_io;
conn_rec *current_conn;
proc_info * ti = dummy;
int process_slot = ti->pid;
int thread_slot = ti->tid;
- ap_context_t *tpool = ti->tpool;
+ ap_pool_t *tpool = ti->tpool;
struct sockaddr sa_client;
ap_socket_t *csd = NULL;
- ap_context_t *ptrans; /* Pool for per-transaction stuff */
+ ap_pool_t *ptrans; /* Pool for per-transaction stuff */
ap_socket_t *sd = NULL;
int srv;
int curr_pollfd, last_pollfd = 0;
sigfillset(&sig_mask);
sigprocmask(SIG_BLOCK, &sig_mask, NULL);
- ap_create_context(&ptrans, tpool);
+ ap_create_pool(&ptrans, tpool);
ap_lock(worker_thread_count_mutex);
worker_thread_count++;
ap_status_t rv;
my_pid = getpid();
- ap_create_context(&pchild, pconf);
+ ap_create_pool(&pchild, pconf);
if (beosd_setup_child()) {
clean_child_exit(APEXIT_CHILDFATAL);
my_info->pid = my_child_num;
my_info->tid = i;
my_info->sd = 0;
- ap_create_context(&my_info->tpool, pchild);
+ ap_create_pool(&my_info->tpool, pchild);
/* We are creating threads right now */
}
}
-int ap_mpm_run(ap_context_t *_pconf, ap_context_t *plog, server_rec *s)
+int ap_mpm_run(ap_pool_t *_pconf, ap_pool_t *plog, server_rec *s)
{
int remaining_children_to_start;
ap_status_t rv;
return 0;
}
-static void mpmt_beos_pre_config(ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp)
+static void mpmt_beos_pre_config(ap_pool_t *pconf, ap_pool_t *plog, ap_pool_t *ptemp)
{
static int restart_num = 0;
#include "scoreboard.h"
scoreboard *ap_scoreboard_image = NULL;
-extern ap_context_t * pconf;
+extern ap_pool_t * pconf;
static int maintain_connection_status = 1;
-void reinit_scoreboard(ap_context_t *p)
+void reinit_scoreboard(ap_pool_t *p)
{
ap_assert(!ap_scoreboard_image);
ap_scoreboard_image = (scoreboard *) malloc(SCOREBOARD_SIZE);
return NULL;
}
-ap_array_header_t *ap_get_connections(ap_context_t *p)
+ap_array_header_t *ap_get_connections(ap_pool_t *p)
{
int i;
ap_array_header_t *connection_list;
return connection_list;
}
-ap_array_header_t *ap_get_connection_keys(ap_context_t *p, long conn_id)
+ap_array_header_t *ap_get_connection_keys(ap_pool_t *p, long conn_id)
{
int i = 0;
status_table_entry *ss;
return key_list;
}
-ap_array_header_t *ap_get_status_table(ap_context_t *p)
+ap_array_header_t *ap_get_status_table(ap_pool_t *p)
{
int i, j;
ap_array_header_t *server_status;
#include "mpm_default.h" /* For HARD_.*_LIMIT */
API_EXPORT(int) ap_exists_scoreboard_image(void);
-void reinit_scoareboard(ap_context_t *p);
+void reinit_scoareboard(ap_pool_t *p);
void cleanup_scoreboard(void);
void ap_mpmt_beos_set_maintain_connection_status(int flag);
void ap_mpmt_beos_force_reset_connection_status(long conn_id);
-void reinit_scoreboard(ap_context_t *p);
+void reinit_scoreboard(ap_pool_t *p);
void update_scoreboard_global(void);
API_EXPORT(int) find_child_by_pid(int pid);
int ap_update_child_status(int child_num, int thread_num, int status, request_rec *r);
int pid;
int tid;
int sd;
- ap_context_t *tpool; /* "pthread" would be confusing */
+ ap_pool_t *tpool; /* "pthread" would be confusing */
} proc_info;
/*
int raise_sigstop_flags;
#endif
-static ap_context_t *pconf; /* Pool for config stuff */
-static ap_context_t *pchild; /* Pool for httpd child stuff */
+static ap_pool_t *pconf; /* Pool for config stuff */
+static ap_pool_t *pchild; /* Pool for httpd child stuff */
static int my_pid; /* Linux getpid() doesn't work except in main thread. Use
this instead */
* Child process main loop.
*/
-static void process_socket(ap_context_t *p, ap_socket_t *sock, int my_child_num, int my_thread_num)
+static void process_socket(ap_pool_t *p, ap_socket_t *sock, int my_child_num, int my_thread_num)
{
BUFF *conn_io;
conn_rec *current_conn;
proc_info * ti = dummy;
int process_slot = ti->pid;
int thread_slot = ti->tid;
- ap_context_t *tpool = ti->tpool;
+ ap_pool_t *tpool = ti->tpool;
ap_socket_t *csd = NULL;
- ap_context_t *ptrans; /* Pool for per-transaction stuff */
+ ap_pool_t *ptrans; /* Pool for per-transaction stuff */
ap_socket_t *sd = NULL;
int n;
int curr_pollfd, last_pollfd = 0;
free(ti);
- ap_create_context(&ptrans, tpool);
+ ap_create_pool(&ptrans, tpool);
pthread_mutex_lock(&worker_thread_count_mutex);
worker_thread_count++;
my_pid = getpid();
- ap_create_context(&pchild, pconf);
+ ap_create_pool(&pchild, pconf);
/*stuff to do before we switch id's, so we have permissions.*/
reopen_scoreboard(pchild);
my_info->pid = my_child_num;
my_info->tid = i;
my_info->sd = 0;
- ap_create_context(&my_info->tpool, pchild);
+ ap_create_pool(&my_info->tpool, pchild);
/* We are creating threads right now */
(void) ap_update_child_status(my_child_num, i, SERVER_STARTING,
}
}
-int ap_mpm_run(ap_context_t *_pconf, ap_context_t *plog, server_rec *s)
+int ap_mpm_run(ap_pool_t *_pconf, ap_pool_t *plog, server_rec *s)
{
int remaining_children_to_start;
ap_status_t rv;
return 0;
}
-static void mpmt_pthread_pre_config(ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp)
+static void mpmt_pthread_pre_config(ap_pool_t *pconf, ap_pool_t *plog, ap_pool_t *ptemp)
{
static int restart_num = 0;
ap_shm_destroy(scoreboard_shm);
}
-static void setup_shared_mem(ap_context_t *p)
+static void setup_shared_mem(ap_pool_t *p)
{
char buf[512];
const char *fname;
ap_scoreboard_image->global.running_generation = 0;
}
-void reopen_scoreboard(ap_context_t *p)
+void reopen_scoreboard(ap_pool_t *p)
{
}
#endif /* APR_SHARED_MEM */
/* Called by parent process */
-void reinit_scoreboard(ap_context_t *p)
+void reinit_scoreboard(ap_pool_t *p)
{
int running_gen = 0;
if (ap_scoreboard_image)
return NULL;
}
-ap_array_header_t *ap_get_connections(ap_context_t *p)
+ap_array_header_t *ap_get_connections(ap_pool_t *p)
{
int i;
ap_array_header_t *connection_list;
return connection_list;
}
-ap_array_header_t *ap_get_connection_keys(ap_context_t *p, long conn_id)
+ap_array_header_t *ap_get_connection_keys(ap_pool_t *p, long conn_id)
{
int i = 0;
status_table_entry *ss;
return;
}
-ap_array_header_t *ap_get_status_table(ap_context_t *p)
+ap_array_header_t *ap_get_status_table(ap_pool_t *p)
{
int i, j;
ap_array_header_t *server_status;
#endif
API_EXPORT(int) ap_exists_scoreboard_image(void);
-void reinit_scoareboard(ap_context_t *p);
+void reinit_scoareboard(ap_pool_t *p);
void cleanup_scoreboard(void);
API_EXPORT(void) ap_sync_scoreboard_image(void);
void ap_mpmt_pthread_force_reset_connection_status(long conn_id);
#elif defined(USE_POSIX_SCOREBOARD)
static void cleanup_shared_mem(void *d);
#else
-void reinit_scoreboard(ap_context_t *p);
+void reinit_scoreboard(ap_pool_t *p);
#endif
-API_EXPORT(void) reopen_scoreboard(ap_context_t *p);
+API_EXPORT(void) reopen_scoreboard(ap_pool_t *p);
ap_inline void ap_sync_scoreboard_image(void);
void increment_counts(int child_num, int thread_num, request_rec *r);
static int one_process = 0;
-static ap_context_t *pconf; /* Pool for config stuff */
-static ap_context_t *pchild; /* Pool for httpd child stuff */
+static ap_pool_t *pconf; /* Pool for config stuff */
+static ap_pool_t *pchild; /* Pool for httpd child stuff */
static int my_pid; /* it seems silly to call getpid all the time */
#ifndef MULTITHREAD
}
#if defined(USE_FCNTL_SERIALIZED_ACCEPT) || defined(USE_FLOCK_SERIALIZED_ACCEPT)
-static void expand_lock_fname(ap_context_t *p)
+static void expand_lock_fname(ap_pool_t *p)
{
/* XXXX possibly bogus cast */
ap_lock_fname = ap_psprintf(p, "%s.%lu",
#define accept_mutex_child_init(x)
-static void accept_mutex_init(ap_context_t *p)
+static void accept_mutex_init(ap_pool_t *p)
{
ptrdiff_t old;
usptr_t *us;
}
}
-static void accept_mutex_child_init(ap_context_t *p)
+static void accept_mutex_child_init(ap_pool_t *p)
{
ap_register_cleanup(p, NULL, accept_mutex_child_cleanup, ap_null_cleanup);
}
accept_mutex = (void *)(caddr_t)-1;
}
-static void accept_mutex_init(ap_context_t *p)
+static void accept_mutex_init(ap_pool_t *p)
{
pthread_mutexattr_t mattr;
int fd;
#define accept_mutex_child_init(x)
-static void accept_mutex_init(ap_context_t *p)
+static void accept_mutex_init(ap_pool_t *p)
{
union semun ick;
struct semid_ds buf;
* Initialize mutex lock.
* Must be safe to call this on a restart.
*/
-static void accept_mutex_init(ap_context_t *p)
+static void accept_mutex_init(ap_pool_t *p)
{
ap_file_t *tempfile = NULL;
lock_it.l_whence = SEEK_SET; /* from current point */
* Initialize mutex lock.
* Done by each child at it's birth
*/
-static void accept_mutex_child_init(ap_context_t *p)
+static void accept_mutex_child_init(ap_pool_t *p)
{
ap_file_t *tempfile = NULL;
ap_status_t ret;
* Initialize mutex lock.
* Must be safe to call this on a restart.
*/
-static void accept_mutex_init(ap_context_t *p)
+static void accept_mutex_init(ap_pool_t *p)
{
ap_file_t *tempfile = NULL;
ap_status_t ret;
* Initialize mutex lock.
* Done by each child at it's birth
*/
-static void accept_mutex_child_init(ap_context_t *p)
+static void accept_mutex_child_init(ap_pool_t *p)
{
int rc = DosOpenMutexSem(NULL, &lock_sem);
* Initialize mutex lock.
* Must be safe to call this on a restart.
*/
-static void accept_mutex_init(ap_context_t *p)
+static void accept_mutex_init(ap_pool_t *p)
{
int rc = DosCreateMutexSem(NULL, &lock_sem, DC_SEM_SHARED, FALSE);
#define accept_mutex_init(x)
-static void accept_mutex_child_init(ap_context_t *p)
+static void accept_mutex_child_init(ap_pool_t *p)
{
ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
tpf_core_held = 0;
return APR_SUCCESS;
}
-static void setup_shared_mem(ap_context_t *p)
+static void setup_shared_mem(ap_pool_t *p)
{
char buf[512];
const char *fname;
ap_scoreboard_image->global.running_generation = 0;
}
-static void reopen_scoreboard(ap_context_t *p)
+static void reopen_scoreboard(ap_pool_t *p)
{
}
#endif
/* Called by parent process */
-static void reinit_scoreboard(ap_context_t *p)
+static void reinit_scoreboard(ap_pool_t *p)
{
int running_gen = 0;
if (ap_scoreboard_image)
ap_listen_rec *lr;
ap_listen_rec *last_lr;
ap_listen_rec *first_lr;
- ap_context_t *ptrans;
+ ap_pool_t *ptrans;
conn_rec *current_conn;
ap_iol *iol;
ap_status_t stat;
/* Get a sub context for global allocations in this child, so that
* we can have cleanups occur when the child exits.
*/
- ap_create_context(&pchild, pconf);
+ ap_create_pool(&pchild, pconf);
- ap_create_context(&ptrans, pchild);
+ ap_create_pool(&ptrans, pchild);
/* needs to be done before we switch UIDs so we have permissions */
reopen_scoreboard(pchild);
* Executive routines.
*/
-int ap_mpm_run(ap_context_t *_pconf, ap_context_t *plog, server_rec *s)
+int ap_mpm_run(ap_pool_t *_pconf, ap_pool_t *plog, server_rec *s)
{
int remaining_children_to_start;
return 0;
}
-static void prefork_pre_config(ap_context_t *p, ap_context_t *plog, ap_context_t *ptemp)
+static void prefork_pre_config(ap_pool_t *p, ap_pool_t *plog, ap_pool_t *ptemp)
{
static int restart_num = 0;
return NULL;
}
-ap_array_header_t *ap_get_connections(ap_context_t *p)
+ap_array_header_t *ap_get_connections(ap_pool_t *p)
{
int i;
ap_array_header_t *connection_list;
return connection_list;
}
-ap_array_header_t *ap_get_connection_keys(ap_context_t *p, long conn_id)
+ap_array_header_t *ap_get_connection_keys(ap_pool_t *p, long conn_id)
{
int i = 0;
status_table_entry *ss;
return;
}
-ap_array_header_t *ap_get_status_table(ap_context_t *p)
+ap_array_header_t *ap_get_status_table(ap_pool_t *p)
{
int i, j;
ap_array_header_t *server_status;
static other_child_rec *other_children;
#endif
-static ap_context_t *pconf; /* Pool for config stuff */
+static ap_pool_t *pconf; /* Pool for config stuff */
static scoreboard *ap_scoreboard_image = NULL;
struct thread_globals {
int child_num;
- ap_context_t *pchild; /* Pool for httpd child stuff */
+ ap_pool_t *pchild; /* Pool for httpd child stuff */
int usr1_just_die;
};
#define THREAD_GLOBAL(gvar) ((*ppthread_globals)->gvar)
-void reinit_scoreboard(ap_context_t *p)
+void reinit_scoreboard(ap_pool_t *p)
{
if (ap_scoreboard_image == NULL) {
ap_scoreboard_image = (scoreboard *) malloc(SCOREBOARD_SIZE);
* Initialize mutex lock.
* Done by each child at it's birth
*/
-static void accept_mutex_child_init(ap_context_t *p)
+static void accept_mutex_child_init(ap_pool_t *p)
{
int rc = DosOpenMutexSem(NULL, &lock_sem);
* Initialize mutex lock.
* Must be safe to call this on a restart.
*/
-static void accept_mutex_init(ap_context_t *p)
+static void accept_mutex_init(ap_pool_t *p)
{
int rc = DosCreateMutexSem(NULL, &lock_sem, DC_SEM_SHARED, FALSE);
-static int setup_listeners(ap_context_t *pchild, ap_pollfd_t **listen_poll)
+static int setup_listeners(ap_pool_t *pchild, ap_pollfd_t **listen_poll)
{
ap_listen_rec *lr;
int numfds = 0;
{
ap_listen_rec *lr = NULL;
ap_listen_rec *first_lr = NULL;
- ap_context_t *ptrans;
+ ap_pool_t *ptrans;
conn_rec *current_conn;
ap_iol *iol;
- ap_context_t *pchild;
+ ap_pool_t *pchild;
parent_score *sc_parent_rec;
int requests_this_child = 0;
ap_pollfd_t *listen_poll;
/* Get a sub pool for global allocations in this child, so that
* we can have cleanups occur when the child exits.
*/
- ap_create_context(&pchild, pconf);
+ ap_create_pool(&pchild, pconf);
*ppthread_globals = (struct thread_globals *)ap_palloc(pchild, sizeof(struct thread_globals));
THREAD_GLOBAL(child_num) = (int)child_num_arg;
sc_parent_rec = ap_scoreboard_image->parent + THREAD_GLOBAL(child_num);
THREAD_GLOBAL(pchild) = pchild;
- ap_create_context(&ptrans, pchild);
+ ap_create_pool(&ptrans, pchild);
if (setup_listeners(pchild, &listen_poll)) {
clean_child_exit(1);
* Executive routines.
*/
-int ap_mpm_run(ap_context_t *_pconf, ap_context_t *plog, server_rec *s)
+int ap_mpm_run(ap_pool_t *_pconf, ap_pool_t *plog, server_rec *s)
{
int remaining_children_to_start;
int i;
return 0;
}
-static void spmt_os2_pre_config(ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp)
+static void spmt_os2_pre_config(ap_pool_t *pconf, ap_pool_t *plog, ap_pool_t *ptemp)
{
one_process = !!getenv("ONE_PROCESS");
static int num_listenfds = 0;
static SOCKET listenmaxfd = INVALID_SOCKET;
-static ap_context_t *pconf; /* Pool for config stuff */
+static ap_pool_t *pconf; /* Pool for config stuff */
static char ap_coredump_dir[MAX_STRING_LEN];
"win9x_get_connection: ap_pcalloc() failed. Process will exit.");
return NULL;
}
- ap_create_context(&context->ptrans, pconf);
+ ap_create_pool(&context->ptrans, pconf);
}
}
}
}
-static int create_acceptex_context(ap_context_t *_pconf, ap_listen_rec *lr)
+static int create_acceptex_context(ap_pool_t *_pconf, ap_listen_rec *lr)
{
PCOMP_CONTEXT context;
DWORD BytesRead;
"create_acceptex_context: socket() failed. Process will exit.");
return -1;
}
- ap_create_context(&context->ptrans, _pconf);
+ ap_create_pool(&context->ptrans, _pconf);
context->conn_io = ap_bcreate(context->ptrans, B_RDWR);
context->recv_buf = context->conn_io->inbase;
context->recv_buf_size = context->conn_io->bufsiz - 2*PADDED_ADDR_SIZE;
ap_status_t status;
time_t end_time;
int i;
- ap_context_t *pchild;
+ ap_pool_t *pchild;
/* This is the child process or we are running in single process
* mode.
ap_assert(start_mutex);
ap_assert(exit_event);
- ap_create_context(&pchild, pconf);
+ ap_create_pool(&pchild, pconf);
if (listenmaxfd == INVALID_SOCKET) {
(*processes)--;
}
-static int create_process(ap_context_t *p, HANDLE *handles, HANDLE *events, int *processes)
+static int create_process(ap_pool_t *p, HANDLE *handles, HANDLE *events, int *processes)
{
int rv;
/*
* winnt_pre_config() hook
*/
-static void winnt_pre_config(ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp)
+static void winnt_pre_config(ap_pool_t *pconf, ap_pool_t *plog, ap_pool_t *ptemp)
{
char *pid;
}
-static void winnt_post_config(ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp, server_rec* server_conf)
+static void winnt_post_config(ap_pool_t *pconf, ap_pool_t *plog, ap_pool_t *ptemp, server_rec* server_conf)
{
server_conf = server_conf;
}
-API_EXPORT(int) ap_mpm_run(ap_context_t *_pconf, ap_context_t *plog, server_rec *s )
+API_EXPORT(int) ap_mpm_run(ap_pool_t *_pconf, ap_pool_t *plog, server_rec *s )
{
static int restart = 0; /* Default is "not a restart" */
// time_t tmstart;
/* NOP */
}
-API_EXPORT(ap_array_header_t *) ap_get_status_table(ap_context_t *p)
+API_EXPORT(ap_array_header_t *) ap_get_status_table(ap_pool_t *p)
{
/* NOP */
return NULL;
BUFF *conn_io;
char *recv_buf;
int recv_buf_size;
- ap_context_t *ptrans;
+ ap_pool_t *ptrans;
struct sockaddr *sa_server;
int sa_server_len;
struct sockaddr *sa_client;
*
* If ppValue is NULL, allocate space for the value and return it in
* *pValue. The return value is the number of bytes in the value.
- * The first argument is the ap_context_t to use to allocate space for the value.
+ * The first argument is the ap_pool_t to use to allocate space for the value.
*
* If pValue is not NULL, assume it is a buffer of nSizeValue bytes,
* and write the value into the buffer. The return value is the number
* of bytes in the value (so if the return value is greater than
* the supplied nSizeValue, the caller knows that *pValue is truncated).
- * The ap_context_t argument is ignored.
+ * The ap_pool_t argument is ignored.
*
* The return value is the number of bytes in the successfully retreived
* key if everything worked, or:
* message will be logged at priority "warning".
*/
-static int ap_registry_get_key_int(ap_context_t *p, char *key, char *name, char *pBuffer, int nSizeBuffer, char **ppValue)
+static int ap_registry_get_key_int(ap_pool_t *p, char *key, char *name, char *pBuffer, int nSizeBuffer, char **ppValue)
{
long rv;
HKEY hKey;
* an error getting the key.
*/
#if 0
-int ap_registry_get_server_root(ap_context_t *p, char *dir, int size)
+int ap_registry_get_server_root(ap_pool_t *p, char *dir, int size)
{
int rv;
return (rv < -1) ? -1 : 0;
}
#else
-int ap_registry_get_server_root(ap_context_t *p, char **buf)
+int ap_registry_get_server_root(ap_pool_t *p, char **buf)
{
int rv;
return(key);
}
#if 0
-int ap_registry_get_service_conf(ap_context_t *p, char *dir, int size, char *service_name)
+int ap_registry_get_service_conf(ap_pool_t *p, char *dir, int size, char *service_name)
{
int rv;
char *key = ap_get_service_key(service_name);
return (rv < -1) ? -1 : 0;
}
#else
-int ap_registry_get_service_conf(ap_context_t *p, char **buf, char *service_name)
+int ap_registry_get_service_conf(ap_pool_t *p, char **buf, char *service_name)
{
int rv;
char *key = ap_get_service_key(service_name);
char **new, *server_root, *tmp;
char *server_confname = SERVER_CONFIG_FILE;
ap_array_header_t *cmdtbl;
- ap_context_t *pwincmd;
+ ap_pool_t *pwincmd;
- ap_create_context(&pwincmd, NULL);
+ ap_create_pool(&pwincmd, NULL);
if (pwincmd == NULL) {
exit(0);
}
* 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.
*/
-API_EXPORT(char *) ap_field_noparam(ap_context_t *p, const char *intype)
+API_EXPORT(char *) ap_field_noparam(ap_pool_t *p, const char *intype)
{
const char *semi;
}
}
-API_EXPORT(char *) ap_ht_time(ap_context_t *p, ap_time_t t, const char *fmt, int gmt)
+API_EXPORT(char *) ap_ht_time(ap_pool_t *p, ap_time_t t, const char *fmt, int gmt)
{
ap_size_t retcode;
char ts[MAX_STRING_LEN];
return APR_SUCCESS;
}
-API_EXPORT(regex_t *) ap_pregcomp(ap_context_t *p, const char *pattern,
+API_EXPORT(regex_t *) ap_pregcomp(ap_pool_t *p, const char *pattern,
int cflags)
{
regex_t *preg = ap_palloc(p, sizeof(regex_t));
return preg;
}
-API_EXPORT(void) ap_pregfree(ap_context_t *p, regex_t * reg)
+API_EXPORT(void) ap_pregfree(ap_pool_t *p, regex_t * reg)
{
ap_block_alarms();
regfree(reg);
* AT&T V8 regexp package.
*/
-API_EXPORT(char *) ap_pregsub(ap_context_t *p, const char *input, const char *source,
+API_EXPORT(char *) ap_pregsub(ap_pool_t *p, const char *input, const char *source,
size_t nmatch, regmatch_t pmatch[])
{
const char *src = input;
/*
* return the parent directory name including trailing / of the file s
*/
-API_EXPORT(char *) ap_make_dirstr_parent(ap_context_t *p, const char *s)
+API_EXPORT(char *) ap_make_dirstr_parent(ap_pool_t *p, const char *s)
{
char *last_slash = strrchr(s, '/');
char *d;
* This function is deprecated. Use one of the preceeding two functions
* which are faster.
*/
-API_EXPORT(char *) ap_make_dirstr(ap_context_t *p, const char *s, int n)
+API_EXPORT(char *) ap_make_dirstr(ap_pool_t *p, const char *s, int n)
{
register int x, f;
char *res;
* error... ah well. */
}
-API_EXPORT(char *) ap_getword_nc(ap_context_t *atrans, char **line, char stop)
+API_EXPORT(char *) ap_getword_nc(ap_pool_t *atrans, char **line, char stop)
{
return ap_getword(atrans, (const char **) line, stop);
}
-API_EXPORT(char *) ap_getword(ap_context_t *atrans, const char **line, char stop)
+API_EXPORT(char *) ap_getword(ap_pool_t *atrans, const char **line, char stop)
{
char *pos = strchr(*line, stop);
char *res;
return res;
}
-API_EXPORT(char *) ap_getword_white_nc(ap_context_t *atrans, char **line)
+API_EXPORT(char *) ap_getword_white_nc(ap_pool_t *atrans, char **line)
{
return ap_getword_white(atrans, (const char **) line);
}
-API_EXPORT(char *) ap_getword_white(ap_context_t *atrans, const char **line)
+API_EXPORT(char *) ap_getword_white(ap_pool_t *atrans, const char **line)
{
int pos = -1, x;
char *res;
return res;
}
-API_EXPORT(char *) ap_getword_nulls_nc(ap_context_t *atrans, char **line, char stop)
+API_EXPORT(char *) ap_getword_nulls_nc(ap_pool_t *atrans, char **line, char stop)
{
return ap_getword_nulls(atrans, (const char **) line, stop);
}
-API_EXPORT(char *) ap_getword_nulls(ap_context_t *atrans, const char **line, char stop)
+API_EXPORT(char *) ap_getword_nulls(ap_pool_t *atrans, const char **line, char stop)
{
char *pos = strchr(*line, stop);
char *res;
* all honored
*/
-static char *substring_conf(ap_context_t *p, const char *start, int len, char quote)
+static char *substring_conf(ap_pool_t *p, const char *start, int len, char quote)
{
char *result = ap_palloc(p, len + 2);
char *resp = result;
#endif
}
-API_EXPORT(char *) ap_getword_conf_nc(ap_context_t *p, char **line)
+API_EXPORT(char *) ap_getword_conf_nc(ap_pool_t *p, char **line)
{
return ap_getword_conf(p, (const char **) line);
}
-API_EXPORT(char *) ap_getword_conf(ap_context_t *p, const char **line)
+API_EXPORT(char *) ap_getword_conf(ap_pool_t *p, const char **line)
{
const char *str = *line, *strend;
char *res;
* empty string. Any unrecognized construct is not
* replaced and silently ignored.
*/
-API_EXPORT(char *) ap_resolve_env(ap_context_t *p, const char * word)
+API_EXPORT(char *) ap_resolve_env(ap_pool_t *p, const char * word)
{
char tmp[ MAX_STRING_LEN ];
char * s, * e;
}
/* Open a configfile_t as FILE, return open configfile_t struct pointer */
-API_EXPORT(ap_status_t) ap_pcfg_openfile(configfile_t **ret_cfg, ap_context_t *p, const char *name)
+API_EXPORT(ap_status_t) ap_pcfg_openfile(configfile_t **ret_cfg, ap_pool_t *p, const char *name)
{
configfile_t *new_cfg;
ap_file_t *file = NULL;
/* Allocate a configfile_t handle with user defined functions and params */
-API_EXPORT(configfile_t *) ap_pcfg_open_custom(ap_context_t *p, const char *descr,
+API_EXPORT(configfile_t *) ap_pcfg_open_custom(ap_pool_t *p, const char *descr,
void *param,
int(*getch)(void *param),
void *(*getstr) (void *buf, size_t bufsiz, void *param),
* the converted list item (or NULL if none) and the address pointed to by
* field is shifted to the next non-comma, non-whitespace.
*/
-API_EXPORT(char *) ap_get_list_item(ap_context_t *p, const char **field)
+API_EXPORT(char *) ap_get_list_item(ap_pool_t *p, const char **field)
{
const char *tok_start;
const unsigned char *ptr;
* This would be much more efficient if we stored header fields as
* an array of list items as they are received instead of a plain string.
*/
-API_EXPORT(int) ap_find_list_item(ap_context_t *p, const char *line, const char *tok)
+API_EXPORT(int) ap_find_list_item(ap_pool_t *p, const char *line, const char *tok)
{
const unsigned char *pos;
const unsigned char *ptr = (const unsigned char *)line;
* by whitespace at the caller's option.
*/
-API_EXPORT(char *) ap_get_token(ap_context_t *p, const char **accept_line, int accept_white)
+API_EXPORT(char *) ap_get_token(ap_pool_t *p, const char **accept_line, int accept_white)
{
const char *ptr = *accept_line;
const char *tok_start;
/* find http tokens, see the definition of token from RFC2068 */
-API_EXPORT(int) ap_find_token(ap_context_t *p, const char *line, const char *tok)
+API_EXPORT(int) ap_find_token(ap_pool_t *p, const char *line, const char *tok)
{
const unsigned char *start_token;
const unsigned char *s;
}
-API_EXPORT(int) ap_find_last_token(ap_context_t *p, const char *line, const char *tok)
+API_EXPORT(int) ap_find_last_token(ap_pool_t *p, const char *line, const char *tok)
{
int llen, tlen, lidx;
return (strncasecmp(&line[lidx], tok, tlen) == 0);
}
-API_EXPORT(char *) ap_escape_shell_cmd(ap_context_t *p, const char *str)
+API_EXPORT(char *) ap_escape_shell_cmd(ap_pool_t *p, const char *str)
{
char *cmd;
unsigned char *d;
return OK;
}
-API_EXPORT(char *) ap_construct_server(ap_context_t *p, const char *hostname,
+API_EXPORT(char *) ap_construct_server(ap_pool_t *p, const char *hostname,
unsigned port, const request_rec *r)
{
if (ap_is_default_port(port, r))
* something with a '/' in it (and thus does not prefix "./").
*/
-API_EXPORT(char *) ap_escape_path_segment(ap_context_t *p, const char *segment)
+API_EXPORT(char *) ap_escape_path_segment(ap_pool_t *p, const char *segment)
{
char *copy = ap_palloc(p, 3 * strlen(segment) + 1);
const unsigned char *s = (const unsigned char *)segment;
return copy;
}
-API_EXPORT(char *) ap_os_escape_path(ap_context_t *p, const char *path, int partial)
+API_EXPORT(char *) ap_os_escape_path(ap_pool_t *p, const char *path, int partial)
{
char *copy = ap_palloc(p, 3 * strlen(path) + 3);
const unsigned char *s = (const unsigned char *)path;
/* ap_escape_uri is now a macro for os_escape_path */
-API_EXPORT(char *) ap_escape_html(ap_context_t *p, const char *s)
+API_EXPORT(char *) ap_escape_html(ap_pool_t *p, const char *s)
{
int i, j;
char *x;
return (S_ISDIR(finfo.st_mode));
}
-API_EXPORT(char *) ap_make_full_path(ap_context_t *a, const char *src1,
+API_EXPORT(char *) ap_make_full_path(ap_pool_t *a, const char *src1,
const char *src2)
{
register int x;
}
-static char *find_fqdn(ap_context_t *a, struct hostent *p)
+static char *find_fqdn(ap_pool_t *a, struct hostent *p)
{
int x;
return ap_pstrdup(a, (void *) p->h_name);
}
-char *ap_get_local_host(ap_context_t *a)
+char *ap_get_local_host(ap_pool_t *a)
{
#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN 256
/* simple 'pool' alloc()ing glue to ap_base64.c
*/
-API_EXPORT(char *) ap_pbase64decode(ap_context_t *p, const char *bufcoded)
+API_EXPORT(char *) ap_pbase64decode(ap_pool_t *p, const char *bufcoded)
{
char *decoded;
int l;
return decoded;
}
-API_EXPORT(char *) ap_pbase64encode(ap_context_t *p, char *string)
+API_EXPORT(char *) ap_pbase64encode(ap_pool_t *p, char *string)
{
char *encoded;
int l = strlen(string);
/* deprecated names for the above two functions, here for compatibility
*/
-API_EXPORT(char *) ap_uudecode(ap_context_t *p, const char *bufcoded)
+API_EXPORT(char *) ap_uudecode(ap_pool_t *p, const char *bufcoded)
{
return ap_pbase64decode(p, bufcoded);
}
-API_EXPORT(char *) ap_uuencode(ap_context_t *p, char *string)
+API_EXPORT(char *) ap_uuencode(ap_pool_t *p, char *string)
{
return ap_pbase64encode(p, string);
}
/*
* Given a string, replace any bare " with \" .
*/
-API_EXPORT(char *) ap_escape_quotes (ap_context_t *p, const char *instring)
+API_EXPORT(char *) ap_escape_quotes (ap_pool_t *p, const char *instring)
{
int newlen = 0;
const char *inchr = instring;
#include "httpd.h"
#include "util_md5.h"
-API_EXPORT(char *) ap_md5_binary(ap_context_t *p, const unsigned char *buf, int length)
+API_EXPORT(char *) ap_md5_binary(ap_pool_t *p, const unsigned char *buf, int length)
{
const char *hex = "0123456789abcdef";
AP_MD5_CTX my_md5;
return ap_pstrdup(p, result);
}
-API_EXPORT(char *) ap_md5(ap_context_t *p, const unsigned char *string)
+API_EXPORT(char *) ap_md5(ap_pool_t *p, const unsigned char *string)
{
return ap_md5_binary(p, string, (int) strlen((char *)string));
}
static char basis_64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-API_EXPORT(char *) ap_md5contextTo64(ap_context_t *a, AP_MD5_CTX * context)
+API_EXPORT(char *) ap_md5contextTo64(ap_pool_t *a, AP_MD5_CTX * context)
{
unsigned char digest[18];
char *encodedDigest;
#ifdef CHARSET_EBCDIC
-API_EXPORT(char *) ap_md5digest(ap_context_t *p, ap_file_t *infile, int convert)
+API_EXPORT(char *) ap_md5digest(ap_pool_t *p, ap_file_t *infile, int convert)
{
AP_MD5_CTX context;
unsigned char buf[1000];
#else
-API_EXPORT(char *) ap_md5digest(ap_context_t *p, ap_file_t *infile)
+API_EXPORT(char *) ap_md5digest(ap_pool_t *p, ap_file_t *infile)
{
AP_MD5_CTX context;
unsigned char buf[1000];
* are handled in create_argv.
*
*/
-static char **create_argv(ap_context_t *p, char *path, char *user, char *group,
+static char **create_argv(ap_pool_t *p, char *path, char *user, char *group,
char *av0, const char *args)
{
int x, numwords;
}
#endif /* defined(OS2) || defined(WIN32) */
-static char *http2env(ap_context_t *a, char *w)
+static char *http2env(ap_pool_t *a, char *w)
{
char *res = ap_pstrcat(a, "HTTP_", w, NULL);
char *cp = res;
return res;
}
-API_EXPORT(char **) ap_create_environment(ap_context_t *p, ap_table_t *t)
+API_EXPORT(char **) ap_create_environment(ap_pool_t *p, ap_table_t *t)
{
ap_array_header_t *env_arr = ap_table_elts(t);
ap_table_entry_t *elts = (ap_table_entry_t *) env_arr->elts;
}
#if defined(OS2) || defined(WIN32)
-static char **create_argv_cmd(ap_context_t *p, char *av0, const char *args, char *path)
+static char **create_argv_cmd(ap_pool_t *p, char *av0, const char *args, char *path)
{
register int x, n;
char **av;
* from a call to gethostbyname() and lives in static storage.
* By creating a copy we can tuck it away for later use.
*/
-API_EXPORT(struct hostent *) ap_pduphostent(ap_context_t *p, const struct hostent *hp)
+API_EXPORT(struct hostent *) ap_pduphostent(ap_pool_t *p, const struct hostent *hp)
{
struct hostent *newent;
char **ptrs;
* COPY OF the hostent structure, intended to be stored and used later.
* (gethostbyname() uses static storage that would be overwritten on each call)
*/
-API_EXPORT(struct hostent *) ap_pgethostbyname(ap_context_t *p, const char *hostname)
+API_EXPORT(struct hostent *) ap_pgethostbyname(ap_pool_t *p, const char *hostname)
{
struct hostent *hp = gethostbyname(hostname);
return (hp == NULL) ? NULL : ap_pduphostent(p, hp);
/* Unparse a uri_components structure to an URI string.
* Optionally suppress the password for security reasons.
*/
-API_EXPORT(char *) ap_unparse_uri_components(ap_context_t *p, const uri_components *uptr, unsigned flags)
+API_EXPORT(char *) ap_unparse_uri_components(ap_pool_t *p, const uri_components *uptr, unsigned flags)
{
char *ret = "";
* - fills in fields of uri_components *uptr
* - none on any of the r->* fields
*/
-API_EXPORT(int) ap_parse_uri_components(ap_context_t *p, const char *uri, uri_components *uptr)
+API_EXPORT(int) ap_parse_uri_components(ap_pool_t *p, const char *uri, uri_components *uptr)
{
int ret;
regmatch_t match[10]; /* This must have at least as much elements
* - fills in fields of uri_components *uptr
* - none on any of the r->* fields
*/
-API_EXPORT(int) ap_parse_uri_components(ap_context_t *p, const char *uri, uri_components *uptr)
+API_EXPORT(int) ap_parse_uri_components(ap_pool_t *p, const char *uri, uri_components *uptr)
{
const char *s;
const char *s1;
* currently at http://www.mcom.com/newsref/std/tunneling_ssl.html
* for the format of the "CONNECT host:port HTTP/1.0" request
*/
-API_EXPORT(int) ap_parse_hostinfo_components(ap_context_t *p, const char *hostinfo, uri_components *uptr)
+API_EXPORT(int) ap_parse_hostinfo_components(ap_pool_t *p, const char *hostinfo, uri_components *uptr)
{
const char *s;
char *endstr;
/* called at the beginning of the config */
-void ap_init_vhost_config(ap_context_t *p)
+void ap_init_vhost_config(ap_pool_t *p)
{
memset(iphash_table, 0, sizeof(iphash_table));
default_list = NULL;
* *paddr is the variable used to keep track of **paddr between calls
* port is the default port to assume
*/
-static const char *get_addresses(ap_context_t *p, char *w, server_addr_rec ***paddr,
+static const char *get_addresses(ap_pool_t *p, char *w, server_addr_rec ***paddr,
unsigned port)
{
struct hostent *hep;
/* parse the <VirtualHost> addresses */
-const char *ap_parse_vhost_addrs(ap_context_t *p, const char *hostname, server_rec *s)
+const char *ap_parse_vhost_addrs(ap_pool_t *p, const char *hostname, server_rec *s)
{
server_addr_rec **addrs;
const char *err;
-static ipaddr_chain *new_ipaddr_chain(ap_context_t *p,
+static ipaddr_chain *new_ipaddr_chain(ap_pool_t *p,
server_rec *s, server_addr_rec *sar)
{
ipaddr_chain *new;
}
-static name_chain *new_name_chain(ap_context_t *p, server_rec *s, server_addr_rec *sar)
+static name_chain *new_name_chain(ap_pool_t *p, server_rec *s, server_addr_rec *sar)
{
name_chain *new;
}
/* compile the tables and such we need to do the run-time vhost lookups */
-void ap_fini_vhost_config(ap_context_t *p, server_rec *main_s)
+void ap_fini_vhost_config(ap_pool_t *p, server_rec *main_s)
{
server_addr_rec *sar;
int has_default_vhost_addr;
3. All characters encoded must have Unicode scalar values <= 0xFFFF,
(ie characters that would be encoded by surrogates in UTF-16
are not allowed). Note that this restriction doesn't apply to
-the built ap_context_t n support for UTF-8 and UTF-16.
+the built ap_pool_t n support for UTF-8 and UTF-16.
4. No Unicode character may be encoded by more than one distinct sequence
of bytes. */
int main (void)
{
- ap_context_t *p;
+ ap_pool_t *p;
char line[512];
char tok[512];
int main (void)
{
- ap_context_t *p;
+ ap_pool_t *p;
const char *field;
char *newstr;
char instr[512];
projects / thirdparty / apache / httpd.git / commitdiff
