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