X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Fliblber%2Fdecode.c;h=aa33b44dad33a9b27520c950d260963d579ba36a;hb=e8116a8a74fa6e056863c3c962b4fedcf5d93a00;hp=83242a02a875e23301d60ba6b423044c2acba92a;hpb=df38bf83e8babd8e53a661b986a48171975894b6;p=openldap diff --git a/libraries/liblber/decode.c b/libraries/liblber/decode.c index 83242a02a8..aa33b44dad 100644 --- a/libraries/liblber/decode.c +++ b/libraries/liblber/decode.c @@ -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,47 +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 */ -#ifndef __FreeBSD__ -#include -#endif -#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" - -#ifdef LDAP_DEBUG -int lber_debug; -#endif -#ifdef NEEDPROTOS -static int ber_getnint( BerElement *ber, long *num, int len ); -#endif /* NEEDPROTOS */ +#include +#include +#include + +#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 @@ -60,7 +36,9 @@ ber_get_tag( BerElement *ber ) unsigned char xbyte; unsigned long tag; char *tagp; - int i; + unsigned int i; + + assert( ber != NULL ); if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) return( LBER_DEFAULT ); @@ -93,9 +71,13 @@ ber_skip_tag( BerElement *ber, unsigned long *len ) { unsigned long tag; unsigned char lc; - int noctets, diff; + unsigned int noctets; + int diff; unsigned long netlen; + assert( ber != NULL ); + assert( len != NULL ); + /* * Any ber element looks like this: tag length contents. * Assuming everything's ok, we return the tag byte (we @@ -123,15 +105,15 @@ ber_skip_tag( BerElement *ber, unsigned long *len ) *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; } @@ -140,15 +122,24 @@ ber_skip_tag( BerElement *ber, unsigned long *len ) } 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 ); + + ber = ber_dup( ber_in ); + + if( ber == NULL ) { + return LBER_ERROR; + } - save = ber->ber_ptr; tag = ber_skip_tag( ber, len ); - ber->ber_ptr = save; + ber_free( ber, 0 ); return( tag ); } @@ -157,6 +148,10 @@ ber_getnint( BerElement *ber, long *num, int len ) { int diff, sign, i; long netnum; + char *p; + + assert( ber != NULL ); + assert( num != NULL ); /* * The tag and length have already been stripped off. We should @@ -165,7 +160,7 @@ ber_getnint( BerElement *ber, long *num, int len ) * extend after we read it in. */ - if ( len > sizeof(long) ) + if ( (unsigned) len > sizeof(long) ) return( -1 ); netnum = 0; @@ -174,14 +169,15 @@ ber_getnint( BerElement *ber, long *num, int len ) 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 ); } @@ -191,10 +187,12 @@ ber_get_int( BerElement *ber, long *num ) { unsigned long tag, len; + assert( ber != NULL ); + 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 ); @@ -208,19 +206,21 @@ ber_get_stringb( BerElement *ber, char *buf, unsigned long *len ) char *transbuf; #endif /* STR_TRANSLATION */ + assert( ber != NULL ); + 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, @@ -246,23 +246,32 @@ ber_get_stringa( BerElement *ber, char **buf ) { 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 ); + } if ( (*buf = (char *) 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 ) { + 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 ); + *buf = NULL; return( LBER_DEFAULT ); } } @@ -276,27 +285,39 @@ ber_get_stringal( BerElement *ber, struct berval **bv ) { 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 ); + } - if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) + if ( (*bv = (struct berval *) malloc( sizeof(struct berval) )) == NULL ) 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 ); + } - 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; @@ -312,18 +333,30 @@ ber_get_bitstringa( BerElement *ber, char **buf, unsigned long *blen ) 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 ); + + if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) { + *buf = NULL; return( LBER_DEFAULT ); + } --datalen; if ( (*buf = (char *) malloc( (size_t)datalen )) == NULL ) 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 ); + } - if ( ber_read( ber, *buf, datalen ) != datalen ) + if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) { + free( buf ); + *buf = NULL; return( LBER_DEFAULT ); + } *blen = datalen * 8 - unusedbits; return( tag ); @@ -334,6 +367,8 @@ ber_get_null( BerElement *ber ) { unsigned long len, tag; + assert( ber != NULL ); + if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) return( LBER_DEFAULT ); @@ -349,6 +384,9 @@ ber_get_boolean( BerElement *ber, int *boolval ) long longbool; int rc; + assert( ber != NULL ); + assert( boolval != NULL ); + rc = ber_get_int( ber, &longbool ); *boolval = longbool; @@ -358,15 +396,24 @@ ber_get_boolean( BerElement *ber, int *boolval ) 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 ); } *last = ber->ber_ptr + *len; if ( *last == ber->ber_ptr ) { +#ifdef LBER_END_SEQORSET + return( LBER_END_SEQORSET ); +#else return( LBER_DEFAULT ); +#endif } return( ber_peek_tag( ber, len ) ); @@ -375,8 +422,16 @@ ber_first_element( BerElement *ber, unsigned long *len, char **last ) unsigned long ber_next_element( BerElement *ber, unsigned long *len, char *last ) { + assert( ber != NULL ); + assert( len != NULL ); + assert( last != NULL ); + if ( ber->ber_ptr == last ) { +#ifdef LBER_END_SEQORSET + return( LBER_END_SEQORSET ); +#else return( LBER_DEFAULT ); +#endif } return( ber_peek_tag( ber, len ) ); @@ -384,27 +439,30 @@ ber_next_element( BerElement *ber, unsigned long *len, char *last ) /* 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 ); @@ -412,15 +470,29 @@ 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 ); + + 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 ); @@ -439,7 +511,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 */ @@ -449,7 +521,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 */ @@ -466,17 +538,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 */ @@ -484,8 +556,13 @@ va_dcl *sss = NULL; j = 0; for ( tag = ber_first_element( ber, &len, &last ); - tag != LBER_DEFAULT && rc != LBER_DEFAULT; - tag = ber_next_element( ber, &len, last ) ) { + tag != LBER_DEFAULT && +#ifdef LBER_END_SEQORSET + tag != LBER_END_SEQORSET && +#endif + rc != LBER_DEFAULT; + tag = ber_next_element( ber, &len, last ) ) + { if ( *sss == NULL ) { *sss = (char **) malloc( 2 * sizeof(char *) ); @@ -496,6 +573,13 @@ va_dcl rc = ber_get_stringa( ber, &((*sss)[j]) ); j++; } +#ifdef LBER_END_SEQORSET + if (rc != LBER_DEFAULT && + tag != LBER_END_SEQORSET ) + { + rc = LBER_DEFAULT; + } +#endif if ( j > 0 ) (*sss)[j] = NULL; break; @@ -505,8 +589,13 @@ va_dcl *bv = NULL; j = 0; for ( tag = ber_first_element( ber, &len, &last ); - tag != LBER_DEFAULT && rc != LBER_DEFAULT; - tag = ber_next_element( ber, &len, last ) ) { + tag != LBER_DEFAULT && +#ifdef LBER_END_SEQORSET + tag != LBER_END_SEQORSET && +#endif + rc != LBER_DEFAULT; + tag = ber_next_element( ber, &len, last ) ) + { if ( *bv == NULL ) { *bv = (struct berval **) malloc( 2 * sizeof(struct berval *) ); @@ -517,6 +606,13 @@ va_dcl rc = ber_get_stringal( ber, &((*bv)[j]) ); j++; } +#ifdef LBER_END_SEQORSET + if (rc != LBER_DEFAULT && + tag != LBER_END_SEQORSET ) + { + rc = LBER_DEFAULT; + } +#endif if ( j > 0 ) (*bv)[j] = NULL; break; @@ -538,9 +634,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; } @@ -548,12 +645,127 @@ va_dcl 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 ); } void ber_bvfree( struct berval *bv ) { + assert(bv != NULL); /* bv damn better point to something */ + if ( bv->bv_val != NULL ) free( bv->bv_val ); free( (char *) bv ); @@ -564,23 +776,41 @@ ber_bvecfree( struct berval **bv ) { int i; + assert(bv != NULL); /* bv damn better point to something */ + for ( i = 0; bv[i] != NULL; i++ ) ber_bvfree( bv[i] ); free( (char *) bv ); } struct berval * -ber_bvdup( struct berval *bv ) +ber_bvdup( + LDAP_CONST struct berval *bv ) { struct berval *new; + assert( bv != NULL ); + + if( bv == NULL ) { + return NULL; + } + if ( (new = (struct berval *) malloc( sizeof(struct berval) )) == 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 ) { + free( new ); return( NULL ); } + 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; @@ -594,6 +824,8 @@ void ber_set_string_translators( BerElement *ber, BERTranslateProc encode_proc, BERTranslateProc decode_proc ) { + assert( ber != NULL ); + ber->ber_encode_translate_proc = encode_proc; ber->ber_decode_translate_proc = decode_proc; }