/*
 * 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_tables.h"
#include "http_main.h"
#include "httpd.h"
#include "http_config.h"
#include "fcgid_global.h"
#include "fcgid_conf.h"
extern module AP_MODULE_DECLARE_DATA fcgid_module;

#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 "logs/fcgidsock"
#define DEFAULT_SHM_PATH "logs/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 -1
#define DEFAULT_MAX_REQUEST_LEN (1024*1024*1024)    /* 1G */
#define DEFAULT_MAX_MEM_REQUEST_LEN (1024*64)   /* 64k */

static void init_server_config(apr_pool_t * p, fcgid_server_conf * config)
{
    config->default_init_env = NULL;
    config->pass_headers = NULL;
    config->sockname_prefix =
        ap_server_root_relative(p, DEFAULT_SOCKET_PREFIX);
    config->shmname_path = ap_server_root_relative(p, DEFAULT_SHM_PATH);
    config->idle_timeout = DEFAULT_IDLE_TIMEOUT;
    config->idle_scan_interval = DEFAULT_IDLE_SCAN_INTERVAL;
    config->busy_scan_interval = DEFAULT_BUSY_SCAN_INTERVAL;
    config->proc_lifetime = DEFAULT_PROC_LIFETIME;
    config->error_scan_interval = DEFAULT_ERROR_SCAN_INTERVAL;
    config->zombie_scan_interval = DEFAULT_ZOMBIE_SCAN_INTERVAL;
    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->max_class_process_count = DEFAULT_MAX_CLASS_PROCESS_COUNT;
    config->min_class_process_count = DEFAULT_MIN_CLASS_PROCESS_COUNT;
    config->max_process_count = DEFAULT_MAX_PROCESS_COUNT;
    config->output_buffersize = DEFAULT_OUTPUT_BUFFERSIZE;
    config->ipc_comm_timeout = DEFAULT_IPC_COMM_TIMEOUT;
    config->ipc_connect_timeout = DEFAULT_IPC_CONNECT_TIMEOUT;
    config->busy_timeout = DEFAULT_BUSY_TIMEOUT;
    config->php_fix_pathinfo_enable = 0;
    config->max_requests_per_process = DEFAULT_MAX_REQUESTS_PER_PROCESS;
    config->max_request_len = DEFAULT_MAX_REQUEST_LEN;
    config->max_mem_request_len = DEFAULT_MAX_MEM_REQUEST_LEN;
}

void *create_fcgid_server_config(apr_pool_t * p, server_rec * s)
{
    fcgid_server_conf *config = apr_pcalloc(p, sizeof(*config));

    init_server_config(p, config);
    return config;
}

void *merge_fcgid_server_config(apr_pool_t * p, void *basev, void *locv)
{
    int i;
    fcgid_server_conf *merged_config =
        (fcgid_server_conf *) apr_pcalloc(p, sizeof(fcgid_server_conf));
    fcgid_server_conf *base = (fcgid_server_conf *) basev;
    fcgid_server_conf *local = (fcgid_server_conf *) locv;
    const apr_array_header_t *baseenv_array, *locenv_array;

    init_server_config(p, merged_config);

    /* Merge environment variables */
    baseenv_array = apr_table_elts(base->default_init_env);
    locenv_array = apr_table_elts(local->default_init_env);

    if (baseenv_array != NULL || locenv_array != NULL) {
        merged_config->default_init_env = apr_table_make(p, 20);

        if (locenv_array != NULL) {
            const apr_table_entry_t *locenv_entry =
                (apr_table_entry_t *) locenv_array->elts;

            for (i = 0; i < locenv_array->nelts; ++i) {
                apr_table_set(merged_config->default_init_env,
                              locenv_entry[i].key, locenv_entry[i].val);
            }
        }

        if (baseenv_array != NULL) {
            const apr_table_entry_t *baseenv_entry =
                (apr_table_entry_t *) baseenv_array->elts;

            for (i = 0; i < baseenv_array->nelts; ++i) {
                if (apr_table_get
                    (merged_config->default_init_env,
                     baseenv_entry[i].key))
                    continue;
                apr_table_set(merged_config->default_init_env,
                              baseenv_entry[i].key, baseenv_entry[i].val);
            }
        }
    }

    /* Merge pass headers */
    if (local->pass_headers != NULL || base->pass_headers != NULL) {
        merged_config->pass_headers =
            apr_array_make(p, 10, sizeof(const char *));
        if (base->pass_headers != NULL)
            apr_array_cat(merged_config->pass_headers, base->pass_headers);
        if (local->pass_headers != NULL)
            apr_array_cat(merged_config->pass_headers,
                          local->pass_headers);
    }
    // Merge the other configurations
    merged_config->ipc_comm_timeout = base->ipc_comm_timeout;
    merged_config->ipc_comm_timeout = local->ipc_comm_timeout;

    merged_config->ipc_connect_timeout = base->ipc_connect_timeout;
    merged_config->ipc_connect_timeout = local->ipc_connect_timeout;

    merged_config->busy_timeout = base->busy_timeout;
    merged_config->busy_timeout = local->busy_timeout;

    return merged_config;
}

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

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);
    return NULL;
}

