/* io.c - ber general i/o routines */
/*
+ * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
+ * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+ */
+/* Portions
* Copyright (c) 1990 Regents of the University of Michigan.
* All rights reserved.
*
#include "lber-int.h"
-static int ber_realloc LDAP_P(( BerElement *ber, unsigned long len ));
-static int ber_filbuf LDAP_P(( Sockbuf *sb, long len ));
static long BerRead LDAP_P(( Sockbuf *sb, char *buf, long len ));
-#ifdef PCNFS
-static int BerWrite LDAP_P(( Sockbuf *sb, char *buf, long len ));
-#endif /* PCNFS */
-
-#define bergetc( sb, len ) ( sb->sb_ber.ber_end > sb->sb_ber.ber_ptr ? \
- (unsigned char)*sb->sb_ber.ber_ptr++ : \
- ber_filbuf( sb, len ))
-
-#ifdef MACOS
-/*
- * MacTCP/OpenTransport
- */
-#define read( s, b, l ) tcpread( s, 0, (unsigned char *)b, l, NULL )
-#define MAX_WRITE 65535
-#define BerWrite( sb, b, l ) tcpwrite( sb->sb_sd, (unsigned char *)(b), (l<MAX_WRITE)? l : MAX_WRITE )
-#else /* MACOS */
-#ifdef DOS
-#ifdef PCNFS
-/*
- * PCNFS (under DOS)
- */
-#define read( s, b, l ) recv( s, b, l, 0 )
-#define BerWrite( s, b, l ) send( s->sb_sd, b, (int) l, 0 )
-#endif /* PCNFS */
-#ifdef NCSA
-/*
- * NCSA Telnet TCP/IP stack (under DOS)
- */
-#define read( s, b, l ) nread( s, b, l )
-#define BerWrite( s, b, l ) netwrite( s->sb_sd, b, l )
-#endif /* NCSA */
-#ifdef WINSOCK
-/*
- * Windows Socket API (under DOS/Windows 3.x)
- */
-#define read( s, b, l ) recv( s, b, l, 0 )
-#define BerWrite( s, b, l ) send( s->sb_sd, b, l, 0 )
-#endif /* WINSOCK */
-#else /* DOS */
-#ifdef _WIN32
-/*
- * 32-bit Windows Socket API (under Windows NT or Windows 95)
- */
-#define read( s, b, l ) recv( s, b, l, 0 )
-#define BerWrite( s, b, l ) send( s->sb_sd, b, l, 0 )
-#else /* _WIN32 */
-#ifdef VMS
-/*
- * VMS -- each write must be 64K or smaller
- */
-#define MAX_WRITE 65535
-#define BerWrite( sb, b, l ) write( sb->sb_sd, b, (l<MAX_WRITE)? l : MAX_WRITE)
-#else /* VMS */
-/*
- * everything else (Unix/BSD 4.3 socket API)
- */
-#define BerWrite( sb, b, l ) write( sb->sb_sd, b, l )
-#endif /* VMS */
-#define udp_read( sb, b, l, al ) recvfrom(sb->sb_sd, (char *)b, l, 0, \
- (struct sockaddr *)sb->sb_fromaddr, \
- (al = sizeof(struct sockaddr), &al))
-#define udp_write( sb, b, l ) sendto(sb->sb_sd, (char *)(b), l, 0, \
- (struct sockaddr *)sb->sb_useaddr, sizeof(struct sockaddr))
-#endif /* _WIN32 */
-#endif /* DOS */
-#endif /* MACOS */
-
-#ifndef udp_read
-#define udp_read( sb, b, l, al ) CLDAP NOT SUPPORTED
-#define udp_write( sb, b, l ) CLDAP NOT SUPPORTED
-#endif /* udp_read */
+static int ber_realloc LDAP_P(( BerElement *ber, unsigned long len ));
#define EXBUFSIZ 1024
-static int
-ber_filbuf( Sockbuf *sb, long len )
-{
- short rc;
-#ifdef LDAP_CONNECTIONLESS
- int addrlen;
-#endif /* LDAP_CONNECTIONLESS */
-
- if ( sb->sb_ber.ber_buf == NULL ) {
- if ( (sb->sb_ber.ber_buf = (char *) malloc( READBUFSIZ )) ==
- NULL )
- return( -1 );
- sb->sb_ber.ber_ptr = sb->sb_ber.ber_buf;
- sb->sb_ber.ber_end = sb->sb_ber.ber_buf;
- }
-
- if ( sb->sb_naddr > 0 ) {
-#ifdef LDAP_CONNECTIONLESS
- rc = udp_read(sb, sb->sb_ber.ber_buf, READBUFSIZ, addrlen );
-#ifdef LDAP_DEBUG
- if ( lber_debug ) {
- fprintf( stderr, "ber_filbuf udp_read %d bytes\n",
- rc );
- if ( lber_debug > 1 && rc > 0 )
- lber_bprint( sb->sb_ber.ber_buf, rc );
- }
-#endif /* LDAP_DEBUG */
-#else /* LDAP_CONNECTIONLESS */
- rc = -1;
-#endif /* LDAP_CONNECTIONLESS */
- } else {
- rc = read( sb->sb_sd, sb->sb_ber.ber_buf,
- ((sb->sb_options & LBER_NO_READ_AHEAD) && (len < READBUFSIZ)) ?
- len : READBUFSIZ );
- }
-
- if ( rc > 0 ) {
- sb->sb_ber.ber_ptr = sb->sb_ber.ber_buf + 1;
- sb->sb_ber.ber_end = sb->sb_ber.ber_buf + rc;
- return( (unsigned char)*sb->sb_ber.ber_buf );
- }
-
- return( -1 );
-}
+/* probably far too large... */
+#define MAX_BERBUFSIZE (128*1024)
+#if defined( DOS ) && !defined( _WIN32 ) && (MAX_BERBUFSIZE > 65535)
+# undef MAX_BERBUFSIZE
+# define MAX_BERBUFSIZE 65535
+#endif
static long
BerRead( Sockbuf *sb, char *buf, long len )
int c;
long nread = 0;
+ assert( sb != NULL );
+ assert( buf != NULL );
+
while ( len > 0 ) {
- if ( (c = bergetc( sb, len )) < 0 ) {
+ if ( (c = ber_pvt_sb_read( sb, buf, len )) <= 0 ) {
if ( nread > 0 )
break;
return( c );
}
- *buf++ = (char) c;
- nread++;
- len--;
+ buf+= c;
+ nread+=c;
+ len-=c;
}
return( nread );
}
-
long
ber_read( BerElement *ber, char *buf, unsigned long len )
{
unsigned long actuallen, nleft;
+ assert( ber != NULL );
+ assert( buf != NULL );
+
nleft = ber->ber_end - ber->ber_ptr;
actuallen = nleft < len ? nleft : len;
}
long
-ber_write( BerElement *ber, char *buf, unsigned long len, int nosos )
+ber_write(
+ BerElement *ber,
+ LDAP_CONST char *buf,
+ unsigned long len,
+ int nosos )
{
+ assert( ber != NULL );
+ assert( buf != NULL );
+
if ( nosos || ber->ber_sos == NULL ) {
if ( ber->ber_ptr + len > ber->ber_end ) {
if ( ber_realloc( ber, len ) != 0 )
long off;
char *oldbuf;
+ assert( ber != NULL );
+ assert( len > 0 );
+
have = (ber->ber_end - ber->ber_buf) / EXBUFSIZ;
need = (len < EXBUFSIZ ? 1 : (len + (EXBUFSIZ - 1)) / EXBUFSIZ);
total = have * EXBUFSIZ + need * EXBUFSIZ;
void
ber_free( BerElement *ber, int freebuf )
{
+ assert( ber != NULL );
+
if ( freebuf && ber->ber_buf != NULL )
free( ber->ber_buf );
+ ber->ber_buf = NULL;
free( (char *) ber );
}
int
ber_flush( Sockbuf *sb, BerElement *ber, int freeit )
{
- long nwritten, towrite, rc;
+ long nwritten, towrite, rc;
+
+ assert( sb != NULL );
+ assert( ber != NULL );
if ( ber->ber_rwptr == NULL ) {
ber->ber_rwptr = ber->ber_buf;
}
towrite = ber->ber_ptr - ber->ber_rwptr;
-#ifdef LDAP_DEBUG
- if ( lber_debug ) {
- fprintf( stderr, "ber_flush: %ld bytes to sd %ld%s\n", towrite,
+ if ( sb->sb_debug ) {
+ ber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug,
+ "ber_flush: %ld bytes to sd %ld%s\n", towrite,
(long) sb->sb_sd, ber->ber_rwptr != ber->ber_buf ? " (re-flush)"
: "" );
- if ( lber_debug > 1 )
- lber_bprint( ber->ber_rwptr, towrite );
+ ber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
+ ber->ber_rwptr, towrite );
}
-#endif
+
#if !defined(MACOS) && !defined(DOS)
if ( sb->sb_options & (LBER_TO_FILE | LBER_TO_FILE_ONLY) ) {
- rc = write( sb->sb_fd, ber->ber_buf, towrite );
+ rc = write( sb->sb_fd, ber->ber_rwptr, towrite );
if ( sb->sb_options & LBER_TO_FILE_ONLY ) {
return( (int)rc );
}
}
#endif
-
+
nwritten = 0;
do {
- if (sb->sb_naddr > 0) {
-#ifdef LDAP_CONNECTIONLESS
- rc = udp_write( sb, ber->ber_buf + nwritten,
- (size_t)towrite );
-#else /* LDAP_CONNECTIONLESS */
- rc = -1;
-#endif /* LDAP_CONNECTIONLESS */
- if ( rc <= 0 )
- return( -1 );
-
- /* fake error if write was not atomic */
- if (rc < towrite) {
-#ifdef EMSGSIZE
- errno = EMSGSIZE;
-#endif
- return( -1 );
- }
- } else {
- if ( (rc = BerWrite( sb, ber->ber_rwptr,
- (size_t) towrite )) <= 0 ) {
- return( -1 );
- }
+ rc = ber_pvt_sb_write( sb, ber->ber_rwptr, towrite );
+ if (rc<=0) {
+ return -1;
}
towrite -= rc;
nwritten += rc;
{
BerElement *ber;
- if ( (ber = (BerElement *) calloc( 1, sizeof(BerElement) )) == NULLBER )
+ ber = (BerElement *) calloc( 1, sizeof(BerElement) );
+
+ if ( ber == NULLBER )
return( NULLBER );
+
ber->ber_tag = LBER_DEFAULT;
- ber->ber_options = (char) options;
+ ber->ber_options = options;
+ ber->ber_debug = ber_int_debug;
return( ber );
}
BerElement *
-ber_alloc( void )
+ber_alloc( void ) /* deprecated */
{
return( ber_alloc_t( 0 ) );
}
BerElement *
-der_alloc( void )
+der_alloc( void ) /* deprecated */
{
return( ber_alloc_t( LBER_USE_DER ) );
}
BerElement *
-ber_dup( BerElement *ber )
+ber_dup( LDAP_CONST BerElement *ber )
{
BerElement *new;
- if ( (new = ber_alloc()) == NULLBER )
- return( NULLBER );
+ assert( ber != NULL );
+
+ if ( (new = ber_alloc_t( ber->ber_options )) == NULL ) {
+ return( NULL );
+ }
*new = *ber;
}
+/* OLD U-Mich ber_init() */
void
ber_init_w_nullc( BerElement *ber, int options )
{
+ assert( ber != NULL );
+
(void) memset( (char *)ber, '\0', sizeof( BerElement ));
ber->ber_tag = LBER_DEFAULT;
ber->ber_options = (char) options;
+ ber->ber_debug = ber_int_debug;
}
+/* New C-API ber_init() */
+/* This function constructs a BerElement containing a copy
+** of the data in the bv argument.
+*/
BerElement *
ber_init( struct berval *bv )
{
- return ( NULL );
-}
+ BerElement *ber;
+ assert( bv != NULL );
-void
-ber_reset( BerElement *ber, int was_writing )
-{
- if ( was_writing ) {
- ber->ber_end = ber->ber_ptr;
- ber->ber_ptr = ber->ber_buf;
- } else {
- ber->ber_ptr = ber->ber_end;
+ if ( bv == NULL ) {
+ return NULL;
}
- ber->ber_rwptr = NULL;
-}
+ ber = ber_alloc_t( 0 );
+ if( ber == NULLBER ) {
+ /* allocation failed */
+ return ( NULL );
+ }
-#ifdef LDAP_DEBUG
+ /* copy the data */
+ if ( ( (unsigned int) ber_write ( ber, bv->bv_val, bv->bv_len, 0 )) != bv->bv_len ) {
+ /* write failed, so free and return NULL */
+ ber_free( ber, 1 );
+ return( NULL );
+ }
-void
-ber_dump( BerElement *ber, int inout )
+ ber_reset( ber, 1 ); /* reset the pointer to the start of the buffer */
+
+ return ( ber );
+}
+
+/* New C-API ber_flatten routine */
+/* This routine allocates a struct berval whose contents are a BER
+** encoding taken from the ber argument. The bvPtr pointer pointers to
+** the returned berval.
+*/
+int ber_flatten(
+ LDAP_CONST BerElement *ber,
+ struct berval **bvPtr)
{
- fprintf( stderr, "ber_dump: buf 0x%lx, ptr 0x%lx, end 0x%lx\n",
- (long) ber->ber_buf,
- (long) ber->ber_ptr,
- (long) ber->ber_end );
- if ( inout == 1 ) {
- fprintf( stderr, " current len %ld, contents:\n",
- (long) (ber->ber_end - ber->ber_ptr) );
- lber_bprint( ber->ber_ptr, ber->ber_end - ber->ber_ptr );
+ struct berval *bv;
+
+ assert( bvPtr != NULL );
+
+ if(bvPtr == NULL) {
+ return( -1 );
+ }
+
+ if ( (bv = malloc( sizeof(struct berval))) == NULL ) {
+ return( -1 );
+ }
+
+ if ( ber == NULL ) {
+ /* ber is null, create an empty berval */
+ bv->bv_val = NULL;
+ bv->bv_len = 0;
+
} else {
- fprintf( stderr, " current len %ld, contents:\n",
- (long) (ber->ber_ptr - ber->ber_buf) );
- lber_bprint( ber->ber_buf, ber->ber_ptr - ber->ber_buf );
+ /* copy the berval */
+ ptrdiff_t len = ber->ber_ptr - ber->ber_buf;
+
+ if ( (bv->bv_val = (char *) malloc( len + 1 )) == NULL ) {
+ ber_bvfree( bv );
+ return( -1 );
+ }
+
+ SAFEMEMCPY( bv->bv_val, ber->ber_buf, (size_t)len );
+ bv->bv_val[len] = '\0';
+ bv->bv_len = len;
}
+
+ *bvPtr = bv;
+ return( 0 );
}
void
-ber_sos_dump( Seqorset *sos )
+ber_reset( BerElement *ber, int was_writing )
{
- fprintf( stderr, "*** sos dump ***\n" );
- while ( sos != NULLSEQORSET ) {
- fprintf( stderr, "ber_sos_dump: clen %ld first 0x%lx ptr 0x%lx\n",
- (long) sos->sos_clen, (long) sos->sos_first, (long) sos->sos_ptr );
- fprintf( stderr, " current len %ld contents:\n",
- (long) (sos->sos_ptr - sos->sos_first) );
- lber_bprint( sos->sos_first, sos->sos_ptr - sos->sos_first );
-
- sos = sos->sos_next;
+ assert( ber != NULL );
+
+ if ( was_writing ) {
+ ber->ber_end = ber->ber_ptr;
+ ber->ber_ptr = ber->ber_buf;
+ } else {
+ ber->ber_ptr = ber->ber_end;
}
- fprintf( stderr, "*** end dump ***\n" );
-}
-#endif
+ ber->ber_rwptr = NULL;
+}
+#if 0
/* return the tag - LBER_DEFAULT returned means trouble */
static unsigned long
get_tag( Sockbuf *sb )
char *tagp;
unsigned int i;
- if ( BerRead( sb, (char *) &xbyte, 1 ) != 1 )
+ assert( sb != NULL );
+
+ if ( ber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 )
return( LBER_DEFAULT );
if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
tagp = (char *) &tag;
tagp[0] = xbyte;
for ( i = 1; i < sizeof(long); i++ ) {
- if ( BerRead( sb, (char *) &xbyte, 1 ) != 1 )
+ if ( ber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 )
return( LBER_DEFAULT );
tagp[i] = xbyte;
/* want leading, not trailing 0's */
return( tag >> (sizeof(long) - i - 1) );
}
+#endif
+
+/*
+ * A rewrite of ber_get_next that can safely be called multiple times
+ * for the same packet. It will simply continue were it stopped until
+ * a full packet is read.
+ */
unsigned long
ber_get_next( Sockbuf *sb, unsigned long *len, BerElement *ber )
{
- unsigned long tag = 0, netlen, toread;
- unsigned char lc;
- long rc;
- unsigned int noctets, diff;
-
-#ifdef LDAP_DEBUG
- if ( lber_debug )
- fprintf( stderr, "ber_get_next\n" );
-#endif
+ assert( sb != NULL );
+ assert( len != NULL );
+ assert( ber != NULL );
+ if ( ber->ber_debug ) {
+ ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
+ "ber_get_next\n" );
+ }
+
/*
* Any ber element looks like this: tag length contents.
* Assuming everything's ok, we return the tag byte (we
* 2) definite lengths
* 3) primitive encodings used whenever possible
*/
-
- /*
- * first time through - malloc the buffer, set up ptrs, and
- * read the tag and the length and as much of the rest as we can
- */
-
- if ( ber->ber_rwptr == NULL ) {
- /*
- * First, we read the tag.
- */
-
- if ( (tag = get_tag( sb )) == LBER_DEFAULT ) {
- return( LBER_DEFAULT );
- }
- ber->ber_tag = tag;
-
- /*
- * Next, read the length. The first byte contains the length
- * of the length. If bit 8 is set, the length is the long
- * form, otherwise it's the short form. We don't allow a
- * length that's greater than what we can hold in an unsigned
- * long.
+
+ if (ber->ber_rwptr == NULL) {
+ /* XXYYZ
+ * dtest does like this assert.
*/
+ /* assert( ber->ber_buf == NULL ); */
+ ber->ber_rwptr = (char *) &ber->ber_tag;
+ ber->ber_tag = 0;
+ }
- *len = netlen = 0;
- if ( BerRead( sb, (char *) &lc, 1 ) != 1 ) {
- return( LBER_DEFAULT );
+#define PTR_IN_VAR( ptr, var )\
+(((ptr)>=(char *) &(var)) && ((ptr)< (char *) &(var)+sizeof(var)))
+
+ if (PTR_IN_VAR(ber->ber_rwptr, ber->ber_tag)) {
+ if (ber->ber_rwptr == (char *) &ber->ber_tag) {
+ if (ber_pvt_sb_read( sb, ber->ber_rwptr, 1)<=0)
+ return LBER_DEFAULT;
+ if ((ber->ber_rwptr[0] & LBER_BIG_TAG_MASK)
+ != LBER_BIG_TAG_MASK) {
+ ber->ber_tag = ber->ber_rwptr[0];
+ ber->ber_rwptr = (char *) &ber->ber_usertag;
+ goto get_lenbyte;
+ }
+ ber->ber_rwptr++;
}
- if ( lc & 0x80 ) {
- noctets = (lc & 0x7f);
- if ( noctets > sizeof(unsigned long) )
- return( LBER_DEFAULT );
- diff = sizeof(unsigned long) - noctets;
- if ( BerRead( sb, (char *) &netlen + diff, noctets ) !=
- noctets ) {
- return( LBER_DEFAULT );
+ do {
+ /* reading the tag... */
+ if (ber_pvt_sb_read( sb, ber->ber_rwptr, 1)<=0)
+ return LBER_DEFAULT;
+ if (! (ber->ber_rwptr[0] & LBER_MORE_TAG_MASK) ) {
+ ber->ber_tag>>=sizeof(ber->ber_tag) -
+ ((char *) &ber->ber_tag - ber->ber_rwptr);
+ ber->ber_rwptr = (char *) &ber->ber_usertag;
+ goto get_lenbyte;
}
- *len = AC_NTOHL( netlen );
+ } while (PTR_IN_VAR(ber->ber_rwptr,ber->ber_tag));
+ errno = ERANGE; /* this is a serious error. */
+ return LBER_DEFAULT;
+ }
+get_lenbyte:
+ if (ber->ber_rwptr==(char *) &ber->ber_usertag) {
+ unsigned char c;
+ if (ber_pvt_sb_read( sb, (char *) &c, 1)<=0)
+ return LBER_DEFAULT;
+ if (c & 0x80U) {
+ int len = c & 0x7fU;
+ if ( (len==0) || ((unsigned) len>sizeof( ber->ber_len ) ) ) {
+ errno = ERANGE;
+ return LBER_DEFAULT;
+ }
+ ber->ber_rwptr = (char *) &ber->ber_len +
+ sizeof(ber->ber_len) - len;
+ ber->ber_len = 0;
} else {
- *len = lc;
+ ber->ber_len = c;
+ goto fill_buffer;
}
- ber->ber_len = *len;
-
- /*
- * Finally, malloc a buffer for the contents and read it in.
- * It's this buffer that's passed to all the other ber decoding
- * routines.
- */
-
-#if defined( DOS ) && !defined( _WIN32 )
- if ( *len > 65535 ) { /* DOS can't allocate > 64K */
- return( LBER_DEFAULT );
- }
-#endif /* DOS && !_WIN32 */
-
- if ( ( sb->sb_options & LBER_MAX_INCOMING_SIZE ) &&
- *len > (unsigned long) sb->sb_max_incoming ) {
- return( LBER_DEFAULT );
+ }
+ if (PTR_IN_VAR(ber->ber_rwptr, ber->ber_len)) {
+ int res;
+ int to_go;
+ to_go = (char *) &ber->ber_len + sizeof( ber->ber_len ) -
+ ber->ber_rwptr;
+ assert( to_go > 0 );
+ res = ber_pvt_sb_read( sb, ber->ber_rwptr, to_go );
+ if (res <=0)
+ return LBER_DEFAULT;
+ ber->ber_rwptr += res;
+ if (res==to_go) {
+ /* convert length. */
+ ber->ber_len = AC_NTOHL( ber->ber_len );
+ goto fill_buffer;
+ } else {
+#if defined( EWOULDBLOCK )
+ errno = EWOULDBLOCK;
+#elif defined( EAGAIN )
+ errno = EAGAIN;
+#endif
+ return LBER_DEFAULT;
}
-
- if ( (ber->ber_buf = (char *) malloc( (size_t)*len )) == NULL ) {
- return( LBER_DEFAULT );
+ }
+fill_buffer:
+ /* now fill the buffer. */
+ if (ber->ber_buf==NULL) {
+ if (ber->ber_len > MAX_BERBUFSIZE) {
+ errno = ERANGE;
+ return LBER_DEFAULT;
}
- ber->ber_ptr = ber->ber_buf;
- ber->ber_end = ber->ber_buf + *len;
+ ber->ber_buf = (char *) malloc( ber->ber_len );
+ if (ber->ber_buf==NULL)
+ return LBER_DEFAULT;
ber->ber_rwptr = ber->ber_buf;
+ ber->ber_ptr = ber->ber_buf;
+ ber->ber_end = ber->ber_buf + ber->ber_len;
}
-
- toread = (unsigned long)ber->ber_end - (unsigned long)ber->ber_rwptr;
- do {
- if ( (rc = BerRead( sb, ber->ber_rwptr, (long)toread )) <= 0 ) {
- return( LBER_DEFAULT );
+ if ((ber->ber_rwptr>=ber->ber_buf) && (ber->ber_rwptr<ber->ber_end)) {
+ int res;
+ int to_go;
+
+ to_go = ber->ber_end - ber->ber_rwptr;
+ assert( to_go > 0 );
+
+ res = ber_pvt_sb_read( sb, ber->ber_rwptr, to_go );
+ if (res<=0)
+ return LBER_DEFAULT;
+ ber->ber_rwptr+=res;
+
+ if (res<to_go) {
+#if defined( EWOULDBLOCK )
+ errno = EWOULDBLOCK;
+#elif defined( EAGAIN )
+ errno = EAGAIN;
+#endif
+ return LBER_DEFAULT;
}
-
- toread -= rc;
- ber->ber_rwptr += rc;
- } while ( toread > 0 );
-
-#ifdef LDAP_DEBUG
- if ( lber_debug ) {
- fprintf( stderr, "ber_get_next: tag 0x%lx len %ld contents:\n",
- tag, ber->ber_len );
- if ( lber_debug > 1 )
- ber_dump( ber, 1 );
+
+ ber->ber_rwptr = NULL;
+ *len = ber->ber_len;
+ if ( ber->ber_debug ) {
+ ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
+ "ber_get_next: tag 0x%lx len %ld contents:\n",
+ ber->ber_tag, ber->ber_len );
+ ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
+ }
+ return (ber->ber_tag);
}
-#endif
+ assert( 0 ); /* ber structure is messed up ?*/
+ return LBER_DEFAULT;
+}
- *len = ber->ber_len;
+void ber_clear( BerElement *ber, int freebuf )
+{
+ assert( ber != NULL );
+
+ if ((freebuf) && (ber->ber_buf))
+ free( ber->ber_buf );
+ ber->ber_buf = NULL;
ber->ber_rwptr = NULL;
- return( ber->ber_tag );
+ ber->ber_end = NULL;
}
+