source: server/common/oursrc/httpdmods/mod_vhost_ldap.c @ 673

Last change on this file since 673 was 673, checked in by geofft, 14 years ago
Right, when you're copying things you use two variables, not one.
  • Property svn:eol-style set to native
File size: 23.3 KB
Line 
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
52const char USERDIR[] = "web_scripts";
53
54module AP_MODULE_DECLARE_DATA vhost_ldap_module;
55
56typedef enum {
57    MVL_UNSET, MVL_DISABLED, MVL_ENABLED
58} mod_vhost_ldap_status_e;
59
60typedef 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
85typedef 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
95char *attributes[] =
96  { "apacheServerName", "apacheDocumentRoot", "apacheScriptAlias", "apacheSuexecUid", "apacheSuexecGid", "apacheServerAdmin", 0 };
97
98#if (APR_MAJOR_VERSION >= 1)
99static APR_OPTIONAL_FN_TYPE(uldap_connection_close) *util_ldap_connection_close;
100static APR_OPTIONAL_FN_TYPE(uldap_connection_find) *util_ldap_connection_find;
101static APR_OPTIONAL_FN_TYPE(uldap_cache_comparedn) *util_ldap_cache_comparedn;
102static APR_OPTIONAL_FN_TYPE(uldap_cache_compare) *util_ldap_cache_compare;
103static APR_OPTIONAL_FN_TYPE(uldap_cache_checkuserid) *util_ldap_cache_checkuserid;
104static APR_OPTIONAL_FN_TYPE(uldap_cache_getuserdn) *util_ldap_cache_getuserdn;
105static APR_OPTIONAL_FN_TYPE(uldap_ssl_supported) *util_ldap_ssl_supported;
106
107static 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
119static 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
135static void *
136mod_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
152static void *
153mod_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 */
205static 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
320static 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
331static 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
341static 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
351static 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
379static 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
389command_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
422char* mod_vhost_ldap_sanitize(apr_pool_t* p, const char* source) {
423    char* target = apr_palloc(p, 3*strlen(source)+1);
424    for (; *source; source++) {
425        switch (*source) {
426            case '*':
427                strcpy(target, "\\2a");
428                target += 3;
429                break;
430            case '(':
431                strcpy(target, "\\28");
432                target += 3;
433                break;
434            case ')':
435                strcpy(target, "\\29");
436                target += 3;
437                break;
438            case '\\':
439                strcpy(target, "\\5c");
440                target += 3;
441                break;
442            default:
443                *target++ = *source;
444        }
445    }
446    *target = '\0';
447    return target;
448}
449
450#define FILTER_LENGTH MAX_STRING_LEN
451static int mod_vhost_ldap_translate_name(request_rec *r)
452{
453    request_rec *top = (r->main)?r->main:r;
454    mod_vhost_ldap_request_t *reqc;
455    apr_table_t *e;
456    int failures = 0;
457    const char **vals = NULL;
458    char filtbuf[FILTER_LENGTH];
459    mod_vhost_ldap_config_t *conf =
460        (mod_vhost_ldap_config_t *)ap_get_module_config(r->server->module_config, &vhost_ldap_module);
461    core_server_config * core =
462        (core_server_config *) ap_get_module_config(r->server->module_config, &core_module);
463    util_ldap_connection_t *ldc = NULL;
464    int result = 0;
465    const char *dn = NULL;
466    char *cgi;
467    const char *hostname = NULL, *s_hostname = NULL;
468    int is_fallback = 0;
469
470    reqc =
471        (mod_vhost_ldap_request_t *)apr_pcalloc(r->pool, sizeof(mod_vhost_ldap_request_t));
472    memset(reqc, 0, sizeof(mod_vhost_ldap_request_t)); 
473
474    ap_set_module_config(r->request_config, &vhost_ldap_module, reqc);
475
476    // mod_vhost_ldap is disabled or we don't have LDAP Url
477    if ((conf->enabled != MVL_ENABLED)||(!conf->have_ldap_url)) {
478        return DECLINED;
479    }
480
481start_over:
482
483    if (conf->host) {
484        ldc = util_ldap_connection_find(r, conf->host, conf->port,
485                                        conf->binddn, conf->bindpw, conf->deref,
486                                        conf->secure);
487    }
488    else {
489        ap_log_rerror(APLOG_MARK, APLOG_WARNING|APLOG_NOERRNO, 0, r, 
490                      "[mod_vhost_ldap.c] translate: no conf->host - weird...?");
491        return DECLINED;
492    }
493
494    hostname = r->hostname;
495
496fallback:
497
498    ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,
499                   "[mod_vhost_ldap.c]: translating %s", r->uri);
500
501    s_hostname = mod_vhost_ldap_sanitize(r->pool, hostname);
502    apr_snprintf(filtbuf, FILTER_LENGTH, "(&(%s)(|(apacheServerName=%s)(apacheServerAlias=%s)))", conf->filter, s_hostname, s_hostname);
503
504    result = util_ldap_cache_getuserdn(r, ldc, conf->url, conf->basedn, conf->scope,
505                                       attributes, filtbuf, &dn, &vals);
506
507    util_ldap_connection_close(ldc);
508
509    /* sanity check - if server is down, retry it up to 5 times */
510    if (result == LDAP_SERVER_DOWN) {
511        if (failures++ <= 5) {
512            goto start_over;
513        }
514    }
515
516    if ((result == LDAP_NO_SUCH_OBJECT)) {
517        if (conf->fallback && (is_fallback++ <= 0)) {
518            ap_log_rerror(APLOG_MARK, APLOG_NOTICE|APLOG_NOERRNO, 0, r,
519                          "[mod_vhost_ldap.c] translate: "
520                          "virtual host %s not found, trying fallback %s",
521                          hostname, conf->fallback);
522            hostname = conf->fallback;
523            goto fallback;
524        }
525
526        ap_log_rerror(APLOG_MARK, APLOG_WARNING|APLOG_NOERRNO, 0, r,
527                      "[mod_vhost_ldap.c] translate: "
528                      "virtual host %s not found",
529                      hostname);
530
531        return DECLINED;
532    }
533
534    /* handle bind failure */
535    if (result != LDAP_SUCCESS) {
536        ap_log_rerror(APLOG_MARK, APLOG_WARNING|APLOG_NOERRNO, 0, r, 
537                      "[mod_vhost_ldap.c] translate: "
538                      "translate failed; virtual host %s; URI %s [%s]",
539                      hostname, r->uri, ldap_err2string(result));
540        return DECLINED;
541    }
542
543    /* mark the user and DN */
544    reqc->dn = apr_pstrdup(r->pool, dn);
545
546    /* Optimize */
547    if (vals) {
548        int i = 0;
549        while (attributes[i]) {
550
551            if (strcasecmp (attributes[i], "apacheServerName") == 0) {
552                reqc->name = apr_pstrdup (r->pool, vals[i]);
553            }
554            else if (strcasecmp (attributes[i], "apacheServerAdmin") == 0) {
555                reqc->admin = apr_pstrdup (r->pool, vals[i]);
556            }
557            else if (strcasecmp (attributes[i], "apacheDocumentRoot") == 0) {
558                reqc->docroot = apr_pstrdup (r->pool, vals[i]);
559            }
560            else if (strcasecmp (attributes[i], "apacheScriptAlias") == 0) {
561                reqc->cgiroot = apr_pstrdup (r->pool, vals[i]);
562            }
563            else if (strcasecmp (attributes[i], "apacheSuexecUid") == 0) {
564                reqc->uid = apr_pstrdup(r->pool, vals[i]);
565            }
566            else if (strcasecmp (attributes[i], "apacheSuexecGid") == 0) {
567                reqc->gid = apr_pstrdup(r->pool, vals[i]);
568            }
569            i++;
570        }
571    }
572
573    ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,
574                  "[mod_vhost_ldap.c]: loaded from ldap: "
575                  "apacheServerName: %s, "
576                  "apacheServerAdmin: %s, "
577                  "apacheDocumentRoot: %s, "
578                  "apacheScriptAlias: %s, "
579                  "apacheSuexecUid: %s, "
580                  "apacheSuexecGid: %s",
581                  reqc->name, reqc->admin, reqc->docroot, reqc->cgiroot, reqc->uid, reqc->gid);
582
583    if ((reqc->name == NULL)||(reqc->docroot == NULL)) {
584        ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, r, 
585                      "[mod_vhost_ldap.c] translate: "
586                      "translate failed; ServerName or DocumentRoot not defined");
587        return DECLINED;
588    }
589
590    cgi = NULL;
591 
592#if 0
593    if (reqc->cgiroot) {
594        cgi = strstr(r->uri, "cgi-bin/");
595        if (cgi && (cgi != r->uri + strspn(r->uri, "/"))) {
596            cgi = NULL;
597        }
598    }
599    if (cgi) {
600        r->filename = apr_pstrcat (r->pool, reqc->cgiroot, cgi + strlen("cgi-bin"), NULL);
601        r->handler = "cgi-script";
602        apr_table_setn(r->notes, "alias-forced-type", r->handler);
603#endif
604    /* This is a quick, dirty hack. I should be shot for taking 6.170
605     * this term and being willing to write a quick, dirty hack. */
606   
607    if (strncmp(r->uri, "/~", 2) == 0) {
608        char *username;
609        uid_t uid = (uid_t)atoll(reqc->uid);
610        if (apr_uid_name_get(&username, uid, r->pool) != APR_SUCCESS) {
611            ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, r, 
612                          "could not get username for uid %d", uid);
613            return DECLINED;
614        }
615        if (strncmp(r->uri + 2, username, strlen(username)) == 0 &&
616            (r->uri[2 + strlen(username)] == '/' ||
617             r->uri[2 + strlen(username)] == '\0')) {
618            char *homedir;
619            if (apr_uid_homepath_get(&homedir, username, r->pool) != APR_SUCCESS) {
620                ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, r, 
621                              "could not get home directory for user %s", username);
622                return DECLINED;
623            }
624            r->filename = apr_pstrcat(r->pool, homedir, "/", USERDIR, r->uri + 2 + strlen(username), NULL);
625        }
626    } else if (r->uri[0] == '/') {
627        r->filename = apr_pstrcat (r->pool, reqc->docroot, r->uri, NULL);
628    } else {
629        return DECLINED;
630    }
631
632    top->server->server_hostname = apr_pstrdup (top->pool, reqc->name);
633
634    if (reqc->admin) {
635        top->server->server_admin = apr_pstrdup (top->pool, reqc->admin);
636    }
637
638    // set environment variables
639    e = top->subprocess_env;
640    apr_table_addn (e, "SERVER_ROOT", reqc->docroot);
641
642    core->ap_document_root = apr_pstrdup(top->pool, reqc->docroot);
643
644    ap_log_rerror(APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO, 0, r,
645                  "[mod_vhost_ldap.c]: translated to %s", r->filename);
646
647    return OK;
648}
649
650#ifdef HAVE_UNIX_SUEXEC
651static ap_unix_identity_t *mod_vhost_ldap_get_suexec_id_doer(const request_rec * r)
652{
653  ap_unix_identity_t *ugid = NULL;
654  mod_vhost_ldap_config_t *conf = 
655      (mod_vhost_ldap_config_t *)ap_get_module_config(r->server->module_config,
656                                                      &vhost_ldap_module);
657  mod_vhost_ldap_request_t *req =
658      (mod_vhost_ldap_request_t *)ap_get_module_config(r->request_config,
659                                                       &vhost_ldap_module);
660
661  uid_t uid = -1;
662  gid_t gid = -1;
663
664  // mod_vhost_ldap is disabled or we don't have LDAP Url
665  if ((conf->enabled != MVL_ENABLED)||(!conf->have_ldap_url)) {
666      return NULL;
667  }
668
669  if ((req == NULL)||(req->uid == NULL)||(req->gid == NULL)) {
670      return NULL;
671  }
672
673  if ((ugid = apr_palloc(r->pool, sizeof(ap_unix_identity_t))) == NULL) {
674      return NULL;
675  }
676
677  uid = (uid_t)atoll(req->uid);
678  gid = (gid_t)atoll(req->gid);
679
680  if ((uid < MIN_UID)||(gid < MIN_GID)) {
681      return NULL;
682  }
683
684  ugid->uid = uid;
685  ugid->gid = gid;
686  ugid->userdir = 0;
687 
688  return ugid;
689}
690#endif
691
692static void
693mod_vhost_ldap_register_hooks (apr_pool_t * p)
694{
695    ap_hook_post_config(mod_vhost_ldap_post_config, NULL, NULL, APR_HOOK_MIDDLE);
696    ap_hook_translate_name(mod_vhost_ldap_translate_name, NULL, NULL, APR_HOOK_MIDDLE);
697#ifdef HAVE_UNIX_SUEXEC
698    ap_hook_get_suexec_identity(mod_vhost_ldap_get_suexec_id_doer, NULL, NULL, APR_HOOK_MIDDLE);
699#endif
700#if (APR_MAJOR_VERSION >= 1)
701    ap_hook_optional_fn_retrieve(ImportULDAPOptFn,NULL,NULL,APR_HOOK_MIDDLE);
702#endif
703}
704
705module AP_MODULE_DECLARE_DATA vhost_ldap_module = {
706  STANDARD20_MODULE_STUFF,
707  NULL,
708  NULL,
709  mod_vhost_ldap_create_server_config,
710  mod_vhost_ldap_merge_server_config,
711  mod_vhost_ldap_cmds,
712  mod_vhost_ldap_register_hooks,
713};
Note: See TracBrowser for help on using the repository browser.