--- libraries/liblber/decode.c 2002/01/03 01:53:41 1.71 +++ libraries/liblber/decode.c 2009/08/13 00:56:58 1.105.2.8 @@ -1,11 +1,19 @@ /* decode.c - ber input decoding routines */ -/* $OpenLDAP: pkg/ldap/libraries/liblber/decode.c,v 1.70 2002/01/02 16:06:56 kurt Exp $ */ -/* - * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved. - * COPYING RESTRICTIONS APPLY, see COPYRIGHT file +/* $OpenLDAP: pkg/ldap/libraries/liblber/decode.c,v 1.105.2.7 2009/08/02 21:06:33 quanah Exp $ */ +/* This work is part of OpenLDAP Software . + * + * Copyright 1998-2009 The OpenLDAP Foundation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted only as authorized by the OpenLDAP + * Public License. + * + * A copy of this license is available in the file LICENSE in the + * top-level directory of the distribution or, alternatively, at + * . */ -/* Portions - * Copyright (c) 1990 Regents of the University of Michigan. +/* Portions Copyright (c) 1990 Regents of the University of Michigan. * All rights reserved. * * Redistribution and use in source and binary forms are permitted @@ -15,136 +23,212 @@ * software without specific prior written permission. This software * is provided ``as is'' without express or implied warranty. */ +/* ACKNOWLEDGEMENTS: + * This work was originally developed by the University of Michigan + * (as part of U-MICH LDAP). + */ #include "portable.h" #include #include - #include #include #include #include "lber-int.h" -static ber_len_t ber_getnint LDAP_P(( - BerElement *ber, - ber_int_t *num, - ber_len_t len )); -/* return the tag - LBER_DEFAULT returned means trouble */ -ber_tag_t -ber_get_tag( BerElement *ber ) +/* out->bv_len should be the buffer size on input */ +int +ber_decode_oid( BerValue *in, BerValue *out ) +{ + const unsigned char *der; + unsigned long val; + unsigned val1; + ber_len_t i; + char *ptr; + + assert( in != NULL ); + assert( out != NULL ); + + /* need 4 chars/inbyte + \0 for input={7f 7f 7f...} */ + if ( !out->bv_val || (out->bv_len+3)/4 <= in->bv_len ) + return -1; + + ptr = NULL; + der = (unsigned char *) in->bv_val; + val = 0; + for ( i=0; i < in->bv_len; i++ ) { + val |= der[i] & 0x7f; + if ( !( der[i] & 0x80 )) { + if ( ptr == NULL ) { + /* Initial "x.y": val=x*40+y, x<=2, y<40 if x<2 */ + ptr = out->bv_val; + val1 = (val < 80 ? val/40 : 2); + val -= val1*40; + ptr += sprintf( ptr, "%u", val1 ); + } + ptr += sprintf( ptr, ".%lu", val ); + val = 0; + } else if ( val - 1UL < LBER_OID_COMPONENT_MAX >> 7 ) { + val <<= 7; + } else { + /* val would overflow, or is 0 from invalid initial 0x80 octet */ + return -1; + } + } + if ( ptr == NULL || val != 0 ) + return -1; + + out->bv_len = ptr - out->bv_val; + return 0; +} + +/* Return tag, with *bv = rest of element (starting at length octets) */ +static ber_tag_t +ber_tag_and_rest( const BerElement *ber, struct berval *bv ) { - unsigned char xbyte; ber_tag_t tag; - unsigned int i; + ptrdiff_t rest; + unsigned char *ptr; assert( ber != NULL ); assert( LBER_VALID( ber ) ); - if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) { - return LBER_DEFAULT; + ptr = (unsigned char *) ber->ber_ptr; + rest = (unsigned char *) ber->ber_end - ptr; + if ( rest <= 0 ) { + goto fail; } - tag = xbyte; - - if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK ) { - return tag; + tag = ber->ber_tag; + if ( (char *) ptr == ber->ber_buf ) { + tag = *ptr; + } + ptr++; + rest--; + if ( (tag & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK ) { + goto done; } - for ( i = 1; i < sizeof(ber_tag_t); i++ ) { - if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) { - return LBER_DEFAULT; + do { + if ( rest <= 0 ) { + break; } - tag <<= 8; - tag |= 0x00ffUL & (ber_tag_t) xbyte; + tag |= *ptr++ & 0xffU; + rest--; - if ( ! (xbyte & LBER_MORE_TAG_MASK) ) { - break; + if ( ! (tag & LBER_MORE_TAG_MASK) ) { + goto done; } - } + } while ( tag <= (ber_tag_t)-1 / 256 ); - /* tag too big! */ - if ( i == sizeof(ber_tag_t) ) { - return LBER_DEFAULT; - } + fail: + /* Error or unsupported tag size */ + tag = LBER_DEFAULT; + + done: + bv->bv_len = rest; + bv->bv_val = (char *) ptr; + return tag; +} + +/* Return the tag - LBER_DEFAULT returned means trouble */ +ber_tag_t +ber_get_tag( BerElement *ber ) +{ + struct berval bv; + ber_tag_t tag = ber_tag_and_rest( ber, &bv ); + ber->ber_ptr = bv.bv_val; return tag; } +/* Return next element's tag and point *bv at its contents in-place */ ber_tag_t -ber_skip_tag( BerElement *ber, ber_len_t *len ) +ber_peek_element( const BerElement *ber, struct berval *bv ) { ber_tag_t tag; - unsigned char lc; - ber_len_t i, noctets; - unsigned char netlen[sizeof(ber_len_t)]; + ber_len_t len, rest; + unsigned i; + unsigned char *ptr; - assert( ber != NULL ); - assert( len != NULL ); - assert( LBER_VALID( ber ) ); + assert( bv != NULL ); /* * Any ber element looks like this: tag length contents. - * Assuming everything's ok, we return the tag byte (we - * can assume a single byte), and return the length in len. + * Assuming everything's ok, we return the tag, and point + * bv at the contents. * * Assumptions: * 1) definite lengths * 2) primitive encodings used whenever possible */ - *len = 0; + len = 0; /* * First, we read the tag. */ + tag = ber_tag_and_rest( ber, bv ); - if ( (tag = ber_get_tag( ber )) == LBER_DEFAULT ) { - return LBER_DEFAULT; + rest = bv->bv_len; + ptr = (unsigned char *) bv->bv_val; + if ( tag == LBER_DEFAULT || rest == 0 ) { + goto fail; } /* - * Next, read the length. The first byte contains the length of - * the length. If bit 8 is set, the length is the long form, - * otherwise it's the short form. We don't allow a length that's - * greater than what we can hold in a ber_len_t. + * Next, read the length. The first octet determines the length + * of the length. If bit 8 is 0, the length is the short form, + * otherwise if the octet != 0x80 it's the long form, otherwise + * the ber element has the unsupported indefinite-length format. + * Lengths that do not fit in a ber_len_t are not accepted. */ - if ( ber_read( ber, (char *) &lc, 1 ) != 1 ) - return LBER_DEFAULT; - - if ( lc & 0x80U ) { - noctets = (lc & 0x7fU); + len = *ptr++; + rest--; - if ( noctets > sizeof(ber_len_t) ) { - return LBER_DEFAULT; - } - - if( (unsigned) ber_read( ber, netlen, noctets ) != noctets ) { - return LBER_DEFAULT; + if ( len & 0x80U ) { + len &= 0x7fU; + if ( len - 1U > sizeof(ber_len_t) - 1U || rest < len ) { + /* Indefinite-length/too long length/not enough data */ + goto fail; } - for( i = 0; i < noctets; i++ ) { - *len <<= 8; - *len |= netlen[i]; + rest -= len; + i = len; + for( len = *ptr++ & 0xffU; --i; len |= *ptr++ & 0xffU ) { + len <<= 8; } - - } else { - *len = lc; } - /* BER length should be non-negative */ - if( *len < 0 ) { - return LBER_DEFAULT; + /* BER element should have enough data left */ + if( len > rest ) { + fail: + tag = LBER_DEFAULT; } - /* BER element should have enough data left */ - if( *len > (ber_len_t) ber_pvt_ber_remaining( ber ) ) { - return LBER_DEFAULT; + bv->bv_len = len; + bv->bv_val = (char *) ptr; + return tag; +} + +/* Move past next element, point *bv at it in-place, and return its tag. + * The caller may \0-terminate *bv, as next octet is saved in ber->ber_tag. + * Similar to ber_get_stringbv(ber, bv, LBER_BV_NOTERM) except on error. + */ +ber_tag_t +ber_skip_element( BerElement *ber, struct berval *bv ) +{ + ber_tag_t tag = ber_peek_element( ber, bv ); + + if ( tag != LBER_DEFAULT ) { + ber->ber_ptr = bv->bv_val + bv->bv_len; + ber->ber_tag = *(unsigned char *) ber->ber_ptr; } return tag; @@ -155,56 +239,54 @@ ber_peek_tag( BerElement *ber, ber_len_t *len ) { - /* - * This implementation assumes ber_skip_tag() only - * modifies ber_ptr field of the BerElement. - */ + struct berval bv; + ber_tag_t tag = ber_peek_element( ber, &bv ); - char *save; - ber_tag_t tag; + *len = bv.bv_len; + return tag; +} - save = ber->ber_ptr; - tag = ber_skip_tag( ber, len ); - ber->ber_ptr = save; +ber_tag_t +ber_skip_tag( BerElement *ber, ber_len_t *lenp ) +{ + struct berval bv; + ber_tag_t tag = ber_peek_element( ber, &bv ); + ber->ber_ptr = bv.bv_val; + ber->ber_tag = *(unsigned char *) ber->ber_ptr; + + *lenp = bv.bv_len; return tag; } -static ber_len_t -ber_getnint( +ber_tag_t +ber_get_int( BerElement *ber, - ber_int_t *num, - ber_len_t len ) + ber_int_t *num ) { - unsigned char buf[sizeof(ber_int_t)]; + ber_tag_t tag; + ber_len_t len; + struct berval bv; - assert( ber != NULL ); assert( num != NULL ); - assert( LBER_VALID( ber ) ); - - /* - * The tag and length have already been stripped off. We should - * be sitting right before len bytes of 2's complement integer, - * ready to be read straight into an int. We may have to sign - * extend after we read it in. - */ - if ( len > sizeof(ber_int_t) ) { - return -1; - } - - /* read into the low-order bytes of our buffer */ - if ( (ber_len_t) ber_read( ber, (char *) buf, len ) != len ) { - return -1; + tag = ber_skip_element( ber, &bv ); + len = bv.bv_len; + if ( tag == LBER_DEFAULT || len > sizeof(ber_int_t) ) { + return LBER_DEFAULT; } + /* parse two's complement integer */ if( len ) { - /* sign extend if necessary */ + unsigned char *buf = (unsigned char *) bv.bv_val; ber_len_t i; - ber_int_t netnum = 0x80 & buf[0] ? -1 : 0; + ber_int_t netnum = buf[0] & 0xff; + + /* sign extend */ + netnum = (netnum ^ 0x80) - 0x80; /* shift in the bytes */ - for( i=0 ; i= *len ) { + if ( bv.bv_len >= *len ) { return LBER_DEFAULT; } - if ( (ber_len_t) ber_read( ber, buf, datalen ) != datalen ) { - return LBER_DEFAULT; - } + memcpy( buf, bv.bv_val, bv.bv_len ); + buf[bv.bv_len] = '\0'; - buf[datalen] = '\0'; - - *len = datalen; + *len = bv.bv_len; return tag; } -enum bgbvc { ChArray, BvArray, BvVec }; +/* Definitions for get_string vector + * + * ChArray, BvArray, and BvVec are self-explanatory. + * BvOff is a struct berval embedded in an array of larger structures + * of siz bytes at off bytes from the beginning of the struct. + */ +enum bgbvc { ChArray, BvArray, BvVec, BvOff }; +/* Use this single cookie for state, to keep actual + * stack use to the absolute minimum. + */ typedef struct bgbvr { - BerElement *ber; - enum bgbvc choice; - ber_tag_t tag; - ber_len_t len; - char *last; - union { - char ***c; - BVarray *ba; - struct berval ***bv; - } res; + const enum bgbvc choice; + const int alloc; /* choice == BvOff ? 0 : LBER_ALLOC */ + ber_len_t siz; /* input array element size, output count */ + ber_len_t off; /* BvOff offset to the struct berval */ + void *result; } bgbvr; -ber_tag_t -ber_get_stringbvr( bgbvr *b, int n ) +static ber_tag_t +ber_get_stringbvl( BerElement *ber, bgbvr *b ) { - struct berval bv; + int i = 0, n; + ber_tag_t tag; + ber_len_t tot_size = 0, siz = b->siz; + char *last, *orig; + struct berval bv, *bvp = NULL; + union stringbvl_u { + char **ca; /* ChArray */ + BerVarray ba; /* BvArray */ + struct berval **bv; /* BvVec */ + char *bo; /* BvOff */ + } res; + + tag = ber_skip_tag( ber, &bv.bv_len ); + + if ( tag != LBER_DEFAULT ) { + tag = 0; + orig = ber->ber_ptr; + last = orig + bv.bv_len; - if ( n ) - b->tag = ber_next_element( b->ber, &b->len, b->last ); - else - b->tag = ber_first_element( b->ber, &b->len, &b->last ); - - if ( b->tag == LBER_DEFAULT ) - { - if ( n == 0 ) { - *b->res.c = NULL; - return 0; + for ( ; ber->ber_ptr < last; i++, tot_size += siz ) { + if ( ber_skip_element( ber, &bv ) == LBER_DEFAULT ) + break; } - /* do the allocation */ - switch (b->choice) { - case ChArray: - *b->res.c = LBER_MALLOC( (n+1) * sizeof( char * )); - (*b->res.c)[n] = NULL; - break; - case BvArray: - *b->res.ba = LBER_MALLOC( (n+1) * sizeof( struct berval )); - (*b->res.ba)[n].bv_val = NULL; - break; - case BvVec: - *b->res.bv = LBER_MALLOC( (n+1) * sizeof( struct berval *)); - (*b->res.bv)[n] = NULL; - break; + if ( ber->ber_ptr != last ) { + i = 0; + tag = LBER_DEFAULT; } - return 0; + + ber->ber_ptr = orig; + ber->ber_tag = *(unsigned char *) orig; } - if ( ber_get_stringbv( b->ber, &bv ) == LBER_DEFAULT ) - return LBER_DEFAULT; + b->siz = i; + if ( i == 0 ) { + return tag; + } + + /* Allocate and NULL-terminate the result vector */ + b->result = ber_memalloc_x( tot_size + siz, ber->ber_memctx ); + if ( b->result == NULL ) { + return LBER_DEFAULT; + } + switch (b->choice) { + case ChArray: + res.ca = b->result; + res.ca[i] = NULL; + break; + case BvArray: + res.ba = b->result; + res.ba[i].bv_val = NULL; + break; + case BvVec: + res.bv = b->result; + res.bv[i] = NULL; + break; + case BvOff: + res.bo = (char *) b->result + b->off; + ((struct berval *) (res.bo + tot_size))->bv_val = NULL; + tot_size = 0; + break; + } + + n = 0; + do { + tag = ber_get_stringbv( ber, &bv, b->alloc ); + if ( tag == LBER_DEFAULT ) { + goto nomem; + } - b->tag = ber_get_stringbvr( b, n+1 ); - if ( b->tag == 0 ) - { /* store my result */ switch (b->choice) { case ChArray: - (*b->res.c)[n] = bv.bv_val; + res.ca[n] = bv.bv_val; break; case BvArray: - (*b->res.ba)[n] = bv; + res.ba[n] = bv; break; case BvVec: - (*b->res.bv)[n] = ber_bvdup( &bv ); + bvp = ber_memalloc_x( sizeof( struct berval ), + ber->ber_memctx ); + if ( !bvp ) { + ber_memfree_x( bv.bv_val, ber->ber_memctx ); + goto nomem; + } + res.bv[n] = bvp; + *bvp = bv; + break; + case BvOff: + *(struct berval *)(res.bo + tot_size) = bv; + tot_size += siz; break; } - } else { - LBER_FREE( bv.bv_val ); + } while (++n < i); + return tag; + +nomem: + if (b->choice != BvOff) { /* BvOff does not have b->alloc set */ + while (--n >= 0) { + switch(b->choice) { + case ChArray: + ber_memfree_x(res.ca[n], ber->ber_memctx); + break; + case BvArray: + ber_memfree_x(res.ba[n].bv_val, ber->ber_memctx); + break; + case BvVec: + ber_memfree_x(res.bv[n]->bv_val, ber->ber_memctx); + ber_memfree_x(res.bv[n], ber->ber_memctx); + break; + default: + break; + } + } } - return b->tag; + ber_memfree_x(b->result, ber->ber_memctx); + b->result = NULL; + return LBER_DEFAULT; } ber_tag_t -ber_get_stringbv( BerElement *ber, struct berval *bv ) +ber_get_stringbv( BerElement *ber, struct berval *bv, int option ) { ber_tag_t tag; + char *data; - assert( ber != NULL ); - assert( bv != NULL ); - - assert( LBER_VALID( ber ) ); - - if ( (tag = ber_skip_tag( ber, &bv->bv_len )) == LBER_DEFAULT ) { + tag = ber_skip_element( ber, bv ); + if ( tag == LBER_DEFAULT ) { bv->bv_val = NULL; - return LBER_DEFAULT; + return tag; } - if ( (bv->bv_val = (char *) LBER_MALLOC( bv->bv_len + 1 )) == NULL ) { - return LBER_DEFAULT; + data = bv->bv_val; + if ( option & LBER_BV_ALLOC ) { + bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1, + ber->ber_memctx ); + if ( bv->bv_val == NULL ) { + return LBER_DEFAULT; + } + + if ( bv->bv_len != 0 ) { + memcpy( bv->bv_val, data, bv->bv_len ); + } + data = bv->bv_val; } + if ( !( option & LBER_BV_NOTERM )) + data[bv->bv_len] = '\0'; - if ( bv->bv_len > 0 && (ber_len_t) ber_read( ber, bv->bv_val, - bv->bv_len ) != bv->bv_len ) { - LBER_FREE( bv->bv_val ); + return tag; +} + +ber_tag_t +ber_get_stringbv_null( BerElement *ber, struct berval *bv, int option ) +{ + ber_tag_t tag; + char *data; + + tag = ber_skip_element( ber, bv ); + if ( tag == LBER_DEFAULT || bv->bv_len == 0 ) { bv->bv_val = NULL; - return LBER_DEFAULT; + return tag; } - bv->bv_val[bv->bv_len] = '\0'; + + data = bv->bv_val; + if ( option & LBER_BV_ALLOC ) { + bv->bv_val = (char *) ber_memalloc_x( bv->bv_len + 1, + ber->ber_memctx ); + if ( bv->bv_val == NULL ) { + return LBER_DEFAULT; + } + + memcpy( bv->bv_val, data, bv->bv_len ); + data = bv->bv_val; + } + if ( !( option & LBER_BV_NOTERM )) + data[bv->bv_len] = '\0'; return tag; } @@ -389,7 +541,21 @@ ber_get_stringa( BerElement *ber, char * assert( buf != NULL ); - tag = ber_get_stringbv( ber, &bv ); + tag = ber_get_stringbv( ber, &bv, LBER_BV_ALLOC ); + *buf = bv.bv_val; + + return tag; +} + +ber_tag_t +ber_get_stringa_null( BerElement *ber, char **buf ) +{ + BerValue bv; + ber_tag_t tag; + + assert( buf != NULL ); + + tag = ber_get_stringbv_null( ber, &bv, LBER_BV_ALLOC ); *buf = bv.bv_val; return tag; @@ -403,14 +569,15 @@ ber_get_stringal( BerElement *ber, struc assert( ber != NULL ); assert( bv != NULL ); - *bv = (struct berval *) LBER_MALLOC( sizeof(struct berval) ); + *bv = (struct berval *) ber_memalloc_x( sizeof(struct berval), + ber->ber_memctx ); if ( *bv == NULL ) { return LBER_DEFAULT; } - tag = ber_get_stringbv( ber, *bv ); + tag = ber_get_stringbv( ber, *bv, LBER_BV_ALLOC ); if ( tag == LBER_DEFAULT ) { - LBER_FREE( *bv ); + ber_memfree_x( *bv, ber->ber_memctx ); *bv = NULL; } return tag; @@ -422,60 +589,46 @@ ber_get_bitstringa( char **buf, ber_len_t *blen ) { - ber_len_t datalen; ber_tag_t tag; + struct berval data; unsigned char unusedbits; - assert( ber != NULL ); assert( buf != NULL ); assert( blen != NULL ); - assert( LBER_VALID( ber ) ); - - if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) { - *buf = NULL; - return LBER_DEFAULT; + if ( (tag = ber_skip_element( ber, &data )) == LBER_DEFAULT ) { + goto fail; } - --datalen; - if ( (*buf = (char *) LBER_MALLOC( datalen )) == NULL ) { - return LBER_DEFAULT; + if ( --data.bv_len > (ber_len_t)-1 / 8 ) { + goto fail; } - - if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) { - LBER_FREE( buf ); - *buf = NULL; - return LBER_DEFAULT; + unusedbits = *(unsigned char *) data.bv_val++; + if ( unusedbits > 7 ) { + goto fail; } - if ( (ber_len_t) ber_read( ber, *buf, datalen ) != datalen ) { - LBER_FREE( buf ); - *buf = NULL; + *buf = (char *) ber_memalloc_x( data.bv_len, ber->ber_memctx ); + if ( *buf == NULL ) { return LBER_DEFAULT; } + memcpy( *buf, data.bv_val, data.bv_len ); - *blen = datalen * 8 - unusedbits; + *blen = data.bv_len * 8 - unusedbits; return tag; + + fail: + *buf = NULL; + return LBER_DEFAULT; } ber_tag_t ber_get_null( BerElement *ber ) { ber_len_t len; - ber_tag_t tag; - - assert( ber != NULL ); - assert( LBER_VALID( ber ) ); + ber_tag_t tag = ber_skip_tag( ber, &len ); - if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) { - return LBER_DEFAULT; - } - - if ( len != 0 ) { - return LBER_DEFAULT; - } - - return( tag ); + return( len == 0 ? tag : LBER_DEFAULT ); } ber_tag_t @@ -483,18 +636,7 @@ ber_get_boolean( BerElement *ber, ber_int_t *boolval ) { - ber_int_t longbool; - ber_tag_t rc; - - assert( ber != NULL ); - assert( boolval != NULL ); - - assert( LBER_VALID( ber ) ); - - rc = ber_get_int( ber, &longbool ); - *boolval = longbool; - - return rc; + return ber_get_int( ber, boolval ); } ber_tag_t @@ -503,8 +645,6 @@ ber_first_element( ber_len_t *len, char **last ) { - assert( ber != NULL ); - assert( len != NULL ); assert( last != NULL ); /* skip the sequence header, use the len to mark where to stop */ @@ -515,7 +655,7 @@ ber_first_element( *last = ber->ber_ptr + *len; - if ( *last == ber->ber_ptr ) { + if ( *len == 0 ) { return LBER_DEFAULT; } @@ -529,21 +669,16 @@ ber_next_element( LDAP_CONST char *last ) { assert( ber != NULL ); - assert( len != NULL ); assert( last != NULL ); - assert( LBER_VALID( ber ) ); - if ( ber->ber_ptr == last ) { + if ( ber->ber_ptr >= last ) { return LBER_DEFAULT; } return ber_peek_tag( ber, len ); } -/* Hopefully no one sends vectors with more elements than this */ -/* #define TMP_SLOTS 1024 */ - /* VARARGS */ ber_tag_t ber_scanf ( BerElement *ber, @@ -552,33 +687,27 @@ ber_scanf ( BerElement *ber, { va_list ap; LDAP_CONST char *fmt_reset; - char *last; char *s, **ss, ***sss; - struct berval ***bv, **bvp, *bval; + struct berval data, *bval, **bvp, ***bvpp; ber_int_t *i; - int j; ber_len_t *l; ber_tag_t *t; - ber_tag_t rc, tag; + ber_tag_t rc; ber_len_t len; va_start( ap, fmt ); assert( ber != NULL ); assert( fmt != NULL ); - assert( LBER_VALID( ber ) ); fmt_reset = fmt; -#ifdef NEW_LOGGING - LDAP_LOG(( "liblber", LDAP_LEVEL_ENTRY, "ber_scanf fmt (%s) ber:\n", fmt )); - BER_DUMP(( "liblber", LDAP_LEVEL_DETAIL2, ber, 1 )); -#else - 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 ); -#endif + if ( ber->ber_debug & (LDAP_DEBUG_TRACE|LDAP_DEBUG_BER)) { + 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 @@ -599,13 +728,25 @@ ber_scanf ( BerElement *ber, rc = ber_get_stringa( ber, ss ); break; + case 'A': /* octet string - allocate storage as needed, + * but return NULL if len == 0 */ + ss = va_arg( ap, char ** ); + rc = ber_get_stringa_null( ber, ss ); + break; + case 'b': /* boolean */ i = va_arg( ap, ber_int_t * ); rc = ber_get_boolean( ber, i ); break; + case 'B': /* bit string - allocate storage as needed */ + ss = va_arg( ap, char ** ); + l = va_arg( ap, ber_len_t * ); /* for length, in bits */ + rc = ber_get_bitstringa( ber, ss, l ); + break; + case 'e': /* enumerated */ - case 'i': /* int */ + case 'i': /* integer */ i = va_arg( ap, ber_int_t * ); rc = ber_get_int( ber, i ); break; @@ -615,19 +756,35 @@ ber_scanf ( BerElement *ber, rc = ber_peek_tag( ber, l ); break; - case 'n': /* null */ - rc = ber_get_null( ber ); + case 'm': /* octet string in berval, in-place */ + bval = va_arg( ap, struct berval * ); + rc = ber_get_stringbv( ber, bval, 0 ); break; - case 's': /* octet string - in a buffer */ - s = va_arg( ap, char * ); + case 'M': /* bvoffarray - must include address of + * a record len, and record offset. + * number of records will be returned thru + * len ptr on finish. parsed in-place. + */ + { + bgbvr cookie = { BvOff, 0 }; + bvp = va_arg( ap, struct berval ** ); l = va_arg( ap, ber_len_t * ); - rc = ber_get_stringb( ber, s, l ); + cookie.siz = *l; + cookie.off = va_arg( ap, ber_len_t ); + rc = ber_get_stringbvl( ber, &cookie ); + *bvp = cookie.result; + *l = cookie.siz; + break; + } + + case 'n': /* null */ + rc = ber_get_null( ber ); break; case 'o': /* octet string in a supplied berval */ bval = va_arg( ap, struct berval * ); - rc = ber_get_stringbv( ber, bval ); + rc = ber_get_stringbv( ber, bval, LBER_BV_ALLOC ); break; case 'O': /* octet string - allocate & include length */ @@ -635,10 +792,10 @@ ber_scanf ( BerElement *ber, rc = ber_get_stringal( ber, bvp ); break; - case 'B': /* bit string - allocate storage as needed */ - ss = va_arg( ap, char ** ); - l = va_arg( ap, ber_len_t * ); /* for length, in bits */ - rc = ber_get_bitstringa( ber, ss, l ); + case 's': /* octet string - in a buffer */ + s = va_arg( ap, char * ); + l = va_arg( ap, ber_len_t * ); + rc = ber_get_stringb( ber, s, l ); break; case 't': /* tag of next item */ @@ -653,127 +810,47 @@ ber_scanf ( BerElement *ber, case 'v': /* sequence of strings */ { -#ifdef TMP_SLOTS - char *tmp[TMP_SLOTS]; - sss = va_arg( ap, char *** ); - *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 ) ) - { - rc = ber_get_stringa( ber, &tmp[j] ); - j++; - assert(j < TMP_SLOTS); - } - if (j > 0 && rc != LBER_DEFAULT ) { - *sss = (char **)LBER_MALLOC( (j+1) * sizeof(char *)); - if (*sss == NULL) { - rc = LBER_DEFAULT; - } else { - (*sss)[j] = NULL; - for (j--; j>=0; j--) - (*sss)[j] = tmp[j]; - } - } - if ( rc == LBER_DEFAULT ) { - for (j--; j>=0; j--) - LBER_FREE(tmp[j]); - } -#else - bgbvr cookie = { ber, ChArray }; - cookie.res.c = va_arg( ap, char *** ); - rc = ber_get_stringbvr( &cookie, 0 ); -#endif + bgbvr cookie = { + ChArray, LBER_BV_ALLOC, sizeof( char * ) + }; + rc = ber_get_stringbvl( ber, &cookie ); + *(va_arg( ap, char *** )) = cookie.result; break; } case 'V': /* sequence of strings + lengths */ { -#ifdef TMP_SLOTS - struct berval *tmp[TMP_SLOTS]; - bv = va_arg( ap, struct berval *** ); - *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 ) ) - { - rc = ber_get_stringal( ber, &tmp[j] ); - j++; - assert( j < TMP_SLOTS); - } - if (j > 0 && rc != LBER_DEFAULT ) { - *bv = (struct berval **)LBER_MALLOC( (j+1) * sizeof(struct berval *)); - if (*bv == NULL) { - rc = LBER_DEFAULT; - } else { - (*bv)[j] = NULL; - for (j--; j>=0; j--) - (*bv)[j] = tmp[j]; - } - } - if ( rc == LBER_DEFAULT ) { - for (j--; j>=0; j--) - ber_bvfree(tmp[j]); - } -#else - bgbvr cookie = { ber, BvVec }; - cookie.res.bv = va_arg( ap, struct berval *** ); - rc = ber_get_stringbvr( &cookie, 0 ); -#endif + bgbvr cookie = { + BvVec, LBER_BV_ALLOC, sizeof( struct berval * ) + }; + rc = ber_get_stringbvl( ber, &cookie ); + *(va_arg( ap, struct berval *** )) = cookie.result; break; } case 'W': /* bvarray */ { -#ifdef TMP_SLOTS - struct berval tmp[TMP_SLOTS]; - bvp = va_arg( ap, struct berval ** ); - *bvp = NULL; - j = 0; - for ( tag = ber_first_element( ber, &len, &last ); - tag != LBER_DEFAULT && rc != LBER_DEFAULT; - tag = ber_next_element( ber, &len, last ) ) - { - rc = ber_get_stringbv( ber, &tmp[j] ); - j++; - assert( j < TMP_SLOTS); - } - if (j > 0 && rc != LBER_DEFAULT ) { - *bvp = (struct berval *)LBER_MALLOC( (j+1) * sizeof(struct berval)); - if (*bvp == NULL) { - rc = LBER_DEFAULT; - } else { - (*bvp)[j].bv_val = NULL; - (*bvp)[j].bv_len = 0; - for (j--; j>=0; j--) - (*bvp)[j] = tmp[j]; - } - } - if ( rc == LBER_DEFAULT ) { - for (j--; j>=0; j--) - LBER_FREE(tmp[j].bv_val); - } -#else - bgbvr cookie = { ber, BvArray }; - cookie.res.ba = va_arg( ap, struct berval ** ); - rc = ber_get_stringbvr( &cookie, 0 ); -#endif + bgbvr cookie = { + BvArray, LBER_BV_ALLOC, sizeof( struct berval ) + }; + rc = ber_get_stringbvl( ber, &cookie ); + *(va_arg( ap, struct berval ** )) = cookie.result; break; } case 'x': /* skip the next element - whatever it is */ - if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) - break; - ber->ber_ptr += len; + rc = ber_skip_element( ber, &data ); break; case '{': /* begin sequence */ case '[': /* begin set */ - if ( *(fmt + 1) != 'v' && *(fmt + 1) != 'V' - && *(fmt + 1) != 'W' ) + switch ( fmt[1] ) { + case 'v': case 'V': case 'W': case 'M': + break; + default: rc = ber_skip_tag( ber, &len ); + break; + } break; case '}': /* end sequence */ @@ -782,13 +859,8 @@ ber_scanf ( BerElement *ber, default: if( ber->ber_debug ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "liblber", LDAP_LEVEL_ERR, - "ber_scanf: unknown fmt %c\n", *fmt )); -#else ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug, "ber_scanf: unknown fmt %c\n", *fmt ); -#endif } rc = LBER_DEFAULT; break; @@ -796,14 +868,15 @@ ber_scanf ( BerElement *ber, } 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. - */ - va_start( ap, fmt ); + /* + * Error. Reclaim malloced memory that was given to the caller. + * Set allocated pointers to NULL, "data length" outvalues to 0. + */ + va_start( ap, fmt ); - for ( ; fmt_reset < fmt; fmt_reset++ ) { + for ( ; fmt_reset < fmt; fmt_reset++ ) { switch ( *fmt_reset ) { case '!': { /* Hook */ BERDecodeCallback *f; @@ -816,62 +889,82 @@ ber_scanf ( BerElement *ber, } break; case 'a': /* octet string - allocate storage as needed */ + case 'A': ss = va_arg( ap, char ** ); - if ( *ss ) { - LBER_FREE( *ss ); - *ss = NULL; - } + ber_memfree_x( *ss, ber->ber_memctx ); + *ss = NULL; break; case 'b': /* boolean */ case 'e': /* enumerated */ - case 'i': /* int */ - (void) va_arg( ap, int * ); + case 'i': /* integer */ + (void) va_arg( ap, ber_int_t * ); break; - case 's': /* octet string - in a buffer */ - (void) va_arg( ap, char * ); - (void) va_arg( ap, ber_len_t * ); + case 'l': /* length of next item */ + *(va_arg( ap, ber_len_t * )) = 0; break; - case 'l': /* length of next item */ - (void) va_arg( ap, ber_len_t * ); + case 'm': /* berval in-place */ + bval = va_arg( ap, struct berval * ); + BER_BVZERO( bval ); break; - case 't': /* tag of next item */ - case 'T': /* skip tag of next item */ - (void) va_arg( ap, ber_tag_t * ); + case 'M': /* BVoff array in-place */ + bvp = va_arg( ap, struct berval ** ); + ber_memfree_x( *bvp, ber->ber_memctx ); + *bvp = NULL; + *(va_arg( ap, ber_len_t * )) = 0; + (void) va_arg( ap, ber_len_t ); 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; + ber_memfree_x( bval->bv_val, ber->ber_memctx ); + BER_BVZERO( bval ); break; case 'O': /* octet string - allocate & include length */ bvp = va_arg( ap, struct berval ** ); - if ( *bvp ) { - ber_bvfree( *bvp ); - *bvp = NULL; - } + ber_bvfree_x( *bvp, ber->ber_memctx ); + *bvp = NULL; + break; + + case 's': /* octet string - in a buffer */ + (void) va_arg( ap, char * ); + *(va_arg( ap, ber_len_t * )) = 0; + break; + + case 't': /* tag of next item */ + case 'T': /* skip tag of next item */ + (void) va_arg( ap, ber_tag_t * ); break; case 'B': /* bit string - allocate storage as needed */ ss = va_arg( ap, char ** ); - if ( *ss ) { - LBER_FREE( *ss ); - *ss = NULL; - } + ber_memfree_x( *ss, ber->ber_memctx ); + *ss = NULL; *(va_arg( ap, ber_len_t * )) = 0; /* for length, in bits */ break; case 'v': /* sequence of strings */ + sss = va_arg( ap, char *** ); + ber_memvfree_x( (void **) *sss, ber->ber_memctx ); + *sss = NULL; + break; + case 'V': /* sequence of strings + lengths */ - case 'W': /* BVarray */ + bvpp = va_arg( ap, struct berval *** ); + ber_bvecfree_x( *bvpp, ber->ber_memctx ); + *bvpp = NULL; + break; + + case 'W': /* BerVarray */ + bvp = va_arg( ap, struct berval ** ); + ber_bvarray_free_x( *bvp, ber->ber_memctx ); + *bvp = NULL; + break; + case 'n': /* null */ case 'x': /* skip the next element - whatever it is */ case '{': /* begin sequence */ @@ -884,9 +977,9 @@ ber_scanf ( BerElement *ber, /* format should be good */ assert( 0 ); } - } + } - va_end( ap ); + va_end( ap ); } return rc;