Back to index

openldap  2.4.31
Defines | Functions | Variables
memory.c File Reference
#include "portable.h"
#include <ac/stdlib.h>
#include <ac/string.h>
#include "lber-int.h"

Go to the source code of this file.

Defines

#define BER_MEM_VALID(p)   /* no-op */

Functions

void ber_memfree_x (void *p, void *ctx)
void ber_memfree (void *p)
void ber_memvfree_x (void **vec, void *ctx)
void ber_memvfree (void **vec)
voidber_memalloc_x (ber_len_t s, void *ctx)
voidber_memalloc (ber_len_t s)
voidber_memcalloc_x (ber_len_t n, ber_len_t s, void *ctx)
voidber_memcalloc (ber_len_t n, ber_len_t s)
voidber_memrealloc_x (void *p, ber_len_t s, void *ctx)
voidber_memrealloc (void *p, ber_len_t s)
void ber_bvfree_x (struct berval *bv, void *ctx)
void ber_bvfree (struct berval *bv)
void ber_bvecfree_x (struct berval **bv, void *ctx)
void ber_bvecfree (struct berval **bv)
int ber_bvecadd_x (struct berval ***bvec, struct berval *bv, void *ctx)
int ber_bvecadd (struct berval ***bvec, struct berval *bv)
struct bervalber_dupbv_x (struct berval *dst, struct berval *src, void *ctx)
struct bervalber_dupbv (struct berval *dst, struct berval *src)
struct bervalber_bvdup (struct berval *src)
struct bervalber_str2bv_x (LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv, void *ctx)
struct bervalber_str2bv (LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv)
struct bervalber_mem2bv_x (LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv, void *ctx)
struct bervalber_mem2bv (LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv)
char * ber_strdup_x (LDAP_CONST char *s, void *ctx)
char * ber_strdup (LDAP_CONST char *s)
ber_len_t ber_strnlen (LDAP_CONST char *s, ber_len_t len)
char * ber_strndup_x (LDAP_CONST char *s, ber_len_t l, void *ctx)
char * ber_strndup (LDAP_CONST char *s, ber_len_t l)
struct bervalber_bvreplace_x (struct berval *dst, LDAP_CONST struct berval *src, void *ctx)
struct bervalber_bvreplace (struct berval *dst, LDAP_CONST struct berval *src)
void ber_bvarray_free_x (BerVarray a, void *ctx)
void ber_bvarray_free (BerVarray a)
int ber_bvarray_dup_x (BerVarray *dst, BerVarray src, void *ctx)
int ber_bvarray_add_x (BerVarray *a, BerValue *bv, void *ctx)
int ber_bvarray_add (BerVarray *a, BerValue *bv)

Variables

BerMemoryFunctionsber_int_memory_fns = NULL

Define Documentation

#define BER_MEM_VALID (   p)    /* no-op */

Definition at line 120 of file memory.c.


Function Documentation

int ber_bvarray_add ( BerVarray a,
BerValue bv 
)

Definition at line 817 of file memory.c.

