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

version 1.119, 2009/07/29 19:47:54 version 1.122, 2009/07/29 21:03:10
Line 1 Line 1
 /* decode.c - ber input decoding routines */  /* decode.c - ber input decoding routines */
 /* $OpenLDAP: pkg/ldap/libraries/liblber/decode.c,v 1.118 2009/07/29 13:06:28 hallvard Exp $ */  /* $OpenLDAP: pkg/ldap/libraries/liblber/decode.c,v 1.121 2009/07/29 20:38:19 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 411  ber_get_stringbvl( bgbvr *b, ber_len_t * Line 411  ber_get_stringbvl( bgbvr *b, ber_len_t *
                 case BvVec:                  case BvVec:
                         bvp = ber_memalloc_x( sizeof( struct berval ), b->ber->ber_memctx);                          bvp = ber_memalloc_x( sizeof( struct berval ), b->ber->ber_memctx);
                         if ( !bvp ) {                          if ( !bvp ) {
                                 LBER_FREE(bv.bv_val);                                  ber_memfree_x( bv.bv_val, b->ber->ber_memctx );
                                 goto nomem;                                  goto nomem;
                         }                          }
                         (*b->res.bv)[n] = bvp;                          (*b->res.bv)[n] = bvp;
Line 429  nomem: Line 429  nomem:
                 for (--n; n>=0; n--) {                  for (--n; n>=0; n--) {
                         switch(b->choice) {                          switch(b->choice) {
                         case ChArray:                          case ChArray:
                                 LBER_FREE((*b->res.c)[n]);                                  ber_memfree_x((*b->res.c)[n], b->ber->ber_memctx);
                                 break;                                  break;
                         case BvArray:                          case BvArray:
                                 LBER_FREE((*b->res.ba)[n].bv_val);                                  ber_memfree_x((*b->res.ba)[n].bv_val, b->ber->ber_memctx);
                                 break;                                  break;
                         case BvVec:                          case BvVec:
                                 LBER_FREE((*b->res.bv)[n]->bv_val);                                  ber_memfree_x((*b->res.bv)[n]->bv_val, b->ber->ber_memctx);
                                 LBER_FREE((*b->res.bv)[n]);                                  ber_memfree_x((*b->res.bv)[n], b->ber->ber_memctx);
                                 break;                                  break;
                         default:                          default:
                                 break;                                  break;
                         }                          }
                 }                  }
         }          }
         LBER_FREE(*b->res.c);          ber_memfree_x(*b->res.c, b->ber->ber_memctx);
         *b->res.c = NULL;          *b->res.c = NULL;
         return LBER_DEFAULT;          return LBER_DEFAULT;
 }  }
Line 471  ber_get_stringbv( BerElement *ber, struc Line 471  ber_get_stringbv( BerElement *ber, struc
                 if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val,                  if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val,
                         bv->bv_len ) != bv->bv_len )                          bv->bv_len ) != bv->bv_len )
                 {                  {
                         LBER_FREE( bv->bv_val );                          ber_memfree_x( bv->bv_val, ber->ber_memctx );
                         bv->bv_val = NULL;                          bv->bv_val = NULL;
                         return LBER_DEFAULT;                          return LBER_DEFAULT;
                 }                  }
Line 509  ber_get_stringbv_null( BerElement *ber, Line 509  ber_get_stringbv_null( BerElement *ber,
                 if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val,                  if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val,
                         bv->bv_len ) != bv->bv_len )                          bv->bv_len ) != bv->bv_len )
                 {                  {
                         LBER_FREE( bv->bv_val );                          ber_memfree_x( bv->bv_val, ber->ber_memctx );
                         bv->bv_val = NULL;                          bv->bv_val = NULL;
                         return LBER_DEFAULT;                          return LBER_DEFAULT;
                 }                  }
Line 568  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 ) {
                 LBER_FREE( *bv );                  ber_memfree_x( *bv, ber->ber_memctx );
                 *bv = NULL;                  *bv = NULL;
         }          }
         return tag;          return tag;
Line 607  ber_get_bitstringa( Line 607  ber_get_bitstringa(
         }          }
   
         if ( (ber_len_t) ber_read( ber, *buf, datalen ) != datalen ) {          if ( (ber_len_t) ber_read( ber, *buf, datalen ) != datalen ) {
                 LBER_FREE( buf );                  ber_memfree_x( buf, ber->ber_memctx );
                 *buf = NULL;                  *buf = NULL;
                 return LBER_DEFAULT;                  return LBER_DEFAULT;
         }          }
Line 686  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;          char            *s, **ss, ***sss;
         struct berval   **bvp, *bval;          struct berval   *bval, **bvp, ***bvpp;
         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 745  ber_scanf ( BerElement *ber, Line 745  ber_scanf ( BerElement *ber,
                         break;                          break;
   
                 case 'e':       /* enumerated */                  case 'e':       /* enumerated */
                 case 'i':       /* int */                  case 'i':       /* integer */
                         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 893  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 ** );
                         if ( *ss ) {                          ber_memfree_x( *ss, ber->ber_memctx );
                                 LBER_FREE( *ss );                          *ss = NULL;
                                 *ss = NULL;  
                         }  
                         break;                          break;
   
                 case 'b':       /* boolean */                  case 'b':       /* boolean */
                 case 'e':       /* enumerated */                  case 'e':       /* enumerated */
                 case 'i':       /* int */                  case 'i':       /* integer */
                         (void) va_arg( ap, int * );                          (void) va_arg( ap, ber_int_t * );
                         break;                          break;
   
                 case 'l':       /* length of next item */                  case 'l':       /* length of next item */
                         (void) va_arg( ap, ber_len_t * );                          *(va_arg( ap, ber_len_t * )) = 0;
                           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 * );
                         if ( bval->bv_val != NULL ) {                          ber_memfree_x( bval->bv_val, ber->ber_memctx );
                                 LBER_FREE( bval->bv_val );                          BER_BVZERO( bval );
                                 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 ** );
                         if ( *bvp ) {                          ber_bvfree_x( *bvp, ber->ber_memctx );
                                 ber_bvfree( *bvp );                          *bvp = NULL;
                                 *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 * );
                         (void) va_arg( ap, ber_len_t * );                          *(va_arg( ap, ber_len_t * )) = 0;
                         break;                          break;
   
                 case 't':       /* tag of next item */                  case 't':       /* tag of next item */
Line 938  ber_scanf ( BerElement *ber, Line 944  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 ** );
                         if ( *ss ) {                          ber_memfree_x( *ss, ber->ber_memctx );
                                 LBER_FREE( *ss );                          *ss = NULL;
                                 *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.119  
changed lines
  Added in v.1.122


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