ldap-int.h 24.1 KB
Newer Older
Kurt Zeilenga's avatar
Kurt Zeilenga committed
1
/*  ldap-int.h - defines & prototypes internal to the LDAP library */
2
/* $OpenLDAP$ */
3
4
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
 *
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
5
 * Copyright 1998-2020 The OpenLDAP Foundation.
6
7
8
9
10
11
12
13
14
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted only as authorized by the OpenLDAP
 * Public License.
 *
 * A copy of this license is available in the file LICENSE in the
 * top-level directory of the distribution or, alternatively, at
 * <http://www.OpenLDAP.org/license.html>.
Kurt Zeilenga's avatar
Kurt Zeilenga committed
15
 */
16
/*  Portions Copyright (c) 1995 Regents of the University of Michigan.
Kurt Zeilenga's avatar
Kurt Zeilenga committed
17
18
19
 *  All rights reserved.
 */

20
21
#ifndef	_LDAP_INT_H
#define	_LDAP_INT_H 1
Kurt Zeilenga's avatar
Kurt Zeilenga committed
22

23
24
#ifndef NO_THREADS
#define LDAP_R_COMPILE 1
25
26
#endif

27
#include "../liblber/lber-int.h"
28
#include "lutil.h"
29

30
31
32
33
#ifdef LDAP_R_COMPILE
#include <ldap_pvt_thread.h>
#endif

34
35
#ifdef HAVE_CYRUS_SASL
	/* the need for this should be removed */
Howard Chu's avatar
Howard Chu committed
36
#ifdef HAVE_SASL_SASL_H
37
38
#include <sasl/sasl.h>
#else
39
#include <sasl.h>
40
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed
41

42
#define SASL_MAX_BUFF_SIZE	(0xffffff)
Kurt Zeilenga's avatar
Kurt Zeilenga committed
43
#define SASL_MIN_BUFF_SIZE	4096
44
45
#endif

Kurt Zeilenga's avatar
Kurt Zeilenga committed
46
47
/* for struct timeval */
#include <ac/time.h>
48
49
50
#ifdef _WIN32
#include <ac/socket.h>
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed
51

52
#undef TV2MILLISEC
53
#define TV2MILLISEC(tv) (((tv)->tv_sec * 1000) + ((tv)->tv_usec/1000))
54

55
56
57
58
59
60
61
62
63
64
65
66
67
68
/* 
 * Support needed if the library is running in the kernel
 */
#if LDAP_INT_IN_KERNEL
	/* 
	 * Platform specific function to return a pointer to the
	 * process-specific global options. 
	 *
	 * This function should perform the following functions:
	 *  Allocate and initialize a global options struct on a per process basis
	 *  Use callers process identifier to return its global options struct
	 *  Note: Deallocate structure when the process exits
	 */
#	define LDAP_INT_GLOBAL_OPT() ldap_int_global_opt()
Kurt Zeilenga's avatar
Kurt Zeilenga committed
69
	struct ldapoptions *ldap_int_global_opt(void);
70
71
72
73
#else
#	define LDAP_INT_GLOBAL_OPT() (&ldap_int_global_options)
#endif

74
75
/* if used from server code, ldap_debug already points elsewhere */
#ifndef ldap_debug
76
#define ldap_debug	((LDAP_INT_GLOBAL_OPT())->ldo_debug)
77
#endif /* !ldap_debug */
78

Ondřej Kuzník's avatar
Ondřej Kuzník committed
79
#define LDAP_INT_DEBUG
80
81
#include "ldap_log.h"

82
83
#ifdef LDAP_DEBUG

84
85
86
#define DebugTest( level ) \
	( ldap_debug & level )

Ondřej Kuzník's avatar
Ondřej Kuzník committed
87
88
89
90
91
92
93
94
#define Debug0( level, fmt ) \
	do { if ( DebugTest( (level) ) ) \
	ldap_log_printf( NULL, (level), fmt ); \
	} while ( 0 )

#define Debug1( level, fmt, arg1 ) \
	do { if ( DebugTest( (level) ) ) \
	ldap_log_printf( NULL, (level), fmt, arg1 ); \
Howard Chu's avatar
Howard Chu committed
95
	} while ( 0 )
96

Ondřej Kuzník's avatar
Ondřej Kuzník committed
97
98
99
100
101
102
103
104
105
#define Debug2( level, fmt, arg1, arg2 ) \
	do { if ( DebugTest( (level) ) ) \
	ldap_log_printf( NULL, (level), fmt, arg1, arg2 ); \
	} while ( 0 )

#define Debug3( level, fmt, arg1, arg2, arg3 ) \
	do { if ( DebugTest( (level) ) ) \
	ldap_log_printf( NULL, (level), fmt, arg1, arg2, arg3 ); \
	} while ( 0 )
Gary Williams's avatar
Gary Williams committed
106

107
108
#else

109
#define DebugTest( level )                                    (0 == 1)
Ondřej Kuzník's avatar
Ondřej Kuzník committed
110
111
112
113
#define Debug0( level, fmt )                                  ((void)0)
#define Debug1( level, fmt, arg1 )                            ((void)0)
#define Debug2( level, fmt, arg1, arg2 )                      ((void)0)
#define Debug3( level, fmt, arg1, arg2, arg3 )                ((void)0)
114
115
116

#endif /* LDAP_DEBUG */

Kurt Zeilenga's avatar
Kurt Zeilenga committed
117
#define LDAP_DEPRECATED 1
118
119
#include "ldap.h"

Bart Hartgers's avatar
   
