/*

 *

 *   auth_mellon_config.c: an authentication apache module

 *   Copyright © 2003-2007 UNINETT (http://www.uninett.no/)

 *

 *   This program is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation; either version 2 of the License, or

 *   (at your option) any later version.

 *

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 * 

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the Free Software

 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "auth_mellon.h"

#ifdef APLOG_USE_MODULE

APLOG_USE_MODULE(auth_mellon);

#endif

/* This is the default endpoint path. Remember to update the description of

 * the MellonEndpointPath configuration directive if you change this.

 */

static const char *default_endpoint_path = "/mellon/";

/* This is the default name of the attribute we use as a username. Remember

 * to update the description of the MellonUser configuration directive if

 * you change this.

 */

static const char *default_user_attribute = "NAME_ID";

/* This is the default prefix to use for attributes received from the

 * server. Customizable using the MellonEnvPrefix option

 */

static const char *default_env_prefix = "MELLON_";

/* This is the default name of the cookie which mod_auth_mellon will set.

 * If you change this, then you should also update the description of the

 * MellonVar configuration directive.

 */

static const char *default_cookie_name = "cookie";

/* The default setting for cookie is to not enforce secure flag

 */

static const int default_secure_cookie = 0; 

/* The default setting for cookie is to not enforce HttpOnly flag

 */

static const int default_http_only_cookie = 0;

/* The default setting for setting MELLON_SESSION

 */

static const int default_dump_session = 0; 

/* The default setting for setting MELLON_SAML_RESPONSE

 */

static const int default_dump_saml_response = 0; 

/* This is the default IdP initiated login location

 * the MellonDefaultLoginPath configuration directive if you change this.

 */

static const char *default_login_path = "/";

/* saved POST session time to live

 * the MellonPostTTL configuration directive if you change this.

 */

static const apr_time_t post_ttl = 15 * 60;

/* saved POST session maximum size

 * the MellonPostSize configuration directive if you change this.

 */

static const apr_size_t post_size = 1024 * 1024;

/* maximum saved POST sessions

 * the MellonPostCount configuration directive if you change this.

 */

static const int post_count = 100;

#ifdef ENABLE_DIAGNOSTICS

/* Default filename for mellon diagnostics log file.

 * Relative pathname is relative to server root. */

static const char *default_diag_filename = "logs/mellon_diagnostics";

/* Default state for diagnostics is off */

static am_diag_flags_t default_diag_flags = AM_DIAG_FLAG_DISABLE;

#endif

/* whether to merge env. vars or not

 * the MellonMergeEnvVars configuration directive if you change this.

 */

static const char *default_merge_env_vars = NULL;

/* for env. vars with multiple values, the index start

 * the MellonEnvVarsIndexStart configuration directive if you change this.

 */

static const int default_env_vars_index_start = -1;

/* whether to also populate env. var _N with number of values

 * the MellonEnvVarsSetCount configuration directive if you change this.

 */

static const int default_env_vars_count_in_n = -1;

/* The default list of trusted redirect domains. */

static const char * const default_redirect_domains[] = { "[self]", NULL };

/* This function handles configuration directives which set a 

 * multivalued string slot in the module configuration (the destination

 * strucure is a hash).

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *  const char *key      The string argument following this configuration

 *                       directive in the configuraion file.

 *  const char *value    Optional value to be stored in the hash.

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_hash_string_slot(cmd_parms *cmd,

                                          void *struct_ptr,

                                          const char *key,

                                          const char *value)

{

    server_rec *s = cmd->server;

    apr_pool_t *pconf = s->process->pconf;

    am_dir_cfg_rec *cfg = (am_dir_cfg_rec *)struct_ptr;

    int offset;

    apr_hash_t **hash;

    /*

     * If no value is given, we just store the key in the hash.

     */

    if (value == NULL || *value == '\0')

        value = key;

    offset = (int)(long)cmd->info;

    hash = (apr_hash_t **)((char *)cfg + offset);

    apr_hash_set(*hash, apr_pstrdup(pconf, key), APR_HASH_KEY_STRING, value);

    return NULL;

}

