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

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