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

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