int get_idle_timeout(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->idle_timeout : DEFAULT_IDLE_TIMEOUT;
}

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);
    config->idle_scan_interval = atol(arg);
    return NULL;
}

int get_idle_scan_interval(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->idle_scan_interval : DEFAULT_IDLE_TIMEOUT;
}

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);
    return NULL;
}

int get_busy_timeout(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->busy_timeout : DEFAULT_BUSY_TIMEOUT;
}

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);
    config->busy_scan_interval = atol(arg);
    return NULL;
}

int get_busy_scan_interval(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->
        busy_scan_interval : DEFAULT_BUSY_SCAN_INTERVAL;
}

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);
    return NULL;
}

int get_proc_lifetime(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->proc_lifetime : DEFAULT_PROC_LIFETIME;
}

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);
    config->error_scan_interval = atol(arg);
    return NULL;
}

int get_error_scan_interval(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->
        error_scan_interval : DEFAULT_ERROR_SCAN_INTERVAL;
}

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);
    config->zombie_scan_interval = atol(arg);
    return NULL;
}

int get_zombie_scan_interval(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->
        zombie_scan_interval : DEFAULT_ZOMBIE_SCAN_INTERVAL;
}

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);
    config->sockname_prefix = ap_server_root_relative(cmd->pool, arg);
    if (!config->sockname_prefix)
        return "Invalid socket path";

    return NULL;
}

const char *get_socketpath(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config->sockname_prefix;
}

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);
    config->shmname_path = ap_server_root_relative(cmd->pool, arg);
    if (!config->shmname_path)
        return "Invalid shmname path";

    return NULL;
}

const char *get_shmpath(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config->shmname_path;
}

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);
    config->spawnscore_uplimit = atol(arg);
    return NULL;
}

int get_spawnscore_uplimit(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->
        spawnscore_uplimit : DEFAULT_SPAWNSOCRE_UPLIMIT;
}

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);
    config->max_request_len = atol(arg);
    return NULL;
}

int get_max_request_len(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->max_request_len : DEFAULT_MAX_REQUEST_LEN;
}

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);
    return NULL;
}

int get_max_mem_request_len(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->
        max_mem_request_len : DEFAULT_MAX_MEM_REQUEST_LEN;
}

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);
    config->spawn_score = atol(arg);
    return NULL;
}

int get_spawn_score(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->spawn_score : DEFAULT_SPAWN_SCORE;
}

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);
    config->time_score = atol(arg);
    return NULL;
}

int get_time_score(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->time_score : DEFAULT_TIME_SCORE;
}

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);
    config->termination_score = atol(arg);
    return NULL;
}

int get_termination_score(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->termination_score : DEFAULT_TERMINATION_SCORE;
}

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);
    config->max_process_count = atol(arg);
    return NULL;
}

int get_max_process(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->max_process_count : DEFAULT_MAX_PROCESS_COUNT;
}

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);
    return NULL;
}

