Diff for /include/lber.h between versions 1.32 and 1.32.6.9

version 1.32, 1999/06/18 21:53:06 version 1.32.6.9, 2002/01/04 20:38:14
Line 1 Line 1
   /* $OpenLDAP: pkg/ldap/include/lber.h,v 1.32.6.8 2001/06/02 00:33:02 kurt Exp $ */
 /*  /*
  * Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA   * Copyright 1998-2002 The OpenLDAP Foundation, Redwood City, California, USA
  * All rights reserved.   * All rights reserved.
  *   *
  * Redistribution and use in source and binary forms are permitted only   * Redistribution and use in source and binary forms, with or without
  * as authorized by the OpenLDAP Public License.  A copy of this   * modification, are permitted only as authorized by the OpenLDAP
  * license is available at http://www.OpenLDAP.org/license.html or   * Public License.  A copy of this license is available at
  * in file LICENSE in the top-level directory of the distribution.   * http://www.OpenLDAP.org/license.html or in file LICENSE in the
    * top-level directory of the distribution.
  */   */
 /* Portions  /* Portions
  * Copyright (c) 1990 Regents of the University of Michigan.   * Copyright (c) 1990 Regents of the University of Michigan.
Line 22 Line 24
 #ifndef _LBER_H  #ifndef _LBER_H
 #define _LBER_H  #define _LBER_H
   
 #include <ldap_cdefs.h>  
 #include <lber_types.h>  #include <lber_types.h>
   
 LDAP_BEGIN_DECL  LDAP_BEGIN_DECL
   
 /* boolean, enumerations, and integers */  
 typedef LBER_INT_T ber_int_t;  
   
 /* signed and unsigned versions */  
 typedef signed LBER_INT_T ber_sint_t;  
 typedef unsigned LBER_INT_T ber_uint_t;  
   
 /* tags */  
 typedef LBER_TAG_T ber_tag_t;  
   
 /* "socket" descriptors */  
 typedef LBER_SOCKET_T ber_socket_t;  
   
 /* lengths */  
 typedef unsigned LBER_LEN_T ber_len_t;  
   
 /* signed lengths */  
 typedef LBER_LEN_T ber_slen_t;  
   
   
 /* Overview of LBER tag construction  /* Overview of LBER tag construction
  *   *
  *      Bits   *      Bits
Line 65  typedef LBER_LEN_T ber_slen_t; Line 46  typedef LBER_LEN_T ber_slen_t;
  */   */
   
 /* BER classes and mask */  /* BER classes and mask */
 #define LBER_CLASS_UNIVERSAL    (ber_tag_t) 0x00U  #define LBER_CLASS_UNIVERSAL    ((ber_tag_t) 0x00U)
 #define LBER_CLASS_APPLICATION  (ber_tag_t) 0x40U  #define LBER_CLASS_APPLICATION  ((ber_tag_t) 0x40U)
 #define LBER_CLASS_CONTEXT      (ber_tag_t) 0x80U  #define LBER_CLASS_CONTEXT              ((ber_tag_t) 0x80U)
 #define LBER_CLASS_PRIVATE      (ber_tag_t) 0xc0U  #define LBER_CLASS_PRIVATE              ((ber_tag_t) 0xc0U)
 #define LBER_CLASS_MASK         (ber_tag_t) 0xc0U  #define LBER_CLASS_MASK                 ((ber_tag_t) 0xc0U)
   
 /* BER encoding type and mask */  /* BER encoding type and mask */
 #define LBER_PRIMITIVE          (ber_tag_t) 0x00U  #define LBER_PRIMITIVE                  ((ber_tag_t) 0x00U)
 #define LBER_CONSTRUCTED        (ber_tag_t) 0x20U  #define LBER_CONSTRUCTED                ((ber_tag_t) 0x20U)
 #define LBER_ENCODING_MASK      (ber_tag_t) 0x20U  #define LBER_ENCODING_MASK              ((ber_tag_t) 0x20U)
   
 #define LBER_BIG_TAG_MASK       (ber_tag_t) 0x1fU  #define LBER_BIG_TAG_MASK               ((ber_tag_t) 0x1fU)
 #define LBER_MORE_TAG_MASK      (ber_tag_t) 0x80U  #define LBER_MORE_TAG_MASK              ((ber_tag_t) 0x80U)
   
 /*  /*
  * Note that LBER_ERROR and LBER_DEFAULT are values that can never appear   * Note that LBER_ERROR and LBER_DEFAULT are values that can never appear
  * as valid BER tags, and so it is safe to use them to report errors.  In   * as valid BER tags, and so it is safe to use them to report errors.  In
  * fact, any tag for which the following is true is invalid:   * fact, any tag for which the following is true is invalid:
  */   */
 #define LBER_INVALID(t)     (((t) & 0x080) && (((t) & (ber_tag_t) ~ 0x0FF))  #define LBER_INVALID(t)     (((t) & (ber_tag_t) 0x080UL) \
 #define LBER_ERROR                      ((ber_tag_t) ~ 0x0)          && (((t) & (ber_tag_t) ~ 0x0FF))
 #define LBER_DEFAULT            ((ber_tag_t) ~ 0x0)  
   #define LBER_ERROR                      ((ber_tag_t) -1)
   #define LBER_DEFAULT            ((ber_tag_t) -1)
   
 /* general BER types we know about */  /* general BER types we know about */
 #define LBER_BOOLEAN            (ber_tag_t) 0x01UL  #define LBER_BOOLEAN            ((ber_tag_t) 0x01UL)
 #define LBER_INTEGER            (ber_tag_t) 0x02UL  #define LBER_INTEGER            ((ber_tag_t) 0x02UL)
 #define LBER_BITSTRING          (ber_tag_t) 0x03UL  #define LBER_BITSTRING          ((ber_tag_t) 0x03UL)
 #define LBER_OCTETSTRING        (ber_tag_t) 0x04UL  #define LBER_OCTETSTRING        ((ber_tag_t) 0x04UL)
 #define LBER_NULL                       (ber_tag_t) 0x05UL  #define LBER_NULL                       ((ber_tag_t) 0x05UL)
 #define LBER_ENUMERATED         (ber_tag_t) 0x0aUL  #define LBER_ENUMERATED         ((ber_tag_t) 0x0aUL)
 #define LBER_SEQUENCE           (ber_tag_t) 0x30UL      /* constructed */  #define LBER_SEQUENCE           ((ber_tag_t) 0x30UL)    /* constructed */
 #define LBER_SET                        (ber_tag_t) 0x31UL      /* constructed */  #define LBER_SET                        ((ber_tag_t) 0x31UL)    /* constructed */
   
 #define OLD_LBER_SEQUENCE       (ber_tag_t) 0x10UL      /* w/o constructed bit - broken */  
 #define OLD_LBER_SET            (ber_tag_t) 0x11UL      /* w/o constructed bit - broken */  
   
 typedef int (*BERTranslateProc) LDAP_P((  
         char **bufp,  
         unsigned long *buflenp,  
         int free_input ));  
   
 /* LBER BerElement options */  /* LBER BerElement options */
 #define LBER_USE_DER            0x01  #define LBER_USE_DER            0x01
 #define LBER_USE_INDEFINITE_LEN 0x02  #define LBER_USE_INDEFINITE_LEN 0x02
 #define LBER_TRANSLATE_STRINGS  0x04  
   
 /* get/set options for BerElement */  /* get/set options for BerElement */
 #define LBER_OPT_BER_OPTIONS    0x01  #define LBER_OPT_BER_OPTIONS                    0x01
 #define LBER_OPT_BER_DEBUG              0x02  #define LBER_OPT_BER_DEBUG                              0x02
   #define LBER_OPT_BER_REMAINING_BYTES    0x03
   #define LBER_OPT_BER_TOTAL_BYTES                0x04
   #define LBER_OPT_BER_BYTES_TO_WRITE             0x05
   
 #define LBER_OPT_DEBUG_LEVEL    LBER_OPT_BER_DEBUG  #define LBER_OPT_DEBUG_LEVEL    LBER_OPT_BER_DEBUG
   #define LBER_OPT_REMAINING_BYTES        LBER_OPT_BER_REMAINING_BYTES
   #define LBER_OPT_TOTAL_BYTES            LBER_OPT_BER_TOTAL_BYTES
   #define LBER_OPT_BYTES_TO_WRITE         LBER_OPT_BER_BYTES_TO_WRITE
   
 #define LBER_OPT_LOG_PRINT_FN   0x8001  #define LBER_OPT_LOG_PRINT_FN   0x8001
 #define LBER_OPT_MEMORY_FNS             0x8002  #define LBER_OPT_MEMORY_FNS             0x8002
   #define LBER_OPT_ERROR_FN               0x8003
   #define LBER_OPT_LOG_PRINT_FILE         0x8004
   
   /* get/set Memory Debug options */
   #define LBER_OPT_MEMORY_INUSE           0x8005  /* for memory debugging */
   
   typedef int* (*BER_ERRNO_FN) LDAP_P(( void ));
   
 typedef void (*BER_LOG_PRINT_FN) LDAP_P(( char *buf ));  typedef void (*BER_LOG_PRINT_FN) LDAP_P(( LDAP_CONST char *buf ));
   
 typedef void* (*BER_MEMALLOC_FN)        LDAP_P(( ber_len_t size ));  typedef void* (*BER_MEMALLOC_FN)        LDAP_P(( ber_len_t size ));
 typedef void* (*BER_MEMCALLOC_FN)       LDAP_P(( ber_len_t n, ber_len_t size ));  typedef void* (*BER_MEMCALLOC_FN)       LDAP_P(( ber_len_t n, ber_len_t size ));