Bart Hartgers committed
120
121
#include "ldap_pvt.h"

122
123
LDAP_BEGIN_DECL

Kurt Zeilenga's avatar
Kurt Zeilenga committed
124
#define LDAP_URL_PREFIX         "ldap://"
Pierangelo Masarati's avatar
Pierangelo Masarati committed
125
126
127
#define LDAP_URL_PREFIX_LEN     STRLENOF(LDAP_URL_PREFIX)
#define LDAPS_URL_PREFIX	"ldaps://"
#define LDAPS_URL_PREFIX_LEN	STRLENOF(LDAPS_URL_PREFIX)
128
#define LDAPI_URL_PREFIX	"ldapi://"
Pierangelo Masarati's avatar
Pierangelo Masarati committed
129
#define LDAPI_URL_PREFIX_LEN	STRLENOF(LDAPI_URL_PREFIX)
130
131
#ifdef LDAP_CONNECTIONLESS
#define LDAPC_URL_PREFIX	"cldap://"
Pierangelo Masarati's avatar
Pierangelo Masarati committed
132
#define LDAPC_URL_PREFIX_LEN	STRLENOF(LDAPC_URL_PREFIX)
133
#endif
Pierangelo Masarati's avatar
Pierangelo Masarati committed
134
135
#define LDAP_URL_URLCOLON	"URL:"
#define LDAP_URL_URLCOLON_LEN	STRLENOF(LDAP_URL_URLCOLON)
Kurt Zeilenga's avatar
Kurt Zeilenga committed
136

Kurt Zeilenga's avatar
Kurt Zeilenga committed
137
#define LDAP_REF_STR		"Referral:\n"
Pierangelo Masarati's avatar
Pierangelo Masarati committed
138
#define LDAP_REF_STR_LEN	STRLENOF(LDAP_REF_STR)
Kurt Zeilenga's avatar
Kurt Zeilenga committed
139
#define LDAP_LDAP_REF_STR	LDAP_URL_PREFIX
Kurt Zeilenga's avatar
Kurt Zeilenga committed
140
#define LDAP_LDAP_REF_STR_LEN	LDAP_URL_PREFIX_LEN
Kurt Zeilenga's avatar
Kurt Zeilenga committed
141

142
143
#define LDAP_DEFAULT_REFHOPLIMIT 5

144
145
#define LDAP_BOOL_REFERRALS		0
#define LDAP_BOOL_RESTART		1
Julio Sánchez Fernández's avatar
Julio Sánchez Fernández committed
146
#define LDAP_BOOL_TLS			3
147
#define	LDAP_BOOL_CONNECT_ASYNC		4
148
#define	LDAP_BOOL_SASL_NOCANON		5
149
#define	LDAP_BOOL_KEEPCONN		6
150

151
#define LDAP_BOOLEANS	unsigned long
152
#define LDAP_BOOL(n)	((LDAP_BOOLEANS)1 << (n))
Kurt Zeilenga's avatar
Kurt Zeilenga committed
153
154
#define LDAP_BOOL_GET(lo, bool)	\
	((lo)->ldo_booleans & LDAP_BOOL(bool) ? -1 : 0)
155
156
157
#define LDAP_BOOL_SET(lo, bool) ((lo)->ldo_booleans |= LDAP_BOOL(bool))
#define LDAP_BOOL_CLR(lo, bool) ((lo)->ldo_booleans &= ~LDAP_BOOL(bool))
#define LDAP_BOOL_ZERO(lo) ((lo)->ldo_booleans = 0)
158

159
160
161
162
163
164
/*
 * This structure represents both ldap messages and ldap responses.
 * These are really the same, except in the case of search responses,
 * where a response has multiple messages.
 */

165
struct ldapmsg {
166
167
	ber_int_t		lm_msgid;	/* the message id */
	ber_tag_t		lm_msgtype;	/* the message type */
168
169
	BerElement	*lm_ber;	/* the ber encoded message contents */
	struct ldapmsg	*lm_chain;	/* for search - next msg in the resp */
170
	struct ldapmsg	*lm_chain_tail;
171
	struct ldapmsg	*lm_next;	/* next response */
172
	time_t	lm_time;	/* used to maintain cache */
173
};
174

Howard Chu's avatar
Howard Chu committed
175
176
177
178
179
180
181
182
#ifdef HAVE_TLS
struct ldaptls {
	char		*lt_certfile;
	char		*lt_keyfile;
	char		*lt_dhfile;
	char		*lt_cacertfile;
	char		*lt_cacertdir;
	char		*lt_ciphersuite;
183
	char		*lt_crlfile;
184
	char		*lt_randfile;	/* OpenSSL only */
185
	char		*lt_ecname;		/* OpenSSL only */
186
	int		lt_protocol_min;
187
188
189
	struct berval	lt_cacert;
	struct berval	lt_cert;
	struct berval	lt_key;
Howard Chu's avatar
Howard Chu committed
190
191
192
};
#endif

193
194
195
196
197
typedef struct ldaplist {
	struct ldaplist *ll_next;
	void *ll_data;
} ldaplist;

198
199
200
/*
 * structure representing get/set'able options
 * which have global defaults.
201
 * Protect access to this struct with ldo_mutex
202
 * ldap_log.h:ldapoptions_prefix must match the head of this struct.
203
204
 */
