granicus.if.org Git - apache/blob - modules/aaa/mod_authnz_ldap.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "ap_provider.h"
  18 #include "httpd.h"
  19 #include "http_config.h"
  20 #include "ap_provider.h"
  21 #include "http_core.h"
  22 #include "http_log.h"
  23 #include "http_protocol.h"
  24 #include "http_request.h"
  25 #include "util_ldap.h"
  26
  27 #include "mod_auth.h"
  28
  29 #include "apr_strings.h"
  30 #include "apr_xlate.h"
  31 #define APR_WANT_STRFUNC
  32 #include "apr_want.h"
  33 #include "apr_lib.h"
  34
  35 #include <ctype.h>
  36
  37 #if !APR_HAS_LDAP
  38 #error mod_authnz_ldap requires APR-util to have LDAP support built in. To fix add --with-ldap to ./configure.
  39 #endif
  40
  41 static char *default_attributes[3] = { "member", "uniqueMember", NULL };
  42
  43 typedef struct {
  44     apr_pool_t *pool;               /* Pool that this config is allocated from */
  45 #if APR_HAS_THREADS
  46     apr_thread_mutex_t *lock;       /* Lock for this config */
  47 #endif
  48
  49     /* These parameters are all derived from the AuthLDAPURL directive */
  50     char *url;                      /* String representation of the URL */
  51
  52     char *host;                     /* Name of the LDAP server (or space separated list) */
  53     int port;                       /* Port of the LDAP server */
  54     char *basedn;                   /* Base DN to do all searches from */
  55     char *attribute;                /* Attribute to search for */
  56     char **attributes;              /* Array of all the attributes to return */
  57     int scope;                      /* Scope of the search */
  58     char *filter;                   /* Filter to further limit the search  */
  59     deref_options deref;            /* how to handle alias dereferening */
  60     char *binddn;                   /* DN to bind to server (can be NULL) */
  61     char *bindpw;                   /* Password to bind to server (can be NULL) */
  62     int bind_authoritative;         /* If true, will return errors when bind fails */
  63
  64     int user_is_dn;                 /* If true, connection->user is DN instead of userid */
  65     char *remote_user_attribute;    /* If set, connection->user is this attribute instead of userid */
  66     int compare_dn_on_server;       /* If true, will use server to do DN compare */
  67
  68     int have_ldap_url;              /* Set if we have found an LDAP url */
  69
  70     apr_array_header_t *groupattr;  /* List of Group attributes identifying user members. Default:"member uniqueMember" */
  71     int group_attrib_is_dn;         /* If true, the group attribute is the DN, otherwise,
  72                                         it's the exact string passed by the HTTP client */
  73     char **sgAttributes;            /* Array of strings constructed (post-config) from subgroupattrs. Last entry is NULL. */
  74     apr_array_header_t *subgroupclasses; /* List of object classes of sub-groups. Default:"groupOfNames groupOfUniqueNames" */
  75     int maxNestingDepth;            /* Maximum recursive nesting depth permitted during subgroup processing. Default: 10 */
  76
  77     int secure;                     /* True if SSL connections are requested */
  78     char *authz_prefix;             /* Prefix for environment variables added during authz */
  79     int initial_bind_as_user;               /* true if we should try to bind (to lookup DN) directly with the basic auth username */
  80     ap_regex_t *bind_regex;         /* basic auth -> bind'able username regex */
  81     const char *bind_subst;         /* basic auth -> bind'able username substitution */
  82     int search_as_user;             /* true if authz searches should be done with the users credentials (when we did authn) */
  83     int compare_as_user;            /* true if authz compares should be done with the users credentials (when we did authn) */
  84 } authn_ldap_config_t;
  85
  86 typedef struct {
  87     char *dn;                       /* The saved dn from a successful search */
  88     char *user;                     /* The username provided by the client */
  89     const char **vals;              /* The additional values pulled during the DN search*/
  90     char *password;                 /* if this module successfully authenticates, the basic auth password, else null */
  91 } authn_ldap_request_t;
  92
  93 enum auth_ldap_phase {
  94     LDAP_AUTHN, LDAP_AUTHZ
  95 };
  96
  97 enum auth_ldap_optype {
  98     LDAP_SEARCH, LDAP_COMPARE, LDAP_COMPARE_AND_SEARCH /* nested groups */
  99 };
 100
 101 /* maximum group elements supported */
 102 #define GROUPATTR_MAX_ELTS 10
 103
 104 module AP_MODULE_DECLARE_DATA authnz_ldap_module;
 105
 106 static APR_OPTIONAL_FN_TYPE(uldap_connection_close) *util_ldap_connection_close;
 107 static APR_OPTIONAL_FN_TYPE(uldap_connection_find) *util_ldap_connection_find;
 108 static APR_OPTIONAL_FN_TYPE(uldap_cache_comparedn) *util_ldap_cache_comparedn;
 109 static APR_OPTIONAL_FN_TYPE(uldap_cache_compare) *util_ldap_cache_compare;
 110 static APR_OPTIONAL_FN_TYPE(uldap_cache_check_subgroups) *util_ldap_cache_check_subgroups;
 111 static APR_OPTIONAL_FN_TYPE(uldap_cache_checkuserid) *util_ldap_cache_checkuserid;
 112 static APR_OPTIONAL_FN_TYPE(uldap_cache_getuserdn) *util_ldap_cache_getuserdn;
 113 static APR_OPTIONAL_FN_TYPE(uldap_ssl_supported) *util_ldap_ssl_supported;
 114
 115 static apr_hash_t *charset_conversions = NULL;
 116 static char *to_charset = NULL;           /* UTF-8 identifier derived from the charset.conv file */
 117
 118
 119 /* Derive a code page ID give a language name or ID */
 120 static char* derive_codepage_from_lang (apr_pool_t *p, char *language)
 121 {
 122     char *charset;
 123
 124     if (!language)          /* our default codepage */
 125         return apr_pstrdup(p, "ISO-8859-1");
 126
 127     charset = (char*) apr_hash_get(charset_conversions, language, APR_HASH_KEY_STRING);
 128
 129     if (!charset) {
 130         language[2] = '\0';
 131         charset = (char*) apr_hash_get(charset_conversions, language, APR_HASH_KEY_STRING);
 132     }
 133
 134     if (charset) {
 135         charset = apr_pstrdup(p, charset);
 136     }
 137
 138     return charset;
 139 }
 140
 141 static apr_xlate_t* get_conv_set (request_rec *r)
 142 {
 143     char *lang_line = (char*)apr_table_get(r->headers_in, "accept-language");
 144     char *lang;
 145     apr_xlate_t *convset;
 146
 147     if (lang_line) {
 148         lang_line = apr_pstrdup(r->pool, lang_line);
 149         for (lang = lang_line;*lang;lang++) {
 150             if ((*lang == ',') || (*lang == ';')) {
 151                 *lang = '\0';
 152                 break;
 153             }
 154         }
 155         lang = derive_codepage_from_lang(r->pool, lang_line);
 156
 157         if (lang && (apr_xlate_open(&convset, to_charset, lang, r->pool) == APR_SUCCESS)) {
 158             return convset;
 159         }
 160     }
 161
 162     return NULL;
 163 }
 164
 165
 166 static const char* authn_ldap_xlate_password(request_rec *r,
 167                                              const char* sent_password)
 168 {
 169     apr_xlate_t *convset = NULL;
 170     apr_size_t inbytes;
 171     apr_size_t outbytes;
 172     char *outbuf;
 173
 174     if (charset_conversions && (convset = get_conv_set(r)) ) {
 175         inbytes = strlen(sent_password);
 176         outbytes = (inbytes+1)*3;
 177         outbuf = apr_pcalloc(r->pool, outbytes);
 178
 179         /* Convert the password to UTF-8. */
 180         if (apr_xlate_conv_buffer(convset, sent_password, &inbytes, outbuf,
 181                                   &outbytes) == APR_SUCCESS)
 182             return outbuf;
 183     }
 184
 185     return sent_password;
 186 }
 187
 188
 189 /*
 190  * Build the search filter, or at least as much of the search filter that
 191  * will fit in the buffer. We don't worry about the buffer not being able
 192  * to hold the entire filter. If the buffer wasn't big enough to hold the
 193  * filter, ldap_search_s will complain, but the only situation where this
 194  * is likely to happen is if the client sent a really, really long
 195  * username, most likely as part of an attack.
 196  *
 197  * The search filter consists of the filter provided with the URL,
 198  * combined with a filter made up of the attribute provided with the URL,
 199  * and the actual username passed by the HTTP client. For example, assume
 200  * that the LDAP URL is
 201  *
 202  *   ldap://ldap.airius.com/ou=People, o=Airius?uid??(posixid=*)
 203  *
 204  * Further, assume that the userid passed by the client was `userj'.  The
 205  * search filter will be (&(posixid=*)(uid=userj)).
 206  */
 207 #define FILTER_LENGTH MAX_STRING_LEN
 208 static void authn_ldap_build_filter(char *filtbuf,
 209                              request_rec *r,
 210                              const char* sent_user,
 211                              const char* sent_filter,
 212                              authn_ldap_config_t *sec)
 213 {
 214     char *p, *q, *filtbuf_end;
 215     char *user, *filter;
 216     apr_xlate_t *convset = NULL;
 217     apr_size_t inbytes;
 218     apr_size_t outbytes;
 219     char *outbuf;
 220
 221     if (sent_user != NULL) {
 222         user = apr_pstrdup (r->pool, sent_user);
 223     }
 224     else
 225         return;
 226
 227     if (sent_filter != NULL) {
 228         filter = apr_pstrdup (r->pool, sent_filter);
 229     }
 230     else
 231         filter = sec->filter;
 232
 233     if (charset_conversions) {
 234         convset = get_conv_set(r);
 235     }
 236
 237     if (convset) {
 238         inbytes = strlen(user);
 239         outbytes = (inbytes+1)*3;
 240         outbuf = apr_pcalloc(r->pool, outbytes);
 241
 242         /* Convert the user name to UTF-8.  This is only valid for LDAP v3 */
 243         if (apr_xlate_conv_buffer(convset, user, &inbytes, outbuf, &outbytes) == APR_SUCCESS) {
 244             user = apr_pstrdup(r->pool, outbuf);
 245         }
 246     }
 247
 248     /*
 249      * Create the first part of the filter, which consists of the
 250      * config-supplied portions.
 251      */
 252     apr_snprintf(filtbuf, FILTER_LENGTH, "(&(%s)(%s=", filter, sec->attribute);
 253
 254     /*
 255      * Now add the client-supplied username to the filter, ensuring that any
 256      * LDAP filter metachars are escaped.
 257      */
 258     filtbuf_end = filtbuf + FILTER_LENGTH - 1;
 259 #if APR_HAS_MICROSOFT_LDAPSDK
 260     for (p = user, q=filtbuf + strlen(filtbuf);
 261          *p && q < filtbuf_end; ) {
 262         if (strchr("*()\\", *p) != NULL) {
 263             if ( q + 3 >= filtbuf_end)
 264               break;  /* Don't write part of escape sequence if we can't write all of it */
 265             *q++ = '\\';
 266             switch ( *p++ )
 267             {
 268               case '*':
 269                 *q++ = '2';
 270                 *q++ = 'a';
 271                 break;
 272               case '(':
 273                 *q++ = '2';
 274                 *q++ = '8';
 275                 break;
 276               case ')':
 277                 *q++ = '2';
 278                 *q++ = '9';
 279                 break;
 280               case '\\':
 281                 *q++ = '5';
 282                 *q++ = 'c';
 283                 break;
 284                         }
 285         }
 286         else
 287             *q++ = *p++;
 288     }
 289 #else
 290     for (p = user, q=filtbuf + strlen(filtbuf);
 291          *p && q < filtbuf_end; *q++ = *p++) {
 292         if (strchr("*()\\", *p) != NULL) {
 293             *q++ = '\\';
 294             if (q >= filtbuf_end) {
 295               break;
 296             }
 297         }
 298     }
 299 #endif
 300     *q = '\0';
 301
 302     /*
 303      * Append the closing parens of the filter, unless doing so would
 304      * overrun the buffer.
 305      */
 306     if (q + 2 <= filtbuf_end)
 307         strcat(filtbuf, "))");
 308 }
 309
 310 static void *create_authnz_ldap_dir_config(apr_pool_t *p, char *d)
 311 {
 312     authn_ldap_config_t *sec =
 313         (authn_ldap_config_t *)apr_pcalloc(p, sizeof(authn_ldap_config_t));
 314
 315     sec->pool = p;
 316 #if APR_HAS_THREADS
 317     apr_thread_mutex_create(&sec->lock, APR_THREAD_MUTEX_DEFAULT, p);
 318 #endif
 319 /*
 320     sec->authz_enabled = 1;
 321 */
 322     sec->groupattr = apr_array_make(p, GROUPATTR_MAX_ELTS,
 323                                     sizeof(struct mod_auth_ldap_groupattr_entry_t));
 324     sec->subgroupclasses = apr_array_make(p, GROUPATTR_MAX_ELTS,
 325                                     sizeof(struct mod_auth_ldap_groupattr_entry_t));
 326
 327     sec->have_ldap_url = 0;
 328     sec->url = "";
 329     sec->host = NULL;
 330     sec->binddn = NULL;
 331     sec->bindpw = NULL;
 332     sec->bind_authoritative = 1;
 333     sec->deref = always;
 334     sec->group_attrib_is_dn = 1;
 335     sec->secure = -1;   /*Initialize to unset*/
 336     sec->maxNestingDepth = 10;
 337     sec->sgAttributes = apr_pcalloc(p, sizeof (char *) * GROUPATTR_MAX_ELTS + 1);
 338
 339     sec->user_is_dn = 0;
 340     sec->remote_user_attribute = NULL;
 341     sec->compare_dn_on_server = 0;
 342
 343     sec->authz_prefix = AUTHZ_PREFIX;
 344
 345     return sec;
 346 }
 347
 348 static apr_status_t authnz_ldap_cleanup_connection_close(void *param)
 349 {
 350     util_ldap_connection_t *ldc = param;
 351     util_ldap_connection_close(ldc);
 352     return APR_SUCCESS;
 353 }
 354
 355 static int set_request_vars(request_rec *r, enum auth_ldap_phase phase) {
 356     char *prefix = NULL;
 357     int prefix_len;
 358     int remote_user_attribute_set = 0;
 359     authn_ldap_request_t *req =
 360         (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);
 361     authn_ldap_config_t *sec =
 362         (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);
 363     const char **vals = req->vals;
 364
 365     prefix = (phase == LDAP_AUTHN) ? AUTHN_PREFIX : sec->authz_prefix;
 366     prefix_len = strlen(prefix);
 367
 368     if (sec->attributes && vals) {
 369         apr_table_t *e = r->subprocess_env;
 370         int i = 0;
 371         while (sec->attributes[i]) {
 372             char *str = apr_pstrcat(r->pool, prefix, sec->attributes[i], NULL);
 373             int j = prefix_len;
 374             while (str[j]) {
 375                 str[j] = apr_toupper(str[j]);
 376                 j++;
 377             }
 378             apr_table_setn(e, str, vals[i] ? vals[i] : "");
 379
 380             /* handle remote_user_attribute, if set */
 381             if ((phase == LDAP_AUTHN) &&
 382                 sec->remote_user_attribute &&
 383                 !strcmp(sec->remote_user_attribute, sec->attributes[i])) {
 384                 r->user = (char *)apr_pstrdup(r->pool, vals[i]);
 385                 remote_user_attribute_set = 1;
 386             }
 387             i++;
 388         }
 389     }
 390     return remote_user_attribute_set;
 391 }
 392
 393 static const char *ldap_determine_binddn(request_rec *r, const char *user) {
 394     authn_ldap_config_t *sec =
 395         (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);
 396     const char *result = user;
 397     ap_regmatch_t regm[AP_MAX_REG_MATCH];
 398
 399     if (NULL == user || NULL == sec || !sec->bind_regex || !sec->bind_subst) {
 400         return result;
 401     }
 402
 403     if (!ap_regexec(sec->bind_regex, user, AP_MAX_REG_MATCH, regm, 0)) {
 404         char *substituted = ap_pregsub(r->pool, sec->bind_subst, user, AP_MAX_REG_MATCH, regm);
 405         if (NULL != substituted) {
 406             result = substituted;
 407         }
 408     }
 409
 410     apr_table_set(r->subprocess_env, "LDAP_BINDASUSER", result);
 411
 412     return result;
 413 }
 414
 415
 416 /* Some LDAP servers restrict who can search or compare, and the hard-coded ID
 417  * might be good for the DN lookup but not for later operations.
 418  */
 419 static util_ldap_connection_t *get_connection_for_authz(request_rec *r, enum auth_ldap_optype type) {
 420     authn_ldap_request_t *req =
 421         (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);
 422     authn_ldap_config_t *sec =
 423         (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);
 424
 425     char *binddn = sec->binddn;
 426     char *bindpw = sec->bindpw;
 427
 428     /* If the per-request config isn't set, we didn't authenticate this user, and leave the default credentials */
 429     if (req && req->password &&
 430          ((type == LDAP_SEARCH && sec->search_as_user)    ||
 431           (type == LDAP_COMPARE && sec->compare_as_user)  ||
 432           (type == LDAP_COMPARE_AND_SEARCH && sec->compare_as_user && sec->search_as_user))){
 433             binddn = req->dn;
 434             bindpw = req->password;
 435     }
 436
 437     return util_ldap_connection_find(r, sec->host, sec->port,
 438                                      binddn, bindpw,
 439                                      sec->deref, sec->secure);
 440 }
 441 /*
 442  * Authentication Phase
 443  * --------------------
 444  *
 445  * This phase authenticates the credentials the user has sent with
 446  * the request (ie the username and password are checked). This is done
 447  * by making an attempt to bind to the LDAP server using this user's
 448  * DN and the supplied password.
 449  *
 450  */
 451 static authn_status authn_ldap_check_password(request_rec *r, const char *user,
 452                                               const char *password)
 453 {
 454     char filtbuf[FILTER_LENGTH];
 455     authn_ldap_config_t *sec =
 456         (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);
 457
 458     util_ldap_connection_t *ldc = NULL;
 459     int result = 0;
 460     int remote_user_attribute_set = 0;
 461     const char *dn = NULL;
 462     const char *utfpassword;
 463
 464     authn_ldap_request_t *req =
 465         (authn_ldap_request_t *)apr_pcalloc(r->pool, sizeof(authn_ldap_request_t));
 466     ap_set_module_config(r->request_config, &authnz_ldap_module, req);
 467
 468 /*
 469     if (!sec->enabled) {
 470         return AUTH_USER_NOT_FOUND;
 471     }
 472 */
 473
 474     /*
 475      * Basic sanity checks before any LDAP operations even happen.
 476      */
 477     if (!sec->have_ldap_url) {
 478         return AUTH_GENERAL_ERROR;
 479     }
 480
 481     /* There is a good AuthLDAPURL, right? */
 482     if (sec->host) {
 483         const char *binddn = sec->binddn;
 484         const char *bindpw = sec->bindpw;
 485         if (sec->initial_bind_as_user) {
 486             bindpw = password;
 487             binddn = ldap_determine_binddn(r, user);
 488         }
 489
 490         ldc = util_ldap_connection_find(r, sec->host, sec->port,
 491                                        binddn, bindpw,
 492                                        sec->deref, sec->secure);
 493     }
 494     else {
 495         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
 496                       "auth_ldap authenticate: no sec->host - weird...?");
 497         return AUTH_GENERAL_ERROR;
 498     }
 499
 500     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 501                   "auth_ldap authenticate: using URL %s", sec->url);
 502
 503     /* Get the password that the client sent */
 504     if (password == NULL) {
 505         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 506                       "auth_ldap authenticate: no password specified");
 507         util_ldap_connection_close(ldc);
 508         return AUTH_GENERAL_ERROR;
 509     }
 510
 511     if (user == NULL) {
 512         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 513                       "auth_ldap authenticate: no user specified");
 514         util_ldap_connection_close(ldc);
 515         return AUTH_GENERAL_ERROR;
 516     }
 517
 518     /* build the username filter */
 519     authn_ldap_build_filter(filtbuf, r, user, NULL, sec);
 520
 521     ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r,
 522                       "auth_ldap authenticate: final authn filter is %s", filtbuf);
 523
 524     /* convert password to utf-8 */
 525     utfpassword = authn_ldap_xlate_password(r, password);
 526
 527     /* do the user search */
 528     result = util_ldap_cache_checkuserid(r, ldc, sec->url, sec->basedn, sec->scope,
 529                                          sec->attributes, filtbuf, utfpassword,
 530                                          &dn, &(req->vals));
 531     util_ldap_connection_close(ldc);
 532
 533     /* handle bind failure */
 534     if (result != LDAP_SUCCESS) {
 535         if (!sec->bind_authoritative) {
 536            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 537                       "auth_ldap authenticate: user %s authentication failed; "
 538                       "URI %s [%s][%s] (not authoritative)",
 539                       user, r->uri, ldc->reason, ldap_err2string(result));
 540            return AUTH_USER_NOT_FOUND;
 541         }
 542
 543         ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,
 544                       "auth_ldap authenticate: "
 545                       "user %s authentication failed; URI %s [%s][%s]",
 546                       user, r->uri, ldc->reason, ldap_err2string(result));
 547
 548         return (LDAP_NO_SUCH_OBJECT == result) ? AUTH_USER_NOT_FOUND
 549 #ifdef LDAP_SECURITY_ERROR
 550                  : (LDAP_SECURITY_ERROR(result)) ? AUTH_DENIED
 551 #else
 552                  : (LDAP_INAPPROPRIATE_AUTH == result) ? AUTH_DENIED
 553                  : (LDAP_INVALID_CREDENTIALS == result) ? AUTH_DENIED
 554 #ifdef LDAP_INSUFFICIENT_ACCESS
 555                  : (LDAP_INSUFFICIENT_ACCESS == result) ? AUTH_DENIED
 556 #endif
 557 #ifdef LDAP_INSUFFICIENT_RIGHTS
 558                  : (LDAP_INSUFFICIENT_RIGHTS == result) ? AUTH_DENIED
 559 #endif
 560 #endif
 561 #ifdef LDAP_CONSTRAINT_VIOLATION
 562     /* At least Sun Directory Server sends this if a user is
 563      * locked. This is not covered by LDAP_SECURITY_ERROR.
 564      */
 565                  : (LDAP_CONSTRAINT_VIOLATION == result) ? AUTH_DENIED
 566 #endif
 567                  : AUTH_GENERAL_ERROR;
 568     }
 569
 570     /* mark the user and DN */
 571     req->dn = apr_pstrdup(r->pool, dn);
 572     req->user = apr_pstrdup(r->pool, user);
 573     req->password = apr_pstrdup(r->pool, password);
 574     if (sec->user_is_dn) {
 575         r->user = req->dn;
 576     }
 577
 578     /* add environment variables */
 579     remote_user_attribute_set = set_request_vars(r, LDAP_AUTHN);
 580
 581     /* sanity check */
 582     if (sec->remote_user_attribute && !remote_user_attribute_set) {
 583         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
 584                   "auth_ldap authenticate: "
 585                   "REMOTE_USER was to be set with attribute '%s', "
 586                   "but this attribute was not requested for in the "
 587                   "LDAP query for the user. REMOTE_USER will fall "
 588                   "back to username or DN as appropriate.",
 589                   sec->remote_user_attribute);
 590     }
 591
 592     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 593                   "auth_ldap authenticate: accepting %s", user);
 594
 595     return AUTH_GRANTED;
 596 }
 597
 598 static authz_status ldapuser_check_authorization(request_rec *r,
 599                                                  const char *require_args,
 600                                                  const void *parsed_require_args)
 601 {
 602     int result = 0;
 603     authn_ldap_request_t *req =
 604         (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);
 605     authn_ldap_config_t *sec =
 606         (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);
 607
 608     util_ldap_connection_t *ldc = NULL;
 609
 610     const char *t;
 611     char *w;
 612
 613     char filtbuf[FILTER_LENGTH];
 614     const char *dn = NULL;
 615
 616     if (!r->user) {
 617         return AUTHZ_DENIED_NO_USER;
 618     }
 619
 620     if (!sec->have_ldap_url) {
 621         return AUTHZ_DENIED;
 622     }
 623
 624     if (sec->host) {
 625         ldc = get_connection_for_authz(r, LDAP_COMPARE);
 626         apr_pool_cleanup_register(r->pool, ldc,
 627                                   authnz_ldap_cleanup_connection_close,
 628                                   apr_pool_cleanup_null);
 629     }
 630     else {
 631         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
 632                       "auth_ldap authorize: no sec->host - weird...?");
 633         return AUTHZ_DENIED;
 634     }
 635
 636     /*
 637      * If we have been authenticated by some other module than mod_authnz_ldap,
 638      * the req structure needed for authorization needs to be created
 639      * and populated with the userid and DN of the account in LDAP
 640      */
 641
 642
 643     if (!strlen(r->user)) {
 644         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
 645             "ldap authorize: Userid is blank, AuthType=%s",
 646             r->ap_auth_type);
 647     }
 648
 649     if(!req) {
 650         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 651             "ldap authorize: Creating LDAP req structure");
 652
 653         req = (authn_ldap_request_t *)apr_pcalloc(r->pool,
 654             sizeof(authn_ldap_request_t));
 655
 656         /* Build the username filter */
 657         authn_ldap_build_filter(filtbuf, r, r->user, NULL, sec);
 658
 659         /* Search for the user DN */
 660         result = util_ldap_cache_getuserdn(r, ldc, sec->url, sec->basedn,
 661              sec->scope, sec->attributes, filtbuf, &dn, &(req->vals));
 662
 663         /* Search failed, log error and return failure */
 664         if(result != LDAP_SUCCESS) {
 665             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 666                 "auth_ldap authorise: User DN not found, %s", ldc->reason);
 667             return AUTHZ_DENIED;
 668         }
 669
 670         ap_set_module_config(r->request_config, &authnz_ldap_module, req);
 671         req->dn = apr_pstrdup(r->pool, dn);
 672         req->user = r->user;
 673
 674     }
 675
 676     if (req->dn == NULL || strlen(req->dn) == 0) {
 677         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 678                       "auth_ldap authorize: require user: user's DN has not "
 679                       "been defined; failing authorization");
 680         return AUTHZ_DENIED;
 681     }
 682
 683     /*
 684      * First do a whole-line compare, in case it's something like
 685      *   require user Babs Jensen
 686      */
 687     result = util_ldap_cache_compare(r, ldc, sec->url, req->dn, sec->attribute, require_args);
 688     switch(result) {
 689         case LDAP_COMPARE_TRUE: {
 690             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 691                           "auth_ldap authorize: require user: authorization "
 692                           "successful");
 693             set_request_vars(r, LDAP_AUTHZ);
 694             return AUTHZ_GRANTED;
 695         }
 696         default: {
 697             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 698                           "auth_ldap authorize: require user: "
 699                           "authorization failed [%s][%s]",
 700                           ldc->reason, ldap_err2string(result));
 701         }
 702     }
 703
 704     /*
 705      * Now break apart the line and compare each word on it
 706      */
 707     t = require_args;
 708     while ((w = ap_getword_conf(r->pool, &t)) && w[0]) {
 709         result = util_ldap_cache_compare(r, ldc, sec->url, req->dn, sec->attribute, w);
 710         switch(result) {
 711             case LDAP_COMPARE_TRUE: {
 712                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 713                               "auth_ldap authorize: "
 714                               "require user: authorization successful");
 715                 set_request_vars(r, LDAP_AUTHZ);
 716                 return AUTHZ_GRANTED;
 717             }
 718             default: {
 719                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 720                               "auth_ldap authorize: "
 721                               "require user: authorization failed [%s][%s]",
 722                               ldc->reason, ldap_err2string(result));
 723             }
 724         }
 725     }
 726
 727     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 728                   "auth_ldap authorize user: authorization denied for "
 729                   "user %s to %s",
 730                   r->user, r->uri);
 731
 732     return AUTHZ_DENIED;
 733 }
 734
 735 static authz_status ldapgroup_check_authorization(request_rec *r,
 736                                                   const char *require_args,
 737                                                   const void *parsed_require_args)
 738 {
 739     int result = 0;
 740     authn_ldap_request_t *req =
 741         (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);
 742     authn_ldap_config_t *sec =
 743         (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);
 744
 745     util_ldap_connection_t *ldc = NULL;
 746
 747     const char *t;
 748
 749     char filtbuf[FILTER_LENGTH];
 750     const char *dn = NULL;
 751     struct mod_auth_ldap_groupattr_entry_t *ent;
 752     int i;
 753
 754     if (!r->user) {
 755         return AUTHZ_DENIED_NO_USER;
 756     }
 757
 758     if (!sec->have_ldap_url) {
 759         return AUTHZ_DENIED;
 760     }
 761
 762     if (sec->host) {
 763         ldc = get_connection_for_authz(r, LDAP_COMPARE); /* for the top-level group only */
 764         apr_pool_cleanup_register(r->pool, ldc,
 765                                   authnz_ldap_cleanup_connection_close,
 766                                   apr_pool_cleanup_null);
 767     }
 768     else {
 769         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
 770                       "auth_ldap authorize: no sec->host - weird...?");
 771         return AUTHZ_DENIED;
 772     }
 773
 774     /*
 775      * If there are no elements in the group attribute array, the default should be
 776      * member and uniquemember; populate the array now.
 777      */
 778     if (sec->groupattr->nelts == 0) {
 779         struct mod_auth_ldap_groupattr_entry_t *grp;
 780 #if APR_HAS_THREADS
 781         apr_thread_mutex_lock(sec->lock);
 782 #endif
 783         grp = apr_array_push(sec->groupattr);
 784         grp->name = "member";
 785         grp = apr_array_push(sec->groupattr);
 786         grp->name = "uniqueMember";
 787 #if APR_HAS_THREADS
 788         apr_thread_mutex_unlock(sec->lock);
 789 #endif
 790     }
 791
 792     /*
 793      * If there are no elements in the sub group classes array, the default
 794      * should be groupOfNames and groupOfUniqueNames; populate the array now.
 795      */
 796     if (sec->subgroupclasses->nelts == 0) {
 797         struct mod_auth_ldap_groupattr_entry_t *grp;
 798 #if APR_HAS_THREADS
 799         apr_thread_mutex_lock(sec->lock);
 800 #endif
 801         grp = apr_array_push(sec->subgroupclasses);
 802         grp->name = "groupOfNames";
 803         grp = apr_array_push(sec->subgroupclasses);
 804         grp->name = "groupOfUniqueNames";
 805 #if APR_HAS_THREADS
 806         apr_thread_mutex_unlock(sec->lock);
 807 #endif
 808     }
 809
 810     /*
 811      * If we have been authenticated by some other module than mod_auth_ldap,
 812      * the req structure needed for authorization needs to be created
 813      * and populated with the userid and DN of the account in LDAP
 814      */
 815
 816     if (!strlen(r->user)) {
 817         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
 818             "ldap authorize: Userid is blank, AuthType=%s",
 819             r->ap_auth_type);
 820     }
 821
 822     if(!req) {
 823         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 824             "ldap authorize: Creating LDAP req structure");
 825
 826         req = (authn_ldap_request_t *)apr_pcalloc(r->pool,
 827             sizeof(authn_ldap_request_t));
 828         /* Build the username filter */
 829         authn_ldap_build_filter(filtbuf, r, r->user, NULL, sec);
 830
 831         /* Search for the user DN */
 832         result = util_ldap_cache_getuserdn(r, ldc, sec->url, sec->basedn,
 833              sec->scope, sec->attributes, filtbuf, &dn, &(req->vals));
 834
 835         /* Search failed, log error and return failure */
 836         if(result != LDAP_SUCCESS) {
 837             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 838                 "auth_ldap authorise: User DN not found, %s", ldc->reason);
 839             return AUTHZ_DENIED;
 840         }
 841
 842         ap_set_module_config(r->request_config, &authnz_ldap_module, req);
 843         req->dn = apr_pstrdup(r->pool, dn);
 844         req->user = r->user;
 845     }
 846
 847     ent = (struct mod_auth_ldap_groupattr_entry_t *) sec->groupattr->elts;
 848
 849     if (sec->group_attrib_is_dn) {
 850         if (req->dn == NULL || strlen(req->dn) == 0) {
 851             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 852                           "auth_ldap authorize: require group: user's DN has "
 853                           "not been defined; failing authorization for user %s",
 854                           r->user);
 855             return AUTHZ_DENIED;
 856         }
 857     }
 858     else {
 859         if (req->user == NULL || strlen(req->user) == 0) {
 860             /* We weren't called in the authentication phase, so we didn't have a
 861              * chance to set the user field. Do so now. */
 862             req->user = r->user;
 863         }
 864     }
 865
 866     t = require_args;
 867
 868     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 869                   "auth_ldap authorize: require group: testing for group "
 870                   "membership in \"%s\"",
 871                   t);
 872
 873     for (i = 0; i < sec->groupattr->nelts; i++) {
 874         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 875                       "auth_ldap authorize: require group: testing for %s: "
 876                       "%s (%s)",
 877                       ent[i].name,
 878                       sec->group_attrib_is_dn ? req->dn : req->user, t);
 879
 880         result = util_ldap_cache_compare(r, ldc, sec->url, t, ent[i].name,
 881                              sec->group_attrib_is_dn ? req->dn : req->user);
 882         switch(result) {
 883             case LDAP_COMPARE_TRUE: {
 884                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 885                               "auth_ldap authorize: require group: "
 886                               "authorization successful (attribute %s) "
 887                               "[%s][%d - %s]",
 888                               ent[i].name, ldc->reason, result,
 889                               ldap_err2string(result));
 890                 set_request_vars(r, LDAP_AUTHZ);
 891                 return AUTHZ_GRANTED;
 892             }
 893             case LDAP_NO_SUCH_ATTRIBUTE:
 894             case LDAP_COMPARE_FALSE: {
 895                 /* nested groups need searches and compares, so grab a new handle */
 896                 authnz_ldap_cleanup_connection_close(ldc);
 897                 apr_pool_cleanup_kill(r->pool, ldc,authnz_ldap_cleanup_connection_close);
 898
 899                 ldc = get_connection_for_authz(r, LDAP_COMPARE_AND_SEARCH);
 900                 apr_pool_cleanup_register(r->pool, ldc,
 901                                           authnz_ldap_cleanup_connection_close,
 902                                           apr_pool_cleanup_null);
 903
 904                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 905                                "auth_ldap authorise: require group \"%s\": "
 906                                "failed [%s][%d - %s], checking sub-groups",
 907                                t, ldc->reason, result, ldap_err2string(result));
 908
 909                 result = util_ldap_cache_check_subgroups(r, ldc, sec->url, t, ent[i].name,
 910                                                          sec->group_attrib_is_dn ? req->dn : req->user,
 911                                                          sec->sgAttributes[0] ? sec->sgAttributes : default_attributes,
 912                                                          sec->subgroupclasses,
 913                                                          0, sec->maxNestingDepth);
 914                 if(result == LDAP_COMPARE_TRUE) {
 915                     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 916                                   "auth_ldap authorise: require group "
 917                                   "(sub-group): authorisation successful "
 918                                   "(attribute %s) [%s][%d - %s]",
 919                                   ent[i].name, ldc->reason, result,
 920                                   ldap_err2string(result));
 921                     set_request_vars(r, LDAP_AUTHZ);
 922                     return AUTHZ_GRANTED;
 923                 }
 924                 else {
 925                     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 926                                   "auth_ldap authorise: require group "
 927                                   "(sub-group) \"%s\": authorisation failed "
 928                                   "[%s][%d - %s]",
 929                                   t, ldc->reason, result,
 930                                   ldap_err2string(result));
 931                 }
 932                 break;
 933             }
 934             default: {
 935                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 936                               "auth_ldap authorize: require group \"%s\": "
 937                               "authorization failed [%s][%d - %s]",
 938                               t, ldc->reason, result, ldap_err2string(result));
 939             }
 940         }
 941     }
 942
 943     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 944                   "auth_ldap authorize group: authorization denied for "
 945                   "user %s to %s",
 946                   r->user, r->uri);
 947
 948     return AUTHZ_DENIED;
 949 }
 950
 951 static authz_status ldapdn_check_authorization(request_rec *r,
 952                                                const char *require_args,
 953                                                const void *parsed_require_args)
 954 {
 955     int result = 0;
 956     authn_ldap_request_t *req =
 957         (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);
 958     authn_ldap_config_t *sec =
 959         (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);
 960
 961     util_ldap_connection_t *ldc = NULL;
 962
 963     const char *t;
 964
 965     char filtbuf[FILTER_LENGTH];
 966     const char *dn = NULL;
 967
 968     if (!r->user) {
 969         return AUTHZ_DENIED_NO_USER;
 970     }
 971
 972     if (!sec->have_ldap_url) {
 973         return AUTHZ_DENIED;
 974     }
 975
 976     if (sec->host) {
 977         ldc = get_connection_for_authz(r, LDAP_SEARCH); /* _comparedn is a searche */
 978         apr_pool_cleanup_register(r->pool, ldc,
 979                                   authnz_ldap_cleanup_connection_close,
 980                                   apr_pool_cleanup_null);
 981     }
 982     else {
 983         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
 984                       "auth_ldap authorize: no sec->host - weird...?");
 985         return AUTHZ_DENIED;
 986     }
 987
 988     /*
 989      * If we have been authenticated by some other module than mod_auth_ldap,
 990      * the req structure needed for authorization needs to be created
 991      * and populated with the userid and DN of the account in LDAP
 992      */
 993
 994     if (!strlen(r->user)) {
 995         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
 996             "ldap authorize: Userid is blank, AuthType=%s",
 997             r->ap_auth_type);
 998     }
 999
