version 1.5.2.4.2.3, 2001/05/06 22:43:39
|
version 1.29, 1999/05/28 23:19:15
|
Line 25
|
Line 25
|
#include <ac/string.h> |
#include <ac/string.h> |
#include <ac/socket.h> |
#include <ac/socket.h> |
|
|
#include "lber.h" |
#include "lber-int.h" |
|
|
int lber_debug; |
|
|
|
static int ber_getnint LDAP_P(( BerElement *ber, long *num, int len )); |
static int ber_getnint LDAP_P(( BerElement *ber, long *num, int len )); |
|
|
Line 40 ber_get_tag( BerElement *ber )
|
Line 38 ber_get_tag( BerElement *ber )
|
char *tagp; |
char *tagp; |
unsigned int i; |
unsigned int i; |
|
|
|
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 71 ber_skip_tag( BerElement *ber, unsigned
|
Line 72 ber_skip_tag( BerElement *ber, unsigned
|
{ |
{ |
unsigned long tag; |
unsigned long tag; |
unsigned char lc; |
unsigned char lc; |
int noctets, diff; |
unsigned int noctets; |
|
int diff; |
unsigned long netlen; |
unsigned long netlen; |
|
|
|
assert( ber != 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. |
* Assuming everything's ok, we return the tag byte (we |
* Assuming everything's ok, we return the tag byte (we |
Line 101 ber_skip_tag( BerElement *ber, unsigned
|
Line 107 ber_skip_tag( BerElement *ber, unsigned
|
*len = netlen = 0; |
*len = netlen = 0; |
if ( ber_read( ber, (char *) &lc, 1 ) != 1 ) |
if ( ber_read( ber, (char *) &lc, 1 ) != 1 ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
if ( lc & 0x80 ) { |
if ( lc & 0x80U ) { |
noctets = (lc & 0x7f); |
noctets = (lc & 0x7fU); |
if ( noctets > sizeof(unsigned long) ) |
if ( (unsigned) noctets > sizeof(unsigned long) ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
diff = sizeof(unsigned long) - noctets; |
diff = sizeof(unsigned long) - noctets; |
if ( 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 = AC_NTOHL( netlen ); |
Line 114 ber_skip_tag( BerElement *ber, unsigned
|
Line 120 ber_skip_tag( BerElement *ber, unsigned
|
*len = lc; |
*len = lc; |
} |
} |
|
|
|
|
/* BER element should have enough data left */ |
|
if( *len > ber->ber_end - ber->ber_ptr ) { |
|
return LBER_DEFAULT; |
|
} |
|
|
|
return( tag ); |
return( tag ); |
} |
} |
|
|
unsigned long |
unsigned long |
ber_peek_tag( BerElement *ber, unsigned long *len ) |
ber_peek_tag( |
|
LDAP_CONST BerElement *ber_in, /* not const per c-api-02 */ |
|
unsigned long *len ) |
{ |
{ |
char *save; |
|
unsigned long tag; |
unsigned long tag; |
|
BerElement *ber; |
|
|
|
assert( ber_in != NULL ); |
|
assert( BER_VALID( ber_in ) ); |
|
|
|
ber = ber_dup( ber_in ); |
|
|
|
if( ber == NULL ) { |
|
return LBER_ERROR; |
|
} |
|
|
|
assert( BER_VALID( ber ) ); |
|
|
save = ber->ber_ptr; |
|
tag = ber_skip_tag( ber, len ); |
tag = ber_skip_tag( ber, len ); |
ber->ber_ptr = save; |
|
|
|
|
ber_free( ber, 0 ); |
return( tag ); |
return( tag ); |
} |
} |
|
|
Line 143 ber_getnint( BerElement *ber, long *num,
|
Line 155 ber_getnint( BerElement *ber, long *num,
|
long netnum; |
long netnum; |
char *p; |
char *p; |
|
|
|
assert( ber != 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 150 ber_getnint( BerElement *ber, long *num,
|
Line 167 ber_getnint( BerElement *ber, long *num,
|
* extend after we read it in. |
* extend after we read it in. |
*/ |
*/ |
|
|
if ( len > sizeof(long) ) |
if ( (unsigned) len > sizeof(long) ) |
return( -1 ); |
return( -1 ); |
|
|
netnum = 0; |
netnum = 0; |
Line 162 ber_getnint( BerElement *ber, long *num,
|
Line 179 ber_getnint( BerElement *ber, long *num,
|
/* sign extend if necessary */ |
/* sign extend if necessary */ |
p = (char *) &netnum; |
p = (char *) &netnum; |
sign = (0x80 & *(p+diff) ); |
sign = (0x80 & *(p+diff) ); |
if ( sign && len < sizeof(long) ) { |
if ( sign && ((unsigned) len < sizeof(long)) ) { |
for ( i = 0; i < diff; i++ ) { |
for ( i = 0; i < diff; i++ ) { |
*(p+i) = (unsigned char) 0xff; |
*(p+i) = (unsigned char) 0xff; |
} |
} |
Line 177 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 194 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 ) |
|
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 207 ber_get_stringb( BerElement *ber, char *
|
Line 229 ber_get_stringb( BerElement *ber, char *
|
|
|
#ifdef STR_TRANSLATION |
#ifdef STR_TRANSLATION |
if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0 |
if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0 |
&& ber->ber_decode_translate_proc != NULL ) { |
&& ber->ber_decode_translate_proc ) { |
transbuf = buf; |
transbuf = buf; |
++datalen; |
++datalen; |
if ( (*(ber->ber_decode_translate_proc))( &transbuf, &datalen, |
if ( (*(ber->ber_decode_translate_proc))( &transbuf, &datalen, |
Line 215 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 233 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 250 ber_get_stringa( BerElement *ber, char *
|
Line 277 ber_get_stringa( BerElement *ber, char *
|
|
|
#ifdef STR_TRANSLATION |
#ifdef STR_TRANSLATION |
if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0 |
if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0 |
&& ber->ber_decode_translate_proc != NULL ) { |
&& ber->ber_decode_translate_proc ) { |
++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 269 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 293 ber_get_stringal( BerElement *ber, struc
|
Line 325 ber_get_stringal( BerElement *ber, struc
|
|
|
#ifdef STR_TRANSLATION |
#ifdef STR_TRANSLATION |
if ( len > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0 |
if ( len > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0 |
&& ber->ber_decode_translate_proc != NULL ) { |
&& ber->ber_decode_translate_proc ) { |
++len; |
++len; |
if ( (*(ber->ber_decode_translate_proc))( &((*bv)->bv_val), |
if ( (*(ber->ber_decode_translate_proc))( &((*bv)->bv_val), |
&len, 1 ) != 0 ) { |
&len, 1 ) != 0 ) { |
Line 314 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 344 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 359 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 368 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 386 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 ) { |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
Line 397 ber_next_element( BerElement *ber, unsig
|
Line 453 ber_next_element( BerElement *ber, unsig
|
unsigned long |
unsigned long |
ber_scanf |
ber_scanf |
#if HAVE_STDARG |
#if HAVE_STDARG |
( BerElement *ber, char *fmt, ... ) |
( BerElement *ber, |
|
LDAP_CONST char *fmt, |
|
... ) |
#else |
#else |
( va_alist ) |
( va_alist ) |
va_dcl |
va_dcl |
Line 408 va_dcl
|
Line 466 va_dcl
|
BerElement *ber; |
BerElement *ber; |
char *fmt; |
char *fmt; |
#endif |
#endif |
char *fmt_reset; |
LDAP_CONST char *fmt_reset; |
char *last; |
char *last; |
char *s, **ss, ***sss; |
char *s, **ss, ***sss; |
struct berval ***bv, **bvp, *bval; |
struct berval ***bv, **bvp, *bval; |
Line 423 va_dcl
|
Line 481 va_dcl
|
ber = va_arg( ap, BerElement * ); |
ber = va_arg( ap, BerElement * ); |
fmt = va_arg( ap, char * ); |
fmt = va_arg( ap, char * ); |
#endif |
#endif |
|
|
|
assert( ber != NULL ); |
|
assert( fmt != NULL ); |
|
|
|
assert( BER_VALID( ber ) ); |
|
|
fmt_reset = fmt; |
fmt_reset = fmt; |
|
|
#ifdef LDAP_DEBUG |
ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug, |
if ( lber_debug & 64 ) { |
"ber_scanf fmt (%s) ber:\n", fmt ); |
fprintf( stderr, "ber_scanf fmt (%s) ber:\n", fmt ); |
ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 ); |
ber_dump( 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 |
* the error-cleanup code below accordingly. */ |
* the error-cleanup code below accordingly. */ |
switch ( *fmt ) { |
switch ( *fmt ) { |
|
case '!': { /* Hook */ |
|
BERDecodeCallback *f; |
|
void *p; |
|
|
|
f = va_arg( ap, BERDecodeCallback * ); |
|
p = va_arg( ap, void * ); |
|
|
|
rc = (*f)( ber, p, 0 ); |
|
} break; |
|
|
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 ** ); |
rc = ber_get_stringa( ber, ss ); |
rc = ber_get_stringa( ber, ss ); |
Line 454 va_dcl
|
Line 525 va_dcl
|
|
|
case 'l': /* length of next item */ |
case 'l': /* length of next item */ |
l = va_arg( ap, long * ); |
l = va_arg( ap, long * ); |
rc = ber_peek_tag( ber, (unsigned long *)l ); |
rc = ber_peek_tag( ber, l ); |
break; |
break; |
|
|
case 'n': /* null */ |
case 'n': /* null */ |
Line 464 va_dcl
|
Line 535 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, long * ); |
rc = ber_get_stringb( ber, s, (unsigned long *)l ); |
rc = ber_get_stringb( ber, s, l ); |
break; |
break; |
|
|
case 'o': /* octet string in a supplied berval */ |
case 'o': /* octet string in a supplied berval */ |
Line 481 va_dcl
|
Line 552 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, long * ); /* for length, in bits */ |
rc = ber_get_bitstringa( ber, ss, (unsigned long *)l ); |
rc = ber_get_bitstringa( ber, ss, l ); |
break; |
break; |
|
|
case 't': /* tag of next item */ |
case 't': /* tag of next item */ |
i = va_arg( ap, int * ); |
l = va_arg( ap, long * ); |
*i = rc = ber_peek_tag( ber, &len ); |
*l = rc = ber_peek_tag( ber, &len ); |
break; |
break; |
|
|
case 'T': /* skip tag of next item */ |
case 'T': /* skip tag of next item */ |
i = va_arg( ap, int * ); |
l = va_arg( ap, long * ); |
*i = rc = ber_skip_tag( ber, &len ); |
*l = rc = ber_skip_tag( ber, &len ); |
break; |
break; |
|
|
case 'v': /* sequence of strings */ |
case 'v': /* sequence of strings */ |
Line 500 va_dcl
|
Line 571 va_dcl
|
j = 0; |
j = 0; |
for ( tag = ber_first_element( ber, &len, &last ); |
for ( tag = ber_first_element( ber, &len, &last ); |
tag != LBER_DEFAULT && rc != LBER_DEFAULT; |
tag != LBER_DEFAULT && rc != LBER_DEFAULT; |
tag = ber_next_element( ber, &len, last ) ) { |
tag = ber_next_element( ber, &len, last ) ) |
if ( *sss == NULL ) { |
{ |
*sss = (char **) malloc( |
*sss = (char **) LBER_REALLOC( *sss, |
2 * sizeof(char *) ); |
(j + 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++; |
} |
} |
Line 521 va_dcl
|
Line 589 va_dcl
|
j = 0; |
j = 0; |
for ( tag = ber_first_element( ber, &len, &last ); |
for ( tag = ber_first_element( ber, &len, &last ); |
tag != LBER_DEFAULT && rc != LBER_DEFAULT; |
tag != LBER_DEFAULT && rc != LBER_DEFAULT; |
tag = ber_next_element( ber, &len, last ) ) { |
tag = ber_next_element( ber, &len, last ) ) |
if ( *bv == NULL ) { |
{ |
*bv = (struct berval **) malloc( |
*bv = (struct berval **) LBER_REALLOC( *bv, |
2 * sizeof(struct berval *) ); |
(j + 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++; |
} |
} |
Line 553 va_dcl
|
Line 618 va_dcl
|
break; |
break; |
|
|
default: |
default: |
#ifdef LDAP_LIBUI |
if( ber->ber_debug ) { |
fprintf( stderr, "unknown fmt %c\n", *fmt ); |
ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug, |
#endif /* LDAP_LIBUI */ |
"ber_scanf: unknown fmt %c\n", *fmt ); |
|
} |
rc = LBER_DEFAULT; |
rc = LBER_DEFAULT; |
break; |
break; |
} |
} |
Line 578 va_dcl
|
Line 644 va_dcl
|
|
|
for ( ; fmt_reset < fmt; fmt_reset++ ) { |
for ( ; fmt_reset < fmt; fmt_reset++ ) { |
switch ( *fmt_reset ) { |
switch ( *fmt_reset ) { |
|
case '!': { /* Hook */ |
|
BERDecodeCallback *f; |
|
void *p; |
|
|
|
f = va_arg( ap, BERDecodeCallback * ); |
|
p = va_arg( ap, void * ); |
|
|
|
(void) (*f)( ber, p, 1 ); |
|
} break; |
|
|
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; |
|
|
case 'b': /* boolean */ |
case 'b': /* boolean */ |
case 't': /* tag of next item */ |
|
case 'T': /* skip tag of next item */ |
|
(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 * ); |
/* Fall through */ |
(void) va_arg( ap, long * ); |
|
break; |
|
|
case 'e': /* enumerated */ |
case 'e': /* enumerated */ |
case 'i': /* int */ |
case 'i': /* int */ |
case 'l': /* length of next item */ |
case 'l': /* length of next item */ |
|
case 't': /* tag of next item */ |
|
case 'T': /* skip tag of next item */ |
(void) va_arg( ap, long * ); |
(void) va_arg( ap, long * ); |
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 ) { |
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 621 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 630 va_dcl
|
Line 708 va_dcl
|
case 'v': /* sequence of strings */ |
case 'v': /* sequence of strings */ |
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] ); |
free( *sss ); |
(*sss)[j] = NULL; |
|
} |
|
LBER_FREE( *sss ); |
*sss = NULL; |
*sss = NULL; |
} |
} |
break; |
break; |
Line 645 va_dcl
|
Line 725 va_dcl
|
} |
} |
break; |
break; |
|
|
#if 0 /* No action for these format characters */ |
|
case 'n': /* null */ |
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 */ |
case '}': /* end sequence */ |
case '}': /* end sequence */ |
case ']': /* end set */ |
case ']': /* end set */ |
#endif |
break; |
|
|
|
default: |
|
/* format should be good */ |
|
assert( 0 ); |
} |
} |
} |
} |
|
|
Line 666 va_dcl
|
Line 748 va_dcl
|
void |
void |
ber_bvfree( struct berval *bv ) |
ber_bvfree( struct berval *bv ) |
{ |
{ |
|
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 676 ber_bvecfree( struct berval **bv )
|
Line 760 ber_bvecfree( struct berval **bv )
|
{ |
{ |
int i; |
int i; |
|
|
|
assert(bv != NULL); /* bv damn better point to something */ |
|
|
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 * |
ber_bvdup( struct berval *bv ) |
ber_bvdup( |
|
LDAP_CONST struct berval *bv ) |
{ |
{ |
struct berval *new; |
struct berval *new; |
|
|
if ( (new = (struct berval *) malloc( sizeof(struct berval) )) |
assert( bv != NULL ); |
|
|
|
if( bv == NULL ) { |
|
return NULL; |
|
} |
|
|
|
if ( (new = (struct berval *) LBER_MALLOC( sizeof(struct berval) )) |
== NULL ) { |
== NULL ) { |
return( NULL ); |
return( NULL ); |
} |
} |
if ( (new->bv_val = (char *) malloc( bv->bv_len + 1 )) == NULL ) { |
|
|
if ( bv->bv_val == NULL ) { |
|
new->bv_val = NULL; |
|
new->bv_len = 0; |
|
return ( new ); |
|
} |
|
|
|
if ( (new->bv_val = (char *) LBER_MALLOC( bv->bv_len + 1 )) == NULL ) { |
|
LBER_FREE( new ); |
return( NULL ); |
return( NULL ); |
} |
} |
|
|
SAFEMEMCPY( new->bv_val, bv->bv_val, (size_t) bv->bv_len ); |
SAFEMEMCPY( new->bv_val, bv->bv_val, (size_t) bv->bv_len ); |
new->bv_val[bv->bv_len] = '\0'; |
new->bv_val[bv->bv_len] = '\0'; |
new->bv_len = bv->bv_len; |
new->bv_len = bv->bv_len; |
Line 706 void
|
Line 808 void
|
ber_set_string_translators( BerElement *ber, BERTranslateProc encode_proc, |
ber_set_string_translators( BerElement *ber, BERTranslateProc encode_proc, |
BERTranslateProc decode_proc ) |
BERTranslateProc decode_proc ) |
{ |
{ |
|
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; |
} |
} |