struct ldapoptions {
205
206
207
208
	short ldo_valid;
#define LDAP_UNINITIALIZED	0x0
#define LDAP_INITIALIZED	0x1
#define LDAP_VALID_SESSION	0x2
Pierangelo Masarati's avatar
cleanup    
Pierangelo Masarati committed
209
#define LDAP_TRASHED_SESSION	0xFF
210
	int   ldo_debug;
211

212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
	ber_int_t		ldo_version;
	ber_int_t		ldo_deref;
	ber_int_t		ldo_timelimit;
	ber_int_t		ldo_sizelimit;

	/* per API call timeout */
	struct timeval		ldo_tm_api;
	struct timeval		ldo_tm_net;

	LDAPURLDesc *ldo_defludp;
	int		ldo_defport;
	char*	ldo_defbase;
	char*	ldo_defbinddn;	/* bind dn */

	/*
	 * Per connection tcp-keepalive settings (Linux only,
	 * ignored where unsupported)
	 */
	ber_int_t ldo_keepalive_idle;
	ber_int_t ldo_keepalive_probes;
	ber_int_t ldo_keepalive_interval;

	int		ldo_refhoplimit;	/* limit on referral nesting */

	/* LDAPv3 server and client controls */
	LDAPControl	**ldo_sctrls;
	LDAPControl **ldo_cctrls;

	/* LDAP rebind callback function */
	LDAP_REBIND_PROC *ldo_rebind_proc;
	void *ldo_rebind_params;
	LDAP_NEXTREF_PROC *ldo_nextref_proc;
	void *ldo_nextref_params;
	LDAP_URLLIST_PROC *ldo_urllist_proc;
	void *ldo_urllist_params;

	/* LDAP connection callback stack */
	ldaplist *ldo_conn_cbs;

	LDAP_BOOLEANS ldo_booleans;	/* boolean options */

#define LDAP_LDO_NULLARG	,0,0,0,0 ,{0},{0} ,0,0,0,0, 0,0,0,0, 0,0, 0,0,0,0,0,0, 0, 0

255
#ifdef LDAP_CONNECTIONLESS
Howard Chu's avatar
Howard Chu committed
256
#define	LDAP_IS_UDP(ld)		((ld)->ld_options.ldo_is_udp)
257
258
	void*			ldo_peer;	/* struct sockaddr* */
	char*			ldo_cldapdn;
Howard Chu's avatar
Howard Chu committed
259
	int			ldo_is_udp;
260
261
262
#define	LDAP_LDO_CONNECTIONLESS_NULLARG	,0,0,0
#else
#define	LDAP_LDO_CONNECTIONLESS_NULLARG
263
#endif
264

265
#ifdef HAVE_TLS
266
267
   	/* tls context */
   	void		*ldo_tls_ctx;
268
269
	LDAP_TLS_CONNECT_CB	*ldo_tls_connect_cb;
	void*			ldo_tls_connect_arg;
Howard Chu's avatar
Howard Chu committed
270
271
272
273
	struct ldaptls ldo_tls_info;
#define ldo_tls_certfile	ldo_tls_info.lt_certfile
#define ldo_tls_keyfile	ldo_tls_info.lt_keyfile
#define ldo_tls_dhfile	ldo_tls_info.lt_dhfile
274
#define ldo_tls_ecname	ldo_tls_info.lt_ecname
Howard Chu's avatar
Howard Chu committed
275
276
277
#define ldo_tls_cacertfile	ldo_tls_info.lt_cacertfile
#define ldo_tls_cacertdir	ldo_tls_info.lt_cacertdir
#define ldo_tls_ciphersuite	ldo_tls_info.lt_ciphersuite
278
#define ldo_tls_protocol_min	ldo_tls_info.lt_protocol_min
279
#define ldo_tls_crlfile	ldo_tls_info.lt_crlfile
280
#define ldo_tls_randfile	ldo_tls_info.lt_randfile
281
282
283
#define ldo_tls_cacert	ldo_tls_info.lt_cacert
#define ldo_tls_cert	ldo_tls_info.lt_cert
#define ldo_tls_key	ldo_tls_info.lt_key
Howard Chu's avatar
Howard Chu committed
284
285
   	int			ldo_tls_mode;
   	int			ldo_tls_require_cert;
286
	int			ldo_tls_impl;
Howard Chu's avatar
Howard Chu committed
287
   	int			ldo_tls_crlcheck;
Howard Chu's avatar
Howard Chu committed
288
	int			ldo_tls_require_san;
289
290
291
	char		*ldo_tls_pin_hashalg;
	struct berval	ldo_tls_pin;
#define LDAP_LDO_TLS_NULLARG ,0,0,0,{0,0,0,0,0,0,0,0,0},0,0,0,0,0,{0,0}
292
293
#else
#define LDAP_LDO_TLS_NULLARG
Howard Chu's avatar
Howard Chu committed
294
#endif
295
296
297
298
299
300
301
302
303

#ifdef HAVE_CYRUS_SASL
	char*	ldo_def_sasl_mech;		/* SASL Mechanism(s) */
	char*	ldo_def_sasl_realm;		/* SASL realm */
	char*	ldo_def_sasl_authcid;	/* SASL authentication identity */
	char*	ldo_def_sasl_authzid;	/* SASL authorization identity */

	/* SASL Security Properties */
	struct sasl_security_properties	ldo_sasl_secprops;
304
	int ldo_sasl_cbinding;
305
#define LDAP_LDO_SASL_NULLARG ,0,0,0,0,{0},0
306
307
#else
#define LDAP_LDO_SASL_NULLARG
308
#endif
309

Howard Chu's avatar
Howard Chu committed
310
311
312
313
314
315
#ifdef LDAP_R_COMPILE
	ldap_pvt_thread_mutex_t	ldo_mutex;
#define LDAP_LDO_MUTEX_NULLARG	, LDAP_PVT_MUTEX_NULL
#else
#define LDAP_LDO_MUTEX_NULLARG
#endif
316
317
};

