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