/* 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_provider.h"

#include "httpd.h"

#include "http_config.h"

#include "ap_provider.h"

#include "http_core.h"

#include "http_log.h"

#include "http_protocol.h"

#include "http_request.h"

#include "util_ldap.h"

#include "mod_auth.h"

#include "apr_strings.h"

#include "apr_xlate.h"

#define APR_WANT_STRFUNC

#include "apr_want.h"

#include "apr_lib.h"

#include <ctype.h>

#if !APR_HAS_LDAP

#error mod_authnz_ldap requires APR-util to have LDAP support built in. To fix add --with-ldap to ./configure.

#endif

static char *default_attributes[3] = { "member", "uniqueMember", NULL };

typedef struct {

    apr_pool_t *pool;               /* Pool that this config is allocated from */

#if APR_HAS_THREADS

    apr_thread_mutex_t *lock;       /* Lock for this config */

#endif

    /* These parameters are all derived from the AuthLDAPURL directive */

    char *url;                      /* String representation of the URL */

    char *host;                     /* Name of the LDAP server (or space separated list) */

    int port;                       /* Port of the LDAP server */

    char *basedn;                   /* Base DN to do all searches from */

    char *attribute;                /* Attribute to search for */

    char **attributes;              /* Array of all the attributes to return */

    int scope;                      /* Scope of the search */

    char *filter;                   /* Filter to further limit the search  */

    deref_options deref;            /* how to handle alias dereferening */

    char *binddn;                   /* DN to bind to server (can be NULL) */

    char *bindpw;                   /* Password to bind to server (can be NULL) */

    int bind_authoritative;         /* If true, will return errors when bind fails */

    int user_is_dn;                 /* If true, r->user is replaced by DN during authn */

    char *remote_user_attribute;    /* If set, r->user is replaced by this attribute during authn */

    int compare_dn_on_server;       /* If true, will use server to do DN compare */

    int have_ldap_url;              /* Set if we have found an LDAP url */

    apr_array_header_t *groupattr;  /* List of Group attributes identifying user members. Default:"member uniqueMember" */

    int group_attrib_is_dn;         /* If true, the group attribute is the DN, otherwise,

                                        it's the exact string passed by the HTTP client */

    char **sgAttributes;            /* Array of strings constructed (post-config) from subgroupattrs. Last entry is NULL. */

    apr_array_header_t *subgroupclasses; /* List of object classes of sub-groups. Default:"groupOfNames groupOfUniqueNames" */

    int maxNestingDepth;            /* Maximum recursive nesting depth permitted during subgroup processing. Default: 10 */

    int secure;                     /* True if SSL connections are requested */

    char *authz_prefix;             /* Prefix for environment variables added during authz */

    int initial_bind_as_user;               /* true if we should try to bind (to lookup DN) directly with the basic auth username */

    ap_regex_t *bind_regex;         /* basic auth -> bind'able username regex */

    const char *bind_subst;         /* basic auth -> bind'able username substitution */

    int search_as_user;             /* true if authz searches should be done with the users credentials (when we did authn) */

    int compare_as_user;            /* true if authz compares should be done with the users credentials (when we did authn) */

} authn_ldap_config_t;

typedef struct {

    char *dn;                       /* The saved dn from a successful search */

    char *user;                     /* The username provided by the client */

    const char **vals;              /* The additional values pulled during the DN search*/

    char *password;                 /* if this module successfully authenticates, the basic auth password, else null */

} authn_ldap_request_t;

enum auth_ldap_phase {

    LDAP_AUTHN, LDAP_AUTHZ

};

enum auth_ldap_optype {

    LDAP_SEARCH, LDAP_COMPARE, LDAP_COMPARE_AND_SEARCH /* nested groups */

};

/* maximum group elements supported */

#define GROUPATTR_MAX_ELTS 10

module AP_MODULE_DECLARE_DATA authnz_ldap_module;

static APR_OPTIONAL_FN_TYPE(uldap_connection_close) *util_ldap_connection_close;

static APR_OPTIONAL_FN_TYPE(uldap_connection_find) *util_ldap_connection_find;

static APR_OPTIONAL_FN_TYPE(uldap_cache_comparedn) *util_ldap_cache_comparedn;

