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