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_FN              0x8002
 102
 103 typedef void (*BER_LOG_PRINT_FN) LDAP_P(( char *buf ));
 104 typedef void* (*BER_MEMORY_FN) LDAP_P(( void *p, size_t size ));
 105
 106 /* LBER Sockbuf options */
 107 #define LBER_TO_FILE           0x01     /* to a file referenced by sb_fd   */
 108 #define LBER_TO_FILE_ONLY      0x02     /* only write to file, not network */
 109 #define LBER_MAX_INCOMING_SIZE 0x04     /* impose limit on incoming stuff  */
 110 #define LBER_NO_READ_AHEAD     0x08     /* read only as much as requested  */
 111
 112 /* get/set options for Sockbuf */
 113 #define LBER_OPT_SOCKBUF_DESC           0x1000
 114 #define LBER_OPT_SOCKBUF_OPTIONS        0x1001
 115 #define LBER_OPT_SOCKBUF_DEBUG          0x1002
 116
 117 /* on/off values */
 118 #define LBER_OPT_ON             ((void *) 1)
 119 #define LBER_OPT_OFF    ((void *) 0)
 120
 121 #define LBER_OPT_SUCCESS        0
 122 #define LBER_OPT_ERROR          (-1)
 123
 124 typedef struct berelement BerElement;
 125 typedef struct sockbuf Sockbuf;
 126 typedef struct seqorset Seqorset;
 127
 128 /* structure for returning a sequence of octet strings + length */
 129 typedef struct berval {
 130         unsigned long   bv_len;
 131         char            *bv_val;
 132 } BerValue;
 133
 134 /*
 135  * in bprint.c:
 136  */
 137 LDAP_F( void )
 138 ber_print_error LDAP_P((
 139         LDAP_CONST char *data ));
 140
 141 LDAP_F( void )
 142 ber_bprint LDAP_P((
 143         LDAP_CONST char *data, int len ));
 144
 145 LDAP_F( void )
 146 ber_dump LDAP_P((
 147         LDAP_CONST BerElement *ber, int inout ));
 148
 149 LDAP_F( void )
 150 ber_sos_dump LDAP_P((
 151         LDAP_CONST Seqorset *sos ));
 152
 153
 154 /*
 155  * in decode.c:
 156  */
 157 typedef int (*BERDecodeCallback) LDAP_P((
 158         BerElement *ber,
 159         void *data,
 160         int mode ));
 161
 162 LDAP_F( unsigned long )
 163 ber_get_tag LDAP_P((
 164         BerElement *ber ));
 165
 166 LDAP_F( unsigned long )
 167 ber_skip_tag LDAP_P((
 168         BerElement *ber,
 169         unsigned long *len ));
 170
 171 LDAP_F( unsigned long )
 172 ber_peek_tag LDAP_P((
 173         LDAP_CONST BerElement *ber,
 174         unsigned long *len ));
 175
 176 LDAP_F( unsigned long )
 177 ber_get_int LDAP_P((
 178         BerElement *ber,
 179         long *num ));
 180
 181 LDAP_F( unsigned long )
 182 ber_get_stringb LDAP_P((
 183         BerElement *ber,
 184         char *buf,
 185         unsigned long *len ));
 186
 187 LDAP_F( unsigned long )
 188 ber_get_stringa LDAP_P((
 189         BerElement *ber, char **buf ));
 190
 191 LDAP_F( unsigned long )
 192 ber_get_stringal LDAP_P((
 193         BerElement *ber,
 194         struct berval **bv ));
 195
 196 LDAP_F( unsigned long )
 197 ber_get_bitstringa LDAP_P((
 198         BerElement *ber,
 199         char **buf,
 200         unsigned long *len ));
 201
 202 LDAP_F( unsigned long )
 203 ber_get_null LDAP_P((
 204         BerElement *ber ));
 205
 206 LDAP_F( unsigned long )
 207 ber_get_boolean LDAP_P((
 208         BerElement *ber,
 209         int *boolval ));
 210
 211 LDAP_F( unsigned long )
 212 ber_first_element LDAP_P((
 213         BerElement *ber,
 214         unsigned long *len,
 215         char **last ));
 216
 217 LDAP_F( unsigned long )
 218 ber_next_element LDAP_P((
 219         BerElement *ber,
 220         unsigned long *len,
 221         char *last ));
 222
 223 LDAP_F( unsigned long )
 224 ber_scanf LDAP_P((
 225         BerElement *ber,
 226         LDAP_CONST char *fmt,
 227         ... ));
 228
 229 LDAP_F( void )
 230 ber_bvfree LDAP_P((
 231         struct berval *bv ));
 232
 233 LDAP_F( void )
 234 ber_bvecfree LDAP_P((
 235         struct berval **bv ));
 236
 237 LDAP_F( struct berval * )
 238 ber_bvdup LDAP_P((
 239         LDAP_CONST struct berval *bv ));
 240
 241 LDAP_F( void )
 242 ber_set_string_translators LDAP_P((
 243         BerElement *ber,
 244         BERTranslateProc encode_proc,
 245         BERTranslateProc decode_proc ));
 246
 247 /*
 248  * in encode.c
 249  */
 250 typedef int (*BEREncodeCallback) LDAP_P((
 251         BerElement *ber,
 252         void *data ));
 253
 254 LDAP_F( int )
 255 ber_put_enum LDAP_P((
 256         BerElement *ber,
 257         long num,
 258         unsigned long tag ));
 259
 260 LDAP_F( int )
 261 ber_put_int LDAP_P((
 262         BerElement *ber,
 263         long num,
 264         unsigned long tag ));
 265
 266 LDAP_F( int )
 267 ber_put_ostring LDAP_P((
 268         BerElement *ber,
 269         LDAP_CONST char *str,
 270         unsigned long len,
 271         unsigned long tag ));
 272
 273 LDAP_F( int )
 274 ber_put_berval LDAP_P((
 275         BerElement *ber,
 276         LDAP_CONST struct berval *bv,
 277         unsigned long tag ));
 278
 279 LDAP_F( int )
 280 ber_put_string LDAP_P((
 281         BerElement *ber,
 282         LDAP_CONST char *str,
 283         unsigned long tag ));
 284
 285 LDAP_F( int )
 286 ber_put_bitstring LDAP_P((
 287         BerElement *ber,
 288         LDAP_CONST char *str,
 289         unsigned long bitlen,
 290         unsigned long tag ));
 291
 292 LDAP_F( int )
 293 ber_put_null LDAP_P((
 294         BerElement *ber,
 295         unsigned long tag ));
 296
 297 LDAP_F( int )
 298 ber_put_boolean LDAP_P((
 299         BerElement *ber,
 300         int boolval,
 301         unsigned long tag ));
 302
 303 LDAP_F( int )
 304 ber_start_seq LDAP_P((
 305         BerElement *ber,
 306         unsigned long tag ));
 307
 308 LDAP_F( int )
 309 ber_start_set LDAP_P((
 310         BerElement *ber,
 311         unsigned long tag ));
 312
 313 LDAP_F( int )
 314 ber_put_seq LDAP_P((
 315         BerElement *ber ));
 316
 317 LDAP_F( int )
 318 ber_put_set LDAP_P((
 319         BerElement *ber ));
 320
 321 LDAP_F( int )
 322 ber_printf LDAP_P((
 323         BerElement *ber,
 324         LDAP_CONST char *fmt,
 325         ... ));
 326 /*
 327  * in io.c:
 328  */
 329
 330 LDAP_F( long )
 331 ber_read LDAP_P((
 332         BerElement *ber,
 333         char *buf,
 334         unsigned long len ));
 335
 336 LDAP_F( long )
 337 ber_write LDAP_P((
 338         BerElement *ber,
 339         LDAP_CONST char *buf,
 340         unsigned long len,
 341         int nosos ));
 342
 343 LDAP_F( void )
 344 ber_free LDAP_P((
 345         BerElement *ber,
 346         int freebuf ));
 347
 348 LDAP_F( void )
 349 ber_clear LDAP_P((
 350         BerElement *ber,
 351         int freebuf ));
 352
 353 LDAP_F( int )
 354 ber_flush LDAP_P((
 355         Sockbuf *sb, BerElement *ber, int freeit ));
 356
 357 LDAP_F( BerElement * )
 358 ber_alloc LDAP_P(( void )); /* DEPRECATED */
 359
 360 LDAP_F( BerElement * )
 361 der_alloc LDAP_P(( void )); /* DEPRECATED */
 362
 363 LDAP_F( BerElement * )
 364 ber_alloc_t LDAP_P((
 365         int beroptions ));
 366
 367 LDAP_F( BerElement * )
 368 ber_dup LDAP_P((
 369         LDAP_CONST BerElement *ber ));
 370
 371 LDAP_F( unsigned long )
 372 ber_get_next LDAP_P((
 373         Sockbuf *sb,
 374         unsigned long *len,
 375         BerElement *ber ));
 376
 377 LDAP_F( void )
 378 ber_init_w_nullc LDAP_P((
 379         BerElement *ber,
 380         int options ));
 381
 382 LDAP_F( void )
 383 ber_reset LDAP_P((
 384         BerElement *ber,
 385         int was_writing ));
 386
 387 /*
 388  * LBER draft-ietf-ldapext-ldap-c-api-01 routines
 389  */
 390 LDAP_F( BerElement * )
 391 ber_init LDAP_P((
 392         struct berval *bv ));
 393
 394 LDAP_F( int )
 395 ber_flatten LDAP_P((
 396         LDAP_CONST BerElement *ber,
 397         struct berval **bvPtr ));
 398
 399 /*
 400  * LBER ber accessor functions
 401  */
 402
 403 LDAP_F( int )
 404 ber_get_option LDAP_P((
 405         void *item,
 406         int option,
 407         void *outvalue));
 408
 409 LDAP_F( int )
 410 ber_set_option LDAP_P((
 411         void *item,
 412         int option,
 413         LDAP_CONST void *invalue));
 414
 415 /*
 416  * LBER sockbuf.c
 417  */
 418
 419 LDAP_F( Sockbuf * )
 420 ber_sockbuf_alloc( void );
 421
 422 LDAP_F( Sockbuf *  )
 423 ber_sockbuf_alloc_fd(
 424         int fd );
 425
 426 LDAP_F( void )
 427 ber_sockbuf_free(
 428         Sockbuf *sb );
 429
 430 /*
 431  * LBER memory.c
 432  */
 433 LDAP_F( void * )
 434 ber_memalloc LDAP_P((
 435         size_t s ));
 436
 437 LDAP_F( void * )
 438 ber_memrealloc LDAP_P((
 439         void* p,
 440         size_t s ));
 441
 442 LDAP_F( void * )
 443 ber_memcalloc LDAP_P((
 444         size_t n,
 445         size_t s ));
 446
 447 LDAP_F( void )
 448 ber_memfree LDAP_P((
 449         void* p ));
 450
 451 LDAP_END_DECL
 452
 453 #endif /* _LBER_H */