static APR_OPTIONAL_FN_TYPE(uldap_cache_compare) *util_ldap_cache_compare;

static APR_OPTIONAL_FN_TYPE(uldap_cache_check_subgroups) *util_ldap_cache_check_subgroups;

static APR_OPTIONAL_FN_TYPE(uldap_cache_checkuserid) *util_ldap_cache_checkuserid;

static APR_OPTIONAL_FN_TYPE(uldap_cache_getuserdn) *util_ldap_cache_getuserdn;

static APR_OPTIONAL_FN_TYPE(uldap_ssl_supported) *util_ldap_ssl_supported;

static apr_hash_t *charset_conversions = NULL;

static char *to_charset = NULL;           /* UTF-8 identifier derived from the charset.conv file */

/* Derive a code page ID give a language name or ID */

static char* derive_codepage_from_lang (apr_pool_t *p, char *language)

{

    char *charset;

    if (!language)          /* our default codepage */

        return apr_pstrdup(p, "ISO-8859-1");

    charset = (char*) apr_hash_get(charset_conversions, language, APR_HASH_KEY_STRING);

    /*

     * Test if language values like 'en-US' return a match from the charset

     * conversion map when shortened to 'en'.

     */

    if (!charset && strlen(language) > 3 && language[2] == '-') {

        char *language_short = apr_pstrndup(p, language, 2);

        charset = (char*) apr_hash_get(charset_conversions, language_short, APR_HASH_KEY_STRING);

    }

    if (charset) {

        charset = apr_pstrdup(p, charset);

    }

    return charset;

}

static apr_xlate_t* get_conv_set (request_rec *r)

{

    char *lang_line = (char*)apr_table_get(r->headers_in, "accept-language");

    char *lang;

    apr_xlate_t *convset;

    if (lang_line) {

        lang_line = apr_pstrdup(r->pool, lang_line);

        for (lang = lang_line;*lang;lang++) {

            if ((*lang == ',') || (*lang == ';')) {

                *lang = '\0';

                break;

            }

        }

        lang = derive_codepage_from_lang(r->pool, lang_line);

        if (lang && (apr_xlate_open(&convset, to_charset, lang, r->pool) == APR_SUCCESS)) {

            return convset;

        }

    }

    return NULL;

}

static const char* authn_ldap_xlate_password(request_rec *r,

                                             const char* sent_password)

{

    apr_xlate_t *convset = NULL;

    apr_size_t inbytes;

    apr_size_t outbytes;

    char *outbuf;

    if (charset_conversions && (convset = get_conv_set(r)) ) {

        inbytes = strlen(sent_password);

        outbytes = (inbytes+1)*3;

        outbuf = apr_pcalloc(r->pool, outbytes);

        /* Convert the password to UTF-8. */

        if (apr_xlate_conv_buffer(convset, sent_password, &inbytes, outbuf,

                                  &outbytes) == APR_SUCCESS)

            return outbuf;

    }

    return sent_password;

}

/*

 * Build the search filter, or at least as much of the search filter that

 * will fit in the buffer. We don't worry about the buffer not being able

 * to hold the entire filter. If the buffer wasn't big enough to hold the

 * filter, ldap_search_s will complain, but the only situation where this

 * is likely to happen is if the client sent a really, really long

 * username, most likely as part of an attack.

 *

 * The search filter consists of the filter provided with the URL,

 * combined with a filter made up of the attribute provided with the URL,

 * and the actual username passed by the HTTP client. For example, assume

 * that the LDAP URL is

 *

 *   ldap://ldap.airius.com/ou=People, o=Airius?uid??(posixid=*)

 *

 * Further, assume that the userid passed by the client was `userj'.  The

 * search filter will be (&(posixid=*)(uid=userj)).

 */

#define FILTER_LENGTH MAX_STRING_LEN

static void authn_ldap_build_filter(char *filtbuf,

                             request_rec *r,

                             const char* sent_user,

                             const char* sent_filter,

                             authn_ldap_config_t *sec)

