mod_vhost_ldap.c

   1 /* ============================================================
   2  * Copyright (c) 2003-2004, Ondrej Sury
   3  * All rights reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 /*
  20  * mod_vhost_ldap.c --- read virtual host config from LDAP directory
  21  */
  22
  23 #define CORE_PRIVATE
  24
  25 #include <unistd.h>
  26
  27 #include "httpd.h"
  28 #include "http_config.h"
  29 #include "http_core.h"
  30 #include "http_log.h"
  31 #include "http_request.h"
  32 #include "apr_version.h"
  33 #include "apr_ldap.h"
  34 #include "apr_strings.h"
  35 #include "apr_reslist.h"
  36 #include "util_ldap.h"
  37
  38 #if !defined(APU_HAS_LDAP) && !defined(APR_HAS_LDAP)
  39 #error mod_vhost_ldap requires APR-util to have LDAP support built in
  40 #endif
  41
  42 #if !defined(WIN32) && !defined(OS2) && !defined(BEOS) && !defined(NETWARE)
  43 #define HAVE_UNIX_SUEXEC
  44 #endif
  45
  46 #ifdef HAVE_UNIX_SUEXEC
  47 #include "unixd.h"              /* Contains the suexec_identity hook used on Unix */
  48 #endif
  49
  50 #define MIN_UID 100
  51 #define MIN_GID 100
  52 const char USERDIR[] = "web_scripts";
  53
  54 module AP_MODULE_DECLARE_DATA vhost_ldap_module;
  55
  56 typedef enum {
  57     MVL_UNSET, MVL_DISABLED, MVL_ENABLED
  58 } mod_vhost_ldap_status_e;
  59
  60 typedef struct mod_vhost_ldap_config_t {
  61     mod_vhost_ldap_status_e enabled;                    /* Is vhost_ldap enabled? */
  62
  63     /* These parameters are all derived from the VhostLDAPURL directive */
  64     char *url;                          /* String representation of LDAP URL */
  65
  66     char *host;                         /* Name of the LDAP server (or space separated list) */
  67     int port;                           /* Port of the LDAP server */
  68     char *basedn;                       /* Base DN to do all searches from */
  69     int scope;                          /* Scope of the search */
  70     char *filter;                       /* Filter to further limit the search  */
  71     deref_options deref;                /* how to handle alias dereferening */
  72
  73     char *binddn;                       /* DN to bind to server (can be NULL) */
  74     char *bindpw;                       /* Password to bind to server (can be NULL) */
  75
  76     int have_deref;                     /* Set if we have found an Deref option */
  77     int have_ldap_url;                  /* Set if we have found an LDAP url */
  78
  79     int secure;                         /* True if SSL connections are requested */
  80
  81     char *fallback;                     /* Fallback virtual host */
  82
  83 } mod_vhost_ldap_config_t;
  84
  85 typedef struct mod_vhost_ldap_request_t {
  86     char *dn;                           /* The saved dn from a successful search */
  87     char *name;                         /* ServerName */
  88     char *admin;                        /* ServerAdmin */
  89     char *docroot;                      /* DocumentRoot */
  90     char *cgiroot;                      /* ScriptAlias */
  91     char *uid;                          /* Suexec Uid */
  92     char *gid;                          /* Suexec Gid */
  93 } mod_vhost_ldap_request_t;
  94
  95 char *attributes[] =
  96   { "apacheServerName", "apacheDocumentRoot", "apacheScriptAlias", "apacheSuexecUid", "apacheSuexecGid", "apacheServerAdmin", 0 };
  97
  98 #if (APR_MAJOR_VERSION >= 1)
  99 static APR_OPTIONAL_FN_TYPE(uldap_connection_close) *util_ldap_connection_close;
 100 static APR_OPTIONAL_FN_TYPE(uldap_connection_find) *util_ldap_connection_find;
 101 static APR_OPTIONAL_FN_TYPE(uldap_cache_comparedn) *util_ldap_cache_comparedn;
 102 static APR_OPTIONAL_FN_TYPE(uldap_cache_compare) *util_ldap_cache_compare;
 103 static APR_OPTIONAL_FN_TYPE(uldap_cache_checkuserid) *util_ldap_cache_checkuserid;
 104 static APR_OPTIONAL_FN_TYPE(uldap_cache_getuserdn) *util_ldap_cache_getuserdn;
 105 static APR_OPTIONAL_FN_TYPE(uldap_ssl_supported) *util_ldap_ssl_supported;
 106
 107 static void ImportULDAPOptFn(void)
 108 {
 109     util_ldap_connection_close  = APR_RETRIEVE_OPTIONAL_FN(uldap_connection_close);
 110     util_ldap_connection_find   = APR_RETRIEVE_OPTIONAL_FN(uldap_connection_find);
 111     util_ldap_cache_comparedn   = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_comparedn);
 112     util_ldap_cache_compare     = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_compare);
 113     util_ldap_cache_checkuserid = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_checkuserid);
 114     util_ldap_cache_getuserdn   = APR_RETRIEVE_OPTIONAL_FN(uldap_cache_getuserdn);
 115     util_ldap_ssl_supported     = APR_RETRIEVE_OPTIONAL_FN(uldap_ssl_supported);
 116 }
 117 #endif
 118
 119 static int mod_vhost_ldap_post_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
 120 {
 121     /* make sure that mod_ldap (util_ldap) is loaded */
 122     if (ap_find_linked_module("util_ldap.c") == NULL) {
 123         ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, s,
 124                      "Module mod_ldap missing. Mod_ldap (aka. util_ldap) "
 125                      "must be loaded in order for mod_vhost_ldap to function properly");
 126         return HTTP_INTERNAL_SERVER_ERROR;
 127
 128     }
 129
 130     ap_add_version_component(p, MOD_VHOST_LDAP_VERSION);
 131
 132     return OK;
 133 }
 134
 135 static void *
 136 mod_vhost_ldap_create_server_config (apr_pool_t *p, server_rec *s)
 137 {
 138     mod_vhost_ldap_config_t *conf =
 139         (mod_vhost_ldap_config_t *)apr_pcalloc(p, sizeof (mod_vhost_ldap_config_t));
 140
 141     conf->enabled = MVL_UNSET;
 142     conf->have_ldap_url = 0;
 143     conf->have_deref = 0;
 144     conf->binddn = NULL;
 145     conf->bindpw = NULL;
 146     conf->deref = always;
 147     conf->fallback = NULL;
 148
 149     return conf;
 150 }
 151
 152 static void *
 153 mod_vhost_ldap_merge_server_config(apr_pool_t *p, void *parentv, void *childv)
 154 {
 155     mod_vhost_ldap_config_t *parent = (mod_vhost_ldap_config_t *) parentv;
 156     mod_vhost_ldap_config_t *child  = (mod_vhost_ldap_config_t *) childv;
 157     mod_vhost_ldap_config_t *conf =
 158         (mod_vhost_ldap_config_t *)apr_pcalloc(p, sizeof(mod_vhost_ldap_config_t));
 159
 160     if (child->enabled == MVL_UNSET) {
 161         conf->enabled = parent->enabled;
 162     } else {
 163         conf->enabled = child->enabled;
 164     }
 165
 166     if (child->have_ldap_url) {
 167         conf->have_ldap_url = child->have_ldap_url;
 168         conf->url = child->url;
 169         conf->host = child->host;
 170         conf->port = child->port;
 171         conf->basedn = child->basedn;
 172         conf->scope = child->scope;
 173         conf->filter = child->filter;
 174         conf->secure = child->secure;
 175     } else {
 176         conf->have_ldap_url = parent->have_ldap_url;
 177         conf->url = parent->url;
 178         conf->host = parent->host;
 179         conf->port = parent->port;
 180         conf->basedn = parent->basedn;
 181         conf->scope = parent->scope;
 182         conf->filter = parent->filter;
 183         conf->secure = parent->secure;
 184     }
 185     if (child->have_deref) {
 186         conf->have_deref = child->have_deref;
 187         conf->deref = child->deref;
 188     } else {
 189         conf->have_deref = parent->have_deref;
 190         conf->deref = parent->deref;
 191     }
 192
 193     conf->binddn = (child->binddn ? child->binddn : parent->binddn);
 194     conf->bindpw = (child->bindpw ? child->bindpw : parent->bindpw);
 195
 196     conf->fallback = (child->fallback ? child->fallback : parent->fallback);
 197
 198     return conf;
 199 }
 200
 201 /*
 202  * Use the ldap url parsing routines to break up the ldap url into
 203  * host and port.
 204  */
 205 static const char *mod_vhost_ldap_parse_url(cmd_parms *cmd,
 206                                             void *dummy,
 207                                             const char *url)
 208 {
 209     int result;
 210     apr_ldap_url_desc_t *urld;
 211 #if (APR_MAJOR_VERSION >= 1)
 212     apr_ldap_err_t *result_err;
 213 #endif
 214
 215     mod_vhost_ldap_config_t *conf =
 216         (mod_vhost_ldap_config_t *)ap_get_module_config(cmd->server->module_config,
 217                                                         &vhost_ldap_module);
 218
 219     ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0,
 220                  cmd->server, "[mod_vhost_ldap.c] url parse: `%s'",
 221                  url);
 222
 223 #if (APR_MAJOR_VERSION >= 1)    /* for apache >= 2.2 */
 224     result = apr_ldap_url_parse(cmd->pool, url, &(urld), &(result_err));
 225     if (result != LDAP_SUCCESS) {
 226         return result_err->reason;
 227     }
 228 #else
 229     result = apr_ldap_url_parse(url, &(urld));
 230     if (result != LDAP_SUCCESS) {
 231         switch (result) {
 232             case LDAP_URL_ERR_NOTLDAP:
 233                 return "LDAP URL does not begin with ldap://";
 234             case LDAP_URL_ERR_NODN:
 235                 return "LDAP URL does not have a DN";
 236             case LDAP_URL_ERR_BADSCOPE:
 237                 return "LDAP URL has an invalid scope";
 238             case LDAP_URL_ERR_MEM:
 239                 return "Out of memory parsing LDAP URL";
 240             default:
 241                 return "Could not parse LDAP URL";
 242         }
 243     }
 244 #endif
 245     conf->url = apr_pstrdup(cmd->pool, url);
 246
 247     ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0,
 248                  cmd->server, "[mod_vhost_ldap.c] url parse: Host: %s", urld->lud_host);
 249     ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0,
 250                  cmd->server, "[mod_vhost_ldap.c] url parse: Port: %d", urld->lud_port);
 251     ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0,
 252                  cmd->server, "[mod_vhost_ldap.c] url parse: DN: %s", urld->lud_dn);
 253     ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0,
 254                  cmd->server, "[mod_vhost_ldap.c] url parse: attrib: %s", urld->lud_attrs? urld->lud_attrs[0] : "(null)");
 255     ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0,
 256                  cmd->server, "[mod_vhost_ldap.c] url parse: scope: %s",
 257                  (urld->lud_scope == LDAP_SCOPE_SUBTREE? "subtree" :
 258                  urld->lud_scope == LDAP_SCOPE_BASE? "base" :
 259                  urld->lud_scope == LDAP_SCOPE_ONELEVEL? "onelevel" : "unknown"));
 260     ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0,
 261                  cmd->server, "[mod_vhost_ldap.c] url parse: filter: %s", urld->lud_filter);
 262
 263     /* Set all the values, or at least some sane defaults */
 264     if (conf->host) {
 265         char *p = apr_palloc(cmd->pool, strlen(conf->host) + strlen(urld->lud_host) + 2);
 266         strcpy(p, urld->lud_host);
 267         strcat(p, " ");
 268         strcat(p, conf->host);
 269         conf->host = p;
 270     }
 271     else {
 272         conf->host = urld->lud_host? apr_pstrdup(cmd->pool, urld->lud_host) : "localhost";
 273     }
 274     conf->basedn = urld->lud_dn? apr_pstrdup(cmd->pool, urld->lud_dn) : "";
 275
 276     conf->scope = urld->lud_scope == LDAP_SCOPE_ONELEVEL ?
 277         LDAP_SCOPE_ONELEVEL : LDAP_SCOPE_SUBTREE;
 278
 279     if (urld->lud_filter) {
 280         if (urld->lud_filter[0] == '(') {
 281             /*
 282              * Get rid of the surrounding parens; later on when generating the
 283              * filter, they'll be put back.
 284              */
 285             conf->filter = apr_pstrdup(cmd->pool, urld->lud_filter+1);
 286             conf->filter[strlen(conf->filter)-1] = '\0';
 287         }
 288         else {
 289             conf->filter = apr_pstrdup(cmd->pool, urld->lud_filter);
 290         }
 291     }
 292     else {
 293         conf->filter = "objectClass=apacheConfig";
 294     }
 295
 296       /* "ldaps" indicates secure ldap connections desired
 297       */
 298     if (strncasecmp(url, "ldaps", 5) == 0)
 299     {
 300         conf->secure = 1;
 301         conf->port = urld->lud_port? urld->lud_port : LDAPS_PORT;
 302         ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, cmd->server,
 303                      "LDAP: vhost_ldap using SSL connections");
 304     }
 305     else
 306     {
 307         conf->secure = 0;
 308         conf->port = urld->lud_port? urld->lud_port : LDAP_PORT;
 309         ap_log_error(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, cmd->server,
 310                      "LDAP: vhost_ldap not using SSL connections");
 311     }
 312
 313     conf->have_ldap_url = 1;
 314 #if (APR_MAJOR_VERSION < 1) /* free only required for older apr */
 315     apr_ldap_free_urldesc(urld);
 316 #endif
 317     return NULL;
 318 }
 319
 320 static const char *mod_vhost_ldap_set_enabled(cmd_parms *cmd, void *dummy, int enabled)
 321 {
 322     mod_vhost_ldap_config_t *conf =
 323         (mod_vhost_ldap_config_t *)ap_get_module_config(cmd->server->module_config,
 324                                                         &vhost_ldap_module);
 325
 326     conf->enabled = (enabled) ? MVL_ENABLED : MVL_DISABLED;
 327
 328     return NULL;
 329 }
 330
 331 static const char *mod_vhost_ldap_set_binddn(cmd_parms *cmd, void *dummy, const char *binddn)
 332 {
 333     mod_vhost_ldap_config_t *conf =
 334         (mod_vhost_ldap_config_t *)ap_get_module_config(cmd->server->module_config,
 335                                                         &vhost_ldap_module);
 336
 337     conf->binddn = apr_pstrdup(cmd->pool, binddn);
 338     return NULL;
 339 }
 340
 341 static const char *mod_vhost_ldap_set_bindpw(cmd_parms *cmd, void *dummy, const char *bindpw)
 342 {
 343     mod_vhost_ldap_config_t *conf =
 344         (mod_vhost_ldap_config_t *)ap_get_module_config(cmd->server->module_config,
 345                                                         &vhost_ldap_module);
 346
 347     conf->bindpw = apr_pstrdup(cmd->pool, bindpw);
 348     return NULL;
 349 }
 350
 351 static const char *mod_vhost_ldap_set_deref(cmd_parms *cmd, void *dummy, const char *deref)
 352 {
 353     mod_vhost_ldap_config_t *conf =
 354         (mod_vhost_ldap_config_t *)ap_get_module_config (cmd->server->module_config,
 355                                                          &vhost_ldap_module);
 356
 357     if (strcmp(deref, "never") == 0 || strcasecmp(deref, "off") == 0) {
 358         conf->deref = never;
 359         conf->have_deref = 1;
 360     }
 361     else if (strcmp(deref, "searching") == 0) {
 362         conf->deref = searching;
 363         conf->have_deref = 1;
 364     }
 365     else if (strcmp(deref, "finding") == 0) {
 366         conf->deref = finding;
 367         conf->have_deref = 1;
 368     }
 369     else if (strcmp(deref, "always") == 0 || strcasecmp(deref, "on") == 0) {
 370         conf->deref = always;
 371         conf->have_deref = 1;
 372     }
 373     else {
 374         return "Unrecognized value for VhostLDAPAliasDereference directive";
 375     }
 376     return NULL;
 377 }
 378
 379 static const char *mod_vhost_ldap_set_fallback(cmd_parms *cmd, void *dummy, const char *fallback)
 380 {
 381     mod_vhost_ldap_config_t *conf =
 382         (mod_vhost_ldap_config_t *)ap_get_module_config(cmd->server->module_config,
 383                                                         &vhost_ldap_module);
 384
 385     conf->fallback = apr_pstrdup(cmd->pool, fallback);
 386     return NULL;
 387 }
 388
 389 command_rec mod_vhost_ldap_cmds[] = {
 390     AP_INIT_TAKE1("VhostLDAPURL", mod_vhost_ldap_parse_url, NULL, RSRC_CONF,
 391                   "URL to define LDAP connection. This should be an RFC 2255 compliant\n"
 392                   "URL of the form ldap://host[:port]/basedn[?attrib[?scope[?filter]]].\n"
 393                   "<ul>\n"
 394                   "<li>Host is the name of the LDAP server. Use a space separated list of hosts \n"
 395                   "to specify redundant servers.\n"
 396                   "<li>Port is optional, and specifies the port to connect to.\n"
 397                   "<li>basedn specifies the base DN to start searches from\n"
 398                   "</ul>\n"),
 399
 400     AP_INIT_TAKE1 ("VhostLDAPBindDN", mod_vhost_ldap_set_binddn, NULL, RSRC_CONF,
 401                    "DN to use to bind to LDAP server. If not provided, will do an anonymous bind."),
 402
 403     AP_INIT_TAKE1("VhostLDAPBindPassword", mod_vhost_ldap_set_bindpw, NULL, RSRC_CONF,
 404                   "Password to use to bind to LDAP server. If not provided, will do an anonymous bind."),
 405
 406     AP_INIT_FLAG("VhostLDAPEnabled", mod_vhost_ldap_set_enabled, NULL, RSRC_CONF,
 407                  "Set to off to disable vhost_ldap, even if it's been enabled in a higher tree"),
 408
 409     AP_INIT_TAKE1("VhostLDAPDereferenceAliases", mod_vhost_ldap_set_deref, NULL, RSRC_CONF,
 410                   "Determines how aliases are handled during a search. Can be one of the"
 411                   "values \"never\", \"searching\", \"finding\", or \"always\". "
 412                   "Defaults to always."),
 413
 414     AP_INIT_TAKE1("VhostLDAPFallback", mod_vhost_ldap_set_fallback, NULL, RSRC_CONF,
 415                   "Set default virtual host which will be used when requested hostname"
 416                   "is not found in LDAP database. This option can be used to display"
 417                   "\"virtual host not found\" type of page."),
 418
 419     {NULL}
 420 };
 421
 422 #define FILTER_LENGTH MAX_STRING_LEN
 423 static int mod_vhost_ldap_translate_name(request_rec *r)
 424 {
 425     request_rec *top = (r->main)?r->main:r;
 426     mod_vhost_ldap_request_t *reqc;
 427     apr_table_t *e;
 428     int failures = 0;
 429     const char **vals = NULL;
 430     char filtbuf[FILTER_LENGTH];
 431     mod_vhost_ldap_config_t *conf =
 432         (mod_vhost_ldap_config_t *)ap_get_module_config(r->server->module_config, &vhost_ldap_module);
 433     core_server_config * core =
 434         (core_server_config *) ap_get_module_config(r->server->module_config, &core_module);
 435     util_ldap_connection_t *ldc = NULL;
 436     int result = 0;
 437     const char *dn = NULL;
 438     char *cgi;
 439     const char *hostname = NULL;
 440     int is_fallback = 0;
 441
 442     reqc =
 443         (mod_vhost_ldap_request_t *)apr_pcalloc(r->pool, sizeof(mod_vhost_ldap_request_t));
 444     memset(reqc, 0, sizeof(mod_vhost_ldap_request_t));
 445
 446     ap_set_module_config(r->request_config, &vhost_ldap_module, reqc);
 447
 448     // mod_vhost_ldap is disabled or we don't have LDAP Url
 449     if ((conf->enabled != MVL_ENABLED)||(!conf->have_ldap_url)) {
 450         return DECLINED;
 451     }
 452
 453 start_over:
 454
 455     if (conf->host) {
 456         ldc = util_ldap_connection_find(r, conf->host, conf->port,
 457                                         conf->binddn, conf->bindpw, conf->deref,
 458                                         conf->secure);
 459     }
 460     else {
 461         ap_log_rerror(APLOG_MARK, APLOG_WARNING|APLOG_NOERRNO, 0, r,
 462                       "[mod_vhost_ldap.c] translate: no conf->host - weird...?");
 463         return DECLINED;
 464     }
 465
 466     hostname = r->hostname;
 467
 468 fallback:
 469
 470     ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,
 471                    "[mod_vhost_ldap.c]: translating %s", r->uri);
 472
 473     apr_snprintf(filtbuf, FILTER_LENGTH, "(&(%s)(|(apacheServerName=%s)(apacheServerAlias=%s)))", conf->filter, hostname, hostname);
 474
 475     result = util_ldap_cache_getuserdn(r, ldc, conf->url, conf->basedn, conf->scope,
 476                                        attributes, filtbuf, &dn, &vals);
 477
 478     util_ldap_connection_close(ldc);
 479
 480     /* sanity check - if server is down, retry it up to 5 times */
 481     if (result == LDAP_SERVER_DOWN) {
 482         if (failures++ <= 5) {
 483             goto start_over;
 484         }
 485     }
 486
 487     if ((result == LDAP_NO_SUCH_OBJECT)) {
 488         if (conf->fallback && (is_fallback++ <= 0)) {
 489             ap_log_rerror(APLOG_MARK, APLOG_NOTICE|APLOG_NOERRNO, 0, r,
 490                           "[mod_vhost_ldap.c] translate: "
 491                           "virtual host %s not found, trying fallback %s",
 492                           hostname, conf->fallback);
 493             hostname = conf->fallback;
 494             goto fallback;
 495         }
 496
 497         ap_log_rerror(APLOG_MARK, APLOG_WARNING|APLOG_NOERRNO, 0, r,
 498                       "[mod_vhost_ldap.c] translate: "
 499                       "virtual host %s not found",
 500                       hostname);
 501
 502         return DECLINED;
 503     }
 504
 505     /* handle bind failure */
 506     if (result != LDAP_SUCCESS) {
 507         ap_log_rerror(APLOG_MARK, APLOG_WARNING|APLOG_NOERRNO, 0, r,
 508                       "[mod_vhost_ldap.c] translate: "
 509                       "translate failed; virtual host %s; URI %s [%s]",
 510                       hostname, r->uri, ldap_err2string(result));
 511         return DECLINED;
 512     }
 513
 514     /* mark the user and DN */
 515     reqc->dn = apr_pstrdup(r->pool, dn);
 516
 517     /* Optimize */
 518     if (vals) {
 519         int i = 0;
 520         while (attributes[i]) {
 521
 522             if (strcasecmp (attributes[i], "apacheServerName") == 0) {
 523                 reqc->name = apr_pstrdup (r->pool, vals[i]);
 524             }
 525             else if (strcasecmp (attributes[i], "apacheServerAdmin") == 0) {
 526                 reqc->admin = apr_pstrdup (r->pool, vals[i]);
 527             }
 528             else if (strcasecmp (attributes[i], "apacheDocumentRoot") == 0) {
 529                 reqc->docroot = apr_pstrdup (r->pool, vals[i]);
 530             }
 531             else if (strcasecmp (attributes[i], "apacheScriptAlias") == 0) {
 532                 reqc->cgiroot = apr_pstrdup (r->pool, vals[i]);
 533             }
 534             else if (strcasecmp (attributes[i], "apacheSuexecUid") == 0) {
 535                 reqc->uid = apr_pstrdup(r->pool, vals[i]);
 536             }
 537             else if (strcasecmp (attributes[i], "apacheSuexecGid") == 0) {
 538                 reqc->gid = apr_pstrdup(r->pool, vals[i]);
 539             }
 540             i++;
 541         }
 542     }
 543
 544     ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,
 545                   "[mod_vhost_ldap.c]: loaded from ldap: "
 546                   "apacheServerName: %s, "
 547                   "apacheServerAdmin: %s, "
 548                   "apacheDocumentRoot: %s, "
 549                   "apacheScriptAlias: %s, "
 550                   "apacheSuexecUid: %s, "
 551                   "apacheSuexecGid: %s",
 552                   reqc->name, reqc->admin, reqc->docroot, reqc->cgiroot, reqc->uid, reqc->gid);
 553
 554     if ((reqc->name == NULL)||(reqc->docroot == NULL)) {
 555         ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, r,
 556                       "[mod_vhost_ldap.c] translate: "
 557                       "translate failed; ServerName or DocumentRoot not defined");
 558         return DECLINED;
 559     }
 560
 561     cgi = NULL;
 562
 563 #if 0
 564     if (reqc->cgiroot) {
 565         cgi = strstr(r->uri, "cgi-bin/");
 566         if (cgi && (cgi != r->uri + strspn(r->uri, "/"))) {
 567             cgi = NULL;
 568         }
 569     }
 570     if (cgi) {
 571         r->filename = apr_pstrcat (r->pool, reqc->cgiroot, cgi + strlen("cgi-bin"), NULL);
 572         r->handler = "cgi-script";
 573         apr_table_setn(r->notes, "alias-forced-type", r->handler);
 574 #endif
 575     /* This is a quick, dirty hack. I should be shot for taking 6.170
 576      * this term and being willing to write a quick, dirty hack. */
 577
 578     if (strncmp(r->uri, "/~", 2) == 0) {
 579         char *username;
 580         uid_t uid = (uid_t)atoll(reqc->uid);
 581         if (apr_uid_name_get(&username, uid, r->pool) != APR_SUCCESS) {
 582             ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, r,
 583                           "could not get username for uid %d", uid);
 584             return DECLINED;
 585         }
 586         if (strncmp(r->uri + 2, username, strlen(username)) == 0 &&
 587             (r->uri[2 + strlen(username)] == '/' ||
 588              r->uri[2 + strlen(username)] == '\0')) {
 589             char *homedir;
 590             if (apr_uid_homepath_get(&homedir, username, r->pool) != APR_SUCCESS) {
 591                 ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, r,
 592                               "could not get home directory for user %s", username);
 593                 return DECLINED;
 594             }
 595             r->filename = apr_pstrcat(r->pool, homedir, "/", USERDIR, r->uri + 2 + strlen(username), NULL);
 596         }
 597     } else if (r->uri[0] == '/') {
 598         r->filename = apr_pstrcat (r->pool, reqc->docroot, r->uri, NULL);
 599     } else {
 600         return DECLINED;
 601     }
 602
 603     top->server->server_hostname = apr_pstrdup (top->pool, reqc->name);
 604
 605     if (reqc->admin) {
 606         top->server->server_admin = apr_pstrdup (top->pool, reqc->admin);
 607     }
 608
 609     // set environment variables
 610     e = top->subprocess_env;
 611     apr_table_addn (e, "SERVER_ROOT", reqc->docroot);
 612
 613     core->ap_document_root = apr_pstrdup(top->pool, reqc->docroot);
 614
 615     ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,
 616                   "[mod_vhost_ldap.c]: translated to %s", r->filename);
 617
 618     return OK;
 619 }
 620
 621 #ifdef HAVE_UNIX_SUEXEC
 622 static ap_unix_identity_t *mod_vhost_ldap_get_suexec_id_doer(const request_rec * r)
 623 {
 624   ap_unix_identity_t *ugid = NULL;
 625   mod_vhost_ldap_config_t *conf =
 626       (mod_vhost_ldap_config_t *)ap_get_module_config(r->server->module_config,
 627                                                       &vhost_ldap_module);
 628   mod_vhost_ldap_request_t *req =
 629       (mod_vhost_ldap_request_t *)ap_get_module_config(r->request_config,
 630                                                        &vhost_ldap_module);
 631
 632   uid_t uid = -1;
 633   gid_t gid = -1;
 634
 635   // mod_vhost_ldap is disabled or we don't have LDAP Url
 636   if ((conf->enabled != MVL_ENABLED)||(!conf->have_ldap_url)) {
 637       return NULL;
 638   }
 639
 640   if ((req == NULL)||(req->uid == NULL)||(req->gid == NULL)) {
 641       return NULL;
 642   }
 643
 644   if ((ugid = apr_palloc(r->pool, sizeof(ap_unix_identity_t))) == NULL) {
 645       return NULL;
 646   }
 647
 648   uid = (uid_t)atoll(req->uid);
 649   gid = (gid_t)atoll(req->gid);
 650
 651   if ((uid < MIN_UID)||(gid < MIN_GID)) {
 652       return NULL;
 653   }
 654
 655   ugid->uid = uid;
 656   ugid->gid = gid;
 657   ugid->userdir = 0;
 658
 659   return ugid;
 660 }
 661 #endif
 662
 663 static void
 664 mod_vhost_ldap_register_hooks (apr_pool_t * p)
 665 {
 666     ap_hook_post_config(mod_vhost_ldap_post_config, NULL, NULL, APR_HOOK_MIDDLE);
 667     ap_hook_translate_name(mod_vhost_ldap_translate_name, NULL, NULL, APR_HOOK_MIDDLE);
 668 #ifdef HAVE_UNIX_SUEXEC
 669     ap_hook_get_suexec_identity(mod_vhost_ldap_get_suexec_id_doer, NULL, NULL, APR_HOOK_MIDDLE);
 670 #endif
 671 #if (APR_MAJOR_VERSION >= 1)
 672     ap_hook_optional_fn_retrieve(ImportULDAPOptFn,NULL,NULL,APR_HOOK_MIDDLE);
 673 #endif
 674 }
 675
 676 module AP_MODULE_DECLARE_DATA vhost_ldap_module = {
 677   STANDARD20_MODULE_STUFF,
 678   NULL,
 679   NULL,
 680   mod_vhost_ldap_create_server_config,
 681   mod_vhost_ldap_merge_server_config,
 682   mod_vhost_ldap_cmds,
 683   mod_vhost_ldap_register_hooks,
 684 };