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