--- libraries/liblber/decode.c 1998/08/08 22:43:15 1.1.3.1 +++ libraries/liblber/decode.c 1999/06/01 17:01:05 1.31 @@ -1,5 +1,9 @@ /* 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. * All rights reserved. * @@ -11,45 +15,19 @@ * is provided ``as is'' without express or implied warranty. */ +#include "portable.h" + #include -#ifdef MACOS #include -#include -#include "macos.h" -#else /* MACOS */ -#if defined(NeXT) || defined(VMS) -#include -#else /* next || vms */ -#include -#endif /* next || vms */ -#if defined(BC31) || defined(_WIN32) -#include -#else /* BC31 || _WIN32 */ -#include -#endif /* BC31 || _WIN32 */ -#include -#include -#include -#ifdef PCNFS -#include -#endif /* PCNFS */ -#endif /* MACOS */ - -#if defined( DOS ) || defined( _WIN32 ) -#include "msdos.h" -#endif /* DOS */ -#include -#include "lber.h" +#include -#ifdef LDAP_DEBUG -int lber_debug; -#endif +#include +#include -#ifdef NEEDPROTOS -static int ber_getnint( BerElement *ber, long *num, int len ); -#endif /* NEEDPROTOS */ +#include "lber-int.h" +static int ber_getnint LDAP_P(( BerElement *ber, long *num, int len )); /* return the tag - LBER_DEFAULT returned means trouble */ unsigned long @@ -58,7 +36,10 @@ ber_get_tag( BerElement *ber ) unsigned char xbyte; unsigned long tag; char *tagp; - int i; + unsigned int i; + + assert( ber != NULL ); + assert( BER_VALID( ber ) ); if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) return( LBER_DEFAULT ); @@ -91,9 +72,14 @@ ber_skip_tag( BerElement *ber, unsigned { unsigned long tag; unsigned char lc; - int noctets, diff; + unsigned int noctets; + int diff; unsigned long netlen; + assert( ber != NULL ); + assert( len != NULL ); + assert( BER_VALID( ber ) ); + /* * Any ber element looks like this: tag length contents. * Assuming everything's ok, we return the tag byte (we @@ -121,15 +107,15 @@ ber_skip_tag( BerElement *ber, unsigned *len = netlen = 0; if ( ber_read( ber, (char *) &lc, 1 ) != 1 ) return( LBER_DEFAULT ); - if ( lc & 0x80 ) { - noctets = (lc & 0x7f); - if ( noctets > sizeof(unsigned long) ) + if ( lc & 0x80U ) { + noctets = (lc & 0x7fU); + if ( (unsigned) noctets > sizeof(unsigned long) ) return( LBER_DEFAULT ); diff = sizeof(unsigned long) - noctets; - if ( ber_read( ber, (char *) &netlen + diff, noctets ) + if ( (unsigned) ber_read( ber, (char *) &netlen + diff, noctets ) != noctets ) return( LBER_DEFAULT ); - *len = LBER_NTOHL( netlen ); + *len = AC_NTOHL( netlen ); } else { *len = lc; } @@ -138,15 +124,27 @@ ber_skip_tag( BerElement *ber, unsigned } 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; + 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 ); - ber->ber_ptr = save; + ber_free( ber, 0 ); return( tag ); } @@ -155,6 +153,12 @@ ber_getnint( BerElement *ber, long *num, { int diff, sign, i; long netnum; + char *p; + + assert( ber != NULL ); + assert( num != NULL ); + + assert( BER_VALID( ber ) ); /* * The tag and length have already been stripped off. We should @@ -163,7 +167,7 @@ ber_getnint( BerElement *ber, long *num, * extend after we read it in. */ - if ( len > sizeof(long) ) + if ( (unsigned) len > sizeof(long) ) return( -1 ); netnum = 0; @@ -172,14 +176,15 @@ ber_getnint( BerElement *ber, long *num, if ( ber_read( ber, ((char *) &netnum) + diff, len ) != len ) return( -1 ); - /* sign extend if necessary */ - sign = ((0x80 << ((len - 1) * 8)) & netnum); - if ( sign && len < sizeof(long) ) { - for ( i = sizeof(long) - 1; i > len - 1; i-- ) { - netnum |= (0xffL << (i * 8)); + /* sign extend if necessary */ + p = (char *) &netnum; + sign = (0x80 & *(p+diff) ); + if ( sign && ((unsigned) len < sizeof(long)) ) { + for ( i = 0; i < diff; i++ ) { + *(p+i) = (unsigned char) 0xff; } } - *num = LBER_NTOHL( netnum ); + *num = AC_NTOHL( netnum ); return( len ); } @@ -189,10 +194,13 @@ ber_get_int( BerElement *ber, long *num { unsigned long tag, len; + assert( ber != NULL ); + assert( BER_VALID( ber ) ); + if ( (tag = ber_skip_tag( ber, &len )) == 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 ); else return( tag ); @@ -206,19 +214,22 @@ ber_get_stringb( BerElement *ber, char * char *transbuf; #endif /* STR_TRANSLATION */ + assert( ber != NULL ); + assert( BER_VALID( ber ) ); + if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) return( LBER_DEFAULT ); if ( datalen > (*len - 1) ) return( LBER_DEFAULT ); - if ( ber_read( ber, buf, datalen ) != datalen ) + if ( (unsigned long) ber_read( ber, buf, datalen ) != datalen ) return( LBER_DEFAULT ); buf[datalen] = '\0'; #ifdef STR_TRANSLATION if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0 - && ber->ber_decode_translate_proc != NULL ) { + && ber->ber_decode_translate_proc ) { transbuf = buf; ++datalen; if ( (*(ber->ber_decode_translate_proc))( &transbuf, &datalen, @@ -226,11 +237,11 @@ ber_get_stringb( BerElement *ber, char * return( LBER_DEFAULT ); } if ( datalen > *len ) { - free( transbuf ); + LBER_FREE( transbuf ); return( LBER_DEFAULT ); } SAFEMEMCPY( buf, transbuf, datalen ); - free( transbuf ); + LBER_FREE( transbuf ); --datalen; } #endif /* STR_TRANSLATION */ @@ -244,23 +255,34 @@ ber_get_stringa( BerElement *ber, char * { unsigned long datalen, tag; - if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) + assert( ber != NULL ); + assert( buf != NULL ); + + assert( BER_VALID( ber ) ); + + if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) { + *buf = NULL; 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 ); - if ( ber_read( ber, *buf, datalen ) != datalen ) + if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) { + LBER_FREE( *buf ); + *buf = NULL; return( LBER_DEFAULT ); + } (*buf)[datalen] = '\0'; #ifdef STR_TRANSLATION if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0 - && ber->ber_decode_translate_proc != NULL ) { + && ber->ber_decode_translate_proc ) { ++datalen; if ( (*(ber->ber_decode_translate_proc))( buf, &datalen, 1 ) != 0 ) { - free( *buf ); + LBER_FREE( *buf ); + *buf = NULL; return( LBER_DEFAULT ); } } @@ -274,27 +296,41 @@ ber_get_stringal( BerElement *ber, struc { unsigned long len, tag; - if ( (*bv = (struct berval *) malloc( sizeof(struct berval) )) == NULL ) + assert( ber != NULL ); + assert( bv != NULL ); + + assert( BER_VALID( ber ) ); + + if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) { + *bv = NULL; return( LBER_DEFAULT ); + } - if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) + if ( (*bv = (struct berval *) LBER_MALLOC( sizeof(struct berval) )) == NULL ) 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 ) { + LBER_FREE( *bv ); + *bv = NULL; 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 ); + } ((*bv)->bv_val)[len] = '\0'; (*bv)->bv_len = len; #ifdef STR_TRANSLATION if ( len > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0 - && ber->ber_decode_translate_proc != NULL ) { + && ber->ber_decode_translate_proc ) { ++len; if ( (*(ber->ber_decode_translate_proc))( &((*bv)->bv_val), &len, 1 ) != 0 ) { - free( (*bv)->bv_val ); + ber_bvfree( *bv ); + *bv = NULL; return( LBER_DEFAULT ); } (*bv)->bv_len = len - 1; @@ -310,18 +346,32 @@ ber_get_bitstringa( BerElement *ber, cha unsigned long datalen, tag; unsigned char unusedbits; - if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) + assert( ber != NULL ); + assert( buf != NULL ); + assert( blen != NULL ); + + assert( BER_VALID( ber ) ); + + if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) { + *buf = NULL; return( LBER_DEFAULT ); + } --datalen; - if ( (*buf = (char *) malloc( (size_t)datalen )) == NULL ) + if ( (*buf = (char *) LBER_MALLOC( (size_t)datalen )) == NULL ) return( LBER_DEFAULT ); - if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) + if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) { + LBER_FREE( buf ); + *buf = NULL; return( LBER_DEFAULT ); + } - if ( ber_read( ber, *buf, datalen ) != datalen ) + if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) { + LBER_FREE( buf ); + *buf = NULL; return( LBER_DEFAULT ); + } *blen = datalen * 8 - unusedbits; return( tag ); @@ -332,6 +382,9 @@ ber_get_null( BerElement *ber ) { unsigned long len, tag; + assert( ber != NULL ); + assert( BER_VALID( ber ) ); + if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) return( LBER_DEFAULT ); @@ -347,6 +400,11 @@ ber_get_boolean( BerElement *ber, int *b long longbool; int rc; + assert( ber != NULL ); + assert( boolval != NULL ); + + assert( BER_VALID( ber ) ); + rc = ber_get_int( ber, &longbool ); *boolval = longbool; @@ -356,8 +414,13 @@ ber_get_boolean( BerElement *ber, int *b unsigned long 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 */ if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) { + *last = NULL; return( LBER_DEFAULT ); } @@ -373,6 +436,12 @@ ber_first_element( BerElement *ber, unsi unsigned long 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 ) { return( LBER_DEFAULT ); } @@ -382,27 +451,30 @@ ber_next_element( BerElement *ber, unsig /* VARARGS */ unsigned long -ber_scanf( -#if defined( MACOS ) || defined( BC31 ) || defined( _WIN32 ) - BerElement *ber, char *fmt, ... ) +ber_scanf +#if HAVE_STDARG + ( BerElement *ber, + LDAP_CONST char *fmt, + ... ) #else - va_alist ) + ( va_alist ) va_dcl #endif { va_list ap; -#if !defined( MACOS ) && !defined( BC31 ) && !defined( _WIN32 ) +#ifndef HAVE_STDARG BerElement *ber; char *fmt; #endif + LDAP_CONST char *fmt_reset; char *last; char *s, **ss, ***sss; struct berval ***bv, **bvp, *bval; int *i, j; - long *l, rc, tag; - unsigned long len; + long *l; + unsigned long rc, tag, len; -#if defined( MACOS ) || defined( BC31 ) || defined( _WIN32 ) +#ifdef HAVE_STDARG va_start( ap, fmt ); #else va_start( ap ); @@ -410,15 +482,31 @@ va_dcl fmt = va_arg( ap, char * ); #endif -#ifdef LDAP_DEBUG - if ( lber_debug & 64 ) { - fprintf( stderr, "ber_scanf fmt (%s) ber:\n", fmt ); - ber_dump( ber, 1 ); - } -#endif + assert( ber != NULL ); + assert( fmt != NULL ); + + assert( BER_VALID( ber ) ); + + fmt_reset = fmt; + + 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++ ) { + /* When this is modified, remember to update + * the error-cleanup code below accordingly. */ 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 */ ss = va_arg( ap, char ** ); rc = ber_get_stringa( ber, ss ); @@ -437,7 +525,7 @@ va_dcl case 'l': /* length of next item */ l = va_arg( ap, long * ); - rc = ber_peek_tag( ber, (unsigned long *)l ); + rc = ber_peek_tag( ber, l ); break; case 'n': /* null */ @@ -447,7 +535,7 @@ va_dcl case 's': /* octet string - in a buffer */ s = va_arg( ap, char * ); l = va_arg( ap, long * ); - rc = ber_get_stringb( ber, s, (unsigned long *)l ); + rc = ber_get_stringb( ber, s, l ); break; case 'o': /* octet string in a supplied berval */ @@ -464,17 +552,17 @@ va_dcl case 'B': /* bit string - allocate storage as needed */ ss = va_arg( ap, char ** ); 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; case 't': /* tag of next item */ - i = va_arg( ap, int * ); - *i = rc = ber_peek_tag( ber, &len ); + l = va_arg( ap, long * ); + *l = rc = ber_peek_tag( ber, &len ); break; case 'T': /* skip tag of next item */ - i = va_arg( ap, int * ); - *i = rc = ber_skip_tag( ber, &len ); + l = va_arg( ap, long * ); + *l = rc = ber_skip_tag( ber, &len ); break; case 'v': /* sequence of strings */ @@ -483,14 +571,11 @@ va_dcl j = 0; for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT && rc != LBER_DEFAULT; - tag = ber_next_element( ber, &len, last ) ) { - if ( *sss == NULL ) { - *sss = (char **) malloc( - 2 * sizeof(char *) ); - } else { - *sss = (char **) realloc( *sss, - (j + 2) * sizeof(char *) ); - } + tag = ber_next_element( ber, &len, last ) ) + { + *sss = (char **) LBER_REALLOC( *sss, + (j + 2) * sizeof(char *) ); + rc = ber_get_stringa( ber, &((*sss)[j]) ); j++; } @@ -504,14 +589,11 @@ va_dcl j = 0; for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT && rc != LBER_DEFAULT; - tag = ber_next_element( ber, &len, last ) ) { - if ( *bv == NULL ) { - *bv = (struct berval **) malloc( - 2 * sizeof(struct berval *) ); - } else { - *bv = (struct berval **) realloc( *bv, - (j + 2) * sizeof(struct berval *) ); - } + tag = ber_next_element( ber, &len, last ) ) + { + *bv = (struct berval **) LBER_REALLOC( *bv, + (j + 2) * sizeof(struct berval *) ); + rc = ber_get_stringal( ber, &((*bv)[j]) ); j++; } @@ -536,9 +618,10 @@ va_dcl break; default: -#ifndef NO_USERINTERFACE - fprintf( stderr, "unknown fmt %c\n", *fmt ); -#endif /* NO_USERINTERFACE */ + if( ber->ber_debug ) { + ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug, + "ber_scanf: unknown fmt %c\n", *fmt ); + } rc = LBER_DEFAULT; break; } @@ -546,44 +629,120 @@ va_dcl va_end( ap ); - return( rc ); -} + 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 -void -ber_bvfree( struct berval *bv ) -{ - if ( bv->bv_val != NULL ) - free( bv->bv_val ); - free( (char *) bv ); -} + for ( ; fmt_reset < fmt; fmt_reset++ ) { + switch ( *fmt_reset ) { + case '!': { /* Hook */ + BERDecodeCallback *f; + void *p; -void -ber_bvecfree( struct berval **bv ) -{ - int i; + f = va_arg( ap, BERDecodeCallback * ); + p = va_arg( ap, void * ); - for ( i = 0; bv[i] != NULL; i++ ) - ber_bvfree( bv[i] ); - free( (char *) bv ); -} + (void) (*f)( ber, p, 1 ); + } break; -struct berval * -ber_bvdup( struct berval *bv ) -{ - struct berval *new; + case 'a': /* octet string - allocate storage as needed */ + ss = va_arg( ap, char ** ); + if ( *ss ) { + LBER_FREE( *ss ); + *ss = NULL; + } + break; - if ( (new = (struct berval *) malloc( sizeof(struct berval) )) - == NULL ) { - return( NULL ); - } - if ( (new->bv_val = (char *) malloc( bv->bv_len + 1 )) == NULL ) { - return( NULL ); + 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 ) { + LBER_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 ) { + LBER_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++) { + LBER_FREE( (*sss)[j] ); + (*sss)[j] = NULL; + } + LBER_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 ); } - SAFEMEMCPY( new->bv_val, bv->bv_val, (size_t) bv->bv_len ); - new->bv_val[bv->bv_len] = '\0'; - new->bv_len = bv->bv_len; - return( new ); + return( rc ); } @@ -592,6 +751,9 @@ void ber_set_string_translators( BerElement *ber, BERTranslateProc encode_proc, BERTranslateProc decode_proc ) { + assert( ber != NULL ); + assert( BER_VALID( ber ) ); + ber->ber_encode_translate_proc = encode_proc; ber->ber_decode_translate_proc = decode_proc; }