Context Navigation

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

Last change on this file since 561 was 483, checked in by geofft, 17 years ago
allow /~user with no trailing slash to work
Property svn:eol-style set to `native`
File size: 22.7 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
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	};

Note: See TracBrowser for help on using the repository browser.

Download in other formats: