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