1000     if(!req) {
1001         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1002             "ldap authorize: Creating LDAP req structure");
1003
1004         req = (authn_ldap_request_t *)apr_pcalloc(r->pool,
1005             sizeof(authn_ldap_request_t));
1006         /* Build the username filter */
1007         authn_ldap_build_filter(filtbuf, r, r->user, NULL, sec);
1008
1009         /* Search for the user DN */
1010         result = util_ldap_cache_getuserdn(r, ldc, sec->url, sec->basedn,
1011              sec->scope, sec->attributes, filtbuf, &dn, &(req->vals));
1012
1013         /* Search failed, log error and return failure */
1014         if(result != LDAP_SUCCESS) {
1015             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1016                 "auth_ldap authorise: User DN not found with filter %s: %s", filtbuf, ldc->reason);
1017             return AUTHZ_DENIED;
1018         }
1019
1020         ap_set_module_config(r->request_config, &authnz_ldap_module, req);
1021         req->dn = apr_pstrdup(r->pool, dn);
1022         req->user = r->user;
1023     }
1024
1025     t = require_args;
1026
1027     if (req->dn == NULL || strlen(req->dn) == 0) {
1028         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1029                       "auth_ldap authorize: require dn: user's DN has not "
1030                       "been defined; failing authorization");
1031         return AUTHZ_DENIED;
1032     }
1033
1034     result = util_ldap_cache_comparedn(r, ldc, sec->url, req->dn, t, sec->compare_dn_on_server);
1035     switch(result) {
1036         case LDAP_COMPARE_TRUE: {
1037             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1038                           "auth_ldap authorize: "
1039                           "require dn: authorization successful");
1040             set_request_vars(r, LDAP_AUTHZ);
1041             return AUTHZ_GRANTED;
1042         }
1043         default: {
1044             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1045                           "auth_ldap authorize: "
1046                           "require dn \"%s\": LDAP error [%s][%s]",
1047                           t, ldc->reason, ldap_err2string(result));
1048         }
1049     }
1050
1051
1052     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1053                   "auth_ldap authorize dn: authorization denied for "
1054                   "user %s to %s",
1055                   r->user, r->uri);
1056
1057     return AUTHZ_DENIED;
1058 }
1059
1060 static authz_status ldapattribute_check_authorization(request_rec *r,
1061                                                       const char *require_args,
1062                                                       const void *parsed_require_args)
1063 {
1064     int result = 0;
1065     authn_ldap_request_t *req =
1066         (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);
1067     authn_ldap_config_t *sec =
1068         (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);
1069
1070     util_ldap_connection_t *ldc = NULL;
1071
1072     const char *t;
1073     char *w, *value;
1074
1075     char filtbuf[FILTER_LENGTH];
1076     const char *dn = NULL;
1077
1078     if (!r->user) {
1079         return AUTHZ_DENIED_NO_USER;
1080     }
1081
1082     if (!sec->have_ldap_url) {
1083         return AUTHZ_DENIED;
1084     }
1085
1086     if (sec->host) {
1087         ldc = get_connection_for_authz(r, LDAP_COMPARE);
1088         apr_pool_cleanup_register(r->pool, ldc,
1089                                   authnz_ldap_cleanup_connection_close,
1090                                   apr_pool_cleanup_null);
1091     }
1092     else {
1093         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
1094                       "auth_ldap authorize: no sec->host - weird...?");
1095         return AUTHZ_DENIED;
1096     }
1097
1098     /*
1099      * If we have been authenticated by some other module than mod_auth_ldap,
1100      * the req structure needed for authorization needs to be created
1101      * and populated with the userid and DN of the account in LDAP
1102      */
1103
1104     if (!strlen(r->user)) {
1105         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
1106             "ldap authorize: Userid is blank, AuthType=%s",
1107             r->ap_auth_type);
1108     }
1109
1110     if(!req) {
1111         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1112             "ldap authorize: Creating LDAP req structure");
1113
1114         req = (authn_ldap_request_t *)apr_pcalloc(r->pool,
1115             sizeof(authn_ldap_request_t));
1116         /* Build the username filter */
1117         authn_ldap_build_filter(filtbuf, r, r->user, NULL, sec);
1118
1119         /* Search for the user DN */
1120         result = util_ldap_cache_getuserdn(r, ldc, sec->url, sec->basedn,
1121              sec->scope, sec->attributes, filtbuf, &dn, &(req->vals));
1122
1123         /* Search failed, log error and return failure */
1124         if(result != LDAP_SUCCESS) {
1125             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1126                 "auth_ldap authorise: User DN not found with filter %s: %s", filtbuf, ldc->reason);
1127             return AUTHZ_DENIED;
1128         }
1129
1130         ap_set_module_config(r->request_config, &authnz_ldap_module, req);
1131         req->dn = apr_pstrdup(r->pool, dn);
1132         req->user = r->user;
1133     }
1134
1135     if (req->dn == NULL || strlen(req->dn) == 0) {
1136         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1137                       "auth_ldap authorize: require ldap-attribute: user's DN "
1138                       "has not been defined; failing authorization");
1139         return AUTHZ_DENIED;
1140     }
1141
1142     t = require_args;
1143     while (t[0]) {
1144         w = ap_getword(r->pool, &t, '=');
1145         value = ap_getword_conf(r->pool, &t);
1146
1147         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1148                       "auth_ldap authorize: checking attribute %s has value %s",
1149                       w, value);
1150         result = util_ldap_cache_compare(r, ldc, sec->url, req->dn, w, value);
1151         switch(result) {
1152             case LDAP_COMPARE_TRUE: {
1153                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1154                               "auth_ldap authorize: "
1155                               "require attribute: authorization successful");
1156                 set_request_vars(r, LDAP_AUTHZ);
1157                 return AUTHZ_GRANTED;
1158             }
1159             default: {
1160                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1161                               "auth_ldap authorize: require attribute: "
1162                               "authorization failed [%s][%s]",
1163                               ldc->reason, ldap_err2string(result));
1164             }
1165         }
1166     }
1167
1168     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1169                   "auth_ldap authorize attribute: authorization denied for "
1170                   "user %s to %s",
1171                   r->user, r->uri);
1172
1173     return AUTHZ_DENIED;
1174 }
1175
1176 static authz_status ldapfilter_check_authorization(request_rec *r,
1177                                                    const char *require_args,
1178                                                    const void *parsed_require_args)
1179 {
1180     int result = 0;
1181     authn_ldap_request_t *req =
1182         (authn_ldap_request_t *)ap_get_module_config(r->request_config, &authnz_ldap_module);
1183     authn_ldap_config_t *sec =
1184         (authn_ldap_config_t *)ap_get_module_config(r->per_dir_config, &authnz_ldap_module);
1185
1186     util_ldap_connection_t *ldc = NULL;
1187     const char *t;
1188
1189     char filtbuf[FILTER_LENGTH];
1190     const char *dn = NULL;
1191
1192     if (!r->user) {
1193         return AUTHZ_DENIED_NO_USER;
1194     }
1195
1196     if (!sec->have_ldap_url) {
1197         return AUTHZ_DENIED;
1198     }
1199
1200     if (sec->host) {
1201         ldc = get_connection_for_authz(r, LDAP_SEARCH);
1202         apr_pool_cleanup_register(r->pool, ldc,
1203                                   authnz_ldap_cleanup_connection_close,
1204                                   apr_pool_cleanup_null);
1205     }
1206     else {
1207         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
1208                       "auth_ldap authorize: no sec->host - weird...?");
1209         return AUTHZ_DENIED;
1210     }
1211
1212     /*
1213      * If we have been authenticated by some other module than mod_auth_ldap,
1214      * the req structure needed for authorization needs to be created
1215      * and populated with the userid and DN of the account in LDAP
1216      */
1217
1218     if (!strlen(r->user)) {
1219         ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
1220             "ldap authorize: Userid is blank, AuthType=%s",
1221             r->ap_auth_type);
1222     }
1223
1224     if(!req) {
1225         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1226             "ldap authorize: Creating LDAP req structure");
1227
1228         req = (authn_ldap_request_t *)apr_pcalloc(r->pool,
1229             sizeof(authn_ldap_request_t));
1230         /* Build the username filter */
1231         authn_ldap_build_filter(filtbuf, r, r->user, NULL, sec);
1232
1233         /* Search for the user DN */
1234         result = util_ldap_cache_getuserdn(r, ldc, sec->url, sec->basedn,
1235              sec->scope, sec->attributes, filtbuf, &dn, &(req->vals));
1236
1237         /* Search failed, log error and return failure */
1238         if(result != LDAP_SUCCESS) {
1239             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1240                 "auth_ldap authorise: User DN not found with filter %s: %s", filtbuf, ldc->reason);
1241             return AUTHZ_DENIED;
1242         }
1243
1244         ap_set_module_config(r->request_config, &authnz_ldap_module, req);
1245         req->dn = apr_pstrdup(r->pool, dn);
1246         req->user = r->user;
1247     }
1248
1249     if (req->dn == NULL || strlen(req->dn) == 0) {
1250         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1251                       "auth_ldap authorize: require ldap-filter: user's DN "
1252                       "has not been defined; failing authorization");
1253         return AUTHZ_DENIED;
1254     }
1255
1256     t = require_args;
1257
1258     if (t[0]) {
1259         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1260                       "auth_ldap authorize: checking filter %s", t);
1261
1262         /* Build the username filter */
1263         authn_ldap_build_filter(filtbuf, r, req->user, t, sec);
1264
1265         /* Search for the user DN */
1266         result = util_ldap_cache_getuserdn(r, ldc, sec->url, sec->basedn,
1267              sec->scope, sec->attributes, filtbuf, &dn, &(req->vals));
1268
1269         /* Make sure that the filtered search returned the correct user dn */
1270         if (result == LDAP_SUCCESS) {
1271             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1272                           "auth_ldap authorize: checking dn match %s", dn);
1273             if (sec->compare_as_user) {
1274                 /* ldap-filter is the only authz that requires a search and a compare */
1275                 apr_pool_cleanup_kill(r->pool, ldc, authnz_ldap_cleanup_connection_close);
1276                 authnz_ldap_cleanup_connection_close(ldc);
1277                 ldc = get_connection_for_authz(r, LDAP_COMPARE);
1278             }
1279             result = util_ldap_cache_comparedn(r, ldc, sec->url, req->dn, dn,
1280                                                sec->compare_dn_on_server);
1281         }
1282
1283         switch(result) {
1284             case LDAP_COMPARE_TRUE: {
1285                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1286                               "auth_ldap authorize: require ldap-filter: "
1287                               "authorization successful");
1288                 set_request_vars(r, LDAP_AUTHZ);
1289                 return AUTHZ_GRANTED;
1290             }
1291             case LDAP_FILTER_ERROR: {
1292                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1293                               "auth_ldap authorize: require ldap-filter: "
1294                               "%s authorization failed [%s][%s]",
1295                               filtbuf, ldc->reason, ldap_err2string(result));
1296                 break;
1297             }
1298             default: {
1299                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1300                               "auth_ldap authorize: require ldap-filter: "
1301                               "authorization failed [%s][%s]",
1302                               ldc->reason, ldap_err2string(result));
1303             }
1304         }
1305     }
1306
1307     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
1308                   "auth_ldap authorize filter: authorization denied for "
1309                   "user %s to %s",
1310                   r->user, r->uri);
1311
1312     return AUTHZ_DENIED;
1313 }
1314
1315
1316 /*
1317  * Use the ldap url parsing routines to break up the ldap url into
1318  * host and port.
1319  */
1320 static const char *mod_auth_ldap_parse_url(cmd_parms *cmd,
1321                                     void *config,
1322                                     const char *url,
1323                                     const char *mode)
1324 {
1325     int rc;
1326     apr_ldap_url_desc_t *urld;
1327     apr_ldap_err_t *result;
1328
1329     authn_ldap_config_t *sec = config;
1330
1331     rc = apr_ldap_url_parse(cmd->pool, url, &(urld), &(result));
1332     if (rc != APR_SUCCESS) {
1333         return result->reason;
1334     }
1335     sec->url = apr_pstrdup(cmd->pool, url);
1336
1337     /* Set all the values, or at least some sane defaults */
1338     if (sec->host) {
1339         sec->host = apr_pstrcat(cmd->pool, urld->lud_host, " ", sec->host, NULL);
1340     }
1341     else {
1342         sec->host = urld->lud_host? apr_pstrdup(cmd->pool, urld->lud_host) : "localhost";
1343     }
1344     sec->basedn = urld->lud_dn? apr_pstrdup(cmd->pool, urld->lud_dn) : "";
1345     if (urld->lud_attrs && urld->lud_attrs[0]) {
1346         int i = 1;
1347         while (urld->lud_attrs[i]) {
1348             i++;
1349         }
1350         sec->attributes = apr_pcalloc(cmd->pool, sizeof(char *) * (i+1));
1351         i = 0;
1352         while (urld->lud_attrs[i]) {
1353             sec->attributes[i] = apr_pstrdup(cmd->pool, urld->lud_attrs[i]);
1354             i++;
1355         }
1356         sec->attribute = sec->attributes[0];
1357     }
1358     else {
1359         sec->attribute = "uid";
1360     }
1361
1362     sec->scope = urld->lud_scope == LDAP_SCOPE_ONELEVEL ?
1363         LDAP_SCOPE_ONELEVEL : LDAP_SCOPE_SUBTREE;
1364
1365     if (urld->lud_filter) {
1366         if (urld->lud_filter[0] == '(') {
1367             /*
1368              * Get rid of the surrounding parens; later on when generating the
1369              * filter, they'll be put back.
1370              */
1371             sec->filter = apr_pstrmemdup(cmd->pool, urld->lud_filter+1,
1372                                                     strlen(urld->lud_filter)-2);
1373         }
1374         else {
1375             sec->filter = apr_pstrdup(cmd->pool, urld->lud_filter);
1376         }
1377     }
1378     else {
1379         sec->filter = "objectclass=*";
1380     }
1381
1382     if (mode) {
1383         if (0 == strcasecmp("NONE", mode)) {
1384             sec->secure = APR_LDAP_NONE;
1385         }
1386         else if (0 == strcasecmp("SSL", mode)) {
1387             sec->secure = APR_LDAP_SSL;
1388         }
1389         else if (0 == strcasecmp("TLS", mode) || 0 == strcasecmp("STARTTLS", mode)) {
1390             sec->secure = APR_LDAP_STARTTLS;
1391         }
1392         else {
1393             return "Invalid LDAP connection mode setting: must be one of NONE, "
1394                    "SSL, or TLS/STARTTLS";
1395         }
1396     }
1397
1398       /* "ldaps" indicates secure ldap connections desired
1399       */
1400     if (strncasecmp(url, "ldaps", 5) == 0)
1401     {
1402         sec->secure = APR_LDAP_SSL;
1403         sec->port = urld->lud_port? urld->lud_port : LDAPS_PORT;
1404     }
1405     else
1406     {
1407         sec->port = urld->lud_port? urld->lud_port : LDAP_PORT;
1408     }
1409
1410     sec->have_ldap_url = 1;
1411
1412     ap_log_error(APLOG_MARK, APLOG_TRACE1, 0, cmd->server,
1413                  "auth_ldap url parse: `%s', Host: %s, Port: %d, DN: %s, "
1414                  "attrib: %s, scope: %s, filter: %s, connection mode: %s",
1415                  url,
1416                  urld->lud_host,
1417                  urld->lud_port,
1418                  urld->lud_dn,
1419                  urld->lud_attrs? urld->lud_attrs[0] : "(null)",
1420                  (urld->lud_scope == LDAP_SCOPE_SUBTREE? "subtree" :
1421                   urld->lud_scope == LDAP_SCOPE_BASE? "base" :
1422                   urld->lud_scope == LDAP_SCOPE_ONELEVEL? "onelevel" : "unknown"),
1423                  urld->lud_filter,
1424                  sec->secure == APR_LDAP_SSL  ? "using SSL": "not using SSL"
1425                  );
1426
1427     return NULL;
1428 }
1429
1430 static const char *mod_auth_ldap_set_deref(cmd_parms *cmd, void *config, const char *arg)
1431 {
1432     authn_ldap_config_t *sec = config;
1433
1434     if (strcmp(arg, "never") == 0 || strcasecmp(arg, "off") == 0) {
1435         sec->deref = never;
1436     }
1437     else if (strcmp(arg, "searching") == 0) {
1438         sec->deref = searching;
1439     }
1440     else if (strcmp(arg, "finding") == 0) {
1441         sec->deref = finding;
1442     }
1443     else if (strcmp(arg, "always") == 0 || strcasecmp(arg, "on") == 0) {
1444         sec->deref = always;
1445     }
1446     else {
1447         return "Unrecognized value for AuthLDAPAliasDereference directive";
1448     }
1449     return NULL;
1450 }
1451
1452 static const char *mod_auth_ldap_add_subgroup_attribute(cmd_parms *cmd, void *config, const char *arg)
1453 {
1454     int i = 0;
1455
1456     authn_ldap_config_t *sec = config;
1457
1458     for (i = 0; sec->sgAttributes[i]; i++) {
1459         ;
1460     }
1461     if (i == GROUPATTR_MAX_ELTS)
1462         return "Too many AuthLDAPSubGroupAttribute values";
1463
1464     sec->sgAttributes[i] = apr_pstrdup(cmd->pool, arg);
1465
1466     return NULL;
1467 }
1468
1469 static const char *mod_auth_ldap_add_subgroup_class(cmd_parms *cmd, void *config, const char *arg)
1470 {
1471     struct mod_auth_ldap_groupattr_entry_t *new;
1472
1473     authn_ldap_config_t *sec = config;
1474
1475     if (sec->subgroupclasses->nelts > GROUPATTR_MAX_ELTS)
1476         return "Too many AuthLDAPSubGroupClass values";
1477
1478     new = apr_array_push(sec->subgroupclasses);
1479     new->name = apr_pstrdup(cmd->pool, arg);
1480
1481     return NULL;
1482 }
1483
1484 static const char *mod_auth_ldap_set_subgroup_maxdepth(cmd_parms *cmd,
1485                                                        void *config,
1486                                                        const char *max_depth)
1487 {
1488     authn_ldap_config_t *sec = config;
1489
1490     sec->maxNestingDepth = atol(max_depth);
1491
1492     return NULL;
1493 }
1494
1495 static const char *mod_auth_ldap_add_group_attribute(cmd_parms *cmd, void *config, const char *arg)
1496 {
1497     struct mod_auth_ldap_groupattr_entry_t *new;
1498
1499     authn_ldap_config_t *sec = config;
1500
1501     if (sec->groupattr->nelts > GROUPATTR_MAX_ELTS)
1502         return "Too many AuthLDAPGroupAttribute directives";
1503
1504     new = apr_array_push(sec->groupattr);
1505     new->name = apr_pstrdup(cmd->pool, arg);
1506
1507     return NULL;
1508 }
1509
1510 static const char *set_charset_config(cmd_parms *cmd, void *config, const char *arg)
1511 {
1512     ap_set_module_config(cmd->server->module_config, &authnz_ldap_module,
1513                          (void *)arg);
1514     return NULL;
1515 }
1516
1517 static const char *set_bind_pattern(cmd_parms *cmd, void *_cfg, const char *exp, const char *subst)
1518 {
1519     authn_ldap_config_t *sec = _cfg;
1520     ap_regex_t *regexp;
1521
1522     regexp = ap_pregcomp(cmd->pool, exp, AP_REG_EXTENDED);
1523
1524     if (!regexp) {
1525         return apr_pstrcat(cmd->pool, "AuthLDAPInitialBindPattern: cannot compile regular "
1526                                       "expression '", exp, "'", NULL);
1527     }
1528
1529     sec->bind_regex = regexp;
1530     sec->bind_subst = apr_pstrdup(cmd->pool, subst);
1531
1532     return NULL;
1533 }
1534
1535 static const command_rec authnz_ldap_cmds[] =
1536 {
1537     AP_INIT_TAKE12("AuthLDAPURL", mod_auth_ldap_parse_url, NULL, OR_AUTHCFG,
1538                   "URL to define LDAP connection. This should be an RFC 2255 compliant\n"
1539                   "URL of the form ldap://host[:port]/basedn[?attrib[?scope[?filter]]].\n"
1540                   "<ul>\n"
1541                   "<li>Host is the name of the LDAP server. Use a space separated list of hosts \n"
1542                   "to specify redundant servers.\n"
1543                   "<li>Port is optional, and specifies the port to connect to.\n"
1544                   "<li>basedn specifies the base DN to start searches from\n"
1545                   "<li>Attrib specifies what attribute to search for in the directory. If not "
1546                   "provided, it defaults to <b>uid</b>.\n"
1547                   "<li>Scope is the scope of the search, and can be either <b>sub</b> or "
1548                   "<b>one</b>. If not provided, the default is <b>sub</b>.\n"
1549                   "<li>Filter is a filter to use in the search. If not provided, "
1550                   "defaults to <b>(objectClass=*)</b>.\n"
1551                   "</ul>\n"
1552                   "Searches are performed using the attribute and the filter combined. "
1553                   "For example, assume that the\n"
1554                   "LDAP URL is <b>ldap://ldap.airius.com/ou=People, o=Airius?uid?sub?(posixid=*)</b>. "
1555                   "Searches will\n"
1556                   "be done using the filter <b>(&((posixid=*))(uid=<i>username</i>))</b>, "
1557                   "where <i>username</i>\n"
1558                   "is the user name passed by the HTTP client. The search will be a subtree "
1559                   "search on the branch <b>ou=People, o=Airius</b>."),
1560
1561     AP_INIT_TAKE1("AuthLDAPBindDN", ap_set_string_slot,
1562                   (void *)APR_OFFSETOF(authn_ldap_config_t, binddn), OR_AUTHCFG,
1563                   "DN to use to bind to LDAP server. If not provided, will do an anonymous bind."),
1564
1565     AP_INIT_TAKE1("AuthLDAPBindPassword", ap_set_string_slot,
1566                   (void *)APR_OFFSETOF(authn_ldap_config_t, bindpw), OR_AUTHCFG,
1567                   "Password to use to bind to LDAP server. If not provided, will do an anonymous bind."),
1568
1569     AP_INIT_FLAG("AuthLDAPBindAuthoritative", ap_set_flag_slot,
1570                   (void *)APR_OFFSETOF(authn_ldap_config_t, bind_authoritative), OR_AUTHCFG,
1571                   "Set to 'on' to return failures when user-specific bind fails - defaults to on."),
1572
1573     AP_INIT_FLAG("AuthLDAPRemoteUserIsDN", ap_set_flag_slot,
1574                  (void *)APR_OFFSETOF(authn_ldap_config_t, user_is_dn), OR_AUTHCFG,
1575                  "Set to 'on' to set the REMOTE_USER environment variable to be the full "
1576                  "DN of the remote user. By default, this is set to off, meaning that "
1577                  "the REMOTE_USER variable will contain whatever value the remote user sent."),
1578
1579     AP_INIT_TAKE1("AuthLDAPRemoteUserAttribute", ap_set_string_slot,
1580                  (void *)APR_OFFSETOF(authn_ldap_config_t, remote_user_attribute), OR_AUTHCFG,
1581                  "Override the user supplied username and place the "
1582                  "contents of this attribute in the REMOTE_USER "
1583                  "environment variable."),
1584
1585     AP_INIT_FLAG("AuthLDAPCompareDNOnServer", ap_set_flag_slot,
1586                  (void *)APR_OFFSETOF(authn_ldap_config_t, compare_dn_on_server), OR_AUTHCFG,
1587                  "Set to 'on' to force auth_ldap to do DN compares (for the \"require dn\" "
1588                  "directive) using the server, and set it 'off' to do the compares locally "
1589                  "(at the expense of possible false matches). See the documentation for "
1590                  "a complete description of this option."),
1591
1592     AP_INIT_ITERATE("AuthLDAPSubGroupAttribute", mod_auth_ldap_add_subgroup_attribute, NULL, OR_AUTHCFG,
1593                     "Attribute labels used to define sub-group (or nested group) membership in groups - "
1594                     "defaults to member and uniqueMember"),
1595
1596     AP_INIT_ITERATE("AuthLDAPSubGroupClass", mod_auth_ldap_add_subgroup_class, NULL, OR_AUTHCFG,
1597                      "LDAP objectClass values used to identify sub-group instances - "
1598                      "defaults to groupOfNames and groupOfUniqueNames"),
1599
1600     AP_INIT_TAKE1("AuthLDAPMaxSubGroupDepth", mod_auth_ldap_set_subgroup_maxdepth, NULL, OR_AUTHCFG,
1601                       "Maximum subgroup nesting depth to be evaluated - defaults to 10 (top-level group = 0)"),
1602
1603     AP_INIT_ITERATE("AuthLDAPGroupAttribute", mod_auth_ldap_add_group_attribute, NULL, OR_AUTHCFG,
1604                     "A list of attribute labels used to identify the user members of groups - defaults to "
1605                     "member and uniquemember"),
1606
1607     AP_INIT_FLAG("AuthLDAPGroupAttributeIsDN", ap_set_flag_slot,
1608                  (void *)APR_OFFSETOF(authn_ldap_config_t, group_attrib_is_dn), OR_AUTHCFG,
1609                  "If set to 'on', auth_ldap uses the DN that is retrieved from the server for"
1610                  "subsequent group comparisons. If set to 'off', auth_ldap uses the string"
1611                  "provided by the client directly. Defaults to 'on'."),
1612
1613     AP_INIT_TAKE1("AuthLDAPDereferenceAliases", mod_auth_ldap_set_deref, NULL, OR_AUTHCFG,
1614                   "Determines how aliases are handled during a search. Can be one of the"
1615                   "values \"never\", \"searching\", \"finding\", or \"always\". "
1616                   "Defaults to always."),
1617
1618     AP_INIT_TAKE1("AuthLDAPCharsetConfig", set_charset_config, NULL, RSRC_CONF,
1619                   "Character set conversion configuration file. If omitted, character set"
1620                   "conversion is disabled."),
1621
1622     AP_INIT_TAKE1("AuthLDAPAuthorizePrefix", ap_set_string_slot,
1623                   (void *)APR_OFFSETOF(authn_ldap_config_t, authz_prefix), OR_AUTHCFG,
1624                   "The prefix to add to environment variables set during "
1625                   "successful authorization, default '" AUTHZ_PREFIX "'"),
1626
1627     AP_INIT_FLAG("AuthLDAPInitialBindAsUser", ap_set_flag_slot,
1628                  (void *)APR_OFFSETOF(authn_ldap_config_t, initial_bind_as_user), OR_AUTHCFG,
1629                  "Set to 'on' to perform the initial DN lookup with the basic auth credentials "
1630                  "instead of anonymous or hard-coded credentials"),
1631
1632      AP_INIT_TAKE2("AuthLDAPInitialBindPattern", set_bind_pattern, NULL, OR_AUTHCFG,
1633                    "The regex and substitution to determine a username that can bind based on an HTTP basic auth username"),
1634
1635      AP_INIT_FLAG("AuthLDAPSearchAsUser", ap_set_flag_slot,
1636                   (void *)APR_OFFSETOF(authn_ldap_config_t, search_as_user), OR_AUTHCFG,
1637                    "Set to 'on' to perform authorization-based searches with the users credentials, when this module"
1638                    " has also performed authentication.  Does not affect nested groups lookup."),
1639      AP_INIT_FLAG("AuthLDAPCompareAsUser", ap_set_flag_slot,
1640                   (void *)APR_OFFSETOF(authn_ldap_config_t, compare_as_user), OR_AUTHCFG,
1641                   "Set to 'on' to perform authorization-based compares with the users credentials, when this module"
1642                   " has also performed authentication.  Does not affect nested groups lookups."),
1643     {NULL}
1644 };
1645
1646 static int authnz_ldap_post_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
1647 {
1648     ap_configfile_t *f;
1649     char l[MAX_STRING_LEN];
1650     const char *charset_confname = ap_get_module_config(s->module_config,
1651                                                       &authnz_ldap_module);
1652     apr_status_t status;
1653
1654     /*
1655     authn_ldap_config_t *sec = (authn_ldap_config_t *)
1656                                     ap_get_module_config(s->module_config,
1657                                                          &authnz_ldap_module);
1658
1659     if (sec->secure)
1660     {
1661         if (!util_ldap_ssl_supported(s))
1662         {
1663             ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s,
1664                      "LDAP: SSL connections (ldaps://) not supported by utilLDAP");
1665             return(!OK);
1666         }
1667     }
1668     */
1669
1670     /* make sure that mod_ldap (util_ldap) is loaded */
1671     if (ap_find_linked_module("util_ldap.c") == NULL) {
1672         ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
1673                      "Module mod_ldap missing. Mod_ldap (aka. util_ldap) "
1674                      "must be loaded in order for mod_authnz_ldap to function properly");
1675         return HTTP_INTERNAL_SERVER_ERROR;
1676
1677     }
1678
1679     if (!charset_confname) {
1680         return OK;
1681     }
1682
1683     charset_confname = ap_server_root_relative(p, charset_confname);
1684     if (!charset_confname) {
1685         ap_log_error(APLOG_MARK, APLOG_ERR, APR_EBADPATH, s,
1686                      "Invalid charset conversion config path %s",
1687                      (const char *)ap_get_module_config(s->module_config,
1688                                                         &authnz_ldap_module));
1689         return HTTP_INTERNAL_SERVER_ERROR;
1690     }
1691     if ((status = ap_pcfg_openfile(&f, ptemp, charset_confname))
1692                 != APR_SUCCESS) {
1693         ap_log_error(APLOG_MARK, APLOG_ERR, status, s,
1694                      "could not open charset conversion config file %s.",
1695                      charset_confname);
1696         return HTTP_INTERNAL_SERVER_ERROR;
1697     }
1698
1699     charset_conversions = apr_hash_make(p);
1700
1701     while (!(ap_cfg_getline(l, MAX_STRING_LEN, f))) {
1702         const char *ll = l;
1703         char *lang;
1704
1705         if (l[0] == '#') {
1706             continue;
1707         }
1708         lang = ap_getword_conf(p, &ll);
1709         ap_str_tolower(lang);
1710
1711         if (ll[0]) {
1712             char *charset = ap_getword_conf(p, &ll);
1713             apr_hash_set(charset_conversions, lang, APR_HASH_KEY_STRING, charset);
1714         }
1715     }
1716     ap_cfg_closefile(f);
1717
1718     to_charset = derive_codepage_from_lang (p, "utf-8");
1719     if (to_charset == NULL) {
1720         ap_log_error(APLOG_MARK, APLOG_ERR, status, s,
1721                      "could not find the UTF-8 charset in the file %s.",
1722                      charset_confname);
1723         return HTTP_INTERNAL_SERVER_ERROR;
1724     }
1725
1726     return OK;
1727 }
1728
1729 static const authn_provider authn_ldap_provider =
1730 {
1731     &authn_ldap_check_password,
1732 };
1733
1734 static const authz_provider authz_ldapuser_provider =
1735 {
1736     &ldapuser_check_authorization,
1737     NULL,
1738 };
1739 static const authz_provider authz_ldapgroup_provider =
1740 {
1741     &ldapgroup_check_authorization,
1742     NULL,
1743 };
1744
1745 static const authz_provider authz_ldapdn_provider =
1746 {
1747     &ldapdn_check_authorization,
1748     NULL,
1749 };
1750
1751 static const authz_provider authz_ldapattribute_provider =
1752 {
1753     &ldapattribute_check_authorization,
1754     NULL,
1755 };
1756
1757 static const authz_provider authz_ldapfilter_provider =
1758 {
1759     &ldapfilter_check_authorization,
1760     NULL,
1761 };
1762
1763 static void ImportULDAPOptFn(void)
1764 {
1765     util_ldap_connection_close  = APR_RETRIEVE_OPTIONAL_FN(uldap_connection_close);
1766     util_ldap_connection_find   = APR_RETRIEVE_OPTIONAL_FN(uldap_connection_find);
1767     util_ldap_cache_comparedn   = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_comparedn);
1768     util_ldap_cache_compare     = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_compare);
1769     util_ldap_cache_checkuserid = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_checkuserid);
1770     util_ldap_cache_getuserdn   = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_getuserdn);
1771     util_ldap_ssl_supported     = APR_RETRIEVE_OPTIONAL_FN(uldap_ssl_supported);
1772     util_ldap_cache_check_subgroups = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_check_subgroups);
1773 }
1774
1775 static void register_hooks(apr_pool_t *p)
1776 {
1777     /* Register authn provider */
1778     ap_register_auth_provider(p, AUTHN_PROVIDER_GROUP, "ldap",
1779                               AUTHN_PROVIDER_VERSION,
1780                               &authn_ldap_provider, AP_AUTH_INTERNAL_PER_CONF);
1781
1782     /* Register authz providers */
1783     ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "ldap-user",
1784                               AUTHZ_PROVIDER_VERSION,
1785                               &authz_ldapuser_provider,
1786                               AP_AUTH_INTERNAL_PER_CONF);
1787     ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "ldap-group",
1788                               AUTHZ_PROVIDER_VERSION,
1789                               &authz_ldapgroup_provider,
1790                               AP_AUTH_INTERNAL_PER_CONF);
1791     ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "ldap-dn",
1792                               AUTHZ_PROVIDER_VERSION,
1793                               &authz_ldapdn_provider,
1794                               AP_AUTH_INTERNAL_PER_CONF);
1795     ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "ldap-attribute",
1796                               AUTHZ_PROVIDER_VERSION,
1797                               &authz_ldapattribute_provider,
1798                               AP_AUTH_INTERNAL_PER_CONF);
1799     ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "ldap-filter",
1800                               AUTHZ_PROVIDER_VERSION,
1801                               &authz_ldapfilter_provider,
1802                               AP_AUTH_INTERNAL_PER_CONF);
1803
1804     ap_hook_post_config(authnz_ldap_post_config,NULL,NULL,APR_HOOK_MIDDLE);
1805
1806     ap_hook_optional_fn_retrieve(ImportULDAPOptFn,NULL,NULL,APR_HOOK_MIDDLE);
1807 }
1808
1809 AP_DECLARE_MODULE(authnz_ldap) =
1810 {
1811     STANDARD20_MODULE_STUFF,
1812     create_authnz_ldap_dir_config,   /* dir config creater */
1813     NULL,                            /* dir merger --- default is to override */
1814     NULL,                            /* server config */
1815     NULL,                            /* merge server config */
1816     authnz_ldap_cmds,                /* command apr_table_t */
1817     register_hooks                   /* register hooks */
1818 };