{

    char *p, *q, *filtbuf_end;

    char *user, *filter;

    apr_xlate_t *convset = NULL;

    apr_size_t inbytes;

    apr_size_t outbytes;

    char *outbuf;

    int nofilter = 0;

    if (sent_user != NULL) {

        user = apr_pstrdup (r->pool, sent_user);

    }

    else

        return;

    if (sent_filter != NULL) {

        filter = apr_pstrdup (r->pool, sent_filter);

    }

    else

        filter = sec->filter;

    if (charset_conversions) {

        convset = get_conv_set(r);

    }

    if (convset) {

        inbytes = strlen(user);

        outbytes = (inbytes+1)*3;

        outbuf = apr_pcalloc(r->pool, outbytes);

        /* Convert the user name to UTF-8.  This is only valid for LDAP v3 */

        if (apr_xlate_conv_buffer(convset, user, &inbytes, outbuf, &outbytes) == APR_SUCCESS) {

            user = apr_pstrdup(r->pool, outbuf);

        }

    }

    /*

     * Create the first part of the filter, which consists of the

     * config-supplied portions.

     */

    if ((nofilter = (filter && !strcasecmp(filter, "none")))) { 

        apr_snprintf(filtbuf, FILTER_LENGTH, "(%s=", sec->attribute);

    }

    else { 

        apr_snprintf(filtbuf, FILTER_LENGTH, "(&(%s)(%s=", filter, sec->attribute);

    }

    /*

     * Now add the client-supplied username to the filter, ensuring that any

     * LDAP filter metachars are escaped.

     */

    filtbuf_end = filtbuf + FILTER_LENGTH - 1;

#if APR_HAS_MICROSOFT_LDAPSDK

    for (p = user, q=filtbuf + strlen(filtbuf);

         *p && q < filtbuf_end; ) {

        if (strchr("*()\\", *p) != NULL) {

            if ( q + 3 >= filtbuf_end)

              break;  /* Don't write part of escape sequence if we can't write all of it */

            *q++ = '\\';

            switch ( *p++ )

            {

              case '*':

                *q++ = '2';

                *q++ = 'a';

                break;

              case '(':

                *q++ = '2';

                *q++ = '8';

                break;

              case ')':

                *q++ = '2';

                *q++ = '9';

                break;

              case '\\':

                *q++ = '5';

                *q++ = 'c';

                break;

                        }

        }

        else

            *q++ = *p++;

    }

#else

    for (p = user, q=filtbuf + strlen(filtbuf);

         *p && q < filtbuf_end; *q++ = *p++) {

        if (strchr("*()\\", *p) != NULL) {

            *q++ = '\\';

            if (q >= filtbuf_end) {

              break;

            }

        }

    }

#endif

    *q = '\0';

    /*

     * Append the closing parens of the filter, unless doing so would

     * overrun the buffer.

     */

    if (nofilter) { 

        if (q + 1 <= filtbuf_end)

            strcat(filtbuf, ")");

    } 

    else { 

        if (q + 2 <= filtbuf_end)

            strcat(filtbuf, "))");

    }

}

static void *create_authnz_ldap_dir_config(apr_pool_t *p, char *d)

{

    authn_ldap_config_t *sec =

        (authn_ldap_config_t *)apr_pcalloc(p, sizeof(authn_ldap_config_t));

    sec->pool = p;

#if APR_HAS_THREADS

    apr_thread_mutex_create(&sec->lock, APR_THREAD_MUTEX_DEFAULT, p);

#endif

/*

    sec->authz_enabled = 1;

*/

    sec->groupattr = apr_array_make(p, GROUPATTR_MAX_ELTS,

                                    sizeof(struct mod_auth_ldap_groupattr_entry_t));

    sec->subgroupclasses = apr_array_make(p, GROUPATTR_MAX_ELTS,

                                    sizeof(struct mod_auth_ldap_groupattr_entry_t));

    sec->have_ldap_url = 0;

    sec->url = "";

    sec->host = NULL;

    sec->binddn = NULL;

    sec->bindpw = NULL;

    sec->bind_authoritative = 1;

    sec->deref = always;

    sec->group_attrib_is_dn = 1;

    sec->secure = -1;   /*Initialize to unset*/

    sec->maxNestingDepth = 10;

    sec->sgAttributes = apr_pcalloc(p, sizeof (char *) * GROUPATTR_MAX_ELTS + 1);

    sec->user_is_dn = 0;

    sec->remote_user_attribute = NULL;

    sec->compare_dn_on_server = 0;

    sec->authz_prefix = AUTHZ_PREFIX;

    return sec;

}

