Diff for /libraries/liblber/decode.c between versions 1.105.2.9 and 1.119

version 1.105.2.9, 2009/10/31 00:13:00 version 1.119, 2009/07/29 19:47:54
Line 1 Line 1
 /* decode.c - ber input decoding routines */  /* decode.c - ber input decoding routines */
 /* $OpenLDAP$ */  /* $OpenLDAP: pkg/ldap/libraries/liblber/decode.c,v 1.118 2009/07/29 13:06:28 hallvard Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 1998-2009 The OpenLDAP Foundation.   * Copyright 1998-2009 The OpenLDAP Foundation.
Line 86  ber_decode_oid( BerValue *in, BerValue * Line 86  ber_decode_oid( BerValue *in, BerValue *
         return 0;          return 0;
 }  }
   
 /* Return tag, with *bv = rest of element (starting at length octets) */  /* return the tag - LBER_DEFAULT returned means trouble */
 static ber_tag_t  ber_tag_t
 ber_tag_and_rest( const BerElement *ber, struct berval *bv )  ber_get_tag( BerElement *ber )
 {  {
           unsigned char   xbyte;
         ber_tag_t       tag;          ber_tag_t       tag;
         ptrdiff_t       rest;  
         unsigned char   *ptr;  
   
         assert( ber != NULL );          assert( ber != NULL );
         assert( LBER_VALID( ber ) );          assert( LBER_VALID( ber ) );
   
         ptr = (unsigned char *) ber->ber_ptr;          if ( ber_pvt_ber_remaining( ber ) < 1 ) {
         rest = (unsigned char *) ber->ber_end - ptr;                  return LBER_DEFAULT;
         if ( rest <= 0 ) {  
                 goto fail;  
         }          }
   
         tag = ber->ber_tag;          if ( ber->ber_ptr == ber->ber_buf ) {
         if ( (char *) ptr == ber->ber_buf ) {                  tag = *(unsigned char *)ber->ber_ptr;
                 tag = *ptr;          } else {
                   tag = ber->ber_tag;
         }          }
         ptr++;          ber->ber_ptr++;
         rest--;  
         if ( (tag & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK ) {          if ( (tag & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK ) {
                 goto done;                  return tag;
         }          }
   
         do {          do {
                 if ( rest <= 0 ) {                  if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) {
                         break;                          break;
                 }                  }
   
                 tag <<= 8;                  tag <<= 8;
                 tag |= *ptr++ & 0xffU;                  tag |= 0x00ffUL & (ber_tag_t) xbyte;
                 rest--;  
   
                 if ( ! (tag & LBER_MORE_TAG_MASK) ) {                  if ( ! (xbyte & LBER_MORE_TAG_MASK) ) {
                         goto done;                          return tag;
                 }                  }
         } while ( tag <= (ber_tag_t)-1 / 256 );          } while ( tag <= (ber_tag_t)-1 / 256 );
   
  fail:          return LBER_DEFAULT;            /* error or tag too big */
         /* Error or unsupported tag size */  
         tag = LBER_DEFAULT;  
   
  done:  
         bv->bv_len = rest;  
         bv->bv_val = (char *) ptr;  
         return tag;  
 }  
   
 /* Return the tag - LBER_DEFAULT returned means trouble */  
 ber_tag_t  
 ber_get_tag( BerElement *ber )  
 {  
         struct berval bv;  
         ber_tag_t tag = ber_tag_and_rest( ber, &bv );  
   
         ber->ber_ptr = bv.bv_val;  
         return tag;  
 }  }
   
 /* Return next element's tag and point *bv at its contents in-place */  
 ber_tag_t  ber_tag_t
 ber_peek_element( const BerElement *ber, struct berval *bv )  ber_skip_tag( BerElement *ber, ber_len_t *lenp )
 {  {
         ber_tag_t       tag;          ber_tag_t       tag;
         ber_len_t       len, rest;          ber_len_t       len;
         unsigned        i;          unsigned        i, noctets;
         unsigned char *ptr;          unsigned char   lc;
           unsigned char netlen[sizeof(ber_len_t)];
   
         assert( bv != NULL );          assert( lenp != NULL );
   
         /*          /*
          * Any ber element looks like this: tag length contents.           * Any ber element looks like this: tag length contents.
          * Assuming everything's ok, we return the tag, and point           * Assuming everything's ok, we return the tag byte (we
          * bv at the contents.           * can assume a single byte), and return the length in lenp.
          *           *
          * Assumptions:           * Assumptions:
          *      1) definite lengths           *      1) definite lengths
          *      2) primitive encodings used whenever possible           *      2) primitive encodings used whenever possible
          */           */
   
         len = 0;          *lenp = 0;
   
         /*          /*
          * First, we read the tag.           * First, we read the tag.
          */           */
         tag = ber_tag_and_rest( ber, bv );  
   
         rest = bv->bv_len;          if ( (tag = ber_get_tag( ber )) == LBER_DEFAULT ) {
         ptr = (unsigned char *) bv->bv_val;                  return LBER_DEFAULT;
         if ( tag == LBER_DEFAULT || rest == 0 ) {  
                 goto fail;  
         }          }
   
         /*          /*
Line 189  ber_peek_element( const BerElement *ber, Line 166  ber_peek_element( const BerElement *ber,
          * Lengths that do not fit in a ber_len_t are not accepted.           * Lengths that do not fit in a ber_len_t are not accepted.
          */           */
   
         len = *ptr++;          if ( ber_read( ber, (char *) &lc, 1 ) != 1 ) {
         rest--;                  return LBER_DEFAULT;
           }
   
           len = lc;
           if ( lc & 0x80U ) {
                   noctets = (lc & 0x7fU);
   
                   if ( noctets - 1U > sizeof(ber_len_t) - 1U ) {
                           /* Indefinite-length or too long length */
                           return LBER_DEFAULT;
                   }
   
         if ( len & 0x80U ) {                  if( (unsigned) ber_read( ber, (char *) netlen, noctets ) != noctets ) {
                 len &= 0x7fU;                          return LBER_DEFAULT;
                 if ( len - 1U > sizeof(ber_len_t) - 1U || rest < len ) {  
                         /* Indefinite-length/too long length/not enough data */  
                         goto fail;  
                 }                  }
   
                 rest -= len;                  len = netlen[0];
                 i = len;                  for( i = 1; i < noctets; i++ ) {
                 for( len = *ptr++ & 0xffU; --i; len |= *ptr++ & 0xffU ) {  
                         len <<= 8;                          len <<= 8;
                           len |= netlen[i];
                 }                  }
         }  
   
         /* BER element should have enough data left */  
         if( len > rest ) {  
         fail:  
                 tag = LBER_DEFAULT;  
         }          }
           *lenp = len;
   
         bv->bv_len = len;          /* BER element should have enough data left */
         bv->bv_val = (char *) ptr;          if( len > (ber_len_t) ber_pvt_ber_remaining( ber ) ) {
         return tag;                  return LBER_DEFAULT;
 }  
   
 /* Move past next element, point *bv at it in-place, and return its tag.  
  * The caller may \0-terminate *bv, as next octet is saved in ber->ber_tag.  
  * Similar to ber_get_stringbv(ber, bv, LBER_BV_NOTERM) except on error.  
  */  
 ber_tag_t  
 ber_skip_element( BerElement *ber, struct berval *bv )  
 {  
         ber_tag_t tag = ber_peek_element( ber, bv );  
   
         if ( tag != LBER_DEFAULT ) {  
                 ber->ber_ptr = bv->bv_val + bv->bv_len;  
                 ber->ber_tag = *(unsigned char *) ber->ber_ptr;  
         }          }
           ber->ber_tag = *(unsigned char *)ber->ber_ptr;
   
         return tag;          return tag;
 }  }
Line 239  ber_peek_tag( Line 206  ber_peek_tag(
         BerElement *ber,          BerElement *ber,
         ber_len_t *len )          ber_len_t *len )
 {  {
         struct berval bv;          /*
         ber_tag_t tag = ber_peek_element( ber, &bv );           * This implementation assumes ber_skip_tag() only
            * modifies ber_ptr field of the BerElement.
            */
   
         *len = bv.bv_len;          char *save;
         return tag;          ber_tag_t       tag, old;
 }  
   
 ber_tag_t          old = ber->ber_tag;
 ber_skip_tag( BerElement *ber, ber_len_t *lenp )          save = ber->ber_ptr;
 {          tag = ber_skip_tag( ber, len );
         struct berval bv;          ber->ber_ptr = save;
         ber_tag_t tag = ber_peek_element( ber, &bv );          ber->ber_tag = old;
   
         ber->ber_ptr = bv.bv_val;  
         ber->ber_tag = *(unsigned char *) ber->ber_ptr;  
   
         *lenp = bv.bv_len;  
         return tag;          return tag;
 }  }
   
Line 266  ber_get_int( Line 230  ber_get_int(
 {  {
         ber_tag_t       tag;          ber_tag_t       tag;
         ber_len_t       len;          ber_len_t       len;
         struct berval bv;          unsigned char buf[sizeof(ber_int_t)];
   
         assert( num != NULL );          assert( num != NULL );
   
         tag = ber_skip_element( ber, &bv );          if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) {
         len = bv.bv_len;                  return LBER_DEFAULT;
         if ( tag == LBER_DEFAULT || len > sizeof(ber_int_t) ) {          }
   
           if ( len > sizeof(ber_int_t) ) {
                   return LBER_DEFAULT;
           }
   
           /* read into the low-order bytes of our buffer */
           if ( (ber_len_t) ber_read( ber, (char *) buf, len ) != len ) {
                 return LBER_DEFAULT;                  return LBER_DEFAULT;
         }          }
   
         /* parse two's complement integer */          /* parse two's complement integer */
         if( len ) {          if( len ) {
                 unsigned char *buf = (unsigned char *) bv.bv_val;  
                 ber_len_t i;                  ber_len_t i;
                 ber_int_t netnum = buf[0] & 0xff;                  ber_int_t netnum = buf[0] & 0xff;
   
                 /* sign extend */                  /* sign extend */
                 netnum = (netnum ^ 0x80) - 0x80;                  netnum -= (netnum & 0x80) << 1;
   
                 /* shift in the bytes */                  /* shift in the bytes */
                 for( i = 1; i < len; i++ ) {                  for( i = 1; i < len; i++ ) {
Line 296  ber_get_int( Line 266  ber_get_int(
                 *num = 0;                  *num = 0;
         }          }
   
           ber->ber_tag = *(unsigned char *)ber->ber_ptr;
   
         return tag;          return tag;
 }  }
   
Line 313  ber_get_stringb( Line 285  ber_get_stringb(
         char *buf,          char *buf,
         ber_len_t *len )          ber_len_t *len )
 {  {
         struct berval bv;          ber_len_t       datalen;
         ber_tag_t       tag;          ber_tag_t       tag;
   
         if ( (tag = ber_skip_element( ber, &bv )) == LBER_DEFAULT ) {          if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) {
                 return LBER_DEFAULT;                  return LBER_DEFAULT;
         }          }
   
         /* must fit within allocated space with termination */          /* must fit within allocated space with termination */
         if ( bv.bv_len >= *len ) {          if ( datalen >= *len ) {
                   return LBER_DEFAULT;
           }
   
           if ( (ber_len_t) ber_read( ber, buf, datalen ) != datalen ) {
                 return LBER_DEFAULT;                  return LBER_DEFAULT;
         }          }
           ber->ber_tag = *(unsigned char *)ber->ber_ptr;
   
         memcpy( buf, bv.bv_val, bv.bv_len );          buf[datalen] = '\0';
         buf[bv.bv_len] = '\0';  
   
         *len = bv.bv_len;          *len = datalen;
         return tag;          return tag;
 }  }
   
Line 344  enum bgbvc { ChArray, BvArray, BvVec, Bv Line 320  enum bgbvc { ChArray, BvArray, BvVec, Bv
  * stack use to the absolute minimum.   * stack use to the absolute minimum.
  */   */
 typedef struct bgbvr {  typedef struct bgbvr {
         const enum bgbvc choice;          enum bgbvc choice;
         const int option;       /* (ALLOC unless BvOff) | (STRING if ChArray) */          BerElement *ber;
         ber_len_t siz;          /* input array element size, output count */          int alloc;
         ber_len_t off;          /* BvOff offset to the struct berval */          ber_len_t siz;
         void *result;          ber_len_t off;
           union {
                   char ***c;
                   BerVarray *ba;
                   struct berval ***bv;
           } res;
 } bgbvr;  } bgbvr;
   
 static ber_tag_t  static ber_tag_t
 ber_get_stringbvl( BerElement *ber, bgbvr *b )  ber_get_stringbvl( bgbvr *b, ber_len_t *rlen )
 {  {
         int i = 0, n;          int i = 0, n;
         ber_tag_t tag;          ber_tag_t tag;
         ber_len_t tot_size = 0, siz = b->siz;          ber_len_t len;
         char *last, *orig;          char *last, *orig;
         struct berval bv, *bvp = NULL;          struct berval bv, *bvp = NULL;
         union stringbvl_u {  
                 char **ca;                              /* ChArray */  
                 BerVarray ba;                   /* BvArray */  
                 struct berval **bv;             /* BvVec */  
                 char *bo;                               /* BvOff */  
         } res;  
   
         tag = ber_skip_tag( ber, &bv.bv_len );  
   
         if ( tag != LBER_DEFAULT ) {          /* For rewinding, just like ber_peek_tag() */
                 tag = 0;          orig = b->ber->ber_ptr;
                 orig = ber->ber_ptr;          tag = b->ber->ber_tag;
                 last = orig + bv.bv_len;  
   
                 for ( ; ber->ber_ptr < last; i++, tot_size += siz ) {          if ( ber_first_element( b->ber, &len, &last ) != LBER_DEFAULT ) {
                         if ( ber_skip_element( ber, &bv ) == LBER_DEFAULT )                  for ( ; b->ber->ber_ptr < last; i++ ) {
                                 break;                          if (ber_skip_tag( b->ber, &len ) == LBER_DEFAULT) break;
                 }                          b->ber->ber_ptr += len;
                 if ( ber->ber_ptr != last ) {                          b->ber->ber_tag = *(unsigned char *)b->ber->ber_ptr;
                         i = 0;  
                         tag = LBER_DEFAULT;  
                 }                  }
   
                 ber->ber_ptr = orig;  
                 ber->ber_tag = *(unsigned char *) orig;  
         }          }
   
         b->siz = i;          if ( rlen ) *rlen = i;
   
         if ( i == 0 ) {          if ( i == 0 ) {
                 return tag;                  *b->res.c = NULL;
                   return 0;
         }          }
   
         /* Allocate and NULL-terminate the result vector */          n = i;
         b->result = ber_memalloc_x( tot_size + siz, ber->ber_memctx );  
         if ( b->result == NULL ) {          /* Allocate the result vector */
                 return LBER_DEFAULT;  
         }  
         switch (b->choice) {          switch (b->choice) {
         case ChArray:          case ChArray:
                 res.ca = b->result;                  *b->res.c = ber_memalloc_x( (n+1)*sizeof( char * ),
                 res.ca[i] = NULL;                          b->ber->ber_memctx);
                   if ( *b->res.c == NULL ) return LBER_DEFAULT;
                   (*b->res.c)[n] = NULL;
                 break;                  break;
         case BvArray:          case BvArray:
                 res.ba = b->result;                  *b->res.ba = ber_memalloc_x( (n+1)*sizeof( struct berval ),
                 res.ba[i].bv_val = NULL;                          b->ber->ber_memctx);
                   if ( *b->res.ba == NULL ) return LBER_DEFAULT;
                   (*b->res.ba)[n].bv_val = NULL;
                 break;                  break;
         case BvVec:          case BvVec:
                 res.bv = b->result;                  *b->res.bv = ber_memalloc_x( (n+1)*sizeof( struct berval *),
                 res.bv[i] = NULL;                          b->ber->ber_memctx);
                   if ( *b->res.bv == NULL ) return LBER_DEFAULT;
                   (*b->res.bv)[n] = NULL;
                 break;                  break;
         case BvOff:          case BvOff:
                 res.bo = (char *) b->result + b->off;                  *b->res.ba = ber_memalloc_x( (n+1) * b->siz, b->ber->ber_memctx );
                 ((struct berval *) (res.bo + tot_size))->bv_val = NULL;                  if ( *b->res.ba == NULL ) return LBER_DEFAULT;
                 tot_size = 0;                  ((struct berval *)((char *)(*b->res.ba) + n*b->siz +
                           b->off))->bv_val = NULL;
                 break;                  break;
         }          }
           b->ber->ber_ptr = orig;
         n = 0;          b->ber->ber_tag = tag;
         do {          ber_skip_tag( b->ber, &len );
                 tag = ber_get_stringbv( ber, &bv, b->option );          
                 if ( tag == LBER_DEFAULT ) {          for (n=0; n<i; n++)
                         goto failed;          {
                   tag = ber_next_element( b->ber, &len, last );
                   if ( ber_get_stringbv( b->ber, &bv, b->alloc ) == LBER_DEFAULT ) {
                           goto nomem;
                 }                  }
   
                 /* store my result */                  /* store my result */
                 switch (b->choice) {                  switch (b->choice) {
                 case ChArray:                  case ChArray:
                         res.ca[n] = bv.bv_val;                          (*b->res.c)[n] = bv.bv_val;
                         break;                          break;
                 case BvArray:                  case BvArray:
                         res.ba[n] = bv;                          (*b->res.ba)[n] = bv;
                         break;                          break;
                 case BvVec:                  case BvVec:
                         bvp = ber_memalloc_x( sizeof( struct berval ),                          bvp = ber_memalloc_x( sizeof( struct berval ), b->ber->ber_memctx);
                                 ber->ber_memctx );  
                         if ( !bvp ) {                          if ( !bvp ) {
                                 ber_memfree_x( bv.bv_val, ber->ber_memctx );                                  LBER_FREE(bv.bv_val);
                                 goto failed;                                  goto nomem;
                         }                          }
                         res.bv[n] = bvp;                          (*b->res.bv)[n] = bvp;
                         *bvp = bv;                          *bvp = bv;
                         break;                          break;
                 case BvOff:                  case BvOff:
                         *(struct berval *)(res.bo + tot_size) = bv;                          *(BerVarray)((char *)(*b->res.ba)+n*b->siz+b->off) = bv;
                         tot_size += siz;  
                         break;                          break;
                 }                  }
         } while (++n < i);          }
         return tag;          return tag;
   
 failed:  nomem:
         if (b->choice != BvOff) { /* BvOff does not have LBER_BV_ALLOC set */          if (b->alloc || b->choice == BvVec) {
                 while (--n >= 0) {                  for (--n; n>=0; n--) {
                         switch(b->choice) {                          switch(b->choice) {
                         case ChArray:                          case ChArray:
                                 ber_memfree_x(res.ca[n], ber->ber_memctx);                                  LBER_FREE((*b->res.c)[n]);
                                 break;                                  break;
                         case BvArray:                          case BvArray:
                                 ber_memfree_x(res.ba[n].bv_val, ber->ber_memctx);                                  LBER_FREE((*b->res.ba)[n].bv_val);
                                 break;                                  break;
                         case BvVec:                          case BvVec:
                                 ber_memfree_x(res.bv[n]->bv_val, ber->ber_memctx);                                  LBER_FREE((*b->res.bv)[n]->bv_val);
                                 ber_memfree_x(res.bv[n], ber->ber_memctx);                                  LBER_FREE((*b->res.bv)[n]);
                                 break;                                  break;
                         default:                          default:
                                 break;                                  break;
                         }                          }
                 }                  }
         }          }
         ber_memfree_x(b->result, ber->ber_memctx);          LBER_FREE(*b->res.c);
         b->result = NULL;          *b->res.c = NULL;
         return LBER_DEFAULT;          return LBER_DEFAULT;
 }  }
   
Line 477  ber_tag_t Line 452  ber_tag_t
 ber_get_stringbv( BerElement *ber, struct berval *bv, int option )  ber_get_stringbv( BerElement *ber, struct berval *bv, int option )
 {  {
         ber_tag_t       tag;          ber_tag_t       tag;
         char            *data;  
   
         tag = ber_skip_element( ber, bv );          assert( bv != NULL );
         if ( tag == LBER_DEFAULT ||  
                 (( option & LBER_BV_STRING ) && memchr( bv->bv_val, 0, bv->bv_len )))          tag = ber_skip_tag( ber, &bv->bv_len );
         {          if ( tag == LBER_DEFAULT ) {
                 bv->bv_val = NULL;                  bv->bv_val = NULL;
                 return LBER_DEFAULT;                  return tag;
         }          }
   
         data = bv->bv_val;  
         if ( option & LBER_BV_ALLOC ) {          if ( option & LBER_BV_ALLOC ) {
                 bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1,                  bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1,
                         ber->ber_memctx );                          ber->ber_memctx );
Line 495  ber_get_stringbv( BerElement *ber, struc Line 468  ber_get_stringbv( BerElement *ber, struc
                         return LBER_DEFAULT;                          return LBER_DEFAULT;
                 }                  }
   
                 if ( bv->bv_len != 0 ) {                  if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val,
                         memcpy( bv->bv_val, data, bv->bv_len );                          bv->bv_len ) != bv->bv_len )
                   {
                           LBER_FREE( bv->bv_val );
                           bv->bv_val = NULL;
                           return LBER_DEFAULT;
                 }                  }
                 data = bv->bv_val;          } else {
                   bv->bv_val = ber->ber_ptr;
                   ber->ber_ptr += bv->bv_len;
         }          }
           ber->ber_tag = *(unsigned char *)ber->ber_ptr;
         if ( !( option & LBER_BV_NOTERM ))          if ( !( option & LBER_BV_NOTERM ))
                 data[bv->bv_len] = '\0';                  bv->bv_val[bv->bv_len] = '\0';
   
         return tag;          return tag;
 }  }
Line 510  ber_tag_t Line 490  ber_tag_t
 ber_get_stringbv_null( BerElement *ber, struct berval *bv, int option )  ber_get_stringbv_null( BerElement *ber, struct berval *bv, int option )
 {  {
         ber_tag_t       tag;          ber_tag_t       tag;
         char            *data;  
   
         tag = ber_skip_element( ber, bv );          assert( bv != NULL );
   
           tag = ber_skip_tag( ber, &bv->bv_len );
         if ( tag == LBER_DEFAULT || bv->bv_len == 0 ) {          if ( tag == LBER_DEFAULT || bv->bv_len == 0 ) {
                 bv->bv_val = NULL;                  bv->bv_val = NULL;
                 return tag;                  return tag;
         }          }
   
         if (( option & LBER_BV_STRING ) && memchr( bv->bv_val, 0, bv->bv_len )) {  
                 bv->bv_val = NULL;  
                 return LBER_DEFAULT;  
         }  
   
         data = bv->bv_val;  
         if ( option & LBER_BV_ALLOC ) {          if ( option & LBER_BV_ALLOC ) {
                 bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1,                  bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1,
                         ber->ber_memctx );                          ber->ber_memctx );
Line 531  ber_get_stringbv_null( BerElement *ber, Line 506  ber_get_stringbv_null( BerElement *ber,
                         return LBER_DEFAULT;                          return LBER_DEFAULT;
                 }                  }
   
                 memcpy( bv->bv_val, data, bv->bv_len );                  if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val,
                 data = bv->bv_val;                          bv->bv_len ) != bv->bv_len )
                   {
                           LBER_FREE( bv->bv_val );
                           bv->bv_val = NULL;
                           return LBER_DEFAULT;
                   }
           } else {
                   bv->bv_val = ber->ber_ptr;
                   ber->ber_ptr += bv->bv_len;
         }          }
           ber->ber_tag = *(unsigned char *)ber->ber_ptr;
         if ( !( option & LBER_BV_NOTERM ))          if ( !( option & LBER_BV_NOTERM ))
                 data[bv->bv_len] = '\0';                  bv->bv_val[bv->bv_len] = '\0';
   
         return tag;          return tag;
 }  }