/* This function handles configuration directives which set a 

 * multivalued string slot in the module configuration (the destination

 * strucure is a table).

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *  const char *key      The string argument following this configuration

 *                       directive in the configuraion file.

 *  const char *value    Optional value to be stored in the hash.

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_table_string_slot(cmd_parms *cmd,

                                          void *struct_ptr,

                                          const char *key,

                                          const char *value)

{

    server_rec *s = cmd->server;

    apr_pool_t *pconf = s->process->pconf;

    am_dir_cfg_rec *cfg = (am_dir_cfg_rec *)struct_ptr;

    int offset;

    apr_table_t **table;

    /*

     * If no value is given, we just store the key in the hash.

     */

    if (value == NULL || *value == '\0')

        value = key;

    offset = (int)(long)cmd->info;

    table = (apr_table_t **)((char *)cfg + offset);

    apr_table_set(*table, apr_pstrdup(pconf, key), value);

    return NULL;

}

/* This function handles configuration directives which set a file slot

 * in the module configuration. The file contents are immediately read.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *                       This value isn't used by this function.

 *  const char *arg      The string argument following this configuration

 *                       directive in the configuraion file.

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_file_contents_slot(cmd_parms *cmd,

                                          void *struct_ptr,

                                          const char *arg)

{

    const char *path;

    apr_status_t rv;

    am_dir_cfg_rec *cfg = (am_dir_cfg_rec *)struct_ptr;

    int offset;

    am_file_data_t **p_file_data, *file_data;

    path = ap_server_root_relative(cmd->pool, arg);

    if (!path) {

        return apr_pstrcat(cmd->pool, cmd->cmd->name,

                           ": Invalid file path ", arg, NULL);

    }

    offset = (int)(long)cmd->info;

    p_file_data = (am_file_data_t **)((char *)cfg + offset);

    *p_file_data = am_file_data_new(cmd->pool, path);

    file_data = *p_file_data;

    rv = am_file_read(file_data);

    if (rv != APR_SUCCESS) {

        return file_data->strerror;

    }

    return NULL;

}

/* This function handles configuration directives which set a file

 * pathname in the module configuration. The file is checked for

 * existence.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *                       This value isn't used by this function.

 *  const char *arg      The string argument following this configuration

 *                       directive in the configuraion file.

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_file_pathname_slot(cmd_parms *cmd,

                                             void *struct_ptr,

                                             const char *arg)

{

    const char *path;

    apr_status_t rv;

    am_dir_cfg_rec *cfg = (am_dir_cfg_rec *)struct_ptr;

    int offset;

    am_file_data_t **p_file_data, *file_data;

    path = ap_server_root_relative(cmd->pool, arg);

    if (!path) {

        return apr_pstrcat(cmd->pool, cmd->cmd->name,

                           ": Invalid file_data path ", arg, NULL);

    }

    offset = (int)(long)cmd->info;

    p_file_data = (am_file_data_t **)((char *)cfg + offset);

    *p_file_data = am_file_data_new(cmd->pool, path);

    file_data = *p_file_data;

    rv = am_file_stat(file_data);

    if (rv != APR_SUCCESS) {

        return file_data->strerror;

    }

    if (file_data->finfo.filetype != APR_REG) {

        return apr_psprintf(cmd->pool, "file \"%s\" is not a regular file",

                            file_data->path);

    }

    return NULL;

}

/* This function handles configuration directives which use

 * a glob pattern, with a second optional argument

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *  const char *glob_pat glob(3) pattern

 *  const char *option   Optional argument

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_glob_fn12(cmd_parms *cmd,

                                    void *struct_ptr,

                                    const char *glob_pat,

                                    const char *option)

{

    const char *(*take_argv)(cmd_parms *, void *, const char *, const char *);

    apr_array_header_t *files;

    const char *error;

    const char *directory;

    int i;

    take_argv = cmd->info;

    directory = am_filepath_dirname(cmd->pool, glob_pat);

    if (glob_pat == NULL || *glob_pat == '\0')

        return apr_psprintf(cmd->pool,

                            "%s takes one or two arguments",

                            cmd->cmd->name);

    if (apr_match_glob(glob_pat, &files, cmd->pool) != 0)

        return take_argv(cmd, struct_ptr, glob_pat, option);

    for (i = 0; i < files->nelts; i++) {

        const char *path;

        path = apr_pstrcat(cmd->pool, directory, "/", 

                           ((const char **)(files->elts))[i], NULL); 

        error = take_argv(cmd, struct_ptr, path, option);

        if (error != NULL)

            return error;

    }

    return NULL;

}

/* This function handles configuration directives which set an 

 * idp related slot in the module configuration. 

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *  const char *metadata Path to metadata file for one or multiple IdP

 *  const char *chain    Optional path to validating chain

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_idp_string_slot(cmd_parms *cmd,

                                          void *struct_ptr,

                                          const char *metadata,

                                          const char *chain)

{

    server_rec *s = cmd->server;

    apr_pool_t *pconf = s->process->pconf;

    am_dir_cfg_rec *cfg = (am_dir_cfg_rec *)struct_ptr;

    am_file_data_t *idp_file_data = NULL;

    am_file_data_t *chain_file_data = NULL;

#ifndef HAVE_lasso_server_load_metadata

    if (chain != NULL)

        return apr_psprintf(cmd->pool, "Cannot specify validating chain "

                            "for %s since lasso library lacks "

                            "lasso_server_load_metadata()", cmd->cmd->name);

#endif /* HAVE_lasso_server_load_metadata */

    idp_file_data = am_file_data_new(pconf, metadata);

    if (am_file_stat(idp_file_data) != APR_SUCCESS) {

        return idp_file_data->strerror;

    }

    if (chain) {

        chain_file_data = am_file_data_new(pconf, chain);

        if (am_file_stat(chain_file_data) != APR_SUCCESS) {

            return chain_file_data->strerror;

        }

    } else {

        chain_file_data = NULL;

    }

    am_metadata_t *idp_metadata = apr_array_push(cfg->idp_metadata);

    idp_metadata->metadata = idp_file_data;

    idp_metadata->chain = chain_file_data;

    return NULL;

}