{
       return ber_bvarray_add_x( a, bv, NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ber_bvarray_add_x ( BerVarray a,
BerValue bv,
void ctx 
)

Definition at line 772 of file memory.c.

{
       int    n;

       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;
       (*a)[n].bv_len = 0;

       return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ber_bvarray_dup_x ( BerVarray dst,
BerVarray  src,
void ctx 
)

Definition at line 745 of file memory.c.

{
       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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 739 of file memory.c.

{
       ber_bvarray_free_x(a, NULL);
}

Here is the call graph for this function:

void ber_bvarray_free_x ( BerVarray  a,
void ctx 
)

Definition at line 719 of file memory.c.

{
       int i;

       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);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct berval* ber_bvdup ( struct berval src) [read]

Definition at line 527 of file memory.c.

{
       return ber_dupbv_x( NULL, src, NULL );
}

Here is the call graph for this function:

int ber_bvecadd ( struct berval ***  bvec,
struct berval bv 
)

Definition at line 476 of file memory.c.

{
       return ber_bvecadd_x( bvec, bv, NULL );
}

Here is the call graph for this function:

int ber_bvecadd_x ( struct berval ***  bvec,
struct berval bv,
void ctx 
)

Definition at line 427 of file memory.c.

{
       ber_len_t i;
       struct berval **new;

       if( *bvec == NULL ) {
              if( bv == NULL ) {
                     /* nothing to add */
                     return 0;
              }

              *bvec = ber_memalloc_x( 2 * sizeof(struct berval *), ctx );

              if( *bvec == NULL ) {
                     return -1;
              }

              (*bvec)[0] = bv;
              (*bvec)[1] = NULL;

              return 1;
       }

       BER_MEM_VALID( bvec );

       /* count entries */
       for ( i = 0; (*bvec)[i] != NULL; i++ ) {
              /* EMPTY */;
       }

       if( bv == NULL ) {
              return i;
       }

       new = ber_memrealloc_x( *bvec, (i+2) * sizeof(struct berval *), ctx);

       if( new == NULL ) {
              return -1;
       }

       *bvec = new;

       (*bvec)[i++] = bv;
       (*bvec)[i] = NULL;

       return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ber_bvecfree ( struct berval **  bv)

Definition at line 421 of file memory.c.

{
       ber_bvecfree_x( bv, NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ber_bvecfree_x ( struct berval **  bv,
void ctx 
)

Definition at line 399 of file memory.c.

{
       int    i;

       if( bv == NULL ) {
              return;
       }

       BER_MEM_VALID( bv );

       /* 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_memfree_x( (char *) bv, ctx );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ber_bvfree ( struct berval bv)

Definition at line 393 of file memory.c.

{
       ber_bvfree_x( bv, NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ber_bvfree_x ( struct berval bv,
void ctx 
)

Definition at line 377 of file memory.c.

{
       if( bv == NULL ) {
              return;
       }

       BER_MEM_VALID( bv );

       if ( bv->bv_val != NULL ) {
              ber_memfree_x( bv->bv_val, ctx );
       }

       ber_memfree_x( (char *) bv, ctx );
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct berval* ber_bvreplace ( struct berval dst,
LDAP_CONST struct berval src 
) [read]

Definition at line 713 of file memory.c.

{
       return ber_bvreplace_x( dst, src, NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct berval* ber_bvreplace_x ( struct berval dst,
LDAP_CONST struct berval src,
void ctx 
) [read]

Definition at line 697 of file memory.c.

{
       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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct berval* ber_dupbv ( struct berval dst,
struct berval src 
) [read]

Definition at line 520 of file memory.c.

{
       return ber_dupbv_x( dst, src, NULL );
}

Here is the call graph for this function:

struct berval* ber_dupbv_x ( struct berval dst,
struct berval src,
void ctx 
) [read]

Definition at line 482 of file memory.c.

{
       struct berval *new;

       if( src == NULL ) {
              ber_errno = LBER_ERROR_PARAM;
              return NULL;
       }

       if ( dst ) {
              new = dst;
       } else {
              if(( new = ber_memalloc_x( sizeof(struct berval), ctx )) == NULL ) {
                     return NULL;
              }
       }

       if ( src->bv_val == NULL ) {
              new->bv_val = NULL;
              new->bv_len = 0;
              return new;
       }

       if(( new->bv_val = ber_memalloc_x( src->bv_len + 1, ctx )) == NULL ) {
              if ( !dst )
                     ber_memfree_x( new, ctx );
              return NULL;
       }

       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;
}

Here is the call graph for this function:

struct berval* ber_mem2bv ( LDAP_CONST char *  s,
ber_len_t  len,
int  dup,
struct berval bv 
) [read]

Definition at line 616 of file memory.c.

{
       return ber_mem2bv_x( s, len, dup, bv, NULL );
}

Here is the call graph for this function:

struct berval* ber_mem2bv_x ( LDAP_CONST char *  s,
ber_len_t  len,
int  dup,
struct berval bv,
void ctx 
) [read]

Definition at line 578 of file memory.c.

{
       struct berval *new;

       if( s == NULL ) {
              ber_errno = LBER_ERROR_PARAM;
              return NULL;
       }

       if( bv ) {
              new = bv;
       } else {
              if(( new = ber_memalloc_x( sizeof(struct berval), ctx )) == NULL ) {
                     return NULL;
              }
       }

       new->bv_len = len;
       if ( dup ) {
              if ( (new->bv_val = ber_memalloc_x( new->bv_len+1, ctx )) == NULL ) {
                     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 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 242 of file memory.c.

{
       return ber_memalloc_x( s, NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* ber_memalloc_x ( ber_len_t  s,
void ctx 
)

Definition at line 193 of file memory.c.

{
       void *new;

       if( s == 0 ) {
              LDAP_MEMORY_DEBUG_ASSERT( s != 0 );
              return NULL;
       }

       if( ber_int_memory_fns == NULL || ctx == NULL ) {
#ifdef LDAP_MEMORY_DEBUG
              new = malloc(s + sizeof(struct ber_mem_hdr) + sizeof( ber_int_t));
              if( new )
              {
              struct ber_mem_hdr *mh = new;
              mh->bm_top = LBER_MEM_JUNK;
              mh->bm_length = s;
              setdatatop( mh);
              setend( (char *)&mh[1] + mh->bm_length );

              ber_int_meminuse += mh->bm_length; /* Count mem inuse */

#ifdef LDAP_MEMORY_TRACE
              mh->bm_sequence = sequence++;
              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_MEM_VALID( &mh[1] );
              new = &mh[1];
              }
#else
              new = malloc( s );
#endif
       } else {
              new = (*ber_int_memory_fns->bmf_malloc)( s, ctx );
       }

       if( new == NULL ) {
              ber_errno = LBER_ERROR_MEMORY;
       }

       return new;
}

Here is the caller graph for this function:

Definition at line 298 of file memory.c.

{
       return ber_memcalloc_x( n, s, NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* ber_memcalloc_x ( ber_len_t  n,
ber_len_t  s,
void ctx 
)

Definition at line 248 of file memory.c.

{
       void *new;

       if( n == 0 || s == 0 ) {
              LDAP_MEMORY_DEBUG_ASSERT( n != 0 && s != 0);
              return NULL;
       }

       if( ber_int_memory_fns == NULL || ctx == NULL ) {
#ifdef LDAP_MEMORY_DEBUG
              new = n < (-sizeof(struct ber_mem_hdr) - sizeof(ber_int_t)) / s
                     ? calloc(1, n*s + sizeof(struct ber_mem_hdr) + sizeof(ber_int_t))
                     : NULL;
              if( new )
              {
              struct ber_mem_hdr *mh = new;

              mh->bm_top = LBER_MEM_JUNK;
              mh->bm_length = n*s;
              setdatatop( mh);
              setend( (char *)&mh[1] + mh->bm_length );

              ber_int_meminuse += mh->bm_length;

#ifdef LDAP_MEMORY_TRACE
              mh->bm_sequence = sequence++;
              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];
              }
#else
              new = calloc( n, s );
#endif

       } else {
              new = (*ber_int_memory_fns->bmf_calloc)( n, s, ctx );
       }

       if( new == NULL ) {
              ber_errno = LBER_ERROR_MEMORY;
       }

       return new;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ber_memfree ( void p)

Definition at line 163 of file memory.c.

{
       ber_memfree_x(p, NULL);
}

Here is the call graph for this function:

void ber_memfree_x ( void p,
void ctx 
)

Definition at line 126 of file memory.c.

{
       if( p == NULL ) {
              return;
       }

       BER_MEM_VALID( p );

       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));
              assert( mh->bm_top == LBER_MEM_JUNK);
              assert( testdatatop( mh));
              assert( testend( (char *)&mh[1] + mh->bm_length) );
              ber_int_meminuse -= mh->bm_length;

#ifdef LDAP_MEMORY_TRACE
              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));
              free( mh );
#else
              free( p );
#endif
              return;
       }

       assert( ber_int_memory_fns->bmf_free != 0 );

       (*ber_int_memory_fns->bmf_free)( p, ctx );
}
void* ber_memrealloc ( void p,
ber_len_t  s 
)

Definition at line 371 of file memory.c.

{
       return ber_memrealloc_x( p, s, NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* ber_memrealloc_x ( void p,
ber_len_t  s,
void ctx 
)

Definition at line 304 of file memory.c.

{
       void *new = NULL;

       /* realloc(NULL,s) -> malloc(s) */
       if( p == NULL ) {
              return ber_memalloc_x( s, ctx );
       }
       
       /* realloc(p,0) -> free(p) */
       if( s == 0 ) {
              ber_memfree_x( p, ctx );
              return NULL;
       }

       BER_MEM_VALID( p );

       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 *)
                     ((char *)p - sizeof(struct ber_mem_hdr));
              assert( mh->bm_top == LBER_MEM_JUNK);
              assert( testdatatop( mh));
              assert( testend( (char *)&mh[1] + mh->bm_length) );
              oldlen = mh->bm_length;

              p = realloc( mh, s + sizeof(struct ber_mem_hdr) + sizeof(ber_int_t) );
              if( p == NULL ) {
                     ber_errno = LBER_ERROR_MEMORY;
                     return NULL;
              }

                     mh = p;
              mh->bm_length = s;
              setend( (char *)&mh[1] + mh->bm_length );
              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_meminuse += s - oldlen;
#ifdef LDAP_MEMORY_TRACE
              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];
#else
              new = realloc( p, s );
#endif
       } else {
              new = (*ber_int_memory_fns->bmf_realloc)( p, s, ctx );
       }

       if( new == NULL ) {
              ber_errno = LBER_ERROR_MEMORY;
       }

       return new;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ber_memvfree ( void **  vec)

Definition at line 187 of file memory.c.

{
       ber_memvfree_x( vec, NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ber_memvfree_x ( void **  vec,
void ctx 
)

Definition at line 169 of file memory.c.

{
       int    i;

       if( vec == NULL ) {
              return;
       }

       BER_MEM_VALID( vec );

       for ( i = 0; vec[i] != NULL; i++ ) {
              ber_memfree_x( vec[i], ctx );
       }

       ber_memfree_x( vec, ctx );
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct berval* ber_str2bv ( LDAP_CONST char *  s,
ber_len_t  len,
int  dup,
struct berval bv 
) [read]

Definition at line 571 of file memory.c.

{
       return ber_str2bv_x( s, len, dup, bv, NULL );
}

Here is the call graph for this function:

struct berval* ber_str2bv_x ( LDAP_CONST char *  s,
ber_len_t  len,
int  dup,
struct berval bv,
void ctx 
) [read]

Definition at line 534 of file memory.c.

{
       struct berval *new;

       if( s == NULL ) {
              ber_errno = LBER_ERROR_PARAM;
              return NULL;
       }

       if( bv ) {
              new = bv;
       } else {
              if(( new = ber_memalloc_x( sizeof(struct berval), ctx )) == NULL ) {
                     return NULL;
              }
       }

       new->bv_len = len ? len : strlen( s );
       if ( dup ) {
              if ( (new->bv_val = ber_memalloc_x( new->bv_len+1, ctx )) == NULL ) {
                     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 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* ber_strdup ( LDAP_CONST char *  s)

Definition at line 646 of file memory.c.

{
       return ber_strdup_x( s, NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* ber_strdup_x ( LDAP_CONST char *  s,
void ctx 
)

Definition at line 623 of file memory.c.

{
       char    *p;
       size_t len;
       
#ifdef LDAP_MEMORY_DEBUG
       assert(s != NULL);                 /* bv damn better point to something */
#endif

       if( s == NULL ) {
              ber_errno = LBER_ERROR_PARAM;
              return NULL;
       }

       len = strlen( s ) + 1;
       if ( (p = ber_memalloc_x( len, ctx )) != NULL ) {
              AC_MEMCPY( p, s, len );
       }

       return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* ber_strndup ( LDAP_CONST char *  s,
ber_len_t  l 
)

Definition at line 686 of file memory.c.

{
       return ber_strndup_x( s, l, NULL );
}

Here is the call graph for this function:

char* ber_strndup_x ( LDAP_CONST char *  s,
ber_len_t  l,
void ctx 
)

Definition at line 662 of file memory.c.

{
       char    *p;
       size_t len;
       
#ifdef LDAP_MEMORY_DEBUG
       assert(s != NULL);                 /* bv damn better point to something */
#endif

       if( s == NULL ) {
              ber_errno = LBER_ERROR_PARAM;
              return NULL;
       }

       len = ber_strnlen( s, l );
       if ( (p = ber_memalloc_x( len + 1, ctx )) != NULL ) {
              AC_MEMCPY( p, s, len );
              p[len] = '\0';
       }

       return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ber_len_t ber_strnlen ( LDAP_CONST char *  s,
ber_len_t  len 
)

Definition at line 652 of file memory.c.

{
       ber_len_t l;

       for ( l = 0; l < len && s[l] != '\0'; l++ ) ;

       return l;
}

Here is the caller graph for this function:


Variable Documentation

Definition at line 123 of file memory.c.