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.33 and 1.33.2.1

version 1.33, 1999/06/03 16:24:23	version 1.33.2.1, 1999/06/17 17:09:52
Line 30	Line 30

#include "lber-int.h"	#include "lber-int.h"

static int ber_getnint LDAP_P(( BerElement ber, long num, int len ));	static ber_tag_t ber_getnint LDAP_P((
	BerElement *ber,
	ber_int_t *num,
	ber_len_t len ));

/* return the tag - LBER_DEFAULT returned means trouble */	/* return the tag - LBER_DEFAULT returned means trouble */
unsigned long	ber_tag_t
ber_get_tag( BerElement *ber )	ber_get_tag( BerElement *ber )
{	{
unsigned char xbyte;	unsigned char xbyte;
unsigned long tag;	ber_tag_t tag;
char *tagp;	char *tagp;
unsigned int i;	unsigned int i;

Line 48 ber_get_tag( BerElement *ber )	Line 51 ber_get_tag( BerElement *ber )
return( LBER_DEFAULT );	return( LBER_DEFAULT );

if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )	if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
return( (unsigned long) xbyte );	return( (ber_tag_t) xbyte );

tagp = (char *) &tag;	tagp = (char *) &tag;
tagp[0] = xbyte;	tagp[0] = xbyte;
for ( i = 1; i < sizeof(long); i++ ) {	for ( i = 1; i < sizeof(ber_tag_t); i++ ) {
if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )	if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
return( LBER_DEFAULT );	return( LBER_DEFAULT );

Line 63 ber_get_tag( BerElement *ber )	Line 66 ber_get_tag( BerElement *ber )
}	}

/* tag too big! */	/* tag too big! */
if ( i == sizeof(long) )	if ( i == sizeof(ber_tag_t) )
return( LBER_DEFAULT );	return( LBER_DEFAULT );

/* want leading, not trailing 0's */	/* want leading, not trailing 0's */
return( tag >> (sizeof(long) - i - 1) );	return( tag >> (sizeof(ber_tag_t) - i - 1) );
}	}