/* This function handles configuration directives which set an

 * idp federation blacklist slot in the module configuration.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *  int argc             Number of blacklisted providerId.

 *  char *const argv[]   List of blacklisted providerId.

 *

 * Returns:

 *  NULL on success, or errror string

 */

static const char *am_set_idp_ignore_slot(cmd_parms *cmd,

                                          void *struct_ptr,

                                          int argc,

                                          char *const argv[])

{

#ifdef HAVE_lasso_server_load_metadata

    server_rec *s = cmd->server;

    apr_pool_t *pconf = s->process->pconf;

    am_dir_cfg_rec *cfg = (am_dir_cfg_rec *)struct_ptr;

    GList *new_idp_ignore;

    int i;

    if (argc < 1)

        return apr_psprintf(cmd->pool, "%s takes at least one arguments",

                            cmd->cmd->name);

    for (i = 0; i < argc; i++) {

        new_idp_ignore = apr_palloc(pconf, sizeof(GList));

        new_idp_ignore->data = apr_pstrdup(pconf, argv[i]);

        /* Prepend it to the list. */

        new_idp_ignore->next = cfg->idp_ignore;

        if (cfg->idp_ignore != NULL)

            cfg->idp_ignore->prev = new_idp_ignore;

        cfg->idp_ignore = new_idp_ignore;

    }

    return NULL;

#else /* HAVE_lasso_server_load_metadata */

    return apr_psprintf(cmd->pool, "Cannot use %s since lasso library lacks "

                        "lasso_server_load_metadata()", cmd->cmd->name);

#endif /* HAVE_lasso_server_load_metadata */

}

