ldap_pvt.h 14.4 KB
Newer Older
Kurt Zeilenga's avatar
Kurt Zeilenga committed
1
/* $OpenLDAP$ */
2
3
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
 * 
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
4
 * Copyright 1998-2021 The OpenLDAP Foundation.
Bart Hartgers's avatar
 
Bart Hartgers committed
5
6
 * All rights reserved.
 *
7
8
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted only as authorized by the OpenLDAP
9
10
11
12
13
 * Public License.
 *
 * A copy of this license is available in file LICENSE in the
 * top-level directory of the distribution or, alternatively, at
 * <http://www.OpenLDAP.org/license.html>.
Bart Hartgers's avatar
 
Bart Hartgers committed
14
 */
15
16
17

/* ldap-pvt.h - Header for ldap_pvt_ functions.
 * These are meant to be internal to OpenLDAP Software.
Bart Hartgers's avatar
 
Bart Hartgers committed
18
19
20
21
22
 */

#ifndef _LDAP_PVT_H
#define _LDAP_PVT_H 1

23
#include <openldap.h>				/* get public interfaces */
24
#include <lber.h>				/* get ber_slen_t */
25
#include <lber_pvt.h>				/* get Sockbuf_Buf */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
26
27
28

LDAP_BEGIN_DECL

29
LDAP_F ( int )
30
31
ldap_pvt_url_scheme2proto LDAP_P((
	const char * ));
32
LDAP_F ( int )
33
34
ldap_pvt_url_scheme2tls LDAP_P((
	const char * ));
35
36
37
LDAP_F ( int )
ldap_pvt_url_scheme2proxied LDAP_P((
	const char * ));
38

39
40
41
42
LDAP_F ( int )
ldap_pvt_url_scheme_port LDAP_P((
	const char *, int ));

43
44
struct ldap_url_desc; /* avoid pulling in <ldap.h> */

45
46
47
48
49
#define LDAP_PVT_URL_PARSE_NONE			(0x00U)
#define LDAP_PVT_URL_PARSE_NOEMPTY_HOST		(0x01U)
#define LDAP_PVT_URL_PARSE_DEF_PORT		(0x02U)
#define LDAP_PVT_URL_PARSE_NOEMPTY_DN		(0x04U)
#define LDAP_PVT_URL_PARSE_NODEF_SCOPE		(0x08U)
Pierangelo Masarati's avatar
cleanup    
Pierangelo Masarati committed
50
51
52
53
#define	LDAP_PVT_URL_PARSE_HISTORIC		(LDAP_PVT_URL_PARSE_NODEF_SCOPE | \
						 LDAP_PVT_URL_PARSE_NOEMPTY_HOST | \
						 LDAP_PVT_URL_PARSE_DEF_PORT)

54
55
56
LDAP_F( int )
ldap_url_parse_ext LDAP_P((
	LDAP_CONST char *url,
57
58
59
	struct ldap_url_desc **ludpp,
	unsigned flags ));

Pierangelo Masarati's avatar
Pierangelo Masarati committed
60
61
62
63
LDAP_F (int) ldap_url_parselist LDAP_P((	/* deprecated, use ldap_url_parselist_ext() */
	struct ldap_url_desc **ludlist,
	const char *url ));

64
65
66
67
68
69
70
71
72
73
74
LDAP_F (int) ldap_url_parselist_ext LDAP_P((
	struct ldap_url_desc **ludlist,
	const char *url,
	const char *sep,
	unsigned flags ));

LDAP_F (char *) ldap_url_list2urls LDAP_P((
	struct ldap_url_desc *ludlist ));

LDAP_F (void) ldap_free_urllist LDAP_P((
	struct ldap_url_desc *ludlist ));
75

Pierangelo Masarati's avatar
Pierangelo Masarati committed
76
77
78
79
80
81
82
83
84
85
86
87
LDAP_F (int) ldap_pvt_scope2bv LDAP_P ((
	int scope, struct berval *bv ));

