*/
// If 'redirect' is foo/bar, then redirect to it. If it is
// foo/bar/%s, then replace the %s with r->uri.
static void compose_and_set_redirect(request_rec *r, const char* redirect) {
char* composed_redirect = NULL;
if (ap_strstr_c(redirect, "%s")) {
composed_redirect = apr_psprintf(r->pool, redirect, r->uri);
}
apr_table_setn(r->headers_out, "Location", composed_redirect ? composed_redirect : redirect);
}
static const command_rec cookie_auth_cmds[] =
{
AP_INIT_TAKE1("AuthCookieName", ap_set_string_slot,
(void *)APR_OFFSETOF(cookie_auth_config_rec, cookie_auth_cookie),
OR_AUTHCFG, "auth cookie name"),
AP_INIT_TAKE1("AuthCookieEnv", ap_set_string_slot,
(void *)APR_OFFSETOF(cookie_auth_config_rec, cookie_auth_env),
OR_AUTHCFG, "environment variable name for optional auxiliary auth info"),
AP_INIT_TAKE1("AuthCookieEnvRedirect", ap_set_string_slot,
(void *)APR_OFFSETOF(cookie_auth_config_rec, cookie_auth_env_redirect),
OR_AUTHCFG, "path to redirect to if optional auxiliary auth info is missing in cookie"),
AP_INIT_TAKE1("AuthCookieUnauthRedirect", ap_set_string_slot,
(void *)APR_OFFSETOF(cookie_auth_config_rec, cookie_auth_unauth_redirect),
OR_AUTHCFG, "path to redirect to if authentication cookie is not set"),
AP_INIT_TAKE1("AuthCookieEncrypt", ap_set_string_slot,
(void *)APR_OFFSETOF(cookie_auth_config_rec, cookie_auth_encrypt),
OR_AUTHCFG, "secret key used to DES-encrypt the cookie"),
AP_INIT_FLAG("AuthCookieOverride", ap_set_flag_slot,
(void *)APR_OFFSETOF(cookie_auth_config_rec, cookie_auth_override),
apr_table_setn(r->subprocess_env, sconf->mobile_env, "true");
}
}
} else {
// ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server , "No entry found for UA: %s", user_agent);
}
return DECLINED;
}
static const command_rec wurfl_cmds[] =
{
AP_INIT_FLAG("WurflEnable", cmd_wurflengine, NULL, RSRC_CONF,
"On or off to enable the whole WURFL module"),
AP_INIT_TAKE1("WurflDBFile", cmd_wurfldb, NULL, RSRC_CONF,
"the filename of the WURFL-DB xml file"),
AP_INIT_TAKE1("WurflMobileEnv", cmd_wurflmobileenv, NULL, RSRC_CONF,
"ENV to set for mobile user agents"),
AP_INIT_TAKE1("WurflTabletEnv", cmd_wurfltabletenv, NULL, RSRC_CONF,
"ENV to set for tablet user agents"),
{ NULL }
};
static void register_hooks(apr_pool_t *p)
{
ap_hook_header_parser(wurfl_match_headers, NULL, NULL, APR_HOOK_MIDDLE);
}
module AP_MODULE_DECLARE_DATA wurfl_module = {
STANDARD20_MODULE_STUFF,
* @internal
*
* Declares all configuration directives.
*/
static const command_rec ironbee_cmds[] = {
AP_INIT_FLAG(
"IronBeeEnable",
ironbee_cmd_ibenable,
(void*)APR_OFFSETOF(ironbee_config_t, enabled),
RSRC_CONF,
"enable ironbee module"
),
AP_INIT_TAKE1(
"IronBeeConfig",
ironbee_cmd_ibconfig,
(void*)APR_OFFSETOF(ironbee_config_t, config),
RSRC_CONF,
"specify ironbee configuration file"
),
AP_INIT_TAKE1(
"IronBeeBufferSize",
ironbee_cmd_sz,
(void*)APR_OFFSETOF(ironbee_config_t, buf_size),
RSRC_CONF,
"specify buffer size (bytes)"
),
AP_INIT_TAKE1(
"IronBeeBufferFlushSize",
ironbee_cmd_sz,
(void*)APR_OFFSETOF(ironbee_config_t, flush_size),
RSRC_CONF,
"suffixed with 'b', 'k', 'm' or 'g'.";
}
dcfg->max_line_length = (apr_size_t)max;
dcfg->max_line_length_set = 1;
return NULL;
}
#define PROTO_FLAGS AP_FILTER_PROTO_CHANGE|AP_FILTER_PROTO_CHANGE_LENGTH
static void register_hooks(apr_pool_t *pool)
{
ap_register_output_filter(substitute_filter_name, substitute_filter,
NULL, AP_FTYPE_RESOURCE);
}
static const command_rec substitute_cmds[] = {
AP_INIT_TAKE1("Substitute", set_pattern, NULL, OR_FILEINFO,
"Pattern to filter the response content (s/foo/bar/[inf])"),
AP_INIT_TAKE1("SubstituteMaxLineLength", set_max_line_length, NULL, OR_FILEINFO,
"Maximum line length"),
AP_INIT_FLAG("SubstituteInheritBefore", ap_set_flag_slot,
(void *)APR_OFFSETOF(subst_dir_conf, inherit_before), OR_FILEINFO,
"Apply inherited patterns before those of the current context"),
{NULL}
};
AP_DECLARE_MODULE(substitute) = {
STANDARD20_MODULE_STUFF,
create_substitute_dcfg, /* dir config creater */
merge_substitute_dcfg, /* dir merger --- default is to override */
NULL, /* server config */
NULL, /* merge server config */
substitute_cmds, /* command table */
debuglevel = strtol(arg, NULL, 10);
return NULL;
}
#endif
/* module info */
static const command_rec aclr_cmds[] =
{
AP_INIT_FLAG("AccelRedirectSet", set_aclr_state,
NULL, ACCESS_CONF|RSRC_CONF,
"Turn X-Accel-Redirect support On or Off (default Off)"),
AP_INIT_TAKE1("AccelRedirectSize", set_redirect_min_size,
NULL, ACCESS_CONF|RSRC_CONF,
"Minimum size of file for redirect"),
AP_INIT_FLAG("AccelRedirectOutsideDocRoot", set_aclr_outside_of_docroot,
NULL, RSRC_CONF,
"Allow redirect outside of DocumentRoot (default Off)"),
#ifdef DEBUG
AP_INIT_TAKE1("AccelRedirectDebug", set_debug_level,
NULL, RSRC_CONF,
"Debug level (0=off, 1=min, 2=mid, 3=max)"),
#endif
{ NULL }
};
}
} else if (strcmp(name, "AmAgent") == 0) {
if (!strcasecmp(arg, "on")) {
conf->enabled = 1;
} else {
conf->enabled = 0;
}
}
}
}
return NULL;
}
/*Context: either top level or inside VirtualHost*/
static const command_rec amagent_cmds[] = {
AP_INIT_TAKE1("AmAgent", am_set_opt, NULL, RSRC_CONF, "Module enabled/disabled"),
AP_INIT_TAKE1("AmAgentConf", am_set_opt, NULL, RSRC_CONF, "Module configuration file"), {
NULL
}
};
static apr_status_t amagent_cleanup(void *arg) {
/* main process cleanup */
server_rec *s = (server_rec *) arg;
LOG_S(APLOG_DEBUG, s, "amagent_cleanup() %d", getpid());
#ifndef _WIN32
am_shutdown();
#endif
return APR_SUCCESS;
}
//ap_register_input_filter( "MODMRUBYFILTER", mod_mruby_input_filter, NULL, AP_FTYPE_CONTENT_SET);
}
#define MOD_MRUBY_SET_ALL_CMDS_INLINE(hook, dir_name) \
AP_INIT_TAKE1("mruby" #dir_name "FirstCode", set_mod_mruby_##hook##_first_inline, NULL, RSRC_CONF | ACCESS_CONF, "hook inline code for " #hook " first phase."), \
AP_INIT_TAKE1("mruby" #dir_name "MiddleCode", set_mod_mruby_##hook##_middle_inline, NULL, RSRC_CONF | ACCESS_CONF, "hook inline code for " #hook " middle phase."), \
AP_INIT_TAKE1("mruby" #dir_name "LastCode", set_mod_mruby_##hook##_last_inline, NULL, RSRC_CONF | ACCESS_CONF, "hook inline code for " #hook " last phase."),
#define MOD_MRUBY_SET_ALL_CMDS(hook, dir_name) \
AP_INIT_TAKE12("mruby" #dir_name "First", set_mod_mruby_##hook##_first, NULL, RSRC_CONF | ACCESS_CONF, "hook Ruby file for " #hook " first phase."), \
AP_INIT_TAKE12("mruby" #dir_name "Middle", set_mod_mruby_##hook##_middle, NULL, RSRC_CONF | ACCESS_CONF, "hook Ruby file for " #hook " middle phase."), \
AP_INIT_TAKE12("mruby" #dir_name "Last", set_mod_mruby_##hook##_last, NULL, RSRC_CONF | ACCESS_CONF, "hook Ruby file for " #hook " last phase."),
static const command_rec mod_mruby_cmds[] = {
AP_INIT_TAKE1("mrubyHandlerCode", set_mod_mruby_handler_inline, NULL, RSRC_CONF | ACCESS_CONF, "hook inline code for handler phase."),
MOD_MRUBY_SET_ALL_CMDS_INLINE(handler, Handler)
MOD_MRUBY_SET_ALL_CMDS_INLINE(post_read_request, PostReadRequest)
MOD_MRUBY_SET_ALL_CMDS_INLINE(translate_name, TranslateName)
MOD_MRUBY_SET_ALL_CMDS_INLINE(map_to_storage, MapToStorage)
MOD_MRUBY_SET_ALL_CMDS_INLINE(access_checker, AccessChecker)
MOD_MRUBY_SET_ALL_CMDS_INLINE(check_user_id, CheckUserId)
MOD_MRUBY_SET_ALL_CMDS_INLINE(auth_checker, AuthChecker)
MOD_MRUBY_SET_ALL_CMDS_INLINE(fixups, Fixups)
MOD_MRUBY_SET_ALL_CMDS_INLINE(log_transaction, LogTransaction)
AP_INIT_TAKE12("mrubyHandler", set_mod_mruby_handler, NULL, RSRC_CONF | ACCESS_CONF, "hook for handler phase."),
MOD_MRUBY_SET_ALL_CMDS(handler, Handler)
MOD_MRUBY_SET_ALL_CMDS(post_config, PostConfig)
MOD_MRUBY_SET_ALL_CMDS(child_init, ChildInit)
MOD_MRUBY_SET_ALL_CMDS(post_read_request, PostReadRequest)
module AP_MODULE_DECLARE_DATA moon_module;
// config struct
typedef struct moon_svr_cfg {
char *buf;
const char* user_data_url;
const char* group_data_url;
apr_hash_t * user_to_css;
apr_hash_t * group_to_css;
} moon_svr_cfg;
// List of containers and directives
static const command_rec moon_cmds[] = {
AP_INIT_RAW_ARGS("<LMMPGroup", lmmpgroup_cmd, NULL, EXEC_ON_READ|OR_ALL, "Container for setting group css style"),
AP_INIT_RAW_ARGS("<LMMPUser", lmmpuser_cmd, NULL, EXEC_ON_READ|OR_ALL, "Container for setting user css style"),
AP_INIT_TAKE1("LMMPSetUserDataUrl", lmmpset_user_data_url_cmd, NULL, OR_ALL, "set user data url"),
AP_INIT_TAKE1("LMMPSetGroupDataUrl", lmmpset_group_data_url_cmd, NULL, OR_ALL, "set group data url"),
{ NULL }
};
// Standard Module declaration for Apache 2.0
module AP_MODULE_DECLARE_DATA moon_module = {
STANDARD20_MODULE_STUFF,
NULL,
NULL,
create_moon_cfg,
NULL,
moon_cmds,
moon_hooks
};
See LICENSE file for licensing details.
*/
#include "mod_falcon.h"
#include "mod_falcon_config.h"
/*=========================================================
Module data.
Configuration directive for Falcon module
*/
static const command_rec mod_falcon_cmds[] =
{
AP_INIT_TAKE1(
"FalconConfig",
(const char *(*)())falcon_mod_set_config,
NULL,
RSRC_CONF,
"config_file (string) -- Location of the falcon.ini file."
),
AP_INIT_TAKE1(
"FalconHandler",
(const char *(*)())falcon_mod_set_handler,
NULL,
ACCESS_CONF | RSRC_CONF,
"handler script (string) -- Program invoked when falcon-program handler is excited."
),
AP_INIT_TAKE1(
"FalconLoadPath",
(const char *(*)())falcon_mod_set_path,
AP_INIT_TAKE13("LogSQLLoginInfo", set_log_sql_info, NULL, RSRC_CONF,
"The database connection URI in the form "driver://user:password@hostname:port/database"")
,
AP_INIT_TAKE2("LogSQLDBParam", set_dbparam, NULL, RSRC_CONF,
"First argument is the DB parameter, second is the value to assign")
,
AP_INIT_FLAG("LogSQLForcePreserve", set_global_flag_slot,
(void *)APR_OFFSETOF(global_config_t, forcepreserve), RSRC_CONF,
"Forces logging to preserve file and bypasses database")
,
AP_INIT_FLAG("LogSQLDisablePreserve", set_global_flag_slot,
(void *)APR_OFFSETOF(global_config_t, disablepreserve), RSRC_CONF,
"Completely disables use of the preserve file")
,
AP_INIT_TAKE1("LogSQLPreserveFile", set_server_file_slot,
(void *)APR_OFFSETOF(logsql_state,preserve_file), RSRC_CONF,
"Name of the file to use for data preservation during database downtime")
,
AP_INIT_FLAG("LogSQLCreateTables", set_global_nmv_flag_slot,
(void *)APR_OFFSETOF(global_config_t, createtables), RSRC_CONF,
"Turn on module's capability to create its SQL tables on the fly")
,
/* Table names */
AP_INIT_FLAG("LogSQLMassVirtualHosting", set_global_flag_slot,
(void *)APR_OFFSETOF(global_config_t, massvirtual), RSRC_CONF,
"Activates option(s) useful for ISPs performing mass virutal hosting")
,
AP_INIT_TAKE1("LogSQLTransferLogTable", set_server_nmv_string_slot,
(void *)APR_OFFSETOF(logsql_state, transfer_table_name), RSRC_CONF,
"The database table that holds the transfer log")
,
return code;
}
/*
* Only needed configuration is pointer to resin.conf
*/
static const command_rec cwx_commands[] = {
AP_INIT_RAW_ARGS("cwinux-service", cwx_svr_command, NULL,
RSRC_CONF, "Configures service."),
AP_INIT_RAW_ARGS("cwinux-host", cwx_host_command, NULL,
RSRC_CONF, "Configures host."),
AP_INIT_RAW_ARGS("cwinux-balance", cwx_balance_command, NULL,
RSRC_CONF, "Configures balance."),
AP_INIT_RAW_ARGS("cwinux-header", cwx_header_command, NULL,
RSRC_CONF, "Configures header."),
AP_INIT_TAKE1("cwinux-show", cwx_show_command, NULL,
RSRC_CONF, "Configures default show."),
AP_INIT_TAKE1("cwinux-delay", cwx_delay_command, NULL,
RSRC_CONF, "Configures default delay."),
AP_INIT_TAKE1("cwinux-persistent", cwx_persistent_command, NULL,
RSRC_CONF, "Configures default persistent."),
AP_INIT_TAKE1("cwinux-query-timeout", cwx_query_timeout_command, NULL,
RSRC_CONF, "Configures default query-timeout."),
AP_INIT_TAKE1("cwinux-conn-timeout", cwx_conn_timeout_command, NULL,
RSRC_CONF, "Configures default conn-timeout."),
AP_INIT_TAKE1("cwinux-reply-timeout", cwx_reply_timeout_command, NULL,
RSRC_CONF, "Configures default reply-timeout."),
AP_INIT_TAKE1("cwinux-restore-time", cwx_restore_time_command, NULL,
RSRC_CONF, "Configures default restore-time."),
AP_INIT_TAKE1("cwinux-min-idle-conn", cwx_min_idle_conn_command, NULL,
RSRC_CONF, "Configures default min-idle-conn."),
AP_INIT_TAKE1("cwinux-max-idle-conn", cwx_max_idle_conn_command, NULL,
}
static const char *set_keep_alive_max(cmd_parms *cmd, void *dummy,
const char *arg)
{
const char *err = ap_check_cmd_context(cmd, NOT_IN_DIR_LOC_FILE);
if (err != NULL) {
return err;
}
cmd->server->keep_alive_max = atoi(arg);
return NULL;
}
static const command_rec http_cmds[] = {
AP_INIT_TAKE1("KeepAliveTimeout", set_keep_alive_timeout, NULL, RSRC_CONF,
"Keep-Alive timeout duration (sec)"),
AP_INIT_TAKE1("MaxKeepAliveRequests", set_keep_alive_max, NULL, RSRC_CONF,
"Maximum number of Keep-Alive requests per connection, "
"or 0 for infinite"),
AP_INIT_FLAG("KeepAlive", set_keep_alive, NULL, RSRC_CONF,
"Whether persistent connections should be On or Off"),
{ NULL }
};
static const char *http_scheme(const request_rec *r)
{
/*
* The http module shouldn't return anything other than
* "http" (the default) or "https".
*/
if (r->server->server_scheme &&
ret = FTPD_CHROOT_FAIL;
}
}
return ret;
}
/* Module initialization structures */
static const ftpd_provider ftpd_dbm_provider =
{
ftpd_dbm_map_chroot, /* map_chroot */
NULL
};
static const command_rec ftpd_dbm_cmds[] = {
AP_INIT_TAKE1("FtpDBMFile", ftpd_dbm_cmd_dbmpath, NULL, RSRC_CONF,
"Path to Database to use chroot mapping."),
AP_INIT_TAKE1("FtpDBMType", ftpd_dbm_cmd_dbmtype, NULL, RSRC_CONF,
"What type of DBM file to open. default, DB,GDBM,NDBM, SDBM."),
{ NULL }
};
static void register_hooks(apr_pool_t *p)
{
ap_register_provider(p, FTPD_PROVIDER_GROUP, "dbm","0",
&ftpd_dbm_provider);
}
module AP_MODULE_DECLARE_DATA ftpd_dbm_module = {
STANDARD20_MODULE_STUFF,
NULL, /* create per-directory config structure */
NULL, /* merge per-directory config structures */
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 const command_rec authz_dbd_cmds[] = {
AP_INIT_FLAG("AuthzDBDLoginToReferer", ap_set_flag_slot,
(void*)APR_OFFSETOF(authz_dbd_cfg, redirect), ACCESS_CONF,
"Whether to redirect to referer on successful login"),
AP_INIT_TAKE1("AuthzDBDQuery", authz_dbd_prepare,
(void*)APR_OFFSETOF(authz_dbd_cfg, query), ACCESS_CONF,
"SQL query for DBD Authz or login"),
AP_INIT_TAKE1("AuthzDBDRedirectQuery", authz_dbd_prepare,
(void*)APR_OFFSETOF(authz_dbd_cfg, redir_query), ACCESS_CONF,
"SQL query to get per-user redirect URL after login"),
{NULL}
};
static int authz_dbd_login(request_rec *r, authz_dbd_cfg *cfg,
const char *action)
{
int rv;
const char *newuri = NULL;
int nrows;
const char *message;
ap_dbd_t *dbd;
static char *
svc_simulator_256b_get_reply(
apr_pool_t * pool);
static void
svc_simulator_256b_module_init(
apr_pool_t * p,
server_rec * svr_rec);
static void
svc_simulator_256b_register_hooks(
apr_pool_t * p);
/***************************End of Function Headers****************************/
static const command_rec svc_simulator_256b_cmds[] = { AP_INIT_TAKE1("SvcSimulatorInputFile_256b", svc_simulator_256b_set_filepath, NULL,
RSRC_CONF, "Service Simulator file path"), { NULL } };
/* Dispatch list for API hooks */
module AP_MODULE_DECLARE_DATA svc_simulator_256b_module = { STANDARD20_MODULE_STUFF, NULL, /* create per-dir config structures */
NULL, /* merge per-dir config structures */
svc_simulator_256b_create_svr, /* create per-server config structures */
NULL, /* merge per-server config structures */
svc_simulator_256b_cmds, /* table of config file commands */
svc_simulator_256b_register_hooks /* register hooks */
};
static void *
svc_simulator_256b_create_svr(
apr_pool_t * p,
server_rec * s)
{
if (rv != APR_SUCCESS)
return apr_psprintf(cmd->pool, "%pm", &rv);
a->type = T_IP;
}
else { /* no slash, didn't look like an IP address => must be a host */
a->type = T_HOST;
}
return NULL;
}
static char its_an_allow;
static const command_rec access_compat_cmds[] =
{
AP_INIT_TAKE1("order", order, NULL, OR_LIMIT,
"'allow,deny', 'deny,allow', or 'mutual-failure'"),
AP_INIT_ITERATE2("allow", allow_cmd, &its_an_allow, OR_LIMIT,
"'from' followed by hostnames or IP-address wildcards"),
AP_INIT_ITERATE2("deny", allow_cmd, NULL, OR_LIMIT,
"'from' followed by hostnames or IP-address wildcards"),
AP_INIT_TAKE1("Satisfy", satisfy, NULL, OR_AUTHCFG,
"access policy if both allow and require used ('all' or 'any')"),
{NULL}
};
static int in_domain(const char *domain, const char *what)
{
int dl = strlen(domain);
int wl = strlen(what);
if ((wl - dl) >= 0) {
strcpy (buf, path);
strcat (buf, ":");
strcat (buf, arg);
} else {
strcpy (buf, arg);
}
setenv ("AIKIDOPATH", buf, 1);
return NULL;
}
static const command_rec aikido_cmds[] =
{
AP_INIT_TAKE1("AikidoWebApps", set_webapp_dir, NULL, RSRC_CONF,
"The path of the Aikido web applications"),
AP_INIT_TAKE1("AikidoRootDir", set_aikido_dir, NULL, RSRC_CONF,
"The directory containing the aikido.zip file"),
AP_INIT_TAKE1("AikidoAddPath", add_aikido_path, NULL, RSRC_CONF,
"Add a directory to the AIKIDOPATH environment variable"),
AP_INIT_TAKE1("AikidoDebugMode", set_aikido_debug, NULL, RSRC_CONF,
"Set the mod_aikido debug mode (true or false)"),
};
/*
* we have to create our own bucket type for reading from the sockets. The apr_bucket_pipe_make function
* seems to only read once and therefore a large amount of data seems to block the write to the pipe
dcfg->style = CT_COOKIE;
}
else if ((strcasecmp(name, "Cookie2") == 0)
|| (strcasecmp(name, "RFC2965") == 0)) {
dcfg->style = CT_COOKIE2;
}
else {
return apr_psprintf(cmd->pool, "Invalid %s keyword: '%s'",
cmd->cmd->name, name);
}
return NULL;
}
static const command_rec cookie_log_cmds[] = {
AP_INIT_TAKE1("CookieExpires", set_cookie_exp, NULL, OR_FILEINFO,
"an expiry date code"),
AP_INIT_TAKE1("CookieDomain", set_cookie_domain, NULL, OR_FILEINFO,
"domain to which this cookie applies"),
AP_INIT_TAKE1("CookieStyle", set_cookie_style, NULL, OR_FILEINFO,
"'Netscape', 'Cookie' (RFC2109), or 'Cookie2' (RFC2965)"),
AP_INIT_FLAG("CookieTracking", set_cookie_enable, NULL, OR_FILEINFO,
"whether or not to enable cookies"),
AP_INIT_TAKE1("CookieName", set_cookie_name, NULL, OR_FILEINFO,
"name of the tracking cookie"),
{NULL}
};
static void register_hooks(apr_pool_t *p)
{
ap_hook_fixups(spot_cookie,NULL,NULL,APR_HOOK_REALLY_FIRST);
}
zend_hash_move_forward(&d->config)) {
zend_hash_get_current_data(&d->config, (void **) &data);
phpapdebug((stderr, "APPLYING (%s)(%s)\n", str, data->value));
if (zend_alter_ini_entry(str, str_len, data->value, data->value_len, data->status, data->htaccess?PHP_INI_STAGE_HTACCESS:PHP_INI_STAGE_ACTIVATE) == FAILURE) {
phpapdebug((stderr, "..FAILED\n"));
}
}
}
const command_rec php_dir_cmds[] =
{
AP_INIT_TAKE2("php_value", php_apache_value_handler, NULL, OR_OPTIONS, "PHP Value Modifier"),
AP_INIT_TAKE2("php_flag", php_apache_flag_handler, NULL, OR_OPTIONS, "PHP Flag Modifier"),
AP_INIT_TAKE2("php_admin_value", php_apache_admin_value_handler, NULL, ACCESS_CONF|RSRC_CONF, "PHP Value Modifier (Admin)"),
AP_INIT_TAKE2("php_admin_flag", php_apache_admin_flag_handler, NULL, ACCESS_CONF|RSRC_CONF, "PHP Flag Modifier (Admin)"),
AP_INIT_TAKE1("PHPINIDir", php_apache_phpini_set, NULL, RSRC_CONF, "Directory containing the php.ini file"),
{NULL}
};
static apr_status_t destroy_php_config(void *data)
{
php_conf_rec *d = data;
phpapdebug((stderr, "Destroying config %p\n", data));
zend_hash_destroy(&d->config);
return APR_SUCCESS;
}
void *create_php_config(apr_pool_t *p, char *dummy)
{
{
wiki_conf *c = (wiki_conf *) conf;
c->header = arg;
return NULL;
}
static const char *set_wiki_footer(cmd_parms * cmd, void *conf,
const char *arg)
{
wiki_conf *c = (wiki_conf *) conf;
c->footer = arg;
return NULL;
}
static const command_rec wiki_cmds[] = {
AP_INIT_TAKE1("WikiRepository", set_wiki_repo, NULL, OR_ALL,
"set Repository"),
AP_INIT_TAKE1("WikiName", set_wiki_name, NULL, OR_ALL,
"set WikiName"),
AP_INIT_TAKE1("WikiBasePath", set_wiki_basepath, NULL, OR_ALL,
"set Base Path"),
AP_INIT_TAKE1("WikiCSS", set_wiki_css, NULL, OR_ALL,
"set CSS"),
AP_INIT_TAKE1("WikiHeaderHtml", set_wiki_header, NULL, OR_ALL,
"set Header HTML"),
AP_INIT_TAKE1("WikiFooterHtml", set_wiki_footer, NULL, OR_ALL,
"set Footer HTML"),
{NULL}
};
static void wiki_register_hooks(apr_pool_t * p)
const char* makeOptions;
const char* includeFileTypes;
const char* excludeFileTypes;
// const char* excludeRegex;
const char* errorURI;
const char* errorCSS;
int debug;
} dir_cfg;
static const char* cfg_set_filetype(cmd_parms* cmd, void* cfg, const char* val);
static void* create_dir_conf(apr_pool_t* pool, char* x);
static void make_hooks(apr_pool_t *pool);
static const command_rec cmds[]={
AP_INIT_FLAG("Make", ap_set_flag_slot, (void*)APR_OFFSETOF(dir_cfg,onoff), OR_ALL,"Enable mod_make"),
AP_INIT_TAKE1("MakeSourceRoot", ap_set_string_slot, (void*)APR_OFFSETOF(dir_cfg,sourceRoot), OR_ALL,"Source root"),
AP_INIT_TAKE1("MakeFilename", ap_set_string_slot, (void*)APR_OFFSETOF(dir_cfg,makefileName), OR_ALL,"Make filename (i.e., Makefile)"),
AP_INIT_TAKE1("MakeProgram", ap_set_string_slot, (void*)APR_OFFSETOF(dir_cfg,makeProgram), OR_ALL,"Make binary"),
AP_INIT_TAKE1("MakeOptions", ap_set_string_slot, (void*)APR_OFFSETOF(dir_cfg,makeOptions), OR_ALL,"Make options"),
AP_INIT_ITERATE("MakeIncludeFileTypes", cfg_set_filetype, (void*)APR_OFFSETOF(dir_cfg,includeFileTypes),OR_ALL,"Include file types"),
AP_INIT_ITERATE("MakeExcludeFileTypes", cfg_set_filetype, (void*)APR_OFFSETOF(dir_cfg,excludeFileTypes),OR_ALL,"Exclude file types"),
// AP_INIT_TAKE1("MakeExcludeRegex", ap_set_string_slot, (void*)APR_OFFSETOF(dir_cfg,excludeRegex), OR_ALL,"Exclude regex"),
AP_INIT_TAKE1("MakeErrorURI", ap_set_string_slot, (void*)APR_OFFSETOF(dir_cfg,errorURI), OR_ALL,"Error URI"),
AP_INIT_TAKE1("MakeErrorCSS", ap_set_string_slot, (void*)APR_OFFSETOF(dir_cfg,errorCSS), OR_ALL,"Error CSS"),
AP_INIT_FLAG("MakeDebug", ap_set_flag_slot, (void*)APR_OFFSETOF(dir_cfg,debug), OR_ALL,"Enable mod_make debug mode"),
{NULL}
};
module AP_MODULE_DECLARE_DATA make_module = {
STANDARD20_MODULE_STUFF,
create_dir_conf,
conf->user = NULL;
conf->user_set = 0;
}
else {
conf->user = user;
conf->user_set = 1;
}
return NULL;
}
static const command_rec auth_env_cmds[] = {
AP_INIT_TAKE1("AuthEnvUser", add_env_user, NULL, OR_AUTHCFG,
"Specify the username to set REMOTE_USER"),
AP_INIT_FLAG("AuthEnvAuthoritative", set_authoritative, NULL, OR_AUTHCFG,
"Set to 'Off' to allow access control to be passed along"),
{ NULL }
};
static void *create_auth_env_dir_config(apr_pool_t *p, char *d)
{
auth_env_config_rec *conf = apr_pcalloc(p, sizeof(*conf));
/* Any failures are fatal. */
conf->authoritative = 1;
return conf;
}
static const char
*set_cache_maxfs(cmd_parms *parms, void *in_struct_ptr, const char *arg)
{
disk_cache_conf *conf = ap_get_module_config(parms->server->module_config,
&disk_cache_module);
if (apr_strtoff(&conf->maxfs, arg, NULL, 0) != APR_SUCCESS ||
conf->maxfs < 0)
{
return "CacheMaxFileSize argument must be a non-negative integer representing the max size of a file to cache in bytes.";
}
return NULL;
}
static const command_rec disk_cache_cmds[] =
{
AP_INIT_TAKE1("CacheRoot", set_cache_root, NULL, RSRC_CONF,
"The directory to store cache files"),
AP_INIT_TAKE1("CacheDirLevels", set_cache_dirlevels, NULL, RSRC_CONF,
"The number of levels of subdirectories in the cache"),
AP_INIT_TAKE1("CacheDirLength", set_cache_dirlength, NULL, RSRC_CONF,
"The number of characters in subdirectory names"),
AP_INIT_TAKE1("CacheMinFileSize", set_cache_minfs, NULL, RSRC_CONF,
"The minimum file size to cache a document"),
AP_INIT_TAKE1("CacheMaxFileSize", set_cache_maxfs, NULL, RSRC_CONF,
"The maximum file size to cache a document"),
{NULL}
};
static const cache_provider cache_disk_provider =
{
&remove_entity,
&store_headers,
}
static const char *set_dbm_type(cmd_parms *cmd,
void *dir_config,
const char *arg)
{
dbm_auth_config_rec *conf = dir_config;
conf->auth_dbmtype = apr_pstrdup(cmd->pool, arg);
return NULL;
}
static const command_rec dbm_auth_cmds[] =
{
AP_INIT_TAKE1("AuthDBMUserFile", ap_set_file_slot,
(void *)APR_OFFSETOF(dbm_auth_config_rec, auth_dbmpwfile),
OR_AUTHCFG, "dbm database file containing user IDs and passwords"),
AP_INIT_TAKE1("AuthDBMGroupFile", ap_set_file_slot,
(void *)APR_OFFSETOF(dbm_auth_config_rec, auth_dbmgrpfile),
OR_AUTHCFG, "dbm database file containing group names and member user IDs"),
AP_INIT_TAKE12("AuthUserFile", set_dbm_slot,
(void *)APR_OFFSETOF(dbm_auth_config_rec, auth_dbmpwfile),
OR_AUTHCFG, NULL),
AP_INIT_TAKE12("AuthGroupFile", set_dbm_slot,
(void *)APR_OFFSETOF(dbm_auth_config_rec, auth_dbmgrpfile),
OR_AUTHCFG, NULL),
AP_INIT_TAKE1("AuthDBMType", set_dbm_type,
NULL,
OR_AUTHCFG, "what type of DBM file the user file is"),
AP_INIT_FLAG("AuthDBMAuthoritative", ap_set_flag_slot,
(void *)APR_OFFSETOF(dbm_auth_config_rec, auth_dbmauthoritative),
static const char* osrfHttpTranslatorGetConfigFile(cmd_parms *parms, void *config, const char *arg) {
configFile = (char*) arg;
return NULL;
}
static const char* osrfHttpTranslatorGetConfigFileCtx(cmd_parms *parms, void *config, const char *arg) {
configCtx = (char*) arg;
return NULL;
}
static const char* osrfHttpTranslatorGetCacheServer(cmd_parms *parms, void *config, const char *arg) {
cacheServers = (char*) arg;
return NULL;
}
/** set up the configuration handlers */
static const command_rec osrfHttpTranslatorCmds[] = {
AP_INIT_TAKE1( OSRF_TRANSLATOR_CONFIG_FILE, osrfHttpTranslatorGetConfigFile,
NULL, RSRC_CONF, "osrf translator config file"),
AP_INIT_TAKE1( OSRF_TRANSLATOR_CONFIG_CTX, osrfHttpTranslatorGetConfigFileCtx,
NULL, RSRC_CONF, "osrf translator config file context"),
AP_INIT_TAKE1( OSRF_TRANSLATOR_CACHE_SERVER, osrfHttpTranslatorGetCacheServer,
NULL, RSRC_CONF, "osrf translator cache server"),
{NULL}
};
// there can only be one, so use a global static one
static osrfHttpTranslator globalTranslator;
/*
* Constructs a new translator object based on the current apache
* request_rec. Reads the request body and headers.
*/
}
ap_log_rerror(APLOG_MARK, APLOG_INFO|APLOG_NOERRNO, 0, r,
conn->proxy_ips
? "Using %s as client's IP by proxies %s"
: "Using %s as client's IP by internal proxies",
conn->proxied_ip, conn->proxy_ips);
return OK;
}
static const command_rec reverseproxy_cmds[] =
{
AP_INIT_FLAG("ReverseProxyEnable", reveseproxy_enable, NULL, RSRC_CONF,
"Enable mod_reverseproxy"),
AP_INIT_TAKE1("ReverseProxyRemoteIPHeader", header_name_set, NULL, RSRC_CONF,
"Specifies a request header to trust as the client IP, "
"Overrides the default one"),
AP_INIT_ITERATE("ReverseProxyRemoteIPTrusted", proxies_set, 0, RSRC_CONF,
"Specifies one or more proxies which are trusted "
"to present IP headers. Overrides the defaults."),
{ NULL }
};
static void register_hooks(apr_pool_t *p)
{
// We need to run very early so as to not trip up mod_security.
// Hence, this little trick, as mod_security runs at APR_HOOK_REALLY_FIRST.
ap_hook_post_read_request(reverseproxy_modify_connection, NULL, NULL, APR_HOOK_REALLY_FIRST - 10);
}
module AP_MODULE_DECLARE_DATA reverseproxy_module = {
rpaf_setport,
NULL,
RSRC_CONF,
"Let mod_rpaf set the server port from the X-Port header"
),
AP_INIT_ITERATE(
"RPAF_ProxyIPs",
rpaf_set_proxy_ip,
NULL,
RSRC_CONF,
"IP(s) of Proxy server setting X-Forwarded-For header"
),
AP_INIT_TAKE1(
"RPAF_Header",
rpaf_set_headername,
NULL,
RSRC_CONF,
"Which header to look for when trying to find the real ip of the client in a proxy setup"
),
{ NULL }
};
static void register_hooks(apr_pool_t *p) {
ap_hook_post_read_request(change_remote_ip, NULL, NULL, APR_HOOK_FIRST);
}
module AP_MODULE_DECLARE_DATA rpaf_module = {
STANDARD20_MODULE_STUFF,
NULL,
NULL,
rpaf_create_server_cfg,
hp.expire = atoi(arg);
}
return NULL;
}
static const char *debug_hostprotect(cmd_parms *cmd, void *cfg, const char arg[])
{
if(arg != NULL && !strncmp(arg, "On", 2)) {
hp.debug = 1;
}
return NULL;
}
static const command_rec hostprotect_module_directives[] =
{
AP_INIT_TAKE1("HostProtect", enable_hostprotect, NULL, RSRC_CONF, "Enable/Disable HostProtect module."),
AP_INIT_TAKE1("HostProtectResolver", resolver_hostprotect, NULL, RSRC_CONF, "Set resolver IP for HostProtect module."),
AP_INIT_TAKE1("HostProtectPurger", purger_hostprotect, NULL, RSRC_CONF, "Set IP which can purge data from cache."),
AP_INIT_TAKE1("HostProtectDebug", debug_hostprotect, NULL, RSRC_CONF, "Enable/Disable debug level."),
AP_INIT_TAKE1("HostProtectExpire", expire_hostprotect, NULL, RSRC_CONF, "Set expire time of cache."),
{NULL}
};
module AP_MODULE_DECLARE_DATA hostprotect_module = {
STANDARD20_MODULE_STUFF,
NULL, /* create per-dir config structures */
NULL, /* merge per-dir config structures */
NULL, /* create per-server config structures */
NULL, /* merge per-server config structures */
hostprotect_module_directives, /* table of config file commands */
hostprotect_module_register_hooks /* register hooks */
}
static void *create_authz_dbm_dir_config(apr_pool_t *p, char *d)
{
authz_dbm_config_rec *conf = apr_palloc(p, sizeof(*conf));
conf->grpfile = NULL;
conf->dbmtype = "default";
return conf;
}
static const command_rec authz_dbm_cmds[] =
{
AP_INIT_TAKE1("AuthDBMGroupFile", ap_set_file_slot,
(void *)APR_OFFSETOF(authz_dbm_config_rec, grpfile),
OR_AUTHCFG, "database file containing group names and member user IDs"),
AP_INIT_TAKE1("AuthzDBMType", ap_set_string_slot,
(void *)APR_OFFSETOF(authz_dbm_config_rec, dbmtype),
OR_AUTHCFG, "what type of DBM file the group file is"),
{NULL}
};
module AP_MODULE_DECLARE_DATA authz_dbm_module;
/* We do something strange with the group file. If the group file
* contains any : we assume the format is
* key=username value=":"groupname [":"anything here is ignored]
* otherwise we now (0.8.14+) assume that the format is
* key=username value=groupname
* The first allows the password and group files to be the same
NULL,
RSRC_CONF | ACCESS_CONF | OR_FILEINFO,
"Inherit main server configurations or not. Only affect TrigerContentType, TrigerHTML, and TrigerCheckLength."),
AP_INIT_FLAG("TrigerFullCheck",
set_full_chk,
NULL,
RSRC_CONF | ACCESS_CONF | OR_FILEINFO,
"Search each data bucket while no more than TrigerCheckLength, default is only check the first and last data buckets."),
AP_INIT_ITERATE("TrigerContentType",
set_ctypes,
NULL,
RSRC_CONF | ACCESS_CONF | OR_FILEINFO,
"Which types response that we will inject our HTML fragment, default are 'text/html' and 'application/xhtml+xml'."),
AP_INIT_TAKE1("TrigerHTML",
set_js,
NULL,
RSRC_CONF | ACCESS_CONF | OR_FILEINFO,
"HTML fragment that Triger will insert into responses bodies after <head> tag or before </body> tag, or simple at the end if neither tags found."),
AP_INIT_TAKE1("TrigerCheckLength",
set_chk_len,
NULL,
RSRC_CONF | ACCESS_CONF | OR_FILEINFO,
"How long contents we check to find tags so we know where to innsert our js coedes, f.g., <head> and </body>. Default is 256."),
{
NULL}
};
module AP_MODULE_DECLARE_DATA triger_module = {
STANDARD20_MODULE_STUFF,
create_triger_dir_config,
merge_triger_dir_config,
