Cleanup: Complete renaming lber_*() to ber_*(). Fix some sockbuf SASL code rot.

[openldap] / libraries / liblber / memory.c

diff --git a/libraries/liblber/memory.c b/libraries/liblber/memory.c
index 5dcc1ec38864a68125075bd41b9a87aeba0a7870..312ab796fdad850d79bbbb8eb82c56a8876bf268 100644 (file)
--- a/libraries/liblber/memory.c
+++ b/libraries/liblber/memory.c
@@ -12,39 +12,67 @@
 
 #include "lber-int.h"
 
-#ifdef LDAP_MEMORY_DEBUG
+#if LDAP_MEMORY_DEBUG
 struct ber_mem_hdr {
        union bmu_align_u {
+               ber_len_t       bmu_len_t;
+               ber_tag_t       bmu_tag_t;
+               ber_int_t       bmu_int_t;
+
                size_t  bmu_size_t;
                void *  bmu_voidp;
                double  bmu_double;
                long    bmu_long;
+               long    (*bmu_funcp)( double );
+               char    bmu_char[4];
        } ber_align;
-#define bm_junk        ber_align.bmu_size_t
+#define bm_junk        ber_align.bmu_len_t
+#define bm_data        ber_align.bmu_char[1]
 };
 #define BER_MEM_JUNK 0xddeeddeeU
+static const struct ber_mem_hdr ber_int_mem_hdr = { BER_MEM_JUNK };
+#define BER_MEM_BADADDR        ((void *) &ber_int_mem_hdr.bm_data)
+#define BER_MEM_VALID(p)       do { \
+               assert( (p) != BER_MEM_BADADDR );       \
+               assert( (p) != (void *) &ber_int_mem_hdr );     \
+       } while(0)
+#else
+#define BER_MEM_VALID(p)       /* no-op */
 #endif
 
 BerMemoryFunctions *ber_int_memory_fns = NULL;
 
