2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 * Copyright 1998-2009 The OpenLDAP Foundation.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted only as authorized by the OpenLDAP
11 * A copy of this license is available in the file LICENSE in the
12 * top-level directory of the distribution or, alternatively, at
13 * <http://www.OpenLDAP.org/license.html>.
16 #if defined(HAVE_STRNLEN) && !defined(_GNU_SOURCE)
17 #define _GNU_SOURCE 1 /* Get strnlen() from <string.h> */
22 #include <ac/stdlib.h>
23 #include <ac/string.h>
27 #ifdef LDAP_MEMORY_TRACE
31 #ifdef LDAP_MEMORY_DEBUG
33 * LDAP_MEMORY_DEBUG should only be enabled for the purposes of
34 * debugging memory management within OpenLDAP libraries and slapd.
36 * It should only be enabled by an experienced developer as it causes
37 * the inclusion of numerous assert()'s, many of which may be triggered
38 * by a prefectly valid program. If LDAP_MEMORY_DEBUG & 2 is true,
39 * that includes asserts known to break both slapd and current clients.
41 * The code behind this macro is subject to change as needed to
42 * support this testing.
46 ber_int_t bm_top; /* Pattern to detect buf overrun from prev buffer */
47 ber_int_t bm_length; /* Length of user allocated area */
48 #ifdef LDAP_MEMORY_TRACE
49 ber_int_t bm_sequence; /* Allocation sequence number */
51 union bmu_align_u { /* Force alignment, pattern to detect back clobber */
60 long (*bmu_funcp)( double );
61 unsigned char bmu_char[4];
63 #define bm_junk ber_align.bmu_len_t
64 #define bm_data ber_align.bmu_char[1]
65 #define bm_char ber_align.bmu_char
68 /* Pattern at top of allocated space */
69 #define LBER_MEM_JUNK 0xdeaddadaU
71 static const struct ber_mem_hdr ber_int_mem_hdr = { LBER_MEM_JUNK, 0, 0 };
73 /* Note sequence and ber_int_meminuse are counters, but are not
74 * thread safe. If you want to use these values for multithreaded applications,
75 * you must put mutexes around them, otherwise they will have incorrect values.
76 * When debugging, if you sort the debug output, the sequence number will
77 * put allocations/frees together. It is then a simple matter to write a script
78 * to find any allocations that don't have a buffer free function.
80 long ber_int_meminuse = 0;
81 #ifdef LDAP_MEMORY_TRACE
82 static ber_int_t sequence = 0;
85 /* Pattern placed just before user data */
86 static unsigned char toppattern[4] = { 0xde, 0xad, 0xba, 0xde };
87 /* Pattern placed just after user data */
88 static unsigned char endpattern[4] = { 0xd1, 0xed, 0xde, 0xca };
90 #define mbu_len sizeof(ber_int_mem_hdr.ber_align)
92 /* Test if pattern placed just before user data is good */
93 #define testdatatop(val) ( \
94 *(val->bm_char+mbu_len-4)==toppattern[0] && \
95 *(val->bm_char+mbu_len-3)==toppattern[1] && \
96 *(val->bm_char+mbu_len-2)==toppattern[2] && \
97 *(val->bm_char+mbu_len-1)==toppattern[3] )
99 /* Place pattern just before user data */
100 #define setdatatop(val) *(val->bm_char+mbu_len-4)=toppattern[0]; \
101 *(val->bm_char+mbu_len-3)=toppattern[1]; \
102 *(val->bm_char+mbu_len-2)=toppattern[2]; \
103 *(val->bm_char+mbu_len-1)=toppattern[3];
105 /* Test if pattern placed just after user data is good */
106 #define testend(val) ( *((unsigned char *)val+0)==endpattern[0] && \
107 *((unsigned char *)val+1)==endpattern[1] && \
108 *((unsigned char *)val+2)==endpattern[2] && \
109 *((unsigned char *)val+3)==endpattern[3] )
111 /* Place pattern just after user data */
112 #define setend(val) *((unsigned char *)val+0)=endpattern[0]; \
113 *((unsigned char *)val+1)=endpattern[1]; \
114 *((unsigned char *)val+2)=endpattern[2]; \
115 *((unsigned char *)val+3)=endpattern[3];
117 #define BER_MEM_BADADDR ((void *) &ber_int_mem_hdr.bm_data)
118 #define BER_MEM_VALID(p) do { \
119 assert( (p) != BER_MEM_BADADDR ); \
120 assert( (p) != (void *) &ber_int_mem_hdr ); \
124 #define BER_MEM_VALID(p) /* no-op */
127 BerMemoryFunctions *ber_int_memory_fns = NULL;
130 ber_memfree_x( void *p, void *ctx )
138 if( ber_int_memory_fns == NULL || ctx == NULL ) {
139 #ifdef LDAP_MEMORY_DEBUG
140 struct ber_mem_hdr *mh = (struct ber_mem_hdr *)
141 ((char *)p - sizeof(struct ber_mem_hdr));
142 assert( mh->bm_top == LBER_MEM_JUNK);
143 assert( testdatatop( mh));
144 assert( testend( (char *)&mh[1] + mh->bm_length) );
145 ber_int_meminuse -= mh->bm_length;
147 #ifdef LDAP_MEMORY_TRACE
148 fprintf(stderr, "0x%08lx 0x%08lx -f- %ld ber_memfree %ld\n",
149 (long)mh->bm_sequence, (long)mh, (long)mh->bm_length,
152 /* Fill the free space with poison */
153 memset( mh, 0xff, mh->bm_length + sizeof(struct ber_mem_hdr) + sizeof(ber_int_t));
161 assert( ber_int_memory_fns->bmf_free != 0 );
163 (*ber_int_memory_fns->bmf_free)( p, ctx );
167 ber_memfree( void *p )
169 ber_memfree_x(p, NULL);
173 ber_memvfree_x( void **vec, void *ctx )
181 BER_MEM_VALID( vec );
183 for ( i = 0; vec[i] != NULL; i++ ) {
184 ber_memfree_x( vec[i], ctx );
187 ber_memfree_x( vec, ctx );
191 ber_memvfree( void **vec )
193 ber_memvfree_x( vec, NULL );
197 ber_memalloc_x( ber_len_t s, void *ctx )
202 LDAP_MEMORY_DEBUG_ASSERT( s != 0 );
206 if( ber_int_memory_fns == NULL || ctx == NULL ) {
207 #ifdef LDAP_MEMORY_DEBUG
208 struct ber_mem_hdr *mh = malloc(s + sizeof(struct ber_mem_hdr) + sizeof( ber_int_t));
209 if( mh == NULL ) return NULL;
211 mh->bm_top = LBER_MEM_JUNK;
214 setend( (char *)&mh[1] + mh->bm_length );
216 ber_int_meminuse += mh->bm_length; /* Count mem inuse */
218 #ifdef LDAP_MEMORY_TRACE
219 mh->bm_sequence = sequence++;
220 fprintf(stderr, "0x%08lx 0x%08lx -a- %ld ber_memalloc %ld\n",
221 (long)mh->bm_sequence, (long)mh, (long)mh->bm_length,
224 /* poison new memory */
225 memset( (char *)&mh[1], 0xff, s);
227 BER_MEM_VALID( &mh[1] );
233 new = (*ber_int_memory_fns->bmf_malloc)( s, ctx );
237 ber_errno = LBER_ERROR_MEMORY;
244 ber_memalloc( ber_len_t s )
246 return ber_memalloc_x( s, NULL );
250 ber_memcalloc_x( ber_len_t n, ber_len_t s, void *ctx )
254 if( n == 0 || s == 0 ) {
255 LDAP_MEMORY_DEBUG_ASSERT( n != 0 && s != 0);
259 if( ber_int_memory_fns == NULL || ctx == NULL ) {
260 #ifdef LDAP_MEMORY_DEBUG
261 struct ber_mem_hdr *mh = calloc(1,
262 (n * s) + sizeof(struct ber_mem_hdr) + sizeof(ber_int_t) );
263 if( mh == NULL ) return NULL;
265 mh->bm_top = LBER_MEM_JUNK;
268 setend( (char *)&mh[1] + mh->bm_length );
270 ber_int_meminuse += mh->bm_length;
272 #ifdef LDAP_MEMORY_TRACE
273 mh->bm_sequence = sequence++;
274 fprintf(stderr, "0x%08lx 0x%08lx -a- %ld ber_memcalloc %ld\n",
275 (long)mh->bm_sequence, (long)mh, (long)mh->bm_length,
278 BER_MEM_VALID( &mh[1] );
281 new = calloc( n, s );
285 new = (*ber_int_memory_fns->bmf_calloc)( n, s, ctx );
289 ber_errno = LBER_ERROR_MEMORY;
296 ber_memcalloc( ber_len_t n, ber_len_t s )
298 return ber_memcalloc_x( n, s, NULL );
302 ber_memrealloc_x( void* p, ber_len_t s, void *ctx )
306 /* realloc(NULL,s) -> malloc(s) */
308 return ber_memalloc_x( s, ctx );
311 /* realloc(p,0) -> free(p) */
313 ber_memfree_x( p, ctx );
319 if( ber_int_memory_fns == NULL || ctx == NULL ) {
320 #ifdef LDAP_MEMORY_DEBUG
322 struct ber_mem_hdr *mh = (struct ber_mem_hdr *)
323 ((char *)p - sizeof(struct ber_mem_hdr));
324 assert( mh->bm_top == LBER_MEM_JUNK);
325 assert( testdatatop( mh));
326 assert( testend( (char *)&mh[1] + mh->bm_length) );
327 oldlen = mh->bm_length;
329 p = realloc( mh, s + sizeof(struct ber_mem_hdr) + sizeof(ber_int_t) );
331 ber_errno = LBER_ERROR_MEMORY;
337 setend( (char *)&mh[1] + mh->bm_length );
339 /* poison any new memory */
340 memset( (char *)&mh[1] + oldlen, 0xff, s - oldlen);
343 assert( mh->bm_top == LBER_MEM_JUNK);
344 assert( testdatatop( mh));
346 ber_int_meminuse += s - oldlen;
347 #ifdef LDAP_MEMORY_TRACE
348 fprintf(stderr, "0x%08lx 0x%08lx -a- %ld ber_memrealloc %ld\n",
349 (long)mh->bm_sequence, (long)mh, (long)mh->bm_length,
352 BER_MEM_VALID( &mh[1] );
355 new = realloc( p, s );
358 new = (*ber_int_memory_fns->bmf_realloc)( p, s, ctx );
362 ber_errno = LBER_ERROR_MEMORY;
369 ber_memrealloc( void* p, ber_len_t s )
371 return ber_memrealloc_x( p, s, NULL );
375 ber_bvfree_x( struct berval *bv, void *ctx )
383 if ( bv->bv_val != NULL ) {
384 ber_memfree_x( bv->bv_val, ctx );
387 ber_memfree_x( (char *) bv, ctx );
391 ber_bvfree( struct berval *bv )
393 ber_bvfree_x( bv, NULL );
397 ber_bvecfree_x( struct berval **bv, void *ctx )
408 for ( i = 0; bv[i] != NULL; i++ ) ;
410 /* free in reverse order */
411 for ( i--; i >= 0; i-- ) {
412 ber_bvfree_x( bv[i], ctx );
415 ber_memfree_x( (char *) bv, ctx );
419 ber_bvecfree( struct berval **bv )
421 ber_bvecfree_x( bv, NULL );
425 ber_bvecadd_x( struct berval ***bvec, struct berval *bv, void *ctx )
430 if( *bvec == NULL ) {
436 *bvec = ber_memalloc_x( 2 * sizeof(struct berval *), ctx );
438 if( *bvec == NULL ) {
448 BER_MEM_VALID( bvec );
451 for ( i = 0; (*bvec)[i] != NULL; i++ ) {
459 new = ber_memrealloc_x( *bvec, (i+2) * sizeof(struct berval *), ctx);
474 ber_bvecadd( struct berval ***bvec, struct berval *bv )
476 return ber_bvecadd_x( bvec, bv, NULL );
481 struct berval *dst, struct berval *src, void *ctx )
486 ber_errno = LBER_ERROR_PARAM;
493 if(( new = ber_memalloc_x( sizeof(struct berval), ctx )) == NULL ) {
494 ber_errno = LBER_ERROR_MEMORY;
499 if ( src->bv_val == NULL ) {
505 if(( new->bv_val = ber_memalloc_x( src->bv_len + 1, ctx )) == NULL ) {
506 ber_errno = LBER_ERROR_MEMORY;
508 ber_memfree_x( new, ctx );
512 AC_MEMCPY( new->bv_val, src->bv_val, src->bv_len );
513 new->bv_val[src->bv_len] = '\0';
514 new->bv_len = src->bv_len;
521 struct berval *dst, struct berval *src )
523 return ber_dupbv_x( dst, src, NULL );
530 return ber_dupbv_x( NULL, src, NULL );
535 LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv,
541 ber_errno = LBER_ERROR_PARAM;
548 if(( new = ber_memalloc_x( sizeof(struct berval), ctx )) == NULL ) {
549 ber_errno = LBER_ERROR_MEMORY;
554 new->bv_len = len ? len : strlen( s );
556 if ( (new->bv_val = ber_memalloc_x( new->bv_len+1, ctx )) == NULL ) {
557 ber_errno = LBER_ERROR_MEMORY;
559 ber_memfree_x( new, ctx );
563 AC_MEMCPY( new->bv_val, s, new->bv_len );
564 new->bv_val[new->bv_len] = '\0';
566 new->bv_val = (char *) s;
574 LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv)
576 return ber_str2bv_x( s, len, dup, bv, NULL );
581 LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv,
587 ber_errno = LBER_ERROR_PARAM;
594 if(( new = ber_memalloc_x( sizeof(struct berval), ctx )) == NULL ) {
595 ber_errno = LBER_ERROR_MEMORY;
602 if ( (new->bv_val = ber_memalloc_x( new->bv_len+1, ctx )) == NULL ) {
603 ber_errno = LBER_ERROR_MEMORY;
605 ber_memfree_x( new, ctx );
610 AC_MEMCPY( new->bv_val, s, new->bv_len );
611 new->bv_val[new->bv_len] = '\0';
613 new->bv_val = (char *) s;
621 LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv)
623 return ber_mem2bv_x( s, len, dup, bv, NULL );
627 ber_strdup_x( LDAP_CONST char *s, void *ctx )
632 #ifdef LDAP_MEMORY_DEBUG
633 assert(s != NULL); /* bv damn better point to something */
637 ber_errno = LBER_ERROR_PARAM;
641 len = strlen( s ) + 1;
643 if ( (p = ber_memalloc_x( len, ctx )) == NULL ) {
644 ber_errno = LBER_ERROR_MEMORY;
648 AC_MEMCPY( p, s, len );
653 ber_strdup( LDAP_CONST char *s )
655 return ber_strdup_x( s, NULL );
659 ber_strnlen( LDAP_CONST char *s, ber_len_t len )
662 return (ber_len_t)strnlen( s, (ber_len_t)len );
666 for ( l = 0; l < len; l++ ) {
667 if ( s[l] == '\0' ) {
673 #endif /* HAVE_STRNLEN */
677 ber_strndup_x( LDAP_CONST char *s, ber_len_t l, void *ctx )
682 #ifdef LDAP_MEMORY_DEBUG
683 assert(s != NULL); /* bv damn better point to something */
687 ber_errno = LBER_ERROR_PARAM;
691 len = ber_strnlen( s, l );
693 if ( (p = ber_memalloc_x( len + 1, ctx )) == NULL ) {
694 ber_errno = LBER_ERROR_MEMORY;
698 AC_MEMCPY( p, s, len );
704 ber_strndup( LDAP_CONST char *s, ber_len_t l )
706 return ber_strndup_x( s, l, NULL );
710 * dst is resized as required by src and the value of src is copied into dst
711 * dst->bv_val must be NULL (and dst->bv_len must be 0), or it must be
712 * alloc'ed with the context ctx
715 ber_bvreplace_x( struct berval *dst, LDAP_CONST struct berval *src, void *ctx )
717 assert( dst != NULL );
718 assert( !BER_BVISNULL( src ) );
720 if ( BER_BVISNULL( dst ) || dst->bv_len < src->bv_len ) {
721 dst->bv_val = ber_memrealloc_x( dst->bv_val, src->bv_len + 1, ctx );
724 AC_MEMCPY( dst->bv_val, src->bv_val, src->bv_len + 1 );
725 dst->bv_len = src->bv_len;
731 ber_bvreplace( struct berval *dst, LDAP_CONST struct berval *src )
733 return ber_bvreplace_x( dst, src, NULL );
737 ber_bvarray_free_x( BerVarray a, void *ctx )
745 for (i=0; a[i].bv_val; i++) ;
747 /* free in reverse order */
748 for (i--; i>=0; i--) {
749 ber_memfree_x(a[i].bv_val, ctx);
752 ber_memfree_x(a, ctx);
757 ber_bvarray_free( BerVarray a )
759 ber_bvarray_free_x(a, NULL);
763 ber_bvarray_dup_x( BerVarray *dst, BerVarray src, void *ctx )
773 for (i=0; !BER_BVISNULL( &src[i] ); i++) ;
774 new = ber_memalloc_x(( i+1 ) * sizeof(BerValue), ctx );
777 for (j=0; j<i; j++) {
778 ber_dupbv_x( &new[j], &src[j], ctx );
779 if ( BER_BVISNULL( &new[j] )) {
780 ber_bvarray_free_x( new, ctx );
784 BER_BVZERO( &new[j] );
790 ber_bvarray_add_x( BerVarray *a, BerValue *bv, void *ctx )
800 *a = (BerValue *) ber_memalloc_x( 2 * sizeof(BerValue), ctx );
809 for ( n = 0; *a != NULL && (*a)[n].bv_val != NULL; n++ ) {
810 ; /* just count them */
817 atmp = (BerValue *) ber_memrealloc_x( (char *) *a,
818 (n + 2) * sizeof(BerValue), ctx );
828 (*a)[n].bv_val = NULL;
835 ber_bvarray_add( BerVarray *a, BerValue *bv )
837 return ber_bvarray_add_x( a, bv, NULL );