1 /* $OpenLDAP: pkg/ldap/libraries/liblber/memory.c,v 1.64.2.4 2008/02/11 23:26:41 kurt Exp $ */ 2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>. 3 * 4 * Copyright 1998-2008 The OpenLDAP Foundation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted only as authorized by the OpenLDAP 9 * Public License. 10 * 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>. 14 */ 15 16 #include "portable.h" 17 18 #include <ac/stdlib.h> 19 #include <ac/string.h> 20 21 #include "lber-int.h" 22 23 #ifdef LDAP_MEMORY_TRACE 24 #include <stdio.h> 25 #endif 26 27 #ifdef LDAP_MEMORY_DEBUG 28 /* 29 * LDAP_MEMORY_DEBUG should only be enabled for the purposes of 30 * debugging memory management within OpenLDAP libraries and slapd. 31 * 32 * It should only be enabled by an experienced developer as it causes 33 * the inclusion of numerous assert()'s, many of which may be triggered 34 * by a prefectly valid program. If LDAP_MEMORY_DEBUG & 2 is true, 35 * that includes asserts known to break both slapd and current clients. 36 * 37 * The code behind this macro is subject to change as needed to 38 * support this testing. 39 */ 40 41 struct ber_mem_hdr { 42 ber_int_t bm_top; /* Pattern to detect buf overrun from prev buffer */ 43 ber_int_t bm_length; /* Length of user allocated area */ 44 #ifdef LDAP_MEMORY_TRACE 45 ber_int_t bm_sequence; /* Allocation sequence number */ 46 #endif 47 union bmu_align_u { /* Force alignment, pattern to detect back clobber */ 48 ber_len_t bmu_len_t; 49 ber_tag_t bmu_tag_t; 50 ber_int_t bmu_int_t; 51 52 size_t bmu_size_t; 53 void * bmu_voidp; 54 double bmu_double; 55 long bmu_long; 56 long (*bmu_funcp)( double ); 57 unsigned char bmu_char[4]; 58 } ber_align; 59 #define bm_junk ber_align.bmu_len_t 60 #define bm_data ber_align.bmu_char[1] 61 #define bm_char ber_align.bmu_char 62 }; 63 64 /* Pattern at top of allocated space */ 65 #define LBER_MEM_JUNK 0xdeaddadaU 66 67 static const struct ber_mem_hdr ber_int_mem_hdr = { LBER_MEM_JUNK, 0, 0 }; 68 69 /* Note sequence and ber_int_meminuse are counters, but are not 70 * thread safe. If you want to use these values for multithreaded applications, 71 * you must put mutexes around them, otherwise they will have incorrect values. 72 * When debugging, if you sort the debug output, the sequence number will 73 * put allocations/frees together. It is then a simple matter to write a script 74 * to find any allocations that don't have a buffer free function. 75 */ 76 long ber_int_meminuse = 0; 77 #ifdef LDAP_MEMORY_TRACE 78 static ber_int_t sequence = 0; 79 #endif 80 81 /* Pattern placed just before user data */ 82 static unsigned char toppattern[4] = { 0xde, 0xad, 0xba, 0xde }; 83 /* Pattern placed just after user data */ 84 static unsigned char endpattern[4] = { 0xd1, 0xed, 0xde, 0xca }; 85 86 #define mbu_len sizeof(ber_int_mem_hdr.ber_align) 87 88 /* Test if pattern placed just before user data is good */ 89 #define testdatatop(val) ( \ 90 *(val->bm_char+mbu_len-4)==toppattern[0] && \ 91 *(val->bm_char+mbu_len-3)==toppattern[1] && \ 92 *(val->bm_char+mbu_len-2)==toppattern[2] && \ 93 *(val->bm_char+mbu_len-1)==toppattern[3] ) 94 95 /* Place pattern just before user data */ 96 #define setdatatop(val) *(val->bm_char+mbu_len-4)=toppattern[0]; \ 97 *(val->bm_char+mbu_len-3)=toppattern[1]; \ 98 *(val->bm_char+mbu_len-2)=toppattern[2]; \ 99 *(val->bm_char+mbu_len-1)=toppattern[3]; 100 101 /* Test if pattern placed just after user data is good */ 102 #define testend(val) ( *((unsigned char *)val+0)==endpattern[0] && \ 103 *((unsigned char *)val+1)==endpattern[1] && \ 104 *((unsigned char *)val+2)==endpattern[2] && \ 105 *((unsigned char *)val+3)==endpattern[3] ) 106 107 /* Place pattern just after user data */ 108 #define setend(val) *((unsigned char *)val+0)=endpattern[0]; \ 109 *((unsigned char *)val+1)=endpattern[1]; \ 110 *((unsigned char *)val+2)=endpattern[2]; \ 111 *((unsigned char *)val+3)=endpattern[3]; 112 113 #define BER_MEM_BADADDR ((void *) &ber_int_mem_hdr.bm_data) 114 #define BER_MEM_VALID(p) do { \ 115 assert( (p) != BER_MEM_BADADDR ); \ 116 assert( (p) != (void *) &ber_int_mem_hdr ); \ 117 } while(0) 118 119 #else 120 #define BER_MEM_VALID(p) /* no-op */ 121 #endif 122 123 BerMemoryFunctions *ber_int_memory_fns = NULL; 124 125 void 126 ber_memfree_x( void *p, void *ctx ) 127 { 128 if( p == NULL ) { 129 return; 130 } 131 132 BER_MEM_VALID( p ); 133 134 if( ber_int_memory_fns == NULL || ctx == NULL ) { 135 #ifdef LDAP_MEMORY_DEBUG 136 struct ber_mem_hdr *mh = (struct ber_mem_hdr *) 137 ((char *)p - sizeof(struct ber_mem_hdr)); 138 assert( mh->bm_top == LBER_MEM_JUNK); 139 assert( testdatatop( mh)); 140 assert( testend( (char *)&mh[1] + mh->bm_length) ); 141 ber_int_meminuse -= mh->bm_length; 142 143 #ifdef LDAP_MEMORY_TRACE 144 fprintf(stderr, "0x%08lx 0x%08lx -f- %ld ber_memfree %ld\n", 145 (long)mh->bm_sequence, (long)mh, (long)mh->bm_length, 146 ber_int_meminuse); 147 #endif 148 /* Fill the free space with poison */ 149 memset( mh, 0xff, mh->bm_length + sizeof(struct ber_mem_hdr) + sizeof(ber_int_t)); 150 free( mh ); 151 #else 152 free( p ); 153 #endif 154 return; 155 } 156 157 assert( ber_int_memory_fns->bmf_free != 0 ); 158 159 (*ber_int_memory_fns->bmf_free)( p, ctx ); 160 } 161 162 void 163 ber_memfree( void *p ) 164 { 165 ber_memfree_x(p, NULL); 166 } 167 168 void 169 ber_memvfree_x( void **vec, void *ctx ) 170 { 171 int i; 172 173 if( vec == NULL ) { 174 return; 175 } 176 177 BER_MEM_VALID( vec ); 178 179 for ( i = 0; vec[i] != NULL; i++ ) { 180 ber_memfree_x( vec[i], ctx ); 181 } 182 183 ber_memfree_x( vec, ctx ); 184 } 185 186 void 187 ber_memvfree( void **vec ) 188 { 189 ber_memvfree_x( vec, NULL ); 190 } 191 192 void * 193 ber_memalloc_x( ber_len_t s, void *ctx ) 194 { 195 void *new; 196 197 if( s == 0 ) { 198 LDAP_MEMORY_DEBUG_ASSERT( s != 0 ); 199 return NULL; 200 } 201 202 if( ber_int_memory_fns == NULL || ctx == NULL ) { 203 #ifdef LDAP_MEMORY_DEBUG 204 struct ber_mem_hdr *mh = malloc(s + sizeof(struct ber_mem_hdr) + sizeof( ber_int_t)); 205 if( mh == NULL ) return NULL; 206 207 mh->bm_top = LBER_MEM_JUNK; 208 mh->bm_length = s; 209 setdatatop( mh); 210 setend( (char *)&mh[1] + mh->bm_length ); 211 212 ber_int_meminuse += mh->bm_length; /* Count mem inuse */ 213 214 #ifdef LDAP_MEMORY_TRACE 215 mh->bm_sequence = sequence++; 216 fprintf(stderr, "0x%08lx 0x%08lx -a- %ld ber_memalloc %ld\n", 217 (long)mh->bm_sequence, (long)mh, (long)mh->bm_length, 218 ber_int_meminuse); 219 #endif 220 /* poison new memory */ 221 memset( (char *)&mh[1], 0xff, s); 222 223 BER_MEM_VALID( &mh[1] ); 224 new = &mh[1]; 225 #else 226 new = malloc( s ); 227 #endif 228 } else { 229 new = (*ber_int_memory_fns->bmf_malloc)( s, ctx ); 230 } 231 232 if( new == NULL ) { 233 ber_errno = LBER_ERROR_MEMORY; 234 } 235 236 return new; 237 } 238 239 void * 240 ber_memalloc( ber_len_t s ) 241 { 242 return ber_memalloc_x( s, NULL ); 243 } 244 245 void * 246 ber_memcalloc_x( ber_len_t n, ber_len_t s, void *ctx ) 247 { 248 void *new; 249 250 if( n == 0 || s == 0 ) { 251 LDAP_MEMORY_DEBUG_ASSERT( n != 0 && s != 0); 252 return NULL; 253 } 254 255 if( ber_int_memory_fns == NULL || ctx == NULL ) { 256 #ifdef LDAP_MEMORY_DEBUG 257 struct ber_mem_hdr *mh = calloc(1, 258 (n * s) + sizeof(struct ber_mem_hdr) + sizeof(ber_int_t) ); 259 if( mh == NULL ) return NULL; 260 261 mh->bm_top = LBER_MEM_JUNK; 262 mh->bm_length = n*s; 263 setdatatop( mh); 264 setend( (char *)&mh[1] + mh->bm_length ); 265 266 ber_int_meminuse += mh->bm_length; 267 268 #ifdef LDAP_MEMORY_TRACE 269 mh->bm_sequence = sequence++; 270 fprintf(stderr, "0x%08lx 0x%08lx -a- %ld ber_memcalloc %ld\n", 271 (long)mh->bm_sequence, (long)mh, (long)mh->bm_length, 272 ber_int_meminuse); 273 #endif 274 BER_MEM_VALID( &mh[1] ); 275 new = &mh[1]; 276 #else 277 new = calloc( n, s ); 278 #endif 279 280 } else { 281 new = (*ber_int_memory_fns->bmf_calloc)( n, s, ctx ); 282 } 283 284 if( new == NULL ) { 285 ber_errno = LBER_ERROR_MEMORY; 286 } 287 288 return new; 289 } 290 291 void * 292 ber_memcalloc( ber_len_t n, ber_len_t s ) 293 { 294 return ber_memcalloc_x( n, s, NULL ); 295 } 296 297 void * 298 ber_memrealloc_x( void* p, ber_len_t s, void *ctx ) 299 { 300 void *new = NULL; 301 302 /* realloc(NULL,s) -> malloc(s) */ 303 if( p == NULL ) { 304 return ber_memalloc_x( s, ctx ); 305 } 306 307 /* realloc(p,0) -> free(p) */ 308 if( s == 0 ) { 309 ber_memfree_x( p, ctx ); 310 return NULL; 311 } 312 313 BER_MEM_VALID( p ); 314 315 if( ber_int_memory_fns == NULL || ctx == NULL ) { 316 #ifdef LDAP_MEMORY_DEBUG 317 ber_int_t oldlen; 318 struct ber_mem_hdr *mh = (struct ber_mem_hdr *) 319 ((char *)p - sizeof(struct ber_mem_hdr)); 320 assert( mh->bm_top == LBER_MEM_JUNK); 321 assert( testdatatop( mh)); 322 assert( testend( (char *)&mh[1] + mh->bm_length) ); 323 oldlen = mh->bm_length; 324 325 p = realloc( mh, s + sizeof(struct ber_mem_hdr) + sizeof(ber_int_t) ); 326 if( p == NULL ) { 327 ber_errno = LBER_ERROR_MEMORY; 328 return NULL; 329 } 330 331 mh = p; 332 mh->bm_length = s; 333 setend( (char *)&mh[1] + mh->bm_length ); 334 if( s > oldlen ) { 335 /* poison any new memory */ 336 memset( (char *)&mh[1] + oldlen, 0xff, s - oldlen); 337 } 338 339 assert( mh->bm_top == LBER_MEM_JUNK); 340 assert( testdatatop( mh)); 341 342 ber_int_meminuse += s - oldlen; 343 #ifdef LDAP_MEMORY_TRACE 344 fprintf(stderr, "0x%08lx 0x%08lx -a- %ld ber_memrealloc %ld\n", 345 (long)mh->bm_sequence, (long)mh, (long)mh->bm_length, 346 ber_int_meminuse); 347 #endif 348 BER_MEM_VALID( &mh[1] ); 349 return &mh[1]; 350 #else 351 new = realloc( p, s ); 352 #endif 353 } else { 354 new = (*ber_int_memory_fns->bmf_realloc)( p, s, ctx ); 355 } 356 357 if( new == NULL ) { 358 ber_errno = LBER_ERROR_MEMORY; 359 } 360 361 return new; 362 } 363 364 void * 365 ber_memrealloc( void* p, ber_len_t s ) 366 { 367 return ber_memrealloc_x( p, s, NULL ); 368 } 369 370 void 371 ber_bvfree_x( struct berval *bv, void *ctx ) 372 { 373 if( bv == NULL ) { 374 return; 375 } 376 377 BER_MEM_VALID( bv ); 378 379 if ( bv->bv_val != NULL ) { 380 ber_memfree_x( bv->bv_val, ctx ); 381 } 382 383 ber_memfree_x( (char *) bv, ctx ); 384 } 385 386 void 387 ber_bvfree( struct berval *bv ) 388 { 389 ber_bvfree_x( bv, NULL ); 390 } 391 392 void 393 ber_bvecfree_x( struct berval **bv, void *ctx ) 394 { 395 int i; 396 397 if( bv == NULL ) { 398 return; 399 } 400 401 BER_MEM_VALID( bv ); 402 403 /* count elements */ 404 for ( i = 0; bv[i] != NULL; i++ ) ; 405 406 /* free in reverse order */ 407 for ( i--; i >= 0; i-- ) { 408 ber_bvfree_x( bv[i], ctx ); 409 } 410 411 ber_memfree_x( (char *) bv, ctx ); 412 } 413 414 void 415 ber_bvecfree( struct berval **bv ) 416 { 417 ber_bvecfree_x( bv, NULL ); 418 } 419 420 int 421 ber_bvecadd_x( struct berval ***bvec, struct berval *bv, void *ctx ) 422 { 423 ber_len_t i; 424 struct berval **new; 425 426 if( *bvec == NULL ) { 427 if( bv == NULL ) { 428 /* nothing to add */ 429 return 0; 430 } 431 432 *bvec = ber_memalloc_x( 2 * sizeof(struct berval *), ctx ); 433 434 if( *bvec == NULL ) { 435 return -1; 436 } 437 438 (*bvec)[0] = bv; 439 (*bvec)[1] = NULL; 440 441 return 1; 442 } 443 444 BER_MEM_VALID( bvec ); 445 446 /* count entries */ 447 for ( i = 0; (*bvec)[i] != NULL; i++ ) { 448 /* EMPTY */; 449 } 450 451 if( bv == NULL ) { 452 return i; 453 } 454 455 new = ber_memrealloc_x( *bvec, (i+2) * sizeof(struct berval *), ctx); 456 457 if( new == NULL ) { 458 return -1; 459 } 460 461 *bvec = new; 462 463 (*bvec)[i++] = bv; 464 (*bvec)[i] = NULL; 465 466 return i; 467 } 468 469 int 470 ber_bvecadd( struct berval ***bvec, struct berval *bv ) 471 { 472 return ber_bvecadd_x( bvec, bv, NULL ); 473 } 474 475 struct berval * 476 ber_dupbv_x( 477 struct berval *dst, struct berval *src, void *ctx ) 478 { 479 struct berval *new; 480 481 if( src == NULL ) { 482 ber_errno = LBER_ERROR_PARAM; 483 return NULL; 484 } 485 486 if ( dst ) { 487 new = dst; 488 } else { 489 if(( new = ber_memalloc_x( sizeof(struct berval), ctx )) == NULL ) { 490 ber_errno = LBER_ERROR_MEMORY; 491 return NULL; 492 } 493 } 494 495 if ( src->bv_val == NULL ) { 496 new->bv_val = NULL; 497 new->bv_len = 0; 498 return new; 499 } 500 501 if(( new->bv_val = ber_memalloc_x( src->bv_len + 1, ctx )) == NULL ) { 502 ber_errno = LBER_ERROR_MEMORY; 503 if ( !dst ) 504 ber_memfree_x( new, ctx ); 505 return NULL; 506 } 507 508 AC_MEMCPY( new->bv_val, src->bv_val, src->bv_len ); 509 new->bv_val[src->bv_len] = '\0'; 510 new->bv_len = src->bv_len; 511 512 return new; 513 } 514 515 struct berval * 516 ber_dupbv( 517 struct berval *dst, struct berval *src ) 518 { 519 return ber_dupbv_x( dst, src, NULL ); 520 } 521 522 struct berval * 523 ber_bvdup( 524 struct berval *src ) 525 { 526 return ber_dupbv_x( NULL, src, NULL ); 527 } 528 529 struct berval * 530 ber_str2bv_x( 531 LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv, 532 void *ctx) 533 { 534 struct berval *new; 535 536 if( s == NULL ) { 537 ber_errno = LBER_ERROR_PARAM; 538 return NULL; 539 } 540 541 if( bv ) { 542 new = bv; 543 } else { 544 if(( new = ber_memalloc_x( sizeof(struct berval), ctx )) == NULL ) { 545 ber_errno = LBER_ERROR_MEMORY; 546 return NULL; 547 } 548 } 549 550 new->bv_len = len ? len : strlen( s ); 551 if ( dup ) { 552 if ( (new->bv_val = ber_memalloc_x( new->bv_len+1, ctx )) == NULL ) { 553 ber_errno = LBER_ERROR_MEMORY; 554 if ( !bv ) 555 ber_memfree_x( new, ctx ); 556 return NULL; 557 } 558 559 AC_MEMCPY( new->bv_val, s, new->bv_len ); 560 new->bv_val[new->bv_len] = '\0'; 561 } else { 562 new->bv_val = (char *) s; 563 } 564 565 return( new ); 566 } 567 568 struct berval * 569 ber_str2bv( 570 LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv) 571 { 572 return ber_str2bv_x( s, len, dup, bv, NULL ); 573 } 574 575 struct berval * 576 ber_mem2bv_x( 577 LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv, 578 void *ctx) 579 { 580 struct berval *new; 581 582 if( s == NULL ) { 583 ber_errno = LBER_ERROR_PARAM; 584 return NULL; 585 } 586 587 if( bv ) { 588 new = bv; 589 } else { 590 if(( new = ber_memalloc_x( sizeof(struct berval), ctx )) == NULL ) { 591 ber_errno = LBER_ERROR_MEMORY; 592 return NULL; 593 } 594 } 595 596 new->bv_len = len; 597 if ( dup ) { 598 if ( (new->bv_val = ber_memalloc_x( new->bv_len+1, ctx )) == NULL ) { 599 ber_errno = LBER_ERROR_MEMORY; 600 if ( !bv ) { 601 ber_memfree_x( new, ctx ); 602 } 603 return NULL; 604 } 605 606 AC_MEMCPY( new->bv_val, s, new->bv_len ); 607 new->bv_val[new->bv_len] = '\0'; 608 } else { 609 new->bv_val = (char *) s; 610 } 611 612 return( new ); 613 } 614 615 struct berval * 616 ber_mem2bv( 617 LDAP_CONST char *s, ber_len_t len, int dup, struct berval *bv) 618 { 619 return ber_mem2bv_x( s, len, dup, bv, NULL ); 620 } 621 622 char * 623 ber_strdup_x( LDAP_CONST char *s, void *ctx ) 624 { 625 char *p; 626 size_t len; 627 628 #ifdef LDAP_MEMORY_DEBUG 629 assert(s != NULL); /* bv damn better point to something */ 630 #endif 631 632 if( s == NULL ) { 633 ber_errno = LBER_ERROR_PARAM; 634 return NULL; 635 } 636 637 len = strlen( s ) + 1; 638 639 if ( (p = ber_memalloc_x( len, ctx )) == NULL ) { 640 ber_errno = LBER_ERROR_MEMORY; 641 return NULL; 642 } 643 644 AC_MEMCPY( p, s, len ); 645 return p; 646 } 647 648 char * 649 ber_strdup( LDAP_CONST char *s ) 650 { 651 return ber_strdup_x( s, NULL ); 652 } 653 654 char * 655 ber_strndup_x( LDAP_CONST char *s, ber_len_t l, void *ctx ) 656 { 657 char *p; 658 size_t len; 659 660 #ifdef LDAP_MEMORY_DEBUG 661 assert(s != NULL); /* bv damn better point to something */ 662 #endif 663 664 if( s == NULL ) { 665 ber_errno = LBER_ERROR_PARAM; 666 return NULL; 667 } 668 669 len = strlen( s ); 670 671 if ( len > l ) { 672 len = l; 673 } 674 675 if ( (p = ber_memalloc_x( len + 1, ctx )) == NULL ) { 676 ber_errno = LBER_ERROR_MEMORY; 677 return NULL; 678 } 679 680 AC_MEMCPY( p, s, len ); 681 p[len] = '\0'; 682 return p; 683 } 684 685 char * 686 ber_strndup( LDAP_CONST char *s, ber_len_t l ) 687 { 688 return ber_strndup_x( s, l, NULL ); 689 } 690 691 /* 692 * dst is resized as required by src and the value of src is copied into dst 693 * dst->bv_val must be NULL (and dst->bv_len must be 0), or it must be 694 * alloc'ed with the context ctx 695 */ 696 struct berval * 697 ber_bvreplace_x( struct berval *dst, LDAP_CONST struct berval *src, void *ctx ) 698 { 699 assert( dst != NULL ); 700 assert( !BER_BVISNULL( src ) ); 701 702 if ( BER_BVISNULL( dst ) || dst->bv_len < src->bv_len ) { 703 dst->bv_val = ber_memrealloc_x( dst->bv_val, src->bv_len + 1, ctx ); 704 } 705 706 AC_MEMCPY( dst->bv_val, src->bv_val, src->bv_len + 1 ); 707 dst->bv_len = src->bv_len; 708 709 return dst; 710 } 711 712 struct berval * 713 ber_bvreplace( struct berval *dst, LDAP_CONST struct berval *src ) 714 { 715 return ber_bvreplace_x( dst, src, NULL ); 716 } 717 718 void 719 ber_bvarray_free_x( BerVarray a, void *ctx ) 720 { 721 int i; 722 723 if (a) { 724 BER_MEM_VALID( a ); 725 726 /* count elements */ 727 for (i=0; a[i].bv_val; i++) ; 728 729 /* free in reverse order */ 730 for (i--; i>=0; i--) { 731 ber_memfree_x(a[i].bv_val, ctx); 732 } 733 734 ber_memfree_x(a, ctx); 735 } 736 } 737 738 void 739 ber_bvarray_free( BerVarray a ) 740 { 741 ber_bvarray_free_x(a, NULL); 742 } 743 744 int 745 ber_bvarray_dup_x( BerVarray *dst, BerVarray src, void *ctx ) 746 { 747 int i, j; 748 BerVarray new; 749 750 if ( !src ) { 751 *dst = NULL; 752 return 0; 753 } 754 755 for (i=0; !BER_BVISNULL( &src[i] ); i++) ; 756 new = ber_memalloc_x(( i+1 ) * sizeof(BerValue), ctx ); 757 if ( !new ) 758 return -1; 759 for (j=0; j<i; j++) { 760 ber_dupbv_x( &new[j], &src[j], ctx ); 761 if ( BER_BVISNULL( &new[j] )) { 762 ber_bvarray_free_x( new, ctx ); 763 return -1; 764 } 765 } 766 BER_BVZERO( &new[j] ); 767 *dst = new; 768 return 0; 769 } 770 771 int 772 ber_bvarray_add_x( BerVarray *a, BerValue *bv, void *ctx ) 773 { 774 int n; 775 776 if ( *a == NULL ) { 777 if (bv == NULL) { 778 return 0; 779 } 780 n = 0; 781 782 *a = (BerValue *) ber_memalloc_x( 2 * sizeof(BerValue), ctx ); 783 if ( *a == NULL ) { 784 return -1; 785 } 786 787 } else { 788 BerVarray atmp; 789 BER_MEM_VALID( a ); 790 791 for ( n = 0; *a != NULL && (*a)[n].bv_val != NULL; n++ ) { 792 ; /* just count them */ 793 } 794 795 if (bv == NULL) { 796 return n; 797 } 798 799 atmp = (BerValue *) ber_memrealloc_x( (char *) *a, 800 (n + 2) * sizeof(BerValue), ctx ); 801 802 if( atmp == NULL ) { 803 return -1; 804 } 805 806 *a = atmp; 807 } 808 809 (*a)[n++] = *bv; 810 (*a)[n].bv_val = NULL; 811 (*a)[n].bv_len = 0; 812 813 return n; 814 } 815 816 int 817 ber_bvarray_add( BerVarray *a, BerValue *bv ) 818 { 819 return ber_bvarray_add_x( a, bv, NULL ); 820 } 821