/* 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; }