version 1.119, 2009/07/29 19:47:54
|
version 1.124, 2009/08/07 14:04:25
|
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.123 2009/08/04 19:11:38 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 320 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 { |
enum bgbvc choice; |
const enum bgbvc choice; |
BerElement *ber; |
const int alloc; /* choice == BvOff ? 0 : LBER_ALLOC */ |
int alloc; |
ber_len_t siz; /* input array element size, output count */ |
ber_len_t siz; |
ber_len_t off; /* BvOff offset to the struct berval */ |
ber_len_t off; |
void *result; |
union { |
|
char ***c; |
|
BerVarray *ba; |
|
struct berval ***bv; |
|
} res; |
|
} bgbvr; |
} bgbvr; |
|
|
static ber_tag_t |
static ber_tag_t |
ber_get_stringbvl( bgbvr *b, ber_len_t *rlen ) |
ber_get_stringbvl( BerElement *ber, bgbvr *b ) |
{ |
{ |
int i = 0, n; |
int i = 0, n; |
ber_tag_t tag; |
ber_tag_t tag; |
ber_len_t len; |
ber_len_t len, tot_size = 0, siz = b->siz; |
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; |
|
|
/* For rewinding, just like ber_peek_tag() */ |
/* For rewinding, just like ber_peek_tag() */ |
orig = b->ber->ber_ptr; |
orig = ber->ber_ptr; |
tag = b->ber->ber_tag; |
tag = ber->ber_tag; |
|
|
if ( ber_first_element( b->ber, &len, &last ) != LBER_DEFAULT ) { |
if ( ber_first_element( ber, &len, &last ) != LBER_DEFAULT ) { |
for ( ; b->ber->ber_ptr < last; i++ ) { |
for ( ; ber->ber_ptr < last; i++, tot_size += siz ) { |
if (ber_skip_tag( b->ber, &len ) == LBER_DEFAULT) break; |
if ( ber_skip_tag( ber, &len ) == LBER_DEFAULT ) break; |
b->ber->ber_ptr += len; |
ber->ber_ptr += len; |
b->ber->ber_tag = *(unsigned char *)b->ber->ber_ptr; |
ber->ber_tag = *(unsigned char *) ber->ber_ptr; |
} |
} |
} |
} |
|
|
if ( rlen ) *rlen = i; |
b->siz = i; |
|
|
if ( i == 0 ) { |
if ( i == 0 ) { |
*b->res.c = NULL; |
|
return 0; |
return 0; |
} |
} |
|
|
n = i; |
/* Allocate and NULL-terminate the result vector */ |
|
b->result = ber_memalloc_x( tot_size + siz, ber->ber_memctx ); |
/* Allocate the result vector */ |
if ( b->result == NULL ) { |
|
return LBER_DEFAULT; |
|
} |
switch (b->choice) { |
switch (b->choice) { |
case ChArray: |
case ChArray: |
*b->res.c = ber_memalloc_x( (n+1)*sizeof( char * ), |
res.ca = b->result; |
b->ber->ber_memctx); |
res.ca[i] = NULL; |
if ( *b->res.c == NULL ) return LBER_DEFAULT; |
|
(*b->res.c)[n] = NULL; |
|
break; |
break; |
case BvArray: |
case BvArray: |
*b->res.ba = ber_memalloc_x( (n+1)*sizeof( struct berval ), |
res.ba = b->result; |
b->ber->ber_memctx); |
res.ba[i].bv_val = NULL; |
if ( *b->res.ba == NULL ) return LBER_DEFAULT; |
|
(*b->res.ba)[n].bv_val = NULL; |
|
break; |
break; |
case BvVec: |
case BvVec: |
*b->res.bv = ber_memalloc_x( (n+1)*sizeof( struct berval *), |
res.bv = b->result; |
b->ber->ber_memctx); |
res.bv[i] = NULL; |
if ( *b->res.bv == NULL ) return LBER_DEFAULT; |
|
(*b->res.bv)[n] = NULL; |
|
break; |
break; |
case BvOff: |
case BvOff: |
*b->res.ba = ber_memalloc_x( (n+1) * b->siz, b->ber->ber_memctx ); |
res.bo = (char *) b->result + b->off; |
if ( *b->res.ba == NULL ) return LBER_DEFAULT; |
((struct berval *) (res.bo + tot_size))->bv_val = NULL; |
((struct berval *)((char *)(*b->res.ba) + n*b->siz + |
|
b->off))->bv_val = NULL; |
|
break; |
break; |
} |
} |
b->ber->ber_ptr = orig; |
ber->ber_ptr = orig; |
b->ber->ber_tag = tag; |
ber->ber_tag = tag; |
ber_skip_tag( b->ber, &len ); |
ber_skip_tag( ber, &len ); |
|
|
for (n=0; n<i; n++) |
tot_size = 0; |
{ |
n = 0; |
tag = ber_next_element( b->ber, &len, last ); |
do { |
if ( ber_get_stringbv( b->ber, &bv, b->alloc ) == LBER_DEFAULT ) { |
tag = ber_next_element( ber, &len, last ); |
|
if ( ber_get_stringbv( ber, &bv, b->alloc ) == LBER_DEFAULT ) { |
goto nomem; |
goto nomem; |
} |
} |
|
|
/* store my result */ |
/* store my result */ |
switch (b->choice) { |
switch (b->choice) { |
case ChArray: |
case ChArray: |
(*b->res.c)[n] = bv.bv_val; |
res.ca[n] = bv.bv_val; |
break; |
break; |
case BvArray: |
case BvArray: |
(*b->res.ba)[n] = bv; |
res.ba[n] = bv; |
break; |
break; |
case BvVec: |
case BvVec: |
bvp = ber_memalloc_x( sizeof( struct berval ), b->ber->ber_memctx); |
bvp = ber_memalloc_x( sizeof( struct berval ), |
|
ber->ber_memctx ); |
if ( !bvp ) { |
if ( !bvp ) { |
LBER_FREE(bv.bv_val); |
ber_memfree_x( bv.bv_val, ber->ber_memctx ); |
goto nomem; |
goto nomem; |
} |
} |
(*b->res.bv)[n] = bvp; |
res.bv[n] = bvp; |
*bvp = bv; |
*bvp = bv; |
break; |
break; |
case BvOff: |
case BvOff: |
*(BerVarray)((char *)(*b->res.ba)+n*b->siz+b->off) = bv; |
*(struct berval *)(res.bo + tot_size) = bv; |
|
tot_size += siz; |
break; |
break; |
} |
} |
} |
} while (++n < i); |
return tag; |
return tag; |
|
|
nomem: |
nomem: |
if (b->alloc || b->choice == BvVec) { |
if (b->choice != BvOff) { /* BvOff does not have b->alloc set */ |
for (--n; n>=0; n--) { |
while (--n >= 0) { |
switch(b->choice) { |
switch(b->choice) { |
case ChArray: |
case ChArray: |
LBER_FREE((*b->res.c)[n]); |
ber_memfree_x(res.ca[n], ber->ber_memctx); |
break; |
break; |
case BvArray: |
case BvArray: |
LBER_FREE((*b->res.ba)[n].bv_val); |
ber_memfree_x(res.ba[n].bv_val, ber->ber_memctx); |
break; |
break; |
case BvVec: |
case BvVec: |
LBER_FREE((*b->res.bv)[n]->bv_val); |
ber_memfree_x(res.bv[n]->bv_val, ber->ber_memctx); |
LBER_FREE((*b->res.bv)[n]); |
ber_memfree_x(res.bv[n], ber->ber_memctx); |
break; |
break; |
default: |
default: |
break; |
break; |
} |
} |
} |
} |
} |
} |
LBER_FREE(*b->res.c); |
ber_memfree_x(b->result, ber->ber_memctx); |
*b->res.c = NULL; |
b->result = NULL; |
return LBER_DEFAULT; |
return LBER_DEFAULT; |
} |
} |
|
|
Line 471 ber_get_stringbv( BerElement *ber, struc
|
Line 467 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 505 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 564 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 603 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 682 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 741 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 766 ber_scanf ( BerElement *ber,
|
Line 762 ber_scanf ( BerElement *ber,
|
* len ptr on finish. parsed in-place. |
* len ptr on finish. parsed in-place. |
*/ |
*/ |
{ |
{ |
bgbvr cookie = { BvOff }; |
bgbvr cookie = { BvOff, 0 }; |
cookie.ber = ber; |
bvp = va_arg( ap, struct berval ** ); |
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( &cookie, l ); |
rc = ber_get_stringbvl( ber, &cookie ); |
|
*bvp = cookie.result; |
|
*l = cookie.siz; |
break; |
break; |
} |
} |
|
|
Line 809 ber_scanf ( BerElement *ber,
|
Line 805 ber_scanf ( BerElement *ber,
|
|
|
case 'v': /* sequence of strings */ |
case 'v': /* sequence of strings */ |
{ |
{ |
bgbvr cookie = { ChArray }; |
bgbvr cookie = { |
cookie.ber = ber; |
ChArray, LBER_BV_ALLOC, sizeof( char * ) |
cookie.res.c = va_arg( ap, char *** ); |
}; |
cookie.alloc = LBER_BV_ALLOC; |
rc = ber_get_stringbvl( ber, &cookie ); |
rc = ber_get_stringbvl( &cookie, NULL ); |
*(va_arg( ap, char *** )) = cookie.result; |
break; |
break; |
} |
} |
|
|
case 'V': /* sequence of strings + lengths */ |
case 'V': /* sequence of strings + lengths */ |
{ |
{ |
bgbvr cookie = { BvVec }; |
bgbvr cookie = { |
cookie.ber = ber; |
BvVec, LBER_BV_ALLOC, sizeof( struct berval * ) |
cookie.res.bv = va_arg( ap, struct berval *** ); |
}; |
cookie.alloc = LBER_BV_ALLOC; |
rc = ber_get_stringbvl( ber, &cookie ); |
rc = ber_get_stringbvl( &cookie, NULL ); |
*(va_arg( ap, struct berval *** )) = cookie.result; |
break; |
break; |
} |
} |
|
|
case 'W': /* bvarray */ |
case 'W': /* bvarray */ |
{ |
{ |
bgbvr cookie = { BvArray }; |
bgbvr cookie = { |
cookie.ber = ber; |
BvArray, LBER_BV_ALLOC, sizeof( struct berval ) |
cookie.res.ba = va_arg( ap, struct berval ** ); |
}; |
cookie.alloc = LBER_BV_ALLOC; |
rc = ber_get_stringbvl( ber, &cookie ); |
rc = ber_get_stringbvl( &cookie, NULL ); |
*(va_arg( ap, struct berval ** )) = cookie.result; |
break; |
break; |
} |
} |
|
|
Line 893 ber_scanf ( BerElement *ber,
|
Line 889 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 940 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 */ |