static apr_status_t authnz_ldap_cleanup_connection_close(void *param)

{

    util_ldap_connection_t *ldc = param;

    util_ldap_connection_close(ldc);

    return APR_SUCCESS;

}

static int set_request_vars(request_rec *r, enum auth_ldap_phase phase) {

    char *prefix = NULL;

    int prefix_len;

    int remote_user_attribute_set = 0;

    authn_ldap_request_t *req =

        (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);

    authn_ldap_config_t *sec =

        (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);

    const char **vals = req->vals;

    prefix = (phase == LDAP_AUTHN) ? AUTHN_PREFIX : sec->authz_prefix;

    prefix_len = strlen(prefix);

    if (sec->attributes && vals) {

        apr_table_t *e = r->subprocess_env;

        int i = 0;

        while (sec->attributes[i]) {

            char *str = apr_pstrcat(r->pool, prefix, sec->attributes[i], NULL);

            int j = prefix_len;

            while (str[j]) {

                str[j] = apr_toupper(str[j]);

                j++;

            }

            apr_table_setn(e, str, vals[i] ? vals[i] : "");

            /* handle remote_user_attribute, if set */

            if ((phase == LDAP_AUTHN) &&

                sec->remote_user_attribute &&

                !strcmp(sec->remote_user_attribute, sec->attributes[i])) {

                r->user = (char *)apr_pstrdup(r->pool, vals[i]);

                remote_user_attribute_set = 1;

            }

            i++;

        }

    }

    return remote_user_attribute_set;

}

static const char *ldap_determine_binddn(request_rec *r, const char *user) {

    authn_ldap_config_t *sec =

        (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);

    const char *result = user;

    ap_regmatch_t regm[AP_MAX_REG_MATCH];

    if (NULL == user || NULL == sec || !sec->bind_regex || !sec->bind_subst) {

        return result;

    }

    if (!ap_regexec(sec->bind_regex, user, AP_MAX_REG_MATCH, regm, 0)) {

        char *substituted = ap_pregsub(r->pool, sec->bind_subst, user, AP_MAX_REG_MATCH, regm);

        if (NULL != substituted) {

            result = substituted;

        }

    }

    apr_table_set(r->subprocess_env, "LDAP_BINDASUSER", result);

    return result;

}

/* Some LDAP servers restrict who can search or compare, and the hard-coded ID

 * might be good for the DN lookup but not for later operations.

 */

static util_ldap_connection_t *get_connection_for_authz(request_rec *r, enum auth_ldap_optype type) {

    authn_ldap_request_t *req =

        (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);

    authn_ldap_config_t *sec =

        (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);

    char *binddn = sec->binddn;

    char *bindpw = sec->bindpw;

    /* If the per-request config isn't set, we didn't authenticate this user, and leave the default credentials */

    if (req && req->password &&

         ((type == LDAP_SEARCH && sec->search_as_user)    ||

          (type == LDAP_COMPARE && sec->compare_as_user)  ||

          (type == LDAP_COMPARE_AND_SEARCH && sec->compare_as_user && sec->search_as_user))){

            binddn = req->dn;

            bindpw = req->password;

    }

    return util_ldap_connection_find(r, sec->host, sec->port,

                                     binddn, bindpw,

                                     sec->deref, sec->secure);

}

/*

 * Authentication Phase

 * --------------------

 *

 * This phase authenticates the credentials the user has sent with

 * the request (ie the username and password are checked). This is done

 * by making an attempt to bind to the LDAP server using this user's

 * DN and the supplied password.

 *

 */

static authn_status authn_ldap_check_password(request_rec *r, const char *user,

                                              const char *password)