/* This function handles configuration directives which set a file path

 * slot in the module configuration.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *                       This value isn't used by this function.

 *  const char *arg      The string argument following this configuration

 *                       directive in the configuraion file.

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_module_config_file_slot(cmd_parms *cmd,

                                                    void *struct_ptr,

                                                    const char *arg)

{

    return ap_set_file_slot(cmd, am_get_mod_cfg(cmd->server), arg);

}

/* This function handles configuration directives which set an int

 * slot in the module configuration.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *                       This value isn't used by this function.

 *  const char *arg      The string argument following this configuration

 *                       directive in the configuraion file.

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_module_config_int_slot(cmd_parms *cmd,

                                                 void *struct_ptr,

                                                 const char *arg)

{

    return ap_set_int_slot(cmd, am_get_mod_cfg(cmd->server), arg);

}

/* This function handles the MellonDiagnosticsFile configuration directive.

 * It emits as warning in the log file if Mellon is not built with

 * diagnostics enabled.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *  const char *arg      The string argument following this configuration

 *                       directive in the configuraion file.

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_module_diag_file_slot(cmd_parms *cmd,

                                                    void *struct_ptr,

                                                    const char *arg)

{

#ifdef ENABLE_DIAGNOSTICS

    return ap_set_file_slot(cmd, am_get_diag_cfg(cmd->server), arg);

#else

    ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, cmd->server,

                 "%s has no effect because Mellon was not compiled with"

                 " diagnostics enabled, use ./configure --enable-diagnostics"

                 " at build time to turn this feature on.",

                 cmd->directive->directive);

    return NULL;

#endif

}

/* This function handles configuration directives which sets the

 * diagnostics flags in the module configuration.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *  const char *arg      The string argument following this configuration

 *                       directive in the configuraion file.

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_module_diag_flags_slot(cmd_parms *cmd,

                                                 void *struct_ptr,

                                                 const char *arg)

{

#ifdef ENABLE_DIAGNOSTICS

    am_diag_cfg_rec *diag_cfg = am_get_diag_cfg(cmd->server);

    if (strcasecmp(arg, "on") == 0) {

        diag_cfg->flags = AM_DIAG_FLAG_ENABLE_ALL;

    }

    else if (strcasecmp(arg, "off") == 0) {

        diag_cfg->flags = AM_DIAG_FLAG_DISABLE;

    } else {

        return apr_psprintf(cmd->pool, "%s: must be one of: 'on', 'off'",

                            cmd->cmd->name);

    }

    return NULL;

#else

    ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, cmd->server,

                 "%s has no effect because Mellon was not compiled with"

                 " diagnostics enabled, use ./configure --enable-diagnostics"

                 " at build time to turn this feature on.",

                 cmd->directive->directive);

    return NULL;

#endif

}

/* This function handles the MellonCookieSameSite configuration directive.

 * This directive can be set to "lax" or "strict"

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *  const char *arg      The string argument following this configuration

 *                       directive in the configuraion file.

 *

 * Returns:

 *  NULL on success or an error string if the argument is wrong.

 */

static const char *am_set_samesite_slot(cmd_parms *cmd,

                                      void *struct_ptr,

                                      const char *arg)

{

    am_dir_cfg_rec *d = (am_dir_cfg_rec *)struct_ptr;

    if(!strcasecmp(arg, "lax")) {

        d->cookie_samesite = am_samesite_lax;

    } else if(!strcasecmp(arg, "strict")) {

        d->cookie_samesite = am_samesite_strict;

    } else if(!strcasecmp(arg, "none")) {

        d->cookie_samesite = am_samesite_none;

    } else {

        return "The MellonCookieSameSite parameter must be 'lax' or 'strict'";

    }

    return NULL;

}

/* This function handles the MellonEnable configuration directive.

 * This directive can be set to "off", "info" or "auth".

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *  const char *arg      The string argument following this configuration

 *                       directive in the configuraion file.

 *

 * Returns:

 *  NULL on success or an error string if the argument is wrong.

 */

static const char *am_set_enable_slot(cmd_parms *cmd,

                                      void *struct_ptr,

                                      const char *arg)

{

    am_dir_cfg_rec *d = (am_dir_cfg_rec *)struct_ptr;

    if(!strcasecmp(arg, "auth")) {

        d->enable_mellon = am_enable_auth;

    } else if(!strcasecmp(arg, "info")) {

        d->enable_mellon = am_enable_info;

    } else if(!strcasecmp(arg, "off")) {

        d->enable_mellon = am_enable_off;

    } else {

        return "parameter must be 'off', 'info' or 'auth'";

    }

    return NULL;

}

