X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Fliblber%2Fmemory.c;h=18b5bac87621dda49941a61dd3050361d63e3639;hb=42f3b3d87b8bea05ab97304866ebc5cfae2890e7;hp=309fbeab778dbd06886f0f6771063a1fda5813e6;hpb=978e417699699579fb0b858ad485f36399220c4d;p=openldap

diff --git a/libraries/liblber/memory.c b/libraries/liblber/memory.c
index 309fbeab77..18b5bac876 100644
--- a/libraries/liblber/memory.c
+++ b/libraries/liblber/memory.c
@@ -1,8 +1,18 @@
 /* $OpenLDAP$ */
-/*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
- * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 1998-2004 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
  */
+
 #include "portable.h"
 
 #include <ac/stdlib.h>
@@ -53,7 +63,7 @@ struct ber_mem_hdr {
 };
 
 /* Pattern at top of allocated space */
-#define LLBER_MEM_JUNK 0xdeaddadaU
+#define LBER_MEM_JUNK 0xdeaddadaU
 
 static const struct ber_mem_hdr ber_int_mem_hdr = { LBER_MEM_JUNK, 0, 0 };
 
@@ -112,21 +122,8 @@ 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 )
+ber_memfree_x( void *p, void *ctx )
 {
     ber_int_options.lbo_valid = LBER_INITIALIZED;
 
@@ -136,7 +133,7 @@ ber_memfree( void *p )
 
 	BER_MEM_VALID( p );
 
-	if( ber_int_memory_fns == NULL ) {
+	if( ber_int_memory_fns == NULL || ctx == NULL ) {
 #ifdef LDAP_MEMORY_DEBUG
 		struct ber_mem_hdr *mh = (struct ber_mem_hdr *)
 			((char *)p - sizeof(struct ber_mem_hdr));
@@ -160,16 +157,21 @@ ber_memfree( void *p )
 
 	assert( ber_int_memory_fns->bmf_free );
 
-	(*ber_int_memory_fns->bmf_free)( p );
+	(*ber_int_memory_fns->bmf_free)( p, ctx );
 }
 
+void
+ber_memfree( void *p )
+{
+	ber_memfree_x(p, NULL);
+}
 
 void
-ber_memvfree( void **vec )
+ber_memvfree_x( void **vec, void *ctx )
 {
 	int	i;
 
-    ber_int_options.lbo_valid = LBER_INITIALIZED;
+	ber_int_options.lbo_valid = LBER_INITIALIZED;
 
 	if( vec == NULL ) {
 		return;
@@ -178,18 +180,23 @@ ber_memvfree( void **vec )
 	BER_MEM_VALID( vec );
 
 	for ( i = 0; vec[i] != NULL; i++ ) {
-		LBER_FREE( vec[i] );
+		ber_memfree_x( vec[i], ctx );
 	}
 
-	LBER_FREE( vec );
+	ber_memfree_x( vec, ctx );
 }
 
+void
+ber_memvfree( void **vec )
+{
+	ber_memvfree_x( vec, NULL );
+}
 
 void *
-ber_memalloc( ber_len_t s )
+ber_memalloc_x( ber_len_t s, void *ctx )
 {
 	void *new;
-    ber_int_options.lbo_valid = LBER_INITIALIZED;
+	ber_int_options.lbo_valid = LBER_INITIALIZED;
 
 #ifdef LDAP_MEMORY_DEBUG
 	assert( s != 0 );
@@ -199,7 +206,7 @@ ber_memalloc( ber_len_t s )
 		return NULL;
 	}
 
-	if( ber_int_memory_fns == NULL ) {
+	if( ber_int_memory_fns == NULL || ctx == NULL ) {
 #ifdef LDAP_MEMORY_DEBUG
 		struct ber_mem_hdr *mh = malloc(s + sizeof(struct ber_mem_hdr) + sizeof( ber_int_t));
 		if( mh == NULL ) return NULL;
@@ -225,7 +232,7 @@ ber_memalloc( ber_len_t s )
 		new = malloc( s );
 #endif
 	} else {
-		new = (*ber_int_memory_fns->bmf_malloc)( s );
+		new = (*ber_int_memory_fns->bmf_malloc)( s, ctx );
 	}
 
 	if( new == NULL ) {
@@ -235,12 +242,17 @@ ber_memalloc( ber_len_t s )
 	return new;
 }
 
+void *
+ber_memalloc( ber_len_t s )
+{
+	return ber_memalloc_x( s, NULL );
+}
 
 void *
-ber_memcalloc( ber_len_t n, ber_len_t s )
+ber_memcalloc_x( ber_len_t n, ber_len_t s, void *ctx )
 {
 	void *new;
-    ber_int_options.lbo_valid = LBER_INITIALIZED;
+	ber_int_options.lbo_valid = LBER_INITIALIZED;
 
 #ifdef LDAP_MEMORY_DEBUG
 	assert( n != 0 && s != 0);
@@ -250,7 +262,7 @@ ber_memcalloc( ber_len_t n, ber_len_t s )
 		return NULL;
 	}
 
-	if( ber_int_memory_fns == NULL ) {
+	if( ber_int_memory_fns == NULL || ctx == NULL ) {
 #ifdef LDAP_MEMORY_DEBUG
 		struct ber_mem_hdr *mh = calloc(1,
 			(n * s) + sizeof(struct ber_mem_hdr) + sizeof(ber_int_t) );
@@ -275,7 +287,7 @@ ber_memcalloc( ber_len_t n, ber_len_t s )
 #endif
 
 	} else {
-		new = (*ber_int_memory_fns->bmf_calloc)( n, s );
+		new = (*ber_int_memory_fns->bmf_calloc)( n, s, ctx );
 	}
 
 	if( new == NULL ) {
@@ -285,27 +297,32 @@ ber_memcalloc( ber_len_t n, ber_len_t s )
 	return new;
 }
 
+void *
+ber_memcalloc( ber_len_t n, ber_len_t s )
+{
+	return ber_memcalloc_x( n, s, NULL );
+}
 
 void *
-ber_memrealloc( void* p, ber_len_t s )
+ber_memrealloc_x( void* p, ber_len_t s, void *ctx )
 {
 	void *new = NULL;
-    ber_int_options.lbo_valid = LBER_INITIALIZED;
+	ber_int_options.lbo_valid = LBER_INITIALIZED;
 
 	/* realloc(NULL,s) -> malloc(s) */
 	if( p == NULL ) {
-		return ber_memalloc( s );
+		return ber_memalloc_x( s, ctx );
 	}
 	
 	/* realloc(p,0) -> free(p) */
 	if( s == 0 ) {
-		ber_memfree( p );
+		ber_memfree_x( p, ctx );
 		return NULL;
 	}
 
 	BER_MEM_VALID( p );
 
-	if( ber_int_memory_fns == NULL ) {
+	if( ber_int_memory_fns == NULL || ctx == NULL ) {
 #ifdef LDAP_MEMORY_DEBUG
 		ber_int_t oldlen;
 		struct ber_mem_hdr *mh = (struct ber_mem_hdr *)
@@ -324,7 +341,7 @@ ber_memrealloc( void* p, ber_len_t s )
 			mh = p;
 		mh->bm_length = s;
 		setend( (char *)&mh[1] + mh->bm_length );
-		if( (s - oldlen) > 0 ) {
+		if( s > oldlen ) {
 			/* poison any new memory */
 			memset( (char *)&mh[1] + oldlen, 0xff, s - oldlen);
 		}
@@ -343,7 +360,7 @@ ber_memrealloc( void* p, ber_len_t s )
 		new = realloc( p, s );
 #endif
 	} else {
-		new = (*ber_int_memory_fns->bmf_realloc)( p, s );
+		new = (*ber_int_memory_fns->bmf_realloc)( p, s, ctx );
 	}
 
 	if( new == NULL ) {
@@ -353,9 +370,14 @@ ber_memrealloc( void* p, ber_len_t s )
 	return new;
 }
 
+void *
+ber_memrealloc( void* p, ber_len_t s )
+{
+	return ber_memrealloc_x( p, s, NULL );
+}
 
 void
-ber_bvfree( struct berval *bv )
+ber_bvfree_x( struct berval *bv, void *ctx )
 {
 	ber_int_options.lbo_valid = LBER_INITIALIZED;
 
@@ -366,15 +388,20 @@ ber_bvfree( struct berval *bv )
 	BER_MEM_VALID( bv );
 
 	if ( bv->bv_val != NULL ) {
-		LBER_FREE( bv->bv_val );
+		ber_memfree_x( bv->bv_val, ctx );
 	}
 
-	LBER_FREE( (char *) bv );
+	ber_memfree_x( (char *) bv, ctx );
 }
 
+void
+ber_bvfree( struct berval *bv )
+{
+	ber_bvfree_x( bv, NULL );
+}
 
 void
-ber_bvecfree( struct berval **bv )
+ber_bvecfree_x( struct berval **bv, void *ctx )
 {
 	int	i;
 
@@ -386,28 +413,38 @@ ber_bvecfree( struct berval **bv )
 
 	BER_MEM_VALID( bv );
 
-	for ( i = 0; bv[i] != NULL; i++ ) {
-		ber_bvfree( bv[i] );
+	/* count elements */
+	for ( i = 0; bv[i] != NULL; i++ ) ;
+
+	/* free in reverse order */
+	for ( i--; i >= 0; i-- ) {
+		ber_bvfree_x( bv[i], ctx );
 	}
 
-	LBER_FREE( (char *) bv );
+	ber_memfree_x( (char *) bv, ctx );
+}
+
+void
+ber_bvecfree( struct berval **bv )
+{
+	ber_bvecfree_x( bv, NULL );
 }
 
 int
-ber_bvecadd( struct berval ***bvec, struct berval *bv )
+ber_bvecadd_x( struct berval ***bvec, struct berval *bv, void *ctx )
 {
 	ber_len_t i;
 	struct berval **new;
 
 	ber_int_options.lbo_valid = LBER_INITIALIZED;
 
-	if( bvec == NULL ) {
+	if( *bvec == NULL ) {
 		if( bv == NULL ) {
 			/* nothing to add */
 			return 0;
 		}
 
-		*bvec = ber_memalloc( 2 * sizeof(struct berval *) );
+		*bvec = ber_memalloc_x( 2 * sizeof(struct berval *), ctx );
 
 		if( *bvec == NULL ) {
 			return -1;
@@ -422,7 +459,7 @@ ber_bvecadd( struct berval ***bvec, struct berval *bv )
 	BER_MEM_VALID( bvec );
 
 	/* count entries */
-	for ( i = 0; bvec[i] != NULL; i++ ) {
+	for ( i = 0; (*bvec)[i] != NULL; i++ ) {
 		/* EMPTY */;
 	}
 
@@ -430,7 +467,7 @@ ber_bvecadd( struct berval ***bvec, struct berval *bv )
 		return i;
 	}
 
-	new = ber_memrealloc( *bvec, (i+2) * sizeof(struct berval *));
+	new = ber_memrealloc_x( *bvec, (i+2) * sizeof(struct berval *), ctx);
 
 	if( new == NULL ) {
 		return -1;
@@ -444,47 +481,72 @@ ber_bvecadd( struct berval ***bvec, struct berval *bv )
 	return i;
 }
 
+int
+ber_bvecadd( struct berval ***bvec, struct berval *bv )
+{
+	return ber_bvecadd_x( bvec, bv, NULL );
+}
 
 struct berval *
-ber_bvdup(
-	LDAP_CONST struct berval *bv )
+ber_dupbv_x(
+	struct berval *dst, struct berval *src, void *ctx )
 {
 	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 = ber_memalloc_x( sizeof(struct berval), ctx )) == 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 = ber_memalloc_x( src->bv_len + 1, ctx )) == NULL ) {
 		ber_errno = LBER_ERROR_MEMORY;
-		LBER_FREE( new );
+		if ( !dst )
+			ber_memfree_x( new, ctx );
 		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_dupbv(
+	struct berval *dst, struct berval *src )
+{
+	return ber_dupbv_x( dst, src, NULL );
+}
+
+struct berval *
+ber_bvdup(
+	struct berval *src )
+{
+	return ber_dupbv_x( NULL, src, NULL );
+}
+
+struct berval *
+ber_str2bv_x(
+	LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv,
+	void *ctx)
 {
 	struct berval *new;
 
@@ -495,23 +557,46 @@ 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 = ber_memalloc_x( sizeof(struct berval), ctx )) == 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 = ber_memalloc_x( new->bv_len+1, ctx )) == NULL ) {
+			ber_errno = LBER_ERROR_MEMORY;
+			if ( !bv )
+				ber_memfree_x( new, ctx );
+			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_str2bv(
+	LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv)
+{
+	return ber_str2bv_x( s, len, dup, bv, NULL );
+}
+
+struct berval *
+ber_mem2bv_x(
+	LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv,
+	void *ctx)
 {
 	struct berval *new;
-	char *p;
 
 	ber_int_options.lbo_valid = LBER_INITIALIZED;
 
@@ -520,24 +605,77 @@ ber_bvstrdup(
 		return NULL;
 	}
 
-	p = LBER_STRDUP( s );
+	if( bv ) {
+		new = bv;
+	} else {
+		if(( new = ber_memalloc_x( sizeof(struct berval), ctx )) == NULL ) {
+			ber_errno = LBER_ERROR_MEMORY;
+			return NULL;
+		}
+	}
 
-	if( p == NULL ) {
-		ber_errno = LBER_ERROR_MEMORY;
+	new->bv_len = len;
+	if ( dup ) {
+		if ( (new->bv_val = ber_memalloc_x( new->bv_len+1, ctx )) == NULL ) {
+			ber_errno = LBER_ERROR_MEMORY;
+			if ( !bv ) {
+				ber_memfree_x( new, ctx );
+			}
+			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_mem2bv(
+	LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv)
+{
+	return ber_mem2bv_x( s, len, dup, bv, NULL );
+}
+
+char *
+ber_strdup_x( LDAP_CONST char *s, void *ctx )
+{
+	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 ) {
+		ber_errno = LBER_ERROR_PARAM;
 		return NULL;
 	}
 
-	new = ber_bvstr( p );
+	len = strlen( s ) + 1;
 
-	if( new == NULL || *p == '\0' ) {
-		LBER_FREE( p );
+	if ( (p = ber_memalloc_x( len, ctx )) == NULL ) {
+		ber_errno = LBER_ERROR_MEMORY;
+		return NULL;
 	}
 
-	return new;
+	AC_MEMCPY( p, s, len );
+	return p;
 }
 
 char *
 ber_strdup( LDAP_CONST char *s )
+{
+	return ber_strdup_x( s, NULL );
+}
+
+char *
+ber_strndup_x( LDAP_CONST char *s, ber_len_t l, void *ctx )
 {
 	char    *p;
 	size_t	len;
@@ -553,13 +691,104 @@ ber_strdup( LDAP_CONST char *s )
 		return NULL;
 	}
 
-	len = strlen( s ) + 1;
+	len = strlen( s );
+
+	if ( len > l ) {
+		len = l;
+	}
 
-	if ( (p = LBER_MALLOC( len )) == NULL ) {
+	if ( (p = ber_memalloc_x( len + 1, ctx )) == NULL ) {
 		ber_errno = LBER_ERROR_MEMORY;
 		return NULL;
 	}
 
 	AC_MEMCPY( p, s, len );
+	p[len] = '\0';
 	return p;
 }
+
+char *
+ber_strndup( LDAP_CONST char *s, ber_len_t l )
+{
+	return ber_strndup_x( s, l, NULL );
+}
+
+void
+ber_bvarray_free_x( BerVarray a, void *ctx )
+{
+	int i;
+
+	ber_int_options.lbo_valid = LBER_INITIALIZED;
+
+	if (a) {
+		BER_MEM_VALID( a );
+
+		/* count elements */
+		for (i=0; a[i].bv_val; i++) ;
+		
+		/* free in reverse order */
+		for (i--; i>=0; i--) {
+			ber_memfree_x(a[i].bv_val, ctx);
+		}
+
+		ber_memfree_x(a, ctx);
+	}
+}
+
+void
+ber_bvarray_free( BerVarray a )
+{
+	ber_bvarray_free_x(a, NULL);
+}
+
+int
+ber_bvarray_add_x( BerVarray *a, BerValue *bv, void *ctx )
+{
+	int	n;
+
+	ber_int_options.lbo_valid = LBER_INITIALIZED;
+
+	if ( *a == NULL ) {
+		if (bv == NULL) {
+			return 0;
+		}
+		n = 0;
+
+		*a = (BerValue *) ber_memalloc_x( 2 * sizeof(BerValue), ctx );
+		if ( *a == NULL ) {
+			return -1;
+		}
+
+	} else {
+		BerVarray atmp;
+		BER_MEM_VALID( a );
+
+		for ( n = 0; *a != NULL && (*a)[n].bv_val != NULL; n++ ) {
+			;	/* just count them */
+		}
+
+		if (bv == NULL) {
+			return n;
+		}
+
+		atmp = (BerValue *) ber_memrealloc_x( (char *) *a,
+		    (n + 2) * sizeof(BerValue), ctx );
+
+		if( atmp == NULL ) {
+			return -1;
+		}
+
+		*a = atmp;
+	}
+
+	(*a)[n++] = *bv;
+	(*a)[n].bv_val = NULL;
+
+	return n;
+}
+
+int
+ber_bvarray_add( BerVarray *a, BerValue *bv )
+{
+	return ber_bvarray_add_x( a, bv, NULL );
+}