]> git.sur5r.net Git - openldap/blob - include/ldap_pvt.h
ITS#5810: exclude instead of include backends, explain exclusion
[openldap] / include / ldap_pvt.h
1 /* $OpenLDAP$ */
2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
3  * 
4  * Copyright 1998-2009 The OpenLDAP Foundation.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted only as authorized by the OpenLDAP
9  * Public License.
10  *
11  * A copy of this license is available in file LICENSE in the
12  * top-level directory of the distribution or, alternatively, at
13  * <http://www.OpenLDAP.org/license.html>.
14  */
15
16 /* ldap-pvt.h - Header for ldap_pvt_ functions.
17  * These are meant to be internal to OpenLDAP Software.
18  */
19
20 #ifndef _LDAP_PVT_H
21 #define _LDAP_PVT_H 1
22
23 #include <lber.h>                               /* get ber_slen_t */
24 #include <lber_pvt.h>                           /* get Sockbuf_Buf */
25
26 LDAP_BEGIN_DECL
27
28 #define LDAP_PROTO_TCP 1 /* ldap://  */
29 #define LDAP_PROTO_UDP 2 /* reserved */
30 #define LDAP_PROTO_IPC 3 /* ldapi:// */
31 #define LDAP_PROTO_EXT 4 /* user-defined socket/sockbuf */
32
33 LDAP_F ( int )
34 ldap_pvt_url_scheme2proto LDAP_P((
35         const char * ));
36 LDAP_F ( int )
37 ldap_pvt_url_scheme2tls LDAP_P((
38         const char * ));
39
40 LDAP_F ( int )
41 ldap_pvt_url_scheme_port LDAP_P((
42         const char *, int ));
43
44 struct ldap_url_desc; /* avoid pulling in <ldap.h> */
45
46 #define LDAP_PVT_URL_PARSE_NONE                 (0x00U)
47 #define LDAP_PVT_URL_PARSE_NOEMPTY_HOST         (0x01U)
48 #define LDAP_PVT_URL_PARSE_DEF_PORT             (0x02U)
49 #define LDAP_PVT_URL_PARSE_NOEMPTY_DN           (0x04U)
50 #define LDAP_PVT_URL_PARSE_NODEF_SCOPE          (0x08U)
51 #define LDAP_PVT_URL_PARSE_HISTORIC             (LDAP_PVT_URL_PARSE_NODEF_SCOPE | \
52                                                  LDAP_PVT_URL_PARSE_NOEMPTY_HOST | \
53                                                  LDAP_PVT_URL_PARSE_DEF_PORT)
54
55 LDAP_F( int )
56 ldap_url_parse_ext LDAP_P((
57         LDAP_CONST char *url,
58         struct ldap_url_desc **ludpp,
59         unsigned flags ));
60
61 LDAP_F (int) ldap_url_parselist LDAP_P((        /* deprecated, use ldap_url_parselist_ext() */
62         struct ldap_url_desc **ludlist,
63         const char *url ));
64
65 LDAP_F (int) ldap_url_parselist_ext LDAP_P((
66         struct ldap_url_desc **ludlist,
67         const char *url,
68         const char *sep,
69         unsigned flags ));
70
71 LDAP_F (char *) ldap_url_list2urls LDAP_P((
72         struct ldap_url_desc *ludlist ));
73
74 LDAP_F (void) ldap_free_urllist LDAP_P((
75         struct ldap_url_desc *ludlist ));
76
77 LDAP_F (int) ldap_pvt_scope2bv LDAP_P ((
78         int scope, struct berval *bv ));
79
80 LDAP_F (LDAP_CONST char *) ldap_pvt_scope2str LDAP_P ((
81         int scope ));
82
83 LDAP_F (int) ldap_pvt_bv2scope LDAP_P ((
84         struct berval *bv ));
85
86 LDAP_F (int) ldap_pvt_str2scope LDAP_P ((
87         LDAP_CONST char * ));
88
89 LDAP_F( char * )
90 ldap_pvt_ctime LDAP_P((
91         const time_t *tp,
92         char *buf ));
93
94 # if defined( HAVE_GMTIME_R )
95 #   define USE_GMTIME_R
96 #   define ldap_pvt_gmtime(timep, result) gmtime_r((timep), (result))
97 # else
98 LDAP_F( struct tm * )
99 ldap_pvt_gmtime LDAP_P((
100         LDAP_CONST time_t *timep,
101         struct tm *result ));
102 #endif
103
104 # if defined( HAVE_LOCALTIME_R )
105 #   define USE_LOCALTIME_R
106 #   define ldap_pvt_localtime(timep, result) localtime_r((timep), (result))
107 # else
108 LDAP_F( struct tm * )
109 ldap_pvt_localtime LDAP_P((
110         LDAP_CONST time_t *timep,
111         struct tm *result ));
112 # endif
113
114 #if defined( USE_GMTIME_R ) && defined( USE_LOCALTIME_R )
115 #   define ldap_pvt_gmtime_lock() (0)
116 #   define ldap_pvt_gmtime_unlock() (0)
117 #else
118 LDAP_F( int )
119 ldap_pvt_gmtime_lock LDAP_P(( void ));
120
121 LDAP_F( int )
122 ldap_pvt_gmtime_unlock LDAP_P(( void ));
123 #endif /* USE_GMTIME_R && USE_LOCALTIME_R */
124
125 /* Get current time as a structured time */
126 struct lutil_tm;
127 LDAP_F( void )
128 ldap_pvt_gettime LDAP_P(( struct lutil_tm * ));
129
130 /* use this macro to allocate buffer for ldap_pvt_csnstr */
131 #define LDAP_PVT_CSNSTR_BUFSIZE 64
132 LDAP_F( size_t )
133 ldap_pvt_csnstr( char *buf, size_t len, unsigned int replica, unsigned int mod );
134
135 LDAP_F( char *) ldap_pvt_get_fqdn LDAP_P(( char * ));
136
137 struct hostent; /* avoid pulling in <netdb.h> */
138
139 LDAP_F( int )
140 ldap_pvt_gethostbyname_a LDAP_P((
141         const char *name,
142         struct hostent *resbuf,
143         char **buf,
144         struct hostent **result,
145         int *herrno_ptr ));
146
147 LDAP_F( int )
148 ldap_pvt_gethostbyaddr_a LDAP_P((
149         const char *addr,
150         int len,
151         int type,
152         struct hostent *resbuf,
153         char **buf,
154         struct hostent **result,
155         int *herrno_ptr ));
156
157 struct sockaddr;
158
159 LDAP_F( int )
160 ldap_pvt_get_hname LDAP_P((
161         const struct sockaddr * sa,
162         int salen,
163         char *name,
164         int namelen,
165         char **herr ));
166
167
168 /* charray.c */
169
170 LDAP_F( int )
171 ldap_charray_add LDAP_P((
172     char        ***a,
173     const char *s ));
174
175 LDAP_F( int )
176 ldap_charray_merge LDAP_P((
177     char        ***a,
178     char        **s ));
179
180 LDAP_F( void )
181 ldap_charray_free LDAP_P(( char **a ));
182
183 LDAP_F( int )
184 ldap_charray_inlist LDAP_P((
185     char        **a,
186     const char *s ));
187
188 LDAP_F( char ** )
189 ldap_charray_dup LDAP_P(( char **a ));
190
191 LDAP_F( char ** )
192 ldap_str2charray LDAP_P((
193         const char *str,
194         const char *brkstr ));
195
196 LDAP_F( char * )
197 ldap_charray2str LDAP_P((
198         char **array, const char* sep ));
199
200 /* getdn.c */
201
202 #ifdef LDAP_AVA_NULL    /* in ldap.h */
203 LDAP_F( void ) ldap_rdnfree_x LDAP_P(( LDAPRDN rdn, void *ctx ));
204 LDAP_F( void ) ldap_dnfree_x LDAP_P(( LDAPDN dn, void *ctx ));
205
206 LDAP_F( int ) ldap_bv2dn_x LDAP_P(( 
207         struct berval *bv, LDAPDN *dn, unsigned flags, void *ctx ));
208 LDAP_F( int ) ldap_dn2bv_x LDAP_P(( 
209         LDAPDN dn, struct berval *bv, unsigned flags, void *ctx ));
210 LDAP_F( int ) ldap_bv2rdn_x LDAP_P(( 
211         struct berval *, LDAPRDN *, char **, unsigned flags, void *ctx ));
212 LDAP_F( int ) ldap_rdn2bv_x LDAP_P(( 
213         LDAPRDN rdn, struct berval *bv, unsigned flags, void *ctx ));
214 #endif /* LDAP_AVA_NULL */
215
216 /* url.c */
217 LDAP_F (void) ldap_pvt_hex_unescape LDAP_P(( char *s ));
218
219 /*
220  * these macros assume 'x' is an ASCII x
221  * and assume the "C" locale
222  */
223 #define LDAP_ASCII(c)           (!((c) & 0x80))
224 #define LDAP_SPACE(c)           ((c) == ' ' || (c) == '\t' || (c) == '\n')
225 #define LDAP_DIGIT(c)           ((c) >= '0' && (c) <= '9')
226 #define LDAP_LOWER(c)           ((c) >= 'a' && (c) <= 'z')
227 #define LDAP_UPPER(c)           ((c) >= 'A' && (c) <= 'Z')
228 #define LDAP_ALPHA(c)           (LDAP_LOWER(c) || LDAP_UPPER(c))
229 #define LDAP_ALNUM(c)           (LDAP_ALPHA(c) || LDAP_DIGIT(c))
230
231 #define LDAP_LDH(c)                     (LDAP_ALNUM(c) || (c) == '-')
232
233 #define LDAP_HEXLOWER(c)        ((c) >= 'a' && (c) <= 'f')
234 #define LDAP_HEXUPPER(c)        ((c) >= 'A' && (c) <= 'F')
235 #define LDAP_HEX(c)                     (LDAP_DIGIT(c) || \
236                                                                 LDAP_HEXLOWER(c) || LDAP_HEXUPPER(c))
237
238 /* controls.c */
239 struct ldapcontrol;
240 LDAP_F (int)
241 ldap_pvt_put_control LDAP_P((
242         const struct ldapcontrol *c,
243         BerElement *ber ));
244 LDAP_F (int) ldap_pvt_get_controls LDAP_P((
245         BerElement *be,
246         struct ldapcontrol ***ctrlsp));
247
248 #ifdef HAVE_CYRUS_SASL
249 /* cyrus.c */
250 struct sasl_security_properties; /* avoid pulling in <sasl.h> */
251 LDAP_F (int) ldap_pvt_sasl_secprops LDAP_P((
252         const char *in,
253         struct sasl_security_properties *secprops ));
254 LDAP_F (void) ldap_pvt_sasl_secprops_unparse LDAP_P((
255         struct sasl_security_properties *secprops,
256         struct berval *out ));
257
258 LDAP_F (void *) ldap_pvt_sasl_mutex_new LDAP_P((void));
259 LDAP_F (int) ldap_pvt_sasl_mutex_lock LDAP_P((void *mutex));
260 LDAP_F (int) ldap_pvt_sasl_mutex_unlock LDAP_P((void *mutex));
261 LDAP_F (void) ldap_pvt_sasl_mutex_dispose LDAP_P((void *mutex));
262 #endif /* HAVE_CYRUS_SASL */
263
264 struct sockbuf; /* avoid pulling in <lber.h> */
265 LDAP_F (int) ldap_pvt_sasl_install LDAP_P(( struct sockbuf *, void * ));
266 LDAP_F (void) ldap_pvt_sasl_remove LDAP_P(( struct sockbuf * ));
267
268 /*
269  * SASL encryption support for LBER Sockbufs
270  */
271
272 struct sb_sasl_generic_data;
273
274 struct sb_sasl_generic_ops {
275         void (*init)(struct sb_sasl_generic_data *p,
276                      ber_len_t *min_send,
277                      ber_len_t *max_send,
278                      ber_len_t *max_recv);
279         ber_int_t (*encode)(struct sb_sasl_generic_data *p,
280                             unsigned char *buf,
281                             ber_len_t len,
282                             Sockbuf_Buf *dst);
283         ber_int_t (*decode)(struct sb_sasl_generic_data *p,
284                             const Sockbuf_Buf *src,
285                             Sockbuf_Buf *dst);
286         void (*reset_buf)(struct sb_sasl_generic_data *p,
287                           Sockbuf_Buf *buf);
288         void (*fini)(struct sb_sasl_generic_data *p);
289 };
290
291 struct sb_sasl_generic_install {
292         const struct sb_sasl_generic_ops        *ops;
293         void                                    *ops_private;
294 };
295
296 struct sb_sasl_generic_data {
297         const struct sb_sasl_generic_ops        *ops;
298         void                                    *ops_private;
299         Sockbuf_IO_Desc                         *sbiod;
300         ber_len_t                               min_send;
301         ber_len_t                               max_send;
302         ber_len_t                               max_recv;
303         Sockbuf_Buf                             sec_buf_in;
304         Sockbuf_Buf                             buf_in;
305         Sockbuf_Buf                             buf_out;
306         unsigned int                            flags;
307 #define LDAP_PVT_SASL_PARTIAL_WRITE     1
308 };
309  
310 #ifndef LDAP_PVT_SASL_LOCAL_SSF
311 #define LDAP_PVT_SASL_LOCAL_SSF 71      /* SSF for Unix Domain Sockets */
312 #endif /* ! LDAP_PVT_SASL_LOCAL_SSF */
313
314 struct ldap;
315 struct ldapmsg;
316
317 /* abandon */
318 LDAP_F ( int ) ldap_pvt_discard LDAP_P((
319         struct ldap *ld, ber_int_t msgid ));
320
321 /* messages.c */
322 LDAP_F( BerElement * )
323 ldap_get_message_ber LDAP_P((
324         struct ldapmsg * ));
325
326 /* open */
327 LDAP_F (int) ldap_open_internal_connection LDAP_P((
328         struct ldap **ldp, ber_socket_t *fdp ));
329 LDAP_F (int) ldap_init_fd LDAP_P((
330         ber_socket_t fd, int proto, LDAP_CONST char *url, struct ldap **ldp ));
331
332 /* sasl.c */
333 LDAP_F (int) ldap_pvt_sasl_generic_install LDAP_P(( Sockbuf *sb,
334         struct sb_sasl_generic_install *install_arg ));
335 LDAP_F (void) ldap_pvt_sasl_generic_remove LDAP_P(( Sockbuf *sb ));
336
337 /* search.c */
338 LDAP_F( int ) ldap_pvt_put_filter LDAP_P((
339         BerElement *ber,
340         const char *str ));
341
342 LDAP_F( char * )
343 ldap_pvt_find_wildcard LDAP_P(( const char *s ));
344
345 LDAP_F( ber_slen_t )
346 ldap_pvt_filter_value_unescape LDAP_P(( char *filter ));
347
348 LDAP_F( ber_len_t )
349 ldap_bv2escaped_filter_value_len LDAP_P(( struct berval *in ));
350
351 LDAP_F( int )
352 ldap_bv2escaped_filter_value_x LDAP_P(( struct berval *in, struct berval *out,
353         int inplace, void *ctx ));
354
355 LDAP_F (int) ldap_pvt_search LDAP_P((
356         struct ldap *ld,
357         LDAP_CONST char *base,
358         int scope,
359         LDAP_CONST char *filter,
360         char **attrs,
361         int attrsonly,
362         struct ldapcontrol **sctrls,
363         struct ldapcontrol **cctrls,
364         struct timeval *timeout,
365         int sizelimit,
366         int deref,
367         int *msgidp ));
368
369 LDAP_F(int) ldap_pvt_search_s LDAP_P((
370         struct ldap *ld,
371         LDAP_CONST char *base,
372         int scope,
373         LDAP_CONST char *filter,
374         char **attrs,
375         int attrsonly,
376         struct ldapcontrol **sctrls,
377         struct ldapcontrol **cctrls,
378         struct timeval *timeout,
379         int sizelimit,
380         int deref,
381         struct ldapmsg **res ));
382
383 /* string.c */
384 LDAP_F( char * )
385 ldap_pvt_str2upper LDAP_P(( char *str ));
386
387 LDAP_F( char * )
388 ldap_pvt_str2lower LDAP_P(( char *str ));
389
390 LDAP_F( struct berval * )
391 ldap_pvt_str2upperbv LDAP_P(( char *str, struct berval *bv ));
392
393 LDAP_F( struct berval * )
394 ldap_pvt_str2lowerbv LDAP_P(( char *str, struct berval *bv ));
395
396 /* tls.c */
397 LDAP_F (int) ldap_pvt_tls_config LDAP_P(( struct ldap *ld,
398         int option, const char *arg ));
399 LDAP_F (int) ldap_pvt_tls_get_option LDAP_P(( struct ldap *ld,
400         int option, void *arg ));
401 LDAP_F (int) ldap_pvt_tls_set_option LDAP_P(( struct ldap *ld,
402         int option, void *arg ));
403
404 LDAP_F (void) ldap_pvt_tls_destroy LDAP_P(( void ));
405 LDAP_F (int) ldap_pvt_tls_init LDAP_P(( void ));
406 LDAP_F (int) ldap_pvt_tls_init_def_ctx LDAP_P(( int is_server ));
407 LDAP_F (int) ldap_pvt_tls_accept LDAP_P(( Sockbuf *sb, void *ctx_arg ));
408 LDAP_F (int) ldap_pvt_tls_inplace LDAP_P(( Sockbuf *sb ));
409 LDAP_F (void *) ldap_pvt_tls_sb_ctx LDAP_P(( Sockbuf *sb ));
410 LDAP_F (void) ldap_pvt_tls_ctx_free LDAP_P(( void * ));
411
412 typedef int LDAPDN_rewrite_dummy LDAP_P (( void *dn, unsigned flags ));
413
414 typedef int (LDAP_TLS_CONNECT_CB) LDAP_P (( struct ldap *ld, void *ssl,
415         void *ctx, void *arg ));
416
417 LDAP_F (int) ldap_pvt_tls_get_my_dn LDAP_P(( void *ctx, struct berval *dn,
418         LDAPDN_rewrite_dummy *func, unsigned flags ));
419 LDAP_F (int) ldap_pvt_tls_get_peer_dn LDAP_P(( void *ctx, struct berval *dn,
420         LDAPDN_rewrite_dummy *func, unsigned flags ));
421 LDAP_F (int) ldap_pvt_tls_get_strength LDAP_P(( void *ctx ));
422
423 LDAP_END_DECL
424
425 /*
426  * Multiple precision stuff
427  * 
428  * May use OpenSSL's BIGNUM if built with TLS,
429  * or GNU's multiple precision library. But if
430  * long long is available, that's big enough
431  * and much more efficient.
432  *
433  * If none is available, unsigned long data is used.
434  */
435
436 LDAP_BEGIN_DECL
437
438 #ifdef USE_MP_BIGNUM
439 /*
440  * Use OpenSSL's BIGNUM
441  */
442 #include <openssl/crypto.h>
443 #include <openssl/bn.h>
444
445 typedef BIGNUM* ldap_pvt_mp_t;
446 #define LDAP_PVT_MP_INIT        (NULL)
447
448 #define ldap_pvt_mp_init(mp) \
449         do { (mp) = BN_new(); } while (0)
450
451 /* FIXME: we rely on mpr being initialized */
452 #define ldap_pvt_mp_init_set(mpr,mpv) \
453         do { ldap_pvt_mp_init((mpr)); BN_add((mpr), (mpr), (mpv)); } while (0)
454
455 #define ldap_pvt_mp_add(mpr,mpv) \
456         BN_add((mpr), (mpr), (mpv))
457
458 #define ldap_pvt_mp_add_ulong(mp,v) \
459         BN_add_word((mp), (v))
460
461 #define ldap_pvt_mp_clear(mp) \
462         do { BN_free((mp)); (mp) = 0; } while (0)
463
464 #elif defined(USE_MP_GMP)
465 /*
466  * Use GNU's multiple precision library
467  */
468 #include <gmp.h>
469
470 typedef mpz_t           ldap_pvt_mp_t;
471 #define LDAP_PVT_MP_INIT        { 0 }
472
473 #define ldap_pvt_mp_init(mp) \
474         mpz_init((mp))
475
476 #define ldap_pvt_mp_init_set(mpr,mpv) \
477         mpz_init_set((mpr), (mpv))
478
479 #define ldap_pvt_mp_add(mpr,mpv) \
480         mpz_add((mpr), (mpr), (mpv))
481
482 #define ldap_pvt_mp_add_ulong(mp,v)     \
483         mpz_add_ui((mp), (mp), (v))
484
485 #define ldap_pvt_mp_clear(mp) \
486         mpz_clear((mp))
487
488 #else
489 /*
490  * Use unsigned long long
491  */
492
493 #ifdef USE_MP_LONG_LONG
494 typedef unsigned long long      ldap_pvt_mp_t;
495 #define LDAP_PVT_MP_INIT        (0LL)
496 #elif defined(USE_MP_LONG)
497 typedef unsigned long           ldap_pvt_mp_t;
498 #define LDAP_PVT_MP_INIT        (0L)
499 #elif defined(HAVE_LONG_LONG)
500 typedef unsigned long long      ldap_pvt_mp_t;
501 #define LDAP_PVT_MP_INIT        (0LL)
502 #else
503 typedef unsigned long           ldap_pvt_mp_t;
504 #define LDAP_PVT_MP_INIT        (0L)
505 #endif
506
507 #define ldap_pvt_mp_init(mp) \
508         do { (mp) = 0; } while (0)
509
510 #define ldap_pvt_mp_init_set(mpr,mpv) \
511         do { (mpr) = (mpv); } while (0)
512
513 #define ldap_pvt_mp_add(mpr,mpv) \
514         do { (mpr) += (mpv); } while (0)
515
516 #define ldap_pvt_mp_add_ulong(mp,v) \
517         do { (mp) += (v); } while (0)
518
519 #define ldap_pvt_mp_clear(mp) \
520         do { (mp) = 0; } while (0)
521
522 #endif /* MP */
523
524 #include "ldap_pvt_uc.h"
525
526 LDAP_END_DECL
527
528 LDAP_BEGIN_DECL
529
530 #include <limits.h>                             /* get CHAR_BIT */
531
532 /* Buffer space for sign, decimal digits and \0. Note: log10(2) < 146/485. */
533 #define LDAP_PVT_INTTYPE_CHARS(type) (((sizeof(type)*CHAR_BIT-1)*146)/485 + 3)
534
535 LDAP_END_DECL
536
537 #endif /* _LDAP_PVT_H */