318

319
320
321
322
/*
 * structure for representing an LDAP server connection
 */
typedef struct ldap_conn {
323
	Sockbuf		*lconn_sb;
324
#ifdef HAVE_CYRUS_SASL
325
326
	void		*lconn_sasl_authctx;	/* context for bind */
	void		*lconn_sasl_sockctx;	/* for security layer */
Howard Chu's avatar
Howard Chu committed
327
	void		*lconn_sasl_cbind;		/* for channel binding */
328
#endif
329
	int			lconn_refcnt;
330
	time_t		lconn_created;	/* time */
331
	time_t		lconn_lastused;	/* time */
332
333
	int			lconn_rebind_inprogress;	/* set if rebind in progress */
	char		***lconn_rebind_queue;		/* used if rebind in progress */
334
335
336
337
	int			lconn_status;
#define LDAP_CONNST_NEEDSOCKET		1
#define LDAP_CONNST_CONNECTING		2
#define LDAP_CONNST_CONNECTED		3
338
	LDAPURLDesc		*lconn_server;
339
340
	BerElement		*lconn_ber;	/* ber receiving on this conn. */

341
	struct ldap_conn *lconn_next;
342
343
344
345
346
347
348
} LDAPConn;


/*
 * structure used to track outstanding requests
 */
typedef struct ldapreq {
349
	ber_int_t	lr_msgid;	/* the message id */
350
	int		lr_status;	/* status of request */
351
#define LDAP_REQST_COMPLETED	0
352
353
354
355
#define LDAP_REQST_INPROGRESS	1
#define LDAP_REQST_CHASINGREFS	2
#define LDAP_REQST_NOTCONNECTED	3
#define LDAP_REQST_WRITING	4
356
	int		lr_refcnt;	/* count of references */
357
	int		lr_outrefcnt;	/* count of outstanding referrals */
358
	int		lr_abandoned;	/* the request has been abandoned */
359
	ber_int_t	lr_origid;	/* original request's message id */
360
	int		lr_parentcnt;	/* count of parent requests */
361
362
	ber_tag_t	lr_res_msgtype;	/* result message type */
	ber_int_t	lr_res_errno;	/* result LDAP errno */
363
364
365
366
	char		*lr_res_error;	/* result error string */
	char		*lr_res_matched;/* result matched DN string */
	BerElement	*lr_ber;	/* ber encoded request contents */
	LDAPConn	*lr_conn;	/* connection used to send request */
367
	struct berval	lr_dn;		/* DN of request, in lr_ber */
368
	struct ldapreq	*lr_parent;	/* request that spawned this referral */
369
	struct ldapreq	*lr_child;	/* first child request */
370
371
372
373
374
375
376
377
378
379
380
381
382
	struct ldapreq	*lr_refnext;	/* next referral spawned */
	struct ldapreq	*lr_prev;	/* previous request */
	struct ldapreq	*lr_next;	/* next request */
} LDAPRequest;

/*
 * structure for client cache
 */
#define LDAP_CACHE_BUCKETS	31	/* cache hash table size */
typedef struct ldapcache {
	LDAPMessage	*lc_buckets[LDAP_CACHE_BUCKETS];/* hash table */
	LDAPMessage	*lc_requests;			/* unfulfilled reqs */
	long		lc_timeout;			/* request timeout */
383
384
	ber_len_t		lc_maxmem;			/* memory to use */
	ber_len_t		lc_memused;			/* memory in use */
385
386
387
388
389
390
	int		lc_enabled;			/* enabled? */
	unsigned long	lc_options;			/* options */
#define LDAP_CACHE_OPT_CACHENOERRS	0x00000001
#define LDAP_CACHE_OPT_CACHEALLERRS	0x00000002
}  LDAPCache;

391
392
393
394
395
396
397
398
399
/*
 * structure containing referral request info for rebind procedure
 */
typedef struct ldapreqinfo {
	ber_len_t	ri_msgid;
	int			ri_request;
	char 		*ri_url;
} LDAPreqinfo;

400
401
402
403
/*
 * structure representing an ldap connection
 */

404
405
406
struct ldap_common {
	Sockbuf		*ldc_sb;	/* socket descriptor & buffer */
#define ld_sb			ldc->ldc_sb
407

408
409
	unsigned short	ldc_lberoptions;
#define	ld_lberoptions		ldc->ldc_lberoptions
410

411
412
413
	/* protected by msgid_mutex */
	ber_len_t		ldc_msgid;
#define	ld_msgid		ldc->ldc_msgid
414
415

