init.c 14.1 KB
Newer Older
1
/* $OpenLDAP$ */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
2
/*
Kurt Zeilenga's avatar
Kurt Zeilenga committed
3
 * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
Kurt Zeilenga's avatar
Kurt Zeilenga committed
4
5
 * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
 */
6
7
8
#include "portable.h"

#include <stdio.h>
Kurt Zeilenga's avatar
Kurt Zeilenga committed
9
#include <ac/stdlib.h>
10
11
12

#include <ac/socket.h>
#include <ac/string.h>
13
#include <ac/ctype.h>
14
15
#include <ac/time.h>

16
17
#include <limits.h>

18
#include "ldap-int.h"
19
#include "ldap_defaults.h"
20

21
22
struct ldapoptions ldap_int_global_options =
	{ LDAP_UNINITIALIZED, LDAP_DEBUG_NONE };  
23

24
25
26
27
28
#define ATTR_NONE	0
#define ATTR_BOOL	1
#define ATTR_INT	2
#define ATTR_KV		3
#define ATTR_STRING	4
29
#define ATTR_OPTION	5
30
31
32

#define ATTR_SASL	6
#define ATTR_TLS	7
33
34

struct ol_keyvalue {
35
	const char *		key;
36
37
38
	int			value;
};

39
static const struct ol_keyvalue deref_kv[] = {
40
41
42
43
44
45
46
	{"never", LDAP_DEREF_NEVER},
	{"searching", LDAP_DEREF_SEARCHING},
	{"finding", LDAP_DEREF_FINDING},
	{"always", LDAP_DEREF_ALWAYS},
	{NULL, 0}
};

47
static const struct ol_attribute {
48
	int			useronly;
49
	int			type;
50
51
	const char *	name;
	const void *	data;
52
53
	size_t		offset;
} attrs[] = {
54
	{0, ATTR_KV,		"DEREF",	deref_kv, /* or &deref_kv[0] */
55
		offsetof(struct ldapoptions, ldo_deref)},
56
	{0, ATTR_INT,		"SIZELIMIT",	NULL,
57
		offsetof(struct ldapoptions, ldo_sizelimit)},
58
	{0, ATTR_INT,		"TIMELIMIT",	NULL,
59
		offsetof(struct ldapoptions, ldo_timelimit)},
60
61
	{1, ATTR_STRING,	"BINDDN",		NULL,
		offsetof(struct ldapoptions, ldo_defbinddn)},
62
	{0, ATTR_STRING,	"BASE",			NULL,
63
		offsetof(struct ldapoptions, ldo_defbase)},
64
	{0, ATTR_INT,		"PORT",			NULL,		/* deprecated */
65
		offsetof(struct ldapoptions, ldo_defport)},
66
67
	{0, ATTR_OPTION,	"HOST",			NULL,	LDAP_OPT_HOST_NAME}, /* deprecated */
	{0, ATTR_OPTION,	"URI",			NULL,	LDAP_OPT_URI}, /* replaces HOST/PORT */
68
69
	{0, ATTR_BOOL,		"REFERRALS",	NULL,	LDAP_BOOL_REFERRALS},
	{0, ATTR_BOOL,		"RESTART",		NULL,	LDAP_BOOL_RESTART},
70

71
#ifdef HAVE_CYRUS_SASL
72
73
74
75
76
77
78
79
80
	{1, ATTR_STRING,	"SASL_MECH",		NULL,
		offsetof(struct ldapoptions, ldo_def_sasl_mech)},
	{1, ATTR_STRING,	"SASL_REALM",		NULL,
		offsetof(struct ldapoptions, ldo_def_sasl_realm)},
	{1, ATTR_STRING,	"SASL_AUTHCID",		NULL,
		offsetof(struct ldapoptions, ldo_def_sasl_authcid)},
	{1, ATTR_STRING,	"SASL_AUTHZID",		NULL,
		offsetof(struct ldapoptions, ldo_def_sasl_authzid)},
	{0, ATTR_SASL,		"SASL_SECPROPS",	NULL,	LDAP_OPT_X_SASL_SECPROPS},
81
82
#endif

83
#ifdef HAVE_TLS
84
  	{0, ATTR_TLS,		"TLS",			NULL,	LDAP_OPT_X_TLS},
85
86
	{1, ATTR_TLS,		"TLS_CERT",		NULL,	LDAP_OPT_X_TLS_CERTFILE},
	{1, ATTR_TLS,		"TLS_KEY",		NULL,	LDAP_OPT_X_TLS_KEYFILE},
87
88
  	{0, ATTR_TLS,		"TLS_CACERT",	NULL,	LDAP_OPT_X_TLS_CACERTFILE},
  	{0, ATTR_TLS,		"TLS_CACERTDIR",NULL,	LDAP_OPT_X_TLS_CACERTDIR},
89
90
  	{0, ATTR_TLS,		"TLS_REQCERT",	NULL,	LDAP_OPT_X_TLS_REQUIRE_CERT},
	{0, ATTR_TLS,		"TLS_RANDFILE",	NULL,	LDAP_OPT_X_TLS_RANDOM_FILE},
91
92
#endif

93
	{0, ATTR_NONE,		NULL,		NULL,	0}
94
95
};

