versadac  1
versadac - Scalable Recorder Firmware
lber.h
1 /* $OpenLDAP: pkg/ldap/include/lber.h,v 1.99.2.4 2008/02/11 23:26:40 kurt Exp $ */
2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
3  *
4  * Copyright 1998-2008 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 /* Portions Copyright (c) 1990 Regents of the University of Michigan.
16  * All rights reserved.
17  *
18  * Redistribution and use in source and binary forms are permitted
19  * provided that this notice is preserved and that due credit is given
20  * to the University of Michigan at Ann Arbor. The name of the University
21  * may not be used to endorse or promote products derived from this
22  * software without specific prior written permission. This software
23  * is provided ``as is'' without express or implied warranty.
24  */
25 
26 #ifndef _LBER_H
27 #define _LBER_H
28 
29 #include <lber_types.h>
30 #include <string.h>
31 
32 LDAP_BEGIN_DECL
33 
34 /* Overview of LBER tag construction
35  *
36  * Bits
37  * ______
38  * 8 7 | CLASS
39  * 0 0 = UNIVERSAL
40  * 0 1 = APPLICATION
41  * 1 0 = CONTEXT-SPECIFIC
42  * 1 1 = PRIVATE
43  * _____
44  * | 6 | DATA-TYPE
45  * 0 = PRIMITIVE
46  * 1 = CONSTRUCTED
47  * ___________
48  * | 5 ... 1 | TAG-NUMBER
49  */
50 
51 /* BER classes and mask */
52 #define LBER_CLASS_UNIVERSAL ((ber_tag_t) 0x00U)
53 #define LBER_CLASS_APPLICATION ((ber_tag_t) 0x40U)
54 #define LBER_CLASS_CONTEXT ((ber_tag_t) 0x80U)
55 #define LBER_CLASS_PRIVATE ((ber_tag_t) 0xc0U)
56 #define LBER_CLASS_MASK ((ber_tag_t) 0xc0U)
57 
58 /* BER encoding type and mask */
59 #define LBER_PRIMITIVE ((ber_tag_t) 0x00U)
60 #define LBER_CONSTRUCTED ((ber_tag_t) 0x20U)
61 #define LBER_ENCODING_MASK ((ber_tag_t) 0x20U)
62 
63 #define LBER_BIG_TAG_MASK ((ber_tag_t) 0x1fU)
64 #define LBER_MORE_TAG_MASK ((ber_tag_t) 0x80U)
65 
66 /*
67  * Note that LBER_ERROR and LBER_DEFAULT are values that can never appear
68  * as valid BER tags, and so it is safe to use them to report errors. In
69  * fact, any tag for which the following is true is invalid:
70  */
71 #define LBER_INVALID(t) (((t) & (ber_tag_t) 0x080UL) \
72  && (((t) & (ber_tag_t) ~ 0x0FF))
73 
74 #define LBER_ERROR ((ber_tag_t) -1)
75 #define LBER_DEFAULT ((ber_tag_t) -1)
76 
77 /* general BER types we know about */
78 #define LBER_BOOLEAN ((ber_tag_t) 0x01UL)
79 #define LBER_INTEGER ((ber_tag_t) 0x02UL)
80 #define LBER_BITSTRING ((ber_tag_t) 0x03UL)
81 #define LBER_OCTETSTRING ((ber_tag_t) 0x04UL)
82 #define LBER_NULL ((ber_tag_t) 0x05UL)
83 #define LBER_ENUMERATED ((ber_tag_t) 0x0aUL)
84 #define LBER_SEQUENCE ((ber_tag_t) 0x30UL) /* constructed */
85 #define LBER_SET ((ber_tag_t) 0x31UL) /* constructed */
86 
87 /* LBER BerElement options */
88 #define LBER_USE_DER 0x01
89 
90 /* get/set options for BerElement */
91 #define LBER_OPT_BER_OPTIONS 0x01
92 #define LBER_OPT_BER_DEBUG 0x02
93 #define LBER_OPT_BER_REMAINING_BYTES 0x03
94 #define LBER_OPT_BER_TOTAL_BYTES 0x04
95 #define LBER_OPT_BER_BYTES_TO_WRITE 0x05
96 #define LBER_OPT_BER_MEMCTX 0x06
97 
98 #define LBER_OPT_DEBUG_LEVEL LBER_OPT_BER_DEBUG
99 #define LBER_OPT_REMAINING_BYTES LBER_OPT_BER_REMAINING_BYTES
100 #define LBER_OPT_TOTAL_BYTES LBER_OPT_BER_TOTAL_BYTES
101 #define LBER_OPT_BYTES_TO_WRITE LBER_OPT_BER_BYTES_TO_WRITE
102 
103 #define LBER_OPT_LOG_PRINT_FN 0x8001
104 #define LBER_OPT_MEMORY_FNS 0x8002
105 #define LBER_OPT_ERROR_FN 0x8003
106 #define LBER_OPT_LOG_PRINT_FILE 0x8004
107 
108 /* get/set Memory Debug options */
109 #define LBER_OPT_MEMORY_INUSE 0x8005 /* for memory debugging */
110 #define LBER_OPT_LOG_PROC 0x8006 /* for external logging function */
111 
112 typedef int* (*BER_ERRNO_FN) LDAP_P(( void ));
113 
114 typedef void (*BER_LOG_PRINT_FN) LDAP_P(( LDAP_CONST char *buf ));
115 
116 typedef void* (BER_MEMALLOC_FN) LDAP_P(( ber_len_t size, void *ctx ));
117 typedef void* (BER_MEMCALLOC_FN) LDAP_P(( ber_len_t n, ber_len_t size, void *ctx ));
118 typedef void* (BER_MEMREALLOC_FN) LDAP_P(( void *p, ber_len_t size, void *ctx ));
119 typedef void (BER_MEMFREE_FN) LDAP_P(( void *p, void *ctx ));
120 
121 typedef struct lber_memory_fns {
122  BER_MEMALLOC_FN *bmf_malloc;
123  BER_MEMCALLOC_FN *bmf_calloc;
124  BER_MEMREALLOC_FN *bmf_realloc;
125  BER_MEMFREE_FN *bmf_free;
127 
128 /* LBER Sockbuf_IO options */
129 #define LBER_SB_OPT_GET_FD 1
130 #define LBER_SB_OPT_SET_FD 2
131 #define LBER_SB_OPT_HAS_IO 3
132 #define LBER_SB_OPT_SET_NONBLOCK 4
133 #define LBER_SB_OPT_GET_SSL 7
134 #define LBER_SB_OPT_DATA_READY 8
135 #define LBER_SB_OPT_SET_READAHEAD 9
136 #define LBER_SB_OPT_DRAIN 10
137 #define LBER_SB_OPT_NEEDS_READ 11
138 #define LBER_SB_OPT_NEEDS_WRITE 12
139 #define LBER_SB_OPT_GET_MAX_INCOMING 13
140 #define LBER_SB_OPT_SET_MAX_INCOMING 14
141 
142 /* Only meaningful ifdef LDAP_PF_LOCAL_SENDMSG */
143 #define LBER_SB_OPT_UNGET_BUF 15
144 
145 /* Largest option used by the library */
146 #define LBER_SB_OPT_OPT_MAX 15
147 
148 /* LBER IO operations stacking levels */
149 #define LBER_SBIOD_LEVEL_PROVIDER 10
150 #define LBER_SBIOD_LEVEL_TRANSPORT 20
151 #define LBER_SBIOD_LEVEL_APPLICATION 30
152 
153 /* get/set options for Sockbuf */
154 #define LBER_OPT_SOCKBUF_DESC 0x1000
155 #define LBER_OPT_SOCKBUF_OPTIONS 0x1001
156 #define LBER_OPT_SOCKBUF_DEBUG 0x1002
157 
158 /* on/off values */
159 LBER_V( char ) ber_pvt_opt_on;
160 #define LBER_OPT_ON ((void *) &ber_pvt_opt_on)
161 #define LBER_OPT_OFF ((void *) 0)
162 
163 #define LBER_OPT_SUCCESS (0)
164 #define LBER_OPT_ERROR (-1)
165 
166 typedef struct berelement BerElement;
167 #ifdef VXWORKS_BUILD
168 typedef struct lber_sockbuf Sockbuf;
169 #else
170 typedef struct sockbuf Sockbuf;
171 #endif
172 typedef struct seqorset Seqorset;
173 
174 typedef struct sockbuf_io Sockbuf_IO;
175 
176 /* Structure for LBER IO operarion descriptor */
177 typedef struct sockbuf_io_desc {
178  int sbiod_level;
179  Sockbuf *sbiod_sb;
180  Sockbuf_IO *sbiod_io;
181  void *sbiod_pvt;
182  struct sockbuf_io_desc *sbiod_next;
184 
185 /* Structure for LBER IO operation functions */
186 struct sockbuf_io {
187  int (*sbi_setup)( Sockbuf_IO_Desc *sbiod, void *arg );
188  int (*sbi_remove)( Sockbuf_IO_Desc *sbiod );
189  int (*sbi_ctrl)( Sockbuf_IO_Desc *sbiod, int opt, void *arg);
190 
191  ber_slen_t (*sbi_read)( Sockbuf_IO_Desc *sbiod, void *buf,
192  ber_len_t len );
193  ber_slen_t (*sbi_write)( Sockbuf_IO_Desc *sbiod, void *buf,
194  ber_len_t len );
195 
196  int (*sbi_close)( Sockbuf_IO_Desc *sbiod );
197 };
198 
199 /* Helper macros for LBER IO functions */
200 #define LBER_SBIOD_READ_NEXT( sbiod, buf, len ) \
201  ( (sbiod)->sbiod_next->sbiod_io->sbi_read( (sbiod)->sbiod_next, \
202  buf, len ) )
203 #define LBER_SBIOD_WRITE_NEXT( sbiod, buf, len ) \
204  ( (sbiod)->sbiod_next->sbiod_io->sbi_write( (sbiod)->sbiod_next, \
205  buf, len ) )
206 #define LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg ) \
207  ( (sbiod)->sbiod_next ? \
208  ( (sbiod)->sbiod_next->sbiod_io->sbi_ctrl( \
209  (sbiod)->sbiod_next, opt, arg ) ) : 0 )
210 
211 /* structure for returning a sequence of octet strings + length */
212 typedef struct berval {
213  ber_len_t bv_len;
214  char *bv_val;
215 } BerValue;
216 
217 typedef BerValue *BerVarray; /* To distinguish from a single bv */
218 
219 /* this should be moved to lber-int.h */
220 
221 /*
222  * in bprint.c:
223  */
224 LBER_F( void )
225 ber_error_print LDAP_P((
226  LDAP_CONST char *data ));
227 
228 LBER_F( void )
229 ber_bprint LDAP_P((
230  LDAP_CONST char *data, ber_len_t len ));
231 
232 LBER_F( void )
233 ber_dump LDAP_P((
234  BerElement *ber, int inout ));
235 
236 LBER_F( void )
237 ber_sos_dump LDAP_P((
238  Seqorset *sos ));
239 
240 /*
241  * in decode.c:
242  */
243 typedef int (*BERDecodeCallback) LDAP_P((
244  BerElement *ber,
245  void *data,
246  int mode ));
247 
248 LBER_F( ber_tag_t )
249 ber_get_tag LDAP_P((
250  BerElement *ber ));
251 
252 LBER_F( ber_tag_t )
253 ber_skip_tag LDAP_P((
254  BerElement *ber,
255  ber_len_t *len ));
256 
257 LBER_F( ber_tag_t )
258 ber_peek_tag LDAP_P((
259  BerElement *ber,
260  ber_len_t *len ));
261 
262 LBER_F( ber_tag_t )
263 ber_get_int LDAP_P((
264  BerElement *ber,
265  ber_int_t *num ));
266 
267 LBER_F( ber_tag_t )
268 ber_get_enum LDAP_P((
269  BerElement *ber,
270  ber_int_t *num ));
271 
272 LBER_F( ber_tag_t )
273 ber_get_stringb LDAP_P((
274  BerElement *ber,
275  char *buf,
276  ber_len_t *len ));
277 
278 #define LBER_BV_ALLOC 0x01 /* allocate/copy result, otherwise in-place */
279 #define LBER_BV_NOTERM 0x02 /* omit NUL-terminator if parsing in-place */
280 
281 LBER_F( ber_tag_t )
282 ber_get_stringbv LDAP_P((
283  BerElement *ber,
284  struct berval *bv,
285  int options ));
286 
287 LBER_F( ber_tag_t )
288 ber_get_stringa LDAP_P((
289  BerElement *ber,
290  char **buf ));
291 
292 LBER_F( ber_tag_t )
293 ber_get_stringal LDAP_P((
294  BerElement *ber,
295  struct berval **bv ));
296 
297 LBER_F( ber_tag_t )
298 ber_get_bitstringa LDAP_P((
299  BerElement *ber,
300  char **buf,
301  ber_len_t *len ));
302 
303 LBER_F( ber_tag_t )
304 ber_get_null LDAP_P((
305  BerElement *ber ));
306 
307 LBER_F( ber_tag_t )
308 ber_get_boolean LDAP_P((
309  BerElement *ber,
310  ber_int_t *boolval ));
311 
312 LBER_F( ber_tag_t )
313 ber_first_element LDAP_P((
314  BerElement *ber,
315  ber_len_t *len,
316  char **last ));
317 
318 LBER_F( ber_tag_t )
319 ber_next_element LDAP_P((
320  BerElement *ber,
321  ber_len_t *len,
322  LDAP_CONST char *last ));
323 
324 LBER_F( ber_tag_t )
325 ber_scanf LDAP_P((
326  BerElement *ber,
327  LDAP_CONST char *fmt,
328  ... ));
329 
330 LBER_F( int )
331 ber_decode_oid LDAP_P((
332  struct berval *in,
333  struct berval *out ));
334 
335 /*
336  * in encode.c
337  */
338 LBER_F( int )
339 ber_encode_oid LDAP_P((
340  struct berval *in,
341  struct berval *out ));
342 
343 typedef int (*BEREncodeCallback) LDAP_P((
344  BerElement *ber,
345  void *data ));
346 
347 LBER_F( int )
348 ber_put_enum LDAP_P((
349  BerElement *ber,
350  ber_int_t num,
351  ber_tag_t tag ));
352 
353 LBER_F( int )
354 ber_put_int LDAP_P((
355  BerElement *ber,
356  ber_int_t num,
357  ber_tag_t tag ));
358 
359 LBER_F( int )
360 ber_put_ostring LDAP_P((
361  BerElement *ber,
362  LDAP_CONST char *str,
363  ber_len_t len,
364  ber_tag_t tag ));
365 
366 LBER_F( int )
367 ber_put_berval LDAP_P((
368  BerElement *ber,
369  struct berval *bv,
370  ber_tag_t tag ));
371 
372 LBER_F( int )
373 ber_put_string LDAP_P((
374  BerElement *ber,
375  LDAP_CONST char *str,
376  ber_tag_t tag ));
377 
378 LBER_F( int )
379 ber_put_bitstring LDAP_P((
380  BerElement *ber,
381  LDAP_CONST char *str,
382  ber_len_t bitlen,
383  ber_tag_t tag ));
384 
385 LBER_F( int )
386 ber_put_null LDAP_P((
387  BerElement *ber,
388  ber_tag_t tag ));
389 
390 LBER_F( int )
391 ber_put_boolean LDAP_P((
392  BerElement *ber,
393  ber_int_t boolval,
394  ber_tag_t tag ));
395 
396 LBER_F( int )
397 ber_start_seq LDAP_P((
398  BerElement *ber,
399  ber_tag_t tag ));
400 
401 LBER_F( int )
402 ber_start_set LDAP_P((
403  BerElement *ber,
404  ber_tag_t tag ));
405 
406 LBER_F( int )
407 ber_put_seq LDAP_P((
408  BerElement *ber ));
409 
410 LBER_F( int )
411 ber_put_set LDAP_P((
412  BerElement *ber ));
413 
414 LBER_F( int )
415 ber_printf LDAP_P((
416  BerElement *ber,
417  LDAP_CONST char *fmt,
418  ... ));
419 
420 
421 /*
422  * in io.c:
423  */
424 
425 LBER_F( ber_slen_t )
426 ber_skip_data LDAP_P((
427  BerElement *ber,
428  ber_len_t len ));
429 
430 LBER_F( ber_slen_t )
431 ber_read LDAP_P((
432  BerElement *ber,
433  char *buf,
434  ber_len_t len ));
435 
436 LBER_F( ber_slen_t )
437 ber_write LDAP_P((
438  BerElement *ber,
439  LDAP_CONST char *buf,
440  ber_len_t len,
441  int nosos ));
442 
443 LBER_F( void )
444 ber_free LDAP_P((
445  BerElement *ber,
446  int freebuf ));
447 
448 LBER_F( void )
449 ber_free_buf LDAP_P(( BerElement *ber ));
450 
451 LBER_F( int )
452 ber_flush2 LDAP_P((
453  Sockbuf *sb,
454  BerElement *ber,
455  int freeit ));
456 #define LBER_FLUSH_FREE_NEVER (0x0) /* traditional behavior */
457 #define LBER_FLUSH_FREE_ON_SUCCESS (0x1) /* traditional behavior */
458 #define LBER_FLUSH_FREE_ON_ERROR (0x2)
459 #define LBER_FLUSH_FREE_ALWAYS (LBER_FLUSH_FREE_ON_SUCCESS|LBER_FLUSH_FREE_ON_ERROR)
460 
461 LBER_F( int )
462 ber_flush LDAP_P((
463  Sockbuf *sb,
464  BerElement *ber,
465  int freeit )); /* DEPRECATED */
466 
467 LBER_F( BerElement * )
468 ber_alloc LDAP_P(( void )); /* DEPRECATED */
469 
470 LBER_F( BerElement * )
471 der_alloc LDAP_P(( void )); /* DEPRECATED */
472 
473 LBER_F( BerElement * )
474 ber_alloc_t LDAP_P((
475  int beroptions ));
476 
477 LBER_F( BerElement * )
478 ber_dup LDAP_P((
479  BerElement *ber ));
480 
481 LBER_F( ber_tag_t )
482 ber_get_next LDAP_P((
483  Sockbuf *sb,
484  ber_len_t *len,
485  BerElement *ber ));
486 
487 LBER_F( void )
488 ber_init2 LDAP_P((
489  BerElement *ber,
490  struct berval *bv,
491  int options ));
492 
493 LBER_F( void )
494 ber_init_w_nullc LDAP_P(( /* DEPRECATED */
495  BerElement *ber,
496  int options ));
497 
498 LBER_F( void )
499 ber_reset LDAP_P((
500  BerElement *ber,
501  int was_writing ));
502 
503 LBER_F( BerElement * )
504 ber_init LDAP_P((
505  struct berval *bv ));
506 
507 LBER_F( int )
508 ber_flatten LDAP_P((
509  BerElement *ber,
510  struct berval **bvPtr ));
511 
512 LBER_F( int )
513 ber_flatten2 LDAP_P((
514  BerElement *ber,
515  struct berval *bv,
516  int alloc ));
517 
518 LBER_F( int )
519 ber_remaining LDAP_P((
520  BerElement *ber ));
521 
522 /*
523  * LBER ber accessor functions
524  */
525 
526 LBER_F( int )
527 ber_get_option LDAP_P((
528  void *item,
529  int option,
530  void *outvalue));
531 
532 LBER_F( int )
533 ber_set_option LDAP_P((
534  void *item,
535  int option,
536  LDAP_CONST void *invalue));
537 
538 /*
539  * LBER sockbuf.c
540  */
541 
542 LBER_F( Sockbuf * )
543 ber_sockbuf_alloc LDAP_P((
544  void ));
545 
546 LBER_F( void )
547 ber_sockbuf_free LDAP_P((
548  Sockbuf *sb ));
549 
550 LBER_F( int )
551 ber_sockbuf_add_io LDAP_P((
552  Sockbuf *sb,
553  Sockbuf_IO *sbio,
554  int layer,
555  void *arg ));
556 
557 LBER_F( int )
558 ber_sockbuf_remove_io LDAP_P((
559  Sockbuf *sb,
560  Sockbuf_IO *sbio,
561  int layer ));
562 
563 LBER_F( int )
564 ber_sockbuf_ctrl LDAP_P((
565  Sockbuf *sb,
566  int opt,
567  void *arg ));
568 
569 LBER_V( Sockbuf_IO ) ber_sockbuf_io_tcp;
570 LBER_V( Sockbuf_IO ) ber_sockbuf_io_readahead;
571 LBER_V( Sockbuf_IO ) ber_sockbuf_io_fd;
572 LBER_V( Sockbuf_IO ) ber_sockbuf_io_debug;
573 LBER_V( Sockbuf_IO ) ber_sockbuf_io_udp;
574 
575 /*
576  * LBER memory.c
577  */
578 LBER_F( void * )
579 ber_memalloc LDAP_P((
580  ber_len_t s ));
581 
582 LBER_F( void * )
583 ber_memrealloc LDAP_P((
584  void* p,
585  ber_len_t s ));
586 
587 LBER_F( void * )
588 ber_memcalloc LDAP_P((
589  ber_len_t n,
590  ber_len_t s ));
591 
592 LBER_F( void )
593 ber_memfree LDAP_P((
594  void* p ));
595 
596 LBER_F( void )
597 ber_memvfree LDAP_P((
598  void** vector ));
599 
600 LBER_F( void )
601 ber_bvfree LDAP_P((
602  struct berval *bv ));
603 
604 LBER_F( void )
605 ber_bvecfree LDAP_P((
606  struct berval **bv ));
607 
608 LBER_F( int )
609 ber_bvecadd LDAP_P((
610  struct berval ***bvec,
611  struct berval *bv ));
612 
613 LBER_F( struct berval * )
614 ber_dupbv LDAP_P((
615  struct berval *dst, struct berval *src ));
616 
617 LBER_F( struct berval * )
618 ber_bvdup LDAP_P((
619  struct berval *src ));
620 
621 LBER_F( struct berval * )
622 ber_mem2bv LDAP_P((
623  LDAP_CONST char *, ber_len_t len, int duplicate, struct berval *bv));
624 
625 LBER_F( struct berval * )
626 ber_str2bv LDAP_P((
627  LDAP_CONST char *, ber_len_t len, int duplicate, struct berval *bv));
628 
629 #define ber_bvstr(a) ((ber_str2bv)((a), 0, 0, NULL))
630 #define ber_bvstrdup(a) ((ber_str2bv)((a), 0, 1, NULL))
631 
632 LBER_F( char * )
633 ber_strdup LDAP_P((
634  LDAP_CONST char * ));
635 
636 LBER_F( struct berval * )
637 ber_bvreplace LDAP_P((
638  struct berval *dst, LDAP_CONST struct berval *src ));
639 
640 LBER_F( void )
641 ber_bvarray_free LDAP_P(( BerVarray p ));
642 
643 LBER_F( int )
644 ber_bvarray_add LDAP_P(( BerVarray *p, BerValue *bv ));
645 
646 #define ber_bvcmp(v1,v2) \
647  ((v1)->bv_len < (v2)->bv_len \
648  ? -1 : ((v1)->bv_len > (v2)->bv_len \
649  ? 1 : memcmp((v1)->bv_val, (v2)->bv_val, (v1)->bv_len) ))
650 
651 /*
652  * error.c
653  */
654 LBER_F( int * ) ber_errno_addr LDAP_P((void));
655 #define ber_errno (*(ber_errno_addr)())
656 
657 #define LBER_ERROR_NONE 0
658 #define LBER_ERROR_PARAM 0x1
659 #define LBER_ERROR_MEMORY 0x2
660 
661 LDAP_END_DECL
662 
663 #endif /* _LBER_H */
Definition: lber-int.h:104
Definition: lber.h:212
Definition: lber.h:121
Definition: lber-int.h:123
Definition: lber.h:177
Definition: lber.h:186
Definition: lber-int.h:75