	/* do not mess with these */
416
417
418
419
420
421
	/* protected by req_mutex */
	LDAPRequest	*ldc_requests;	/* list of outstanding requests */
	/* protected by res_mutex */
	LDAPMessage	*ldc_responses;	/* list of outstanding responses */
#define	ld_requests		ldc->ldc_requests
#define	ld_responses		ldc->ldc_responses
Kurt Zeilenga's avatar
ldap.h:    
Kurt Zeilenga committed
422

423
424
425
426
427
	/* protected by abandon_mutex */
	ber_len_t	ldc_nabandoned;
	ber_int_t	*ldc_abandoned;	/* array of abandoned requests */
#define	ld_nabandoned		ldc->ldc_nabandoned
#define	ld_abandoned		ldc->ldc_abandoned
Kurt Zeilenga's avatar
ldap.h:    
Kurt Zeilenga committed
428

429
430
431
	/* unused by libldap */
	LDAPCache	*ldc_cache;	/* non-null if cache is initialized */
#define	ld_cache		ldc->ldc_cache
Kurt Zeilenga's avatar
ldap.h:    
Kurt Zeilenga committed
432

433
	/* do not mess with the rest though */
434

435
436
437
438
439
440
441
442
443
444
445
446
	/* protected by conn_mutex */
	LDAPConn	*ldc_defconn;	/* default connection */
#define	ld_defconn		ldc->ldc_defconn
	LDAPConn	*ldc_conns;	/* list of server connections */
#define	ld_conns		ldc->ldc_conns
	void		*ldc_selectinfo;/* platform specifics for select */
#define	ld_selectinfo		ldc->ldc_selectinfo

	/* ldap_common refcnt - free only if 0 */
	/* protected by ldc_mutex */
	unsigned int		ldc_refcnt;
#define	ld_ldcrefcnt		ldc->ldc_refcnt
Howard Chu's avatar
Howard Chu committed
447

448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
	/* protected by ldo_mutex */
	struct ldapoptions ldc_options;
#define ld_options		ldc->ldc_options

#define ld_valid		ld_options.ldo_valid
#define ld_debug		ld_options.ldo_debug

#define ld_deref		ld_options.ldo_deref
#define ld_timelimit		ld_options.ldo_timelimit
#define ld_sizelimit		ld_options.ldo_sizelimit

#define ld_defbinddn		ld_options.ldo_defbinddn
#define ld_defbase		ld_options.ldo_defbase
#define ld_defhost		ld_options.ldo_defhost
#define ld_defport		ld_options.ldo_defport

#define ld_refhoplimit		ld_options.ldo_refhoplimit

#define ld_sctrls		ld_options.ldo_sctrls
#define ld_cctrls		ld_options.ldo_cctrls
#define ld_rebind_proc		ld_options.ldo_rebind_proc
#define ld_rebind_params	ld_options.ldo_rebind_params
#define ld_nextref_proc		ld_options.ldo_nextref_proc
#define ld_nextref_params	ld_options.ldo_nextref_params
#define ld_urllist_proc		ld_options.ldo_urllist_proc
#define ld_urllist_params	ld_options.ldo_urllist_params

#define ld_version		ld_options.ldo_version

Howard Chu's avatar
Howard Chu committed
477
#ifdef LDAP_R_COMPILE
478
	ldap_pvt_thread_mutex_t	ldc_mutex;
Howard Chu's avatar
Howard Chu committed
479
480
481
482
483
	ldap_pvt_thread_mutex_t	ldc_msgid_mutex;
	ldap_pvt_thread_mutex_t	ldc_conn_mutex;
	ldap_pvt_thread_mutex_t	ldc_req_mutex;
	ldap_pvt_thread_mutex_t	ldc_res_mutex;
	ldap_pvt_thread_mutex_t	ldc_abandon_mutex;
484
485
#define	ld_ldopts_mutex		ld_options.ldo_mutex
#define	ld_ldcmutex		ldc->ldc_mutex
Howard Chu's avatar
Howard Chu committed
486
487
488
489
490
491
#define	ld_msgid_mutex		ldc->ldc_msgid_mutex
#define	ld_conn_mutex		ldc->ldc_conn_mutex
#define	ld_req_mutex		ldc->ldc_req_mutex
#define	ld_res_mutex		ldc->ldc_res_mutex
#define	ld_abandon_mutex	ldc->ldc_abandon_mutex
#endif
492
493
494
495
496
497
498
499
500
501
502
};

struct ldap {
	/* thread shared */
	struct ldap_common	*ldc;

	/* thread specific */
	ber_int_t		ld_errno;
	char			*ld_error;
	char			*ld_matched;
	char			**ld_referrals;
503
};
504

Pierangelo Masarati's avatar
cleanup    
Pierangelo Masarati committed
505
506
507
#define LDAP_VALID(ld)		( (ld)->ld_valid == LDAP_VALID_SESSION )
#define LDAP_TRASHED(ld)	( (ld)->ld_valid == LDAP_TRASHED_SESSION )
#define LDAP_TRASH(ld)		( (ld)->ld_valid = LDAP_TRASHED_SESSION )
508

Kurt Zeilenga's avatar
Kurt Zeilenga committed
509
#ifdef LDAP_R_COMPILE
510
LDAP_V ( ldap_pvt_thread_mutex_t ) ldap_int_resolv_mutex;
511
LDAP_V ( ldap_pvt_thread_mutex_t ) ldap_int_hostname_mutex;
Howard Chu's avatar
Howard Chu committed
512
LDAP_V ( int ) ldap_int_stackguard;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
513
514

#endif
Luke Howard's avatar
   
Luke Howard committed
515

Howard Chu's avatar
Howard Chu committed
516
517
518
519
520
521
#ifdef LDAP_R_COMPILE
#define LDAP_MUTEX_LOCK(mutex)    ldap_pvt_thread_mutex_lock( mutex )
#define LDAP_MUTEX_UNLOCK(mutex)  ldap_pvt_thread_mutex_unlock( mutex )
#define LDAP_ASSERT_MUTEX_OWNER(mutex) \
	LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER(mutex)
