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 5c3910f44a3496ed6d463661791d456eefaf3b29..312ab796fdad850d79bbbb8eb82c56a8876bf268 100644 (file)
--- a/libraries/liblber/memory.c
+++ b/libraries/liblber/memory.c
@@ -4,34 +4,85 @@
  */
 #include "portable.h"
 
-#include <stdlib.h>
+#include <ac/stdlib.h>
 #include <ac/string.h>
 
+#undef LDAP_F_PRE
+#define LDAP_F_PRE LDAP_F_EXPORT
+
 #include "lber-int.h"
 
+#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_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 );                          
+               mh->bm_junk = ~BER_MEM_JUNK;
+               free( mh );
+#else
                free( p );
+#endif
                return;
        }
 
        assert( ber_int_memory_fns->bmf_free );
 
+               
        (*ber_int_memory_fns->bmf_free)( p );
 }
 
@@ -41,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] );
@@ -52,20 +109,31 @@ 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;
        }
 
        if( ber_int_memory_fns == NULL ) {
+#ifdef LDAP_MEMORY_DEBUG
+               struct ber_mem_hdr *mh = malloc(s + sizeof(struct ber_mem_hdr));
+
+               if( mh == NULL ) return NULL;
+
+               mh->bm_junk = BER_MEM_JUNK;
+
+               BER_MEM_VALID( &mh[1] );
+               return &mh[1];
+#else
                return malloc( s );
+#endif
        }
 
        assert( ber_int_memory_fns->bmf_malloc );
@@ -75,20 +143,30 @@ 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;
        }
 
        if( ber_int_memory_fns == NULL ) {
+#ifdef LDAP_MEMORY_DEBUG
+               struct ber_mem_hdr *mh = calloc(1,
+                       (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 );
+#endif
        }
 
        assert( ber_int_memory_fns->bmf_calloc );
@@ -98,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;
 
@@ -113,8 +191,27 @@ 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 + 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 );
+#endif
        }
 
        assert( ber_int_memory_fns->bmf_realloc );
@@ -126,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 );
 
@@ -142,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] );
 
@@ -159,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;
        }
@@ -183,9 +285,35 @@ 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;
 
        return( new );
 }
+
+char *
+ber_strdup( LDAP_CONST char *s )
+{
+       char    *p;
+       size_t  len;
+       
+       ber_int_options.lbo_valid = LBER_INITIALIZED;
+
+#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 );
+}