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.100 and 1.108

version 1.100, 2004/01/01 18:15:25	version 1.108, 2007/03/23 14:27:38
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.99 2003/11/26 21:51:15 kurt Exp $ */	/* $OpenLDAP: pkg/ldap/libraries/liblber/decode.c,v 1.107 2007/03/20 14:10:16 hyc 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-2004 The OpenLDAP Foundation.	* Copyright 1998-2007 The OpenLDAP Foundation.
* All rights reserved.	* All rights reserved.
*	*
* Redistribution and use in source and binary forms, with or without	* Redistribution and use in source and binary forms, with or without
Line 45 static ber_len_t ber_getnint LDAP_P((	Line 45 static ber_len_t ber_getnint LDAP_P((
ber_int_t *num,	ber_int_t *num,
ber_len_t len ));	ber_len_t len ));

	/* out->bv_len should be the buffer size on input */
	int
	ber_decode_oid( BerValue in, BerValue out )
	{
	unsigned char *der = in->bv_val;
	unsigned long val, val1;
	int i, len;
	char *ptr;

	assert( in != NULL );
	assert( out != NULL );

	/* expands by 5/2, and we add dots - call it 3 */
	if ( !out->bv_val \|\| out->bv_len < in->bv_len * 3 )
	return -1;

	val1 = der[0] / 40;
	val = der[0] - val1 * 40;

	len = sprintf( out->bv_val, "%ld.%ld", val1, val );
	ptr = out->bv_val + len;
	val = 0;
	for ( i=1; i<in->bv_len; i++ ) {
	val = val << 7;
	val \|= der[i] & 0x7f;
	if ( !( der[i] & 0x80 )) {
	ptr += sprintf( ptr, ".%ld", val );
	val = 0;
	}
	}
	out->bv_len = ptr - out->bv_val;
	return 0;
	}

/* return the tag - LBER_DEFAULT returned means trouble */	/* return the tag - LBER_DEFAULT returned means trouble */
ber_tag_t	ber_tag_t
ber_get_tag( BerElement *ber )	ber_get_tag( BerElement *ber )
Line 437 nomem:	Line 471 nomem:
}	}

