libraries/liblber/decode.c - diff

Return to decode.c CVS log

Up to [OpenLDAP] / libraries / liblber

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

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) + nb->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)+nb->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 */

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