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