LDAP_F (LDAP_CONST char *) ldap_pvt_scope2str LDAP_P ((
	int scope ));

LDAP_F (int) ldap_pvt_bv2scope LDAP_P ((
	struct berval *bv ));

LDAP_F (int) ldap_pvt_str2scope LDAP_P ((
	LDAP_CONST char * ));

88
LDAP_F( char * )
Kurt Zeilenga's avatar
Kurt Zeilenga committed
89
90
91
92
ldap_pvt_ctime LDAP_P((
	const time_t *tp,
	char *buf ));

93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
# if defined( HAVE_GMTIME_R )
#   define USE_GMTIME_R
#   define ldap_pvt_gmtime(timep, result) gmtime_r((timep), (result))
# else
LDAP_F( struct tm * )
ldap_pvt_gmtime LDAP_P((
	LDAP_CONST time_t *timep,
	struct tm *result ));
#endif

# if defined( HAVE_LOCALTIME_R )
#   define USE_LOCALTIME_R
#   define ldap_pvt_localtime(timep, result) localtime_r((timep), (result))
# else
LDAP_F( struct tm * )
ldap_pvt_localtime LDAP_P((
	LDAP_CONST time_t *timep,
	struct tm *result ));
# endif

113
114
115
116
117
118
119
120
121
122
123
#if defined( USE_GMTIME_R ) && defined( USE_LOCALTIME_R )
#   define ldap_pvt_gmtime_lock() (0)
#   define ldap_pvt_gmtime_unlock() (0)
#else
LDAP_F( int )
ldap_pvt_gmtime_lock LDAP_P(( void ));

LDAP_F( int )
ldap_pvt_gmtime_unlock LDAP_P(( void ));
#endif /* USE_GMTIME_R && USE_LOCALTIME_R */

124
/* Get current time as a structured time */
125
struct lutil_tm;
126
127
128
LDAP_F( void )
ldap_pvt_gettime LDAP_P(( struct lutil_tm * ));

129
130
#ifdef _WIN32
#define gettimeofday(tv,tz)	ldap_pvt_gettimeofday(tv,tz)
Howard Chu's avatar
Howard Chu committed
131
struct timeval;
132
133
134
135
LDAP_F( int )
ldap_pvt_gettimeofday LDAP_P(( struct timeval *tv, void *unused ));
#endif

136
137
138
139
140
/* use this macro to allocate buffer for ldap_pvt_csnstr */
#define LDAP_PVT_CSNSTR_BUFSIZE	64
LDAP_F( size_t )
ldap_pvt_csnstr( char *buf, size_t len, unsigned int replica, unsigned int mod );

141
142
LDAP_F( char *) ldap_pvt_get_fqdn LDAP_P(( char * ));

Kurt Zeilenga's avatar
Kurt Zeilenga committed
143
144
struct hostent;	/* avoid pulling in <netdb.h> */