/* This function handles the MellonSecureCookie configuration directive.

 * This directive can be set to "on", "off", "secure" or "httponly".

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *  const char *arg      The string argument following this configuration

 *                       directive in the configuraion file.

 *

 * Returns:

 *  NULL on success or an error string if the argument is wrong.

 */

static const char *am_set_secure_slots(cmd_parms *cmd,

                                      void *struct_ptr,

                                      const char *arg)

{

    am_dir_cfg_rec *d = (am_dir_cfg_rec *)struct_ptr;

    if(!strcasecmp(arg, "on")) {

        d->secure = 1;

        d->http_only = 1;

    } else if(!strcasecmp(arg, "secure")) {

        d->secure = 1;

    } else if(!strcasecmp(arg, "httponly")) {

        d->http_only = 1;

    } else if(strcasecmp(arg, "off")) {

        return "parameter must be 'on', 'off', 'secure' or 'httponly'";

    }

    return NULL;

}

/* This function handles the obsolete MellonDecoder configuration directive.

 * It is a no-op.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for this configuration

 *                       directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *  const char *arg      The string argument following this configuration

 *                       directive in the configuraion file.

 *

 * Returns:

 *  NULL

 */

static const char *am_set_decoder_slot(cmd_parms *cmd,

                                       void *struct_ptr,

                                       const char *arg)

{

    return NULL;

}

/* This function handles the MellonEndpointPath configuration directive.

 * If the path doesn't end with a '/', then we will append one.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for the MellonEndpointPath

 *                       configuration directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *                       NULL if we are not in a directory configuration.

 *  const char *arg      The string argument containing the path of the

 *                       endpoint directory.

 *

 * Returns:

 *  This function will always return NULL.

 */

static const char *am_set_endpoint_path(cmd_parms *cmd,

                                        void *struct_ptr,

                                        const char *arg)

{

    am_dir_cfg_rec *d = (am_dir_cfg_rec *)struct_ptr;

    /* Make sure that the path ends with '/'. */

    if(strlen(arg) == 0 || arg[strlen(arg) - 1] != '/') {

        d->endpoint_path = apr_pstrcat(cmd->pool, arg, "/", NULL);

    } else {

        d->endpoint_path = arg;

    }

    return NULL;

}

/* This function handles the MellonSetEnv configuration directive.

 * This directive allows the user to change the name of attributes.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for the MellonSetEnv

 *                       configuration directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *  const char *newName  The new name of the attribute.

 *  const char *oldName  The old name of the attribute.

 *

 * Returns:

 *  This function will always return NULL.

 */

static const char *am_set_setenv_slot(cmd_parms *cmd,

                                      void *struct_ptr,

                                      const char *newName,

                                      const char *oldName)

{

    am_dir_cfg_rec *d = (am_dir_cfg_rec *)struct_ptr;

    /* Configure as prefixed attribute name */

    am_envattr_conf_t *envattr_conf = (am_envattr_conf_t *)apr_palloc(cmd->pool, sizeof(am_envattr_conf_t));

    envattr_conf->name = newName;

    envattr_conf->prefixed = 1;

    apr_hash_set(d->envattr, oldName, APR_HASH_KEY_STRING, envattr_conf);

    return NULL;

}

/* This function handles the MellonSetEnvNoPrefix configuration directive.

 * This directive allows the user to change the name of attributes without prefixing them with MELLON_.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for the MellonSetEnv

 *                       configuration directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *  const char *newName  The new name of the attribute.

 *  const char *oldName  The old name of the attribute.

 *

 * Returns:

 *  This function will always return NULL.

 */

static const char *am_set_setenv_no_prefix_slot(cmd_parms *cmd,

                                      void *struct_ptr,

                                      const char *newName,

                                      const char *oldName)

