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

   1 /* decode.c - ber input decoding routines */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 1998-2009 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16 /* Portions Copyright (c) 1990 Regents of the University of Michigan.
  17  * All rights reserved.
  18  *
  19  * Redistribution and use in source and binary forms are permitted
  20  * provided that this notice is preserved and that due credit is given
  21  * to the University of Michigan at Ann Arbor. The name of the University
  22  * may not be used to endorse or promote products derived from this
  23  * software without specific prior written permission. This software
  24  * is provided ``as is'' without express or implied warranty.
  25  */
  26 /* ACKNOWLEDGEMENTS:
  27  * This work was originally developed by the University of Michigan
  28  * (as part of U-MICH LDAP).
  29  */
  30
  31 #include "portable.h"
  32
  33 #include <stdio.h>
  34
  35 #include <ac/stdlib.h>
  36 #include <ac/stdarg.h>
  37 #include <ac/string.h>
  38 #include <ac/socket.h>
  39
  40 #include "lber-int.h"
  41
  42
  43 /* out->bv_len should be the buffer size on input */
  44 int
  45 ber_decode_oid( BerValue *in, BerValue *out )
  46 {
  47         const unsigned char *der;
  48         unsigned long val;
  49         unsigned val1;
  50         ber_len_t i;
  51         char *ptr;
  52
  53         assert( in != NULL );
  54         assert( out != NULL );
  55
  56         /* need 4 chars/inbyte + \0 for input={7f 7f 7f...} */
  57         if ( !out->bv_val || (out->bv_len+3)/4 <= in->bv_len )
  58                 return -1;
  59
  60         ptr = NULL;
  61         der = (unsigned char *) in->bv_val;
  62         val = 0;
  63         for ( i=0; i < in->bv_len; i++ ) {
  64                 val |= der[i] & 0x7f;
  65                 if ( !( der[i] & 0x80 )) {
  66                         if ( ptr == NULL ) {
  67                                 /* Initial "x.y": val=x*40+y, x<=2, y<40 if x<2 */
  68                                 ptr = out->bv_val;
  69                                 val1 = (val < 80 ? val/40 : 2);
  70                                 val -= val1*40;
  71                                 ptr += sprintf( ptr, "%u", val1 );
  72                         }
  73                         ptr += sprintf( ptr, ".%lu", val );
  74                         val = 0;
  75                 } else if ( val - 1UL < LBER_OID_COMPONENT_MAX >> 7 ) {
  76                         val <<= 7;
  77                 } else {
  78                         /* val would overflow, or is 0 from invalid initial 0x80 octet */
  79                         return -1;
  80                 }
  81         }
  82         if ( ptr == NULL || val != 0 )
  83                 return -1;
  84
  85         out->bv_len = ptr - out->bv_val;
  86         return 0;
  87 }
  88
  89 /* return the tag - LBER_DEFAULT returned means trouble */
  90 ber_tag_t
  91 ber_get_tag( BerElement *ber )
  92 {
  93         unsigned char   xbyte;
  94         ber_tag_t       tag;
  95
  96         assert( ber != NULL );
  97         assert( LBER_VALID( ber ) );
  98
  99         if ( ber_pvt_ber_remaining( ber ) < 1 ) {
 100                 return LBER_DEFAULT;
 101         }
 102
 103         if ( ber->ber_ptr == ber->ber_buf ) {
 104                 tag = *(unsigned char *)ber->ber_ptr;
 105         } else {
 106                 tag = ber->ber_tag;
 107         }
 108         ber->ber_ptr++;
 109
 110         if ( (tag & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK ) {
 111                 return tag;
 112         }
 113
 114         do {
 115                 if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) {
 116                         break;
 117                 }
 118
 119                 tag <<= 8;
 120                 tag |= 0x00ffUL & (ber_tag_t) xbyte;
 121
 122                 if ( ! (xbyte & LBER_MORE_TAG_MASK) ) {
 123                         return tag;
 124                 }
 125         } while ( tag <= (ber_tag_t)-1 / 256 );
 126
 127         return LBER_DEFAULT;            /* error or tag too big */
 128 }
 129
 130 ber_tag_t
 131 ber_skip_tag( BerElement *ber, ber_len_t *lenp )
 132 {
 133         ber_tag_t       tag;
 134         ber_len_t       len;
 135         unsigned        i, noctets;
 136         unsigned char   lc;
 137         unsigned char netlen[sizeof(ber_len_t)];
 138
 139         assert( lenp != NULL );
 140
 141         /*
 142          * Any ber element looks like this: tag length contents.
 143          * Assuming everything's ok, we return the tag byte (we
 144          * can assume a single byte), and return the length in lenp.
 145          *
 146          * Assumptions:
 147          *      1) definite lengths
 148          *      2) primitive encodings used whenever possible
 149          */
 150
 151         *lenp = 0;
 152
 153         /*
 154          * First, we read the tag.
 155          */
 156
 157         if ( (tag = ber_get_tag( ber )) == LBER_DEFAULT ) {
 158                 return LBER_DEFAULT;
 159         }
 160
 161         /*
 162          * Next, read the length.  The first octet determines the length
 163          * of the length.       If bit 8 is 0, the length is the short form,
 164          * otherwise if the octet != 0x80 it's the long form, otherwise
 165          * the ber element has the unsupported indefinite-length format.
 166          * Lengths that do not fit in a ber_len_t are not accepted.
 167          */
 168
 169         if ( ber_read( ber, (char *) &lc, 1 ) != 1 ) {
 170                 return LBER_DEFAULT;
 171         }
 172
 173         len = lc;
 174         if ( lc & 0x80U ) {
 175                 noctets = (lc & 0x7fU);
 176
 177                 if ( noctets - 1U > sizeof(ber_len_t) - 1U ) {
 178                         /* Indefinite-length or too long length */
 179                         return LBER_DEFAULT;
 180                 }
 181
 182                 if( (unsigned) ber_read( ber, (char *) netlen, noctets ) != noctets ) {
 183                         return LBER_DEFAULT;
 184                 }
 185
 186                 len = netlen[0];
 187                 for( i = 1; i < noctets; i++ ) {
 188                         len <<= 8;
 189                         len |= netlen[i];
 190                 }
 191
 192         }
 193         *lenp = len;
 194
 195         /* BER element should have enough data left */
 196         if( len > (ber_len_t) ber_pvt_ber_remaining( ber ) ) {
 197                 return LBER_DEFAULT;
 198         }
 199         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 200
 201         return tag;
 202 }
 203
 204 ber_tag_t
 205 ber_peek_tag(
 206         BerElement *ber,
 207         ber_len_t *len )
 208 {
 209         /*
 210          * This implementation assumes ber_skip_tag() only
 211          * modifies ber_ptr field of the BerElement.
 212          */
 213
 214         char *save;
 215         ber_tag_t       tag, old;
 216
 217         old = ber->ber_tag;
 218         save = ber->ber_ptr;
 219         tag = ber_skip_tag( ber, len );
 220         ber->ber_ptr = save;
 221         ber->ber_tag = old;
 222
 223         return tag;
 224 }
 225
 226 ber_tag_t
 227 ber_get_int(
 228         BerElement *ber,
 229         ber_int_t *num )
 230 {
 231         ber_tag_t       tag;
 232         ber_len_t       len;
 233         unsigned char buf[sizeof(ber_int_t)];
 234
 235         assert( num != NULL );
 236
 237         if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) {
 238                 return LBER_DEFAULT;
 239         }
 240
 241         if ( len > sizeof(ber_int_t) ) {
 242                 return LBER_DEFAULT;
 243         }
 244
 245         /* read into the low-order bytes of our buffer */
 246         if ( (ber_len_t) ber_read( ber, (char *) buf, len ) != len ) {
 247                 return LBER_DEFAULT;
 248         }
 249
 250         /* parse two's complement integer */
 251         if( len ) {
 252                 ber_len_t i;
 253                 ber_int_t netnum = buf[0] & 0xff;
 254
 255                 /* sign extend */
 256                 netnum -= (netnum & 0x80) << 1;
 257
 258                 /* shift in the bytes */
 259                 for( i = 1; i < len; i++ ) {
 260                         netnum = (netnum << 8 ) | buf[i];
 261                 }
 262
 263                 *num = netnum;
 264
 265         } else {
 266                 *num = 0;
 267         }
 268
 269         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 270
 271         return tag;
 272 }
 273
 274 ber_tag_t
 275 ber_get_enum(
 276         BerElement *ber,
 277         ber_int_t *num )
 278 {
 279         return ber_get_int( ber, num );
 280 }
 281
 282 ber_tag_t
 283 ber_get_stringb(
 284         BerElement *ber,
 285         char *buf,
 286         ber_len_t *len )
 287 {
 288         ber_len_t       datalen;
 289         ber_tag_t       tag;
 290
 291         if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) {
 292                 return LBER_DEFAULT;
 293         }
 294
 295         /* must fit within allocated space with termination */
 296         if ( datalen >= *len ) {
 297                 return LBER_DEFAULT;
 298         }
 299
 300         if ( (ber_len_t) ber_read( ber, buf, datalen ) != datalen ) {
 301                 return LBER_DEFAULT;
 302         }
 303         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 304
 305         buf[datalen] = '\0';
 306
 307         *len = datalen;
 308         return tag;
 309 }
 310
 311 /* Definitions for get_string vector
 312  *
 313  * ChArray, BvArray, and BvVec are self-explanatory.
 314  * BvOff is a struct berval embedded in an array of larger structures
 315  * of siz bytes at off bytes from the beginning of the struct.
 316  */
 317 enum bgbvc { ChArray, BvArray, BvVec, BvOff };
 318
 319 /* Use this single cookie for state, to keep actual
 320  * stack use to the absolute minimum.
 321  */
 322 typedef struct bgbvr {
 323         enum bgbvc choice;
 324         BerElement *ber;
 325         int alloc;
 326         ber_len_t siz;
 327         ber_len_t off;
 328         union {
 329                 char ***c;
 330                 BerVarray *ba;
 331                 struct berval ***bv;
 332         } res;
 333 } bgbvr;
 334
 335 static ber_tag_t
 336 ber_get_stringbvl( bgbvr *b, ber_len_t *rlen )
 337 {
 338         int i = 0, n;
 339         ber_tag_t tag;
 340         ber_len_t len;
 341         char *last, *orig;
 342         struct berval bv, *bvp = NULL;
 343
 344         /* For rewinding, just like ber_peek_tag() */
 345         orig = b->ber->ber_ptr;
 346         tag = b->ber->ber_tag;
 347
 348         if ( ber_first_element( b->ber, &len, &last ) != LBER_DEFAULT ) {
 349                 for ( ; b->ber->ber_ptr < last; i++ ) {
 350                         if (ber_skip_tag( b->ber, &len ) == LBER_DEFAULT) break;
 351                         b->ber->ber_ptr += len;
 352                         b->ber->ber_tag = *(unsigned char *)b->ber->ber_ptr;
 353                 }
 354         }
 355
 356         if ( rlen ) *rlen = i;
 357
 358         if ( i == 0 ) {
 359                 *b->res.c = NULL;
 360                 return 0;
 361         }
 362
 363         n = i;
 364
 365         /* Allocate the result vector */
 366         switch (b->choice) {
 367         case ChArray:
 368                 *b->res.c = ber_memalloc_x( (n+1)*sizeof( char * ),
 369                         b->ber->ber_memctx);
 370                 if ( *b->res.c == NULL ) return LBER_DEFAULT;
 371                 (*b->res.c)[n] = NULL;
 372                 break;
 373         case BvArray:
 374                 *b->res.ba = ber_memalloc_x( (n+1)*sizeof( struct berval ),
 375                         b->ber->ber_memctx);
 376                 if ( *b->res.ba == NULL ) return LBER_DEFAULT;
 377                 (*b->res.ba)[n].bv_val = NULL;
 378                 break;
 379         case BvVec:
 380                 *b->res.bv = ber_memalloc_x( (n+1)*sizeof( struct berval *),
 381                         b->ber->ber_memctx);
 382                 if ( *b->res.bv == NULL ) return LBER_DEFAULT;
 383                 (*b->res.bv)[n] = NULL;
 384                 break;
 385         case BvOff:
 386                 *b->res.ba = ber_memalloc_x( (n+1) * b->siz, b->ber->ber_memctx );
 387                 if ( *b->res.ba == NULL ) return LBER_DEFAULT;
 388                 ((struct berval *)((char *)(*b->res.ba) + n*b->siz +
 389                         b->off))->bv_val = NULL;
 390                 break;
 391         }
 392         b->ber->ber_ptr = orig;
 393         b->ber->ber_tag = tag;
 394         ber_skip_tag( b->ber, &len );
 395
 396         for (n=0; n<i; n++)
 397         {
 398                 tag = ber_next_element( b->ber, &len, last );
 399                 if ( ber_get_stringbv( b->ber, &bv, b->alloc ) == LBER_DEFAULT ) {
 400                         goto nomem;
 401                 }
 402
 403                 /* store my result */
 404                 switch (b->choice) {
 405                 case ChArray:
 406                         (*b->res.c)[n] = bv.bv_val;
 407                         break;
 408                 case BvArray:
 409                         (*b->res.ba)[n] = bv;
 410                         break;
 411                 case BvVec:
 412                         bvp = ber_memalloc_x( sizeof( struct berval ), b->ber->ber_memctx);
 413                         if ( !bvp ) {
 414                                 LBER_FREE(bv.bv_val);
 415                                 goto nomem;
 416                         }
 417                         (*b->res.bv)[n] = bvp;
 418                         *bvp = bv;
 419                         break;
 420                 case BvOff:
 421                         *(BerVarray)((char *)(*b->res.ba)+n*b->siz+b->off) = bv;
 422                         break;
 423                 }
 424         }
 425         return tag;
 426
 427 nomem:
 428         if (b->alloc || b->choice == BvVec) {
 429                 for (--n; n>=0; n--) {
 430                         switch(b->choice) {
 431                         case ChArray:
 432                                 LBER_FREE((*b->res.c)[n]);
 433                                 break;
 434                         case BvArray:
 435                                 LBER_FREE((*b->res.ba)[n].bv_val);
 436                                 break;
 437                         case BvVec:
 438                                 LBER_FREE((*b->res.bv)[n]->bv_val);
 439                                 LBER_FREE((*b->res.bv)[n]);
 440                                 break;
 441                         default:
 442                                 break;
 443                         }
 444                 }
 445         }
 446         LBER_FREE(*b->res.c);
 447         *b->res.c = NULL;
 448         return LBER_DEFAULT;
 449 }
 450
 451 ber_tag_t
 452 ber_get_stringbv( BerElement *ber, struct berval *bv, int option )
 453 {
 454         ber_tag_t       tag;
 455
 456         assert( bv != NULL );
 457
 458         tag = ber_skip_tag( ber, &bv->bv_len );
 459         if ( tag == LBER_DEFAULT ) {
 460                 bv->bv_val = NULL;
 461                 return tag;
 462         }
 463
 464         if ( option & LBER_BV_ALLOC ) {
 465                 bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1,
 466                         ber->ber_memctx );
 467                 if ( bv->bv_val == NULL ) {
 468                         return LBER_DEFAULT;
 469                 }
 470
 471                 if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val,
 472                         bv->bv_len ) != bv->bv_len )
 473                 {
 474                         LBER_FREE( bv->bv_val );
 475                         bv->bv_val = NULL;
 476                         return LBER_DEFAULT;
 477                 }
 478         } else {
 479                 bv->bv_val = ber->ber_ptr;
 480                 ber->ber_ptr += bv->bv_len;
 481         }
 482         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 483         if ( !( option & LBER_BV_NOTERM ))
 484                 bv->bv_val[bv->bv_len] = '\0';
 485
 486         return tag;
 487 }
 488
 489 ber_tag_t
 490 ber_get_stringbv_null( BerElement *ber, struct berval *bv, int option )
 491 {
 492         ber_tag_t       tag;
 493
 494         assert( bv != NULL );
 495
 496         tag = ber_skip_tag( ber, &bv->bv_len );
 497         if ( tag == LBER_DEFAULT || bv->bv_len == 0 ) {
 498                 bv->bv_val = NULL;
 499                 return tag;
 500         }
 501
 502         if ( option & LBER_BV_ALLOC ) {
 503                 bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1,
 504                         ber->ber_memctx );
 505                 if ( bv->bv_val == NULL ) {
 506                         return LBER_DEFAULT;
 507                 }
 508
 509                 if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val,
 510                         bv->bv_len ) != bv->bv_len )
 511                 {
 512                         LBER_FREE( bv->bv_val );
 513                         bv->bv_val = NULL;
 514                         return LBER_DEFAULT;
 515                 }
 516         } else {
 517                 bv->bv_val = ber->ber_ptr;
 518                 ber->ber_ptr += bv->bv_len;
 519         }
 520         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 521         if ( !( option & LBER_BV_NOTERM ))
 522                 bv->bv_val[bv->bv_len] = '\0';
 523
 524         return tag;
 525 }
 526
 527 ber_tag_t
 528 ber_get_stringa( BerElement *ber, char **buf )
 529 {
 530         BerValue        bv;
 531         ber_tag_t       tag;
 532
 533         assert( buf != NULL );
 534
 535         tag = ber_get_stringbv( ber, &bv, LBER_BV_ALLOC );
 536         *buf = bv.bv_val;
 537
 538         return tag;
 539 }
 540
 541 ber_tag_t
 542 ber_get_stringa_null( BerElement *ber, char **buf )
 543 {
 544         BerValue        bv;
 545         ber_tag_t       tag;
 546
 547         assert( buf != NULL );
 548
 549         tag = ber_get_stringbv_null( ber, &bv, LBER_BV_ALLOC );
 550         *buf = bv.bv_val;
 551
 552         return tag;
 553 }
 554
 555 ber_tag_t
 556 ber_get_stringal( BerElement *ber, struct berval **bv )
 557 {
 558         ber_tag_t       tag;
 559
 560         assert( ber != NULL );
 561         assert( bv != NULL );
 562
 563         *bv = (struct berval *) ber_memalloc_x( sizeof(struct berval),
 564                 ber->ber_memctx );
 565         if ( *bv == NULL ) {
 566                 return LBER_DEFAULT;
 567         }
 568
 569         tag = ber_get_stringbv( ber, *bv, LBER_BV_ALLOC );
 570         if ( tag == LBER_DEFAULT ) {
 571                 LBER_FREE( *bv );
 572                 *bv = NULL;
 573         }
 574         return tag;
 575 }
 576
 577 ber_tag_t
 578 ber_get_bitstringa(
 579         BerElement *ber,
 580         char **buf,
 581         ber_len_t *blen )
 582 {
 583         ber_len_t       datalen;
 584         ber_tag_t       tag;
 585         unsigned char   unusedbits;
 586
 587         assert( buf != NULL );
 588         assert( blen != NULL );
 589
 590         if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) {
 591                 goto fail;
 592         }
 593
 594         if ( --datalen > (ber_len_t)-1 / 8 ) {
 595                 goto fail;
 596         }
 597         if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) {
 598                 goto fail;
 599         }
 600         if ( unusedbits > 7 ) {
 601                 goto fail;
 602         }
 603
 604         *buf = (char *) ber_memalloc_x( datalen, ber->ber_memctx );
 605         if ( *buf == NULL ) {
 606                 return LBER_DEFAULT;
 607         }
 608
 609         if ( (ber_len_t) ber_read( ber, *buf, datalen ) != datalen ) {
 610                 LBER_FREE( buf );
 611                 *buf = NULL;
 612                 return LBER_DEFAULT;
 613         }
 614         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 615
 616         *blen = datalen * 8 - unusedbits;
 617         return tag;
 618
 619  fail:
 620         *buf = NULL;
 621         return LBER_DEFAULT;
 622 }
 623
 624 ber_tag_t
 625 ber_get_null( BerElement *ber )
 626 {
 627         ber_len_t       len;
 628         ber_tag_t       tag = ber_skip_tag( ber, &len );
 629
 630         return( len == 0 ? tag : LBER_DEFAULT );
 631 }
 632
 633 ber_tag_t
 634 ber_get_boolean(
 635         BerElement *ber,
 636         ber_int_t *boolval )
 637 {
 638         return ber_get_int( ber, boolval );
 639 }
 640
 641 ber_tag_t
 642 ber_first_element(
 643         BerElement *ber,
 644         ber_len_t *len,
 645         char **last )
 646 {
 647         assert( last != NULL );
 648
 649         /* skip the sequence header, use the len to mark where to stop */
 650         if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) {
 651                 *last = NULL;
 652                 return LBER_DEFAULT;
 653         }
 654
 655         *last = ber->ber_ptr + *len;
 656
 657         if ( *len == 0 ) {
 658                 return LBER_DEFAULT;
 659         }
 660
 661         return ber_peek_tag( ber, len );
 662 }
 663
 664 ber_tag_t
 665 ber_next_element(
 666         BerElement *ber,
 667         ber_len_t *len,
 668         LDAP_CONST char *last )
 669 {
 670         assert( ber != NULL );
 671         assert( last != NULL );
 672         assert( LBER_VALID( ber ) );
 673
 674         if ( ber->ber_ptr >= last ) {
 675                 return LBER_DEFAULT;
 676         }
 677
 678         return ber_peek_tag( ber, len );
 679 }
 680
 681 /* VARARGS */
 682 ber_tag_t
 683 ber_scanf ( BerElement *ber,
 684         LDAP_CONST char *fmt,
 685         ... )
 686 {
 687         va_list         ap;
 688         LDAP_CONST char         *fmt_reset;
 689         char            *s, **ss;
 690         struct berval   **bvp, *bval;
 691         ber_int_t       *i;
 692         ber_len_t       *l;
 693         ber_tag_t       *t;
 694         ber_tag_t       rc;
 695         ber_len_t       len;
 696
 697         va_start( ap, fmt );
 698
 699         assert( ber != NULL );
 700         assert( fmt != NULL );
 701         assert( LBER_VALID( ber ) );
 702
 703         fmt_reset = fmt;
 704
 705         if ( ber->ber_debug & (LDAP_DEBUG_TRACE|LDAP_DEBUG_BER)) {
 706                 ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 707                         "ber_scanf fmt (%s) ber:\n", fmt );
 708                 ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
 709         }
 710
 711         for ( rc = 0; *fmt && rc != LBER_DEFAULT; fmt++ ) {
 712                 /* When this is modified, remember to update
 713                  * the error-cleanup code below accordingly. */
 714                 switch ( *fmt ) {
 715                 case '!': { /* Hook */
 716                                 BERDecodeCallback *f;
 717                                 void *p;
 718
 719                                 f = va_arg( ap, BERDecodeCallback * );
 720                                 p = va_arg( ap, void * );
 721
 722                                 rc = (*f)( ber, p, 0 );
 723                         } break;
 724
 725                 case 'a':       /* octet string - allocate storage as needed */
 726                         ss = va_arg( ap, char ** );
 727                         rc = ber_get_stringa( ber, ss );
 728                         break;
 729
 730                 case 'A':       /* octet string - allocate storage as needed,
 731                                  * but return NULL if len == 0 */
 732                         ss = va_arg( ap, char ** );
 733                         rc = ber_get_stringa_null( ber, ss );
 734                         break;
 735
 736                 case 'b':       /* boolean */
 737                         i = va_arg( ap, ber_int_t * );
 738                         rc = ber_get_boolean( ber, i );
 739                         break;
 740
 741                 case 'B':       /* bit string - allocate storage as needed */
 742                         ss = va_arg( ap, char ** );
 743                         l = va_arg( ap, ber_len_t * ); /* for length, in bits */
 744                         rc = ber_get_bitstringa( ber, ss, l );
 745                         break;
 746
 747                 case 'e':       /* enumerated */
 748                 case 'i':       /* int */
 749                         i = va_arg( ap, ber_int_t * );
 750                         rc = ber_get_int( ber, i );
 751                         break;
 752
 753                 case 'l':       /* length of next item */
 754                         l = va_arg( ap, ber_len_t * );
 755                         rc = ber_peek_tag( ber, l );
 756                         break;
 757
 758                 case 'm':       /* octet string in berval, in-place */
 759                         bval = va_arg( ap, struct berval * );
 760                         rc = ber_get_stringbv( ber, bval, 0 );
 761                         break;
 762
 763                 case 'M':       /* bvoffarray - must include address of
 764                                  * a record len, and record offset.
 765                                  * number of records will be returned thru
 766                                  * len ptr on finish. parsed in-place.
 767                                  */
 768                 {
 769                         bgbvr cookie = { BvOff };
 770                         cookie.ber = ber;
 771                         cookie.res.ba = va_arg( ap, struct berval ** );
 772                         cookie.alloc = 0;
 773                         l = va_arg( ap, ber_len_t * );
 774                         cookie.siz = *l;
 775                         cookie.off = va_arg( ap, ber_len_t );
 776                         rc = ber_get_stringbvl( &cookie, l );
 777                         break;
 778                 }
 779
 780                 case 'n':       /* null */
 781                         rc = ber_get_null( ber );
 782                         break;
 783
 784                 case 'o':       /* octet string in a supplied berval */
 785                         bval = va_arg( ap, struct berval * );
 786                         rc = ber_get_stringbv( ber, bval, LBER_BV_ALLOC );
 787                         break;
 788
 789                 case 'O':       /* octet string - allocate & include length */
 790                         bvp = va_arg( ap, struct berval ** );
 791                         rc = ber_get_stringal( ber, bvp );
 792                         break;
 793
 794                 case 's':       /* octet string - in a buffer */
 795                         s = va_arg( ap, char * );
 796                         l = va_arg( ap, ber_len_t * );
 797                         rc = ber_get_stringb( ber, s, l );
 798                         break;
 799
 800                 case 't':       /* tag of next item */
 801                         t = va_arg( ap, ber_tag_t * );
 802                         *t = rc = ber_peek_tag( ber, &len );
 803                         break;
 804
 805                 case 'T':       /* skip tag of next item */
 806                         t = va_arg( ap, ber_tag_t * );
 807                         *t = rc = ber_skip_tag( ber, &len );
 808                         break;
 809
 810                 case 'v':       /* sequence of strings */
 811                 {
 812                         bgbvr cookie = { ChArray };
 813                         cookie.ber = ber;
 814                         cookie.res.c = va_arg( ap, char *** );
 815                         cookie.alloc = LBER_BV_ALLOC;
 816                         rc = ber_get_stringbvl( &cookie, NULL );
 817                         break;
 818                 }
 819
 820                 case 'V':       /* sequence of strings + lengths */
 821                 {
 822                         bgbvr cookie = { BvVec };
 823                         cookie.ber = ber;
 824                         cookie.res.bv = va_arg( ap, struct berval *** );
 825                         cookie.alloc = LBER_BV_ALLOC;
 826                         rc = ber_get_stringbvl( &cookie, NULL );
 827                         break;
 828                 }
 829
 830                 case 'W':       /* bvarray */
 831                 {
 832                         bgbvr cookie = { BvArray };
 833                         cookie.ber = ber;
 834                         cookie.res.ba = va_arg( ap, struct berval ** );
 835                         cookie.alloc = LBER_BV_ALLOC;
 836                         rc = ber_get_stringbvl( &cookie, NULL );
 837                         break;
 838                 }
 839
 840                 case 'x':       /* skip the next element - whatever it is */
 841                         if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
 842                                 break;
 843                         ber->ber_ptr += len;
 844                         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 845                         break;
 846
 847                 case '{':       /* begin sequence */
 848                 case '[':       /* begin set */
 849                         switch ( fmt[1] ) {
 850                         case 'v': case 'V': case 'W': case 'M':
 851                                 break;
 852                         default:
 853                                 rc = ber_skip_tag( ber, &len );
 854                                 break;
 855                         }
 856                         break;
 857
 858                 case '}':       /* end sequence */
 859                 case ']':       /* end set */
 860                         break;
 861
 862                 default:
 863                         if( ber->ber_debug ) {
 864                                 ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug,
 865                                         "ber_scanf: unknown fmt %c\n", *fmt );
 866                         }
 867                         rc = LBER_DEFAULT;
 868                         break;
 869                 }
 870         }
 871
 872         va_end( ap );
 873
 874         if ( rc == LBER_DEFAULT ) {
 875                 /*
 876                  * Error.  Reclaim malloced memory that was given to the caller.
 877                  * Set allocated pointers to NULL, "data length" outvalues to 0.
 878                  */
 879                 va_start( ap, fmt );
 880
 881                 for ( ; fmt_reset < fmt; fmt_reset++ ) {
 882                 switch ( *fmt_reset ) {
 883                 case '!': { /* Hook */
 884                                 BERDecodeCallback *f;
 885                                 void *p;
 886
 887                                 f = va_arg( ap, BERDecodeCallback * );
 888                                 p = va_arg( ap, void * );
 889
 890                                 (void) (*f)( ber, p, 1 );
 891                         } break;
 892
 893                 case 'a':       /* octet string - allocate storage as needed */
 894                 case 'A':
 895                         ss = va_arg( ap, char ** );
 896                         if ( *ss ) {
 897                                 LBER_FREE( *ss );
 898                                 *ss = NULL;
 899                         }
 900                         break;
 901
 902                 case 'b':       /* boolean */
 903                 case 'e':       /* enumerated */
 904                 case 'i':       /* int */
 905                         (void) va_arg( ap, int * );
 906                         break;
 907
 908                 case 'l':       /* length of next item */
 909                         (void) va_arg( ap, ber_len_t * );
 910                         break;
 911
 912                 case 'o':       /* octet string in a supplied berval */
 913                         bval = va_arg( ap, struct berval * );
 914                         if ( bval->bv_val != NULL ) {
 915                                 LBER_FREE( bval->bv_val );
 916                                 bval->bv_val = NULL;
 917                         }
 918                         bval->bv_len = 0;
 919                         break;
 920
 921                 case 'O':       /* octet string - allocate & include length */
 922                         bvp = va_arg( ap, struct berval ** );
 923                         if ( *bvp ) {
 924                                 ber_bvfree( *bvp );
 925                                 *bvp = NULL;
 926                         }
 927                         break;
 928
 929                 case 's':       /* octet string - in a buffer */
 930                         (void) va_arg( ap, char * );
 931                         (void) va_arg( ap, ber_len_t * );
 932                         break;
 933
 934                 case 't':       /* tag of next item */
 935                 case 'T':       /* skip tag of next item */
 936                         (void) va_arg( ap, ber_tag_t * );
 937                         break;
 938
 939                 case 'B':       /* bit string - allocate storage as needed */
 940                         ss = va_arg( ap, char ** );
 941                         if ( *ss ) {
 942                                 LBER_FREE( *ss );
 943                                 *ss = NULL;
 944                         }
 945                         *(va_arg( ap, ber_len_t * )) = 0; /* for length, in bits */
 946                         break;
 947
 948                 case 'm':       /* berval in-place */
 949                 case 'M':       /* BVoff array in-place */
 950                 case 'n':       /* null */
 951                 case 'v':       /* sequence of strings */
 952                 case 'V':       /* sequence of strings + lengths */
 953                 case 'W':       /* BerVarray */
 954                 case 'x':       /* skip the next element - whatever it is */
 955                 case '{':       /* begin sequence */
 956                 case '[':       /* begin set */
 957                 case '}':       /* end sequence */
 958                 case ']':       /* end set */
 959                         break;
 960
 961                 default:
 962                         /* format should be good */
 963                         assert( 0 );
 964                 }
 965                 }
 966
 967                 va_end( ap );
 968         }
 969
 970         return rc;
 971 }