#else
522
523
524
#define LDAP_MUTEX_LOCK(mutex)    ((void) 0)
#define LDAP_MUTEX_UNLOCK(mutex)  ((void) 0)
#define LDAP_ASSERT_MUTEX_OWNER(mutex) ((void) 0)
Howard Chu's avatar
Howard Chu committed
525
526
#endif

527
#define	LDAP_NEXT_MSGID(ld, id) do { \
528
	LDAP_MUTEX_LOCK( &(ld)->ld_msgid_mutex ); \
529
530
531
	(id) = ++(ld)->ld_msgid; \
	LDAP_MUTEX_UNLOCK( &(ld)->ld_msgid_mutex ); \
} while (0)
532

533
534
535
536
537
538
539
540
541
542
543
/*
 * in abandon.c
 */

LDAP_F (int)
ldap_int_bisect_find( ber_int_t *v, ber_len_t n, ber_int_t id, int *idxp );
LDAP_F (int)
ldap_int_bisect_insert( ber_int_t **vp, ber_len_t *np, int id, int idx );
LDAP_F (int)
ldap_int_bisect_delete( ber_int_t **vp, ber_len_t *np, int id, int idx );

544
545
546
547
548
549
550
551
552
553
554
555
/*
 * in add.c
 */

LDAP_F (BerElement *) ldap_build_add_req LDAP_P((
	LDAP *ld,
	const char *dn,
	LDAPMod **attrs,
	LDAPControl **sctrls,
	LDAPControl **cctrls,
	ber_int_t *msgidp ));

556
557
558
559
560
561
562
/*
 * in lbase64.c
 */

LDAP_F (int) ldap_int_decode_b64_inplace LDAP_P((
	struct berval *value ));

563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
/*
 * in compare.c
 */

LDAP_F (BerElement *) ldap_build_compare_req LDAP_P((
	LDAP *ld,
	const char *dn,
	const char *attr,
	struct berval *bvalue,
	LDAPControl **sctrls,
	LDAPControl **cctrls,
	ber_int_t *msgidp ));

/*
 * in delete.c
 */

LDAP_F (BerElement *) ldap_build_delete_req LDAP_P((
	LDAP *ld,
	const char *dn,
	LDAPControl **sctrls,
	LDAPControl **cctrls,
	ber_int_t *msgidp ));

Howard Chu's avatar
Howard Chu committed
587
588
589
590
591
592
593
594
595
596
597
598
/*
 * in extended.c
 */

LDAP_F (BerElement *) ldap_build_extended_req LDAP_P((
	LDAP *ld,
	const char *reqoid,
	struct berval *reqdata,
	LDAPControl **sctrls,
	LDAPControl **cctrls,
	ber_int_t *msgidp ));

599
600
601
/*
 * in init.c
 */
602

603
604
LDAP_V ( struct ldapoptions ) ldap_int_global_options;

605
606
LDAP_F ( void ) ldap_int_initialize LDAP_P((struct ldapoptions *, int *));
LDAP_F ( void ) ldap_int_initialize_global_options LDAP_P((
607
	struct ldapoptions *, int *));
608

609
610
/* memory.c */
	/* simple macros to realloc for now */
Howard Chu's avatar
Howard Chu committed
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
#define LDAP_MALLOC(s)		(ber_memalloc_x((s),NULL))
#define LDAP_CALLOC(n,s)	(ber_memcalloc_x((n),(s),NULL))
#define LDAP_REALLOC(p,s)	(ber_memrealloc_x((p),(s),NULL))
#define LDAP_FREE(p)		(ber_memfree_x((p),NULL))
#define LDAP_VFREE(v)		(ber_memvfree_x((void **)(v),NULL))
#define LDAP_STRDUP(s)		(ber_strdup_x((s),NULL))
#define LDAP_STRNDUP(s,l)	(ber_strndup_x((s),(l),NULL))

#define LDAP_MALLOCX(s,x)	(ber_memalloc_x((s),(x)))
#define LDAP_CALLOCX(n,s,x)	(ber_memcalloc_x((n),(s),(x)))
#define LDAP_REALLOCX(p,s,x)	(ber_memrealloc_x((p),(s),(x)))
#define LDAP_FREEX(p,x)		(ber_memfree_x((p),(x)))
#define LDAP_VFREEX(v,x)	(ber_memvfree_x((void **)(v),(x)))
#define LDAP_STRDUPX(s,x)	(ber_strdup_x((s),(x)))
#define LDAP_STRNDUPX(s,l,x)	(ber_strndup_x((s),(l),(x)))
626

627
628
629
/*
 * in error.c
 */
Howard Chu's avatar
Howard Chu committed
630
LDAP_F (void) ldap_int_error_init( void );
631

632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
/*
 * in modify.c
 */

LDAP_F (BerElement *) ldap_build_modify_req LDAP_P((
	LDAP *ld,
	const char *dn,
	LDAPMod **mods,
	LDAPControl **sctrls,
	LDAPControl **cctrls,
	ber_int_t *msgidp ));

/*
 * in modrdn.c
 */

LDAP_F (BerElement *) ldap_build_moddn_req LDAP_P((
	LDAP *ld,
	const char *dn,
	const char *newrdn,
	const char *newSuperior,
	int deleteoldrdn,
	LDAPControl **sctrls,
	LDAPControl **cctrls,
	ber_int_t *msgidp ));

658
659
660
/*
 * in unit-int.c
 */
661
LDAP_F (void) ldap_int_utils_init LDAP_P(( void ));
662
663


664
665
666
/*
 * in print.c
 */