96
#define MAX_LDAP_ATTR_LEN  sizeof("TLS_CACERTDIR")
97
98
#define MAX_LDAP_ENV_PREFIX_LEN 8

99
100
static void openldap_ldap_init_w_conf(
	const char *file, int userconf )
101
102
103
104
105
106
{
	char linebuf[128];
	FILE *fp;
	int i;
	char *cmd, *opt;
	char *start, *end;
107
108
109
110
111
	struct ldapoptions *gopts;

	if ((gopts = LDAP_INT_GLOBAL_OPT()) == NULL) {
		return;			/* Could not allocate mem for global options */
	}
112

113
114
115
116
117
	if (file == NULL) {
		/* no file name */
		return;
	}

Julius Enarusai's avatar
   
Julius Enarusai committed
118
#ifdef NEW_LOGGING
Julius Enarusai's avatar
   
Julius Enarusai committed
119
120
	LDAP_LOG ( CONFIG, DETAIL1, 
		"openldap_init_w_conf: trying %s\n", file, 0, 0 );
Julius Enarusai's avatar
   
Julius Enarusai committed
121
#else
122
	Debug(LDAP_DEBUG_TRACE, "ldap_init: trying %s\n", file, 0, 0);
Julius Enarusai's avatar
   
Julius Enarusai committed
123
#endif
124

125
126
127
128
129
130
	fp = fopen(file, "r");
	if(fp == NULL) {
		/* could not open file */
		return;
	}

Julius Enarusai's avatar
   
Julius Enarusai committed
131
#ifdef NEW_LOGGING
Julius Enarusai's avatar
   
Julius Enarusai committed
132
	LDAP_LOG ( CONFIG, DETAIL1, "openldap_init_w_conf: using %s\n", file, 0, 0 );
Julius Enarusai's avatar
   
Julius Enarusai committed
133
#else
134
	Debug(LDAP_DEBUG_TRACE, "ldap_init: using %s\n", file, 0, 0);
Julius Enarusai's avatar
   
Julius Enarusai committed
135
#endif
136

137
138
139
140
141
	while((start = fgets(linebuf, sizeof(linebuf), fp)) != NULL) {
		/* skip lines starting with '#' */
		if(*start == '#') continue;

		/* trim leading white space */
142
143
		while((*start != '\0') && isspace((unsigned char) *start))
			start++;
144
145
146
147
148
149

		/* anything left? */
		if(*start == '\0') continue;

		/* trim trailing white space */
		end = &start[strlen(start)-1];
150
		while(isspace((unsigned char)*end)) end--;
151
152
153
154
155
156
157
158
		end[1] = '\0';

		/* anything left? */
		if(*start == '\0') continue;
		

		/* parse the command */
		cmd=start;
159
		while((*start != '\0') && !isspace((unsigned char)*start)) {
160
161
162
163
164
165
166
167
168
			start++;
		}
		if(*start == '\0') {
			/* command has no argument */
			continue;
		} 

		*start++ = '\0';

169
		/* we must have some whitespace to skip */
170
		while(isspace((unsigned char)*start)) start++;
171
172
173
174
175
		opt = start;

		for(i=0; attrs[i].type != ATTR_NONE; i++) {
			void *p;

176
			if( !userconf && attrs[i].useronly ) {
177
178
179
				continue;
			}

180
181
182
183
184
185
186
187
188
189
			if(strcasecmp(cmd, attrs[i].name) != 0) {
				continue;
			}

			switch(attrs[i].type) {
			case ATTR_BOOL:
				if((strcasecmp(opt, "on") == 0) 
					|| (strcasecmp(opt, "yes") == 0)
					|| (strcasecmp(opt, "true") == 0))
				{
190
					LDAP_BOOL_SET(gopts, attrs[i].offset);
191
192

				} else {
193
					LDAP_BOOL_CLR(gopts, attrs[i].offset);
194
195
196
197
198
				}

				break;

			case ATTR_INT:
199
				p = &((char *) gopts)[attrs[i].offset];
200
201
202
203
				* (int*) p = atoi(opt);
				break;

			case ATTR_KV: {
204
					const struct ol_keyvalue *kv;
205

206
					for(kv = attrs[i].data;
207
208
209
210
						kv->key != NULL;
						kv++) {

						if(strcasecmp(opt, kv->key) == 0) {
211
							p = &((char *) gopts)[attrs[i].offset];
212
213
214
215
216
217
218
							* (int*) p = kv->value;
							break;
						}
					}
				} break;

			case ATTR_STRING:
219
				p = &((char *) gopts)[attrs[i].offset];
220
				if (* (char**) p != NULL) LDAP_FREE(* (char**) p);
221
				* (char**) p = LDAP_STRDUP(opt);
222
				break;
223
224
			case ATTR_OPTION:
				ldap_set_option( NULL, attrs[i].offset, opt );
225
				break;
226
227
228
229
230
231
232
			case ATTR_SASL:
#ifdef HAVE_CYRUS_SASL
			   	ldap_int_sasl_config( gopts, attrs[i].offset, opt );
#endif
				break;
			case ATTR_TLS:
#ifdef HAVE_TLS
Kurt Zeilenga's avatar
Kurt Zeilenga committed
233
			   	ldap_int_tls_config( NULL, attrs[i].offset, opt );
234
235
#endif
				break;
236
			}
237

238
			break;
239
240
		}
	}
241
242

	fclose(fp);
243
244
}

