git.sur5r.net Git - openldap/blob - include/lber.h

   1 /*
   2  * Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted only
   6  * as authorized by the OpenLDAP Public License.  A copy of this
   7  * license is available at http://www.OpenLDAP.org/license.html or
   8  * in file LICENSE in the top-level directory of the distribution.
   9  */
  10 /* Portions
  11  * Copyright (c) 1990 Regents of the University of Michigan.
  12  * All rights reserved.
  13  *
  14  * Redistribution and use in source and binary forms are permitted
  15  * provided that this notice is preserved and that due credit is given
  16  * to the University of Michigan at Ann Arbor. The name of the University
  17  * may not be used to endorse or promote products derived from this
  18  * software without specific prior written permission. This software
  19  * is provided ``as is'' without express or implied warranty.
  20  */
  21
  22 #ifndef _LBER_H
  23 #define _LBER_H
  24
  25 #include <ldap_cdefs.h>
  26
  27 LDAP_BEGIN_DECL
  28
  29 /* Overview of LBER tag construction
  30  *
  31  *      Bits
  32  *      ______
  33  *      8 7 | CLASS
  34  *      0 0 = UNIVERSAL
  35  *      0 1 = APPLICATION
  36  *      1 0 = CONTEXT-SPECIFIC
  37  *      1 1 = PRIVATE
  38  *              _____
  39  *              | 6 | DATA-TYPE
  40  *                0 = PRIMITIVE
  41  *                1 = CONSTRUCTED
  42  *                      ___________
  43  *                      | 5 ... 1 | TAG-NUMBER
  44  */
  45
  46 /* BER classes and mask */
  47 #define LBER_CLASS_UNIVERSAL    0x00UL
  48 #define LBER_CLASS_APPLICATION  0x40UL
  49 #define LBER_CLASS_CONTEXT      0x80UL
  50 #define LBER_CLASS_PRIVATE      0xc0UL
  51 #define LBER_CLASS_MASK         0xc0UL
  52
  53 /* BER encoding type and mask */
  54 #define LBER_PRIMITIVE          0x00UL
  55 #define LBER_CONSTRUCTED        0x20UL
  56 #define LBER_ENCODING_MASK      0x20UL
  57
  58 #define LBER_BIG_TAG_MASK       0x1fUL
  59 #define LBER_MORE_TAG_MASK      0x80UL
  60
  61 /*
  62  * Note that LBER_ERROR and LBER_DEFAULT are values that can never appear
  63  * as valid BER tags, and so it is safe to use them to report errors.  In
  64  * fact, any tag for which the following is true is invalid:
  65  *     (( tag & 0x00000080 ) != 0 ) && (( tag & 0xFFFFFF00 ) != 0 )
  66  */
  67 #define LBER_INVALID(tag) ( ( (tag) & 0xFFFFFF80UL ) != 0 )
  68 #define LBER_ERROR              0xffffffffUL
  69 #define LBER_DEFAULT            0xffffffffUL
  70
  71 /* general BER types we know about */
  72 #define LBER_BOOLEAN            0x01UL
  73 #define LBER_INTEGER            0x02UL
  74 #define LBER_BITSTRING          0x03UL
  75 #define LBER_OCTETSTRING        0x04UL
  76 #define LBER_NULL               0x05UL
  77 #define LBER_ENUMERATED         0x0aUL
  78 #define LBER_SEQUENCE           0x30UL  /* constructed */
  79 #define LBER_SET                0x31UL  /* constructed */
  80
  81 #define OLD_LBER_SEQUENCE       0x10UL  /* w/o constructed bit - broken */
  82 #define OLD_LBER_SET            0x11UL  /* w/o constructed bit - broken */
  83
  84 typedef int (*BERTranslateProc) LDAP_P((
  85         char **bufp,
  86         unsigned long *buflenp,
  87         int free_input ));
  88
  89 /* LBER BerElement options */
  90 #define LBER_USE_DER            0x01
  91 #define LBER_USE_INDEFINITE_LEN 0x02
  92 #define LBER_TRANSLATE_STRINGS  0x04
  93
  94 /* get/set options for BerElement */
  95 #define LBER_OPT_BER_OPTIONS    0x01
  96 #define LBER_OPT_BER_DEBUG              0x02
  97
  98 #define LBER_OPT_DEBUG_LEVEL    LBER_OPT_BER_DEBUG
  99
 100 #define LBER_OPT_LOG_PRINT_FN   0x8001
 101 #define LBER_OPT_MEMORY_FNS             0x8002
 102
 103 typedef void (*BER_LOG_PRINT_FN) LDAP_P(( char *buf ));
 104
 105 typedef void* (*BER_MEMALLOC_FN)        LDAP_P(( size_t size ));
 106 typedef void* (*BER_MEMCALLOC_FN)       LDAP_P(( size_t n, size_t size ));
 107 typedef void* (*BER_MEMREALLOC_FN)      LDAP_P(( void *p, size_t size ));
 108 typedef void  (*BER_MEMFREE_FN)         LDAP_P(( void *p ));
 109
 110 typedef struct lber_memory_fns {
 111         BER_MEMALLOC_FN bmf_malloc;
 112         BER_MEMCALLOC_FN bmf_calloc;
 113         BER_MEMREALLOC_FN bmf_realloc;
 114         BER_MEMFREE_FN bmf_free;
 115 } BerMemoryFunctions;
 116
 117 /* LBER Sockbuf options */
 118 #define LBER_TO_FILE           0x01     /* to a file referenced by sb_fd   */
 119 #define LBER_TO_FILE_ONLY      0x02     /* only write to file, not network */
 120 #define LBER_MAX_INCOMING_SIZE 0x04     /* impose limit on incoming stuff  */
 121 #define LBER_NO_READ_AHEAD     0x08     /* read only as much as requested  */
 122
 123 /* get/set options for Sockbuf */
 124 #define LBER_OPT_SOCKBUF_DESC           0x1000
 125 #define LBER_OPT_SOCKBUF_OPTIONS        0x1001
 126 #define LBER_OPT_SOCKBUF_DEBUG          0x1002
 127
 128 /* on/off values */
 129 #define LBER_OPT_ON             ((void *) 1)
 130 #define LBER_OPT_OFF    ((void *) 0)
 131
 132 #define LBER_OPT_SUCCESS        0
 133 #define LBER_OPT_ERROR          (-1)
 134
 135 typedef struct berelement BerElement;
 136 typedef struct sockbuf Sockbuf;
 137 typedef struct seqorset Seqorset;
 138
 139 /* structure for returning a sequence of octet strings + length */
 140 typedef struct berval {
 141         unsigned long   bv_len;
 142         char            *bv_val;
 143 } BerValue;
 144
 145 /*
 146  * in bprint.c:
 147  */
 148 LDAP_F( void )
 149 ber_print_error LDAP_P((
 150         LDAP_CONST char *data ));
 151
 152 LDAP_F( void )
 153 ber_bprint LDAP_P((
 154         LDAP_CONST char *data, int len ));
 155
 156 LDAP_F( void )
 157 ber_dump LDAP_P((
 158         LDAP_CONST BerElement *ber, int inout ));
 159
 160 LDAP_F( void )
 161 ber_sos_dump LDAP_P((
 162         LDAP_CONST Seqorset *sos ));
 163
 164
 165 /*
 166  * in decode.c:
 167  */
 168 typedef int (*BERDecodeCallback) LDAP_P((
 169         BerElement *ber,
 170         void *data,
 171         int mode ));
 172
 173 LDAP_F( unsigned long )
 174 ber_get_tag LDAP_P((
 175         BerElement *ber ));
 176
 177 LDAP_F( unsigned long )
 178 ber_skip_tag LDAP_P((
 179         BerElement *ber,
 180         unsigned long *len ));
 181
 182 LDAP_F( unsigned long )
 183 ber_peek_tag LDAP_P((
 184         LDAP_CONST BerElement *ber,
 185         unsigned long *len ));
 186
 187 LDAP_F( unsigned long )
 188 ber_get_int LDAP_P((
 189         BerElement *ber,
 190         long *num ));
 191
 192 LDAP_F( unsigned long )
 193 ber_get_stringb LDAP_P((
 194         BerElement *ber,
 195         char *buf,
 196         unsigned long *len ));
 197
 198 LDAP_F( unsigned long )
 199 ber_get_stringa LDAP_P((
 200         BerElement *ber, char **buf ));
 201
 202 LDAP_F( unsigned long )
 203 ber_get_stringal LDAP_P((
 204         BerElement *ber,
 205         struct berval **bv ));
 206
 207 LDAP_F( unsigned long )
 208 ber_get_bitstringa LDAP_P((
 209         BerElement *ber,
 210         char **buf,
 211         unsigned long *len ));
 212
 213 LDAP_F( unsigned long )
 214 ber_get_null LDAP_P((
 215         BerElement *ber ));
 216
 217 LDAP_F( unsigned long )
 218 ber_get_boolean LDAP_P((
 219         BerElement *ber,
 220         int *boolval ));
 221
 222 LDAP_F( unsigned long )
 223 ber_first_element LDAP_P((
 224         BerElement *ber,
 225         unsigned long *len,
 226         char **last ));
 227
 228 LDAP_F( unsigned long )
 229 ber_next_element LDAP_P((
 230         BerElement *ber,
 231         unsigned long *len,
 232         char *last ));
 233
 234 LDAP_F( unsigned long )
 235 ber_scanf LDAP_P((
 236         BerElement *ber,
 237         LDAP_CONST char *fmt,
 238         ... ));
 239
 240 LDAP_F( void )
 241 ber_set_string_translators LDAP_P((
 242         BerElement *ber,
 243         BERTranslateProc encode_proc,
 244         BERTranslateProc decode_proc ));
 245
 246 /*
 247  * in encode.c
 248  */
 249 typedef int (*BEREncodeCallback) LDAP_P((
 250         BerElement *ber,
 251         void *data ));
 252
 253 LDAP_F( int )
 254 ber_put_enum LDAP_P((
 255         BerElement *ber,
 256         long num,
 257         unsigned long tag ));
 258
 259 LDAP_F( int )
 260 ber_put_int LDAP_P((
 261         BerElement *ber,
 262         long num,
 263         unsigned long tag ));
 264
 265 LDAP_F( int )
 266 ber_put_ostring LDAP_P((
 267         BerElement *ber,
 268         LDAP_CONST char *str,
 269         unsigned long len,
 270         unsigned long tag ));
 271
 272 LDAP_F( int )
 273 ber_put_berval LDAP_P((
 274         BerElement *ber,
 275         LDAP_CONST struct berval *bv,
 276         unsigned long tag ));
 277
 278 LDAP_F( int )
 279 ber_put_string LDAP_P((
 280         BerElement *ber,
 281         LDAP_CONST char *str,
 282         unsigned long tag ));
 283
 284 LDAP_F( int )
 285 ber_put_bitstring LDAP_P((
 286         BerElement *ber,
 287         LDAP_CONST char *str,
 288         unsigned long bitlen,
 289         unsigned long tag ));
 290
 291 LDAP_F( int )
 292 ber_put_null LDAP_P((
 293         BerElement *ber,
 294         unsigned long tag ));
 295
 296 LDAP_F( int )
 297 ber_put_boolean LDAP_P((
 298         BerElement *ber,
 299         int boolval,
 300         unsigned long tag ));
 301
 302 LDAP_F( int )
 303 ber_start_seq LDAP_P((
 304         BerElement *ber,
 305         unsigned long tag ));
 306
 307 LDAP_F( int )
 308 ber_start_set LDAP_P((
 309         BerElement *ber,
 310         unsigned long tag ));
 311
 312 LDAP_F( int )
 313 ber_put_seq LDAP_P((
 314         BerElement *ber ));
 315
 316 LDAP_F( int )
 317 ber_put_set LDAP_P((
 318         BerElement *ber ));
 319
 320 LDAP_F( int )
 321 ber_printf LDAP_P((
 322         BerElement *ber,
 323         LDAP_CONST char *fmt,
 324         ... ));
 325 /*
 326  * in io.c:
 327  */
 328
 329 LDAP_F( long )
 330 ber_read LDAP_P((
 331         BerElement *ber,
 332         char *buf,
 333         unsigned long len ));
 334
 335 LDAP_F( long )
 336 ber_write LDAP_P((
 337         BerElement *ber,
 338         LDAP_CONST char *buf,
 339         unsigned long len,
 340         int nosos ));
 341
 342 LDAP_F( void )
 343 ber_free LDAP_P((
 344         BerElement *ber,
 345         int freebuf ));
 346
 347 LDAP_F( int )
 348 ber_flush LDAP_P((
 349         Sockbuf *sb, BerElement *ber, int freeit ));
 350
 351 LDAP_F( BerElement * )
 352 ber_alloc LDAP_P(( void )); /* DEPRECATED */
 353
 354 LDAP_F( BerElement * )
 355 der_alloc LDAP_P(( void )); /* DEPRECATED */
 356
 357 LDAP_F( BerElement * )
 358 ber_alloc_t LDAP_P((
 359         int beroptions ));
 360
 361 LDAP_F( BerElement * )
 362 ber_dup LDAP_P((
 363         LDAP_CONST BerElement *ber ));
 364
 365 LDAP_F( unsigned long )
 366 ber_get_next LDAP_P((
 367         Sockbuf *sb,
 368         unsigned long *len,
 369         BerElement *ber ));
 370
 371 LDAP_F( void )
 372 ber_init_w_nullc LDAP_P((
 373         BerElement *ber,
 374         int options ));
 375
 376 LDAP_F( void )
 377 ber_reset LDAP_P((
 378         BerElement *ber,
 379         int was_writing ));
 380
 381 /*
 382  * LBER draft-ietf-ldapext-ldap-c-api-01 routines
 383  */
 384 LDAP_F( BerElement * )
 385 ber_init LDAP_P((
 386         struct berval *bv ));
 387
 388 LDAP_F( int )
 389 ber_flatten LDAP_P((
 390         LDAP_CONST BerElement *ber,
 391         struct berval **bvPtr ));
 392
 393 /*
 394  * LBER ber accessor functions
 395  */
 396
 397 LDAP_F( int )
 398 ber_get_option LDAP_P((
 399         void *item,
 400         int option,
 401         void *outvalue));
 402
 403 LDAP_F( int )
 404 ber_set_option LDAP_P((
 405         void *item,
 406         int option,
 407         LDAP_CONST void *invalue));
 408
 409 /*
 410  * LBER sockbuf.c
 411  */
 412
 413 LDAP_F( Sockbuf * )
 414 ber_sockbuf_alloc( void );
 415
 416 LDAP_F( Sockbuf *  )
 417 ber_sockbuf_alloc_fd(
 418         int fd );
 419
 420 LDAP_F( void )
 421 ber_sockbuf_free(
 422         Sockbuf *sb );
 423
 424 /*
 425  * LBER memory.c
 426  */
 427 LDAP_F( void * )
 428 ber_memalloc LDAP_P((
 429         size_t s ));
 430
 431 LDAP_F( void * )
 432 ber_memrealloc LDAP_P((
 433         void* p,
 434         size_t s ));
 435
 436 LDAP_F( void * )
 437 ber_memcalloc LDAP_P((
 438         size_t n,
 439         size_t s ));
 440
 441 LDAP_F( void )
 442 ber_memfree LDAP_P((
 443         void* p ));
 444
 445 LDAP_F( void )
 446 ber_memvfree LDAP_P((
 447         void** vector ));
 448
 449 LDAP_F( void )
 450 ber_bvfree LDAP_P((
 451         struct berval *bv ));
 452
 453 LDAP_F( void )
 454 ber_bvecfree LDAP_P((
 455         struct berval **bv ));
 456
 457 LDAP_F( struct berval * )
 458 ber_bvdup LDAP_P((
 459         LDAP_CONST struct berval *bv ));
 460
 461 LDAP_END_DECL
 462
 463 #endif /* _LBER_H */