home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ldapsdk.zip / include / lber.h < prev    next >
C/C++ Source or Header  |  2001-06-02  |  12KB  |  574 lines
  1. /* $OpenLDAP: pkg/ldap/include/lber.h,v 1.32.6.8 2001/06/02 00:33:02 kurt Exp $ */
  2. /*
  3.  * Copyright 1998-2001 The OpenLDAP Foundation, Redwood City, California, USA
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted only as authorized by the OpenLDAP
  8.  * Public License.  A copy of this license is available at
  9.  * http://www.OpenLDAP.org/license.html or in file LICENSE in the
  10.  * top-level directory of the distribution.
  11.  */
  12. /* Portions
  13.  * Copyright (c) 1990 Regents of the University of Michigan.
  14.  * All rights reserved.
  15.  *
  16.  * Redistribution and use in source and binary forms are permitted
  17.  * provided that this notice is preserved and that due credit is given
  18.  * to the University of Michigan at Ann Arbor. The name of the University
  19.  * may not be used to endorse or promote products derived from this
  20.  * software without specific prior written permission. This software
  21.  * is provided ``as is'' without express or implied warranty.
  22.  */
  23.  
  24. #ifndef _LBER_H
  25. #define _LBER_H
  26.  
  27. #include <lber_types.h>
  28.  
  29. LDAP_BEGIN_DECL
  30.  
  31. /* Overview of LBER tag construction
  32.  *
  33.  *    Bits
  34.  *    ______
  35.  *    8 7 | CLASS
  36.  *    0 0 = UNIVERSAL
  37.  *    0 1 = APPLICATION
  38.  *    1 0 = CONTEXT-SPECIFIC
  39.  *    1 1 = PRIVATE
  40.  *        _____
  41.  *        | 6 | DATA-TYPE
  42.  *          0 = PRIMITIVE
  43.  *          1 = CONSTRUCTED
  44.  *            ___________
  45.  *            | 5 ... 1 | TAG-NUMBER
  46.  */
  47.  
  48. /* BER classes and mask */
  49. #define LBER_CLASS_UNIVERSAL    ((ber_tag_t) 0x00U)
  50. #define LBER_CLASS_APPLICATION    ((ber_tag_t) 0x40U)
  51. #define LBER_CLASS_CONTEXT        ((ber_tag_t) 0x80U)
  52. #define LBER_CLASS_PRIVATE        ((ber_tag_t) 0xc0U)
  53. #define LBER_CLASS_MASK            ((ber_tag_t) 0xc0U)
  54.  
  55. /* BER encoding type and mask */
  56. #define LBER_PRIMITIVE            ((ber_tag_t) 0x00U)
  57. #define LBER_CONSTRUCTED        ((ber_tag_t) 0x20U)
  58. #define LBER_ENCODING_MASK        ((ber_tag_t) 0x20U)
  59.  
  60. #define LBER_BIG_TAG_MASK        ((ber_tag_t) 0x1fU)
  61. #define LBER_MORE_TAG_MASK        ((ber_tag_t) 0x80U)
  62.  
  63. /*
  64.  * Note that LBER_ERROR and LBER_DEFAULT are values that can never appear
  65.  * as valid BER tags, and so it is safe to use them to report errors.  In
  66.  * fact, any tag for which the following is true is invalid:
  67.  */
  68. #define LBER_INVALID(t)     (((t) & (ber_tag_t) 0x080UL) \
  69.     && (((t) & (ber_tag_t) ~ 0x0FF))
  70.  
  71. #define LBER_ERROR            ((ber_tag_t) -1)
  72. #define LBER_DEFAULT        ((ber_tag_t) -1)
  73.  
  74. /* general BER types we know about */
  75. #define LBER_BOOLEAN        ((ber_tag_t) 0x01UL)
  76. #define LBER_INTEGER        ((ber_tag_t) 0x02UL)
  77. #define LBER_BITSTRING        ((ber_tag_t) 0x03UL)
  78. #define LBER_OCTETSTRING    ((ber_tag_t) 0x04UL)
  79. #define LBER_NULL            ((ber_tag_t) 0x05UL)
  80. #define LBER_ENUMERATED        ((ber_tag_t) 0x0aUL)
  81. #define LBER_SEQUENCE        ((ber_tag_t) 0x30UL)    /* constructed */
  82. #define LBER_SET            ((ber_tag_t) 0x31UL)    /* constructed */
  83.  
  84. /* LBER BerElement options */
  85. #define LBER_USE_DER        0x01
  86. #define LBER_USE_INDEFINITE_LEN    0x02
  87.  
  88. /* get/set options for BerElement */
  89. #define LBER_OPT_BER_OPTIONS            0x01
  90. #define LBER_OPT_BER_DEBUG                0x02
  91. #define LBER_OPT_BER_REMAINING_BYTES    0x03
  92. #define LBER_OPT_BER_TOTAL_BYTES        0x04
  93. #define LBER_OPT_BER_BYTES_TO_WRITE        0x05
  94.  
  95. #define LBER_OPT_DEBUG_LEVEL    LBER_OPT_BER_DEBUG
  96. #define LBER_OPT_REMAINING_BYTES    LBER_OPT_BER_REMAINING_BYTES
  97. #define LBER_OPT_TOTAL_BYTES        LBER_OPT_BER_TOTAL_BYTES
  98. #define LBER_OPT_BYTES_TO_WRITE        LBER_OPT_BER_BYTES_TO_WRITE
  99.  
  100. #define LBER_OPT_LOG_PRINT_FN    0x8001
  101. #define LBER_OPT_MEMORY_FNS        0x8002
  102. #define LBER_OPT_ERROR_FN        0x8003
  103. #define LBER_OPT_LOG_PRINT_FILE        0x8004
  104.  
  105. /* get/set Memory Debug options */
  106. #define LBER_OPT_MEMORY_INUSE        0x8005    /* for memory debugging */
  107.  
  108. typedef int* (*BER_ERRNO_FN) LDAP_P(( void ));
  109.  
  110. typedef void (*BER_LOG_PRINT_FN) LDAP_P(( LDAP_CONST char *buf ));
  111.  
  112. typedef void* (*BER_MEMALLOC_FN)    LDAP_P(( ber_len_t size ));
  113. typedef void* (*BER_MEMCALLOC_FN)    LDAP_P(( ber_len_t n, ber_len_t size ));
  114. typedef void* (*BER_MEMREALLOC_FN)    LDAP_P(( void *p, ber_len_t size ));
  115. typedef void  (*BER_MEMFREE_FN)        LDAP_P(( void *p ));
  116.  
  117. typedef struct lber_memory_fns {
  118.     BER_MEMALLOC_FN    bmf_malloc;
  119.     BER_MEMCALLOC_FN bmf_calloc;
  120.     BER_MEMREALLOC_FN bmf_realloc;
  121.     BER_MEMFREE_FN bmf_free;
  122. } BerMemoryFunctions;
  123.  
  124. /* LBER Sockbuf_IO options */ 
  125. #define LBER_SB_OPT_GET_FD        1
  126. #define LBER_SB_OPT_SET_FD        2
  127. #define LBER_SB_OPT_HAS_IO        3
  128. #define LBER_SB_OPT_SET_NONBLOCK    4
  129. #define LBER_SB_OPT_GET_SSL        7
  130. #define LBER_SB_OPT_DATA_READY        8
  131. #define LBER_SB_OPT_SET_READAHEAD    9
  132. #define LBER_SB_OPT_DRAIN        10
  133. #define LBER_SB_OPT_NEEDS_READ        11
  134. #define LBER_SB_OPT_NEEDS_WRITE        12
  135. #define LBER_SB_OPT_GET_MAX_INCOMING 13
  136. #define LBER_SB_OPT_SET_MAX_INCOMING 14
  137. /* Largest option used by the library */
  138. #define LBER_SB_OPT_OPT_MAX        14
  139.  
  140. /* LBER IO operations stacking levels */
  141. #define LBER_SBIOD_LEVEL_PROVIDER    10
  142. #define LBER_SBIOD_LEVEL_TRANSPORT    20
  143. #define LBER_SBIOD_LEVEL_APPLICATION    30
  144.  
  145. /* get/set options for Sockbuf */
  146. #define LBER_OPT_SOCKBUF_DESC        0x1000
  147. #define LBER_OPT_SOCKBUF_OPTIONS    0x1001
  148. #define LBER_OPT_SOCKBUF_DEBUG        0x1002
  149.  
  150. /* on/off values */
  151. #define LBER_OPT_ON        ((void *) 1)
  152. #define LBER_OPT_OFF    ((void *) 0)
  153.  
  154. #define LBER_OPT_SUCCESS    (0)
  155. #define LBER_OPT_ERROR        (-1)
  156.  
  157. typedef struct berelement BerElement;
  158. typedef struct sockbuf Sockbuf;
  159. typedef struct seqorset Seqorset;
  160.  
  161. typedef struct sockbuf_io Sockbuf_IO;
  162.  
  163. /* Structure for LBER IO operarion descriptor */
  164. typedef struct sockbuf_io_desc {
  165.     int            sbiod_level;
  166.     Sockbuf            *sbiod_sb;
  167.     Sockbuf_IO        *sbiod_io;
  168.     void             *sbiod_pvt;
  169.     struct sockbuf_io_desc    *sbiod_next;
  170. } Sockbuf_IO_Desc;
  171.  
  172. /* Structure for LBER IO operation functions */
  173. struct sockbuf_io {
  174.     int (*sbi_setup)( Sockbuf_IO_Desc *sbiod, void *arg );
  175.     int (*sbi_remove)( Sockbuf_IO_Desc *sbiod );
  176.     int (*sbi_ctrl)( Sockbuf_IO_Desc *sbiod, int opt, void *arg);
  177.     
  178.     ber_slen_t (*sbi_read)( Sockbuf_IO_Desc *sbiod, void *buf,
  179.         ber_len_t len );
  180.     ber_slen_t (*sbi_write)( Sockbuf_IO_Desc *sbiod, void *buf,
  181.         ber_len_t len );
  182.     
  183.     int (*sbi_close)( Sockbuf_IO_Desc *sbiod );
  184. };
  185.  
  186. /* Helper macros for LBER IO functions */
  187. #define LBER_SBIOD_READ_NEXT( sbiod, buf, len ) \
  188.     ( (sbiod)->sbiod_next->sbiod_io->sbi_read( (sbiod)->sbiod_next, \
  189.         buf, len ) )
  190. #define LBER_SBIOD_WRITE_NEXT( sbiod, buf, len ) \
  191.     ( (sbiod)->sbiod_next->sbiod_io->sbi_write( (sbiod)->sbiod_next, \
  192.         buf, len ) )
  193. #define LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg ) \
  194.     ( (sbiod)->sbiod_next ? \
  195.         ( (sbiod)->sbiod_next->sbiod_io->sbi_ctrl( \
  196.         (sbiod)->sbiod_next, opt, arg ) ) : 0 )
  197.  
  198. /* structure for returning a sequence of octet strings + length */
  199. typedef struct berval {
  200.     ber_len_t    bv_len;
  201.     char        *bv_val;
  202. } BerValue;
  203.  
  204. /* this should be moved to lber-int.h */
  205.  
  206. /*
  207.  * in bprint.c:
  208.  */
  209. LBER_F( void )
  210. ber_error_print LDAP_P((
  211.     LDAP_CONST char *data ));
  212.  
  213. LBER_F( void )
  214. ber_bprint LDAP_P((
  215.     LDAP_CONST char *data, ber_len_t len ));
  216.  
  217. LBER_F( void )
  218. ber_dump LDAP_P((
  219.     BerElement *ber, int inout ));
  220.  
  221. LBER_F( void )
  222. ber_sos_dump LDAP_P((
  223.     Seqorset *sos ));
  224.  
  225.  
  226. /*
  227.  * in decode.c:
  228.  */
  229. typedef int (*BERDecodeCallback) LDAP_P((
  230.     BerElement *ber,
  231.     void *data,
  232.     int mode ));
  233.  
  234. LBER_F( ber_tag_t )
  235. ber_get_tag LDAP_P((
  236.     BerElement *ber ));
  237.  
  238. LBER_F( ber_tag_t )
  239. ber_skip_tag LDAP_P((
  240.     BerElement *ber,
  241.     ber_len_t *len ));
  242.  
  243. LBER_F( ber_tag_t )
  244. ber_peek_tag LDAP_P((
  245.     BerElement *ber,
  246.     ber_len_t *len ));
  247.  
  248. LBER_F( ber_tag_t )
  249. ber_get_int LDAP_P((
  250.     BerElement *ber,
  251.     ber_int_t *num ));
  252.  
  253. LBER_F( ber_tag_t )
  254. ber_get_enum LDAP_P((
  255.     BerElement *ber,
  256.     ber_int_t *num ));
  257.  
  258. LBER_F( ber_tag_t )
  259. ber_get_stringb LDAP_P((
  260.     BerElement *ber,
  261.     char *buf,
  262.     ber_len_t *len ));
  263.  
  264. LBER_F( ber_tag_t )
  265. ber_get_stringa LDAP_P((
  266.     BerElement *ber,
  267.     char **buf ));
  268.  
  269. LBER_F( ber_tag_t )
  270. ber_get_stringal LDAP_P((
  271.     BerElement *ber,
  272.     struct berval **bv ));
  273.  
  274. LBER_F( ber_tag_t )
  275. ber_get_bitstringa LDAP_P((
  276.     BerElement *ber,
  277.     char **buf,
  278.     ber_len_t *len ));
  279.  
  280. LBER_F( ber_tag_t )
  281. ber_get_null LDAP_P((
  282.     BerElement *ber ));
  283.  
  284. LBER_F( ber_tag_t )
  285. ber_get_boolean LDAP_P((
  286.     BerElement *ber,
  287.     ber_int_t *boolval ));
  288.  
  289. LBER_F( ber_tag_t )
  290. ber_first_element LDAP_P((
  291.     BerElement *ber,
  292.     ber_len_t *len,
  293.     char **last ));
  294.  
  295. LBER_F( ber_tag_t )
  296. ber_next_element LDAP_P((
  297.     BerElement *ber,
  298.     ber_len_t *len,
  299.     LDAP_CONST char *last ));
  300.  
  301. LBER_F( ber_tag_t )
  302. ber_scanf LDAP_P((                                  
  303.     BerElement *ber,
  304.     LDAP_CONST char *fmt,
  305.     ... ));
  306.  
  307. /*
  308.  * in encode.c
  309.  */
  310. typedef int (*BEREncodeCallback) LDAP_P((
  311.     BerElement *ber,
  312.     void *data ));
  313.  
  314. LBER_F( int )
  315. ber_put_enum LDAP_P((
  316.     BerElement *ber,
  317.     ber_int_t num,
  318.     ber_tag_t tag ));
  319.  
  320. LBER_F( int )
  321. ber_put_int LDAP_P((
  322.     BerElement *ber,
  323.     ber_int_t num,
  324.     ber_tag_t tag ));
  325.  
  326. LBER_F( int )
  327. ber_put_ostring LDAP_P((
  328.     BerElement *ber,
  329.     LDAP_CONST char *str,
  330.     ber_len_t len,
  331.     ber_tag_t tag ));
  332.  
  333. LBER_F( int )
  334. ber_put_berval LDAP_P((
  335.     BerElement *ber,
  336.     LDAP_CONST struct berval *bv,
  337.     ber_tag_t tag ));
  338.  
  339. LBER_F( int )
  340. ber_put_string LDAP_P((
  341.     BerElement *ber,
  342.     LDAP_CONST char *str,
  343.     ber_tag_t tag ));
  344.  
  345. LBER_F( int )
  346. ber_put_bitstring LDAP_P((
  347.     BerElement *ber,
  348.     LDAP_CONST char *str,
  349.     ber_len_t bitlen,
  350.     ber_tag_t tag ));
  351.  
  352. LBER_F( int )
  353. ber_put_null LDAP_P((
  354.     BerElement *ber,
  355.     ber_tag_t tag ));
  356.  
  357. LBER_F( int )
  358. ber_put_boolean LDAP_P((
  359.     BerElement *ber,
  360.     ber_int_t boolval,
  361.     ber_tag_t tag ));
  362.  
  363. LBER_F( int )
  364. ber_start_seq LDAP_P((
  365.     BerElement *ber,
  366.     ber_tag_t tag ));
  367.  
  368. LBER_F( int )
  369. ber_start_set LDAP_P((
  370.     BerElement *ber,
  371.     ber_tag_t tag ));
  372.  
  373. LBER_F( int )
  374. ber_put_seq LDAP_P((
  375.     BerElement *ber ));
  376.  
  377. LBER_F( int )
  378. ber_put_set LDAP_P((
  379.     BerElement *ber ));
  380.  
  381. LBER_F( int )
  382. ber_printf LDAP_P((
  383.     BerElement *ber,
  384.     LDAP_CONST char *fmt,
  385.     ... ));
  386.  
  387.  
  388. /*
  389.  * in io.c:
  390.  */
  391.  
  392. LBER_F( ber_slen_t )
  393. ber_read LDAP_P((
  394.     BerElement *ber,
  395.     char *buf,
  396.     ber_len_t len ));
  397.  
  398. LBER_F( ber_slen_t )
  399. ber_write LDAP_P((
  400.     BerElement *ber,
  401.     LDAP_CONST char *buf,
  402.     ber_len_t len,
  403.     int nosos ));
  404.  
  405. LBER_F( void )
  406. ber_free LDAP_P((
  407.     BerElement *ber,
  408.     int freebuf ));
  409.  
  410. LBER_F( int )
  411. ber_flush LDAP_P((
  412.     Sockbuf *sb,
  413.     BerElement *ber,
  414.     int freeit ));
  415.  
  416. LBER_F( BerElement * )
  417. ber_alloc LDAP_P(( void )); /* DEPRECATED */
  418.  
  419. LBER_F( BerElement * )
  420. der_alloc LDAP_P(( void )); /* DEPRECATED */
  421.  
  422. LBER_F( BerElement * )
  423. ber_alloc_t LDAP_P((
  424.     int beroptions ));
  425.  
  426. LBER_F( BerElement * )
  427. ber_dup LDAP_P((
  428.     BerElement *ber ));
  429.  
  430. LBER_F( ber_tag_t )
  431. ber_get_next LDAP_P((
  432.     Sockbuf *sb,
  433.     ber_len_t *len,
  434.     BerElement *ber ));
  435.  
  436. LBER_F( void )
  437. ber_init_w_nullc LDAP_P((    /* DEPRECATED */
  438.     BerElement *ber,
  439.     int options ));
  440.  
  441. LBER_F( void )
  442. ber_reset LDAP_P((
  443.     BerElement *ber,
  444.     int was_writing ));
  445.  
  446. LBER_F( BerElement * )
  447. ber_init LDAP_P((
  448.     struct berval *bv ));
  449.  
  450. LBER_F( int )
  451. ber_flatten LDAP_P((
  452.     BerElement *ber,
  453.     struct berval **bvPtr ));
  454.  
  455. /*
  456.  * LBER ber accessor functions
  457.  */
  458.  
  459. LBER_F( int )
  460. ber_get_option LDAP_P((
  461.     void *item,
  462.     int option,
  463.     void *outvalue));
  464.  
  465. LBER_F( int )
  466. ber_set_option LDAP_P((
  467.     void *item,
  468.     int option,
  469.     LDAP_CONST void *invalue));
  470.  
  471. /*
  472.  * LBER sockbuf.c
  473.  */
  474.  
  475. LBER_F( Sockbuf *  )
  476. ber_sockbuf_alloc LDAP_P((
  477.     void ));
  478.  
  479. LBER_F( void )
  480. ber_sockbuf_free LDAP_P((
  481.     Sockbuf *sb ));
  482.  
  483. LBER_F( int )
  484. ber_sockbuf_add_io LDAP_P((
  485.     Sockbuf *sb,
  486.     Sockbuf_IO *sbio,
  487.     int layer,
  488.     void *arg ));
  489.  
  490. LBER_F( int )
  491. ber_sockbuf_remove_io LDAP_P((
  492.     Sockbuf *sb,
  493.     Sockbuf_IO *sbio,
  494.     int layer ));
  495.  
  496. LBER_F( int )
  497. ber_sockbuf_ctrl LDAP_P((
  498.     Sockbuf *sb,
  499.     int opt,
  500.     void *arg ));
  501.  
  502. LBER_F( Sockbuf_IO ) ber_sockbuf_io_tcp;
  503. LBER_F( Sockbuf_IO ) ber_sockbuf_io_readahead;
  504. LBER_F( Sockbuf_IO ) ber_sockbuf_io_fd;
  505. LBER_F( Sockbuf_IO ) ber_sockbuf_io_debug;
  506.  
  507. /*
  508.  * LBER memory.c
  509.  */
  510. LBER_F( void * )
  511. ber_memalloc LDAP_P((
  512.     ber_len_t s ));
  513.  
  514. LBER_F( void * )
  515. ber_memrealloc LDAP_P((
  516.     void* p,
  517.     ber_len_t s ));
  518.  
  519. LBER_F( void * )
  520. ber_memcalloc LDAP_P((
  521.     ber_len_t n,
  522.     ber_len_t s ));
  523.  
  524. LBER_F( void )
  525. ber_memfree LDAP_P((
  526.     void* p ));
  527.  
  528. LBER_F( void )
  529. ber_memvfree LDAP_P((
  530.     void** vector ));
  531.  
  532. LBER_F( void )
  533. ber_bvfree LDAP_P((
  534.     struct berval *bv ));
  535.  
  536. LBER_F( void )
  537. ber_bvecfree LDAP_P((
  538.     struct berval **bv ));
  539.  
  540. LBER_F( int )
  541. ber_bvecadd LDAP_P((
  542.     struct berval ***bvec,
  543.     struct berval *bv ));
  544.  
  545. LBER_F( struct berval * )
  546. ber_bvdup LDAP_P((
  547.     LDAP_CONST struct berval *bv ));
  548.  
  549. LBER_F( struct berval * )
  550. ber_bvstr LDAP_P((
  551.     LDAP_CONST char * ));
  552.  
  553. LBER_F( struct berval * )
  554. ber_bvstrdup LDAP_P((
  555.     LDAP_CONST char * ));
  556.  
  557. LBER_F( char * )
  558. ber_strdup LDAP_P((
  559.     LDAP_CONST char * ));
  560.  
  561. /*
  562.  * error.c
  563.  */
  564. LBER_F( int * ) ber_errno_addr LDAP_P((void));
  565. #define ber_errno (*(ber_errno_addr)())
  566.  
  567. #define LBER_ERROR_NONE        0
  568. #define LBER_ERROR_PARAM    0x1
  569. #define LBER_ERROR_MEMORY    0x2
  570.  
  571. LDAP_END_DECL
  572.  
  573. #endif /* _LBER_H */
  574.