245
246
247
248
249
static void openldap_ldap_init_w_sysconf(const char *file)
{
	openldap_ldap_init_w_conf( file, 0 );
}

250
251
static void openldap_ldap_init_w_userconf(const char *file)
{
252
	char *home;
253
	char *path = NULL;
254
255
256
257
258
259
260
261

	if (file == NULL) {
		/* no file name */
		return;
	}

	home = getenv("HOME");

Kurt Zeilenga's avatar
Kurt Zeilenga committed
262
	if (home != NULL) {
Julius Enarusai's avatar
   
Julius Enarusai committed
263
#ifdef NEW_LOGGING
Julius Enarusai's avatar
   
Julius Enarusai committed
264
265
	LDAP_LOG ( CONFIG, ARGS, 
		"openldap_init_w_userconf: HOME env is %s\n", home, 0, 0 );
Julius Enarusai's avatar
   
Julius Enarusai committed
266
#else
267
268
		Debug(LDAP_DEBUG_TRACE, "ldap_init: HOME env is %s\n",
		      home, 0, 0);
Julius Enarusai's avatar
   
Julius Enarusai committed
269
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed
270
		path = LDAP_MALLOC(strlen(home) + strlen(file) + sizeof( LDAP_DIRSEP "."));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
271
	} else {
Julius Enarusai's avatar
   
Julius Enarusai committed
272
#ifdef NEW_LOGGING
Julius Enarusai's avatar
   
Julius Enarusai committed
273
274
	LDAP_LOG ( CONFIG, ARGS, "openldap_init_w_userconf: HOME env is NULL\n",
		0, 0, 0 );
Julius Enarusai's avatar
   
Julius Enarusai committed
275
#else
276
277
		Debug(LDAP_DEBUG_TRACE, "ldap_init: HOME env is NULL\n",
		      0, 0, 0);
Julius Enarusai's avatar
   
Julius Enarusai committed
278
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed
279
280
281
	}

	if(home != NULL && path != NULL) {
282
283
		/* we assume UNIX path syntax is used... */

Kurt Zeilenga's avatar
Kurt Zeilenga committed
284
		/* try ~/file */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
285
		sprintf(path, "%s" LDAP_DIRSEP "%s", home, file);
286
		openldap_ldap_init_w_conf(path, 1);
287

Kurt Zeilenga's avatar
Kurt Zeilenga committed
288
		/* try ~/.file */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
289
		sprintf(path, "%s" LDAP_DIRSEP ".%s", home, file);
290
		openldap_ldap_init_w_conf(path, 1);
Kurt Zeilenga's avatar
Kurt Zeilenga committed
291
	}
292
293

	if(path != NULL) {
294
		LDAP_FREE(path);
295
	}
296
297

	/* try file */
298
	openldap_ldap_init_w_conf(file, 1);
299
300
}

