git.sur5r.net Git - openldap/blob - libraries/liblber/decode.c

   1 /* decode.c - ber input decoding routines */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7 /* Portions
   8  * Copyright (c) 1990 Regents of the University of Michigan.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms are permitted
  12  * provided that this notice is preserved and that due credit is given
  13  * to the University of Michigan at Ann Arbor. The name of the University
  14  * may not be used to endorse or promote products derived from this
  15  * software without specific prior written permission. This software
  16  * is provided ``as is'' without express or implied warranty.
  17  */
  18
  19 #include "portable.h"
  20
  21 #include <stdio.h>
  22
  23 #include <ac/stdlib.h>
  24
  25 #include <ac/stdarg.h>
  26 #include <ac/string.h>
  27 #include <ac/socket.h>
  28
  29 #undef LDAP_F_PRE
  30 #define LDAP_F_PRE LDAP_F_EXPORT
  31
  32 #include "lber-int.h"
  33
  34 static ber_len_t ber_getnint LDAP_P((
  35         BerElement *ber,
  36         ber_int_t *num,
  37         ber_len_t len ));
  38
  39 /* return the tag - LBER_DEFAULT returned means trouble */
  40 ber_tag_t
  41 ber_get_tag( BerElement *ber )
  42 {
  43         unsigned char   xbyte;
  44         ber_tag_t       tag;
  45         char            *tagp;
  46         unsigned int    i;
  47
  48         assert( ber != NULL );
  49         assert( BER_VALID( ber ) );
  50
  51         if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
  52                 return( LBER_DEFAULT );
  53
  54         if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
  55                 return( (ber_tag_t) xbyte );
  56
  57         tagp = (char *) &tag;
  58         tagp[0] = xbyte;
  59         for ( i = 1; i < sizeof(ber_tag_t); i++ ) {
  60                 if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
  61                         return( LBER_DEFAULT );
  62
  63                 tagp[i] = xbyte;
  64
  65                 if ( ! (xbyte & LBER_MORE_TAG_MASK) )
  66                         break;
  67         }
  68
  69         /* tag too big! */
  70         if ( i == sizeof(ber_tag_t) )
  71                 return( LBER_DEFAULT );
  72
  73         /* want leading, not trailing 0's */
  74         return( tag >> (sizeof(ber_tag_t) - i - 1) );
  75 }
  76
  77 ber_tag_t
  78 ber_skip_tag( BerElement *ber, ber_len_t *len )
  79 {
  80         ber_tag_t       tag;
  81         unsigned char   lc;
  82         ber_len_t       i, noctets;
  83         unsigned char netlen[sizeof(ber_len_t)];
  84
  85         assert( ber != NULL );
  86         assert( len != NULL );
  87         assert( BER_VALID( ber ) );
  88
  89         /*
  90          * Any ber element looks like this: tag length contents.
  91          * Assuming everything's ok, we return the tag byte (we
  92          * can assume a single byte), and return the length in len.
  93          *
  94          * Assumptions:
  95          *      1) definite lengths
  96          *      2) primitive encodings used whenever possible
  97          */
  98
  99         /*
 100          * First, we read the tag.
 101          */
 102
 103         if ( (tag = ber_get_tag( ber )) == LBER_DEFAULT )
 104                 return( LBER_DEFAULT );
 105
 106         /*
 107          * Next, read the length.  The first byte contains the length of
 108          * the length.  If bit 8 is set, the length is the long form,
 109          * otherwise it's the short form.  We don't allow a length that's
 110          * greater than what we can hold in a ber_len_t.
 111          */
 112
 113         *len = 0;
 114
 115         if ( ber_read( ber, (char *) &lc, 1 ) != 1 )
 116                 return( LBER_DEFAULT );
 117
 118         if ( lc & 0x80U ) {
 119                 noctets = (lc & 0x7fU);
 120
 121                 if ( noctets > sizeof(ber_len_t) ) {
 122                         return( LBER_DEFAULT );
 123                 }
 124
 125                 if( (unsigned) ber_read( ber, netlen, noctets ) != noctets ) {
 126                         return( LBER_DEFAULT );
 127                 }
 128
 129                 for( i = 0; i < noctets; i++ ) {
 130                         *len <<= 8;
 131                         *len |= netlen[i];
 132                 }
 133
 134         } else {
 135                 *len = lc;
 136         }
 137
 138         return( tag );
 139 }
 140
 141 ber_tag_t
 142 ber_peek_tag(
 143         BerElement *ber_in,
 144         ber_len_t *len )
 145 {
 146         ber_tag_t       tag;
 147         BerElement *ber;
 148
 149         assert( ber_in != NULL );
 150         assert( BER_VALID( ber_in ) );
 151
 152         ber = ber_dup( ber_in );
 153
 154         if( ber == NULL ) {
 155                 return LBER_ERROR;
 156         }
 157
 158         assert( BER_VALID( ber ) );
 159
 160         tag = ber_skip_tag( ber, len );
 161
 162         ber_free( ber, 0 );
 163         return( tag );
 164 }
 165
 166 static ber_len_t
 167 ber_getnint(
 168         BerElement *ber,
 169         ber_int_t *num,
 170         ber_len_t len )
 171 {
 172         unsigned char buf[sizeof(ber_int_t)];
 173
 174         assert( ber != NULL );
 175         assert( num != NULL );
 176
 177         assert( BER_VALID( ber ) );
 178
 179         /*
 180          * The tag and length have already been stripped off.  We should
 181          * be sitting right before len bytes of 2's complement integer,
 182          * ready to be read straight into an int.  We may have to sign
 183          * extend after we read it in.
 184          */
 185
 186         if ( len > sizeof(ber_int_t) )
 187                 return( -1 );
 188
 189         /* read into the low-order bytes of our buffer */
 190         if ( (ber_len_t) ber_read( ber, (char *) buf, len ) != len ) {
 191                 return( -1 );
 192         }
 193
 194         if( len ) {
 195                 /* sign extend if necessary */
 196                 ber_len_t i;
 197                 ber_int_t netnum = 0x80 & buf[0] ? -1 : 0;
 198
 199                 /* shift in the bytes */
 200                 for( i=0 ; i<len; i++ ) {
 201                         netnum = (netnum << 8 ) | buf[i];
 202                 }
 203
 204                 *num = netnum;
 205
 206         } else {
 207                 *num = 0;
 208         }
 209
 210         return( len );
 211 }
 212
 213 ber_tag_t
 214 ber_get_int(
 215         BerElement *ber,
 216         ber_int_t *num )
 217 {
 218         ber_tag_t       tag;
 219         ber_len_t       len;
 220
 221         assert( ber != NULL );
 222         assert( BER_VALID( ber ) );
 223
 224         if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
 225                 return( LBER_DEFAULT );
 226
 227         if ( ber_getnint( ber, num, len ) != len )
 228                 return( LBER_DEFAULT );
 229         else
 230                 return( tag );
 231 }
 232
 233 ber_tag_t
 234 ber_get_stringb(
 235         BerElement *ber,
 236         char *buf,
 237         ber_len_t *len )
 238 {
 239         ber_len_t       datalen;
 240         ber_tag_t       tag;
 241
 242 #ifdef STR_TRANSLATION
 243         char            *transbuf;
 244 #endif /* STR_TRANSLATION */
 245
 246         assert( ber != NULL );
 247         assert( BER_VALID( ber ) );
 248
 249         if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
 250                 return( LBER_DEFAULT );
 251         if ( datalen > (*len - 1) )
 252                 return( LBER_DEFAULT );
 253
 254         if ( (ber_len_t) ber_read( ber, buf, datalen ) != datalen )
 255                 return( LBER_DEFAULT );
 256
 257         buf[datalen] = '\0';
 258
 259 #ifdef STR_TRANSLATION
 260         if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
 261             && ber->ber_decode_translate_proc ) {
 262                 transbuf = buf;
 263                 ++datalen;
 264                 if ( (*(ber->ber_decode_translate_proc))( &transbuf, &datalen,
 265                     0 ) != 0 ) {
 266                         return( LBER_DEFAULT );
 267                 }
 268                 if ( datalen > *len ) {
 269                         LBER_FREE( transbuf );
 270                         return( LBER_DEFAULT );
 271                 }
 272                 SAFEMEMCPY( buf, transbuf, datalen );
 273                 LBER_FREE( transbuf );
 274                 --datalen;
 275         }
 276 #endif /* STR_TRANSLATION */
 277
 278         *len = datalen;
 279         return( tag );
 280 }
 281
 282 ber_tag_t
 283 ber_get_stringa( BerElement *ber, char **buf )
 284 {
 285         ber_len_t       datalen;
 286         ber_tag_t       tag;
 287
 288         assert( ber != NULL );
 289         assert( buf != NULL );
 290
 291         assert( BER_VALID( ber ) );
 292
 293         if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) {
 294                 *buf = NULL;
 295                 return( LBER_DEFAULT );
 296         }
 297
 298         if ( (*buf = (char *) LBER_MALLOC( datalen + 1 )) == NULL )
 299                 return( LBER_DEFAULT );
 300
 301         if ( (ber_len_t) ber_read( ber, *buf, datalen ) != datalen ) {
 302                 LBER_FREE( *buf );
 303                 *buf = NULL;
 304                 return( LBER_DEFAULT );
 305         }
 306         (*buf)[datalen] = '\0';
 307
 308 #ifdef STR_TRANSLATION
 309         if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
 310             && ber->ber_decode_translate_proc ) {
 311                 ++datalen;
 312                 if ( (*(ber->ber_decode_translate_proc))( buf, &datalen, 1 )
 313                     != 0 ) {
 314                         LBER_FREE( *buf );
 315                         *buf = NULL;
 316                         return( LBER_DEFAULT );
 317                 }
 318         }
 319 #endif /* STR_TRANSLATION */
 320
 321         return( tag );
 322 }
 323
 324 ber_tag_t
 325 ber_get_stringal( BerElement *ber, struct berval **bv )
 326 {
 327         ber_len_t       len;
 328         ber_tag_t       tag;
 329
 330         assert( ber != NULL );
 331         assert( bv != NULL );
 332
 333         assert( BER_VALID( ber ) );
 334
 335         if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) {
 336                 *bv = NULL;
 337                 return( LBER_DEFAULT );
 338         }
 339
 340         if ( (*bv = (struct berval *) LBER_MALLOC( sizeof(struct berval) )) == NULL )
 341                 return( LBER_DEFAULT );
 342
 343         if ( ((*bv)->bv_val = (char *) LBER_MALLOC( len + 1 )) == NULL ) {
 344                 LBER_FREE( *bv );
 345                 *bv = NULL;
 346                 return( LBER_DEFAULT );
 347         }
 348
 349         if ( (ber_len_t) ber_read( ber, (*bv)->bv_val, len ) != len ) {
 350                 ber_bvfree( *bv );
 351                 *bv = NULL;
 352                 return( LBER_DEFAULT );
 353         }
 354         ((*bv)->bv_val)[len] = '\0';
 355         (*bv)->bv_len = len;
 356
 357 #ifdef STR_TRANSLATION
 358         if ( len > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
 359             && ber->ber_decode_translate_proc ) {
 360                 ++len;
 361                 if ( (*(ber->ber_decode_translate_proc))( &((*bv)->bv_val),
 362                     &len, 1 ) != 0 ) {
 363                         ber_bvfree( *bv );
 364                         *bv = NULL;
 365                         return( LBER_DEFAULT );
 366                 }
 367                 (*bv)->bv_len = len - 1;
 368         }
 369 #endif /* STR_TRANSLATION */
 370
 371         return( tag );
 372 }
 373
 374 ber_tag_t
 375 ber_get_bitstringa(
 376         BerElement *ber,
 377         char **buf,
 378         ber_len_t *blen )
 379 {
 380         ber_len_t       datalen;
 381         ber_tag_t       tag;
 382         unsigned char   unusedbits;
 383
 384         assert( ber != NULL );
 385         assert( buf != NULL );
 386         assert( blen != NULL );
 387
 388         assert( BER_VALID( ber ) );
 389
 390         if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) {
 391                 *buf = NULL;
 392                 return( LBER_DEFAULT );
 393         }
 394         --datalen;
 395
 396         if ( (*buf = (char *) LBER_MALLOC( datalen )) == NULL )
 397                 return( LBER_DEFAULT );
 398
 399         if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) {
 400                 LBER_FREE( buf );
 401                 *buf = NULL;
 402                 return( LBER_DEFAULT );
 403         }
 404
 405         if ( (ber_len_t) ber_read( ber, *buf, datalen ) != datalen ) {
 406                 LBER_FREE( buf );
 407                 *buf = NULL;
 408                 return( LBER_DEFAULT );
 409         }
 410
 411         *blen = datalen * 8 - unusedbits;
 412         return( tag );
 413 }
 414
 415 ber_tag_t
 416 ber_get_null( BerElement *ber )
 417 {
 418         ber_len_t       len;
 419         ber_tag_t       tag;
 420
 421         assert( ber != NULL );
 422         assert( BER_VALID( ber ) );
 423
 424         if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
 425                 return( LBER_DEFAULT );
 426
 427         if ( len != 0 )
 428                 return( LBER_DEFAULT );
 429
 430         return( tag );
 431 }
 432
 433 ber_tag_t
 434 ber_get_boolean(
 435         BerElement *ber,
 436         ber_int_t *boolval )
 437 {
 438         ber_int_t       longbool;
 439         ber_tag_t       rc;
 440
 441         assert( ber != NULL );
 442         assert( boolval != NULL );
 443
 444         assert( BER_VALID( ber ) );
 445
 446         rc = ber_get_int( ber, &longbool );
 447         *boolval = longbool;
 448
 449         return( rc );
 450 }
 451
 452 ber_tag_t
 453 ber_first_element(
 454         BerElement *ber,
 455         ber_len_t *len,
 456         char **last )
 457 {
 458         assert( ber != NULL );
 459         assert( len != NULL );
 460         assert( last != NULL );
 461
 462         /* skip the sequence header, use the len to mark where to stop */
 463         if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) {
 464                 *last = NULL;
 465                 return( LBER_DEFAULT );
 466         }
 467
 468         *last = ber->ber_ptr + *len;
 469
 470         if ( *last == ber->ber_ptr ) {
 471                 return( LBER_DEFAULT );
 472         }
 473
 474         return( ber_peek_tag( ber, len ) );
 475 }
 476
 477 ber_tag_t
 478 ber_next_element(
 479         BerElement *ber,
 480         ber_len_t *len,
 481         LDAP_CONST char *last )
 482 {
 483         assert( ber != NULL );
 484         assert( len != NULL );
 485         assert( last != NULL );
 486
 487         assert( BER_VALID( ber ) );
 488
 489         if ( ber->ber_ptr == last ) {
 490                 return( LBER_DEFAULT );
 491         }
 492
 493         return( ber_peek_tag( ber, len ) );
 494 }
 495
 496 /* VARARGS */
 497 ber_tag_t
 498 ber_scanf ( BerElement *ber,
 499         LDAP_CONST char *fmt,
 500         ... )
 501 {
 502         va_list         ap;
 503         LDAP_CONST char         *fmt_reset;
 504         char            *last;
 505         char            *s, **ss, ***sss;
 506         struct berval   ***bv, **bvp, *bval;
 507         ber_int_t       *i;
 508         int j;
 509         ber_len_t       *l;
 510         ber_tag_t       *t;
 511         ber_tag_t       rc, tag;
 512         ber_len_t       len;
 513
 514         va_start( ap, fmt );
 515
 516         assert( ber != NULL );
 517         assert( fmt != NULL );
 518
 519         assert( BER_VALID( ber ) );
 520
 521         fmt_reset = fmt;
 522
 523         ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 524                 "ber_scanf fmt (%s) ber:\n", fmt );
 525         ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
 526
 527         for ( rc = 0; *fmt && rc != LBER_DEFAULT; fmt++ ) {
 528                 /* When this is modified, remember to update
 529                  * the error-cleanup code below accordingly. */
 530                 switch ( *fmt ) {
 531                 case '!': { /* Hook */
 532                                 BERDecodeCallback *f;
 533                                 void *p;
 534
 535                                 f = va_arg( ap, BERDecodeCallback * );
 536                                 p = va_arg( ap, void * );
 537
 538                                 rc = (*f)( ber, p, 0 );
 539                         } break;
 540
 541                 case 'a':       /* octet string - allocate storage as needed */
 542                         ss = va_arg( ap, char ** );
 543                         rc = ber_get_stringa( ber, ss );
 544                         break;
 545
 546                 case 'b':       /* boolean */
 547                         i = va_arg( ap, ber_int_t * );
 548                         rc = ber_get_boolean( ber, i );
 549                         break;
 550
 551                 case 'e':       /* enumerated */
 552                 case 'i':       /* int */
 553                         i = va_arg( ap, ber_int_t * );
 554                         rc = ber_get_int( ber, i );
 555                         break;
 556
 557                 case 'l':       /* length of next item */
 558                         l = va_arg( ap, ber_len_t * );
 559                         rc = ber_peek_tag( ber, l );
 560                         break;
 561
 562                 case 'n':       /* null */
 563                         rc = ber_get_null( ber );
 564                         break;
 565
 566                 case 's':       /* octet string - in a buffer */
 567                         s = va_arg( ap, char * );
 568                         l = va_arg( ap, ber_len_t * );
 569                         rc = ber_get_stringb( ber, s, l );
 570                         break;
 571
 572                 case 'o':       /* octet string in a supplied berval */
 573                         bval = va_arg( ap, struct berval * );
 574                         ber_peek_tag( ber, &bval->bv_len );
 575                         rc = ber_get_stringa( ber, &bval->bv_val );
 576                         break;
 577
 578                 case 'O':       /* octet string - allocate & include length */
 579                         bvp = va_arg( ap, struct berval ** );
 580                         rc = ber_get_stringal( ber, bvp );
 581                         break;
 582
 583                 case 'B':       /* bit string - allocate storage as needed */
 584                         ss = va_arg( ap, char ** );
 585                         l = va_arg( ap, ber_len_t * ); /* for length, in bits */
 586                         rc = ber_get_bitstringa( ber, ss, l );
 587                         break;
 588
 589                 case 't':       /* tag of next item */
 590                         t = va_arg( ap, ber_tag_t * );
 591                         *t = rc = ber_peek_tag( ber, &len );
 592                         break;
 593
 594                 case 'T':       /* skip tag of next item */
 595                         t = va_arg( ap, ber_tag_t * );
 596                         *t = rc = ber_skip_tag( ber, &len );
 597                         break;
 598
 599                 case 'v':       /* sequence of strings */
 600                         sss = va_arg( ap, char *** );
 601                         *sss = NULL;
 602                         j = 0;
 603                         for ( tag = ber_first_element( ber, &len, &last );
 604                             tag != LBER_DEFAULT && rc != LBER_DEFAULT;
 605                             tag = ber_next_element( ber, &len, last ) )
 606                         {
 607                                 *sss = (char **) LBER_REALLOC( *sss,
 608                                         (j + 2) * sizeof(char *) );
 609
 610                                 rc = ber_get_stringa( ber, &((*sss)[j]) );
 611                                 j++;
 612                         }
 613                         if ( j > 0 )
 614                                 (*sss)[j] = NULL;
 615                         break;
 616
 617                 case 'V':       /* sequence of strings + lengths */
 618                         bv = va_arg( ap, struct berval *** );
 619                         *bv = NULL;
 620                         j = 0;
 621                         for ( tag = ber_first_element( ber, &len, &last );
 622                             tag != LBER_DEFAULT && rc != LBER_DEFAULT;
 623                             tag = ber_next_element( ber, &len, last ) )
 624                         {
 625                                 *bv = (struct berval **) LBER_REALLOC( *bv,
 626                                         (j + 2) * sizeof(struct berval *) );
 627
 628                                 rc = ber_get_stringal( ber, &((*bv)[j]) );
 629                                 j++;
 630                         }
 631                         if ( j > 0 )
 632                                 (*bv)[j] = NULL;
 633                         break;
 634
 635                 case 'x':       /* skip the next element - whatever it is */
 636                         if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
 637                                 break;
 638                         ber->ber_ptr += len;
 639                         break;
 640
 641                 case '{':       /* begin sequence */
 642                 case '[':       /* begin set */
 643                         if ( *(fmt + 1) != 'v' && *(fmt + 1) != 'V' )
 644                                 rc = ber_skip_tag( ber, &len );
 645                         break;
 646
 647                 case '}':       /* end sequence */
 648                 case ']':       /* end set */
 649                         break;
 650
 651                 default:
 652                         if( ber->ber_debug ) {
 653                                 ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug,
 654                                         "ber_scanf: unknown fmt %c\n", *fmt );
 655                         }
 656                         rc = LBER_DEFAULT;
 657                         break;
 658                 }
 659         }
 660
 661         va_end( ap );
 662
 663         if ( rc == LBER_DEFAULT ) {
 664             /*
 665              * Error.  Reclaim malloced memory that was given to the caller.
 666              * Set allocated pointers to NULL, "data length" outvalues to 0.
 667              */
 668             va_start( ap, fmt );
 669
 670             for ( ; fmt_reset < fmt; fmt_reset++ ) {
 671                 switch ( *fmt_reset ) {
 672                 case '!': { /* Hook */
 673                                 BERDecodeCallback *f;
 674                                 void *p;
 675
 676                                 f = va_arg( ap, BERDecodeCallback * );
 677                                 p = va_arg( ap, void * );
 678
 679                                 (void) (*f)( ber, p, 1 );
 680                         } break;
 681
 682                 case 'a':       /* octet string - allocate storage as needed */
 683                         ss = va_arg( ap, char ** );
 684                         if ( *ss ) {
 685                                 LBER_FREE( *ss );
 686                                 *ss = NULL;
 687                         }
 688                         break;
 689
 690                 case 'b':       /* boolean */
 691                 case 'e':       /* enumerated */
 692                 case 'i':       /* int */
 693                         (void) va_arg( ap, int * );
 694                         break;
 695
 696                 case 's':       /* octet string - in a buffer */
 697                         (void) va_arg( ap, char * );
 698                         (void) va_arg( ap, ber_len_t * );
 699                         break;
 700
 701                 case 'l':       /* length of next item */
 702                         (void) va_arg( ap, ber_len_t * );
 703                         break;
 704
 705                 case 't':       /* tag of next item */
 706                 case 'T':       /* skip tag of next item */
 707                         (void) va_arg( ap, ber_tag_t * );
 708                         break;
 709
 710                 case 'o':       /* octet string in a supplied berval */
 711                         bval = va_arg( ap, struct berval * );
 712                         if ( bval->bv_val != NULL ) {
 713                                 LBER_FREE( bval->bv_val );
 714                                 bval->bv_val = NULL;
 715                         }
 716                         bval->bv_len = 0;
 717                         break;
 718
 719                 case 'O':       /* octet string - allocate & include length */
 720                         bvp = va_arg( ap, struct berval ** );
 721                         if ( *bvp ) {
 722                                 ber_bvfree( *bvp );
 723                                 *bvp = NULL;
 724                         }
 725                         break;
 726
 727                 case 'B':       /* bit string - allocate storage as needed */
 728                         ss = va_arg( ap, char ** );
 729                         if ( *ss ) {
 730                                 LBER_FREE( *ss );
 731                                 *ss = NULL;
 732                         }
 733                         *(va_arg( ap, ber_len_t * )) = 0; /* for length, in bits */
 734                         break;
 735
 736                 case 'v':       /* sequence of strings */
 737                         sss = va_arg( ap, char *** );
 738                         if ( *sss ) {
 739                                 for (j = 0;  (*sss)[j];  j++) {
 740                                         LBER_FREE( (*sss)[j] );
 741                                         (*sss)[j] = NULL;
 742                                 }
 743                                 LBER_FREE( *sss );
 744                                 *sss = NULL;
 745                         }
 746                         break;
 747
 748                 case 'V':       /* sequence of strings + lengths */
 749                         bv = va_arg( ap, struct berval *** );
 750                         if ( *bv ) {
 751                                 ber_bvecfree( *bv );
 752                                 *bv = NULL;
 753                         }
 754                         break;
 755
 756                 case 'n':       /* null */
 757                 case 'x':       /* skip the next element - whatever it is */
 758                 case '{':       /* begin sequence */
 759                 case '[':       /* begin set */
 760                 case '}':       /* end sequence */
 761                 case ']':       /* end set */
 762                         break;
 763
 764                 default:
 765                         /* format should be good */
 766                         assert( 0 );
 767                 }
 768             }
 769
 770             va_end( ap );
 771         }
 772
 773         return( rc );
 774 }
 775
 776
 777 #ifdef STR_TRANSLATION
 778 void
 779 ber_set_string_translators( BerElement *ber, BERTranslateProc encode_proc,
 780         BERTranslateProc decode_proc )
 781 {
 782         assert( ber != NULL );
 783         assert( BER_VALID( ber ) );
 784
 785     ber->ber_encode_translate_proc = encode_proc;
 786     ber->ber_decode_translate_proc = decode_proc;
 787 }
 788 #endif /* STR_TRANSLATION */