int get_output_buffersize(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->output_buffersize : DEFAULT_OUTPUT_BUFFERSIZE;
}

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);
    return NULL;
}

int get_max_class_process(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->
        max_class_process_count : DEFAULT_MAX_CLASS_PROCESS_COUNT;
}

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);
    return NULL;
}

int get_min_class_process(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->
        min_class_process_count : DEFAULT_MIN_CLASS_PROCESS_COUNT;
}

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);
    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);
    config->max_requests_per_process = atol(arg);
    return NULL;
}

int get_max_requests_per_process(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->
        max_requests_per_process : DEFAULT_MAX_REQUESTS_PER_PROCESS;
}

int get_php_fix_pathinfo_enable(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->php_fix_pathinfo_enable : 0;
}

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);
    return NULL;
}

int get_ipc_connect_timeout(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->
        ipc_connect_timeout : DEFAULT_IPC_CONNECT_TIMEOUT;
}

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);
    return NULL;
}

int get_ipc_comm_timeout(server_rec * s)
{
    fcgid_server_conf *config =
        ap_get_module_config(s->module_config, &fcgid_module);
    return config ? config->ipc_comm_timeout : DEFAULT_IPC_COMM_TIMEOUT;
}

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);

    apr_table_set(config->default_init_env, name, value ? value : "");
    return NULL;
}

apr_table_t *get_default_env_vars(request_rec * r)
{
    fcgid_server_conf *config =
        ap_get_module_config(r->server->module_config, &fcgid_module);
    return config->default_init_env;
}

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

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;

    /* Is the wrapper exist? */
    if ((rv = apr_stat(&finfo, authenticator, APR_FINFO_NORM,
                       cmd->temp_pool)) != APR_SUCCESS) {
        return apr_psprintf(cmd->pool,
                            "can't get authenticator file info: %s, errno: %d",
                            authenticator, apr_get_os_error());
    }

    /* Create the wrapper node */
    dirconfig->authenticator_info =
        apr_pcalloc(cmd->server->process->pconf,
                    sizeof(*dirconfig->authenticator_info));
    if (!dirconfig->authenticator_info)
        return "Can't alloc memory for authenticator_info";
    strncpy(dirconfig->authenticator_info->path, authenticator,
            _POSIX_PATH_MAX - 1);
    dirconfig->authenticator_info->path[_POSIX_PATH_MAX - 1] = '\0';
    dirconfig->authenticator_info->inode = finfo.inode;
    dirconfig->authenticator_info->deviceid = finfo.device;
    dirconfig->authenticator_info->share_group_id = (apr_size_t) - 1;
    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;
    return NULL;
}

auth_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;

    /* Is the wrapper exist? */
    if ((rv = apr_stat(&finfo, authorizer, APR_FINFO_NORM,
                       cmd->temp_pool)) != APR_SUCCESS) {
        return apr_psprintf(cmd->pool,
                            "can't get authorizer file info: %s, errno: %d",
                            authorizer, apr_get_os_error());
    }

    /* Create the wrapper node */
    dirconfig->authorizer_info =
        apr_pcalloc(cmd->server->process->pconf,
                    sizeof(*dirconfig->authorizer_info));
    if (!dirconfig->authorizer_info)
        return "Can't alloc memory for authorizer";
    strncpy(dirconfig->authorizer_info->path, authorizer,
            _POSIX_PATH_MAX - 1);
    dirconfig->authorizer_info->path[_POSIX_PATH_MAX - 1] = '\0';
    dirconfig->authorizer_info->inode = finfo.inode;
    dirconfig->authorizer_info->deviceid = finfo.device;
    dirconfig->authorizer_info->share_group_id = (apr_size_t) - 1;
    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;
    return NULL;
}