301
302
303
static void openldap_ldap_init_w_env(
		struct ldapoptions *gopts,
		const char *prefix)
304
305
306
307
308
309
310
311
{
	char buf[MAX_LDAP_ATTR_LEN+MAX_LDAP_ENV_PREFIX_LEN];
	int len;
	int i;
	void *p;
	char *value;

	if (prefix == NULL) {
312
		prefix = LDAP_ENV_PREFIX;
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
	}

	strncpy(buf, prefix, MAX_LDAP_ENV_PREFIX_LEN);
	buf[MAX_LDAP_ENV_PREFIX_LEN] = '\0';
	len = strlen(buf);

	for(i=0; attrs[i].type != ATTR_NONE; i++) {
		strcpy(&buf[len], attrs[i].name);
		value = getenv(buf);

		if(value == NULL) {
			continue;
		}

		switch(attrs[i].type) {
		case ATTR_BOOL:
			if((strcasecmp(value, "on") == 0) 
				|| (strcasecmp(value, "yes") == 0)
				|| (strcasecmp(value, "true") == 0))
			{
333
				LDAP_BOOL_SET(gopts, attrs[i].offset);
334
335

			} else {
336
				LDAP_BOOL_CLR(gopts, attrs[i].offset);
337
338
339
340
			}
			break;

		case ATTR_INT:
341
			p = &((char *) gopts)[attrs[i].offset];
342
343
344
345
			* (int*) p = atoi(value);
			break;

		case ATTR_KV: {
346
				const struct ol_keyvalue *kv;
347

348
				for(kv = attrs[i].data;
349
350
351
352
					kv->key != NULL;
					kv++) {

					if(strcasecmp(value, kv->key) == 0) {
353
						p = &((char *) gopts)[attrs[i].offset];
354
355
356
357
358
359
360
						* (int*) p = kv->value;
						break;
					}
				}
			} break;

		case ATTR_STRING:
361
			p = &((char *) gopts)[attrs[i].offset];
362
			if (* (char**) p != NULL) LDAP_FREE(* (char**) p);
363
364
365
			if (*value == '\0') {
				* (char**) p = NULL;
			} else {
366
				* (char**) p = LDAP_STRDUP(value);
367
368
			}
			break;
369
370
		case ATTR_OPTION:
			ldap_set_option( NULL, attrs[i].offset, value );
371
			break;
372
373
374
375
376
377
378
		case ATTR_SASL:
#ifdef HAVE_CYRUS_SASL
		   	ldap_int_sasl_config( gopts, attrs[i].offset, value );
#endif			 	
		   	break;
		case ATTR_TLS:
#ifdef HAVE_TLS
Kurt Zeilenga's avatar
Kurt Zeilenga committed
379
		   	ldap_int_tls_config( NULL, attrs[i].offset, value );
380
381
#endif			 	
		   	break;
382
383
384
385
		}
	}
}

