(void *) APR_OFFSETOF(pg_auth_config_rec,
										auth_pg_grp_table), OR_AUTHCFG,
				  "the name of the table containing username/group tuples."),
	AP_INIT_TAKE1("Auth_PG_grp_group_field", ap_set_string_slot,
				  (void *) APR_OFFSETOF(pg_auth_config_rec,
										auth_pg_grp_group_field),
				  OR_AUTHCFG,
				  "the name of the group-name field."),
	AP_INIT_TAKE1("Auth_PG_grp_user_field", ap_set_string_slot,
				  (void *) APR_OFFSETOF(pg_auth_config_rec,
										auth_pg_grp_user_field),
				  OR_AUTHCFG,
				  "the name of the group-name field."),
	AP_INIT_FLAG("Auth_PG_nopasswd", ap_set_flag_slot,
				 (void *) APR_OFFSETOF(pg_auth_config_rec,
									   auth_pg_nopasswd),
				 OR_AUTHCFG,
				 "'on' or 'off'"),
	AP_INIT_FLAG("Auth_PG_encrypted", ap_set_flag_slot,
				 (void *) APR_OFFSETOF(pg_auth_config_rec,
									   auth_pg_encrypted),
				 OR_AUTHCFG,
				 "'on' or 'off'"),
	AP_INIT_TAKE1("Auth_PG_hash_type", pg_set_hash_type, NULL, OR_AUTHCFG,
				  "password hash type (CRYPT|MD5|BASE64|NETEPI)."),
	AP_INIT_FLAG("Auth_PG_netepi_old_passwords", ap_set_flag_slot,
				 (void *) APR_OFFSETOF(pg_auth_config_rec,
									   auth_pg_netepi_old_passwords),
				 OR_AUTHCFG,
				 "'on' or 'off'"),
	AP_INIT_FLAG("Auth_PG_cache_passwords", ap_set_flag_slot,

        ls->interval = APR_USEC_PER_SEC * (apr_time_t) atol(inte);
        if (ls->interval < INTERVAL_MIN) {
            ls->interval = INTERVAL_MIN;
        }
    }

    if (NULL != offs) {
        /* Offset in minutes */
        ls->offset = APR_USEC_PER_SEC * 60 * (apr_time_t) atol(offs);
    }

    return NULL;
}

static const command_rec rotate_log_cmds[] = {
    AP_INIT_FLAG(  "RotateLogs", set_rotated_logs, NULL, RSRC_CONF,
                   "Enable rotated logging"),
    AP_INIT_FLAG(  "RotateLogsLocalTime", set_localtime, NULL, RSRC_CONF,
                   "Rotate relative to local time"),
    AP_INIT_TAKE12("RotateInterval", set_interval, NULL, RSRC_CONF,
                   "Set rotation interval in seconds with"
                   " optional offset in minutes"),
    {NULL}
};

static void *make_log_options(apr_pool_t *p, server_rec *s) {
    log_options *ls;

    ls = (log_options *) apr_palloc(p, sizeof(log_options));
    ls->enabled     = 1;
    ls->interval    = INTERVAL_DEFAULT;
    ls->offset      = 0;

                    r->server->port    = atoi(portvalue);
                    r->parsed_uri.port = r->server->port;
                } else {
                    r->server->port = cfg->orig_port;
                }
            }
        }
    }
    return DECLINED;
}