{

    char filtbuf[FILTER_LENGTH];

    authn_ldap_config_t *sec =

        (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);

    util_ldap_connection_t *ldc = NULL;

    int result = 0;

    int remote_user_attribute_set = 0;

    const char *dn = NULL;

    const char *utfpassword;

    authn_ldap_request_t *req =

        (authn_ldap_request_t *)apr_pcalloc(r->pool, sizeof(authn_ldap_request_t));

    ap_set_module_config(r->request_config, &authnz_ldap_module, req);

/*

    if (!sec->enabled) {

        return AUTH_USER_NOT_FOUND;

    }

*/

    /*

     * Basic sanity checks before any LDAP operations even happen.

     */

    if (!sec->have_ldap_url) {

        ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(02558) 

                      "no AuthLDAPURL");

        return AUTH_GENERAL_ERROR;

    }

    /* There is a good AuthLDAPURL, right? */

    if (sec->host) {

        const char *binddn = sec->binddn;

        const char *bindpw = sec->bindpw;

        if (sec->initial_bind_as_user) {

            bindpw = password;

            binddn = ldap_determine_binddn(r, user);

        }

        ldc = util_ldap_connection_find(r, sec->host, sec->port,

                                       binddn, bindpw,

                                       sec->deref, sec->secure);

    }

    else {

        ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(01690)

                      "auth_ldap authenticate: no sec->host - weird...?");

        return AUTH_GENERAL_ERROR;

    }

    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01691)

                  "auth_ldap authenticate: using URL %s", sec->url);

    /* Get the password that the client sent */

    if (password == NULL) {

        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01692)

                      "auth_ldap authenticate: no password specified");

        util_ldap_connection_close(ldc);

        return AUTH_GENERAL_ERROR;

    }

    if (user == NULL) {

        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01693)

                      "auth_ldap authenticate: no user specified");

        util_ldap_connection_close(ldc);

        return AUTH_GENERAL_ERROR;

    }

    /* build the username filter */

    authn_ldap_build_filter(filtbuf, r, user, NULL, sec);

    ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r,

                      "auth_ldap authenticate: final authn filter is %s", filtbuf);

    /* convert password to utf-8 */

    utfpassword = authn_ldap_xlate_password(r, password);

    /* do the user search */

    result = util_ldap_cache_checkuserid(r, ldc, sec->url, sec->basedn, sec->scope,

                                         sec->attributes, filtbuf, utfpassword,

                                         &dn, &(req->vals));

    util_ldap_connection_close(ldc);

    /* handle bind failure */

    if (result != LDAP_SUCCESS) {

        if (!sec->bind_authoritative) {

           ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01694)

                      "auth_ldap authenticate: user %s authentication failed; "

                      "URI %s [%s][%s] (not authoritative)",

                      user, r->uri, ldc->reason, ldap_err2string(result));

           return AUTH_USER_NOT_FOUND;

        }

        ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(01695)

                      "auth_ldap authenticate: "

                      "user %s authentication failed; URI %s [%s][%s]",

                      user, r->uri, ldc->reason, ldap_err2string(result));

        /* talking to a primitive LDAP server (like RACF-over-LDAP) that doesn't return specific errors */

        if (!strcasecmp(sec->filter, "none") && LDAP_OTHER == result) { 

            return AUTH_USER_NOT_FOUND;

        }

        return (LDAP_NO_SUCH_OBJECT == result) ? AUTH_USER_NOT_FOUND

#ifdef LDAP_SECURITY_ERROR

                 : (LDAP_SECURITY_ERROR(result)) ? AUTH_DENIED

#else

                 : (LDAP_INAPPROPRIATE_AUTH == result) ? AUTH_DENIED

                 : (LDAP_INVALID_CREDENTIALS == result) ? AUTH_DENIED

#ifdef LDAP_INSUFFICIENT_ACCESS

                 : (LDAP_INSUFFICIENT_ACCESS == result) ? AUTH_DENIED

#endif

#ifdef LDAP_INSUFFICIENT_RIGHTS

                 : (LDAP_INSUFFICIENT_RIGHTS == result) ? AUTH_DENIED

#endif

#endif

#ifdef LDAP_CONSTRAINT_VIOLATION

    /* At least Sun Directory Server sends this if a user is

     * locked. This is not covered by LDAP_SECURITY_ERROR.

     */

                 : (LDAP_CONSTRAINT_VIOLATION == result) ? AUTH_DENIED

