version 1.4.10.1, 1998/09/23 02:33:17
|
version 1.26, 1999/05/20 19:53:56
|
Line 1
|
Line 1
|
/* decode.c - ber input decoding routines */ |
/* decode.c - ber input decoding routines */ |
/* |
/* |
|
* Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved. |
|
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file |
|
*/ |
|
/* Portions |
* Copyright (c) 1990 Regents of the University of Michigan. |
* Copyright (c) 1990 Regents of the University of Michigan. |
* All rights reserved. |
* All rights reserved. |
* |
* |
Line 11
|
Line 15
|
* is provided ``as is'' without express or implied warranty. |
* is provided ``as is'' without express or implied warranty. |
*/ |
*/ |
|
|
#define LDAP_BRIDGE /* disable LDAP_BRIDGE code */ |
|
#include "portable.h" |
#include "portable.h" |
|
|
#include <stdio.h> |
#include <stdio.h> |
|
|
#ifdef MACOS |
|
#include <stdlib.h> |
#include <stdlib.h> |
#include <stdarg.h> |
|
#include "macos.h" |
|
#else /* MACOS */ |
|
|
|
#if defined(NeXT) || defined(VMS) || defined(__FreeBSD__) |
#include <ac/stdarg.h> |
#include <stdlib.h> |
|
#else /* next || vms || freebsd */ |
|
#include <malloc.h> |
|
#endif /* next || vms || freebsd */ |
|
#if defined(BC31) || defined(_WIN32) |
|
#include <stdarg.h> |
|
#else /* BC31 || _WIN32 */ |
|
#include <varargs.h> |
|
#endif /* BC31 || _WIN32 */ |
|
#include <sys/types.h> |
|
#include <sys/socket.h> |
|
#include <netinet/in.h> |
|
#ifdef PCNFS |
|
#include <tklib.h> |
|
#endif /* PCNFS */ |
|
#endif /* MACOS */ |
|
|
|
#if defined( DOS ) || defined( _WIN32 ) |
|
#include "msdos.h" |
|
#endif /* DOS */ |
|
|
|
#include <string.h> |
#include <ac/string.h> |
|
#include <ac/socket.h> |
|
|
#include "lber.h" |
#include "lber-int.h" |
|
|
#ifdef LDAP_DEBUG |
|
int lber_debug; |
|
#endif |
|
|
|
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 61 ber_get_tag( BerElement *ber )
|
Line 36 ber_get_tag( BerElement *ber )
|
unsigned char xbyte; |
unsigned char xbyte; |
unsigned long tag; |
unsigned long tag; |
char *tagp; |
char *tagp; |
int i; |
unsigned int i; |
|
|
|
assert( ber != NULL ); |
|
|
if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) |
if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
Line 94 ber_skip_tag( BerElement *ber, unsigned
|
Line 71 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 ); |
|
|
/* |
/* |
* 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 124 ber_skip_tag( BerElement *ber, unsigned
|
Line 105 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 = LBER_NTOHL( netlen ); |
*len = AC_NTOHL( netlen ); |
} else { |
} else { |
*len = lc; |
*len = lc; |
} |
} |
Line 141 ber_skip_tag( BerElement *ber, unsigned
|
Line 122 ber_skip_tag( BerElement *ber, unsigned
|
} |
} |
|
|
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 ); |
|
|
|
ber = ber_dup( ber_in ); |
|
|
|
if( ber == NULL ) { |
|
return LBER_ERROR; |
|
} |
|
|
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 160 ber_getnint( BerElement *ber, long *num,
|
Line 150 ber_getnint( BerElement *ber, long *num,
|
long netnum; |
long netnum; |
char *p; |
char *p; |
|
|
|
assert( ber != NULL ); |
|
assert( num != NULL ); |
|
|
/* |
/* |
* 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 167 ber_getnint( BerElement *ber, long *num,
|
Line 160 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 179 ber_getnint( BerElement *ber, long *num,
|
Line 172 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) = 0xff; |
*(p+i) = (unsigned char) 0xff; |
} |
} |
} |
} |
*num = LBER_NTOHL( netnum ); |
*num = AC_NTOHL( netnum ); |
|
|
return( len ); |
return( len ); |
} |
} |
Line 194 ber_get_int( BerElement *ber, long *num
|
Line 187 ber_get_int( BerElement *ber, long *num
|
{ |
{ |
unsigned long tag, len; |
unsigned long tag, len; |
|
|
|
assert( ber != NULL ); |
|
|
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 ( ber_getnint( ber, num, (int)len ) != len ) |
if ( (unsigned long) ber_getnint( ber, num, (int)len ) != len ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
else |
else |
return( tag ); |
return( tag ); |
Line 211 ber_get_stringb( BerElement *ber, char *
|
Line 206 ber_get_stringb( BerElement *ber, char *
|
char *transbuf; |
char *transbuf; |
#endif /* STR_TRANSLATION */ |
#endif /* STR_TRANSLATION */ |
|
|
|
assert( ber != NULL ); |
|
|
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) ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
|
if ( ber_read( ber, buf, datalen ) != datalen ) |
if ( (unsigned long) ber_read( ber, buf, datalen ) != datalen ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
|
buf[datalen] = '\0'; |
buf[datalen] = '\0'; |
|
|
#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 249 ber_get_stringa( BerElement *ber, char *
|
Line 246 ber_get_stringa( BerElement *ber, char *
|
{ |
{ |
unsigned long datalen, tag; |
unsigned long datalen, tag; |
|
|
if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) |
assert( ber != NULL ); |
|
assert( buf != NULL ); |
|
|
|
if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) { |
|
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
} |
|
|
if ( (*buf = (char *) malloc( (size_t)datalen + 1 )) == NULL ) |
if ( (*buf = (char *) malloc( (size_t)datalen + 1 )) == NULL ) |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
|
if ( ber_read( ber, *buf, datalen ) != datalen ) |
if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) { |
|
free( *buf ); |
|
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
} |
(*buf)[datalen] = '\0'; |
(*buf)[datalen] = '\0'; |
|
|
#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 ); |
free( *buf ); |
|
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
} |
} |
Line 279 ber_get_stringal( BerElement *ber, struc
|
Line 285 ber_get_stringal( BerElement *ber, struc
|
{ |
{ |
unsigned long len, tag; |
unsigned long len, tag; |
|
|
if ( (*bv = (struct berval *) malloc( sizeof(struct berval) )) == NULL ) |
assert( ber != NULL ); |
|
assert( bv != NULL ); |
|
|
|
if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) { |
|
*bv = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
} |
|
|
if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) |
if ( (*bv = (struct berval *) 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 *) malloc( (size_t)len + 1 )) == NULL ) { |
|
free( *bv ); |
|
*bv = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
} |
|
|
if ( ber_read( ber, (*bv)->bv_val, len ) != len ) |
if ( (unsigned long) ber_read( ber, (*bv)->bv_val, len ) != len ) { |
|
ber_bvfree( *bv ); |
|
*bv = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
} |
((*bv)->bv_val)[len] = '\0'; |
((*bv)->bv_val)[len] = '\0'; |
(*bv)->bv_len = len; |
(*bv)->bv_len = len; |
|
|
#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 ) { |
free( (*bv)->bv_val ); |
ber_bvfree( *bv ); |
|
*bv = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
(*bv)->bv_len = len - 1; |
(*bv)->bv_len = len - 1; |
Line 315 ber_get_bitstringa( BerElement *ber, cha
|
Line 333 ber_get_bitstringa( BerElement *ber, cha
|
unsigned long datalen, tag; |
unsigned long datalen, tag; |
unsigned char unusedbits; |
unsigned char unusedbits; |
|
|
if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) |
assert( ber != NULL ); |
|
assert( buf != NULL ); |
|
assert( blen != NULL ); |
|
|
|
if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) { |
|
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
} |
--datalen; |
--datalen; |
|
|
if ( (*buf = (char *) malloc( (size_t)datalen )) == NULL ) |
if ( (*buf = (char *) 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 ); |
|
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
} |
|
|
if ( ber_read( ber, *buf, datalen ) != datalen ) |
if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) { |
|
free( buf ); |
|
*buf = NULL; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
|
} |
|
|
*blen = datalen * 8 - unusedbits; |
*blen = datalen * 8 - unusedbits; |
return( tag ); |
return( tag ); |
Line 337 ber_get_null( BerElement *ber )
|
Line 367 ber_get_null( BerElement *ber )
|
{ |
{ |
unsigned long len, tag; |
unsigned long len, tag; |
|
|
|
assert( ber != NULL ); |
|
|
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 352 ber_get_boolean( BerElement *ber, int *b
|
Line 384 ber_get_boolean( BerElement *ber, int *b
|
long longbool; |
long longbool; |
int rc; |
int rc; |
|
|
|
assert( ber != NULL ); |
|
assert( boolval != NULL ); |
|
|
rc = ber_get_int( ber, &longbool ); |
rc = ber_get_int( ber, &longbool ); |
*boolval = longbool; |
*boolval = longbool; |
|
|
Line 361 ber_get_boolean( BerElement *ber, int *b
|
Line 396 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; |
return( LBER_DEFAULT ); |
return( LBER_DEFAULT ); |
} |
} |
|
|
*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 378 ber_first_element( BerElement *ber, unsi
|
Line 422 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 ); |
|
|
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 387 ber_next_element( BerElement *ber, unsig
|
Line 439 ber_next_element( BerElement *ber, unsig
|
|
|
/* VARARGS */ |
/* VARARGS */ |
unsigned long |
unsigned long |
ber_scanf( |
ber_scanf |
#if defined( MACOS ) || defined( BC31 ) || defined( _WIN32 ) |
#if HAVE_STDARG |
BerElement *ber, char *fmt, ... ) |
( BerElement *ber, |
|
LDAP_CONST char *fmt, |
|
... ) |
#else |
#else |
va_alist ) |
( va_alist ) |
va_dcl |
va_dcl |
#endif |
#endif |
{ |
{ |
va_list ap; |
va_list ap; |
#if !defined( MACOS ) && !defined( BC31 ) && !defined( _WIN32 ) |
#ifndef HAVE_STDARG |
BerElement *ber; |
BerElement *ber; |
char *fmt; |
char *fmt; |
#endif |
#endif |
|
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; |
int *i, j; |
int *i, j; |
long *l, rc, tag; |
long *l; |
unsigned long len; |
unsigned long rc, tag, len; |
|
|
#if defined( MACOS ) || defined( BC31 ) || defined( _WIN32 ) |
#ifdef HAVE_STDARG |
va_start( ap, fmt ); |
va_start( ap, fmt ); |
#else |
#else |
va_start( ap ); |
va_start( ap ); |
Line 415 va_dcl
|
Line 470 va_dcl
|
fmt = va_arg( ap, char * ); |
fmt = va_arg( ap, char * ); |
#endif |
#endif |
|
|
#ifdef LDAP_DEBUG |
assert( ber != NULL ); |
if ( lber_debug & 64 ) { |
assert( fmt != NULL ); |
fprintf( stderr, "ber_scanf fmt (%s) ber:\n", fmt ); |
|
ber_dump( ber, 1 ); |
fmt_reset = fmt; |
} |
|
#endif |
ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug, |
|
"ber_scanf fmt (%s) ber:\n", fmt ); |
|
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 |
|
* 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 442 va_dcl
|
Line 511 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 452 va_dcl
|
Line 521 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 469 va_dcl
|
Line 538 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 487 va_dcl
|
Line 556 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 && rc != LBER_DEFAULT; |
tag != LBER_DEFAULT && |
tag = ber_next_element( ber, &len, last ) ) { |
#ifdef LBER_END_SEQORSET |
|
tag != LBER_END_SEQORSET && |
|
#endif |
|
rc != LBER_DEFAULT; |
|
tag = ber_next_element( ber, &len, last ) ) |
|
{ |
if ( *sss == NULL ) { |
if ( *sss == NULL ) { |
*sss = (char **) malloc( |
*sss = (char **) malloc( |
2 * sizeof(char *) ); |
2 * sizeof(char *) ); |
Line 499 va_dcl
|
Line 573 va_dcl
|
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 508 va_dcl
|
Line 589 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 && rc != LBER_DEFAULT; |
tag != LBER_DEFAULT && |
tag = ber_next_element( ber, &len, last ) ) { |
#ifdef LBER_END_SEQORSET |
|
tag != LBER_END_SEQORSET && |
|
#endif |
|
rc != LBER_DEFAULT; |
|
tag = ber_next_element( ber, &len, last ) ) |
|
{ |
if ( *bv == NULL ) { |
if ( *bv == NULL ) { |
*bv = (struct berval **) malloc( |
*bv = (struct berval **) malloc( |
2 * sizeof(struct berval *) ); |
2 * sizeof(struct berval *) ); |
Line 520 va_dcl
|
Line 606 va_dcl
|
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 541 va_dcl
|
Line 634 va_dcl
|
break; |
break; |
|
|
default: |
default: |
#ifndef NO_USERINTERFACE |
if( ber->ber_debug ) { |
fprintf( stderr, "unknown fmt %c\n", *fmt ); |
ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug, |
#endif /* NO_USERINTERFACE */ |
"ber_scanf: unknown fmt %c\n", *fmt ); |
|
} |
rc = LBER_DEFAULT; |
rc = LBER_DEFAULT; |
break; |
break; |
} |
} |
Line 551 va_dcl
|
Line 645 va_dcl
|
|
|
va_end( ap ); |
va_end( ap ); |
|
|
|
if ( rc == LBER_DEFAULT ) { |
|
/* |
|
* Error. Reclaim malloced memory that was given to the caller. |
|
* Set allocated pointers to NULL, "data length" outvalues to 0. |
|
*/ |
|
#ifdef HAVE_STDARG |
|
va_start( ap, fmt ); |
|
#else |
|
va_start( ap ); |
|
(void) va_arg( ap, BerElement * ); |
|
(void) va_arg( ap, char * ); |
|
#endif |
|
|
|
for ( ; fmt_reset < fmt; 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 */ |
|
ss = va_arg( ap, char ** ); |
|
if ( *ss ) { |
|
free( *ss ); |
|
*ss = NULL; |
|
} |
|
break; |
|
|
|
case 'b': /* boolean */ |
|
(void) va_arg( ap, int * ); |
|
break; |
|
|
|
case 's': /* octet string - in a buffer */ |
|
(void) va_arg( ap, char * ); |
|
(void) va_arg( ap, long * ); |
|
break; |
|
|
|
case 'e': /* enumerated */ |
|
case 'i': /* int */ |
|
case 'l': /* length of next item */ |
|
case 't': /* tag of next item */ |
|
case 'T': /* skip tag of next item */ |
|
(void) va_arg( ap, long * ); |
|
break; |
|
|
|
case 'o': /* octet string in a supplied berval */ |
|
bval = va_arg( ap, struct berval * ); |
|
if ( bval->bv_val != NULL ) { |
|
free( bval->bv_val ); |
|
bval->bv_val = NULL; |
|
} |
|
bval->bv_len = 0; |
|
break; |
|
|
|
case 'O': /* octet string - allocate & include length */ |
|
bvp = va_arg( ap, struct berval ** ); |
|
if ( *bvp ) { |
|
ber_bvfree( *bvp ); |
|
*bvp = NULL; |
|
} |
|
break; |
|
|
|
case 'B': /* bit string - allocate storage as needed */ |
|
ss = va_arg( ap, char ** ); |
|
if ( *ss ) { |
|
free( *ss ); |
|
*ss = NULL; |
|
} |
|
*(va_arg( ap, long * )) = 0; /* for length, in bits */ |
|
break; |
|
|
|
case 'v': /* sequence of strings */ |
|
sss = va_arg( ap, char *** ); |
|
if ( *sss ) { |
|
for (j = 0; (*sss)[j]; j++) { |
|
free( (*sss)[j] ); |
|
(*sss)[j] = NULL; |
|
} |
|
free( *sss ); |
|
*sss = NULL; |
|
} |
|
break; |
|
|
|
case 'V': /* sequence of strings + lengths */ |
|
bv = va_arg( ap, struct berval *** ); |
|
if ( *bv ) { |
|
ber_bvecfree( *bv ); |
|
*bv = NULL; |
|
} |
|
break; |
|
|
|
case 'n': /* null */ |
|
case 'x': /* skip the next element - whatever it is */ |
|
case '{': /* begin sequence */ |
|
case '[': /* begin set */ |
|
case '}': /* end sequence */ |
|
case ']': /* end set */ |
|
break; |
|
|
|
default: |
|
/* format should be good */ |
|
assert( 0 ); |
|
} |
|
} |
|
|
|
va_end( ap ); |
|
} |
|
|
return( rc ); |
return( rc ); |
} |
} |
|
|
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 ); |
free( bv->bv_val ); |
free( (char *) bv ); |
free( (char *) bv ); |
Line 567 ber_bvecfree( struct berval **bv )
|
Line 776 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 ); |
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; |
|
|
|
assert( bv != NULL ); |
|
|
|
if( bv == NULL ) { |
|
return NULL; |
|
} |
|
|
if ( (new = (struct berval *) malloc( sizeof(struct berval) )) |
if ( (new = (struct berval *) malloc( sizeof(struct berval) )) |
== NULL ) { |
== NULL ) { |
return( NULL ); |
return( NULL ); |
} |
} |
|
|
|
if ( bv->bv_val == NULL ) { |
|
new->bv_val = NULL; |
|
new->bv_len = 0; |
|
return ( new ); |
|
} |
|
|
if ( (new->bv_val = (char *) malloc( bv->bv_len + 1 )) == NULL ) { |
if ( (new->bv_val = (char *) malloc( bv->bv_len + 1 )) == NULL ) { |
|
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 597 void
|
Line 824 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 ); |
|
|
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; |
} |
} |