version 1.23, 1999/05/19 18:38:02
|
version 1.29, 1999/05/28 23:19:15
|
Line 39 ber_get_tag( BerElement *ber )
|
Line 39 ber_get_tag( BerElement *ber )
|
unsigned int i; |
unsigned int i; |
|
|
assert( ber != NULL ); |
assert( ber != NULL ); |
|
assert( BER_VALID( ber ) ); |
|
|
if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) |
if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
Line 77 ber_skip_tag( BerElement *ber, unsigned
|
Line 78 ber_skip_tag( BerElement *ber, unsigned
|
|
|
assert( ber != NULL ); |
assert( ber != NULL ); |
assert( len != NULL ); |
assert( len != NULL ); |
|
assert( BER_VALID( ber ) ); |
|
|
/* |
/* |
* Any ber element looks like this: tag length contents. |
* Any ber element looks like this: tag length contents. |
Line 127 ber_peek_tag(
|
Line 129 ber_peek_tag(
|
unsigned long *len ) |
unsigned long *len ) |
{ |
{ |
unsigned long tag; |
unsigned long tag; |
BerElement *ber = ber_dup( ber_in ); |
BerElement *ber; |
|
|
|
assert( ber_in != NULL ); |
|
assert( BER_VALID( ber_in ) ); |
|
|
|
ber = ber_dup( ber_in ); |
|
|
if( ber == NULL ) { |
if( ber == NULL ) { |
return LBER_ERROR; |
return LBER_ERROR; |
} |
} |
|
|
|
assert( BER_VALID( ber ) ); |
|
|
tag = ber_skip_tag( ber, len ); |
tag = ber_skip_tag( ber, len ); |
|
|
ber_free( ber, 1 ); |
ber_free( ber, 0 ); |
return( tag ); |
return( tag ); |
} |
} |
|
|
Line 149 ber_getnint( BerElement *ber, long *num,
|
Line 158 ber_getnint( BerElement *ber, long *num,
|
assert( ber != NULL ); |
assert( ber != NULL ); |
assert( num != NULL ); |
assert( num != NULL ); |
|
|
|
assert( BER_VALID( ber ) ); |
|
|
/* |
/* |
* The tag and length have already been stripped off. We should |
* The tag and length have already been stripped off. We should |
* be sitting right before len bytes of 2's complement integer, |
* be sitting right before len bytes of 2's complement integer, |
Line 183 ber_get_int( BerElement *ber, long *num
|
Line 194 ber_get_int( BerElement *ber, long *num
|
{ |
{ |
unsigned long tag, len; |
unsigned long tag, len; |
|
|
|
assert( ber != NULL ); |
|
assert( BER_VALID( ber ) ); |
|
|
if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) |
if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
|
Line 200 ber_get_stringb( BerElement *ber, char *
|
Line 214 ber_get_stringb( BerElement *ber, char *
|
char *transbuf; |
char *transbuf; |
#endif /* STR_TRANSLATION */ |
#endif /* STR_TRANSLATION */ |
|
|
|
assert( ber != NULL ); |
|
assert( BER_VALID( ber ) ); |
|
|
if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) |
if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
if ( datalen > (*len - 1) ) |
if ( datalen > (*len - 1) ) |
Line 220 ber_get_stringb( BerElement *ber, char *
|
Line 237 ber_get_stringb( BerElement *ber, char *
|
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
if ( datalen > *len ) { |
if ( datalen > *len ) { |
free( transbuf ); |
LBER_FREE( transbuf ); |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
SAFEMEMCPY( buf, transbuf, datalen ); |
SAFEMEMCPY( buf, transbuf, datalen ); |
free( transbuf ); |
LBER_FREE( transbuf ); |
--datalen; |
--datalen; |
} |
} |
#endif /* STR_TRANSLATION */ |
#endif /* STR_TRANSLATION */ |
Line 238 ber_get_stringa( BerElement *ber, char *
|
Line 255 ber_get_stringa( BerElement *ber, char *
|
{ |
{ |
unsigned long datalen, tag; |
unsigned long datalen, tag; |
|
|
|
assert( ber != NULL ); |
|
assert( buf != NULL ); |
|
|
|
assert( BER_VALID( ber ) ); |
|
|
if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) { |
if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) { |
*buf = NULL; |
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
|
|
if ( (*buf = (char *) malloc( (size_t)datalen + 1 )) == NULL ) |
if ( (*buf = (char *) LBER_MALLOC( (size_t)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 ) { |
free( *buf ); |
LBER_FREE( *buf ); |
*buf = NULL; |
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
Line 259 ber_get_stringa( BerElement *ber, char *
|
Line 281 ber_get_stringa( BerElement *ber, char *
|
++datalen; |
++datalen; |
if ( (*(ber->ber_decode_translate_proc))( buf, &datalen, 1 ) |
if ( (*(ber->ber_decode_translate_proc))( buf, &datalen, 1 ) |
!= 0 ) { |
!= 0 ) { |
free( *buf ); |
LBER_FREE( *buf ); |
*buf = NULL; |
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
Line 274 ber_get_stringal( BerElement *ber, struc
|
Line 296 ber_get_stringal( BerElement *ber, struc
|
{ |
{ |
unsigned long len, tag; |
unsigned long len, tag; |
|
|
|
assert( ber != NULL ); |
|
assert( bv != NULL ); |
|
|
|
assert( BER_VALID( ber ) ); |
|
|
if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) { |
if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) { |
*bv = NULL; |
*bv = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
|
|
if ( (*bv = (struct berval *) 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 *) malloc( (size_t)len + 1 )) == NULL ) { |
if ( ((*bv)->bv_val = (char *) LBER_MALLOC( (size_t)len + 1 )) == NULL ) { |
free( *bv ); |
LBER_FREE( *bv ); |
*bv = NULL; |
*bv = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
Line 319 ber_get_bitstringa( BerElement *ber, cha
|
Line 346 ber_get_bitstringa( BerElement *ber, cha
|
unsigned long datalen, tag; |
unsigned long datalen, tag; |
unsigned char unusedbits; |
unsigned char unusedbits; |
|
|
|
assert( ber != NULL ); |
|
assert( buf != NULL ); |
|
assert( blen != NULL ); |
|
|
|
assert( BER_VALID( ber ) ); |
|
|
if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) { |
if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) { |
*buf = NULL; |
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
--datalen; |
--datalen; |
|
|
if ( (*buf = (char *) malloc( (size_t)datalen )) == NULL ) |
if ( (*buf = (char *) LBER_MALLOC( (size_t)datalen )) == NULL ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
|
if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) { |
if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) { |
free( buf ); |
LBER_FREE( buf ); |
*buf = NULL; |
*buf = 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 ) { |
free( buf ); |
LBER_FREE( buf ); |
*buf = NULL; |
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
Line 349 ber_get_null( BerElement *ber )
|
Line 382 ber_get_null( BerElement *ber )
|
{ |
{ |
unsigned long len, tag; |
unsigned long len, tag; |
|
|
|
assert( ber != NULL ); |
|
assert( BER_VALID( ber ) ); |
|
|
if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) |
if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
|
Line 364 ber_get_boolean( BerElement *ber, int *b
|
Line 400 ber_get_boolean( BerElement *ber, int *b
|
long longbool; |
long longbool; |
int rc; |
int rc; |
|
|
|
assert( ber != NULL ); |
|
assert( boolval != NULL ); |
|
|
|
assert( BER_VALID( ber ) ); |
|
|
rc = ber_get_int( ber, &longbool ); |
rc = ber_get_int( ber, &longbool ); |
*boolval = longbool; |
*boolval = longbool; |
|
|
Line 373 ber_get_boolean( BerElement *ber, int *b
|
Line 414 ber_get_boolean( BerElement *ber, int *b
|
unsigned long |
unsigned long |
ber_first_element( BerElement *ber, unsigned long *len, char **last ) |
ber_first_element( BerElement *ber, unsigned long *len, char **last ) |
{ |
{ |
|
assert( ber != NULL ); |
|
assert( len != NULL ); |
|
assert( last != NULL ); |
|
|
/* skip the sequence header, use the len to mark where to stop */ |
/* skip the sequence header, use the len to mark where to stop */ |
if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) { |
if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) { |
*last = NULL; |
*last = NULL; |
Line 382 ber_first_element( BerElement *ber, unsi
|
Line 427 ber_first_element( BerElement *ber, unsi
|
*last = ber->ber_ptr + *len; |
*last = ber->ber_ptr + *len; |
|
|
if ( *last == ber->ber_ptr ) { |
if ( *last == ber->ber_ptr ) { |
#ifdef LBER_END_SEQORSET |
|
return( LBER_END_SEQORSET ); |
|
#else |
|
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
#endif |
|
} |
} |
|
|
return( ber_peek_tag( ber, len ) ); |
return( ber_peek_tag( ber, len ) ); |
Line 395 ber_first_element( BerElement *ber, unsi
|
Line 436 ber_first_element( BerElement *ber, unsi
|
unsigned long |
unsigned long |
ber_next_element( BerElement *ber, unsigned long *len, char *last ) |
ber_next_element( BerElement *ber, unsigned long *len, char *last ) |
{ |
{ |
|
assert( ber != NULL ); |
|
assert( len != NULL ); |
|
assert( last != NULL ); |
|
|
|
assert( BER_VALID( ber ) ); |
|
|
if ( ber->ber_ptr == last ) { |
if ( ber->ber_ptr == last ) { |
#ifdef LBER_END_SEQORSET |
|
return( LBER_END_SEQORSET ); |
|
#else |
|
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
#endif |
|
} |
} |
|
|
return( ber_peek_tag( ber, len ) ); |
return( ber_peek_tag( ber, len ) ); |
Line 431 va_dcl
|
Line 474 va_dcl
|
long *l; |
long *l; |
unsigned long rc, tag, len; |
unsigned long rc, tag, len; |
|
|
assert( ber != NULL ); |
|
|
|
#ifdef HAVE_STDARG |
#ifdef HAVE_STDARG |
va_start( ap, fmt ); |
va_start( ap, fmt ); |
#else |
#else |
Line 444 va_dcl
|
Line 485 va_dcl
|
assert( ber != NULL ); |
assert( ber != NULL ); |
assert( fmt != NULL ); |
assert( fmt != NULL ); |
|
|
|
assert( BER_VALID( ber ) ); |
|
|
fmt_reset = fmt; |
fmt_reset = fmt; |
|
|
if ( ber->ber_debug ) { |
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 ); |
|
} |
|
|
|
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 529 va_dcl
|
Line 570 va_dcl
|
*sss = NULL; |
*sss = NULL; |
j = 0; |
j = 0; |
for ( tag = ber_first_element( ber, &len, &last ); |
for ( tag = ber_first_element( ber, &len, &last ); |
tag != LBER_DEFAULT && |
tag != LBER_DEFAULT && rc != LBER_DEFAULT; |
#ifdef LBER_END_SEQORSET |
|
tag != LBER_END_SEQORSET && |
|
#endif |
|
rc != LBER_DEFAULT; |
|
tag = ber_next_element( ber, &len, last ) ) |
tag = ber_next_element( ber, &len, last ) ) |
{ |
{ |
if ( *sss == NULL ) { |
*sss = (char **) LBER_REALLOC( *sss, |
*sss = (char **) malloc( |
(j + 2) * sizeof(char *) ); |
2 * sizeof(char *) ); |
|
} else { |
|
*sss = (char **) realloc( *sss, |
|
(j + 2) * sizeof(char *) ); |
|
} |
|
rc = ber_get_stringa( ber, &((*sss)[j]) ); |
rc = ber_get_stringa( ber, &((*sss)[j]) ); |
j++; |
j++; |
} |
} |
#ifdef LBER_END_SEQORSET |
|
if (rc != LBER_DEFAULT && |
|
tag != LBER_END_SEQORSET ) |
|
{ |
|
rc = LBER_DEFAULT; |
|
} |
|
#endif |
|
if ( j > 0 ) |
if ( j > 0 ) |
(*sss)[j] = NULL; |
(*sss)[j] = NULL; |
break; |
break; |
Line 562 va_dcl
|
Line 588 va_dcl
|
*bv = NULL; |
*bv = NULL; |
j = 0; |
j = 0; |
for ( tag = ber_first_element( ber, &len, &last ); |
for ( tag = ber_first_element( ber, &len, &last ); |
tag != LBER_DEFAULT && |
tag != LBER_DEFAULT && rc != LBER_DEFAULT; |
#ifdef LBER_END_SEQORSET |
|
tag != LBER_END_SEQORSET && |
|
#endif |
|
rc != LBER_DEFAULT; |
|
tag = ber_next_element( ber, &len, last ) ) |
tag = ber_next_element( ber, &len, last ) ) |
{ |
{ |
if ( *bv == NULL ) { |
*bv = (struct berval **) LBER_REALLOC( *bv, |
*bv = (struct berval **) malloc( |
(j + 2) * sizeof(struct berval *) ); |
2 * sizeof(struct berval *) ); |
|
} else { |
|
*bv = (struct berval **) realloc( *bv, |
|
(j + 2) * sizeof(struct berval *) ); |
|
} |
|
rc = ber_get_stringal( ber, &((*bv)[j]) ); |
rc = ber_get_stringal( ber, &((*bv)[j]) ); |
j++; |
j++; |
} |
} |
#ifdef LBER_END_SEQORSET |
|
if (rc != LBER_DEFAULT && |
|
tag != LBER_END_SEQORSET ) |
|
{ |
|
rc = LBER_DEFAULT; |
|
} |
|
#endif |
|
if ( j > 0 ) |
if ( j > 0 ) |
(*bv)[j] = NULL; |
(*bv)[j] = NULL; |
break; |
break; |
Line 646 va_dcl
|
Line 657 va_dcl
|
case 'a': /* octet string - allocate storage as needed */ |
case 'a': /* octet string - allocate storage as needed */ |
ss = va_arg( ap, char ** ); |
ss = va_arg( ap, char ** ); |
if ( *ss ) { |
if ( *ss ) { |
free( *ss ); |
LBER_FREE( *ss ); |
*ss = NULL; |
*ss = NULL; |
} |
} |
break; |
break; |
Line 670 va_dcl
|
Line 681 va_dcl
|
|
|
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 ) { |
if ( bval->bv_val != NULL ) { |
free( bval->bv_val ); |
LBER_FREE( bval->bv_val ); |
bval->bv_val = NULL; |
bval->bv_val = NULL; |
} |
} |
bval->bv_len = 0; |
bval->bv_len = 0; |
Line 688 va_dcl
|
Line 699 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 ** ); |
if ( *ss ) { |
if ( *ss ) { |
free( *ss ); |
LBER_FREE( *ss ); |
*ss = NULL; |
*ss = NULL; |
} |
} |
*(va_arg( ap, long * )) = 0; /* for length, in bits */ |
*(va_arg( ap, long * )) = 0; /* for length, in bits */ |
Line 698 va_dcl
|
Line 709 va_dcl
|
sss = va_arg( ap, char *** ); |
sss = va_arg( ap, char *** ); |
if ( *sss ) { |
if ( *sss ) { |
for (j = 0; (*sss)[j]; j++) { |
for (j = 0; (*sss)[j]; j++) { |
free( (*sss)[j] ); |
LBER_FREE( (*sss)[j] ); |
(*sss)[j] = NULL; |
(*sss)[j] = NULL; |
} |
} |
free( *sss ); |
LBER_FREE( *sss ); |
*sss = NULL; |
*sss = NULL; |
} |
} |
break; |
break; |
Line 740 ber_bvfree( struct berval *bv )
|
Line 751 ber_bvfree( struct berval *bv )
|
assert(bv != NULL); /* bv damn better point to something */ |
assert(bv != NULL); /* bv damn better point to something */ |
|
|
if ( bv->bv_val != NULL ) |
if ( bv->bv_val != NULL ) |
free( bv->bv_val ); |
LBER_FREE( bv->bv_val ); |
free( (char *) bv ); |
LBER_FREE( (char *) bv ); |
} |
} |
|
|
void |
void |
Line 753 ber_bvecfree( struct berval **bv )
|
Line 764 ber_bvecfree( struct berval **bv )
|
|
|
for ( i = 0; bv[i] != NULL; i++ ) |
for ( i = 0; bv[i] != NULL; i++ ) |
ber_bvfree( bv[i] ); |
ber_bvfree( bv[i] ); |
free( (char *) bv ); |
LBER_FREE( (char *) bv ); |
} |
} |
|
|
struct berval * |
struct berval * |
Line 768 ber_bvdup(
|
Line 779 ber_bvdup(
|
return NULL; |
return NULL; |
} |
} |
|
|
if ( (new = (struct berval *) malloc( sizeof(struct berval) )) |
if ( (new = (struct berval *) LBER_MALLOC( sizeof(struct berval) )) |
== NULL ) { |
== NULL ) { |
return( NULL ); |
return( NULL ); |
} |
} |
Line 779 ber_bvdup(
|
Line 790 ber_bvdup(
|
return ( new ); |
return ( new ); |
} |
} |
|
|
if ( (new->bv_val = (char *) malloc( bv->bv_len + 1 )) == NULL ) { |
if ( (new->bv_val = (char *) LBER_MALLOC( bv->bv_len + 1 )) == NULL ) { |
free( new ); |
LBER_FREE( new ); |
return( NULL ); |
return( NULL ); |
} |
} |
|
|
Line 798 ber_set_string_translators( BerElement *
|
Line 809 ber_set_string_translators( BerElement *
|
BERTranslateProc decode_proc ) |
BERTranslateProc decode_proc ) |
{ |
{ |
assert( ber != NULL ); |
assert( ber != NULL ); |
|
assert( BER_VALID( ber ) ); |
|
|
ber->ber_encode_translate_proc = encode_proc; |
ber->ber_encode_translate_proc = encode_proc; |
ber->ber_decode_translate_proc = decode_proc; |
ber->ber_decode_translate_proc = decode_proc; |