unsigned long	ber_tag_t
ber_skip_tag( BerElement ber, unsigned long len )	ber_skip_tag( BerElement ber, ber_len_t len )
{	{
unsigned long tag;	ber_tag_t tag;
unsigned char lc;	unsigned char lc;
unsigned int noctets;	ber_len_t noctets;
int diff;	int diff;
unsigned long netlen;	ber_len_t netlen;

assert( ber != NULL );	assert( ber != NULL );
assert( len != NULL );	assert( len != NULL );
Line 112 ber_skip_tag( BerElement *ber, unsigned	Line 115 ber_skip_tag( BerElement *ber, unsigned
return( LBER_DEFAULT );	return( LBER_DEFAULT );
if ( lc & 0x80U ) {	if ( lc & 0x80U ) {
noctets = (lc & 0x7fU);	noctets = (lc & 0x7fU);
if ( (unsigned) noctets > sizeof(unsigned long) )	if ( noctets > sizeof(ber_len_t) )
return( LBER_DEFAULT );	return( LBER_DEFAULT );
diff = sizeof(unsigned long) - noctets;	diff = sizeof(ber_len_t) - noctets;
if ( (unsigned) ber_read( ber, (char *) &netlen + diff, noctets )	if ( (unsigned) ber_read( ber, (char *) &netlen + diff, noctets )
!= noctets )	!= noctets )
return( LBER_DEFAULT );	return( LBER_DEFAULT );
*len = AC_NTOHL( netlen );	*len = LBER_LEN_NTOH( netlen );
} else {	} else {
*len = lc;	*len = lc;
}	}
Line 126 ber_skip_tag( BerElement *ber, unsigned	Line 129 ber_skip_tag( BerElement *ber, unsigned
return( tag );	return( tag );
}	}

unsigned long	ber_tag_t
ber_peek_tag(	ber_peek_tag(
LDAP_CONST BerElement ber_in, / not const per c-api-02 */	LDAP_CONST BerElement *ber_in,
unsigned long *len )	ber_len_t *len )
{	{
unsigned long tag;	ber_tag_t tag;
BerElement *ber;	BerElement *ber;

assert( ber_in != NULL );	assert( ber_in != NULL );
Line 151 ber_peek_tag(	Line 154 ber_peek_tag(
return( tag );	return( tag );
}	}

static int	static ber_tag_t
ber_getnint( BerElement ber, long num, int len )	ber_getnint(
	BerElement *ber,
	ber_int_t *num,
	ber_len_t len )
{	{
int diff, sign, i;	int diff, sign, i;
long netnum;	ber_int_t netnum;
char *p;	char *p;

assert( ber != NULL );	assert( ber != NULL );
Line 170 ber_getnint( BerElement ber, long num,	Line 176 ber_getnint( BerElement ber, long num,
* extend after we read it in.	* extend after we read it in.
*/	*/

if ( (unsigned) len > sizeof(long) )	if ( len > sizeof(ber_int_t) )
return( -1 );	return( -1 );

netnum = 0;	netnum = 0;
diff = sizeof(long) - len;	diff = sizeof(ber_int_t) - len;
/* read into the low-order bytes of netnum */	/* read into the low-order bytes of netnum */
if ( ber_read( ber, ((char *) &netnum) + diff, len ) != len )	if ( (ber_len_t) ber_read( ber, ((char *) &netnum) + diff, len ) != len )
return( -1 );	return( -1 );

/* sign extend if necessary */	/* sign extend if necessary */
p = (char *) &netnum;	p = (char *) &netnum;
sign = (0x80 & *(p+diff) );	sign = (0x80 & *(p+diff) );
if ( sign && ((unsigned) len < sizeof(long)) ) {	if ( sign && ((size_t) len < sizeof(ber_int_t)) ) {
for ( i = 0; i < diff; i++ ) {	for ( i = 0; i < diff; i++ ) {
*(p+i) = (unsigned char) 0xff;	*(p+i) = (unsigned char) ~0;
}	}
}	}
*num = AC_NTOHL( netnum );	*num = LBER_INT_NTOH( netnum );

return( len );	return( len );
}	}

unsigned long	ber_tag_t
ber_get_int( BerElement ber, long num )	ber_get_int(
	BerElement *ber,
	ber_int_t *num )
{	{
unsigned long tag, len;	ber_tag_t tag;
	ber_len_t len;

assert( ber != NULL );	assert( ber != NULL );
assert( BER_VALID( ber ) );	assert( BER_VALID( ber ) );
Line 203 ber_get_int( BerElement ber, long num	Line 212 ber_get_int( BerElement ber, long num
if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )	if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
return( LBER_DEFAULT );	return( LBER_DEFAULT );

if ( (unsigned long) ber_getnint( ber, num, (int)len ) != len )	if ( (unsigned long) ber_getnint( ber, num, len ) != len )
return( LBER_DEFAULT );	return( LBER_DEFAULT );
else	else
return( tag );	return( tag );
}	}

unsigned long	ber_tag_t
ber_get_stringb( BerElement ber, char buf, unsigned long *len )	ber_get_stringb(
	BerElement *ber,
	char *buf,
	ber_len_t *len )
{	{
unsigned long datalen, tag;	ber_len_t datalen;
	ber_tag_t tag;

#ifdef STR_TRANSLATION	#ifdef STR_TRANSLATION
char *transbuf;	char *transbuf;
#endif /* STR_TRANSLATION */	#endif /* STR_TRANSLATION */
Line 253 ber_get_stringb( BerElement ber, char	Line 267 ber_get_stringb( BerElement ber, char
return( tag );	return( tag );
}	}

unsigned long	ber_tag_t
ber_get_stringa( BerElement ber, char *buf )	ber_get_stringa( BerElement ber, char *buf )
{	{
unsigned long datalen, tag;	ber_len_t datalen;
	ber_tag_t tag;

assert( ber != NULL );	assert( ber != NULL );
assert( buf != NULL );	assert( buf != NULL );
Line 268 ber_get_stringa( BerElement ber, char	Line 283 ber_get_stringa( BerElement ber, char
return( LBER_DEFAULT );	return( LBER_DEFAULT );
}	}

if ( (buf = (char ) LBER_MALLOC( (size_t)datalen + 1 )) == NULL )	if ( (buf = (char ) LBER_MALLOC( datalen + 1 )) == NULL )
return( LBER_DEFAULT );	return( LBER_DEFAULT );

if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) {	if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) {
Line 294 ber_get_stringa( BerElement ber, char	Line 309 ber_get_stringa( BerElement ber, char
return( tag );	return( tag );
}	}

unsigned long	ber_tag_t
ber_get_stringal( BerElement ber, struct berval *bv )	ber_get_stringal( BerElement ber, struct berval *bv )
{	{
unsigned long len, tag;	ber_len_t len;
	ber_tag_t tag;

assert( ber != NULL );	assert( ber != NULL );
assert( bv != NULL );	assert( bv != NULL );
Line 312 ber_get_stringal( BerElement *ber, struc	Line 328 ber_get_stringal( BerElement *ber, struc
if ( (bv = (struct berval ) LBER_MALLOC( sizeof(struct berval) )) == NULL )	if ( (bv = (struct berval ) LBER_MALLOC( sizeof(struct berval) )) == NULL )
return( LBER_DEFAULT );	return( LBER_DEFAULT );

if ( ((bv)->bv_val = (char ) LBER_MALLOC( (size_t)len + 1 )) == NULL ) {	if ( ((bv)->bv_val = (char ) LBER_MALLOC( len + 1 )) == NULL ) {
LBER_FREE( *bv );	LBER_FREE( *bv );
*bv = NULL;	*bv = NULL;
return( LBER_DEFAULT );	return( LBER_DEFAULT );
}	}

if ( (unsigned long) ber_read( ber, (*bv)->bv_val, len ) != len ) {	if ( (ber_len_t) ber_read( ber, (*bv)->bv_val, len ) != len ) {
ber_bvfree( *bv );	ber_bvfree( *bv );
*bv = NULL;	*bv = NULL;
return( LBER_DEFAULT );	return( LBER_DEFAULT );
Line 343 ber_get_stringal( BerElement *ber, struc	Line 359 ber_get_stringal( BerElement *ber, struc
return( tag );	return( tag );
}	}

unsigned long	ber_tag_t
ber_get_bitstringa( BerElement ber, char buf, unsigned long blen )	ber_get_bitstringa(
	BerElement *ber,
	char **buf,
	ber_len_t *blen )
{	{
unsigned long datalen, tag;	ber_len_t datalen;
	ber_tag_t tag;
unsigned char unusedbits;	unsigned char unusedbits;

assert( ber != NULL );	assert( ber != NULL );
Line 361 ber_get_bitstringa( BerElement *ber, cha	Line 381 ber_get_bitstringa( BerElement *ber, cha
}	}
--datalen;	--datalen;

if ( (buf = (char ) LBER_MALLOC( (size_t)datalen )) == NULL )	if ( (buf = (char ) LBER_MALLOC( datalen )) == NULL )
return( LBER_DEFAULT );	return( LBER_DEFAULT );

if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) {	if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) {
Line 380 ber_get_bitstringa( BerElement *ber, cha	Line 400 ber_get_bitstringa( BerElement *ber, cha
return( tag );	return( tag );
}	}

unsigned long	ber_tag_t
ber_get_null( BerElement *ber )	ber_get_null( BerElement *ber )
{	{
unsigned long len, tag;	ber_len_t len;
	ber_tag_t tag;

assert( ber != NULL );	assert( ber != NULL );
assert( BER_VALID( ber ) );	assert( BER_VALID( ber ) );
Line 397 ber_get_null( BerElement *ber )	Line 418 ber_get_null( BerElement *ber )
return( tag );	return( tag );
}	}

unsigned long	ber_tag_t
ber_get_boolean( BerElement ber, int boolval )	ber_get_boolean(
	BerElement *ber,
	ber_int_t *boolval )
{	{
long longbool;	ber_int_t longbool;
int rc;	ber_tag_t rc;

assert( ber != NULL );	assert( ber != NULL );
assert( boolval != NULL );	assert( boolval != NULL );
Line 414 ber_get_boolean( BerElement ber, int b	Line 437 ber_get_boolean( BerElement ber, int b
return( rc );	return( rc );
}	}

unsigned long	ber_tag_t
ber_first_element( BerElement ber, unsigned long len, char **last )	ber_first_element(
	BerElement *ber,
	ber_len_t *len,
	char **last )
{	{
assert( ber != NULL );	assert( ber != NULL );
assert( len != NULL );	assert( len != NULL );
Line 436 ber_first_element( BerElement *ber, unsi	Line 462 ber_first_element( BerElement *ber, unsi
return( ber_peek_tag( ber, len ) );	return( ber_peek_tag( ber, len ) );
}	}

unsigned long	ber_tag_t
ber_next_element( BerElement ber, unsigned long len, char *last )	ber_next_element(
	BerElement *ber,
	ber_len_t *len,
	char *last )
{	{
assert( ber != NULL );	assert( ber != NULL );
assert( len != NULL );	assert( len != NULL );
Line 453 ber_next_element( BerElement *ber, unsig	Line 482 ber_next_element( BerElement *ber, unsig
}	}

/* VARARGS */	/* VARARGS */
unsigned long	ber_tag_t
ber_scanf	ber_scanf
#if HAVE_STDARG	#if HAVE_STDARG
( BerElement *ber,	( BerElement *ber,
Line 473 va_dcl	Line 502 va_dcl
char *last;	char *last;
char s, ss, **sss;	char s, ss, **sss;
struct berval *bv, bvp, *bval;	struct berval *bv, bvp, *bval;
int *i, j;	ber_int_t *i;
long *l;	int j;
unsigned long rc, tag, len;	ber_len_t *l;
	ber_tag_t *t;
	ber_tag_t rc, tag;
	ber_len_t len;

#ifdef HAVE_STDARG	#ifdef HAVE_STDARG
va_start( ap, fmt );	va_start( ap, fmt );
Line 516 va_dcl	Line 548 va_dcl
break;	break;

case 'b': /* boolean */	case 'b': /* boolean */
i = va_arg( ap, int * );	i = va_arg( ap, ber_int_t * );
rc = ber_get_boolean( ber, i );	rc = ber_get_boolean( ber, i );
break;	break;

case 'e': /* enumerated */	case 'e': /* enumerated */
case 'i': /* int */	case 'i': /* int */
l = va_arg( ap, long * );	i = va_arg( ap, ber_int_t * );
rc = ber_get_int( ber, l );	rc = ber_get_int( ber, i );
break;	break;

case 'l': /* length of next item */	case 'l': /* length of next item */
l = va_arg( ap, long * );	l = va_arg( ap, ber_len_t * );
rc = ber_peek_tag( ber, l );	rc = ber_peek_tag( ber, l );
break;	break;

Line 537 va_dcl	Line 569 va_dcl

case 's': /* octet string - in a buffer */	case 's': /* octet string - in a buffer */
s = va_arg( ap, char * );	s = va_arg( ap, char * );
l = va_arg( ap, long * );	l = va_arg( ap, ber_len_t * );
rc = ber_get_stringb( ber, s, l );	rc = ber_get_stringb( ber, s, l );
break;	break;

Line 554 va_dcl	Line 586 va_dcl

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 ** );
l = va_arg( ap, long * ); /* for length, in bits */	l = va_arg( ap, ber_len_t * ); /* for length, in bits */
rc = ber_get_bitstringa( ber, ss, l );	rc = ber_get_bitstringa( ber, ss, l );
break;	break;

case 't': /* tag of next item */	case 't': /* tag of next item */
l = va_arg( ap, long * );	t = va_arg( ap, ber_tag_t * );
*l = rc = ber_peek_tag( ber, &len );	*t = rc = ber_peek_tag( ber, &len );
break;	break;

case 'T': /* skip tag of next item */	case 'T': /* skip tag of next item */
l = va_arg( ap, long * );	t = va_arg( ap, ber_tag_t * );
*l = rc = ber_skip_tag( ber, &len );	*t = rc = ber_skip_tag( ber, &len );
break;	break;

case 'v': /* sequence of strings */	case 'v': /* sequence of strings */
Line 666 va_dcl	Line 698 va_dcl
break;	break;

case 'b': /* boolean */	case 'b': /* boolean */
	case 'e': /* enumerated */
	case 'i': /* int */
(void) va_arg( ap, int * );	(void) va_arg( ap, int * );
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, long * );	(void) va_arg( ap, ber_len_t * );
break;	break;

case 'e': /* enumerated */
case 'i': /* int */
case 'l': /* length of next item */	case 'l': /* length of next item */
	(void) va_arg( ap, ber_len_t * );
	break;

case 't': /* tag of next item */	case 't': /* tag of next item */
case 'T': /* skip tag of next item */	case 'T': /* skip tag of next item */
(void) va_arg( ap, long * );	(void) va_arg( ap, ber_tag_t * );
break;	break;

case 'o': /* octet string in a supplied berval */	case 'o': /* octet string in a supplied berval */
Line 705 va_dcl	Line 740 va_dcl
LBER_FREE( *ss );	LBER_FREE( *ss );
*ss = NULL;	*ss = NULL;
}	}
(va_arg( ap, long )) = 0; /* for length, in bits */	(va_arg( ap, ber_len_t )) = 0; /* for length, in bits */
break;	break;

case 'v': /* sequence of strings */	case 'v': /* sequence of strings */

Removed from v.1.33
changed lines
	Added in v.1.33.2.1