init.c 14 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
85
	{1, ATTR_TLS,		"TLS_CERT",		NULL,	LDAP_OPT_X_TLS_CERTFILE},
	{1, ATTR_TLS,		"TLS_KEY",		NULL,	LDAP_OPT_X_TLS_KEYFILE},
86
87
  	{0, ATTR_TLS,		"TLS_CACERT",	NULL,	LDAP_OPT_X_TLS_CACERTFILE},
  	{0, ATTR_TLS,		"TLS_CACERTDIR",NULL,	LDAP_OPT_X_TLS_CACERTDIR},
88
89
  	{0, ATTR_TLS,		"TLS_REQCERT",	NULL,	LDAP_OPT_X_TLS_REQUIRE_CERT},
	{0, ATTR_TLS,		"TLS_RANDFILE",	NULL,	LDAP_OPT_X_TLS_RANDOM_FILE},
90
91
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		*start++ = '\0';

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

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

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

179
180
181
182
183
184
185
186
187
188
			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))
				{
189
					LDAP_BOOL_SET(gopts, attrs[i].offset);
190
191

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

				break;

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

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

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

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

			case ATTR_STRING:
218
				p = &((char *) gopts)[attrs[i].offset];
219
				if (* (char**) p != NULL) LDAP_FREE(* (char**) p);
220
				* (char**) p = LDAP_STRDUP(opt);
221
				break;
222
223
			case ATTR_OPTION:
				ldap_set_option( NULL, attrs[i].offset, opt );
224
				break;
225
226
227
228
229
230
231
			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
232
			   	ldap_int_tls_config( NULL, attrs[i].offset, opt );
233
234
#endif
				break;
235
			}
236

237
			break;
238
239
		}
	}
240
241

	fclose(fp);
242
243
}

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

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

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

	home = getenv("HOME");

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

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

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

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

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

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

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

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

	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))
			{
332
				LDAP_BOOL_SET(gopts, attrs[i].offset);
333
334

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

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

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

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

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

		case ATTR_STRING:
360
			p = &((char *) gopts)[attrs[i].offset];
361
			if (* (char**) p != NULL) LDAP_FREE(* (char**) p);
362
363
364
			if (*value == '\0') {
				* (char**) p = NULL;
			} else {
365
				* (char**) p = LDAP_STRDUP(value);
366
367
			}
			break;
368
369
		case ATTR_OPTION:
			ldap_set_option( NULL, attrs[i].offset, value );
370
			break;
371
372
373
374
375
376
377
		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
378
		   	ldap_int_tls_config( NULL, attrs[i].offset, value );
379
380
#endif			 	
		   	break;
381
382
383
384
		}
	}
}

385
386
387
388
389
390
391
392
393
394
395
#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

396
static void
Howard Chu's avatar
Howard Chu committed
397
ldap_int_destroy_global_options(void)
398
399
400
{
	struct ldapoptions *gopts = LDAP_INT_GLOBAL_OPT();

401
402
	gopts->ldo_valid = LDAP_UNINITIALIZED;

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

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

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

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

430
	/* ldo_defludp will be freed by the termination handler
431
	 */
432
433
	ldap_url_parselist(&gopts->ldo_defludp, "ldap://localhost/");
	gopts->ldo_defport = LDAP_PORT;
434
435
436
437
#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
	 */
438
	atexit(ldap_int_destroy_global_options);
439
#endif
440

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

445
	LDAP_BOOL_ZERO(gopts);
446

447
	LDAP_BOOL_SET(gopts, LDAP_BOOL_REFERRALS);
448

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

455
#ifdef HAVE_CYRUS_SASL
456
457
458
459
460
	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
461
462
	memset( &gopts->ldo_sasl_secprops,
		'\0', sizeof(gopts->ldo_sasl_secprops) );
463
464

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

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

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

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

485
486
	ldap_int_error_init();

487
488
	ldap_int_utils_init();

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
520
#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;
	}
}
521
522
523
524
525
#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 );
526
#endif
527
528
529
530
	if ( ldap_int_tblsize == 0 )
		ldap_int_ip_init();

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

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

536
537
538
539
540
541
542
543
544
#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 ) {
545
			gopts->ldo_def_sasl_authcid = user;
546
547
548
549
		}
    }
#endif

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

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

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

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

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

603
	openldap_ldap_init_w_env(gopts, NULL);
604
605

	ldap_int_sasl_init();
606
}