/* 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.
*
* is provided ``as is'' without express or implied warranty.
*/
-#define DISABLE_BRIDGE
#include "portable.h"
#include <stdio.h>
#include <stdlib.h>
+#include <ac/ctype.h>
+#include <ac/errno.h>
+#include <ac/socket.h>
#include <ac/string.h>
-#include <ctype.h>
-#include <unistd.h>
-
-#if defined( DOS ) || defined( _WIN32 )
-#include "msdos.h"
-#endif /* DOS || _WIN32 */
+#include <ac/unistd.h>
-#ifdef MACOS
-#include "macos.h"
-#else /* MACOS */
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#ifdef PCNFS
-#include <tklib.h>
-#endif /* PCNFS */
-#endif /* MACOS */
-
-#ifdef _WIN32
-#include <winsock.h>
+#ifdef HAVE_IO_H
#include <io.h>
-#endif /* _WIN32 */
+#endif
-#include "lber.h"
+#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 ));
#define EXBUFSIZ 1024
-int
+static int
ber_filbuf( Sockbuf *sb, long len )
{
short rc;
-#ifdef CLDAP
+#ifdef LDAP_CONNECTIONLESS
int addrlen;
-#endif /* CLDAP */
+#endif /* LDAP_CONNECTIONLESS */
if ( sb->sb_ber.ber_buf == NULL ) {
if ( (sb->sb_ber.ber_buf = (char *) malloc( READBUFSIZ )) ==
}
if ( sb->sb_naddr > 0 ) {
-#ifdef CLDAP
+#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 );
+
+ if ( sb->sb_debug ) {
+ lber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug,
+ "ber_filbuf udp_read %d bytes\n",
+ rc );
+ if ( rc > 0 )
+ lber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
+ sb->sb_ber.ber_buf, rc );
}
-#endif /* LDAP_DEBUG */
-#else /* CLDAP */
+#else /* LDAP_CONNECTIONLESS */
rc = -1;
-#endif /* CLDAP */
+#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 );
+ ((sb->sb_options & LBER_NO_READ_AHEAD) && (len < READBUFSIZ)) ?
+ len : READBUFSIZ );
}
if ( rc > 0 ) {
}
-long
+static long
BerRead( Sockbuf *sb, char *buf, long len )
{
int c;
break;
return( c );
}
- *buf++ = c;
+ *buf++ = (char) c;
nread++;
len--;
}
}
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 ) {
+ lber_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 );
+ lber_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 );
nwritten = 0;
do {
if (sb->sb_naddr > 0) {
-#ifdef CLDAP
+#ifdef LDAP_CONNECTIONLESS
rc = udp_write( sb, ber->ber_buf + nwritten,
(size_t)towrite );
-#else /* CLDAP */
+#else /* LDAP_CONNECTIONLESS */
rc = -1;
-#endif /* CLDAP */
+#endif /* LDAP_CONNECTIONLESS */
if ( rc <= 0 )
return( -1 );
+
/* fake error if write was not atomic */
if (rc < towrite) {
-#if !defined( MACOS ) && !defined( DOS )
+#ifdef EMSGSIZE
errno = EMSGSIZE;
#endif
return( -1 );
return( NULLBER );
ber->ber_tag = LBER_DEFAULT;
ber->ber_options = options;
+ ber->ber_debug = lber_int_debug;
return( ber );
}
BerElement *
-ber_alloc()
+ber_alloc( void )
{
return( ber_alloc_t( 0 ) );
}
BerElement *
-der_alloc()
+der_alloc( void )
{
return( ber_alloc_t( LBER_USE_DER ) );
}
}
+/* OLD U-Mich ber_init() */
void
-ber_init( BerElement *ber, int options )
+ber_init_w_nullc( BerElement *ber, int options )
{
(void) memset( (char *)ber, '\0', sizeof( BerElement ));
ber->ber_tag = LBER_DEFAULT;
- ber->ber_options = options;
+ ber->ber_options = (char) options;
}
-
-void
-ber_reset( BerElement *ber, int was_writing )
+/* 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 )
{
- if ( was_writing ) {
- ber->ber_end = ber->ber_ptr;
- ber->ber_ptr = ber->ber_buf;
- } else {
- ber->ber_ptr = ber->ber_end;
+ BerElement *ber;
+
+ 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 ( (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(
+ 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;
+
+ 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;
+ 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;
+}
/* return the tag - LBER_DEFAULT returned means trouble */
static unsigned long
unsigned char xbyte;
unsigned long tag;
char *tagp;
- int i;
+ unsigned int i;
if ( BerRead( sb, (char *) &xbyte, 1 ) != 1 )
return( LBER_DEFAULT );
unsigned long tag = 0, netlen, toread;
unsigned char lc;
long rc;
- int noctets, diff;
+ long noctets;
+ unsigned int diff;
-#ifdef LDAP_DEBUG
- if ( lber_debug )
- fprintf( stderr, "ber_get_next\n" );
-#endif
+ if ( ber->ber_debug ) {
+ lber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
+ "ber_get_next\n" );
+ }
/*
* Any ber element looks like this: tag length contents.
noctets ) {
return( LBER_DEFAULT );
}
- *len = LBER_NTOHL( netlen );
+ *len = AC_NTOHL( netlen );
} else {
*len = lc;
}
#endif /* DOS && !_WIN32 */
if ( ( sb->sb_options & LBER_MAX_INCOMING_SIZE ) &&
- *len > sb->sb_max_incoming ) {
+ *len > (unsigned long) sb->sb_max_incoming ) {
return( LBER_DEFAULT );
}
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",
+ if ( ber->ber_debug ) {
+ lber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
+ "ber_get_next: tag 0x%lx len %ld contents:\n",
tag, ber->ber_len );
- if ( lber_debug > 1 )
- ber_dump( ber, 1 );
+
+ lber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
}
-#endif
*len = ber->ber_len;
ber->ber_rwptr = NULL;
return( ber->ber_tag );
}
+
+Sockbuf *lber_sockbuf_alloc( void )
+{
+ Sockbuf *sb = calloc(1, sizeof(Sockbuf));
+ sb->sb_debug = lber_int_debug;
+ return sb;
+}
+
+Sockbuf *lber_sockbuf_alloc_fd( int fd )
+{
+ Sockbuf *sb = lber_sockbuf_alloc();
+ sb->sb_sd = fd;
+
+ return sb;
+}
+
+void lber_sockbuf_free( Sockbuf *sb )
+{
+ if(sb == NULL) return;
+
+ free(sb);
+}
+
+int lber_sockbuf_get_option( Sockbuf *sb, int opt, void *outvalue )
+{
+ return LBER_OPT_ERROR;
+}
+
+int lber_sockbuf_set_option( Sockbuf *sb, int opt, void *invalue )
+{
+ return LBER_OPT_ERROR;
+}