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