#endif

                 : AUTH_GENERAL_ERROR;

    }

    /* mark the user and DN */

    req->dn = apr_pstrdup(r->pool, dn);

    req->user = apr_pstrdup(r->pool, user);

    req->password = apr_pstrdup(r->pool, password);

    if (sec->user_is_dn) {

        r->user = req->dn;

    }

    /* add environment variables */

    remote_user_attribute_set = set_request_vars(r, LDAP_AUTHN);

    /* sanity check */

    if (sec->remote_user_attribute && !remote_user_attribute_set) {

        ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(01696)

                  "auth_ldap authenticate: "

                  "REMOTE_USER was to be set with attribute '%s', "

                  "but this attribute was not requested for in the "

                  "LDAP query for the user. REMOTE_USER will fall "

                  "back to username or DN as appropriate.",

                  sec->remote_user_attribute);

    }

    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01697)

                  "auth_ldap authenticate: accepting %s", user);

    return AUTH_GRANTED;

}

static authz_status ldapuser_check_authorization(request_rec *r,

                                                 const char *require_args,

                                                 const void *parsed_require_args)

{

    int result = 0;

    authn_ldap_request_t *req =

        (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);

    authn_ldap_config_t *sec =

        (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);

    util_ldap_connection_t *ldc = NULL;

    const char *err = NULL;

    const ap_expr_info_t *expr = parsed_require_args;

    const char *require;

    const char *t;

    char *w;

    char filtbuf[FILTER_LENGTH];

    const char *dn = NULL;

    if (!r->user) {

        return AUTHZ_DENIED_NO_USER;

    }

    if (!sec->have_ldap_url) {

        return AUTHZ_DENIED;

    }

    if (sec->host) {

        ldc = get_connection_for_authz(r, LDAP_COMPARE);

        apr_pool_cleanup_register(r->pool, ldc,

                                  authnz_ldap_cleanup_connection_close,

                                  apr_pool_cleanup_null);

    }

    else {

        ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(01698)

                      "auth_ldap authorize: no sec->host - weird...?");

        return AUTHZ_DENIED;

    }

    /*

     * If we have been authenticated by some other module than mod_authnz_ldap,

     * the req structure needed for authorization needs to be created

     * and populated with the userid and DN of the account in LDAP

     */

    if (!strlen(r->user)) {

        ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(01699)

            "ldap authorize: Userid is blank, AuthType=%s",

            r->ap_auth_type);

    }

    if(!req) {

        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01700)

            "ldap authorize: Creating LDAP req structure");

        req = (authn_ldap_request_t *)apr_pcalloc(r->pool,

            sizeof(authn_ldap_request_t));

        /* Build the username filter */

        authn_ldap_build_filter(filtbuf, r, r->user, NULL, sec);

        /* Search for the user DN */

        result = util_ldap_cache_getuserdn(r, ldc, sec->url, sec->basedn,

             sec->scope, sec->attributes, filtbuf, &dn, &(req->vals));

        /* Search failed, log error and return failure */

        if(result != LDAP_SUCCESS) {

            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01701)

                "auth_ldap authorise: User DN not found, %s", ldc->reason);

            return AUTHZ_DENIED;

        }

        ap_set_module_config(r->request_config, &authnz_ldap_module, req);

        req->dn = apr_pstrdup(r->pool, dn);

        req->user = r->user;

    }

    if (req->dn == NULL || strlen(req->dn) == 0) {

        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01702)

                      "auth_ldap authorize: require user: user's DN has not "

                      "been defined; failing authorization");

        return AUTHZ_DENIED;

    }

    require = ap_expr_str_exec(r, expr, &err;;

    if (err) {

        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(02585)

                      "auth_ldap authorize: require user: Can't evaluate expression: %s",

                      err);

        return AUTHZ_DENIED;

    }

    /*

     * First do a whole-line compare, in case it's something like

     *   require user Babs Jensen

     */

    result = util_ldap_cache_compare(r, ldc, sec->url, req->dn, sec->attribute, require);

    switch(result) {

        case LDAP_COMPARE_TRUE: {

            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01703)

                          "auth_ldap authorize: require user: authorization "

                          "successful");

            set_request_vars(r, LDAP_AUTHZ);

            return AUTHZ_GRANTED;

        }

        default: {

            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01704)

                          "auth_ldap authorize: require user: "

                          "authorization failed [%s][%s]",

                          ldc->reason, ldap_err2string(result));

        }

    }

    /*

     * Now break apart the line and compare each word on it

     */

    t = require;

    while ((w = ap_getword_conf(r->pool, &t)) && w[0]) {

        result = util_ldap_cache_compare(r, ldc, sec->url, req->dn, sec->attribute, w);

        switch(result) {

            case LDAP_COMPARE_TRUE: {

                ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01705)

                              "auth_ldap authorize: "

                              "require user: authorization successful");

                set_request_vars(r, LDAP_AUTHZ);

                return AUTHZ_GRANTED;

            }

            default: {

                ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01706)

                              "auth_ldap authorize: "

                              "require user: authorization failed [%s][%s]",

                              ldc->reason, ldap_err2string(result));

            }

        }

    }

    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01707)

                  "auth_ldap authorize user: authorization denied for "

                  "user %s to %s",

                  r->user, r->uri);

    return AUTHZ_DENIED;

}