ber_tag_t	ber_tag_t
ber_get_stringbv( BerElement ber, struct berval bv, int alloc )	ber_get_stringbv( BerElement ber, struct berval bv, int option )
{	{
ber_tag_t tag;	ber_tag_t tag;

Line 455 ber_get_stringbv( BerElement *ber, struc	Line 489 ber_get_stringbv( BerElement *ber, struc
return LBER_DEFAULT;	return LBER_DEFAULT;
}	}

if ( 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 );
if ( bv->bv_val == NULL ) {	if ( bv->bv_val == NULL ) {
Line 474 ber_get_stringbv( BerElement *ber, struc	Line 508 ber_get_stringbv( BerElement *ber, struc
ber->ber_ptr += bv->bv_len;	ber->ber_ptr += bv->bv_len;
}	}
ber->ber_tag = (unsigned char )ber->ber_ptr;	ber->ber_tag = (unsigned char )ber->ber_ptr;
bv->bv_val[bv->bv_len] = '\0';	if ( !( option & LBER_BV_NOTERM ))
	bv->bv_val[bv->bv_len] = '\0';

	return tag;
	}

	ber_tag_t
	ber_get_stringbv_null( BerElement ber, struct berval bv, int option )
	{
	ber_tag_t tag;

	assert( ber != NULL );
	assert( bv != NULL );

	assert( LBER_VALID( ber ) );

	if ( (tag = ber_skip_tag( ber, &bv->bv_len )) == LBER_DEFAULT ) {
	bv->bv_val = NULL;
	return LBER_DEFAULT;
	}

	if ( (ber_len_t) ber_pvt_ber_remaining( ber ) < bv->bv_len ) {
	return LBER_DEFAULT;
	}

	if ( bv->bv_len == 0 ) {
	bv->bv_val = NULL;
	ber->ber_tag = (unsigned char )ber->ber_ptr;
	return tag;
	}

	if ( option & LBER_BV_ALLOC ) {
	bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1,
	ber->ber_memctx );
	if ( bv->bv_val == NULL ) {
	return LBER_DEFAULT;
	}

	if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, 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 ))
	bv->bv_val[bv->bv_len] = '\0';

return tag;	return tag;
}	}
Line 487 ber_get_stringa( BerElement ber, char	Line 572 ber_get_stringa( BerElement ber, char

assert( buf != NULL );	assert( buf != NULL );

tag = ber_get_stringbv( ber, &bv, 1 );	tag = ber_get_stringbv( ber, &bv, LBER_BV_ALLOC );
	*buf = bv.bv_val;

	return tag;
	}

	ber_tag_t
	ber_get_stringa_null( BerElement ber, char *buf )
	{
	BerValue bv;
	ber_tag_t tag;

	assert( buf != NULL );

	tag = ber_get_stringbv_null( ber, &bv, LBER_BV_ALLOC );
*buf = bv.bv_val;	*buf = bv.bv_val;

return tag;	return tag;
Line 507 ber_get_stringal( BerElement *ber, struc	Line 606 ber_get_stringal( BerElement *ber, struc
return LBER_DEFAULT;	return LBER_DEFAULT;
}	}

tag = ber_get_stringbv( ber, *bv, 1 );	tag = ber_get_stringbv( ber, *bv, LBER_BV_ALLOC );
if ( tag == LBER_DEFAULT ) {	if ( tag == LBER_DEFAULT ) {
LBER_FREE( *bv );	LBER_FREE( *bv );
*bv = NULL;	*bv = NULL;
Line 669 ber_scanf ( BerElement *ber,	Line 768 ber_scanf ( BerElement *ber,

fmt_reset = fmt;	fmt_reset = fmt;

#ifdef NEW_LOGGING
LDAP_LOG( BER, ENTRY, "ber_scanf fmt (%s) ber:\n", fmt, 0, 0 );

if ( LDAP_LOGS_TEST(BER, DETAIL2 )) {
BER_DUMP(( "liblber", LDAP_LEVEL_DETAIL2, ber, 1 ));
}
#else
ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,	ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
"ber_scanf fmt (%s) ber:\n", fmt );	"ber_scanf fmt (%s) ber:\n", fmt );
ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );	ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
#endif

for ( rc = 0; *fmt && rc != LBER_DEFAULT; fmt++ ) {	for ( rc = 0; *fmt && rc != LBER_DEFAULT; fmt++ ) {
/* When this is modified, remember to update	/* When this is modified, remember to update
Line 700 ber_scanf ( BerElement *ber,	Line 791 ber_scanf ( BerElement *ber,
rc = ber_get_stringa( ber, ss );	rc = ber_get_stringa( ber, ss );
break;	break;

	case 'A': /* octet string - allocate storage as needed,
	* but return NULL if len == 0 */
	ss = va_arg( ap, char ** );
	rc = ber_get_stringa_null( ber, ss );
	break;

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

	case 'B': /* bit string - allocate storage as needed */
	ss = va_arg( ap, char ** );
	l = va_arg( ap, ber_len_t * ); /* for length, in bits */
	rc = ber_get_bitstringa( ber, ss, l );
	break;

case 'e': /* enumerated */	case 'e': /* enumerated */
case 'i': /* int */	case 'i': /* int */
i = va_arg( ap, ber_int_t * );	i = va_arg( ap, ber_int_t * );
Line 716 ber_scanf ( BerElement *ber,	Line 819 ber_scanf ( BerElement *ber,
rc = ber_peek_tag( ber, l );	rc = ber_peek_tag( ber, l );
break;	break;

case 'n': /* null */	case 'm': /* octet string in berval, in-place */
rc = ber_get_null( ber );	bval = va_arg( ap, struct berval * );
	rc = ber_get_stringbv( ber, bval, 0 );
break;	break;

case 's': /* octet string - in a buffer */	case 'M': /* bvoffarray - must include address of
s = va_arg( ap, char * );	* a record len, and record offset.
	* number of records will be returned thru
	* len ptr on finish. parsed in-place.
	*/
	{
	bgbvr cookie = { BvOff };
	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 * );
rc = ber_get_stringb( ber, s, l );	cookie.siz = *l;
	cookie.off = va_arg( ap, ber_len_t );
	rc = ber_get_stringbvl( &cookie, l );
break;	break;
	}

case 'm': /* octet string in berval, in-place */	case 'n': /* null */
bval = va_arg( ap, struct berval * );	rc = ber_get_null( ber );
rc = ber_get_stringbv( ber, bval, 0 );
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 * );
rc = ber_get_stringbv( ber, bval, 1 );	rc = ber_get_stringbv( ber, bval, LBER_BV_ALLOC );
break;	break;

case 'O': /* octet string - allocate & include length */	case 'O': /* octet string - allocate & include length */
Line 741 ber_scanf ( BerElement *ber,	Line 855 ber_scanf ( BerElement *ber,
rc = ber_get_stringal( ber, bvp );	rc = ber_get_stringal( ber, bvp );
break;	break;

case 'B': /* bit string - allocate storage as needed */	case 's': /* octet string - in a buffer */
ss = va_arg( ap, char ** );	s = va_arg( ap, char * );
l = va_arg( ap, ber_len_t * ); /* for length, in bits */	l = va_arg( ap, ber_len_t * );
rc = ber_get_bitstringa( ber, ss, l );	rc = ber_get_stringb( ber, s, l );
break;	break;

case 't': /* tag of next item */	case 't': /* tag of next item */
Line 762 ber_scanf ( BerElement *ber,	Line 876 ber_scanf ( BerElement *ber,
bgbvr cookie = { ChArray };	bgbvr cookie = { ChArray };
cookie.ber = ber;	cookie.ber = ber;
cookie.res.c = va_arg( ap, char *** );	cookie.res.c = va_arg( ap, char *** );
cookie.alloc = 1;	cookie.alloc = LBER_BV_ALLOC;
rc = ber_get_stringbvl( &cookie, NULL );	rc = ber_get_stringbvl( &cookie, NULL );
break;	break;
}	}
Line 772 ber_scanf ( BerElement *ber,	Line 886 ber_scanf ( BerElement *ber,
bgbvr cookie = { BvVec };	bgbvr cookie = { BvVec };
cookie.ber = ber;	cookie.ber = ber;
cookie.res.bv = va_arg( ap, struct berval *** );	cookie.res.bv = va_arg( ap, struct berval *** );
cookie.alloc = 1;	cookie.alloc = LBER_BV_ALLOC;
rc = ber_get_stringbvl( &cookie, NULL );	rc = ber_get_stringbvl( &cookie, NULL );
break;	break;
}	}
Line 782 ber_scanf ( BerElement *ber,	Line 896 ber_scanf ( BerElement *ber,
bgbvr cookie = { BvArray };	bgbvr cookie = { BvArray };
cookie.ber = ber;	cookie.ber = ber;
cookie.res.ba = va_arg( ap, struct berval ** );	cookie.res.ba = va_arg( ap, struct berval ** );
cookie.alloc = 1;	cookie.alloc = LBER_BV_ALLOC;
rc = ber_get_stringbvl( &cookie, NULL );	rc = ber_get_stringbvl( &cookie, NULL );
break;	break;
}	}

case 'M': /* bvoffarray - must include address of
* a record len, and record offset.
* number of records will be returned thru
* len ptr on finish. parsed in-place.
*/
{
bgbvr cookie = { BvOff };
cookie.ber = ber;
cookie.res.ba = va_arg( ap, struct berval ** );
cookie.alloc = 0;
l = va_arg( ap, ber_len_t * );
cookie.siz = *l;
cookie.off = va_arg( ap, ber_len_t );
rc = ber_get_stringbvl( &cookie, l );
break;
}

case 'x': /* skip the next element - whatever it is */	case 'x': /* skip the next element - whatever it is */
if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )	if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
break;	break;
Line 824 ber_scanf ( BerElement *ber,	Line 921 ber_scanf ( BerElement *ber,

default:	default:
if( ber->ber_debug ) {	if( ber->ber_debug ) {
#ifdef NEW_LOGGING
LDAP_LOG( BER, ERR,
"ber_scanf: unknown fmt %c\n", *fmt, 0, 0 );
#else
ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug,	ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug,
"ber_scanf: unknown fmt %c\n", *fmt );	"ber_scanf: unknown fmt %c\n", *fmt );
#endif
}	}
rc = LBER_DEFAULT;	rc = LBER_DEFAULT;
break;	break;
Line 858 ber_scanf ( BerElement *ber,	Line 950 ber_scanf ( BerElement *ber,
} break;	} break;

case 'a': /* octet string - allocate storage as needed */	case 'a': /* octet string - allocate storage as needed */
	case 'A':
ss = va_arg( ap, char ** );	ss = va_arg( ap, char ** );
if ( *ss ) {	if ( *ss ) {
LBER_FREE( *ss );	LBER_FREE( *ss );
Line 871 ber_scanf ( BerElement *ber,	Line 964 ber_scanf ( BerElement *ber,
(void) va_arg( ap, int * );	(void) va_arg( ap, int * );
break;	break;

case 's': /* octet string - in a buffer */
(void) va_arg( ap, char * );
(void) va_arg( ap, ber_len_t * );
break;

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

case 't': /* tag of next item */
case 'T': /* skip tag of next item */
(void) va_arg( ap, ber_tag_t * );
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 ) {	if ( bval->bv_val != NULL ) {
Line 902 ber_scanf ( BerElement *ber,	Line 985 ber_scanf ( BerElement *ber,
}	}
break;	break;

	case 's': /* octet string - in a buffer */
	(void) va_arg( ap, char * );
	(void) va_arg( ap, ber_len_t * );
	break;

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

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 ) {	if ( *ss ) {
Line 911 ber_scanf ( BerElement *ber,	Line 1004 ber_scanf ( BerElement *ber,
(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 'v': /* sequence of strings */
case 'V': /* sequence of strings + lengths */
case 'W': /* BerVarray */
case 'm': /* berval in-place */	case 'm': /* berval in-place */
case 'M': /* BVoff array in-place */	case 'M': /* BVoff array in-place */
case 'n': /* null */	case 'n': /* null */
	case 'v': /* sequence of strings */
	case 'V': /* sequence of strings + lengths */
	case 'W': /* BerVarray */
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.100
changed lines
	Added in v.1.108