386
387
388
389
390
391
392
393
394
395
396
#if defined(__GNUC__)
/* Declare this function as a destructor so that it will automatically be
 * invoked either at program exit (if libldap is a static library) or
 * at unload time (if libldap is a dynamic library).
 *
 * Sorry, don't know how to handle this for non-GCC environments.
 */
static void ldap_int_destroy_global_options(void)
	__attribute__ ((destructor));
#endif

397
static void
Howard Chu's avatar
Howard Chu committed
398
ldap_int_destroy_global_options(void)
399
400
401
402
403
404
405
{
	struct ldapoptions *gopts = LDAP_INT_GLOBAL_OPT();

	if ( gopts->ldo_defludp ) {
		ldap_free_urllist( gopts->ldo_defludp );
		gopts->ldo_defludp = NULL;
	}
406
407
408
#if defined(HAVE_WINSOCK) || defined(HAVE_WINSOCK2)
	WSACleanup( );
#endif
409
410
}

411
412
413
414
/* 
 * Initialize the global options structure with default values.
 */
void ldap_int_initialize_global_options( struct ldapoptions *gopts, int *dbglvl )
415
{
416
	if (dbglvl)
417
	    gopts->ldo_debug = *dbglvl;
418
	else
419
		gopts->ldo_debug = 0;
420

421
422
423
424
	gopts->ldo_version   = LDAP_VERSION2;
	gopts->ldo_deref     = LDAP_DEREF_NEVER;
	gopts->ldo_timelimit = LDAP_NO_LIMIT;
	gopts->ldo_sizelimit = LDAP_NO_LIMIT;
425

426
427
	gopts->ldo_tm_api = (struct timeval *)NULL;
	gopts->ldo_tm_net = (struct timeval *)NULL;
428

429
	/* ldo_defludp will be freed by the termination handler
430
	 */
431
432
	ldap_url_parselist(&gopts->ldo_defludp, "ldap://localhost/");
	gopts->ldo_defport = LDAP_PORT;
433
434
435
436
#if !defined(__GNUC__) && !defined(PIC)
	/* Do this only for a static library, and only if we can't
	 * arrange for it to be executed as a library destructor
	 */
437
	atexit(ldap_int_destroy_global_options);
438
#endif
439

440
	gopts->ldo_refhoplimit = LDAP_DEFAULT_REFHOPLIMIT;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
441
442
	gopts->ldo_rebind_proc = NULL;
	gopts->ldo_rebind_params = NULL;
443

444
	LDAP_BOOL_ZERO(gopts);
445

446
	LDAP_BOOL_SET(gopts, LDAP_BOOL_REFERRALS);
447

448
449
450
#ifdef LDAP_CONNECTIONLESS
	gopts->ldo_peer = NULL;
	gopts->ldo_cldapdn = NULL;
Howard Chu's avatar
Howard Chu committed
451
	gopts->ldo_is_udp = 0;
452
453
#endif

454
#ifdef HAVE_CYRUS_SASL
455
456
457
458
459
	gopts->ldo_def_sasl_mech = NULL;
	gopts->ldo_def_sasl_realm = NULL;
	gopts->ldo_def_sasl_authcid = NULL;
	gopts->ldo_def_sasl_authzid = NULL;

Kurt Zeilenga's avatar
Kurt Zeilenga committed
460
461
	memset( &gopts->ldo_sasl_secprops,
		'\0', sizeof(gopts->ldo_sasl_secprops) );
462
463

	gopts->ldo_sasl_secprops.max_ssf = INT_MAX;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
464
465
466
	gopts->ldo_sasl_secprops.maxbufsize = SASL_MAX_BUFF_SIZE;
	gopts->ldo_sasl_secprops.security_flags =
		SASL_SEC_NOPLAINTEXT | SASL_SEC_NOANONYMOUS;
467
#endif
468

469
470
471
472
	gopts->ldo_valid = LDAP_INITIALIZED;
   	return;
}