static authz_status ldapgroup_check_authorization(request_rec *r,

                                                  const char *require_args,

                                                  const void *parsed_require_args)

{

    int result = 0;

    authn_ldap_request_t *req =

        (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);

    authn_ldap_config_t *sec =

        (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);

    util_ldap_connection_t *ldc = NULL;

    const char *err = NULL;

    const ap_expr_info_t *expr = parsed_require_args;

    const char *require;

    const char *t;

    char filtbuf[FILTER_LENGTH];

    const char *dn = NULL;

    struct mod_auth_ldap_groupattr_entry_t *ent;

    int i;

    if (!r->user) {

        return AUTHZ_DENIED_NO_USER;

    }

    if (!sec->have_ldap_url) {

        return AUTHZ_DENIED;

    }

    if (sec->host) {

        ldc = get_connection_for_authz(r, LDAP_COMPARE); /* for the top-level group only */

        apr_pool_cleanup_register(r->pool, ldc,

                                  authnz_ldap_cleanup_connection_close,

                                  apr_pool_cleanup_null);

    }

    else {

        ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(01708)

                      "auth_ldap authorize: no sec->host - weird...?");

        return AUTHZ_DENIED;

    }

    /*

     * If there are no elements in the group attribute array, the default should be

     * member and uniquemember; populate the array now.

     */

    if (sec->groupattr->nelts == 0) {

        struct mod_auth_ldap_groupattr_entry_t *grp;

#if APR_HAS_THREADS

        apr_thread_mutex_lock(sec->lock);

#endif

        grp = apr_array_push(sec->groupattr);

        grp->name = "member";

        grp = apr_array_push(sec->groupattr);

        grp->name = "uniqueMember";

#if APR_HAS_THREADS

        apr_thread_mutex_unlock(sec->lock);

#endif

    }

    /*

     * If there are no elements in the sub group classes array, the default

     * should be groupOfNames and groupOfUniqueNames; populate the array now.

     */

    if (sec->subgroupclasses->nelts == 0) {

        struct mod_auth_ldap_groupattr_entry_t *grp;

#if APR_HAS_THREADS

        apr_thread_mutex_lock(sec->lock);

#endif

        grp = apr_array_push(sec->subgroupclasses);

        grp->name = "groupOfNames";

        grp = apr_array_push(sec->subgroupclasses);

        grp->name = "groupOfUniqueNames";

#if APR_HAS_THREADS

        apr_thread_mutex_unlock(sec->lock);

#endif

    }

    /*

     * If we have been authenticated by some other module than mod_auth_ldap,

     * the req structure needed for authorization needs to be created

     * and populated with the userid and DN of the account in LDAP

     */

    if (!strlen(r->user)) {

        ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(01709)

            "ldap authorize: Userid is blank, AuthType=%s",

            r->ap_auth_type);

    }

    if(!req) {

        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01710)

            "ldap authorize: Creating LDAP req structure");

        req = (authn_ldap_request_t *)apr_pcalloc(r->pool,

            sizeof(authn_ldap_request_t));

        /* Build the username filter */

        authn_ldap_build_filter(filtbuf, r, r->user, NULL, sec);

        /* Search for the user DN */

        result = util_ldap_cache_getuserdn(r, ldc, sec->url, sec->basedn,

             sec->scope, sec->attributes, filtbuf, &dn, &(req->vals));

        /* Search failed, log error and return failure */

        if(result != LDAP_SUCCESS) {

            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01711)