Line 134  typedef struct lber_memory_fns { Line 121  typedef struct lber_memory_fns {
         BER_MEMFREE_FN bmf_free;          BER_MEMFREE_FN bmf_free;
 } BerMemoryFunctions;  } BerMemoryFunctions;
   
 /* LBER Sockbuf options */   /* LBER Sockbuf_IO options */ 
 #define LBER_TO_FILE           0x01     /* to a file referenced by sb_fd   */  #define LBER_SB_OPT_GET_FD              1
 #define LBER_TO_FILE_ONLY      0x02     /* only write to file, not network */  #define LBER_SB_OPT_SET_FD              2
 #define LBER_MAX_INCOMING_SIZE 0x04     /* impose limit on incoming stuff  */  #define LBER_SB_OPT_HAS_IO              3
 #define LBER_NO_READ_AHEAD     0x08     /* read only as much as requested  */  #define LBER_SB_OPT_SET_NONBLOCK        4
   #define LBER_SB_OPT_GET_SSL             7
   #define LBER_SB_OPT_DATA_READY          8
   #define LBER_SB_OPT_SET_READAHEAD       9
   #define LBER_SB_OPT_DRAIN               10
   #define LBER_SB_OPT_NEEDS_READ          11
   #define LBER_SB_OPT_NEEDS_WRITE         12
   #define LBER_SB_OPT_GET_MAX_INCOMING 13
   #define LBER_SB_OPT_SET_MAX_INCOMING 14
   /* Largest option used by the library */
   #define LBER_SB_OPT_OPT_MAX             14
   
   /* LBER IO operations stacking levels */
   #define LBER_SBIOD_LEVEL_PROVIDER       10
   #define LBER_SBIOD_LEVEL_TRANSPORT      20
   #define LBER_SBIOD_LEVEL_APPLICATION    30
   
 /* get/set options for Sockbuf */  /* get/set options for Sockbuf */
 #define LBER_OPT_SOCKBUF_DESC           0x1000  #define LBER_OPT_SOCKBUF_DESC           0x1000
