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