static const command_rec rpaf_cmds[] = {
    AP_INIT_FLAG(
                 "RPAF_Enable",
                 rpaf_enable,
                 NULL,
                 RSRC_CONF,
                 "Enable mod_rpaf"
                 ),
    AP_INIT_FLAG(
                 "RPAF_SetHostName",
                 rpaf_sethostname,
                 NULL,
                 RSRC_CONF,
                 "Let mod_rpaf set the hostname from the X-Host header and update vhosts"
                 ),
    AP_INIT_FLAG(
                 "RPAF_SetHTTPS",
                 rpaf_sethttps,
                 NULL,
                 RSRC_CONF,

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

    dir->enabled= 0;
    dir->authoritative= 1;	/* strong by default */

    return dir;
}


/*
 * Config file commands that this module can handle
 */

static const command_rec authz_unixgroup_cmds[] =
{
    AP_INIT_FLAG("AuthzUnixgroup",
	ap_set_flag_slot,
	(void *)APR_OFFSETOF(authz_unixgroup_dir_config_rec, enabled),
	OR_AUTHCFG,
	"Set to 'on' to enable unix group checking"),

    AP_INIT_FLAG("AuthzUnixgroupAuthoritative",
	ap_set_flag_slot,
	(void *)APR_OFFSETOF(authz_unixgroup_dir_config_rec, authoritative),
	OR_AUTHCFG,
	"Set to 'off' to allow access control to be passed along to lower "
	    "modules if this module can't confirm access rights" ),

    { NULL }
};


/* Check if the named user is in the given list of groups.  The list of

     (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),
     OR_AUTHCFG, "Set to 'no' to allow access control to be passed along to lower modules, if the UserID is not known in this module"),
    {NULL}
};

module AP_MODULE_DECLARE_DATA auth_dbm_module;

static char *get_dbm_pw(request_rec *r, 
                        char *user, 
                        char *auth_dbmpwfile, 
                        char *dbtype)
{
    apr_dbm_t *f;
    apr_datum_t d, q;
    char *pw = NULL;
    apr_status_t retval;

        if (config->proxies_header_name)
            apr_table_setn(r->headers_in, config->proxies_header_name,
                           conn->proxy_ips);
    }

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

                    apr_table_set(r->headers_in, "Host", apr_pstrdup(r->pool, hostvalue));
                    r->hostname = apr_pstrdup(r->pool, hostvalue);
                    ap_update_vhost_from_headers(r);
                }
            }

        }
    }
    return DECLINED;
}

static const command_rec rpaf_cmds[] = {
    AP_INIT_FLAG(
                 "RPAFenable",
                 rpaf_enable,
                 NULL,
                 RSRC_CONF,
                 "Enable mod_rpaf"
                 ),
    AP_INIT_FLAG(
                 "RPAFsethostname",
                 rpaf_sethostname,
                 NULL,
                 RSRC_CONF,
                 "Let mod_rpaf set the hostname from X-Host header and update vhosts"
                 ),
    AP_INIT_ITERATE(
                    "RPAFproxy_ips",
                    rpaf_set_proxy_ip,
                    NULL,
                    RSRC_CONF,

    ctype = apr_array_push(cfg->ctypes);
    ctype->data = apr_pstrdup(pool, line);

    return NULL;
}

static void register_hooks(apr_pool_t * pool)
{
    ap_register_output_filter(triger_filter_name,
			      triger_filter, NULL, AP_FTYPE_RESOURCE);
}

static const command_rec triger_cmds[] = {
    AP_INIT_FLAG("TrigerEnable",
		 set_enabled,
		 NULL,
		 RSRC_CONF | ACCESS_CONF | OR_FILEINFO,
		 "Enable/Disable the Triger output filter"),
    AP_INIT_FLAG("TrigerInherit",
		 set_inherit,
		 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,

    config->plugin_paths        = strlen(override->plugin_paths) ?
                                   override->plugin_paths :
                                   base->plugin_paths;

    config->precision           = (override->precision > 0) ?
                                   override->precision :
                                   base->precision;

    return (void *)config;
}

/* Commands */
static const command_rec sass_cmds[] =
{
    AP_INIT_FLAG("SassSaveOutput", ap_set_flag_slot,
                 (void *)APR_OFFSETOF(sass_dir_config_t, save_output),
                 RSRC_CONF|ACCESS_CONF, "Save CSS/source map output to file"),
    AP_INIT_FLAG("SassDisplayError", ap_set_flag_slot,
                 (void *)APR_OFFSETOF(sass_dir_config_t, display_error),
                 RSRC_CONF|ACCESS_CONF, "Display errors in the browser"),
    AP_INIT_TAKE1("SassOutputStyle", ap_set_string_slot,
                 (void *)APR_OFFSETOF(sass_dir_config_t, output_style),
                 RSRC_CONF|ACCESS_CONF, "Output style for the generated css code (Expanded | Nested | Compact | Compressed)"),
    AP_INIT_FLAG("SassSourceComments", ap_set_flag_slot,
                 (void *)APR_OFFSETOF(sass_dir_config_t, source_comments),
                 RSRC_CONF|ACCESS_CONF, "If you want inline source comments"),
    AP_INIT_FLAG("SassSourceMap", ap_set_flag_slot,
                 (void *)APR_OFFSETOF(sass_dir_config_t, source_map),
                 RSRC_CONF|ACCESS_CONF, "Generate a source map"),
    AP_INIT_FLAG("SassOmitSourceMapUrl", ap_set_flag_slot,
                 (void *)APR_OFFSETOF(sass_dir_config_t, omit_source_map_url),

    ap_hook_check_user_id(mod_stlog_check_user_id, NULL, NULL, APR_HOOK_MIDDLE);
    ap_hook_type_checker(mod_stlog_type_checker, NULL, NULL, APR_HOOK_MIDDLE);
    ap_hook_access_checker(mod_stlog_access_checker, NULL, NULL, APR_HOOK_MIDDLE);
    ap_hook_auth_checker(mod_stlog_auth_checker, NULL, NULL, APR_HOOK_MIDDLE);
    ap_hook_insert_filter(mod_stlog_insert_filter, NULL, NULL, APR_HOOK_MIDDLE);
    ap_hook_fixups(mod_stlog_fixups, NULL, NULL, APR_HOOK_MIDDLE);
    ap_hook_quick_handler(mod_stlog_quick_handler, NULL, NULL, APR_HOOK_FIRST);
    ap_hook_handler(mod_stlog_handler, NULL, NULL, APR_HOOK_REALLY_FIRST);
    ap_hook_log_transaction(mod_stlog_log_transaction, NULL, NULL, APR_HOOK_MIDDLE);
    //ap_hook_error_log(mod_stlog_error_log, NULL, NULL, APR_HOOK_MIDDLE);
}

static const command_rec mod_stlog_cmds[] = {

    AP_INIT_TAKE1("DumpRequestLog", set_stlog_logname, NULL, RSRC_CONF | ACCESS_CONF, "Dumping log name."),
    AP_INIT_FLAG("DumpPostReadRequest", set_stlog_post_read_request, NULL, RSRC_CONF | ACCESS_CONF, "hook for post_read_request phase."),
    AP_INIT_FLAG("DumpTranslateName", set_stlog_translate_name, NULL, RSRC_CONF | ACCESS_CONF, "hook for translate_name phase."),
    AP_INIT_FLAG("DumpMapToStorage", set_stlog_map_to_storage, NULL, RSRC_CONF | ACCESS_CONF, "hook for map_to_storage phase."),
    AP_INIT_FLAG("DumpCheckUserId", set_stlog_check_user_id, NULL, RSRC_CONF | ACCESS_CONF, "hook for check_user_id phase."),
    AP_INIT_FLAG("DumpTypeChecker", set_stlog_type_checker, NULL, RSRC_CONF | ACCESS_CONF, "hook for type_checker phase."),
    AP_INIT_FLAG("DumpAccessChecker", set_stlog_access_checker, NULL, RSRC_CONF | ACCESS_CONF, "hook for access_checker phase."),
    AP_INIT_FLAG("DumpAuthChecker", set_stlog_auth_checker, NULL, RSRC_CONF | ACCESS_CONF, "hook for auth_checker phase."),
    AP_INIT_FLAG("DumpInsertFilter", set_stlog_insert_filter, NULL, RSRC_CONF | ACCESS_CONF, "hook for insert_filter phase."),
    AP_INIT_FLAG("DumpFixups", set_stlog_fixups, NULL, RSRC_CONF | ACCESS_CONF, "hook for fixups phase."),
    AP_INIT_FLAG("DumpQuickHandler", set_stlog_quick_handler, NULL, RSRC_CONF | ACCESS_CONF, "hook for quick_handler phase."),
    AP_INIT_FLAG("DumpHandler", set_stlog_handler, NULL, RSRC_CONF | ACCESS_CONF, "hook for handler phase."),
    AP_INIT_FLAG("DumpLogTransaction", set_stlog_log_transaction, NULL, RSRC_CONF | ACCESS_CONF, "hook for log_transaction phase."),
    //AP_INIT_FLAG("DumpErrorLog", set_stlog_error_log, NULL, RSRC_CONF | ACCESS_CONF, "hook for error_log phase."),
    {NULL}
};

  if (XSENDFILE_ENABLED != enabled) {
    return;
  }

  ap_add_output_filter(
    "XSENDFILE",
    NULL,
    r,
    r->connection
	  );
}
static const command_rec xsendfile_command_table[] = {
  AP_INIT_FLAG(
    "XSendFile",
    xsendfile_cmd_flag,
    NULL,
    OR_FILEINFO,
    "On|Off - Enable/disable(default) processing"
    ),
  AP_INIT_FLAG(
    "XSendFileIgnoreEtag",
    xsendfile_cmd_flag,
    NULL,
    OR_FILEINFO,
    "On|Off - Ignore script provided Etag headers (default: Off)"
    ),
  AP_INIT_FLAG(
    "XSendFileIgnoreLastModified",
    xsendfile_cmd_flag,
    NULL,
    OR_FILEINFO,

command_rec mod_vhost_ldap_cmds[] = {
	AP_INIT_TAKE1("VhostLDAPURL", mod_vhost_ldap_parse_url, NULL, RSRC_CONF,
					"URL to define LDAP connection.\n"),
	AP_INIT_TAKE1 ("VhostLDAPBaseDN", mod_vhost_ldap_set_basedn, NULL, RSRC_CONF,	"LDAP Hostname."),
	AP_INIT_TAKE1 ("VhostLDAPSearchScope", mod_vhost_ldap_set_searchscope, NULL, RSRC_CONF,
					"LDAP Hostname."),
	AP_INIT_TAKE1 ("VhostLDAPFilter", mod_vhost_ldap_set_filter, NULL, RSRC_CONF,
					"LDAP Hostname."),
				
	AP_INIT_TAKE1 ("VhostLDAPBindDN", mod_vhost_ldap_set_binddn, NULL, RSRC_CONF,
					"DN to use to bind to LDAP server. If not provided, will do an anonymous bind."),

	AP_INIT_TAKE1("VhostLDAPBindPassword", mod_vhost_ldap_set_bindpw, NULL, RSRC_CONF,
					"Password to use to bind to LDAP server. If not provided, will do an anonymous bind."),

	AP_INIT_FLAG("VhostLDAPEnabled", mod_vhost_ldap_set_enabled, NULL, RSRC_CONF,
					"Set to off to disable vhost_ldap, even if it's been enabled in a higher tree"),

	AP_INIT_TAKE1("VhostLDAPFallbackName", mod_vhost_ldap_set_fallback_name, NULL, RSRC_CONF,
					"Set default virtual host which will be used when requested hostname"
					"is not found in LDAP database. This option can be used to display"
					"\"virtual host not found\" type of page."),
	AP_INIT_TAKE1("VhostLDAPFallbackDocumentRoot", mod_vhost_ldap_set_fallback_docroot, NULL, RSRC_CONF,
					"Set default virtual host Document Root which will be used when requested hostname"
					"is not found in LDAP database. This option can be used to display"
					"\"virtual host not found\" type of page."),
	AP_INIT_TAKE1("VhostLDAProotdir", mod_vhost_ldap_set_rootdir, NULL, RSRC_CONF, "Configurable rootDir for vhosts"),
	AP_INIT_TAKE1("phpIncludePath",mod_vhost_ldap_set_phpincludepath, NULL, RSRC_CONF, "php include_path configuration for vhost"),
	{NULL}
};

static int ldapconnect(LDAP **ldapconn, mod_vhost_ldap_config_t *conf)

    } else {
        return apr_psprintf(cmd->pool, "No such variable %s", name);
    }

    return NULL;
}

/* ********************************************

    Configuration options

   ******************************************** */

static const command_rec commands[] = {
    AP_INIT_FLAG( "QS2Cookie",              set_config_enable,  NULL, OR_FILEINFO,
                  "whether or not to enable querystring to cookie module"),
    AP_INIT_FLAG( "QS2CookieEnableIfDNT",   set_config_enable,  NULL, OR_FILEINFO,
                  "whether or not to enable cookies if 'X-DNT' header is present"),
    AP_INIT_FLAG( "QS2CookieEncodeInKey",   set_config_enable,  NULL, OR_FILEINFO,
                  "rather than encoding the pairs in the value, encode them in the key"),
    AP_INIT_TAKE1("QS2CookieExpires",       set_config_value,   NULL, OR_FILEINFO,
                  "expiry time for the cookie, in seconds after the request is served"),
    AP_INIT_TAKE1("QS2CookieDomain",        set_config_value,   NULL, OR_FILEINFO,
                  "domain to which this cookie applies"),
    AP_INIT_TAKE1("QS2CookieMaxSize",       set_config_value,   NULL, OR_FILEINFO,
                  "maximum size to allow for all the key/value pairs in this request"),
    AP_INIT_TAKE1("QS2CookiePrefix",        set_config_value,   NULL, OR_FILEINFO,
                  "prefix all cookie keys with this string"),
    AP_INIT_TAKE1("QS2CookieName",          set_config_value,   NULL, OR_FILEINFO,
                  "this will be the cookie name, unless QS2CookieNameFrom is set"),
    AP_INIT_TAKE1("QS2CookieNameFrom",      set_config_value,   NULL, OR_FILEINFO,

    conf->etag_response = arg;

    return NULL;
}

/* cmd callbacks */
static const command_rec caldav_cmds[] =
{
    DIRECTIVE("MinDateTime",  min_date_time, "Minumum datetime")
    DIRECTIVE("MaxDateTime",  max_date_time, "Maximum datetime")
    DIRECTIVE("MaxInstances", max_instances, "Maximum instances")
    DIRECTIVE("MaxAttendeesPerInstance", max_attendees_per_instance,
		"Maximum attendees per instance")

    /* per directory/location, or per server */
    AP_INIT_FLAG("CalQueryETagResponse", etag_response, NULL,
		 OR_OPTIONS, "response with ETag for calendar-query"),
    { NULL }
};

/** store resource type for a calendar collection */
static int caldav_store_resource_type(request_rec *r,
                                      const dav_resource *resource)
{
    dav_db *db;
    dav_namespace_map *map = NULL;
    dav_prop_name restype[1] = { { NS_DAV, "resourcetype" } };
    apr_xml_elem el_child[1] = { { 0 } };
    apr_text text = { 0 };
    apr_array_header_t *ns;
    const dav_provider *provider = dav_lookup_provider(DAV_DEFAULT_PROVIDER);
    const dav_hooks_propdb *db_hooks = provider ? provider->propdb : NULL;

	 (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),
     OR_AUTHCFG, "Limited to 'on' or 'off'"),
    AP_INIT_FLAG("AuthCookieBase64", ap_set_flag_slot,
     (void *)APR_OFFSETOF(cookie_auth_config_rec, cookie_auth_base64),
     OR_AUTHCFG, "Limited to 'on' or 'off'"),
    {NULL}
};

module AP_MODULE_DECLARE_DATA auth_cookie_module;

static int check_auth_cookie(request_rec *r)
{

	const char *cookies = NULL, *auth_line = NULL;
	char *cookie = NULL;

    }
    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 void *merge_auth_env_dir_config(apr_pool_t *p, void *basev, void *overridesv)

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

/*
 * Respond to a callback to create a config record for a specific directory.
 */
static void *create_mconfig_for_directory(apr_pool_t *p, char *dir)
{
    return mkconfig(p);
}

/*
 * Define the directives specific to this module.  This structure is referenced
 * later by the 'module' structure.
 */
static const command_rec speling_cmds[] =
{
    AP_INIT_FLAG("CheckSpelling", ap_set_flag_slot,
                  (void*)APR_OFFSETOF(spconfig, enabled), OR_OPTIONS,
                 "whether or not to fix miscapitalized/misspelled requests"),
    AP_INIT_FLAG("CheckCaseOnly", ap_set_flag_slot,
                  (void*)APR_OFFSETOF(spconfig, check_case_only), OR_OPTIONS,
                 "whether or not to fix only miscapitalized requests"),
    AP_INIT_FLAG("CheckBasenameMatch", ap_set_flag_slot,
                  (void*)APR_OFFSETOF(spconfig, check_basename_match), OR_OPTIONS,
                 "whether or not to fix files with the same base name"),
    { NULL }
};

typedef enum {
    SP_IDENTICAL = 0,
    SP_MISCAPITALIZED = 1,
    SP_TRANSPOSITION = 2,
    SP_MISSINGCHAR = 3,

static const char *mag_deleg_ccache_dir(cmd_parms *parms, void *mconfig,
                                        const char *value)
{
    struct mag_config *cfg = (struct mag_config *)mconfig;

    cfg->deleg_ccache_dir = apr_pstrdup(parms->pool, value);
    if (!cfg->deleg_ccache_dir) {
        ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, parms->server,
                     "%s", "OOM handling GssapiDelegCcacheDir option");
    }

    return NULL;
}

static const command_rec mag_commands[] = {
    AP_INIT_FLAG("GssapiSSLonly", mag_ssl_only, NULL, OR_AUTHCFG,
                  "Work only if connection is SSL Secured"),
    AP_INIT_FLAG("GssapiLocalName", mag_map_to_local, NULL, OR_AUTHCFG,
                  "Translate principals to local names"),
    AP_INIT_FLAG("GssapiConnectionBound", mag_conn_ctx, NULL, OR_AUTHCFG,
                  "Authentication is bound to the TCP connection"),
    AP_INIT_FLAG("GssapiUseSessions", mag_use_sess, NULL, OR_AUTHCFG,
                  "Authentication uses mod_sessions to hold status"),
    AP_INIT_RAW_ARGS("GssapiSessionKey", mag_sess_key, NULL, OR_AUTHCFG,
                     "Key Used to seal session data."),
#ifdef HAVE_GSS_ACQUIRE_CRED_FROM
    AP_INIT_FLAG("GssapiUseS4U2Proxy", mag_use_s4u2p, NULL, OR_AUTHCFG,
                  "Initializes credentials for s4u2proxy usage"),
#endif
#ifdef HAVE_GSS_STORE_CRED_INTO
    AP_INIT_ITERATE("GssapiCredStore", mag_cred_store, NULL, OR_AUTHCFG,
                    "Credential Store"),