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