667
LDAP_F (int) ldap_log_printf LDAP_P((LDAP *ld, int level, const char *fmt, ...)) LDAP_GCCATTR((format(printf, 3, 4)));
668

669
670
671
/*
 * in controls.c
 */
672
LDAP_F (int) ldap_int_put_controls LDAP_P((
Kurt Zeilenga's avatar
Kurt Zeilenga committed
673
	LDAP *ld,
674
	LDAPControl *const *ctrls,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
675
	BerElement *ber ));
676

677
678
679
LDAP_F (int) ldap_int_client_controls LDAP_P((
	LDAP *ld,
	LDAPControl **ctrlp ));
680

Kurt Zeilenga's avatar
Kurt Zeilenga committed
681
/*
Kurt Zeilenga's avatar
Kurt Zeilenga committed
682
 * in dsparse.c
Kurt Zeilenga's avatar
Kurt Zeilenga committed
683
 */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
684
685
LDAP_F (int) ldap_int_next_line_tokens LDAP_P(( char **bufp, ber_len_t *blenp, char ***toksp ));

Kurt Zeilenga's avatar
Kurt Zeilenga committed
686
687
688
689

/*
 * in open.c
 */
690
LDAP_F (int) ldap_open_defconn( LDAP *ld );
691
692
LDAP_F (int) ldap_int_open_connection( LDAP *ld,
	LDAPConn *conn, LDAPURLDesc *srvlist, int async );
693
LDAP_F (int) ldap_int_check_async_open( LDAP *ld, ber_socket_t sd );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
694
695
696
697

/*
 * in os-ip.c
 */
698
#ifndef HAVE_POLL
Howard Chu's avatar
Howard Chu committed
699
LDAP_V (int) ldap_int_tblsize;
700
701
702
LDAP_F (void) ldap_int_ip_init( void );
#endif

703
704
LDAP_F (int) ldap_int_timeval_dup( struct timeval **dest,
	const struct timeval *tm );
705
LDAP_F (int) ldap_connect_to_host( LDAP *ld, Sockbuf *sb,
706
	int proto, LDAPURLDesc *srv, int async );
707
LDAP_F (int) ldap_int_poll( LDAP *ld, ber_socket_t s,
708
	struct timeval *tvp, int wr );
Hallvard Furuseth's avatar
Hallvard Furuseth committed
709

710
#if defined(HAVE_TLS) || defined(HAVE_CYRUS_SASL)
711
LDAP_V (char *) ldap_int_hostname;
712
713
LDAP_F (char *) ldap_host_connected_to( Sockbuf *sb,
	const char *host );
714
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed
715

Kurt Zeilenga's avatar
Kurt Zeilenga committed
716
LDAP_F (int) ldap_int_select( LDAP *ld, struct timeval *timeout );
717
718
719
720
721
LDAP_F (void *) ldap_new_select_info( void );
LDAP_F (void) ldap_free_select_info( void *sip );
LDAP_F (void) ldap_mark_select_write( LDAP *ld, Sockbuf *sb );
LDAP_F (void) ldap_mark_select_read( LDAP *ld, Sockbuf *sb );
LDAP_F (void) ldap_mark_select_clear( LDAP *ld, Sockbuf *sb );
722
LDAP_F (void) ldap_clear_select_write( LDAP *ld, Sockbuf *sb );
723
724
LDAP_F (int) ldap_is_read_ready( LDAP *ld, Sockbuf *sb );
LDAP_F (int) ldap_is_write_ready( LDAP *ld, Sockbuf *sb );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
725

726
LDAP_F (int) ldap_int_connect_cbs( LDAP *ld, Sockbuf *sb,
727
	ber_socket_t *s, LDAPURLDesc *srv, struct sockaddr *addr );
728

729
730
731
/*
 * in os-local.c
 */
732
733
#ifdef LDAP_PF_LOCAL
LDAP_F (int) ldap_connect_to_path( LDAP *ld, Sockbuf *sb,
734
	LDAPURLDesc *srv, int async );
735
#endif /* LDAP_PF_LOCAL */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
736
737
738
739

/*
 * in request.c
 */
740
LDAP_F (ber_int_t) ldap_send_initial_request( LDAP *ld, ber_tag_t msgtype,
741
	const char *dn, BerElement *ber, ber_int_t msgid );
742
743
744
LDAP_F (BerElement *) ldap_alloc_ber_with_options( LDAP *ld );
LDAP_F (void) ldap_set_ber_options( LDAP *ld, BerElement *ber );

745
746
747
748
749
LDAP_F (int) ldap_send_server_request( LDAP *ld, BerElement *ber,
	ber_int_t msgid, LDAPRequest *parentreq, LDAPURLDesc **srvlist,
	LDAPConn *lc, LDAPreqinfo *bind, int noconn, int m_res );
LDAP_F (LDAPConn *) ldap_new_connection( LDAP *ld, LDAPURLDesc **srvlist,
	int use_ldsb, int connect, LDAPreqinfo *bind, int m_req, int m_res );
750
LDAP_F (LDAPRequest *) ldap_find_request_by_msgid( LDAP *ld, ber_int_t msgid );
Pierangelo Masarati's avatar
Pierangelo Masarati committed
751
LDAP_F (void) ldap_return_request( LDAP *ld, LDAPRequest *lr, int freeit );
752
753
754
755
LDAP_F (void) ldap_free_request( LDAP *ld, LDAPRequest *lr );
LDAP_F (void) ldap_free_connection( LDAP *ld, LDAPConn *lc, int force, int unbind );
LDAP_F (void) ldap_dump_connection( LDAP *ld, LDAPConn *lconns, int all );
LDAP_F (void) ldap_dump_requests_and_responses( LDAP *ld );
756
757
758
759
LDAP_F (int) ldap_chase_referrals( LDAP *ld, LDAPRequest *lr,
	char **errstrp, int sref, int *hadrefp );
