/* post config init */
apr_status_t h2_task_init(apr_pool_t *pool, server_rec *s)
{
h2_task_logio_add_bytes_in = APR_RETRIEVE_OPTIONAL_FN(ap_logio_add_bytes_in);
h2_task_logio_add_bytes_out = APR_RETRIEVE_OPTIONAL_FN(ap_logio_add_bytes_out);
return APR_SUCCESS;
}
/**
* Initialise the database.
*
* If the mod_dbd module is missing, this method will return APR_EGENERAL.
*/
static apr_status_t dbd_init(request_rec *r, const char *query, ap_dbd_t **dbdp,
apr_dbd_prepared_t **statementp)
{
ap_dbd_t *dbd;
apr_dbd_prepared_t *statement;
if (!session_dbd_prepare_fn || !session_dbd_acquire_fn) {
session_dbd_prepare_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_prepare);
session_dbd_acquire_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_acquire);
if (!session_dbd_prepare_fn || !session_dbd_acquire_fn) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01850)
"You must load mod_dbd to enable AuthDBD functions");
return APR_EGENERAL;
}
}
dbd = session_dbd_acquire_fn(r);
if (!dbd) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01851)
"failed to acquire database connection");
return APR_EGENERAL;
}
statement = apr_hash_get(dbd->prepared, query, APR_HASH_KEY_STRING);
if (!statement) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01852)
"failed to find the prepared statement called '%s'", query);
return APR_EGENERAL;
}
*dbdp = dbd;
*statementp = statement;
return APR_SUCCESS;
}
static const char *set_rotated_logs(cmd_parms *cmd, void *dummy, int flag) {
log_options *ls = ap_get_module_config(cmd->server->module_config, &log_rotate_module);
if (flag) {
/* Always hook the writer functions when we're enabled even if we've
* done it already. We can't unhook which means that once we've been
* enabled we become responsible for all transfer log output. Note that
* a subsequent BufferedLogs On in conf will clobber these hooks and
* disable us.
*/
APR_OPTIONAL_FN_TYPE(ap_log_set_writer_init) *set_writer_init;
APR_OPTIONAL_FN_TYPE(ap_log_set_writer) *set_writer;
set_writer_init = APR_RETRIEVE_OPTIONAL_FN(ap_log_set_writer_init);
set_writer = APR_RETRIEVE_OPTIONAL_FN(ap_log_set_writer);
if (NULL != set_writer_init && NULL != set_writer) {
set_writer_init(ap_rotated_log_writer_init);
set_writer(ap_rotated_log_writer);
ls->enabled = 1;
} else {
ap_log_error(APLOG_MARK, APLOG_ERR, APR_SUCCESS, cmd->server,
"can't install log rotator - ap_log_set_writer not available");
ls->enabled = 0;
}
}
else
{
ls->enabled = 0;
}
return NULL;
}
apr_status_t oidc_session_init() {
if (!ap_session_load_fn || !ap_session_get_fn || !ap_session_set_fn || !ap_session_save_fn) {
ap_session_load_fn = APR_RETRIEVE_OPTIONAL_FN(ap_session_load);
ap_session_get_fn = APR_RETRIEVE_OPTIONAL_FN(ap_session_get);
ap_session_set_fn = APR_RETRIEVE_OPTIONAL_FN(ap_session_set);
ap_session_save_fn = APR_RETRIEVE_OPTIONAL_FN(ap_session_save);
}
return OK;
}
apr_status_t ml_retrieve_option_functions (apr_pool_t *p)
{
ap_session_get = APR_RETRIEVE_OPTIONAL_FN(ap_session_get);
ap_session_set = APR_RETRIEVE_OPTIONAL_FN(ap_session_set);
ap_session_load = APR_RETRIEVE_OPTIONAL_FN(ap_session_load);
ap_session_save = APR_RETRIEVE_OPTIONAL_FN(ap_session_save);
return APR_SUCCESS;
}
static void
optional_fn_retrieve(void)
{
ssl_is_https = APR_RETRIEVE_OPTIONAL_FN(ssl_is_https);
ssl_var_lookup = APR_RETRIEVE_OPTIONAL_FN(ssl_var_lookup);
ssl_keying_material = APR_RETRIEVE_OPTIONAL_FN(ssl_export_keying_material);
/*
ssl_renegotiation = APR_RETRIEVE_OPTIONAL_FN(ssl_renegotiation);
modssl_register_npn = APR_RETRIEVE_OPTIONAL_FN(modssl_register_npn);
*/
}
static const
char *cmd_spread_logs(cmd_parms *cmd, void *dummy, int flag)
{
log_spread2_options *opt = ap_get_module_config(cmd->server->module_config, &log_spread2_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err) {
return err;
}
APR_OPTIONAL_FN_TYPE(ap_log_set_writer_init) *set_writer_init;
APR_OPTIONAL_FN_TYPE(ap_log_set_writer) *set_writer;
set_writer_init = APR_RETRIEVE_OPTIONAL_FN(ap_log_set_writer_init);
set_writer = APR_RETRIEVE_OPTIONAL_FN(ap_log_set_writer);
if (set_writer_init == NULL || set_writer == NULL) {
return MNAME ": can't install log writer - ap_log_set_writer not available";
}
SP_disconnect(opt->mbox);
opt->enabled = 0;
if (flag) {
apr_status_t rv = SP_connect(opt->name, 0, 0, 0, &opt->mbox, opt->priv);
if (rv != ACCEPT_SESSION) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, cmd->server,
MNAME ": could not open connection to daemon.");
return NULL;
}
opt->old_writer_init = set_writer_init(ap_spread_log_writer_init);
opt->old_writer = set_writer(ap_spread_log_writer);
opt->enabled = 1;
} else {
if (opt->old_writer_init) {
set_writer_init(opt->old_writer_init);
opt->old_writer_init = NULL;
}
if (opt->old_writer) {
set_writer(opt->old_writer);
opt->old_writer = NULL;
}
}
return NULL;
}
static void rpaf_register_hooks(apr_pool_t *p) {
ap_hook_post_read_request(rpaf_post_read_request, NULL, NULL, APR_HOOK_FIRST);
/* this will only work if mod_ssl is not loaded */
if (APR_RETRIEVE_OPTIONAL_FN(ssl_is_https) == NULL)
APR_REGISTER_OPTIONAL_FN(ssl_is_https);
}
/*
=============================================================================
db:close(): Closes an open database connection.
=============================================================================
*/
int lua_db_close(lua_State *L)
{
/*~~~~~~~~~~~~~~~~~~~~*/
lua_db_handle *db;
apr_status_t rc = 0;
/*~~~~~~~~~~~~~~~~~~~~*/
db = lua_get_db_handle(L);
if (db && db->alive) {
if (db->type == LUA_DBTYPE_APR_DBD) {
rc = apr_dbd_close(db->driver, db->handle);
if (db->pool) apr_pool_destroy(db->pool);
}
else {
lua_ap_dbd_close = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_close);
if (lua_ap_dbd_close != NULL)
if (db->dbdhandle) lua_ap_dbd_close(db->server, db->dbdhandle);
}
db->driver = NULL;
db->handle = NULL;
db->alive = 0;
db->pool = NULL;
}
lua_settop(L, 0);
lua_pushnumber(L, rc);
return 1;
}
// Get the full URI of the request_rec's request location
// clean_params specifies whether or not all openid.* and modauthopenid.* params should be cleared
static void full_uri(request_rec *r, std::string& result, modauthopenid_config *s_cfg, bool clean_params=false) {
std::string hostname(r->hostname);
std::string uri(r->uri);
apr_port_t i_port = ap_get_server_port(r);
// Fetch the APR function for determining if we are looking at an https URL
APR_OPTIONAL_FN_TYPE(ssl_is_https) *using_https = APR_RETRIEVE_OPTIONAL_FN(ssl_is_https);
std::string prefix = (using_https != NULL && using_https(r->connection)) ? "https://" : "http://";
char *port = apr_psprintf(r->pool, "%lu", (unsigned long) i_port);
std::string s_port = (i_port == 80 || i_port == 443) ? "" : ":" + std::string(port);
std::string args;
if(clean_params) {
opkele::params_t params;
if(r->args != NULL) params = modauthopenid::parse_query_string(std::string(r->args));
modauthopenid::remove_openid_vars(params);
args = params.append_query("", "");
} else {
args = (r->args == NULL) ? "" : "?" + std::string(r->args);
}
if(s_cfg->server_name == NULL)
result = prefix + hostname + s_port + uri + args;
else
result = std::string(s_cfg->server_name) + uri + args;
}
/*
=============================================================================
db:__gc(): Garbage collecting function.
=============================================================================
*/
int lua_db_gc(lua_State *L)
{
/*~~~~~~~~~~~~~~~~*/
lua_db_handle *db;
/*~~~~~~~~~~~~~~~~~~~~*/
db = lua_touserdata(L, 1);
if (db && db->alive) {
if (db->type == LUA_DBTYPE_APR_DBD) {
apr_dbd_close(db->driver, db->handle);
if (db->pool) apr_pool_destroy(db->pool);
}
else {
lua_ap_dbd_close = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_close);
if (lua_ap_dbd_close != NULL)
if (db->dbdhandle) lua_ap_dbd_close(db->server, db->dbdhandle);
}
db->driver = NULL;
db->handle = NULL;
db->alive = 0;
db->pool = NULL;
}
lua_settop(L, 0);
return 0;
}
/*******************************************************************************
* Once per lifetime init, retrieve optional functions
*/
apr_status_t h2_h2_init(apr_pool_t *pool, server_rec *s)
{
(void)pool;
ap_log_error(APLOG_MARK, APLOG_TRACE1, 0, s, "h2_h2, child_init");
opt_ssl_engine_disable = APR_RETRIEVE_OPTIONAL_FN(ssl_engine_disable);
opt_ssl_is_https = APR_RETRIEVE_OPTIONAL_FN(ssl_is_https);
opt_ssl_var_lookup = APR_RETRIEVE_OPTIONAL_FN(ssl_var_lookup);
if (!opt_ssl_is_https || !opt_ssl_var_lookup) {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
APLOGNO(02951) "mod_ssl does not seem to be enabled");
}
cipher_init(pool);
return APR_SUCCESS;
}
static int log_fluentd_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp)
{
static APR_OPTIONAL_FN_TYPE(ap_log_set_writer_init) *log_set_writer_init_fn = NULL;
static APR_OPTIONAL_FN_TYPE(ap_log_set_writer) *log_set_writer_fn = NULL;
log_set_writer_init_fn = APR_RETRIEVE_OPTIONAL_FN(ap_log_set_writer_init);
log_set_writer_fn = APR_RETRIEVE_OPTIONAL_FN(ap_log_set_writer);
if (log_set_writer_init_fn && log_set_writer_fn) {
if (!normal_log_writer_init) {
module *mod_log_config = ap_find_linked_module("mod_log_config.c");
normal_log_writer_init = log_set_writer_init_fn(log_fluentd_writer_init);
normal_log_writer = log_set_writer_fn(log_fluentd_writer);
}
}
return OK;
}
apr_status_t h2_h2_init(apr_pool_t *pool, server_rec *s)
{
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, "h2_h2, child_init");
opt_ssl_engine_disable = APR_RETRIEVE_OPTIONAL_FN(ssl_engine_disable);
opt_ssl_is_https = APR_RETRIEVE_OPTIONAL_FN(ssl_is_https);
opt_ssl_var_lookup = APR_RETRIEVE_OPTIONAL_FN(ssl_var_lookup);
opt_ssl_register_npn = APR_RETRIEVE_OPTIONAL_FN(modssl_register_npn);
opt_ssl_register_alpn = APR_RETRIEVE_OPTIONAL_FN(modssl_register_alpn);
if (!opt_ssl_is_https) {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
"mod_ssl does not seem to be enabled");
}
else if (!opt_ssl_register_alpn && !opt_ssl_register_npn) {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
"mod_ssl does not offer ALPN or NPN registration");
}
return APR_SUCCESS;
}
static int mag_post_config(apr_pool_t *cfgpool, apr_pool_t *log,
apr_pool_t *temp, server_rec *s)
{
/* FIXME: create mutex to deal with connections and contexts ? */
mag_is_https = APR_RETRIEVE_OPTIONAL_FN(ssl_is_https);
mag_post_config_session();
ap_add_version_component(cfgpool, MOD_AUTH_GSSAPI_VERSION);
return OK;
}
static const char *authn_dbd_prepare(cmd_parms *cmd, void *cfg, const char *query)
{
static unsigned int label_num = 0;
char *label;
if (authn_dbd_prepare_fn == NULL) {
authn_dbd_prepare_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_prepare);
if (authn_dbd_prepare_fn == NULL) {
return "You must load mod_dbd to enable AuthDBD functions";
}
authn_dbd_acquire_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_acquire);
}
label = apr_psprintf(cmd->pool, "authn_dbd_%d", ++label_num);
authn_dbd_prepare_fn(cmd->server, query, label);
/* save the label here for our own use */
return ap_set_string_slot(cmd, cfg, label);
}
static int log_millisecond_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp)
{
static APR_OPTIONAL_FN_TYPE(ap_register_log_handler) *log_register;
log_register = APR_RETRIEVE_OPTIONAL_FN(ap_register_log_handler);
if (!log_register)
return DECLINED;
log_register(p, "M", log_request_duration_milliseconds, 1);
return OK;
}
static int asn_post_config(apr_pool_t *pconf, apr_pool_t *plog,
apr_pool_t *ptemp, server_rec *s)
{
apr_version(&vsn);
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, s,
"[mod_asn] compiled with APR/APR-Util %s/%s",
APR_VERSION_STRING, APU_VERSION_STRING);
if ((vsn.major == 1) && (vsn.minor == 2)) {
dbd_first_row = 0;
} else {
dbd_first_row = 1;
}
ap_add_version_component(pconf, VERSION_COMPONENT);
/* make sure that mod_dbd is loaded */
if (asn_dbd_prepare_fn == NULL) {
asn_dbd_prepare_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_prepare);
if (asn_dbd_prepare_fn == NULL) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
"[mod_asn] You must load mod_dbd to enable mod_asn to work");
return HTTP_INTERNAL_SERVER_ERROR;
}
asn_dbd_open_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_open);
asn_dbd_close_fn = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_close);
}
/* prepare DBD SQL statements */
static unsigned int label_num = 0;
server_rec *sp;
for (sp = s; sp; sp = sp->next) {
asn_server_conf *cfg = ap_get_module_config(sp->module_config,
&asn_module);
/* make a label */
cfg->query_prep = apr_psprintf(pconf, "asn_dbd_%d", ++label_num);
asn_dbd_prepare_fn(sp, cfg->query, cfg->query_prep);
}
return OK;
}
static int firstbyte_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp)
{
static APR_OPTIONAL_FN_TYPE(ap_register_log_handler) *log_pfn_register;
log_pfn_register = APR_RETRIEVE_OPTIONAL_FN(ap_register_log_handler);
if (log_pfn_register) {
log_pfn_register(p, "F", log_firstbyte_time, 0);
}
return OK;
}
static void ImportULDAPOptFn(void)
{
util_ldap_connection_close = APR_RETRIEVE_OPTIONAL_FN(uldap_connection_close);
util_ldap_connection_find = APR_RETRIEVE_OPTIONAL_FN(uldap_connection_find);
util_ldap_cache_comparedn = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_comparedn);
util_ldap_cache_compare = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_compare);
util_ldap_cache_checkuserid = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_checkuserid);
util_ldap_cache_getuserdn = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_getuserdn);
util_ldap_ssl_supported = APR_RETRIEVE_OPTIONAL_FN(uldap_ssl_supported);
}
static void register_hooks(apr_pool_t *p)
{
authz_owner_get_file_group = APR_RETRIEVE_OPTIONAL_FN(authz_owner_get_file_group);
ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "dbm-group",
AUTHZ_PROVIDER_VERSION,
&authz_dbmgroup_provider,
AP_AUTH_INTERNAL_PER_CONF);
ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "dbm-file-group",
AUTHZ_PROVIDER_VERSION,
&authz_dbmfilegroup_provider,
AP_AUTH_INTERNAL_PER_CONF);
}
AP_DECLARE(int) ap_calc_scoreboard_size(void)
{
ap_mpm_query(AP_MPMQ_HARD_LIMIT_THREADS, &thread_limit);
ap_mpm_query(AP_MPMQ_HARD_LIMIT_DAEMONS, &server_limit);
scoreboard_size = sizeof(global_score);
scoreboard_size += sizeof(process_score) * server_limit;
scoreboard_size += sizeof(worker_score) * server_limit * thread_limit;
pfn_ap_logio_get_last_bytes = APR_RETRIEVE_OPTIONAL_FN(ap_logio_get_last_bytes);
return scoreboard_size;
}
static int logio_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp)
{
static APR_OPTIONAL_FN_TYPE(ap_register_log_handler) *log_pfn_register;
log_pfn_register = APR_RETRIEVE_OPTIONAL_FN(ap_register_log_handler);
if (log_pfn_register) {
log_pfn_register(p, "I", log_bytes_in, 0);
log_pfn_register(p, "O", log_bytes_out, 0);
log_pfn_register(p, "S", log_bytes_combined, 0);
}
return OK;
}
static const char *authz_dbd_prepare(cmd_parms *cmd, void *cfg,
const char *query)
{
static unsigned int label_num = 0;
char *label;
const char *err = ap_check_cmd_context(cmd, NOT_IN_HTACCESS);
if (err)
return err;
if (dbd_prepare == NULL) {
dbd_prepare = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_prepare);
if (dbd_prepare == NULL) {
return "You must load mod_dbd to enable AuthzDBD functions";
}
dbd_handle = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_acquire);
}
label = apr_psprintf(cmd->pool, "authz_dbd_%d", ++label_num);
dbd_prepare(cmd->server, query, label);
/* save the label here for our own use */
return ap_set_string_slot(cmd, cfg, label);
}
static void authz_unixgroup_register_hooks(apr_pool_t *p)
{
/* Get a handle on mod_authz_owner */
authz_owner_get_file_group = APR_RETRIEVE_OPTIONAL_FN(authz_owner_get_file_group);
/* Register authz providers */
ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "unix-group",
AUTHZ_PROVIDER_VERSION,
&authz_unixgroup_provider, AP_AUTH_INTERNAL_PER_CONF);
ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "unix-file-group",
AUTHZ_PROVIDER_VERSION,
&authz_unixfilegroup_provider, AP_AUTH_INTERNAL_PER_CONF);
}
static int
prefork_post_config(apr_pool_t *p, apr_pool_t *plog,
apr_pool_t *dummy, server_rec *ptemp)
{
g_start_time = time(0);
ap_add_version_component(p, VERSION);
g_ssl_lookup = APR_RETRIEVE_OPTIONAL_FN(ssl_var_lookup);
apr_thread_mutex_create(&g_lock_lock, APR_THREAD_MUTEX_DEFAULT, p);
return OK;
}
static int cgi_post_config(apr_pool_t *p, apr_pool_t *plog,
apr_pool_t *ptemp, server_rec *s)
{
cgi_pfn_reg_with_ssi = APR_RETRIEVE_OPTIONAL_FN(ap_register_include_handler);
cgi_pfn_gtv = APR_RETRIEVE_OPTIONAL_FN(ap_ssi_get_tag_and_value);
cgi_pfn_ps = APR_RETRIEVE_OPTIONAL_FN(ap_ssi_parse_string);
if ((cgi_pfn_reg_with_ssi) && (cgi_pfn_gtv) && (cgi_pfn_ps)) {
/* Required by mod_include filter. This is how mod_cgi registers
* with mod_include to provide processing of the exec directive.
*/
cgi_pfn_reg_with_ssi("exec", handle_exec);
}
/* This is the means by which unusual (non-unix) os's may find alternate
* means to run a given command (e.g. shebang/registry parsing on Win32)
*/
cgi_build_command = APR_RETRIEVE_OPTIONAL_FN(ap_cgi_build_command);
if (!cgi_build_command) {
cgi_build_command = default_build_command;
}
return OK;
}
/* Create or reinit an existing scoreboard. The MPM can control whether
* the scoreboard is shared across multiple processes or not
*/
int ap_create_scoreboard(apr_pool_t *p, ap_scoreboard_e sb_type)
{
int i;
#if APR_HAS_SHARED_MEMORY
apr_status_t rv;
#endif
pfn_ap_logio_get_last_bytes = APR_RETRIEVE_OPTIONAL_FN(ap_logio_get_last_bytes);
if (ap_scoreboard_image) {
ap_scoreboard_image->global->restart_time = apr_time_now();
memset(ap_scoreboard_image->parent, 0,
sizeof(process_score) * server_limit);
for (i = 0; i < server_limit; i++) {
memset(ap_scoreboard_image->servers[i], 0,
sizeof(worker_score) * thread_limit);
}
return OK;
}
ap_calc_scoreboard_size();
#if APR_HAS_SHARED_MEMORY
if (sb_type == SB_SHARED) {
void *sb_shared;
rv = open_scoreboard(p);
if (rv || !(sb_shared = apr_shm_baseaddr_get(ap_scoreboard_shm))) {
return HTTP_INTERNAL_SERVER_ERROR;
}
memset(sb_shared, 0, scoreboard_size);
ap_init_scoreboard(sb_shared);
}
else
#endif
{
/* A simple malloc will suffice */
void *sb_mem = ap_calloc(1, scoreboard_size);
ap_init_scoreboard(sb_mem);
}
scoreboard_type = sb_type;
ap_scoreboard_image->global->running_generation = 0;
ap_scoreboard_image->global->restart_time = apr_time_now();
apr_pool_cleanup_register(p, NULL, ap_cleanup_scoreboard, apr_pool_cleanup_null);
return OK;
}
static int log_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp)
{
static APR_OPTIONAL_FN_TYPE(ap_register_log_handler) *log_pfn_register;
log_pfn_register = APR_RETRIEVE_OPTIONAL_FN(ap_register_log_handler);
if (log_pfn_register) {
log_pfn_register(p, "h", log_remote_host, 0);
log_pfn_register(p, "a", log_remote_address, 0 );
log_pfn_register(p, "A", log_local_address, 0 );
log_pfn_register(p, "l", log_remote_logname, 0);
log_pfn_register(p, "u", log_remote_user, 0);
log_pfn_register(p, "t", log_request_time, 0);
log_pfn_register(p, "f", log_request_file, 0);
log_pfn_register(p, "b", clf_log_bytes_sent, 0);
log_pfn_register(p, "B", log_bytes_sent, 0);
log_pfn_register(p, "i", log_header_in, 0);
log_pfn_register(p, "o", log_header_out, 0);
log_pfn_register(p, "n", log_note, 0);
log_pfn_register(p, "e", log_env_var, 0);
log_pfn_register(p, "V", log_server_name, 0);
log_pfn_register(p, "v", log_virtual_host, 0);
log_pfn_register(p, "p", log_server_port, 0);
log_pfn_register(p, "P", log_pid_tid, 0);
log_pfn_register(p, "H", log_request_protocol, 0);
log_pfn_register(p, "m", log_request_method, 0);
log_pfn_register(p, "q", log_request_query, 0);
log_pfn_register(p, "X", log_connection_status, 0);
log_pfn_register(p, "C", log_cookie, 0);
log_pfn_register(p, "k", log_requests_on_connection, 0);
log_pfn_register(p, "r", log_request_line, 1);
log_pfn_register(p, "D", log_request_duration_microseconds, 1);
log_pfn_register(p, "T", log_request_duration, 1);
log_pfn_register(p, "U", log_request_uri, 1);
log_pfn_register(p, "s", log_status, 1);
log_pfn_register(p, "R", log_handler, 1);
}
/* reset to default conditions */
ap_log_set_writer_init(ap_default_log_writer_init);
ap_log_set_writer(ap_default_log_writer);
buffered_logs = 0;
return OK;
}
AP_DECLARE(int) ap_calc_scoreboard_size(void)
{
ap_mpm_query(AP_MPMQ_HARD_LIMIT_THREADS, &thread_limit);
ap_mpm_query(AP_MPMQ_HARD_LIMIT_DAEMONS, &server_limit);
if (!proxy_lb_workers)
proxy_lb_workers = APR_RETRIEVE_OPTIONAL_FN(ap_proxy_lb_workers);
if (proxy_lb_workers)
lb_limit = proxy_lb_workers();
else
lb_limit = 0;
scoreboard_size = sizeof(global_score);
scoreboard_size += sizeof(process_score) * server_limit;
scoreboard_size += sizeof(worker_score) * server_limit * thread_limit;
if (lb_limit)
scoreboard_size += sizeof(lb_score) * lb_limit;
return scoreboard_size;
}
