/* $OpenLDAP$ */
-/*
- * Copyright 1998-2003 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-2008 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>
#include "lber-int.h"
#ifdef LDAP_MEMORY_TRACE
-# ifndef LDAP_MEMORY_DEBUG
-# define LDAP_MEMORY_DEBUG 1
-# endif
#include <stdio.h>
#endif
-#if LDAP_MEMORY_DEBUG
+#ifdef LDAP_MEMORY_DEBUG
/*
* LDAP_MEMORY_DEBUG should only be enabled for the purposes of
* debugging memory management within OpenLDAP libraries and slapd.
- * It should only be enabled by an experienced developer as it
- * causes the inclusion of numerous assert()'s, many of which may
- * be triggered by a prefectly valid program.
+ *
+ * It should only be enabled by an experienced developer as it causes
+ * the inclusion of numerous assert()'s, many of which may be triggered
+ * by a prefectly valid program. If LDAP_MEMORY_DEBUG & 2 is true,
+ * that includes asserts known to break both slapd and current clients.
*
* The code behind this macro is subject to change as needed to
* support this testing.
static const struct ber_mem_hdr ber_int_mem_hdr = { LBER_MEM_JUNK, 0, 0 };
-/* Note sequence and ber_int_options.lbu_meminuse are counters, but are not
+/* Note sequence and ber_int_meminuse are counters, but are not
* thread safe. If you want to use these values for multithreaded applications,
* you must put mutexes around them, otherwise they will have incorrect values.
* When debugging, if you sort the debug output, the sequence number will
* put allocations/frees together. It is then a simple matter to write a script
* to find any allocations that don't have a buffer free function.
*/
+long ber_int_meminuse = 0;
#ifdef LDAP_MEMORY_TRACE
static ber_int_t sequence = 0;
#endif
void
ber_memfree_x( void *p, void *ctx )
{
- ber_int_options.lbo_valid = LBER_INITIALIZED;
-
if( p == NULL ) {
return;
}
assert( mh->bm_top == LBER_MEM_JUNK);
assert( testdatatop( mh));
assert( testend( (char *)&mh[1] + mh->bm_length) );
- ber_int_options.lbo_meminuse -= mh->bm_length;
+ ber_int_meminuse -= mh->bm_length;
#ifdef LDAP_MEMORY_TRACE
- fprintf(stderr, "0x%08x 0x%08x -f- %d ber_memfree %d\n",
- mh->bm_sequence, mh, mh->bm_length, ber_int_options.lbo_meminuse);
+ fprintf(stderr, "0x%08lx 0x%08lx -f- %ld ber_memfree %ld\n",
+ (long)mh->bm_sequence, (long)mh, (long)mh->bm_length,
+ ber_int_meminuse);
#endif
/* Fill the free space with poison */
memset( mh, 0xff, mh->bm_length + sizeof(struct ber_mem_hdr) + sizeof(ber_int_t));
return;
}
- assert( ber_int_memory_fns->bmf_free );
+ assert( ber_int_memory_fns->bmf_free != 0 );
(*ber_int_memory_fns->bmf_free)( p, ctx );
}
{
int i;
- ber_int_options.lbo_valid = LBER_INITIALIZED;
-
if( vec == NULL ) {
return;
}
ber_memalloc_x( ber_len_t s, void *ctx )
{
void *new;
- ber_int_options.lbo_valid = LBER_INITIALIZED;
-
-#ifdef LDAP_MEMORY_DEBUG
- assert( s != 0 );
-#endif
if( s == 0 ) {
+ LDAP_MEMORY_DEBUG_ASSERT( s != 0 );
return NULL;
}
setdatatop( mh);
setend( (char *)&mh[1] + mh->bm_length );
- ber_int_options.lbo_meminuse += mh->bm_length; /* Count mem inuse */
+ ber_int_meminuse += mh->bm_length; /* Count mem inuse */
#ifdef LDAP_MEMORY_TRACE
mh->bm_sequence = sequence++;
- fprintf(stderr, "0x%08x 0x%08x -a- %d ber_memalloc %d\n",
- mh->bm_sequence, mh, mh->bm_length, ber_int_options.lbo_meminuse);
+ fprintf(stderr, "0x%08lx 0x%08lx -a- %ld ber_memalloc %ld\n",
+ (long)mh->bm_sequence, (long)mh, (long)mh->bm_length,
+ ber_int_meminuse);
#endif
/* poison new memory */
memset( (char *)&mh[1], 0xff, s);
ber_memcalloc_x( ber_len_t n, ber_len_t s, void *ctx )
{
void *new;
- ber_int_options.lbo_valid = LBER_INITIALIZED;
-
-#ifdef LDAP_MEMORY_DEBUG
- assert( n != 0 && s != 0);
-#endif
if( n == 0 || s == 0 ) {
+ LDAP_MEMORY_DEBUG_ASSERT( n != 0 && s != 0);
return NULL;
}
setdatatop( mh);
setend( (char *)&mh[1] + mh->bm_length );
- ber_int_options.lbo_meminuse += mh->bm_length;
+ ber_int_meminuse += mh->bm_length;
#ifdef LDAP_MEMORY_TRACE
mh->bm_sequence = sequence++;
- fprintf(stderr, "0x%08x 0x%08x -a- %d ber_memcalloc %d\n",
- mh->bm_sequence, mh, mh->bm_length, ber_int_options.lbo_meminuse);
+ fprintf(stderr, "0x%08lx 0x%08lx -a- %ld ber_memcalloc %ld\n",
+ (long)mh->bm_sequence, (long)mh, (long)mh->bm_length,
+ ber_int_meminuse);
#endif
BER_MEM_VALID( &mh[1] );
new = &mh[1];
ber_memrealloc_x( void* p, ber_len_t s, void *ctx )
{
void *new = NULL;
- ber_int_options.lbo_valid = LBER_INITIALIZED;
/* realloc(NULL,s) -> malloc(s) */
if( p == NULL ) {
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);
}
assert( mh->bm_top == LBER_MEM_JUNK);
assert( testdatatop( mh));
- ber_int_options.lbo_meminuse += s - oldlen;
+ ber_int_meminuse += s - oldlen;
#ifdef LDAP_MEMORY_TRACE
- fprintf(stderr, "0x%08x 0x%08x -a- %d ber_memrealloc %d\n",
- mh->bm_sequence, mh, mh->bm_length, ber_int_options.lbo_meminuse);
+ fprintf(stderr, "0x%08lx 0x%08lx -a- %ld ber_memrealloc %ld\n",
+ (long)mh->bm_sequence, (long)mh, (long)mh->bm_length,
+ ber_int_meminuse);
#endif
BER_MEM_VALID( &mh[1] );
return &mh[1];
void
ber_bvfree_x( struct berval *bv, void *ctx )
{
- ber_int_options.lbo_valid = LBER_INITIALIZED;
-
if( bv == NULL ) {
return;
}
{
int i;
- ber_int_options.lbo_valid = LBER_INITIALIZED;
-
if( bv == NULL ) {
return;
}
BER_MEM_VALID( bv );
- for ( i = 0; bv[i] != NULL; 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 );
}
ber_len_t i;
struct berval **new;
- ber_int_options.lbo_valid = LBER_INITIALIZED;
-
if( *bvec == NULL ) {
if( bv == NULL ) {
/* nothing to add */
{
struct berval *new;
- ber_int_options.lbo_valid = LBER_INITIALIZED;
-
if( src == NULL ) {
ber_errno = LBER_ERROR_PARAM;
return NULL;
{
struct berval *new;
- ber_int_options.lbo_valid = LBER_INITIALIZED;
-
if( s == NULL ) {
ber_errno = LBER_ERROR_PARAM;
return NULL;
{
struct berval *new;
- ber_int_options.lbo_valid = LBER_INITIALIZED;
-
if( s == NULL ) {
ber_errno = LBER_ERROR_PARAM;
return NULL;
if ( dup ) {
if ( (new->bv_val = ber_memalloc_x( new->bv_len+1, ctx )) == NULL ) {
ber_errno = LBER_ERROR_MEMORY;
- if ( !bv )
+ if ( !bv ) {
ber_memfree_x( new, ctx );
+ }
return NULL;
}
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
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
}
AC_MEMCPY( p, s, len );
- p[ len ] = '\0';
+ p[len] = '\0';
return p;
}
return ber_strndup_x( s, l, NULL );
}
+/*
+ * dst is resized as required by src and the value of src is copied into dst
+ * dst->bv_val must be NULL (and dst->bv_len must be 0), or it must be
+ * alloc'ed with the context ctx
+ */
+struct berval *
+ber_bvreplace_x( struct berval *dst, LDAP_CONST struct berval *src, void *ctx )
+{
+ assert( dst != NULL );
+ assert( !BER_BVISNULL( src ) );
+
+ if ( BER_BVISNULL( dst ) || dst->bv_len < src->bv_len ) {
+ dst->bv_val = ber_memrealloc_x( dst->bv_val, src->bv_len + 1, ctx );
+ }
+
+ AC_MEMCPY( dst->bv_val, src->bv_val, src->bv_len + 1 );
+ dst->bv_len = src->bv_len;
+
+ return dst;
+}
+
+struct berval *
+ber_bvreplace( struct berval *dst, LDAP_CONST struct berval *src )
+{
+ return ber_bvreplace_x( dst, src, 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 );
- for (i=0; a[i].bv_val; i++) {
+ /* 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_bvarray_free_x(a, NULL);
}
+int
+ber_bvarray_dup_x( BerVarray *dst, BerVarray src, void *ctx )
+{
+ int i, j;
+ BerVarray new;
+
+ if ( !src ) {
+ *dst = NULL;
+ return 0;
+ }
+
+ for (i=0; !BER_BVISNULL( &src[i] ); i++) ;
+ new = ber_memalloc_x(( i+1 ) * sizeof(BerValue), ctx );
+ if ( !new )
+ return -1;
+ for (j=0; j<i; j++) {
+ ber_dupbv_x( &new[j], &src[j], ctx );
+ if ( BER_BVISNULL( &new[j] )) {
+ ber_bvarray_free_x( new, ctx );
+ return -1;
+ }
+ }
+ BER_BVZERO( &new[j] );
+ *dst = new;
+ return 0;
+}
+
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;
(*a)[n++] = *bv;
(*a)[n].bv_val = NULL;
+ (*a)[n].bv_len = 0;
return n;
}
projects / openldap / blobdiff