auth_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;

    /* Is the wrapper exist? */
    if ((rv = apr_stat(&finfo, access, APR_FINFO_NORM,
                       cmd->temp_pool)) != APR_SUCCESS) {
        return apr_psprintf(cmd->pool,
                            "can't get authorizer file info: %s, errno: %d",
                            access, apr_get_os_error());
    }

    /* Create the wrapper node */
    dirconfig->access_info =
        apr_pcalloc(cmd->server->process->pconf,
                    sizeof(*dirconfig->access_info));
    if (!dirconfig->access_info)
        return "Can't alloc memory for access";
    strncpy(dirconfig->access_info->path, access, _POSIX_PATH_MAX - 1);
    dirconfig->access_info->path[_POSIX_PATH_MAX - 1] = '\0';
    dirconfig->access_info->inode = finfo.inode;
    dirconfig->access_info->deviceid = finfo.device;
    dirconfig->access_info->share_group_id = (apr_size_t) - 1;
    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;
    return NULL;
}

auth_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;
}

typedef struct {
    apr_hash_t *wrapper_id_hash;
    apr_size_t cur_id;
} wrapper_id_info;

const char *set_wrapper_config(cmd_parms * cmd, void *dirconfig,
                               const char *wrapperpath,
                               const char *extension)
{
    const char *path, *tmp;
    apr_status_t rv;
    apr_finfo_t finfo;
    const char *userdata_key = "fcgid_wrapper_id";
    wrapper_id_info *id_info;
    apr_size_t *wrapper_id;
    fcgid_wrapper_conf *wrapper = NULL;
    fcgid_dir_conf *config = (fcgid_dir_conf *) dirconfig;

    /* Sanity check */
    if (wrapperpath == NULL || extension == NULL
        || *extension != '.' || *(extension + 1) == '\0'
        || strchr(extension, '/') || strchr(extension, '\\'))
        return "Invalid wrapper file extension";

    /* Get wrapper_id base on wrapperpath */
    apr_pool_userdata_get((void *) &id_info, userdata_key,
                          cmd->server->process->pool);
    if (!id_info) {
        id_info =
            apr_pcalloc(cmd->server->process->pool, sizeof(*id_info));
        id_info->wrapper_id_hash =
            apr_hash_make(cmd->server->process->pool);
        apr_pool_userdata_set((const void *) id_info, userdata_key,
                              apr_pool_cleanup_null,
                              cmd->server->process->pool);
    }
    if ((wrapper_id =
         apr_hash_get(id_info->wrapper_id_hash, wrapperpath,
                      strlen(wrapperpath))) == NULL) {
        wrapper_id =
            apr_pcalloc(cmd->server->process->pool, sizeof(*wrapper_id));
        *wrapper_id = id_info->cur_id++;
        apr_hash_set(id_info->wrapper_id_hash, wrapperpath,
                     strlen(wrapperpath), wrapper_id);
    }

    wrapper = apr_pcalloc(cmd->server->process->pconf, sizeof(*wrapper));
    if (!wrapper)
        return "Can't alloc memory for wrapper";

    /* Get wrapper path */
    tmp = wrapperpath;
    path = ap_getword_white(cmd->temp_pool, &tmp);
    if (path == NULL || *path == '\0')
        return "Invalid wrapper config";

    /* Is the wrapper exist? */
    if ((rv = apr_stat(&finfo, path, APR_FINFO_NORM,
                       cmd->temp_pool)) != APR_SUCCESS) {
        return apr_psprintf(cmd->pool,
                            "can't get fastcgi file info: %s(%s), errno: %d",
                            wrapperpath, path, apr_get_os_error());
    }

    strncpy(wrapper->args, wrapperpath, _POSIX_PATH_MAX - 1);
    wrapper->args[_POSIX_PATH_MAX - 1] = '\0';
    wrapper->inode = finfo.inode;
    wrapper->deviceid = finfo.device;
    wrapper->share_group_id = *wrapper_id;
    *wrapper_id++;

    /* Add the node now */
    apr_hash_set(config->wrapper_info_hash, extension, strlen(extension),
                 wrapper);

    return NULL;
}

fcgid_wrapper_conf *get_wrapper_info(const char *cgipath, request_rec * r)
{
    char *extension;
    fcgid_wrapper_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)
        return NULL;

    /* Search file name extension in per_dir_config */
    if (config
        && (wrapper =
            apr_hash_get(config->wrapper_info_hash, extension,
                         strlen(extension))))
        return wrapper;

    return NULL;
}