ITS#5360 move tls option setup

[openldap] / libraries / liblber / io.c

diff --git a/libraries/liblber/io.c b/libraries/liblber/io.c
index f5f7ce9b166a6078c236985a56e0d6772896348e..a85f081aa49aba5627a2cf53452c911da6b48959 100644 (file)
--- a/libraries/liblber/io.c
+++ b/libraries/liblber/io.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2008 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -47,6 +47,25 @@
 #include "lber-int.h"
 #include "ldap_log.h"
 
+ber_slen_t
+ber_skip_data(
+       BerElement *ber,
+       ber_len_t len )
+{
+       ber_len_t       actuallen, nleft;
+
+       assert( ber != NULL );
+
+       assert( LBER_VALID( ber ) );
+
+       nleft = ber_pvt_ber_remaining( ber );
+       actuallen = nleft < len ? nleft : len;
+       ber->ber_ptr += actuallen;
+       ber->ber_tag = *(unsigned char *)ber->ber_ptr;
+
+       return( (ber_slen_t) actuallen );
+}
+
 ber_slen_t
 ber_read(
        BerElement *ber,
@@ -185,11 +204,8 @@ ber_free_buf( BerElement *ber )
 void
 ber_free( BerElement *ber, int freebuf )
 {
-#ifdef LDAP_MEMORY_DEBUG
-       assert( ber != NULL );
-#endif
-
        if( ber == NULL ) {
+               LDAP_MEMORY_DEBUG_ASSERT( ber != NULL );
                return;
        }
 
@@ -200,9 +216,17 @@ ber_free( BerElement *ber, int freebuf )
 
 int
 ber_flush( Sockbuf *sb, BerElement *ber, int freeit )
+{
+       return ber_flush2( sb, ber,
+               freeit ? LBER_FLUSH_FREE_ON_SUCCESS
+                       : LBER_FLUSH_FREE_NEVER );
+}
+
+int
+ber_flush2( Sockbuf *sb, BerElement *ber, int freeit )
 {
        ber_len_t       towrite;
-       ber_slen_t      rc;     
+       ber_slen_t      rc;
 
        assert( sb != NULL );
        assert( ber != NULL );
@@ -217,7 +241,7 @@ ber_flush( Sockbuf *sb, BerElement *ber, int freeit )
 
        if ( sb->sb_debug ) {
                ber_log_printf( LDAP_DEBUG_TRACE, sb->sb_debug,
-                       "ber_flush: %ld bytes to sd %ld%s\n",
+                       "ber_flush2: %ld bytes to sd %ld%s\n",
                        towrite, (long) sb->sb_fd,
                        ber->ber_rwptr != ber->ber_buf ?  " (re-flush)" : "" );
                ber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
@@ -231,16 +255,17 @@ ber_flush( Sockbuf *sb, BerElement *ber, int freeit )
 #else
                rc = ber_int_sb_write( sb, ber->ber_rwptr, towrite );
 #endif
-               if (rc<=0) {
+               if ( rc <= 0 ) {
+                       if ( freeit & LBER_FLUSH_FREE_ON_ERROR ) ber_free( ber, 1 );
                        return -1;
                }
                towrite -= rc;
                ber->ber_rwptr += rc;
        } 
 
-       if ( freeit ) ber_free( ber, 1 );
+       if ( freeit & LBER_FLUSH_FREE_ON_SUCCESS ) ber_free( ber, 1 );
 
-       return( 0 );
+       return 0;
 }
 
 BerElement *
@@ -248,8 +273,6 @@ ber_alloc_t( int options )
 {
        BerElement      *ber;
 
-    ber_int_options.lbo_valid = LBER_INITIALIZED;
-
        ber = (BerElement *) LBER_CALLOC( 1, sizeof(BerElement) );
 
        if ( ber == NULL ) {
@@ -301,8 +324,6 @@ ber_init2( BerElement *ber, struct berval *bv, int options )
 {
        assert( ber != NULL );
 
-       ber_int_options.lbo_valid = LBER_INITIALIZED;
-
        (void) memset( (char *)ber, '\0', sizeof( BerElement ));
        ber->ber_valid = LBER_VALID_BERELEMENT;
        ber->ber_tag = LBER_DEFAULT;
@@ -336,8 +357,6 @@ ber_init( struct berval *bv )
 
        assert( bv != NULL );
 
-    ber_int_options.lbo_valid = LBER_INITIALIZED;
-
        if ( bv == NULL ) {
                return NULL;
        }
@@ -377,8 +396,6 @@ int ber_flatten2(
 {
        assert( bv != NULL );
 
-       ber_int_options.lbo_valid = LBER_INITIALIZED;
-
        if ( bv == NULL ) {
                return -1;
        }
@@ -416,8 +433,6 @@ int ber_flatten(
  
        assert( bvPtr != NULL );
 
-       ber_int_options.lbo_valid = LBER_INITIALIZED;
-
        if(bvPtr == NULL) {
                return -1;
        }
@@ -473,8 +488,10 @@ ber_get_next(
        assert( SOCKBUF_VALID( sb ) );
        assert( LBER_VALID( ber ) );
 
-       ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
-               "ber_get_next\n" );
+       if ( ber->ber_debug & LDAP_DEBUG_TRACE ) {
+               ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
+                       "ber_get_next\n" );
+       }
 
        /*
         * Any ber element looks like this: tag length contents.
@@ -510,7 +527,7 @@ ber_get_next(
                char buf[sizeof(ber->ber_len)-1];
                ber_len_t tlen = 0;
 
-               errno = 0;
+               sock_errset(0);
                sblen=ber_int_sb_read( sb, ber->ber_rwptr,
                        ((char *)&ber->ber_len + LENSIZE*2 - 1)-ber->ber_rwptr);
                if (sblen<=0) return LBER_DEFAULT;
@@ -530,16 +547,16 @@ ber_get_next(
                                                break;
                                        /* Is the tag too big? */
                                        if (i == sizeof(ber_tag_t)-1) {
-                                               errno = ERANGE;
+                                               sock_errset(ERANGE);
                                                return LBER_DEFAULT;
                                        }
                                }
                                /* Did we run out of bytes? */
                                if ((char *)p == ber->ber_rwptr) {
 #if defined( EWOULDBLOCK )
-                                       errno = EWOULDBLOCK;
+                                       sock_errset(EWOULDBLOCK);
 #elif defined( EAGAIN )
-                                       errno = EAGAIN;
+                                       sock_errset(EAGAIN);
 #endif                 
                                        return LBER_DEFAULT;
                                }
@@ -550,28 +567,28 @@ ber_get_next(
 
                if ( ber->ber_ptr == ber->ber_rwptr ) {
 #if defined( EWOULDBLOCK )
-                       errno = EWOULDBLOCK;
+                       sock_errset(EWOULDBLOCK);
 #elif defined( EAGAIN )
-                       errno = EAGAIN;
+                       sock_errset(EAGAIN);
 #endif                 
                        return LBER_DEFAULT;
                }
 
                /* Now look for the length */
                if (*ber->ber_ptr & 0x80) {     /* multi-byte */
-                       ber_len_t i;
+                       int i;
                        unsigned char *p = (unsigned char *)ber->ber_ptr;
                        int llen = *p++ & 0x7f;
                        if (llen > (int)sizeof(ber_len_t)) {
-                               errno = ERANGE;
+                               sock_errset(ERANGE);
                                return LBER_DEFAULT;
                        }
                        /* Not enough bytes? */
                        if (ber->ber_rwptr - (char *)p < llen) {
 #if defined( EWOULDBLOCK )
-                               errno = EWOULDBLOCK;
+                               sock_errset(EWOULDBLOCK);
 #elif defined( EAGAIN )
-                               errno = EAGAIN;
+                               sock_errset(EAGAIN);
 #endif                 
                                return LBER_DEFAULT;
                        }
@@ -602,7 +619,7 @@ ber_get_next(
 
                /* make sure length is reasonable */
                if ( ber->ber_len == 0 ) {
-                       errno = ERANGE;
+                       sock_errset(ERANGE);
                        return LBER_DEFAULT;
                }
 
@@ -610,7 +627,7 @@ ber_get_next(
                        ber_log_printf( LDAP_DEBUG_CONNS, ber->ber_debug,
                                "ber_get_next: sockbuf_max_incoming exceeded "
                                "(%ld > %ld)\n", ber->ber_len, sb->sb_max_incoming );
-                       errno = ERANGE;
+                       sock_errset(ERANGE);
                        return LBER_DEFAULT;
                }
 
@@ -621,7 +638,7 @@ ber_get_next(
                         * already read.
                         */
                        if ( ber->ber_len < sblen + l ) {
-                               errno = ERANGE;
+                               sock_errset(ERANGE);
                                return LBER_DEFAULT;
                        }
                        ber->ber_buf = (char *) ber_memalloc_x( ber->ber_len + 1, ber->ber_memctx );
@@ -653,16 +670,16 @@ ber_get_next(
                to_go = ber->ber_end - ber->ber_rwptr;
                assert( to_go > 0 );
                
-               errno = 0;
+               sock_errset(0);
                res = ber_int_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;
+                       sock_errset(EWOULDBLOCK);
 #elif defined( EAGAIN )
-                       errno = EAGAIN;
+                       sock_errset(EAGAIN);
 #endif                 
                        return LBER_DEFAULT;
                }