{

    am_dir_cfg_rec *d = (am_dir_cfg_rec *)struct_ptr;

    /* Configure as not prefixed attribute name */

    am_envattr_conf_t *envattr_conf = (am_envattr_conf_t *)apr_palloc(cmd->pool, sizeof(am_envattr_conf_t));

    envattr_conf->name = newName;

    envattr_conf->prefixed = 0;

    apr_hash_set(d->envattr, oldName, APR_HASH_KEY_STRING, envattr_conf);

    return NULL;

}

/* This function decodes MellonCond flags, such as [NOT,REG]

 *

 * Parameters:

 *  const char *arg      Pointer to the flags string

 *

 * Returns:

 *  flags, or -1 on error

 */

static int am_cond_flags(const char *arg)

{

    int flags = AM_COND_FLAG_NULL; 

    static const char * const options[] = {

        "OR",  /* AM_EXPIRE_FLAG_OR */

        "NOT", /* AM_EXPIRE_FLAG_NOT */

        "REG", /* AM_EXPIRE_FLAG_REG */

        "NC",  /* AM_EXPIRE_FLAG_NC */

        "MAP", /* AM_EXPIRE_FLAG_MAP */

        "REF", /* AM_EXPIRE_FLAG_REF */

        "SUB", /* AM_EXPIRE_FLAG_SUB */

        /* The other options (IGN, REQ, FSTR, ...) are only internally used  */

    };

    apr_size_t options_count = sizeof(options) / sizeof(*options);

    /* Skip inital [ */

    if (arg[0] == '[')

        arg++;

    else

        return -1;

    do {

        apr_size_t i;

        for (i = 0; i < options_count; i++) {

            apr_size_t optlen = strlen(options[i]);

            if (strncmp(arg, options[i], optlen) == 0) {

                /* Make sure we have a separator next */

                if (arg[optlen] && !strchr("]\t ,", (int)arg[optlen]))

                       return -1;

                flags |= (1 << i); 

                arg += optlen;

                break;

            }

            /* no match */

            if (i == options_count)

                return -1;

            /* skip spaces, tabs and commas */

            arg += strspn(arg, " \t,");

            /*

             * End of option, but we fire an error if 

             * there is trailing garbage

             */

            if (*arg == ']') {

                arg++;

                return (*arg == '\0') ? flags : -1;

            }

         }

    } while (*arg);

    /* Missing trailing ] */

    return -1;

}

/* This function handles the MellonCond configuration directive, which

 * allows the user to restrict access based on attributes received from

 * the IdP.

 *

 * Parameters:

 *  cmd_parms *cmd       The command structure for the MellonCond

 *                       configuration directive.

 *  void *struct_ptr     Pointer to the current directory configuration.

 *  const char *attribute   Pointer to the attribute name

 *  const char *value       Pointer to the attribute value or regex

 *  const char *options     Pointer to options

 *

 * Returns:

 *  NULL on success or an error string on failure.

 */

static const char *am_set_cond_slot(cmd_parms *cmd,

                                    void *struct_ptr,

                                    const char *attribute,

                                    const char *value,

                                    const char *options)

{

    am_dir_cfg_rec *d = struct_ptr;

    int flags = AM_COND_FLAG_NULL;

    am_cond_t *element;

    if (attribute == NULL || *attribute == '\0' || 

        value == NULL || *value == '\0')

        return apr_pstrcat(cmd->pool, cmd->cmd->name,

                           " takes at least two arguments", NULL);

    if (options != NULL && *options != '\0')

        flags = am_cond_flags(options);

    if (flags == -1)

         return apr_psprintf(cmd->pool, "%s - invalid flags %s",

                             cmd->cmd->name, options);

    element = (am_cond_t *)apr_array_push(d->cond);

    element->varname = attribute;

    element->flags = flags;

    element->str = NULL;

    element->regex = NULL;

    element->directive = apr_pstrcat(cmd->pool, cmd->directive->directive, 

                                     " ", cmd->directive->args, NULL);

    if (element->flags & AM_COND_FLAG_REG) {

        int regex_flags = AP_REG_EXTENDED|AP_REG_NOSUB;

        if (element->flags & AM_COND_FLAG_NC)

            regex_flags |= AP_REG_ICASE;