Line 548  ber_get_stringa( BerElement *ber, char * Line 532  ber_get_stringa( BerElement *ber, char *
   
         assert( buf != NULL );          assert( buf != NULL );
   
         tag = ber_get_stringbv( ber, &bv, LBER_BV_ALLOC | LBER_BV_STRING );          tag = ber_get_stringbv( ber, &bv, LBER_BV_ALLOC );
         *buf = bv.bv_val;          *buf = bv.bv_val;
   
         return tag;          return tag;
Line 562  ber_get_stringa_null( BerElement *ber, c Line 546  ber_get_stringa_null( BerElement *ber, c
   
         assert( buf != NULL );          assert( buf != NULL );
   
         tag = ber_get_stringbv_null( ber, &bv, LBER_BV_ALLOC | LBER_BV_STRING );          tag = ber_get_stringbv_null( ber, &bv, LBER_BV_ALLOC );
         *buf = bv.bv_val;          *buf = bv.bv_val;
   
         return tag;          return tag;
Line 584  ber_get_stringal( BerElement *ber, struc Line 568  ber_get_stringal( BerElement *ber, struc
   
         tag = ber_get_stringbv( ber, *bv, LBER_BV_ALLOC );          tag = ber_get_stringbv( ber, *bv, LBER_BV_ALLOC );
         if ( tag == LBER_DEFAULT ) {          if ( tag == LBER_DEFAULT ) {
                 ber_memfree_x( *bv, ber->ber_memctx );                  LBER_FREE( *bv );
                 *bv = NULL;                  *bv = NULL;
         }          }
         return tag;          return tag;
Line 596  ber_get_bitstringa( Line 580  ber_get_bitstringa(
         char **buf,          char **buf,
         ber_len_t *blen )          ber_len_t *blen )
 {  {
           ber_len_t       datalen;
         ber_tag_t       tag;          ber_tag_t       tag;
         struct berval   data;  
         unsigned char   unusedbits;          unsigned char   unusedbits;
   
         assert( buf != NULL );          assert( buf != NULL );
         assert( blen != NULL );          assert( blen != NULL );
   
         if ( (tag = ber_skip_element( ber, &data )) == LBER_DEFAULT ) {          if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) {
                 goto fail;                  goto fail;
         }          }
   
         if ( --data.bv_len > (ber_len_t)-1 / 8 ) {          if ( --datalen > (ber_len_t)-1 / 8 ) {
                 goto fail;                  goto fail;
         }          }
         unusedbits = *(unsigned char *) data.bv_val++;          if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) {
         if ( unusedbits > 7 ) {  
                 goto fail;                  goto fail;
         }          }
           if ( unusedbits > 7 ) {
         if ( memchr( data.bv_val, 0, data.bv_len )) {  
                 goto fail;                  goto fail;
         }          }
   
         *buf = (char *) ber_memalloc_x( data.bv_len, ber->ber_memctx );          *buf = (char *) ber_memalloc_x( datalen, ber->ber_memctx );
         if ( *buf == NULL ) {          if ( *buf == NULL ) {
                 return LBER_DEFAULT;                  return LBER_DEFAULT;
         }          }
         memcpy( *buf, data.bv_val, data.bv_len );  
   
         *blen = data.bv_len * 8 - unusedbits;          if ( (ber_len_t) ber_read( ber, *buf, datalen ) != datalen ) {
                   LBER_FREE( buf );
                   *buf = NULL;
                   return LBER_DEFAULT;
           }
           ber->ber_tag = *(unsigned char *)ber->ber_ptr;
   
           *blen = datalen * 8 - unusedbits;
         return tag;          return tag;
   
  fail:   fail:
Line 698  ber_scanf ( BerElement *ber, Line 686  ber_scanf ( BerElement *ber,
 {  {
         va_list         ap;          va_list         ap;
         LDAP_CONST char         *fmt_reset;          LDAP_CONST char         *fmt_reset;
         char            *s, **ss, ***sss;          char            *s, **ss;
         struct berval   data, *bval, **bvp, ***bvpp;          struct berval   **bvp, *bval;
         ber_int_t       *i;          ber_int_t       *i;
         ber_len_t       *l;          ber_len_t       *l;
         ber_tag_t       *t;          ber_tag_t       *t;
Line 757  ber_scanf ( BerElement *ber, Line 745  ber_scanf ( BerElement *ber,
                         break;                          break;
   
                 case 'e':       /* enumerated */                  case 'e':       /* enumerated */
                 case 'i':       /* integer */                  case 'i':       /* int */
                         i = va_arg( ap, ber_int_t * );                          i = va_arg( ap, ber_int_t * );
                         rc = ber_get_int( ber, i );                          rc = ber_get_int( ber, i );
                         break;                          break;
Line 778  ber_scanf ( BerElement *ber, Line 766  ber_scanf ( BerElement *ber,
                                  * len ptr on finish. parsed in-place.                                   * len ptr on finish. parsed in-place.
                                  */                                   */
                 {                  {
                         bgbvr cookie = { BvOff, 0 };                          bgbvr cookie = { BvOff };
                         bvp = va_arg( ap, struct berval ** );                          cookie.ber = ber;
                           cookie.res.ba = va_arg( ap, struct berval ** );
                           cookie.alloc = 0;
                         l = va_arg( ap, ber_len_t * );                          l = va_arg( ap, ber_len_t * );
                         cookie.siz = *l;                          cookie.siz = *l;
                         cookie.off = va_arg( ap, ber_len_t );                          cookie.off = va_arg( ap, ber_len_t );
                         rc = ber_get_stringbvl( ber, &cookie );                          rc = ber_get_stringbvl( &cookie, l );
                         *bvp = cookie.result;  
                         *l = cookie.siz;  
                         break;                          break;
                 }                  }
   
Line 821  ber_scanf ( BerElement *ber, Line 809  ber_scanf ( BerElement *ber,
   
                 case 'v':       /* sequence of strings */                  case 'v':       /* sequence of strings */
                 {                  {
                         bgbvr cookie = {                          bgbvr cookie = { ChArray };
                                 ChArray, LBER_BV_ALLOC | LBER_BV_STRING, sizeof( char * )                          cookie.ber = ber;
                         };                          cookie.res.c = va_arg( ap, char *** );
                         rc = ber_get_stringbvl( ber, &cookie );                          cookie.alloc = LBER_BV_ALLOC;
                         *(va_arg( ap, char *** )) = cookie.result;                          rc = ber_get_stringbvl( &cookie, NULL );
                         break;                          break;
                 }                  }
   
                 case 'V':       /* sequence of strings + lengths */                  case 'V':       /* sequence of strings + lengths */
                 {                  {
                         bgbvr cookie = {                          bgbvr cookie = { BvVec };
                                 BvVec, LBER_BV_ALLOC, sizeof( struct berval * )                          cookie.ber = ber;
                         };                          cookie.res.bv = va_arg( ap, struct berval *** );
                         rc = ber_get_stringbvl( ber, &cookie );                          cookie.alloc = LBER_BV_ALLOC;
                         *(va_arg( ap, struct berval *** )) = cookie.result;                          rc = ber_get_stringbvl( &cookie, NULL );
                         break;                          break;
                 }                  }
   
                 case 'W':       /* bvarray */                  case 'W':       /* bvarray */
                 {                  {
                         bgbvr cookie = {                          bgbvr cookie = { BvArray };
                                 BvArray, LBER_BV_ALLOC, sizeof( struct berval )                          cookie.ber = ber;
                         };                          cookie.res.ba = va_arg( ap, struct berval ** );
                         rc = ber_get_stringbvl( ber, &cookie );                          cookie.alloc = LBER_BV_ALLOC;
                         *(va_arg( ap, struct berval ** )) = cookie.result;                          rc = ber_get_stringbvl( &cookie, NULL );
                         break;                          break;
                 }                  }
   
                 case 'x':       /* skip the next element - whatever it is */                  case 'x':       /* skip the next element - whatever it is */
                         rc = ber_skip_element( ber, &data );                          if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
                                   break;
                           ber->ber_ptr += len;
                           ber->ber_tag = *(unsigned char *)ber->ber_ptr;
                         break;                          break;
   
                 case '{':       /* begin sequence */                  case '{':       /* begin sequence */
Line 902  ber_scanf ( BerElement *ber, Line 893  ber_scanf ( BerElement *ber,
                 case 'a':       /* octet string - allocate storage as needed */                  case 'a':       /* octet string - allocate storage as needed */
                 case 'A':                  case 'A':
                         ss = va_arg( ap, char ** );                          ss = va_arg( ap, char ** );
                         ber_memfree_x( *ss, ber->ber_memctx );                          if ( *ss ) {
                         *ss = NULL;                                  LBER_FREE( *ss );
                                   *ss = NULL;
                           }
                         break;                          break;
   
                 case 'b':       /* boolean */                  case 'b':       /* boolean */
                 case 'e':       /* enumerated */                  case 'e':       /* enumerated */
                 case 'i':       /* integer */                  case 'i':       /* int */
                         (void) va_arg( ap, ber_int_t * );                          (void) va_arg( ap, int * );
                         break;                          break;
   
                 case 'l':       /* length of next item */                  case 'l':       /* length of next item */
                         *(va_arg( ap, ber_len_t * )) = 0;                          (void) va_arg( ap, ber_len_t * );
                         break;  
   
                 case 'm':       /* berval in-place */  
                         bval = va_arg( ap, struct berval * );  
                         BER_BVZERO( bval );  
                         break;  
   
                 case 'M':       /* BVoff array in-place */  
                         bvp = va_arg( ap, struct berval ** );  
                         ber_memfree_x( *bvp, ber->ber_memctx );  
                         *bvp = NULL;  
                         *(va_arg( ap, ber_len_t * )) = 0;  
                         (void) va_arg( ap, ber_len_t );  
                         break;                          break;
   
                 case 'o':       /* octet string in a supplied berval */                  case 'o':       /* octet string in a supplied berval */
                         bval = va_arg( ap, struct berval * );                          bval = va_arg( ap, struct berval * );
                         ber_memfree_x( bval->bv_val, ber->ber_memctx );                          if ( bval->bv_val != NULL ) {
                         BER_BVZERO( bval );                                  LBER_FREE( bval->bv_val );
                                   bval->bv_val = NULL;
                           }
                           bval->bv_len = 0;
                         break;                          break;
   
                 case 'O':       /* octet string - allocate & include length */                  case 'O':       /* octet string - allocate & include length */
                         bvp = va_arg( ap, struct berval ** );                          bvp = va_arg( ap, struct berval ** );
                         ber_bvfree_x( *bvp, ber->ber_memctx );                          if ( *bvp ) {
                         *bvp = NULL;                                  ber_bvfree( *bvp );
                                   *bvp = NULL;
                           }
                         break;                          break;
   
                 case 's':       /* octet string - in a buffer */                  case 's':       /* octet string - in a buffer */
                         (void) va_arg( ap, char * );                          (void) va_arg( ap, char * );
                         *(va_arg( ap, ber_len_t * )) = 0;                          (void) va_arg( ap, ber_len_t * );
                         break;                          break;
   
                 case 't':       /* tag of next item */                  case 't':       /* tag of next item */
Line 953  ber_scanf ( BerElement *ber, Line 938  ber_scanf ( BerElement *ber,
   
                 case 'B':       /* bit string - allocate storage as needed */                  case 'B':       /* bit string - allocate storage as needed */
                         ss = va_arg( ap, char ** );                          ss = va_arg( ap, char ** );
                         ber_memfree_x( *ss, ber->ber_memctx );                          if ( *ss ) {
                         *ss = NULL;                                  LBER_FREE( *ss );
                                   *ss = NULL;
                           }
                         *(va_arg( ap, ber_len_t * )) = 0; /* for length, in bits */                          *(va_arg( ap, ber_len_t * )) = 0; /* for length, in bits */
                         break;                          break;
   
                   case 'm':       /* berval in-place */
                   case 'M':       /* BVoff array in-place */
                   case 'n':       /* null */
                 case 'v':       /* sequence of strings */                  case 'v':       /* sequence of strings */
                         sss = va_arg( ap, char *** );  
                         ber_memvfree_x( (void **) *sss, ber->ber_memctx );  
                         *sss = NULL;  
                         break;  
   
                 case 'V':       /* sequence of strings + lengths */                  case 'V':       /* sequence of strings + lengths */
                         bvpp = va_arg( ap, struct berval *** );  
                         ber_bvecfree_x( *bvpp, ber->ber_memctx );  
                         *bvpp = NULL;  
                         break;  
   
                 case 'W':       /* BerVarray */                  case 'W':       /* BerVarray */
                         bvp = va_arg( ap, struct berval ** );  
                         ber_bvarray_free_x( *bvp, ber->ber_memctx );  
                         *bvp = NULL;  
                         break;  
   
                 case 'n':       /* null */  
                 case 'x':       /* skip the next element - whatever it is */                  case 'x':       /* skip the next element - whatever it is */
                 case '{':       /* begin sequence */                  case '{':       /* begin sequence */
                 case '[':       /* begin set */                  case '[':       /* begin set */

Removed from v.1.105.2.9  
changed lines
  Added in v.1.119


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org