Coverted LDAP_LOG macro to use subsystem ID int values instead of string values

[openldap] / libraries / liblber / memory.c

diff --git a/libraries/liblber/memory.c b/libraries/liblber/memory.c
index d836dcc6eab3ad0f55b38c7cc14bde3e0b01369e..599a542988ad757e9e3b342b4f1265fcaaec65e6 100644 (file)
--- a/libraries/liblber/memory.c
+++ b/libraries/liblber/memory.c
@@ -1,6 +1,6 @@
 /* $OpenLDAP$ */
 /*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 #include "portable.h"
@@ -112,19 +112,6 @@ static unsigned char endpattern[4] = { 0xd1, 0xed, 0xde, 0xca };
 
 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 )
 {
@@ -294,12 +281,12 @@ ber_memrealloc( void* p, ber_len_t s )
 
        /* realloc(NULL,s) -> malloc(s) */
        if( p == NULL ) {
-               return ber_memalloc( s );
+               return LBER_MALLOC( s );
        }
        
        /* realloc(p,0) -> free(p) */
        if( s == 0 ) {
-               ber_memfree( p );
+               LBER_FREE( p );
                return NULL;
        }
 
@@ -407,7 +394,7 @@ ber_bvecadd( struct berval ***bvec, struct berval *bv )
                        return 0;
                }
 
-               *bvec = ber_memalloc( 2 * sizeof(struct berval *) );
+               *bvec = LBER_MALLOC( 2 * sizeof(struct berval *) );
 
                if( *bvec == NULL ) {
                        return -1;
@@ -430,7 +417,7 @@ ber_bvecadd( struct berval ***bvec, struct berval *bv )
                return i;
        }
 