473
474
#if defined(LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND) \
	|| defined(HAVE_TLS) || defined(HAVE_CYRUS_SASL)
475
char * ldap_int_hostname = NULL;
476
477
#endif

478
479
480
481
482
483
void ldap_int_initialize( struct ldapoptions *gopts, int *dbglvl )
{
	if ( gopts->ldo_valid == LDAP_INITIALIZED ) {
		return;
	}

484
485
	ldap_int_error_init();

486
487
	ldap_int_utils_init();

488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
#ifdef HAVE_WINSOCK2
{	WORD wVersionRequested;
	WSADATA wsaData;
 
	wVersionRequested = MAKEWORD( 2, 0 );
	if ( WSAStartup( wVersionRequested, &wsaData ) != 0 ) {
		/* Tell the user that we couldn't find a usable */
		/* WinSock DLL.                                  */
		return;
	}
 
	/* Confirm that the WinSock DLL supports 2.0.*/
	/* Note that if the DLL supports versions greater    */
	/* than 2.0 in addition to 2.0, it will still return */
	/* 2.0 in wVersion since that is the version we      */
	/* requested.                                        */
 
	if ( LOBYTE( wsaData.wVersion ) != 2 ||
		HIBYTE( wsaData.wVersion ) != 0 )
	{
	    /* Tell the user that we couldn't find a usable */
	    /* WinSock DLL.                                  */
	    WSACleanup( );
	    return; 
	}
}	/* The WinSock DLL is acceptable. Proceed. */
#elif HAVE_WINSOCK
{	WSADATA wsaData;
	if ( WSAStartup( 0x0101, &wsaData ) != 0 ) {
	    return;
	}
}
520
521
522
523
524
#endif

#if defined(LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND) \
	|| defined(HAVE_TLS) || defined(HAVE_CYRUS_SASL)
	ldap_int_hostname = ldap_pvt_get_fqdn( ldap_int_hostname );
525
#endif
526
527
528
529
	if ( ldap_int_tblsize == 0 )
		ldap_int_ip_init();

	ldap_int_initialize_global_options(gopts, NULL);
Kurt Zeilenga's avatar
Kurt Zeilenga committed
530
531
532
533
534

	if( getenv("LDAPNOINIT") != NULL ) {
		return;
	}

535
536
537
538
539
540
541
542
543
#ifdef HAVE_CYRUS_SASL
	{
		/* set authentication identity to current user name */
		char *user = getenv("USER");

		if( user == NULL ) user = getenv("USERNAME");
		if( user == NULL ) user = getenv("LOGNAME");

		if( user != NULL ) {
544
			gopts->ldo_def_sasl_authcid = user;
545
546
547
548
		}
    }
#endif

549
	openldap_ldap_init_w_sysconf(LDAP_CONF_FILE);
550
	openldap_ldap_init_w_userconf(LDAP_USERRC_FILE);
551
552

	{
553
		char *altfile = getenv(LDAP_ENV_PREFIX "CONF");
554
555

		if( altfile != NULL ) {
Julius Enarusai's avatar
   
Julius Enarusai committed
556
#ifdef NEW_LOGGING
Julius Enarusai's avatar
   
Julius Enarusai committed
557
			LDAP_LOG ( CONFIG, DETAIL1, 
Julius Enarusai's avatar
   
Julius Enarusai committed
558
				"openldap_init_w_userconf: %sCONF env is %s\n",
Julius Enarusai's avatar
   
Julius Enarusai committed
559
				LDAP_ENV_PREFIX, altfile, 0 );
Julius Enarusai's avatar
   
Julius Enarusai committed
560
#else
561
562
			Debug(LDAP_DEBUG_TRACE, "ldap_init: %s env is %s\n",
			      LDAP_ENV_PREFIX "CONF", altfile, 0);
Julius Enarusai's avatar
   
Julius Enarusai committed
563
#endif
564
			openldap_ldap_init_w_sysconf( altfile );
565
		}
566
		else
Julius Enarusai's avatar
   
Julius Enarusai committed
567
#ifdef NEW_LOGGING
Julius Enarusai's avatar
   
Julius Enarusai committed
568
			LDAP_LOG ( CONFIG, DETAIL1, 
Julius Enarusai's avatar
   
Julius Enarusai committed
569
				"openldap_init_w_userconf: %sCONF env is NULL\n",
Julius Enarusai's avatar
   
Julius Enarusai committed
570
				LDAP_ENV_PREFIX, 0, 0 );
Julius Enarusai's avatar
   
Julius Enarusai committed
571
#else
572
573
			Debug(LDAP_DEBUG_TRACE, "ldap_init: %s env is NULL\n",
			      LDAP_ENV_PREFIX "CONF", 0, 0);
Julius Enarusai's avatar
   
Julius Enarusai committed
574
#endif
575
576
	}

577
	{
578
		char *altfile = getenv(LDAP_ENV_PREFIX "RC");
579
580

		if( altfile != NULL ) {
Julius Enarusai's avatar
   
Julius Enarusai committed
581
#ifdef NEW_LOGGING
Julius Enarusai's avatar
   
Julius Enarusai committed
582
			LDAP_LOG ( CONFIG, DETAIL1, 
Julius Enarusai's avatar
   
Julius Enarusai committed
583
				"openldap_init_w_userconf: %sRC env is %s\n",
Julius Enarusai's avatar
   
Julius Enarusai committed
584
				LDAP_ENV_PREFIX, altfile, 0 );
Julius Enarusai's avatar
   
Julius Enarusai committed
585
#else
586
587
			Debug(LDAP_DEBUG_TRACE, "ldap_init: %s env is %s\n",
			      LDAP_ENV_PREFIX "RC", altfile, 0);
Julius Enarusai's avatar
   
Julius Enarusai committed
588
#endif
589
590
			openldap_ldap_init_w_userconf( altfile );
		}
591
		else
Julius Enarusai's avatar
   
Julius Enarusai committed
592
#ifdef NEW_LOGGING
Julius Enarusai's avatar
   
Julius Enarusai committed
593
			LDAP_LOG ( CONFIG, DETAIL1, 
Julius Enarusai's avatar
   
Julius Enarusai committed
594
				"openldap_init_w_userconf: %sRC env is NULL\n",
Julius Enarusai's avatar
   
Julius Enarusai committed
595
				LDAP_ENV_PREFIX, 0, 0 );
Julius Enarusai's avatar
   
Julius Enarusai committed
596
#else
597
598
			Debug(LDAP_DEBUG_TRACE, "ldap_init: %s env is NULL\n",
			      LDAP_ENV_PREFIX "RC", 0, 0);
Julius Enarusai's avatar
   
Julius Enarusai committed
599
#endif
600
601
	}

602
	openldap_ldap_init_w_env(gopts, NULL);
603
604

	ldap_int_sasl_init();
605
}