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

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