-       new = ber_memrealloc( *bvec, (i+2) * sizeof(struct berval *));
+       new = LBER_REALLOC( *bvec, (i+2) * sizeof(struct berval *));
 
        if( new == NULL ) {
                return -1;
@@ -446,45 +433,59 @@ ber_bvecadd( struct berval ***bvec, struct berval *bv )
 
 
 struct berval *
-ber_bvdup(
-       LDAP_CONST struct berval *bv )
+ber_dupbv(
+       struct berval *dst, struct berval *src )
 {
        struct berval *new;
 
        ber_int_options.lbo_valid = LBER_INITIALIZED;
 
-       if( bv == NULL ) {
+       if( src == NULL ) {
                ber_errno = LBER_ERROR_PARAM;
                return NULL;
        }
 
-       if(( new = LBER_MALLOC( sizeof(struct berval) )) == NULL ) {
-               ber_errno = LBER_ERROR_MEMORY;
-               return NULL;
+       if ( dst ) {
+               new = dst;
+       } else {
+               if(( new = LBER_MALLOC( sizeof(struct berval) )) == NULL ) {
+                       ber_errno = LBER_ERROR_MEMORY;
+                       return NULL;
+               }
        }
 
-       if ( bv->bv_val == NULL ) {
+       if ( src->bv_val == NULL ) {
                new->bv_val = NULL;
                new->bv_len = 0;
                return new;
        }
 
-       if(( new->bv_val = LBER_MALLOC( bv->bv_len + 1 )) == NULL ) {
+       if(( new->bv_val = LBER_MALLOC( src->bv_len + 1 )) == NULL ) {
                ber_errno = LBER_ERROR_MEMORY;
-               LBER_FREE( new );
+               if ( !dst )
+                       LBER_FREE( new );
                return NULL;
        }
 
-       AC_MEMCPY( new->bv_val, bv->bv_val, bv->bv_len );
-       new->bv_val[bv->bv_len] = '\0';
-       new->bv_len = bv->bv_len;
+       AC_MEMCPY( new->bv_val, src->bv_val, src->bv_len );
+       new->bv_val[src->bv_len] = '\0';
+       new->bv_len = src->bv_len;
 
        return new;
 }
 
+
 struct berval *
-ber_bvstr(
-       LDAP_CONST char *s )
+ber_bvdup(
+       struct berval *src )
+{
+       return ber_dupbv( NULL, src );
+}
+
+
+struct berval *
+ber_str2bv(
+       LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv)
 {
        struct berval *new;
 
@@ -495,45 +496,71 @@ ber_bvstr(
                return NULL;
        }
 
-       if(( new = LBER_MALLOC( sizeof(struct berval) )) == NULL ) {
-               ber_errno = LBER_ERROR_MEMORY;
-               return NULL;
+       if( bv ) {
+               new = bv;
+       } else {
+               if(( new = LBER_MALLOC( sizeof(struct berval) )) == NULL ) {
+                       ber_errno = LBER_ERROR_MEMORY;
+                       return NULL;
+               }
        }
 
-       new->bv_val = (char *) s;
-       new->bv_len = strlen( s );
+       new->bv_len = len ? len : strlen( s );
+       if ( dup ) {
+               if ( (new->bv_val = LBER_MALLOC( new->bv_len+1 )) == NULL ) {
+                       ber_errno = LBER_ERROR_MEMORY;
+                       if ( !bv )
+                               LBER_FREE( new );
+                       return NULL;
+               }
+
+               AC_MEMCPY( new->bv_val, s, new->bv_len );
+               new->bv_val[new->bv_len] = '\0';
+       } else {
+               new->bv_val = (char *) s;
+       }
 
        return( new );
 }
 
 struct berval *
-ber_bvstrdup(
-       LDAP_CONST char *s )
+ber_mem2bv(
+       LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv)
 {
        struct berval *new;
-       char *p;
 
        ber_int_options.lbo_valid = LBER_INITIALIZED;
 
-       if( s == NULL ) {
+       if( s == NULL || len == 0 ) {
                ber_errno = LBER_ERROR_PARAM;
                return NULL;
        }
 
-       p = LBER_STRDUP( s );
-
-       if( p == NULL ) {
-               ber_errno = LBER_ERROR_MEMORY;
-               return NULL;
+       if( bv ) {
+               new = bv;
+       } else {
+               if(( new = LBER_MALLOC( sizeof(struct berval) )) == NULL ) {
+                       ber_errno = LBER_ERROR_MEMORY;
+                       return NULL;
+               }
        }
 
-       new = ber_bvstr( p );
+       new->bv_len = len;
+       if ( dup ) {
+               if ( (new->bv_val = LBER_MALLOC( new->bv_len+1 )) == NULL ) {
+                       ber_errno = LBER_ERROR_MEMORY;
+                       if ( !bv )
+                               LBER_FREE( new );
+                       return NULL;
+               }
 
-       if( new == NULL || *p == '\0' ) {
-               LBER_FREE( p );
+               AC_MEMCPY( new->bv_val, s, new->bv_len );
+               new->bv_val[new->bv_len] = '\0';
+       } else {
+               new->bv_val = (char *) s;
        }
 
-       return new;
+       return( new );
 }
 
 char *
@@ -616,3 +643,58 @@ ber_strndup__( LDAP_CONST char *s, size_t l )
        p[ len ] = '\0';
        return p;
 }
+
+void
+ber_bvarray_free( BerVarray a )
+{
+       int i;
+
+       ber_int_options.lbo_valid = LBER_INITIALIZED;
+
+       if (a) {
+               BER_MEM_VALID( a );
+
+               for (i=0; a[i].bv_val; i++) {
+                       LBER_FREE(a[i].bv_val);
+               }
+
+               LBER_FREE(a);
+       }
+}
+
+int
+ber_bvarray_add( BerVarray *a, BerValue *bv )
+{
+       int     n;
+
+       ber_int_options.lbo_valid = LBER_INITIALIZED;
+
+       if ( *a == NULL ) {
+               if (bv == NULL) {
+                       return 0;
+               }
+               n = 0;
+               *a = (BerValue *) LBER_MALLOC( 2 * sizeof(BerValue) );
+       } else {
+               BER_MEM_VALID( a );
+
+               for ( n = 0; *a != NULL && (*a)[n].bv_val != NULL; n++ ) {
+                       ;       /* NULL */
+               }
+
+               if (bv == NULL) {
+                       return n;
+               }
+               *a = (BerValue *) LBER_REALLOC( (char *) *a,
+                   (n + 2) * sizeof(BerValue) );
+       }
+       if ( *a == NULL ) {
+               return -1;
+       }
+
+       (*a)[n++] = *bv;
+       (*a)[n].bv_val = NULL;
+
+       return n;
+}
+