LDAP_F (int) ldap_chase_v3referrals( LDAP *ld, LDAPRequest *lr,
	char **refs, int sref, char **referralsp, int *hadrefp );
760
LDAP_F (int) ldap_append_referral( LDAP *ld, char **referralsp, char *s );
761
LDAP_F (int) ldap_int_flush_request( LDAP *ld, LDAPRequest *lr );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
762

763
764
765
/*
 * in result.c:
 */
766
LDAP_F (const char *) ldap_int_msgtype2str( ber_tag_t tag );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
767
768
769
770

/*
 * in search.c
 */
771
LDAP_F (BerElement *) ldap_build_search_req LDAP_P((
772
	LDAP *ld,
773
774
775
776
777
	const char *base,
	ber_int_t scope,
	const char *filter,
	char **attrs,
	ber_int_t attrsonly,
778
779
	LDAPControl **sctrls,
	LDAPControl **cctrls,
780
	ber_int_t timelimit,
781
	ber_int_t sizelimit,
782
	ber_int_t deref,
783
	ber_int_t *msgidp));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
784
785
786
787
788


/*
 * in unbind.c
 */
789
LDAP_F (int) ldap_ld_free LDAP_P((
Kurt Zeilenga's avatar
Kurt Zeilenga committed
790
791
792
793
794
	LDAP *ld,
	int close,
	LDAPControl **sctrls,
	LDAPControl **cctrls ));

795
LDAP_F (int) ldap_send_unbind LDAP_P((
Kurt Zeilenga's avatar
Kurt Zeilenga committed
796
797
798
799
	LDAP *ld,
	Sockbuf *sb,
	LDAPControl **sctrls,
	LDAPControl **cctrls ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
800

801
802
803
/*
 * in url.c
 */
804
LDAP_F (LDAPURLDesc *) ldap_url_dup LDAP_P((
805
806
	LDAPURLDesc *ludp ));

807
LDAP_F (LDAPURLDesc *) ldap_url_duplist LDAP_P((
808
809
	LDAPURLDesc *ludlist ));

810
LDAP_F (int) ldap_url_parsehosts LDAP_P((
811
	LDAPURLDesc **ludlist,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
812
813
	const char *hosts,
	int port ));
814

815
LDAP_F (char *) ldap_url_list2hosts LDAP_P((
816
817
	LDAPURLDesc *ludlist ));

818
819
820
/*
 * in cyrus.c
 */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
821

822
823
824
825
LDAP_F (int) ldap_int_sasl_init LDAP_P(( void ));

LDAP_F (int) ldap_int_sasl_open LDAP_P((
	LDAP *ld, LDAPConn *conn,
826
	const char* host ));
827
828
LDAP_F (int) ldap_int_sasl_close LDAP_P(( LDAP *ld, LDAPConn *conn ));

Kurt Zeilenga's avatar
Kurt Zeilenga committed
829
LDAP_F (int) ldap_int_sasl_external LDAP_P((
830
831
	LDAP *ld, LDAPConn *conn,
	const char* authid, ber_len_t ssf ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
832

833
834
835
836
837
838
839
840
LDAP_F (int) ldap_int_sasl_get_option LDAP_P(( LDAP *ld,
	int option, void *arg ));
LDAP_F (int) ldap_int_sasl_set_option LDAP_P(( LDAP *ld,
	int option, void *arg ));
LDAP_F (int) ldap_int_sasl_config LDAP_P(( struct ldapoptions *lo,
	int option, const char *arg ));

LDAP_F (int) ldap_int_sasl_bind LDAP_P((
841
	LDAP *ld,
842
843
844
	const char *,
	const char *,
	LDAPControl **, LDAPControl **,
845
846
847

	/* should be passed in client controls */
	unsigned flags,
848
	LDAP_SASL_INTERACT_PROC *interact,
Howard Chu's avatar
Howard Chu committed
849
850
851
852
	void *defaults,
	LDAPMessage *result,
	const char **rmech,
	int *msgid ));
853

854
855
856
857
858
859
860
861
862
863
864
/* in sasl.c */

LDAP_F (BerElement *) ldap_build_bind_req LDAP_P((
	LDAP *ld,
	const char *dn,
	const char *mech,
	struct berval *cred,
	LDAPControl **sctrls,
	LDAPControl **cctrls,
	ber_int_t *msgidp ));

865
866
867
868
869
/* in schema.c */
LDAP_F (char *) ldap_int_parse_numericoid LDAP_P((
	const char **sp,
	int *code,
	const int flags ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
870

871
872
873
/*
 * in tls.c
 */
874
LDAP_F (int) ldap_int_tls_start LDAP_P(( LDAP *ld,
875
	LDAPConn *conn, LDAPURLDesc *srv ));
876

Howard Chu's avatar
Howard Chu committed
877
878
LDAP_F (void) ldap_int_tls_destroy LDAP_P(( struct ldapoptions *lo ));

879
880
881
882
883
884
/*
 *	in getvalues.c
 */
LDAP_F (char **) ldap_value_dup LDAP_P((
	char *const *vals ));

Kurt Zeilenga's avatar
Kurt Zeilenga committed
885
LDAP_END_DECL
886
887

#endif /* _LDAP_INT_H */