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         const enum bgbvc choice;
 324         const int alloc;        /* choice == BvOff ? 0 : LBER_ALLOC */
 325         ber_len_t siz;          /* input array element size, output count */
 326         ber_len_t off;          /* BvOff offset to the struct berval */
 327         void *result;
 328 } bgbvr;
 329
 330 static ber_tag_t
 331 ber_get_stringbvl( BerElement *ber, bgbvr *b )
 332 {
 333         int i = 0, n;
 334         ber_tag_t tag;
 335         ber_len_t len, tot_size = 0, siz = b->siz;
 336         char *last, *orig;
 337         struct berval bv, *bvp = NULL;
 338         union stringbvl_u {
 339                 char **ca;                              /* ChArray */
 340                 BerVarray ba;                   /* BvArray */
 341                 struct berval **bv;             /* BvVec */
 342                 char *bo;                               /* BvOff */
 343         } res;
 344
 345         /* For rewinding, just like ber_peek_tag() */
 346         orig = ber->ber_ptr;
 347         tag = ber->ber_tag;
 348
 349         if ( ber_first_element( ber, &len, &last ) != LBER_DEFAULT ) {
 350                 for ( ; ber->ber_ptr < last; i++, tot_size += siz ) {
 351                         if ( ber_skip_tag( ber, &len ) == LBER_DEFAULT ) break;
 352                         ber->ber_ptr += len;
 353                         ber->ber_tag = *(unsigned char *) ber->ber_ptr;
 354                 }
 355         }
 356
 357         b->siz = i;
 358         if ( i == 0 ) {
 359                 return 0;
 360         }
 361
 362         /* Allocate and NULL-terminate the result vector */
 363         b->result = ber_memalloc_x( tot_size + siz, ber->ber_memctx );
 364         if ( b->result == NULL ) {
 365                 return LBER_DEFAULT;
 366         }
 367         switch (b->choice) {
 368         case ChArray:
 369                 res.ca = b->result;
 370                 res.ca[i] = NULL;
 371                 break;
 372         case BvArray:
 373                 res.ba = b->result;
 374                 res.ba[i].bv_val = NULL;
 375                 break;
 376         case BvVec:
 377                 res.bv = b->result;
 378                 res.bv[i] = NULL;
 379                 break;
 380         case BvOff:
 381                 res.bo = (char *) b->result + b->off;
 382                 ((struct berval *) (res.bo + tot_size))->bv_val = NULL;
 383                 break;
 384         }
 385         ber->ber_ptr = orig;
 386         ber->ber_tag = tag;
 387         ber_skip_tag( ber, &len );
 388
 389         tot_size = 0;
 390         n = 0;
 391         do {
 392                 tag = ber_next_element( ber, &len, last );
 393                 if ( ber_get_stringbv( ber, &bv, b->alloc ) == LBER_DEFAULT ) {
 394                         goto nomem;
 395                 }
 396
 397                 /* store my result */
 398                 switch (b->choice) {
 399                 case ChArray:
 400                         res.ca[n] = bv.bv_val;
 401                         break;
 402                 case BvArray:
 403                         res.ba[n] = bv;
 404                         break;
 405                 case BvVec:
 406                         bvp = ber_memalloc_x( sizeof( struct berval ),
 407                                 ber->ber_memctx );
 408                         if ( !bvp ) {
 409                                 ber_memfree_x( bv.bv_val, ber->ber_memctx );
 410                                 goto nomem;
 411                         }
 412                         res.bv[n] = bvp;
 413                         *bvp = bv;
 414                         break;
 415                 case BvOff:
 416                         *(struct berval *)(res.bo + tot_size) = bv;
 417                         tot_size += siz;
 418                         break;
 419                 }
 420         } while (++n < i);
 421         return tag;
 422
 423 nomem:
 424         if (b->choice != BvOff) {       /* BvOff does not have b->alloc set */
 425                 while (--n >= 0) {
 426                         switch(b->choice) {
 427                         case ChArray:
 428                                 ber_memfree_x(res.ca[n], ber->ber_memctx);
 429                                 break;
 430                         case BvArray:
 431                                 ber_memfree_x(res.ba[n].bv_val, ber->ber_memctx);
 432                                 break;
 433                         case BvVec:
 434                                 ber_memfree_x(res.bv[n]->bv_val, ber->ber_memctx);
 435                                 ber_memfree_x(res.bv[n], ber->ber_memctx);
 436                                 break;
 437                         default:
 438                                 break;
 439                         }
 440                 }
 441         }
 442         ber_memfree_x(b->result, ber->ber_memctx);
 443         b->result = NULL;
 444         return LBER_DEFAULT;
 445 }
 446
 447 ber_tag_t
 448 ber_get_stringbv( BerElement *ber, struct berval *bv, int option )
 449 {
 450         ber_tag_t       tag;
 451
 452         assert( bv != NULL );
 453
 454         tag = ber_skip_tag( ber, &bv->bv_len );
 455         if ( tag == LBER_DEFAULT ) {
 456                 bv->bv_val = NULL;
 457                 return tag;
 458         }
 459
 460         if ( option & LBER_BV_ALLOC ) {
 461                 bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1,
 462                         ber->ber_memctx );
 463                 if ( bv->bv_val == NULL ) {
 464                         return LBER_DEFAULT;
 465                 }
 466
 467                 if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val,
 468                         bv->bv_len ) != bv->bv_len )
 469                 {
 470                         ber_memfree_x( bv->bv_val, ber->ber_memctx );
 471                         bv->bv_val = NULL;
 472                         return LBER_DEFAULT;
 473                 }
 474         } else {
 475                 bv->bv_val = ber->ber_ptr;
 476                 ber->ber_ptr += bv->bv_len;
 477         }
 478         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 479         if ( !( option & LBER_BV_NOTERM ))
 480                 bv->bv_val[bv->bv_len] = '\0';
 481
 482         return tag;
 483 }
 484
 485 ber_tag_t
 486 ber_get_stringbv_null( BerElement *ber, struct berval *bv, int option )
 487 {
 488         ber_tag_t       tag;
 489
 490         assert( bv != NULL );
 491
 492         tag = ber_skip_tag( ber, &bv->bv_len );
 493         if ( tag == LBER_DEFAULT || bv->bv_len == 0 ) {
 494                 bv->bv_val = NULL;
 495                 return tag;
 496         }
 497
 498         if ( option & LBER_BV_ALLOC ) {
 499                 bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1,
 500                         ber->ber_memctx );
 501                 if ( bv->bv_val == NULL ) {
 502                         return LBER_DEFAULT;
 503                 }
 504
 505                 if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val,
 506                         bv->bv_len ) != bv->bv_len )
 507                 {
 508                         ber_memfree_x( bv->bv_val, ber->ber_memctx );
 509                         bv->bv_val = NULL;
 510                         return LBER_DEFAULT;
 511                 }
 512         } else {
 513                 bv->bv_val = ber->ber_ptr;
 514                 ber->ber_ptr += bv->bv_len;
 515         }
 516         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 517         if ( !( option & LBER_BV_NOTERM ))
 518                 bv->bv_val[bv->bv_len] = '\0';
 519
 520         return tag;
 521 }
 522
 523 ber_tag_t
 524 ber_get_stringa( BerElement *ber, char **buf )
 525 {
 526         BerValue        bv;
 527         ber_tag_t       tag;
 528
 529         assert( buf != NULL );
 530
 531         tag = ber_get_stringbv( ber, &bv, LBER_BV_ALLOC );
 532         *buf = bv.bv_val;
 533
 534         return tag;
 535 }
 536
 537 ber_tag_t
 538 ber_get_stringa_null( BerElement *ber, char **buf )
 539 {
 540         BerValue        bv;
 541         ber_tag_t       tag;
 542
 543         assert( buf != NULL );
 544
 545         tag = ber_get_stringbv_null( ber, &bv, LBER_BV_ALLOC );
 546         *buf = bv.bv_val;
 547
 548         return tag;
 549 }
 550
 551 ber_tag_t
 552 ber_get_stringal( BerElement *ber, struct berval **bv )
 553 {
 554         ber_tag_t       tag;
 555
 556         assert( ber != NULL );
 557         assert( bv != NULL );
 558
 559         *bv = (struct berval *) ber_memalloc_x( sizeof(struct berval),
 560                 ber->ber_memctx );
 561         if ( *bv == NULL ) {
 562                 return LBER_DEFAULT;
 563         }
 564
 565         tag = ber_get_stringbv( ber, *bv, LBER_BV_ALLOC );
 566         if ( tag == LBER_DEFAULT ) {
 567                 ber_memfree_x( *bv, ber->ber_memctx );
 568                 *bv = NULL;
 569         }
 570         return tag;
 571 }
 572
 573 ber_tag_t
 574 ber_get_bitstringa(
 575         BerElement *ber,
 576         char **buf,
 577         ber_len_t *blen )
 578 {
 579         ber_len_t       datalen;
 580         ber_tag_t       tag;
 581         unsigned char   unusedbits;
 582
 583         assert( buf != NULL );
 584         assert( blen != NULL );
 585
 586         if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) {
 587                 goto fail;
 588         }
 589
 590         if ( --datalen > (ber_len_t)-1 / 8 ) {
 591                 goto fail;
 592         }
 593         if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) {
 594                 goto fail;
 595         }
 596         if ( unusedbits > 7 ) {
 597                 goto fail;
 598         }
 599
 600         *buf = (char *) ber_memalloc_x( datalen, ber->ber_memctx );
 601         if ( *buf == NULL ) {
 602                 return LBER_DEFAULT;
 603         }
 604
 605         if ( (ber_len_t) ber_read( ber, *buf, datalen ) != datalen ) {
 606                 ber_memfree_x( buf, ber->ber_memctx );
 607                 *buf = NULL;
 608                 return LBER_DEFAULT;
 609         }
 610         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 611
 612         *blen = datalen * 8 - unusedbits;
 613         return tag;
 614
 615  fail:
 616         *buf = NULL;
 617         return LBER_DEFAULT;
 618 }
 619
 620 ber_tag_t
 621 ber_get_null( BerElement *ber )
 622 {
 623         ber_len_t       len;
 624         ber_tag_t       tag = ber_skip_tag( ber, &len );
 625
 626         return( len == 0 ? tag : LBER_DEFAULT );
 627 }
 628
 629 ber_tag_t
 630 ber_get_boolean(
 631         BerElement *ber,
 632         ber_int_t *boolval )
 633 {
 634         return ber_get_int( ber, boolval );
 635 }
 636
 637 ber_tag_t
 638 ber_first_element(
 639         BerElement *ber,
 640         ber_len_t *len,
 641         char **last )
 642 {
 643         assert( last != NULL );
 644
 645         /* skip the sequence header, use the len to mark where to stop */
 646         if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) {
 647                 *last = NULL;
 648                 return LBER_DEFAULT;
 649         }
 650
 651         *last = ber->ber_ptr + *len;
 652
 653         if ( *len == 0 ) {
 654                 return LBER_DEFAULT;
 655         }
 656
 657         return ber_peek_tag( ber, len );
 658 }
 659
 660 ber_tag_t
 661 ber_next_element(
 662         BerElement *ber,
 663         ber_len_t *len,
 664         LDAP_CONST char *last )
 665 {
 666         assert( ber != NULL );
 667         assert( last != NULL );
 668         assert( LBER_VALID( ber ) );
 669
 670         if ( ber->ber_ptr >= last ) {
 671                 return LBER_DEFAULT;
 672         }
 673
 674         return ber_peek_tag( ber, len );
 675 }
 676
 677 /* VARARGS */
 678 ber_tag_t
 679 ber_scanf ( BerElement *ber,
 680         LDAP_CONST char *fmt,
 681         ... )
 682 {
 683         va_list         ap;
 684         LDAP_CONST char         *fmt_reset;
 685         char            *s, **ss, ***sss;
 686         struct berval   *bval, **bvp, ***bvpp;
 687         ber_int_t       *i;
 688         ber_len_t       *l;
 689         ber_tag_t       *t;
 690         ber_tag_t       rc;
 691         ber_len_t       len;
 692
 693         va_start( ap, fmt );
 694
 695         assert( ber != NULL );
 696         assert( fmt != NULL );
 697         assert( LBER_VALID( ber ) );
 698
 699         fmt_reset = fmt;
 700
 701         if ( ber->ber_debug & (LDAP_DEBUG_TRACE|LDAP_DEBUG_BER)) {
 702                 ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 703                         "ber_scanf fmt (%s) ber:\n", fmt );
 704                 ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
 705         }
 706
 707         for ( rc = 0; *fmt && rc != LBER_DEFAULT; fmt++ ) {
 708                 /* When this is modified, remember to update
 709                  * the error-cleanup code below accordingly. */
 710                 switch ( *fmt ) {
 711                 case '!': { /* Hook */
 712                                 BERDecodeCallback *f;
 713                                 void *p;
 714
 715                                 f = va_arg( ap, BERDecodeCallback * );
 716                                 p = va_arg( ap, void * );
 717
 718                                 rc = (*f)( ber, p, 0 );
 719                         } break;
 720
 721                 case 'a':       /* octet string - allocate storage as needed */
 722                         ss = va_arg( ap, char ** );
 723                         rc = ber_get_stringa( ber, ss );
 724                         break;
 725
 726                 case 'A':       /* octet string - allocate storage as needed,
 727                                  * but return NULL if len == 0 */
 728                         ss = va_arg( ap, char ** );
 729                         rc = ber_get_stringa_null( ber, ss );
 730                         break;
 731
 732                 case 'b':       /* boolean */
 733                         i = va_arg( ap, ber_int_t * );
 734                         rc = ber_get_boolean( ber, i );
 735                         break;
 736
 737                 case 'B':       /* bit string - allocate storage as needed */
 738                         ss = va_arg( ap, char ** );
 739                         l = va_arg( ap, ber_len_t * ); /* for length, in bits */
 740                         rc = ber_get_bitstringa( ber, ss, l );
 741                         break;
 742
 743                 case 'e':       /* enumerated */
 744                 case 'i':       /* integer */
 745                         i = va_arg( ap, ber_int_t * );
 746                         rc = ber_get_int( ber, i );
 747                         break;
 748
 749                 case 'l':       /* length of next item */
 750                         l = va_arg( ap, ber_len_t * );
 751                         rc = ber_peek_tag( ber, l );
 752                         break;
 753
 754                 case 'm':       /* octet string in berval, in-place */
 755                         bval = va_arg( ap, struct berval * );
 756                         rc = ber_get_stringbv( ber, bval, 0 );
 757                         break;
 758
 759                 case 'M':       /* bvoffarray - must include address of
 760                                  * a record len, and record offset.
 761                                  * number of records will be returned thru
 762                                  * len ptr on finish. parsed in-place.
 763                                  */
 764                 {
 765                         bgbvr cookie = { BvOff, 0 };
 766                         bvp = va_arg( ap, struct berval ** );
 767                         l = va_arg( ap, ber_len_t * );
 768                         cookie.siz = *l;
 769                         cookie.off = va_arg( ap, ber_len_t );
 770                         rc = ber_get_stringbvl( ber, &cookie );
 771                         *bvp = cookie.result;
 772                         *l = cookie.siz;
 773                         break;
 774                 }
 775
 776                 case 'n':       /* null */
 777                         rc = ber_get_null( ber );
 778                         break;
 779
 780                 case 'o':       /* octet string in a supplied berval */
 781                         bval = va_arg( ap, struct berval * );
 782                         rc = ber_get_stringbv( ber, bval, LBER_BV_ALLOC );
 783                         break;
 784
 785                 case 'O':       /* octet string - allocate & include length */
 786                         bvp = va_arg( ap, struct berval ** );
 787                         rc = ber_get_stringal( ber, bvp );
 788                         break;
 789
 790                 case 's':       /* octet string - in a buffer */
 791                         s = va_arg( ap, char * );
 792                         l = va_arg( ap, ber_len_t * );
 793                         rc = ber_get_stringb( ber, s, l );
 794                         break;
 795
 796                 case 't':       /* tag of next item */
 797                         t = va_arg( ap, ber_tag_t * );
 798                         *t = rc = ber_peek_tag( ber, &len );
 799                         break;
 800
 801                 case 'T':       /* skip tag of next item */
 802                         t = va_arg( ap, ber_tag_t * );
 803                         *t = rc = ber_skip_tag( ber, &len );
 804                         break;
 805
 806                 case 'v':       /* sequence of strings */
 807                 {
 808                         bgbvr cookie = {
 809                                 ChArray, LBER_BV_ALLOC, sizeof( char * )
 810                         };
 811                         rc = ber_get_stringbvl( ber, &cookie );
 812                         *(va_arg( ap, char *** )) = cookie.result;
 813                         break;
 814                 }
 815
 816                 case 'V':       /* sequence of strings + lengths */
 817                 {
 818                         bgbvr cookie = {
 819                                 BvVec, LBER_BV_ALLOC, sizeof( struct berval * )
 820                         };
 821                         rc = ber_get_stringbvl( ber, &cookie );
 822                         *(va_arg( ap, struct berval *** )) = cookie.result;
 823                         break;
 824                 }
 825
 826                 case 'W':       /* bvarray */
 827                 {
 828                         bgbvr cookie = {
 829                                 BvArray, LBER_BV_ALLOC, sizeof( struct berval )
 830                         };
 831                         rc = ber_get_stringbvl( ber, &cookie );
 832                         *(va_arg( ap, struct berval ** )) = cookie.result;
 833                         break;
 834                 }
 835
 836                 case 'x':       /* skip the next element - whatever it is */
 837                         if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
 838                                 break;
 839                         ber->ber_ptr += len;
 840                         ber->ber_tag = *(unsigned char *)ber->ber_ptr;
 841                         break;
 842
 843                 case '{':       /* begin sequence */
 844                 case '[':       /* begin set */
 845                         switch ( fmt[1] ) {
 846                         case 'v': case 'V': case 'W': case 'M':
 847                                 break;
 848                         default:
 849                                 rc = ber_skip_tag( ber, &len );
 850                                 break;
 851                         }
 852                         break;
 853
 854                 case '}':       /* end sequence */
 855                 case ']':       /* end set */
 856                         break;
 857
 858                 default:
 859                         if( ber->ber_debug ) {
 860                                 ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug,
 861                                         "ber_scanf: unknown fmt %c\n", *fmt );
 862                         }
 863                         rc = LBER_DEFAULT;
 864                         break;
 865                 }
 866         }
 867
 868         va_end( ap );
 869
 870         if ( rc == LBER_DEFAULT ) {
 871                 /*
 872                  * Error.  Reclaim malloced memory that was given to the caller.
 873                  * Set allocated pointers to NULL, "data length" outvalues to 0.
 874                  */
 875                 va_start( ap, fmt );
 876
 877                 for ( ; fmt_reset < fmt; fmt_reset++ ) {
 878                 switch ( *fmt_reset ) {
 879                 case '!': { /* Hook */
 880                                 BERDecodeCallback *f;
 881                                 void *p;
 882
 883                                 f = va_arg( ap, BERDecodeCallback * );
 884                                 p = va_arg( ap, void * );
 885
 886                                 (void) (*f)( ber, p, 1 );
 887                         } break;
 888
 889                 case 'a':       /* octet string - allocate storage as needed */
 890                 case 'A':
 891                         ss = va_arg( ap, char ** );
 892                         ber_memfree_x( *ss, ber->ber_memctx );
 893                         *ss = NULL;
 894                         break;
 895
 896                 case 'b':       /* boolean */
 897                 case 'e':       /* enumerated */
 898                 case 'i':       /* integer */
 899                         (void) va_arg( ap, ber_int_t * );
 900                         break;
 901
 902                 case 'l':       /* length of next item */
 903                         *(va_arg( ap, ber_len_t * )) = 0;
 904                         break;
 905
 906                 case 'm':       /* berval in-place */
 907                         bval = va_arg( ap, struct berval * );
 908                         BER_BVZERO( bval );
 909                         break;
 910
 911                 case 'M':       /* BVoff array in-place */
 912                         bvp = va_arg( ap, struct berval ** );
 913                         ber_memfree_x( *bvp, ber->ber_memctx );
 914                         *bvp = NULL;
 915                         *(va_arg( ap, ber_len_t * )) = 0;
 916                         (void) va_arg( ap, ber_len_t );
 917                         break;
 918
 919                 case 'o':       /* octet string in a supplied berval */
 920                         bval = va_arg( ap, struct berval * );
 921                         ber_memfree_x( bval->bv_val, ber->ber_memctx );
 922                         BER_BVZERO( bval );
 923                         break;
 924
 925                 case 'O':       /* octet string - allocate & include length */
 926                         bvp = va_arg( ap, struct berval ** );
 927                         ber_bvfree_x( *bvp, ber->ber_memctx );
 928                         *bvp = NULL;
 929                         break;
 930
 931                 case 's':       /* octet string - in a buffer */
 932                         (void) va_arg( ap, char * );
 933                         *(va_arg( ap, ber_len_t * )) = 0;
 934                         break;
 935
 936                 case 't':       /* tag of next item */
 937                 case 'T':       /* skip tag of next item */
 938                         (void) va_arg( ap, ber_tag_t * );
 939                         break;
 940
 941                 case 'B':       /* bit string - allocate storage as needed */
 942                         ss = va_arg( ap, char ** );
 943                         ber_memfree_x( *ss, ber->ber_memctx );
 944                         *ss = NULL;
 945                         *(va_arg( ap, ber_len_t * )) = 0; /* for length, in bits */
 946                         break;
 947
 948                 case 'v':       /* sequence of strings */
 949                         sss = va_arg( ap, char *** );
 950                         ber_memvfree_x( (void **) *sss, ber->ber_memctx );
 951                         *sss = NULL;
 952                         break;
 953
 954                 case 'V':       /* sequence of strings + lengths */
 955                         bvpp = va_arg( ap, struct berval *** );
 956                         ber_bvecfree_x( *bvpp, ber->ber_memctx );
 957                         *bvpp = NULL;
 958                         break;
 959
 960                 case 'W':       /* BerVarray */
 961                         bvp = va_arg( ap, struct berval ** );
 962                         ber_bvarray_free_x( *bvp, ber->ber_memctx );
 963                         *bvp = NULL;
 964                         break;
 965
 966                 case 'n':       /* null */
 967                 case 'x':       /* skip the next element - whatever it is */
 968                 case '{':       /* begin sequence */
 969                 case '[':       /* begin set */
 970                 case '}':       /* end sequence */
 971                 case ']':       /* end set */
 972                         break;
 973
 974                 default:
 975                         /* format should be good */
 976                         assert( 0 );
 977                 }
 978                 }
 979
 980                 va_end( ap );
 981         }
 982
 983         return rc;
 984 }