145
LDAP_F( int )
Kurt Zeilenga's avatar
Kurt Zeilenga committed
146
ldap_pvt_gethostbyname_a LDAP_P((
147
	const char *name,
Bart Hartgers's avatar
 
Bart Hartgers committed
148
149
150
	struct hostent *resbuf,
	char **buf,
	struct hostent **result,
151
	int *herrno_ptr ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
152

153
LDAP_F( int )
Kurt Zeilenga's avatar
Kurt Zeilenga committed
154
ldap_pvt_gethostbyaddr_a LDAP_P((
Bart Hartgers's avatar
 
Bart Hartgers committed
155
156
157
158
159
160
	const char *addr,
	int len,
	int type,
	struct hostent *resbuf,
	char **buf,
	struct hostent **result,
161
	int *herrno_ptr ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
162

Howard Chu's avatar
Howard Chu committed
163
164
struct sockaddr;

165
166
167
168
169
170
171
172
LDAP_F( int )
ldap_pvt_get_hname LDAP_P((
	const struct sockaddr * sa,
	int salen,
	char *name,
	int namelen,
	char **herr ));

173
174
175

/* charray.c */

176
LDAP_F( int )
177
178
ldap_charray_add LDAP_P((
    char	***a,
179
    const char *s ));
180

181
LDAP_F( int )
182
183
184
185
ldap_charray_merge LDAP_P((
    char	***a,
    char	**s ));

186
LDAP_F( void )
187
188
ldap_charray_free LDAP_P(( char **a ));

189
LDAP_F( int )
190
191
ldap_charray_inlist LDAP_P((
    char	**a,
192
    const char *s ));
193

194
LDAP_F( char ** )
195
196
ldap_charray_dup LDAP_P(( char **a ));

197
LDAP_F( char ** )
198
ldap_str2charray LDAP_P((
199
200
	const char *str,
	const char *brkstr ));
201

202
203
204
205
LDAP_F( char * )
ldap_charray2str LDAP_P((
	char **array, const char* sep ));

206
207
208
209
210
211
212
213
214
215
216
217
218
219
/* getdn.c */

#ifdef LDAP_AVA_NULL	/* in ldap.h */
LDAP_F( void ) ldap_rdnfree_x LDAP_P(( LDAPRDN rdn, void *ctx ));
LDAP_F( void ) ldap_dnfree_x LDAP_P(( LDAPDN dn, void *ctx ));

LDAP_F( int ) ldap_bv2dn_x LDAP_P(( 
	struct berval *bv, LDAPDN *dn, unsigned flags, void *ctx ));
LDAP_F( int ) ldap_dn2bv_x LDAP_P(( 
	LDAPDN dn, struct berval *bv, unsigned flags, void *ctx ));
LDAP_F( int ) ldap_bv2rdn_x LDAP_P(( 
	struct berval *, LDAPRDN *, char **, unsigned flags, void *ctx ));
LDAP_F( int ) ldap_rdn2bv_x LDAP_P(( 
	LDAPRDN rdn, struct berval *bv, unsigned flags, void *ctx ));
220
#endif /* LDAP_AVA_NULL */
221

Kurt Zeilenga's avatar
Kurt Zeilenga committed
222
/* url.c */
223
LDAP_F (void) ldap_pvt_hex_unescape LDAP_P(( char *s ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
224

Kurt Zeilenga's avatar
Kurt Zeilenga committed
225
226
227
228
/*
 * these macros assume 'x' is an ASCII x
 * and assume the "C" locale
 */
229
#define LDAP_ASCII(c)		(!((c) & 0x80))
Kurt Zeilenga's avatar
Kurt Zeilenga committed
230
#define LDAP_SPACE(c)		((c) == ' ' || (c) == '\t' || (c) == '\n')
Kurt Zeilenga's avatar
Kurt Zeilenga committed
231
232
233
234
235
#define LDAP_DIGIT(c)		((c) >= '0' && (c) <= '9')
#define LDAP_LOWER(c)		((c) >= 'a' && (c) <= 'z')
#define LDAP_UPPER(c)		((c) >= 'A' && (c) <= 'Z')
#define LDAP_ALPHA(c)		(LDAP_LOWER(c) || LDAP_UPPER(c))
#define LDAP_ALNUM(c)		(LDAP_ALPHA(c) || LDAP_DIGIT(c))
236

Kurt Zeilenga's avatar
Kurt Zeilenga committed
237
238
239
240
241
242
#define LDAP_LDH(c)			(LDAP_ALNUM(c) || (c) == '-')

#define LDAP_HEXLOWER(c)	((c) >= 'a' && (c) <= 'f')
#define LDAP_HEXUPPER(c)	((c) >= 'A' && (c) <= 'F')
#define LDAP_HEX(c)			(LDAP_DIGIT(c) || \
								LDAP_HEXLOWER(c) || LDAP_HEXUPPER(c))
243

244
/* controls.c */
245
struct ldapcontrol;
246
247
248
249
LDAP_F (int)
ldap_pvt_put_control LDAP_P((
	const struct ldapcontrol *c,
	BerElement *ber ));
250
LDAP_F (int) ldap_pvt_get_controls LDAP_P((
251
252
	BerElement *be,
	struct ldapcontrol ***ctrlsp));
253

254
#ifdef HAVE_CYRUS_SASL
255
256
257
258
259
/* cyrus.c */
struct sasl_security_properties; /* avoid pulling in <sasl.h> */
LDAP_F (int) ldap_pvt_sasl_secprops LDAP_P((
	const char *in,
	struct sasl_security_properties *secprops ));
260
261
262
LDAP_F (void) ldap_pvt_sasl_secprops_unparse LDAP_P((
	struct sasl_security_properties *secprops,
	struct berval *out ));
263
264
265
266
267

LDAP_F (void *) ldap_pvt_sasl_mutex_new LDAP_P((void));
LDAP_F (int) ldap_pvt_sasl_mutex_lock LDAP_P((void *mutex));
LDAP_F (int) ldap_pvt_sasl_mutex_unlock LDAP_P((void *mutex));
LDAP_F (void) ldap_pvt_sasl_mutex_dispose LDAP_P((void *mutex));
268
269
270
271

LDAP_F (int) ldap_pvt_sasl_cbinding_parse LDAP_P(( const char *arg ));
LDAP_F (void *) ldap_pvt_sasl_cbinding LDAP_P(( void *ssl, int type,
					        int is_server ));
272
#endif /* HAVE_CYRUS_SASL */
273
274
275

struct sockbuf; /* avoid pulling in <lber.h> */
LDAP_F (int) ldap_pvt_sasl_install LDAP_P(( struct sockbuf *, void * ));
Jong Hyuk Choi's avatar
cleanup    
Jong Hyuk Choi committed
276
LDAP_F (void) ldap_pvt_sasl_remove LDAP_P(( struct sockbuf * ));
277

278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
/*
 * SASL encryption support for LBER Sockbufs
 */

struct sb_sasl_generic_data;

struct sb_sasl_generic_ops {
	void (*init)(struct sb_sasl_generic_data *p,
		     ber_len_t *min_send,
		     ber_len_t *max_send,
		     ber_len_t *max_recv);
	ber_int_t (*encode)(struct sb_sasl_generic_data *p,
			    unsigned char *buf,
			    ber_len_t len,
			    Sockbuf_Buf *dst);
	ber_int_t (*decode)(struct sb_sasl_generic_data *p,
			    const Sockbuf_Buf *src,
			    Sockbuf_Buf *dst);
	void (*reset_buf)(struct sb_sasl_generic_data *p,
			  Sockbuf_Buf *buf);
	void (*fini)(struct sb_sasl_generic_data *p);
};

struct sb_sasl_generic_install {
	const struct sb_sasl_generic_ops 	*ops;
	void					*ops_private;
};

struct sb_sasl_generic_data {
	const struct sb_sasl_generic_ops 	*ops;
	void					*ops_private;
	Sockbuf_IO_Desc				*sbiod;
	ber_len_t				min_send;
	ber_len_t				max_send;
	ber_len_t				max_recv;
	Sockbuf_Buf				sec_buf_in;
	Sockbuf_Buf				buf_in;
	Sockbuf_Buf				buf_out;
316
	unsigned int				flags;
Howard Chu's avatar
Howard Chu committed
317
#define LDAP_PVT_SASL_PARTIAL_WRITE	1
318
319
};
 
320
#ifndef LDAP_PVT_SASL_LOCAL_SSF
321
#define LDAP_PVT_SASL_LOCAL_SSF	71	/* SSF for Unix Domain Sockets */
322
#endif /* ! LDAP_PVT_SASL_LOCAL_SSF */
323

Kurt Zeilenga's avatar
Kurt Zeilenga committed
324
struct ldap;
Kurt Zeilenga's avatar
Kurt Zeilenga committed
325
struct ldapmsg;
326
struct ldifrecord;
327

328
329
330
/* abandon */
LDAP_F ( int ) ldap_pvt_discard LDAP_P((
	struct ldap *ld, ber_int_t msgid ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
331

332
333
334
335
336
/* init.c */
LDAP_F( int )
ldap_pvt_conf_option LDAP_P((
	char *cmd, char *opt, int userconf ));

337
338
339
340
/* ldifutil.c */
LDAP_F( int )
ldap_parse_ldif_record_x LDAP_P((
	struct berval *rbuf,
341
	unsigned long linenum,
342
343
344
345
346
	struct ldifrecord *lr,
	const char *errstr,
	unsigned int flags,
	void *ctx ));

347
348
349
350
351
/* messages.c */
LDAP_F( BerElement * )
ldap_get_message_ber LDAP_P((
	struct ldapmsg * ));

352
353
354
355
/* open */
LDAP_F (int) ldap_open_internal_connection LDAP_P((
	struct ldap **ldp, ber_socket_t *fdp ));

Pierangelo Masarati's avatar
Pierangelo Masarati committed
356
357
358
359
360
/* sasl.c */
LDAP_F (int) ldap_pvt_sasl_generic_install LDAP_P(( Sockbuf *sb,
	struct sb_sasl_generic_install *install_arg ));
LDAP_F (void) ldap_pvt_sasl_generic_remove LDAP_P(( Sockbuf *sb ));

361
/* search.c */
362
363
364
365
LDAP_F( int ) ldap_pvt_put_filter LDAP_P((
	BerElement *ber,
	const char *str ));

366
LDAP_F( char * )
367
ldap_pvt_find_wildcard LDAP_P((	const char *s ));
368

369
LDAP_F( ber_slen_t )
370
371
ldap_pvt_filter_value_unescape LDAP_P(( char *filter ));

372
373
374
375
376
377
378
LDAP_F( ber_len_t )
ldap_bv2escaped_filter_value_len LDAP_P(( struct berval *in ));

LDAP_F( int )
ldap_bv2escaped_filter_value_x LDAP_P(( struct berval *in, struct berval *out,
	int inplace, void *ctx ));

379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
LDAP_F (int) ldap_pvt_search LDAP_P((
	struct ldap *ld,
	LDAP_CONST char *base,
	int scope,
	LDAP_CONST char *filter,
	char **attrs,
	int attrsonly,
	struct ldapcontrol **sctrls,
	struct ldapcontrol **cctrls,
	struct timeval *timeout,
	int sizelimit,
	int deref,
	int *msgidp ));

LDAP_F(int) ldap_pvt_search_s LDAP_P((
	struct ldap *ld,
	LDAP_CONST char *base,
	int scope,
	LDAP_CONST char *filter,
	char **attrs,
	int attrsonly,
	struct ldapcontrol **sctrls,
	struct ldapcontrol **cctrls,
	struct timeval *timeout,
	int sizelimit,
	int deref,
	struct ldapmsg **res ));

407
/* string.c */
408
LDAP_F( char * )
409
410
ldap_pvt_str2upper LDAP_P(( char *str ));

411
LDAP_F( char * )
412
413
ldap_pvt_str2lower LDAP_P(( char *str ));

414
415
416
417
418
419
LDAP_F( struct berval * )
ldap_pvt_str2upperbv LDAP_P(( char *str, struct berval *bv ));

LDAP_F( struct berval * )
ldap_pvt_str2lowerbv LDAP_P(( char *str, struct berval *bv ));

420
/* tls.c */
421
LDAP_F (int) ldap_pvt_tls_config LDAP_P(( struct ldap *ld,
422
	int option, const char *arg ));
423
424
425
426
LDAP_F (int) ldap_pvt_tls_get_option LDAP_P(( struct ldap *ld,
	int option, void *arg ));
LDAP_F (int) ldap_pvt_tls_set_option LDAP_P(( struct ldap *ld,
	int option, void *arg ));
427

428
LDAP_F (void) ldap_pvt_tls_destroy LDAP_P(( void ));
429
LDAP_F (int) ldap_pvt_tls_init LDAP_P(( void ));
430
LDAP_F (int) ldap_pvt_tls_init_def_ctx LDAP_P(( int is_server ));
431
LDAP_F (int) ldap_pvt_tls_accept LDAP_P(( Sockbuf *sb, void *ctx_arg ));
432
LDAP_F (int) ldap_pvt_tls_connect LDAP_P(( struct ldap *ld, Sockbuf *sb, const char *host ));
433
LDAP_F (int) ldap_pvt_tls_inplace LDAP_P(( Sockbuf *sb ));
434
LDAP_F (void *) ldap_pvt_tls_sb_ctx LDAP_P(( Sockbuf *sb ));
435
LDAP_F (void) ldap_pvt_tls_ctx_free LDAP_P(( void * ));
436

Howard Chu's avatar
Howard Chu committed
437
438
typedef int LDAPDN_rewrite_dummy LDAP_P (( void *dn, unsigned flags ));

439
440
441
typedef int (LDAP_TLS_CONNECT_CB) LDAP_P (( struct ldap *ld, void *ssl,
	void *ctx, void *arg ));

442
LDAP_F (int) ldap_pvt_tls_get_my_dn LDAP_P(( void *ctx, struct berval *dn,
Howard Chu's avatar
Howard Chu committed
443
	LDAPDN_rewrite_dummy *func, unsigned flags ));
444
LDAP_F (int) ldap_pvt_tls_get_peer_dn LDAP_P(( void *ctx, struct berval *dn,
Howard Chu's avatar
Howard Chu committed
445
	LDAPDN_rewrite_dummy *func, unsigned flags ));
446
LDAP_F (int) ldap_pvt_tls_get_strength LDAP_P(( void *ctx ));
Howard Chu's avatar
Howard Chu committed
447
LDAP_F (int) ldap_pvt_tls_get_unique LDAP_P(( void *ctx, struct berval *buf, int is_server ));
448
LDAP_F (int) ldap_pvt_tls_get_endpoint LDAP_P(( void *ctx, struct berval *buf, int is_server ));
Howard Chu's avatar
Howard Chu committed
449
450
LDAP_F (const char *) ldap_pvt_tls_get_version LDAP_P(( void *ctx ));
LDAP_F (const char *) ldap_pvt_tls_get_cipher LDAP_P(( void *ctx ));
451

Kurt Zeilenga's avatar
Kurt Zeilenga committed
452
453
LDAP_END_DECL

454
455
456
457
/*
 * Multiple precision stuff
 * 
 * May use OpenSSL's BIGNUM if built with TLS,
Howard Chu's avatar
Howard Chu committed
458
459
460
 * or GNU's multiple precision library. But if
 * long long is available, that's big enough
 * and much more efficient.
461
462
463
 *
 * If none is available, unsigned long data is used.
 */
Howard Chu's avatar
Howard Chu committed
464

465
466
LDAP_BEGIN_DECL

467
#ifdef USE_MP_BIGNUM
468
469
470
471
472
473
/*
 * Use OpenSSL's BIGNUM
 */
#include <openssl/crypto.h>
#include <openssl/bn.h>

Kurt Zeilenga's avatar
Kurt Zeilenga committed
474
typedef	BIGNUM* ldap_pvt_mp_t;
Pierangelo Masarati's avatar
Pierangelo Masarati committed
475
#define	LDAP_PVT_MP_INIT	(NULL)
476
477

#define	ldap_pvt_mp_init(mp) \
Kurt Zeilenga's avatar
Kurt Zeilenga committed
478
	do { (mp) = BN_new(); } while (0)
Kurt Zeilenga's avatar
Kurt Zeilenga committed
479

480
481
482
483
484
485
486
487
488
489
490
491
492
/* FIXME: we rely on mpr being initialized */
#define	ldap_pvt_mp_init_set(mpr,mpv) \
	do { ldap_pvt_mp_init((mpr)); BN_add((mpr), (mpr), (mpv)); } while (0)

#define	ldap_pvt_mp_add(mpr,mpv) \
	BN_add((mpr), (mpr), (mpv))

#define	ldap_pvt_mp_add_ulong(mp,v) \
	BN_add_word((mp), (v))

#define ldap_pvt_mp_clear(mp) \
	do { BN_free((mp)); (mp) = 0; } while (0)

493
#elif defined(USE_MP_GMP)
494
495
496
497
/*
 * Use GNU's multiple precision library
 */
#include <gmp.h>
Bart Hartgers's avatar
 
Bart Hartgers committed
498

499
typedef mpz_t		ldap_pvt_mp_t;
Pierangelo Masarati's avatar
Pierangelo Masarati committed
500
501
#define	LDAP_PVT_MP_INIT	{ 0 }

502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
#define ldap_pvt_mp_init(mp) \
	mpz_init((mp))

#define	ldap_pvt_mp_init_set(mpr,mpv) \
	mpz_init_set((mpr), (mpv))

#define	ldap_pvt_mp_add(mpr,mpv) \
	mpz_add((mpr), (mpr), (mpv))

#define	ldap_pvt_mp_add_ulong(mp,v)	\
	mpz_add_ui((mp), (mp), (v))

#define ldap_pvt_mp_clear(mp) \
	mpz_clear((mp))

Kurt Zeilenga's avatar
Kurt Zeilenga committed
517
#else
518
/*
Kurt Zeilenga's avatar
Kurt Zeilenga committed
519
 * Use unsigned long long
520
521
 */

522
#ifdef USE_MP_LONG_LONG
523
typedef	unsigned long long	ldap_pvt_mp_t;
Pierangelo Masarati's avatar
Pierangelo Masarati committed
524
#define	LDAP_PVT_MP_INIT	(0LL)
525
#elif defined(USE_MP_LONG)
526
typedef	unsigned long		ldap_pvt_mp_t;
Pierangelo Masarati's avatar
Pierangelo Masarati committed
527
#define	LDAP_PVT_MP_INIT	(0L)
528
#elif defined(HAVE_LONG_LONG)
Kurt Zeilenga's avatar
Kurt Zeilenga committed
529
530
531
532
533
534
typedef	unsigned long long	ldap_pvt_mp_t;
#define	LDAP_PVT_MP_INIT	(0LL)
#else
typedef	unsigned long		ldap_pvt_mp_t;
#define	LDAP_PVT_MP_INIT	(0L)
#endif
535
536

#define ldap_pvt_mp_init(mp) \
Kurt Zeilenga's avatar
Kurt Zeilenga committed
537
	do { (mp) = 0; } while (0)
538
539

#define	ldap_pvt_mp_init_set(mpr,mpv) \
Kurt Zeilenga's avatar
Kurt Zeilenga committed
540
	do { (mpr) = (mpv); } while (0)
541
542

#define	ldap_pvt_mp_add(mpr,mpv) \
Kurt Zeilenga's avatar
Kurt Zeilenga committed
543
	do { (mpr) += (mpv); } while (0)
544
545

#define	ldap_pvt_mp_add_ulong(mp,v) \
Kurt Zeilenga's avatar
Kurt Zeilenga committed
546
	do { (mp) += (v); } while (0)
547
548

#define ldap_pvt_mp_clear(mp) \
Kurt Zeilenga's avatar
Kurt Zeilenga committed
549
	do { (mp) = 0; } while (0)
550

Kurt Zeilenga's avatar
Kurt Zeilenga committed
551
#endif /* MP */
552
553
554

#include "ldap_pvt_uc.h"

555
556
557
558
559
560
561
562
563
564
565
LDAP_END_DECL

LDAP_BEGIN_DECL

#include <limits.h>				/* get CHAR_BIT */

/* Buffer space for sign, decimal digits and \0. Note: log10(2) < 146/485. */
#define LDAP_PVT_INTTYPE_CHARS(type) (((sizeof(type)*CHAR_BIT-1)*146)/485 + 3)

LDAP_END_DECL

Kurt Zeilenga's avatar
Kurt Zeilenga committed
566
#endif /* _LDAP_PVT_H */