/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ap_config.h"
#include "ap_mmn.h"
#include "apr_strings.h"
#include "apr_hash.h"
#include "apr_lib.h"
#include "apr_tables.h"
#include "apr_version.h"
#include "http_main.h"
#include "httpd.h"
#include "http_config.h"
#include "fcgid_global.h"
#include "fcgid_conf.h"
#ifndef DEFAULT_REL_RUNTIMEDIR /* Win32, etc. */
#define DEFAULT_REL_RUNTIMEDIR "logs"
#endif
#define DEFAULT_IDLE_TIMEOUT 300
#define DEFAULT_IDLE_SCAN_INTERVAL 120
#define DEFAULT_BUSY_TIMEOUT 300
#define DEFAULT_BUSY_SCAN_INTERVAL 120
#define DEFAULT_ERROR_SCAN_INTERVAL 3
#define DEFAULT_ZOMBIE_SCAN_INTERVAL 3
#define DEFAULT_PROC_LIFETIME (60*60)
#define DEFAULT_SOCKET_PREFIX DEFAULT_REL_RUNTIMEDIR "/fcgidsock"
#define DEFAULT_SHM_PATH DEFAULT_REL_RUNTIMEDIR "/fcgid_shm"
#define DEFAULT_SPAWNSOCRE_UPLIMIT 10
#define DEFAULT_SPAWN_SCORE 1
#define DEFAULT_TERMINATION_SCORE 2
#define DEFAULT_TIME_SCORE 1
#define DEFAULT_MAX_PROCESS_COUNT 1000
#define DEFAULT_MAX_CLASS_PROCESS_COUNT 100
#define DEFAULT_MIN_CLASS_PROCESS_COUNT 3
#define DEFAULT_IPC_CONNECT_TIMEOUT 3
#define DEFAULT_IPC_COMM_TIMEOUT 40
#define DEFAULT_OUTPUT_BUFFERSIZE 65536
#define DEFAULT_MAX_REQUESTS_PER_PROCESS 0
/* by default, allow spooling of request bodies up to
* 128k (first 64k in memory)
*/
#define DEFAULT_MAX_REQUEST_LEN (1024*128)
#define DEFAULT_MAX_MEM_REQUEST_LEN (1024*64)
#define DEFAULT_WRAPPER_KEY "ALL"
#define WRAPPER_FLAG_VIRTUAL "virtual"
void *create_fcgid_server_config(apr_pool_t * p, server_rec * s)
{
fcgid_server_conf *config = apr_pcalloc(p, sizeof(*config));
static int vhost_id = 0;
/* allow vhost comparison even when some mass-vhost module
* makes a copy of the server_rec to override docroot or
* other such settings
*/
++vhost_id;
config->vhost_id = vhost_id;
if (!s->is_virtual) {
config->busy_scan_interval = DEFAULT_BUSY_SCAN_INTERVAL;
config->error_scan_interval = DEFAULT_ERROR_SCAN_INTERVAL;
config->idle_scan_interval = DEFAULT_IDLE_SCAN_INTERVAL;
config->max_process_count = DEFAULT_MAX_PROCESS_COUNT;
config->shmname_path = ap_server_root_relative(p, DEFAULT_SHM_PATH);
config->sockname_prefix =
ap_server_root_relative(p, DEFAULT_SOCKET_PREFIX);
config->spawn_score = DEFAULT_SPAWN_SCORE;
config->spawnscore_uplimit = DEFAULT_SPAWNSOCRE_UPLIMIT;
config->termination_score = DEFAULT_TERMINATION_SCORE;
config->time_score = DEFAULT_TIME_SCORE;
config->zombie_scan_interval = DEFAULT_ZOMBIE_SCAN_INTERVAL;
}
/* Redundant; pcalloc creates this structure;
* config->default_init_env = NULL;
* config->pass_headers = NULL;
* config->php_fix_pathinfo_enable = 0;
* config->*_set = 0;
*/
config->cmdopts_hash = apr_hash_make(p);
config->ipc_comm_timeout = DEFAULT_IPC_COMM_TIMEOUT;
config->ipc_connect_timeout = DEFAULT_IPC_CONNECT_TIMEOUT;
config->max_mem_request_len = DEFAULT_MAX_MEM_REQUEST_LEN;
config->max_request_len = DEFAULT_MAX_REQUEST_LEN;
config->max_requests_per_process = DEFAULT_MAX_REQUESTS_PER_PROCESS;
config->output_buffersize = DEFAULT_OUTPUT_BUFFERSIZE;
config->max_class_process_count = DEFAULT_MAX_CLASS_PROCESS_COUNT;
config->min_class_process_count = DEFAULT_MIN_CLASS_PROCESS_COUNT;
config->busy_timeout = DEFAULT_BUSY_TIMEOUT;
config->idle_timeout = DEFAULT_IDLE_TIMEOUT;
config->proc_lifetime = DEFAULT_PROC_LIFETIME;
return config;
}
#define MERGE_SCALAR(base, local, merged, field) \
if (!(local)->field##_set) { \
merged->field = base->field; \
}
void *merge_fcgid_server_config(apr_pool_t * p, void *basev, void *locv)
{
fcgid_server_conf *base = (fcgid_server_conf *) basev;
fcgid_server_conf *local = (fcgid_server_conf *) locv;
fcgid_server_conf *merged =
(fcgid_server_conf *) apr_pmemdup(p, local, sizeof(fcgid_server_conf));
merged->cmdopts_hash = apr_hash_overlay(p, local->cmdopts_hash,
base->cmdopts_hash);
/* Merge environment variables */
if (base->default_init_env == NULL) {
/* merged already set to local */
}
else if (local->default_init_env == NULL) {
merged->default_init_env = base->default_init_env;
}
else {
merged->default_init_env =
apr_table_copy(p, base->default_init_env);
apr_table_overlap(merged->default_init_env,
local->default_init_env,
APR_OVERLAP_TABLES_SET);
}
/* Merge pass headers */
if (base->pass_headers == NULL) {
/* merged already set to local */
}
else if (local->pass_headers == NULL) {
merged->pass_headers = base->pass_headers;
}
else {
merged->pass_headers =
apr_array_append(p,
base->pass_headers,
local->pass_headers);
}
/* Merge the scalar settings */
MERGE_SCALAR(base, local, merged, ipc_comm_timeout);
MERGE_SCALAR(base, local, merged, ipc_connect_timeout);
MERGE_SCALAR(base, local, merged, max_mem_request_len);
MERGE_SCALAR(base, local, merged, max_request_len);
MERGE_SCALAR(base, local, merged, max_requests_per_process);
MERGE_SCALAR(base, local, merged, output_buffersize);
MERGE_SCALAR(base, local, merged, max_class_process_count);
MERGE_SCALAR(base, local, merged, min_class_process_count);
MERGE_SCALAR(base, local, merged, busy_timeout);
MERGE_SCALAR(base, local, merged, idle_timeout);
MERGE_SCALAR(base, local, merged, proc_lifetime);
return merged;
}
void *create_fcgid_dir_config(apr_pool_t * p, char *dummy)
{
fcgid_dir_conf *config = apr_pcalloc(p, sizeof(fcgid_dir_conf));
config->wrapper_info_hash = apr_hash_make(p);
/* config->authenticator_info = NULL; */
config->authenticator_authoritative = 1;
/* config->authorizer_info = NULL; */
config->authorizer_authoritative = 1;
/* config->access_info = NULL; */
config->access_authoritative = 1;
return (void *) config;
}
void *merge_fcgid_dir_config(apr_pool_t *p, void *basev, void *locv)
{
fcgid_dir_conf *base = (fcgid_dir_conf *) basev;
fcgid_dir_conf *local = (fcgid_dir_conf *) locv;
fcgid_dir_conf *merged =
(fcgid_dir_conf *) apr_pmemdup(p, local, sizeof(fcgid_dir_conf));
merged->wrapper_info_hash =
apr_hash_overlay(p, local->wrapper_info_hash,
base->wrapper_info_hash);
if (!local->authenticator_info) {
merged->authenticator_info = base->authenticator_info;
}
if (!local->authorizer_info) {
merged->authorizer_info = base->authorizer_info;
}
if (!local->access_info) {
merged->access_info = base->access_info;
}
MERGE_SCALAR(base, local, merged, authenticator_authoritative);
MERGE_SCALAR(base, local, merged, authorizer_authoritative);
MERGE_SCALAR(base, local, merged, access_authoritative);
return merged;
}
const char *set_idle_timeout(cmd_parms * cmd, void *dummy, const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
config->idle_timeout = atol(arg);
config->idle_timeout_set = 1;
return NULL;
}
const char *set_idle_scan_interval(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->idle_scan_interval = atol(arg);
return NULL;
}
const char *set_busy_timeout(cmd_parms * cmd, void *dummy, const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
config->busy_timeout = atol(arg);
config->busy_timeout_set = 1;
return NULL;
}
const char *set_busy_scan_interval(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->busy_scan_interval = atol(arg);
return NULL;
}
const char *set_proc_lifetime(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
config->proc_lifetime = atol(arg);
config->proc_lifetime_set = 1;
return NULL;
}
const char *set_error_scan_interval(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->error_scan_interval = atol(arg);
return NULL;
}
const char *set_zombie_scan_interval(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->zombie_scan_interval = atol(arg);
return NULL;
}
const char *set_socketpath(cmd_parms * cmd, void *dummy, const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->sockname_prefix = ap_server_root_relative(cmd->pool, arg);
if (!config->sockname_prefix)
return "Invalid socket path";
return NULL;
}
const char *set_shmpath(cmd_parms * cmd, void *dummy, const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->shmname_path = ap_server_root_relative(cmd->pool, arg);
if (!config->shmname_path)
return "Invalid shmname path";
return NULL;
}
const char *set_spawnscore_uplimit(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->spawnscore_uplimit = atol(arg);
return NULL;
}
static int strtoff(apr_off_t *val, const char *arg)
{
char *errp;
#if APR_MAJOR_VERSION < 1
*val = (apr_off_t)strtol(arg, &errp, 10);
if (*errp) {
return 1;
}
#else
if (APR_SUCCESS != apr_strtoff(val, arg, &errp, 10) || *errp) {
return 1;
}
#endif
return 0;
}
const char *set_max_request_len(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
if (strtoff(&config->max_request_len, arg)
|| config->max_request_len < 0) {
return "FcgidMaxRequestLen requires a non-negative integer.";
}
config->max_request_len_set = 1;
return NULL;
}
const char *set_max_mem_request_len(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
config->max_mem_request_len = atol(arg);
config->max_mem_request_len_set = 1;
return NULL;
}
const char *set_spawn_score(cmd_parms * cmd, void *dummy, const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->spawn_score = atol(arg);
return NULL;
}
const char *set_time_score(cmd_parms * cmd, void *dummy, const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->time_score = atol(arg);
return NULL;
}
const char *set_termination_score(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->termination_score = atol(arg);
return NULL;
}
const char *set_max_process(cmd_parms * cmd, void *dummy, const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->max_process_count = atol(arg);
return NULL;
}
const char *set_output_buffersize(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
config->output_buffersize = atol(arg);
config->output_buffersize_set = 1;
return NULL;
}
const char *set_max_class_process(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
config->max_class_process_count = atol(arg);
config->max_class_process_count_set = 1;
return NULL;
}
const char *set_min_class_process(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
config->min_class_process_count = atol(arg);
config->min_class_process_count_set = 1;
return NULL;
}
const char *set_php_fix_pathinfo_enable(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
if (err != NULL) {
return err;
}
config->php_fix_pathinfo_enable = atol(arg);
return NULL;
}
const char *set_max_requests_per_process(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
if ((config->max_requests_per_process = atol(arg)) == -1) {
config->max_requests_per_process = 0;
}
config->max_requests_per_process_set = 1;
return NULL;
}
const char *set_ipc_connect_timeout(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
config->ipc_connect_timeout = atol(arg);
config->ipc_connect_timeout_set = 1;
return NULL;
}
const char *set_ipc_comm_timeout(cmd_parms * cmd, void *dummy,
const char *arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config =
ap_get_module_config(s->module_config, &fcgid_module);
config->ipc_comm_timeout = atol(arg);
if (config->ipc_comm_timeout <= 0) {
return "FcgidIOTimeout must be greater than 0";
}
config->ipc_comm_timeout_set = 1;
return NULL;
}
static void add_envvar_to_table(apr_table_t *t, apr_pool_t *p,
const char *name, const char *value)
{
#if defined(WIN32) || defined(OS2) || defined(NETWARE)
/* Case insensitive environment platforms */
char *pstr;
for (name = pstr = apr_pstrdup(p, name); *pstr; ++pstr) {
*pstr = apr_toupper(*pstr);
}
#endif
apr_table_set(t, name, value ? value : "");
}
const char *add_default_env_vars(cmd_parms * cmd, void *dummy,
const char *name, const char *value)
{
fcgid_server_conf *config =
ap_get_module_config(cmd->server->module_config, &fcgid_module);
if (config->default_init_env == NULL)
config->default_init_env = apr_table_make(cmd->pool, 20);
add_envvar_to_table(config->default_init_env, cmd->pool, name, value);
return NULL;
}
const char *add_pass_headers(cmd_parms * cmd, void *dummy,
const char *names)
{
const char **header;
fcgid_server_conf *config =
ap_get_module_config(cmd->server->module_config, &fcgid_module);
if (config->pass_headers == NULL)
config->pass_headers =
apr_array_make(cmd->pool, 10, sizeof(const char *));
header = (const char **) apr_array_push(config->pass_headers);
*header = ap_getword_conf(cmd->pool, &names);
return header ? NULL : "Invalid PassHeaders";
}
apr_array_header_t *get_pass_headers(request_rec * r)
{
fcgid_server_conf *config =
ap_get_module_config(r->server->module_config, &fcgid_module);
return config->pass_headers;
}
static const char *missing_file_msg(apr_pool_t *p, const char *filetype, const char *filename,
apr_status_t rv)
{
char errbuf[120];
apr_strerror(rv, errbuf, sizeof errbuf);
return apr_psprintf(p, "%s %s cannot be accessed: (%d)%s",
filetype, filename, rv, errbuf);
}
const char *set_authenticator_info(cmd_parms * cmd, void *config,
const char *authenticator)
{
apr_status_t rv;
apr_finfo_t finfo;
fcgid_dir_conf *dirconfig = (fcgid_dir_conf *) config;
char **args;
/* Get wrapper path */
apr_tokenize_to_argv(authenticator, &args, cmd->temp_pool);
if (*args == NULL || **args == '\0')
return "Invalid authenticator config";
/* Fetch only required file details inode + device */
if ((rv = apr_stat(&finfo, args[0], APR_FINFO_IDENT,
cmd->temp_pool)) != APR_SUCCESS) {
return missing_file_msg(cmd->pool, "Authenticator", authenticator, rv);
}
/* Create the wrapper node */
dirconfig->authenticator_info =
apr_pcalloc(cmd->server->process->pconf,
sizeof(*dirconfig->authenticator_info));
dirconfig->authenticator_info->cgipath = apr_pstrdup(cmd->pool, args[0]);
dirconfig->authenticator_info->cmdline = authenticator;
dirconfig->authenticator_info->inode = finfo.inode;
dirconfig->authenticator_info->deviceid = finfo.device;
return NULL;
}
const char *set_authenticator_authoritative(cmd_parms * cmd,
void *config, int arg)
{
fcgid_dir_conf *dirconfig = (fcgid_dir_conf *) config;
dirconfig->authenticator_authoritative = arg;
dirconfig->authenticator_authoritative_set = 1;
return NULL;
}
fcgid_cmd_conf *get_authenticator_info(request_rec * r, int *authoritative)
{
fcgid_dir_conf *config =
ap_get_module_config(r->per_dir_config, &fcgid_module);
if (config != NULL && config->authenticator_info != NULL) {
*authoritative = config->authenticator_authoritative;
return config->authenticator_info;
}
return NULL;
}
const char *set_authorizer_info(cmd_parms * cmd, void *config,
const char *authorizer)
{
apr_status_t rv;
apr_finfo_t finfo;
fcgid_dir_conf *dirconfig = (fcgid_dir_conf *) config;
char **args;
/* Get wrapper path */
apr_tokenize_to_argv(authorizer, &args, cmd->temp_pool);
if (*args == NULL || **args == '\0')
return "Invalid authorizer config";
/* Fetch only required file details inode + device */
if ((rv = apr_stat(&finfo, args[0], APR_FINFO_IDENT,
cmd->temp_pool)) != APR_SUCCESS) {
return missing_file_msg(cmd->pool, "Authorizer", authorizer, rv);
}
/* Create the wrapper node */
dirconfig->authorizer_info =
apr_pcalloc(cmd->server->process->pconf,
sizeof(*dirconfig->authorizer_info));
dirconfig->authorizer_info->cgipath = apr_pstrdup(cmd->pool, args[0]);
dirconfig->authorizer_info->cmdline = authorizer;
dirconfig->authorizer_info->inode = finfo.inode;
dirconfig->authorizer_info->deviceid = finfo.device;
return NULL;
}
const char *set_authorizer_authoritative(cmd_parms * cmd,
void *config, int arg)
{
fcgid_dir_conf *dirconfig = (fcgid_dir_conf *) config;
dirconfig->authorizer_authoritative = arg;
dirconfig->authorizer_authoritative_set = 1;
return NULL;
}
fcgid_cmd_conf *get_authorizer_info(request_rec * r, int *authoritative)
{
fcgid_dir_conf *config =
ap_get_module_config(r->per_dir_config, &fcgid_module);
if (config != NULL && config->authorizer_info != NULL) {
*authoritative = config->authorizer_authoritative;
return config->authorizer_info;
}
return NULL;
}
const char *set_access_info(cmd_parms * cmd, void *config,
const char *access)
{
apr_status_t rv;
apr_finfo_t finfo;
fcgid_dir_conf *dirconfig = (fcgid_dir_conf *) config;
char **args;
/* Get wrapper path */
apr_tokenize_to_argv(access, &args, cmd->temp_pool);
if (*args == NULL || **args == '\0')
return "Invalid access config";
/* Fetch only required file details inode + device */
if ((rv = apr_stat(&finfo, args[0], APR_FINFO_IDENT,
cmd->temp_pool)) != APR_SUCCESS) {
return missing_file_msg(cmd->pool, "Access checker", access, rv);
}
/* Create the wrapper node */
dirconfig->access_info =
apr_pcalloc(cmd->server->process->pconf,
sizeof(*dirconfig->access_info));
dirconfig->access_info->cgipath = apr_pstrdup(cmd->pool, args[0]);
dirconfig->access_info->cmdline = access;
dirconfig->access_info->inode = finfo.inode;
dirconfig->access_info->deviceid = finfo.device;
return NULL;
}
const char *set_access_authoritative(cmd_parms * cmd,
void *config, int arg)
{
fcgid_dir_conf *dirconfig = (fcgid_dir_conf *) config;
dirconfig->access_authoritative = arg;
dirconfig->access_authoritative_set = 1;
return NULL;
}
fcgid_cmd_conf *get_access_info(request_rec * r, int *authoritative)
{
fcgid_dir_conf *config =
ap_get_module_config(r->per_dir_config, &fcgid_module);
if (config != NULL && config->access_info != NULL) {
*authoritative = config->access_authoritative;
return config->access_info;
}
return NULL;
}
#ifdef WIN32
/* FcgidWin32PreventOrphans
*
* When Apache process gets recycled or shutdown abruptly, CGI processes
* spawned by mod_fcgid will get orphaned. Orphaning happens mostly when
* Apache worker threads take more than 30 seconds to exit gracefully.
*
* Apache when run as windows service during shutdown/restart of service
* process (master/parent) will terminate child httpd process within 30
* seconds (refer \server\mpm\winnt\mpm_winnt.c:master_main()
* int timeout = 30000; ~line#1142), therefore if Apache worker threads
* are too busy to react to Master's graceful exit signal within 30 seconds
* mod_fcgid cleanup routines will not get invoked (refer child_main()
* \server\mpm\winnt\child.c: apr_pool_destroy(pchild); ~line#2275)
* thereby orphaning all mod_fcgid spwaned CGI processes. Therefore we utilize
* Win32 JobObjects to clean up child processes automatically so that CGI
* processes are force-killed by win32 during abnormal mod_fcgid termination.
*
*/
const char *set_win32_prevent_process_orphans(cmd_parms *cmd, void *dummy,
int arg)
{
server_rec *s = cmd->server;
fcgid_server_conf *config = ap_get_module_config(s->module_config,
&fcgid_module);
const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
#define SETUP_ERR_MSG "Error enabling CGI process orphan prevention"
if (err != NULL) {
return err;
}
if (arg && config->hJobObjectForAutoCleanup == NULL) {
/* Create Win32 job object to prevent CGI process oprhaning
*/
JOBOBJECT_EXTENDED_LIMIT_INFORMATION job_info = { 0 };
config->hJobObjectForAutoCleanup = CreateJobObject(NULL, NULL);
if (config->hJobObjectForAutoCleanup == NULL) {
ap_log_perror(APLOG_MARK, APLOG_STARTUP|APLOG_ERR, apr_get_os_error(),
cmd->pool, "mod_fcgid: unable to create job object.");
return SETUP_ERR_MSG;
}
/* Set job info so that all spawned CGI processes are associated
* with mod_fcgid
*/
job_info.BasicLimitInformation.LimitFlags
= JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
if (SetInformationJobObject(config->hJobObjectForAutoCleanup,
JobObjectExtendedLimitInformation,
&job_info, sizeof(job_info)) == 0) {
ap_log_perror(APLOG_MARK, APLOG_STARTUP|APLOG_ERR, apr_get_os_error(),
cmd->pool, "mod_fcgid: unable to set job object information.");
CloseHandle(config->hJobObjectForAutoCleanup);
config->hJobObjectForAutoCleanup = NULL;
return SETUP_ERR_MSG;
}
}
return NULL;
}
#endif /* WIN32*/
const char *set_wrapper_config(cmd_parms * cmd, void *dirconfig,
const char *wrapper_cmdline,
const char *extension,
const char *virtual)
{
const char *path;
apr_status_t rv;
apr_finfo_t finfo;
fcgid_cmd_conf *wrapper = NULL;
fcgid_dir_conf *config = (fcgid_dir_conf *) dirconfig;
char **args;
/* Sanity checks */
if (virtual == NULL && extension != NULL && !strcasecmp(extension, WRAPPER_FLAG_VIRTUAL)) {
virtual = WRAPPER_FLAG_VIRTUAL;
extension = NULL;
}
if (virtual != NULL && strcasecmp(virtual, WRAPPER_FLAG_VIRTUAL)) {
return "Invalid wrapper flag";
}
if (extension != NULL
&& (*extension != '.' || *(extension + 1) == '\0'
|| ap_strchr_c(extension, '/') || ap_strchr_c(extension, '\\')))
return "Invalid wrapper file extension";
/* Get wrapper path */
apr_tokenize_to_argv(wrapper_cmdline, &args, cmd->temp_pool);
path = apr_pstrdup(cmd->pool, args[0]);
if (path == NULL || *path == '\0')
return "Invalid wrapper config";
/* Fetch only required file details inode + device */
if ((rv = apr_stat(&finfo, path, APR_FINFO_IDENT,
cmd->temp_pool)) != APR_SUCCESS) {
return missing_file_msg(cmd->pool, "Wrapper", path, rv);
}
wrapper = apr_pcalloc(cmd->pool, sizeof(*wrapper));
if (strlen(path) >= FCGID_PATH_MAX) {
return "Executable path length exceeds compiled-in limit";
}
wrapper->cgipath = apr_pstrdup(cmd->pool, path);
if (strlen(wrapper_cmdline) >= FCGID_CMDLINE_MAX) {
return "Command line length exceeds compiled-in limit";
}
wrapper->cmdline = apr_pstrdup(cmd->pool, wrapper_cmdline);
wrapper->inode = finfo.inode;
wrapper->deviceid = finfo.device;
wrapper->virtual = (virtual != NULL && !strcasecmp(virtual, WRAPPER_FLAG_VIRTUAL));
if (extension == NULL)
extension = DEFAULT_WRAPPER_KEY;
/* Add the node now */
/* If an extension is configured multiple times, the last directive wins. */
apr_hash_set(config->wrapper_info_hash, extension, strlen(extension),
wrapper);
return NULL;
}
fcgid_cmd_conf *get_wrapper_info(const char *cgipath, request_rec * r)
{
const char *extension;
fcgid_cmd_conf *wrapper;
fcgid_dir_conf *config =
ap_get_module_config(r->per_dir_config, &fcgid_module);
/* Get file name extension */
extension = ap_strrchr_c(cgipath, '.');
if (extension == NULL)
extension = DEFAULT_WRAPPER_KEY;
/* Search file name extension in per_dir_config */
if (config) {
wrapper = apr_hash_get(config->wrapper_info_hash, extension,
strlen(extension));
if (wrapper == NULL)
wrapper = apr_hash_get(config->wrapper_info_hash, DEFAULT_WRAPPER_KEY,
strlen(DEFAULT_WRAPPER_KEY));
return wrapper;
}
return NULL;
}
static int set_cmd_envvars(fcgid_cmd_env *cmdenv, apr_table_t *envvars)
{
const apr_array_header_t *envvars_arr;
const apr_table_entry_t *envvars_entry;
int i;
int overflow = 0;
if (envvars) {
envvars_arr = apr_table_elts(envvars);
envvars_entry = (apr_table_entry_t *) envvars_arr->elts;
if (envvars_arr->nelts > INITENV_CNT) {
overflow = envvars_arr->nelts - INITENV_CNT;
}
for (i = 0; i < envvars_arr->nelts && i < INITENV_CNT; ++i) {
if (envvars_entry[i].key == NULL
|| envvars_entry[i].key[0] == '\0')
break;
apr_cpystrn(cmdenv->initenv_key[i], envvars_entry[i].key,
INITENV_KEY_LEN);
apr_cpystrn(cmdenv->initenv_val[i], envvars_entry[i].val,
INITENV_VAL_LEN);
}
if (i < INITENV_CNT) {
cmdenv->initenv_key[i][0] = '\0';
}
}
else {
cmdenv->initenv_key[0][0] = '\0';
}
return overflow;
}
const char *set_cmd_options(cmd_parms *cmd, void *dummy, const char *args)
{
server_rec *s = cmd->server;
fcgid_server_conf *sconf =
ap_get_module_config(s->module_config, &fcgid_module);
const char *cmdname;
fcgid_cmd_options *cmdopts;
apr_table_t *envvars = NULL;
int overflow;
apr_finfo_t finfo;
apr_status_t rv;
cmdopts = apr_pcalloc(cmd->pool, sizeof *cmdopts);
cmdopts->cmdenv = apr_pcalloc(cmd->pool, sizeof *cmdopts->cmdenv);
cmdopts->busy_timeout = DEFAULT_BUSY_TIMEOUT;
cmdopts->idle_timeout = DEFAULT_IDLE_TIMEOUT;
cmdopts->ipc_comm_timeout = DEFAULT_IPC_COMM_TIMEOUT;
cmdopts->ipc_connect_timeout = DEFAULT_IPC_CONNECT_TIMEOUT;
cmdopts->max_class_process_count = DEFAULT_MAX_CLASS_PROCESS_COUNT;
cmdopts->max_requests_per_process = DEFAULT_MAX_REQUESTS_PER_PROCESS;
cmdopts->min_class_process_count = DEFAULT_MIN_CLASS_PROCESS_COUNT;
cmdopts->proc_lifetime = DEFAULT_PROC_LIFETIME;
/* via pcalloc: cmdopts->initenv_key[0][0] = '\0'; */
cmdname = ap_getword_conf(cmd->pool, &args);
if (!strlen(cmdname)) {
return "A command must be specified for FcgidCmdOptions";
}
/* Test only for file existence */
rv = apr_stat(&finfo, cmdname, APR_FINFO_MIN, cmd->temp_pool);
if (rv != APR_SUCCESS) {
return missing_file_msg(cmd->pool, "Command", cmdname, rv);
}
if (!*args) {
return "At least one option must be specified for FcgidCmdOptions";
}
while (*args) {
const char *option = ap_getword_conf(cmd->pool, &args);
const char *val;
/* TODO: Consider supporting BusyTimeout.
*/
if (!strcasecmp(option, "ConnectTimeout")) {
val = ap_getword_conf(cmd->pool, &args);
if (!strlen(val)) {
return "ConnectTimeout must have an argument";
}
cmdopts->ipc_connect_timeout = atoi(val);
continue;
}
if (!strcasecmp(option, "IdleTimeout")) {
val = ap_getword_conf(cmd->pool, &args);
if (!strlen(val)) {
return "IdleTimeout must have an argument";
}
cmdopts->idle_timeout = atoi(val);
continue;
}
if (!strcasecmp(option, "InitialEnv")) {
char *name;
char *eql;
name = ap_getword_conf(cmd->pool, &args);
if (!strlen(name)) {
return "InitialEnv must have an argument";
}
eql = strchr(name, '=');
if (eql) {
*eql = '\0';
++eql;
}
if (!envvars) {
envvars = apr_table_make(cmd->pool, 20);
}
add_envvar_to_table(envvars, cmd->pool, name, eql);
continue;
}
if (!strcasecmp(option, "IOTimeout")) {
val = ap_getword_conf(cmd->pool, &args);
if (!strlen(val)) {
return "IOTimeout must have an argument";
}
cmdopts->ipc_comm_timeout = atoi(val);
continue;
}
if (!strcasecmp(option, "MaxProcesses")) {
val = ap_getword_conf(cmd->pool, &args);
if (!strlen(val)) {
return "MaxProcesses must have an argument";
}
cmdopts->max_class_process_count = atoi(val);
continue;
}
if (!strcasecmp(option, "MaxProcessLifetime")) {
val = ap_getword_conf(cmd->pool, &args);
if (!strlen(val)) {
return "MaxProcessLifetime must have an argument";
}
cmdopts->proc_lifetime = atoi(val);
continue;
}
if (!strcasecmp(option, "MaxRequestsPerProcess")) {
val = ap_getword_conf(cmd->pool, &args);
if (!strlen(val)) {
return "MaxRequestsPerProcess must have an argument";
}
cmdopts->max_requests_per_process = atoi(val);
continue;
}
if (!strcasecmp(option, "MinProcesses")) {
val = ap_getword_conf(cmd->pool, &args);
if (!strlen(val)) {
return "MinProcesses must have an argument";
}
cmdopts->min_class_process_count = atoi(val);
continue;
}
return apr_psprintf(cmd->pool,
"Invalid option for FcgidCmdOptions: %s",
option);
}
if ((overflow = set_cmd_envvars(cmdopts->cmdenv, envvars)) != 0) {
return apr_psprintf(cmd->pool, "mod_fcgid: environment variable table "
"overflow; increase INITENV_CNT in fcgid_pm.h from"
" %d to at least %d",
INITENV_CNT, INITENV_CNT + overflow);
}
apr_hash_set(sconf->cmdopts_hash, cmdname, strlen(cmdname), cmdopts);
return NULL;
}
void get_cmd_options(request_rec *r, const char *cmdpath,
fcgid_cmd_options *cmdopts,
fcgid_cmd_env *cmdenv)
{
fcgid_server_conf *sconf =
ap_get_module_config(r->server->module_config, &fcgid_module);
fcgid_cmd_options *cmd_specific = apr_hash_get(sconf->cmdopts_hash,
cmdpath,
strlen(cmdpath));
int overflow;
if (cmd_specific) { /* ignore request context configuration */
*cmdopts = *cmd_specific;
*cmdenv = *cmdopts->cmdenv;
cmdopts->cmdenv = NULL;
/* pick up configuration for values that can't be configured
* on FcgidCmdOptions
*/
cmdopts->busy_timeout = sconf->busy_timeout;
return;
}
cmdopts->busy_timeout = sconf->busy_timeout;
cmdopts->idle_timeout = sconf->idle_timeout;
cmdopts->ipc_comm_timeout = sconf->ipc_comm_timeout;
cmdopts->ipc_connect_timeout = sconf->ipc_connect_timeout;
cmdopts->max_class_process_count = sconf->max_class_process_count;
cmdopts->max_requests_per_process = sconf->max_requests_per_process;
cmdopts->min_class_process_count = sconf->min_class_process_count;
cmdopts->proc_lifetime = sconf->proc_lifetime;
if ((overflow = set_cmd_envvars(cmdenv, sconf->default_init_env)) != 0) {
ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
"mod_fcgid: %d environment variables dropped; increase "
"INITENV_CNT in fcgid_pm.h from %d to at least %d",
overflow,
INITENV_CNT,
INITENV_CNT + overflow);
}
cmdopts->cmdenv = NULL;
}