+#if 0 && defined( LDAP_MEMORY_DEBUG )
+void
+ber_int_memfree( void **p )
+{
+       assert( p != NULL );
+       BER_MEM_VALID( *p );
+
+       ber_memfree( p );
+
+       *p = BER_MEM_BADADDR;
+}
+#endif
+
 void
 ber_memfree( void *p )
 {
     ber_int_options.lbo_valid = LBER_INITIALIZED;
 
-       /* catch p == NULL when debugging */
-       assert( p != NULL );
-
-       /* ignore p == NULL when not debugging */
        if( p == NULL ) {
                return;
        }
 
+       BER_MEM_VALID( p );
+
        if( ber_int_memory_fns == NULL ) {
 #ifdef LDAP_MEMORY_DEBUG
                struct ber_mem_hdr *mh = (struct ber_mem_hdr *)
                        ((char *)p - sizeof(struct ber_mem_hdr));
-               assert( mh->bm_junk == BER_MEM_JUNK );
+
+               assert( mh->bm_junk == BER_MEM_JUNK );                          
+               mh->bm_junk = ~BER_MEM_JUNK;
                free( mh );
 #else
                free( p );
@@ -64,7 +92,13 @@ ber_memvfree( void **vec )
 {
        int     i;
 
-       assert(vec != NULL);    /* vec damn better point to something */
+    ber_int_options.lbo_valid = LBER_INITIALIZED;
+
+       if( vec == NULL ) {
+               return;
+       }
+
+       BER_MEM_VALID( vec );
 
        for ( i = 0; vec[i] != NULL; i++ ) {
                LBER_FREE( vec[i] );
@@ -75,14 +109,14 @@ ber_memvfree( void **vec )
 
 
 void *
-ber_memalloc( size_t s )
+ber_memalloc( ber_len_t s )
 {
     ber_int_options.lbo_valid = LBER_INITIALIZED;
 
-       /* catch s == 0 when debugging */
-       assert( s );
+#ifdef LDAP_MEMORY_DEBUG
+       assert( s != 0 );
+#endif
 
-       /* ignore s == 0 when not debugging */
        if( s == 0 ) {
                return NULL;
        }
@@ -95,6 +129,7 @@ ber_memalloc( size_t s )
 
                mh->bm_junk = BER_MEM_JUNK;
 
+               BER_MEM_VALID( &mh[1] );
                return &mh[1];
 #else
                return malloc( s );
@@ -108,14 +143,14 @@ ber_memalloc( size_t s )
 
 
 void *
-ber_memcalloc( size_t n, size_t s )
+ber_memcalloc( ber_len_t n, ber_len_t s )
 {
     ber_int_options.lbo_valid = LBER_INITIALIZED;
 
-       /* catch s,n == 0 when debugging */
-       assert( n && s );
+#ifdef LDAP_MEMORY_DEBUG
+       assert( n != 0 && s != 0);
+#endif
 
-       /* ignore s,n == 0 when not debugging */
        if( n == 0 || s == 0 ) {
                return NULL;
        }
@@ -126,6 +161,8 @@ ber_memcalloc( size_t n, size_t s )
                        (n * s) + sizeof(struct ber_mem_hdr) );
 
                mh->bm_junk = BER_MEM_JUNK;
+
+               BER_MEM_VALID( &mh[1] );
                return &mh[1];
 #else
                return calloc( n, s );
@@ -139,7 +176,7 @@ ber_memcalloc( size_t n, size_t s )
 
 
 void *
-ber_memrealloc( void* p, size_t s )
+ber_memrealloc( void* p, ber_len_t s )
 {
     ber_int_options.lbo_valid = LBER_INITIALIZED;
 
@@ -154,18 +191,23 @@ ber_memrealloc( void* p, size_t s )
                return NULL;
        }
 
+       BER_MEM_VALID( p );
+
        if( ber_int_memory_fns == NULL ) {
 #ifdef LDAP_MEMORY_DEBUG
                struct ber_mem_hdr *mh = (struct ber_mem_hdr *)
                        ((char *)p - sizeof(struct ber_mem_hdr));
                assert( mh->bm_junk == BER_MEM_JUNK );
 
-               p = realloc( mh, s );
+               p = realloc( mh, s + sizeof(struct ber_mem_hdr) );
 
                if( p == NULL ) return NULL;
 
                mh = p;
 
+               assert( mh->bm_junk == BER_MEM_JUNK );
+
+               BER_MEM_VALID( &mh[1] );
                return &mh[1];
 #else
                return realloc( p, s );
@@ -181,10 +223,14 @@ ber_memrealloc( void* p, size_t s )
 void
 ber_bvfree( struct berval *bv )
 {
-       assert(bv != NULL);                     /* bv damn better point to something */
-
        ber_int_options.lbo_valid = LBER_INITIALIZED;
 
+       if( bv == NULL ) {
+               return;
+       }
+
+       BER_MEM_VALID( bv );
+
        if ( bv->bv_val != NULL )
                LBER_FREE( bv->bv_val );
 
@@ -197,10 +243,14 @@ ber_bvecfree( struct berval **bv )
 {
        int     i;
 
-       assert(bv != NULL);                     /* bv damn better point to something */
-
        ber_int_options.lbo_valid = LBER_INITIALIZED;
 
+       if( bv == NULL ) {
+               return;
+       }
+
+       BER_MEM_VALID( bv );
+
        for ( i = 0; bv[i] != NULL; i++ )
                ber_bvfree( bv[i] );
 
@@ -214,15 +264,12 @@ ber_bvdup(
 {
        struct berval *new;
 
-       assert( bv != NULL );
-
        ber_int_options.lbo_valid = LBER_INITIALIZED;
 
        if( bv == NULL ) {
                return NULL;
        }
 
-
        if(( new = LBER_MALLOC( sizeof(struct berval) )) == NULL ) {
                return NULL;
        }
@@ -238,7 +285,7 @@ ber_bvdup(
                return NULL;
        }
 
-       SAFEMEMCPY( new->bv_val, bv->bv_val, (size_t) bv->bv_len );
+       SAFEMEMCPY( new->bv_val, bv->bv_val, bv->bv_len );
        new->bv_val[bv->bv_len] = '\0';
        new->bv_len = bv->bv_len;
 
@@ -246,15 +293,27 @@ ber_bvdup(
 }
 
 char *
-(ber_strdup)( LDAP_CONST char *s )
+ber_strdup( LDAP_CONST char *s )
 {
        char    *p;
-       size_t  len = strlen( s ) + 1;
+       size_t  len;
+       
+       ber_int_options.lbo_valid = LBER_INITIALIZED;
 
-       if ( (p = (char *) LBER_MALLOC( len )) == NULL ) {
+#ifdef LDAP_MEMORY_DEBUG
+       assert(s != NULL);                      /* bv damn better point to something */
+#endif
+
+       if( s == NULL ) {
+               return( NULL );
+       }
+
+       len = strlen( s ) + 1;
+
+       if ( (p = LBER_MALLOC( len )) == NULL ) {
                return( NULL );
        }
 
        SAFEMEMCPY( p, s, len );
        return( p );
-}
\ No newline at end of file
+}