Line 149  typedef struct lber_memory_fns { Line 151  typedef struct lber_memory_fns {
 #define LBER_OPT_ON             ((void *) 1)  #define LBER_OPT_ON             ((void *) 1)
 #define LBER_OPT_OFF    ((void *) 0)  #define LBER_OPT_OFF    ((void *) 0)
   
 #define LBER_OPT_SUCCESS        0  #define LBER_OPT_SUCCESS        (0)
 #define LBER_OPT_ERROR          (-1)  #define LBER_OPT_ERROR          (-1)
   
 typedef struct berelement BerElement;  typedef struct berelement BerElement;
 typedef struct sockbuf Sockbuf;  typedef struct sockbuf Sockbuf;
 typedef struct seqorset Seqorset;  typedef struct seqorset Seqorset;
   
   typedef struct sockbuf_io Sockbuf_IO;
   
   /* Structure for LBER IO operarion descriptor */
   typedef struct sockbuf_io_desc {
           int                     sbiod_level;
           Sockbuf                 *sbiod_sb;
           Sockbuf_IO              *sbiod_io;
           void                    *sbiod_pvt;
           struct sockbuf_io_desc  *sbiod_next;
   } Sockbuf_IO_Desc;
   
   /* Structure for LBER IO operation functions */
   struct sockbuf_io {
           int (*sbi_setup)( Sockbuf_IO_Desc *sbiod, void *arg );
           int (*sbi_remove)( Sockbuf_IO_Desc *sbiod );
           int (*sbi_ctrl)( Sockbuf_IO_Desc *sbiod, int opt, void *arg);
           
           ber_slen_t (*sbi_read)( Sockbuf_IO_Desc *sbiod, void *buf,
                   ber_len_t len );
           ber_slen_t (*sbi_write)( Sockbuf_IO_Desc *sbiod, void *buf,
                   ber_len_t len );
           
           int (*sbi_close)( Sockbuf_IO_Desc *sbiod );
   };
   
   /* Helper macros for LBER IO functions */
   #define LBER_SBIOD_READ_NEXT( sbiod, buf, len ) \
           ( (sbiod)->sbiod_next->sbiod_io->sbi_read( (sbiod)->sbiod_next, \
                   buf, len ) )
   #define LBER_SBIOD_WRITE_NEXT( sbiod, buf, len ) \
           ( (sbiod)->sbiod_next->sbiod_io->sbi_write( (sbiod)->sbiod_next, \
                   buf, len ) )
   #define LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg ) \
           ( (sbiod)->sbiod_next ? \
                   ( (sbiod)->sbiod_next->sbiod_io->sbi_ctrl( \
                   (sbiod)->sbiod_next, opt, arg ) ) : 0 )
   
 /* structure for returning a sequence of octet strings + length */  /* structure for returning a sequence of octet strings + length */
 typedef struct berval {  typedef struct berval {
         ber_len_t       bv_len;          ber_len_t       bv_len;
         char            *bv_val;          char            *bv_val;
 } BerValue;  } BerValue;
   
   /* this should be moved to lber-int.h */
   
 /*  /*
  * in bprint.c:   * in bprint.c:
  */   */
 LDAP_F( void )  LBER_F( void )
 ber_print_error LDAP_P((  ber_error_print LDAP_P((
         LDAP_CONST char *data ));          LDAP_CONST char *data ));
   
 LDAP_F( void )  LBER_F( void )
 ber_bprint LDAP_P((  ber_bprint LDAP_P((
         LDAP_CONST char *data, ber_len_t len ));          LDAP_CONST char *data, ber_len_t len ));
   
 LDAP_F( void )  LBER_F( void )
 ber_dump LDAP_P((  ber_dump LDAP_P((
         LDAP_CONST BerElement *ber, int inout ));          BerElement *ber, int inout ));
   
 LDAP_F( void )  LBER_F( void )
 ber_sos_dump LDAP_P((  ber_sos_dump LDAP_P((
         LDAP_CONST Seqorset *sos ));          Seqorset *sos ));
   
   
 /*  /*
Line 190  typedef int (*BERDecodeCallback) LDAP_P( Line 231  typedef int (*BERDecodeCallback) LDAP_P(
         void *data,          void *data,
         int mode ));          int mode ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_get_tag LDAP_P((  ber_get_tag LDAP_P((
         BerElement *ber ));          BerElement *ber ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_skip_tag LDAP_P((  ber_skip_tag LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_len_t *len ));          ber_len_t *len ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_peek_tag LDAP_P((  ber_peek_tag LDAP_P((
         LDAP_CONST BerElement *ber,          BerElement *ber,
         ber_len_t *len ));          ber_len_t *len ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_get_int LDAP_P((  ber_get_int LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_int_t *num ));          ber_int_t *num ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
   ber_get_enum LDAP_P((
           BerElement *ber,
           ber_int_t *num ));
   
   LBER_F( ber_tag_t )
 ber_get_stringb LDAP_P((  ber_get_stringb LDAP_P((
         BerElement *ber,          BerElement *ber,
         char *buf,          char *buf,
         ber_len_t *len ));          ber_len_t *len ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_get_stringa LDAP_P((  ber_get_stringa LDAP_P((
         BerElement *ber,          BerElement *ber,
         char **buf ));          char **buf ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_get_stringal LDAP_P((  ber_get_stringal LDAP_P((
         BerElement *ber,          BerElement *ber,
         struct berval **bv ));          struct berval **bv ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_get_bitstringa LDAP_P((  ber_get_bitstringa LDAP_P((
         BerElement *ber,          BerElement *ber,
         char **buf,          char **buf,
         ber_len_t *len ));          ber_len_t *len ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_get_null LDAP_P((  ber_get_null LDAP_P((
         BerElement *ber ));          BerElement *ber ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_get_boolean LDAP_P((  ber_get_boolean LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_int_t *boolval ));          ber_int_t *boolval ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_first_element LDAP_P((  ber_first_element LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_len_t *len,          ber_len_t *len,
         char **last ));          char **last ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_next_element LDAP_P((  ber_next_element LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_len_t *len,          ber_len_t *len,
         char *last ));          LDAP_CONST char *last ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_scanf LDAP_P((                                                                  ber_scanf LDAP_P((                                                                
         BerElement *ber,          BerElement *ber,
         LDAP_CONST char *fmt,          LDAP_CONST char *fmt,
         ... ));          ... ));
   
 LDAP_F( void )  
 ber_set_string_translators LDAP_P((  
         BerElement *ber,  
         BERTranslateProc encode_proc,  
         BERTranslateProc decode_proc ));  
   
 /*  /*
  * in encode.c   * in encode.c
  */   */
Line 271  typedef int (*BEREncodeCallback) LDAP_P( Line 311  typedef int (*BEREncodeCallback) LDAP_P(
         BerElement *ber,          BerElement *ber,
         void *data ));          void *data ));
   
 LDAP_F( int )  LBER_F( int )
 ber_put_enum LDAP_P((  ber_put_enum LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_int_t num,          ber_int_t num,
         ber_tag_t tag ));          ber_tag_t tag ));
   
 LDAP_F( int )  LBER_F( int )
 ber_put_int LDAP_P((  ber_put_int LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_int_t num,          ber_int_t num,
         ber_tag_t tag ));          ber_tag_t tag ));
   
 LDAP_F( int )  LBER_F( int )
 ber_put_ostring LDAP_P((  ber_put_ostring LDAP_P((
         BerElement *ber,          BerElement *ber,
         LDAP_CONST char *str,          LDAP_CONST char *str,
         ber_len_t len,          ber_len_t len,
         ber_tag_t tag ));          ber_tag_t tag ));
   
 LDAP_F( int )  LBER_F( int )
 ber_put_berval LDAP_P((  ber_put_berval LDAP_P((
         BerElement *ber,          BerElement *ber,
         LDAP_CONST struct berval *bv,          LDAP_CONST struct berval *bv,
         ber_tag_t tag ));          ber_tag_t tag ));
   
 LDAP_F( int )  LBER_F( int )
 ber_put_string LDAP_P((  ber_put_string LDAP_P((
         BerElement *ber,          BerElement *ber,
         LDAP_CONST char *str,          LDAP_CONST char *str,
         ber_tag_t tag ));          ber_tag_t tag ));
   
 LDAP_F( int )  LBER_F( int )
 ber_put_bitstring LDAP_P((  ber_put_bitstring LDAP_P((
         BerElement *ber,          BerElement *ber,
         LDAP_CONST char *str,          LDAP_CONST char *str,
         ber_len_t bitlen,          ber_len_t bitlen,
         ber_tag_t tag ));          ber_tag_t tag ));
   
 LDAP_F( int )  LBER_F( int )
 ber_put_null LDAP_P((  ber_put_null LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_tag_t tag ));          ber_tag_t tag ));
   
 LDAP_F( int )  LBER_F( int )
 ber_put_boolean LDAP_P((  ber_put_boolean LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_int_t boolval,          ber_int_t boolval,
         ber_tag_t tag ));          ber_tag_t tag ));
   
 LDAP_F( int )  LBER_F( int )
 ber_start_seq LDAP_P((  ber_start_seq LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_tag_t tag ));          ber_tag_t tag ));
   
 LDAP_F( int )  LBER_F( int )
 ber_start_set LDAP_P((  ber_start_set LDAP_P((
         BerElement *ber,          BerElement *ber,
         ber_tag_t tag ));          ber_tag_t tag ));
   
 LDAP_F( int )  LBER_F( int )
 ber_put_seq LDAP_P((  ber_put_seq LDAP_P((
         BerElement *ber ));          BerElement *ber ));
   
 LDAP_F( int )  LBER_F( int )
 ber_put_set LDAP_P((  ber_put_set LDAP_P((
         BerElement *ber ));          BerElement *ber ));
   
 LDAP_F( int )  LBER_F( int )
 ber_printf LDAP_P((  ber_printf LDAP_P((
         BerElement *ber,          BerElement *ber,
         LDAP_CONST char *fmt,          LDAP_CONST char *fmt,
Line 349  ber_printf LDAP_P(( Line 389  ber_printf LDAP_P((
  * in io.c:   * in io.c:
  */   */
   
 LDAP_F( ber_slen_t )  LBER_F( ber_slen_t )
 ber_read LDAP_P((  ber_read LDAP_P((
         BerElement *ber,          BerElement *ber,
         char *buf,          char *buf,
         ber_len_t len ));          ber_len_t len ));
   
 LDAP_F( ber_slen_t )  LBER_F( ber_slen_t )
 ber_write LDAP_P((  ber_write LDAP_P((
         BerElement *ber,          BerElement *ber,
         LDAP_CONST char *buf,          LDAP_CONST char *buf,
         ber_len_t len,          ber_len_t len,
         int nosos ));          int nosos ));
   
 LDAP_F( void )  LBER_F( void )
 ber_free LDAP_P((  ber_free LDAP_P((
         BerElement *ber,          BerElement *ber,
         int freebuf ));          int freebuf ));
   
 LDAP_F( int )  LBER_F( int )
 ber_flush LDAP_P((  ber_flush LDAP_P((
         Sockbuf *sb,          Sockbuf *sb,
         BerElement *ber,          BerElement *ber,
         int freeit ));          int freeit ));
   
 LDAP_F( BerElement * )  LBER_F( BerElement * )
 ber_alloc LDAP_P(( void )); /* DEPRECATED */  ber_alloc LDAP_P(( void )); /* DEPRECATED */
   
 LDAP_F( BerElement * )  LBER_F( BerElement * )
 der_alloc LDAP_P(( void )); /* DEPRECATED */  der_alloc LDAP_P(( void )); /* DEPRECATED */
   
 LDAP_F( BerElement * )  LBER_F( BerElement * )
 ber_alloc_t LDAP_P((  ber_alloc_t LDAP_P((
         int beroptions ));          int beroptions ));
   
 LDAP_F( BerElement * )  LBER_F( BerElement * )
 ber_dup LDAP_P((  ber_dup LDAP_P((
         LDAP_CONST BerElement *ber ));          BerElement *ber ));
   
 LDAP_F( ber_tag_t )  LBER_F( ber_tag_t )
 ber_get_next LDAP_P((  ber_get_next LDAP_P((
         Sockbuf *sb,          Sockbuf *sb,
         ber_len_t *len,          ber_len_t *len,
         BerElement *ber ));          BerElement *ber ));
   
 LDAP_F( void )  LBER_F( void )
 ber_init_w_nullc LDAP_P((  ber_init_w_nullc LDAP_P((       /* DEPRECATED */
         BerElement *ber,          BerElement *ber,
         int options ));          int options ));
   
 LDAP_F( void )  LBER_F( void )
 ber_reset LDAP_P((  ber_reset LDAP_P((
         BerElement *ber,          BerElement *ber,
         int was_writing ));          int was_writing ));
   
 LDAP_F( BerElement * )  LBER_F( BerElement * )
 ber_init LDAP_P((  ber_init LDAP_P((
         struct berval *bv ));          struct berval *bv ));
   
 LDAP_F( int )  LBER_F( int )
 ber_flatten LDAP_P((  ber_flatten LDAP_P((
         LDAP_CONST BerElement *ber,          BerElement *ber,
         struct berval **bvPtr ));          struct berval **bvPtr ));
   
 /*  /*
  * LBER ber accessor functions   * LBER ber accessor functions
  */   */
   
 LDAP_F( int )  LBER_F( int )
 ber_get_option LDAP_P((  ber_get_option LDAP_P((
         LDAP_CONST void *item,          void *item,
         int option,          int option,
         void *outvalue));          void *outvalue));
   
 LDAP_F( int )  LBER_F( int )
 ber_set_option LDAP_P((  ber_set_option LDAP_P((
         void *item,          void *item,
         int option,          int option,
Line 432  ber_set_option LDAP_P(( Line 472  ber_set_option LDAP_P((
  * LBER sockbuf.c   * LBER sockbuf.c
  */   */
   
 LDAP_F( Sockbuf * )  LBER_F( Sockbuf *  )
 ber_sockbuf_alloc( void );  ber_sockbuf_alloc LDAP_P((
           void ));
   
   LBER_F( void )
   ber_sockbuf_free LDAP_P((
           Sockbuf *sb ));
   
   LBER_F( int )
   ber_sockbuf_add_io LDAP_P((
           Sockbuf *sb,
           Sockbuf_IO *sbio,
           int layer,
           void *arg ));
   
   LBER_F( int )
   ber_sockbuf_remove_io LDAP_P((
           Sockbuf *sb,
           Sockbuf_IO *sbio,
           int layer ));
   
 LDAP_F( Sockbuf *  )  LBER_F( int )
 ber_sockbuf_alloc_fd(  ber_sockbuf_ctrl LDAP_P((
         ber_socket_t fd );          Sockbuf *sb,
           int opt,
 LDAP_F( void )          void *arg ));
 ber_sockbuf_free(  
         Sockbuf *sb );  LBER_F( Sockbuf_IO ) ber_sockbuf_io_tcp;
   LBER_F( Sockbuf_IO ) ber_sockbuf_io_readahead;
   LBER_F( Sockbuf_IO ) ber_sockbuf_io_fd;
   LBER_F( Sockbuf_IO ) ber_sockbuf_io_debug;
   
 /*  /*
  * LBER memory.c   * LBER memory.c
  */   */
 LDAP_F( void * )  LBER_F( void * )
 ber_memalloc LDAP_P((  ber_memalloc LDAP_P((
         ber_len_t s ));          ber_len_t s ));
   
 LDAP_F( void * )  LBER_F( void * )
 ber_memrealloc LDAP_P((  ber_memrealloc LDAP_P((
         void* p,          void* p,
         ber_len_t s ));          ber_len_t s ));
   
 LDAP_F( void * )  LBER_F( void * )
 ber_memcalloc LDAP_P((  ber_memcalloc LDAP_P((
         ber_len_t n,          ber_len_t n,
         ber_len_t s ));          ber_len_t s ));
   
 LDAP_F( void )  LBER_F( void )
 ber_memfree LDAP_P((  ber_memfree LDAP_P((
         void* p ));          void* p ));
   
 LDAP_F( void )  LBER_F( void )
 ber_memvfree LDAP_P((  ber_memvfree LDAP_P((
         void** vector ));          void** vector ));
   
 LDAP_F( void )  LBER_F( void )
 ber_bvfree LDAP_P((  ber_bvfree LDAP_P((
         struct berval *bv ));          struct berval *bv ));
   
 LDAP_F( void )  LBER_F( void )
 ber_bvecfree LDAP_P((  ber_bvecfree LDAP_P((
         struct berval **bv ));          struct berval **bv ));
   
 LDAP_F( struct berval * )  LBER_F( int )
   ber_bvecadd LDAP_P((
           struct berval ***bvec,
           struct berval *bv ));
   
   LBER_F( struct berval * )
 ber_bvdup LDAP_P((  ber_bvdup LDAP_P((
         LDAP_CONST struct berval *bv ));          LDAP_CONST struct berval *bv ));
   
 LDAP_F( char * )  LBER_F( struct berval * )
   ber_bvstr LDAP_P((
           LDAP_CONST char * ));
   
   LBER_F( struct berval * )
   ber_bvstrdup LDAP_P((
           LDAP_CONST char * ));
   
   LBER_F( char * )
 ber_strdup LDAP_P((  ber_strdup LDAP_P((
         LDAP_CONST char * ));          LDAP_CONST char * ));
   
   /*
    * error.c
    */
   LBER_F( int * ) ber_errno_addr LDAP_P((void));
   #define ber_errno (*(ber_errno_addr)())
   
   #define LBER_ERROR_NONE         0
   #define LBER_ERROR_PARAM        0x1
   #define LBER_ERROR_MEMORY       0x2
   
 LDAP_END_DECL  LDAP_END_DECL
   
 #endif /* _LBER_H */  #endif /* _LBER_H */

Removed from v.1.32  
changed lines
  Added in v.1.32.6.9


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org