1 /* decode.c - ber input decoding routines */
3 * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
4 * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
7 * Copyright (c) 1990 Regents of the University of Michigan.
10 * Redistribution and use in source and binary forms are permitted
11 * provided that this notice is preserved and that due credit is given
12 * to the University of Michigan at Ann Arbor. The name of the University
13 * may not be used to endorse or promote products derived from this
14 * software without specific prior written permission. This software
15 * is provided ``as is'' without express or implied warranty.
23 #include <ac/stdarg.h>
25 #include <ac/string.h>
26 #include <ac/socket.h>
30 static int ber_getnint LDAP_P(( BerElement *ber, long *num, int len ));
32 /* return the tag - LBER_DEFAULT returned means trouble */
34 ber_get_tag( BerElement *ber )
41 assert( ber != NULL );
42 assert( BER_VALID( ber ) );
44 if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
45 return( LBER_DEFAULT );
47 if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
48 return( (unsigned long) xbyte );
52 for ( i = 1; i < sizeof(long); i++ ) {
53 if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
54 return( LBER_DEFAULT );
58 if ( ! (xbyte & LBER_MORE_TAG_MASK) )
63 if ( i == sizeof(long) )
64 return( LBER_DEFAULT );
66 /* want leading, not trailing 0's */
67 return( tag >> (sizeof(long) - i - 1) );
71 ber_skip_tag( BerElement *ber, unsigned long *len )
79 assert( ber != NULL );
80 assert( len != NULL );
81 assert( BER_VALID( ber ) );
84 * Any ber element looks like this: tag length contents.
85 * Assuming everything's ok, we return the tag byte (we
86 * can assume a single byte), and return the length in len.
90 * 2) primitive encodings used whenever possible
94 * First, we read the tag.
97 if ( (tag = ber_get_tag( ber )) == LBER_DEFAULT )
98 return( LBER_DEFAULT );
101 * Next, read the length. The first byte contains the length of
102 * the length. If bit 8 is set, the length is the long form,
103 * otherwise it's the short form. We don't allow a length that's
104 * greater than what we can hold in an unsigned long.
108 if ( ber_read( ber, (char *) &lc, 1 ) != 1 )
109 return( LBER_DEFAULT );
111 noctets = (lc & 0x7fU);
112 if ( (unsigned) noctets > sizeof(unsigned long) )
113 return( LBER_DEFAULT );
114 diff = sizeof(unsigned long) - noctets;
115 if ( (unsigned) ber_read( ber, (char *) &netlen + diff, noctets )
117 return( LBER_DEFAULT );
118 *len = AC_NTOHL( netlen );
128 LDAP_CONST BerElement *ber_in, /* not const per c-api-02 */
134 assert( ber_in != NULL );
135 assert( BER_VALID( ber_in ) );
137 ber = ber_dup( ber_in );
143 assert( BER_VALID( ber ) );
145 tag = ber_skip_tag( ber, len );
152 ber_getnint( BerElement *ber, long *num, int len )
158 assert( ber != NULL );
159 assert( num != NULL );
161 assert( BER_VALID( ber ) );
164 * The tag and length have already been stripped off. We should
165 * be sitting right before len bytes of 2's complement integer,
166 * ready to be read straight into an int. We may have to sign
167 * extend after we read it in.
170 if ( (unsigned) len > sizeof(long) )
174 diff = sizeof(long) - len;
175 /* read into the low-order bytes of netnum */
176 if ( ber_read( ber, ((char *) &netnum) + diff, len ) != len )
179 /* sign extend if necessary */
180 p = (char *) &netnum;
181 sign = (0x80 & *(p+diff) );
182 if ( sign && ((unsigned) len < sizeof(long)) ) {
183 for ( i = 0; i < diff; i++ ) {
184 *(p+i) = (unsigned char) 0xff;
187 *num = AC_NTOHL( netnum );
193 ber_get_int( BerElement *ber, long *num )
195 unsigned long tag, len;
197 assert( ber != NULL );
198 assert( BER_VALID( ber ) );
200 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
201 return( LBER_DEFAULT );
203 if ( (unsigned long) ber_getnint( ber, num, (int)len ) != len )
204 return( LBER_DEFAULT );
210 ber_get_stringb( BerElement *ber, char *buf, unsigned long *len )
212 unsigned long datalen, tag;
213 #ifdef STR_TRANSLATION
215 #endif /* STR_TRANSLATION */
217 assert( ber != NULL );
218 assert( BER_VALID( ber ) );
220 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
221 return( LBER_DEFAULT );
222 if ( datalen > (*len - 1) )
223 return( LBER_DEFAULT );
225 if ( (unsigned long) ber_read( ber, buf, datalen ) != datalen )
226 return( LBER_DEFAULT );
230 #ifdef STR_TRANSLATION
231 if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
232 && ber->ber_decode_translate_proc ) {
235 if ( (*(ber->ber_decode_translate_proc))( &transbuf, &datalen,
237 return( LBER_DEFAULT );
239 if ( datalen > *len ) {
240 LBER_FREE( transbuf );
241 return( LBER_DEFAULT );
243 SAFEMEMCPY( buf, transbuf, datalen );
244 LBER_FREE( transbuf );
247 #endif /* STR_TRANSLATION */
254 ber_get_stringa( BerElement *ber, char **buf )
256 unsigned long datalen, tag;
258 assert( ber != NULL );
259 assert( buf != NULL );
261 assert( BER_VALID( ber ) );
263 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) {
265 return( LBER_DEFAULT );
268 if ( (*buf = (char *) LBER_MALLOC( (size_t)datalen + 1 )) == NULL )
269 return( LBER_DEFAULT );
271 if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) {
274 return( LBER_DEFAULT );
276 (*buf)[datalen] = '\0';
278 #ifdef STR_TRANSLATION
279 if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
280 && ber->ber_decode_translate_proc ) {
282 if ( (*(ber->ber_decode_translate_proc))( buf, &datalen, 1 )
286 return( LBER_DEFAULT );
289 #endif /* STR_TRANSLATION */
295 ber_get_stringal( BerElement *ber, struct berval **bv )
297 unsigned long len, tag;
299 assert( ber != NULL );
300 assert( bv != NULL );
302 assert( BER_VALID( ber ) );
304 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT ) {
306 return( LBER_DEFAULT );
309 if ( (*bv = (struct berval *) LBER_MALLOC( sizeof(struct berval) )) == NULL )
310 return( LBER_DEFAULT );
312 if ( ((*bv)->bv_val = (char *) LBER_MALLOC( (size_t)len + 1 )) == NULL ) {
315 return( LBER_DEFAULT );
318 if ( (unsigned long) ber_read( ber, (*bv)->bv_val, len ) != len ) {
321 return( LBER_DEFAULT );
323 ((*bv)->bv_val)[len] = '\0';
326 #ifdef STR_TRANSLATION
327 if ( len > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
328 && ber->ber_decode_translate_proc ) {
330 if ( (*(ber->ber_decode_translate_proc))( &((*bv)->bv_val),
334 return( LBER_DEFAULT );
336 (*bv)->bv_len = len - 1;
338 #endif /* STR_TRANSLATION */
344 ber_get_bitstringa( BerElement *ber, char **buf, unsigned long *blen )
346 unsigned long datalen, tag;
347 unsigned char unusedbits;
349 assert( ber != NULL );
350 assert( buf != NULL );
351 assert( blen != NULL );
353 assert( BER_VALID( ber ) );
355 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT ) {
357 return( LBER_DEFAULT );
361 if ( (*buf = (char *) LBER_MALLOC( (size_t)datalen )) == NULL )
362 return( LBER_DEFAULT );
364 if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) {
367 return( LBER_DEFAULT );
370 if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) {
373 return( LBER_DEFAULT );
376 *blen = datalen * 8 - unusedbits;
381 ber_get_null( BerElement *ber )
383 unsigned long len, tag;
385 assert( ber != NULL );
386 assert( BER_VALID( ber ) );
388 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
389 return( LBER_DEFAULT );
392 return( LBER_DEFAULT );
398 ber_get_boolean( BerElement *ber, int *boolval )
403 assert( ber != NULL );
404 assert( boolval != NULL );
406 assert( BER_VALID( ber ) );
408 rc = ber_get_int( ber, &longbool );
415 ber_first_element( BerElement *ber, unsigned long *len, char **last )
417 assert( ber != NULL );
418 assert( len != NULL );
419 assert( last != NULL );
421 /* skip the sequence header, use the len to mark where to stop */
422 if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) {
424 return( LBER_DEFAULT );
427 *last = ber->ber_ptr + *len;
429 if ( *last == ber->ber_ptr ) {
430 return( LBER_DEFAULT );
433 return( ber_peek_tag( ber, len ) );
437 ber_next_element( BerElement *ber, unsigned long *len, char *last )
439 assert( ber != NULL );
440 assert( len != NULL );
441 assert( last != NULL );
443 assert( BER_VALID( ber ) );
445 if ( ber->ber_ptr == last ) {
446 return( LBER_DEFAULT );
449 return( ber_peek_tag( ber, len ) );
457 LDAP_CONST char *fmt,
469 LDAP_CONST char *fmt_reset;
471 char *s, **ss, ***sss;
472 struct berval ***bv, **bvp, *bval;
475 unsigned long rc, tag, len;
481 ber = va_arg( ap, BerElement * );
482 fmt = va_arg( ap, char * );
485 assert( ber != NULL );
486 assert( fmt != NULL );
488 assert( BER_VALID( ber ) );
492 ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
493 "ber_scanf fmt (%s) ber:\n", fmt );
494 ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
496 for ( rc = 0; *fmt && rc != LBER_DEFAULT; fmt++ ) {
497 /* When this is modified, remember to update
498 * the error-cleanup code below accordingly. */
500 case '!': { /* Hook */
501 BERDecodeCallback *f;
504 f = va_arg( ap, BERDecodeCallback * );
505 p = va_arg( ap, void * );
507 rc = (*f)( ber, p, 0 );
510 case 'a': /* octet string - allocate storage as needed */
511 ss = va_arg( ap, char ** );
512 rc = ber_get_stringa( ber, ss );
515 case 'b': /* boolean */
516 i = va_arg( ap, int * );
517 rc = ber_get_boolean( ber, i );
520 case 'e': /* enumerated */
522 l = va_arg( ap, long * );
523 rc = ber_get_int( ber, l );
526 case 'l': /* length of next item */
527 l = va_arg( ap, long * );
528 rc = ber_peek_tag( ber, l );
532 rc = ber_get_null( ber );
535 case 's': /* octet string - in a buffer */
536 s = va_arg( ap, char * );
537 l = va_arg( ap, long * );
538 rc = ber_get_stringb( ber, s, l );
541 case 'o': /* octet string in a supplied berval */
542 bval = va_arg( ap, struct berval * );
543 ber_peek_tag( ber, &bval->bv_len );
544 rc = ber_get_stringa( ber, &bval->bv_val );
547 case 'O': /* octet string - allocate & include length */
548 bvp = va_arg( ap, struct berval ** );
549 rc = ber_get_stringal( ber, bvp );
552 case 'B': /* bit string - allocate storage as needed */
553 ss = va_arg( ap, char ** );
554 l = va_arg( ap, long * ); /* for length, in bits */
555 rc = ber_get_bitstringa( ber, ss, l );
558 case 't': /* tag of next item */
559 l = va_arg( ap, long * );
560 *l = rc = ber_peek_tag( ber, &len );
563 case 'T': /* skip tag of next item */
564 l = va_arg( ap, long * );
565 *l = rc = ber_skip_tag( ber, &len );
568 case 'v': /* sequence of strings */
569 sss = va_arg( ap, char *** );
572 for ( tag = ber_first_element( ber, &len, &last );
573 tag != LBER_DEFAULT && rc != LBER_DEFAULT;
574 tag = ber_next_element( ber, &len, last ) )
576 *sss = (char **) LBER_REALLOC( *sss,
577 (j + 2) * sizeof(char *) );
579 rc = ber_get_stringa( ber, &((*sss)[j]) );
586 case 'V': /* sequence of strings + lengths */
587 bv = va_arg( ap, struct berval *** );
590 for ( tag = ber_first_element( ber, &len, &last );
591 tag != LBER_DEFAULT && rc != LBER_DEFAULT;
592 tag = ber_next_element( ber, &len, last ) )
594 *bv = (struct berval **) LBER_REALLOC( *bv,
595 (j + 2) * sizeof(struct berval *) );
597 rc = ber_get_stringal( ber, &((*bv)[j]) );
604 case 'x': /* skip the next element - whatever it is */
605 if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
610 case '{': /* begin sequence */
611 case '[': /* begin set */
612 if ( *(fmt + 1) != 'v' && *(fmt + 1) != 'V' )
613 rc = ber_skip_tag( ber, &len );
616 case '}': /* end sequence */
617 case ']': /* end set */
621 if( ber->ber_debug ) {
622 ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug,
623 "ber_scanf: unknown fmt %c\n", *fmt );
632 if ( rc == LBER_DEFAULT ) {
634 * Error. Reclaim malloced memory that was given to the caller.
635 * Set allocated pointers to NULL, "data length" outvalues to 0.
641 (void) va_arg( ap, BerElement * );
642 (void) va_arg( ap, char * );
645 for ( ; fmt_reset < fmt; fmt_reset++ ) {
646 switch ( *fmt_reset ) {
647 case '!': { /* Hook */
648 BERDecodeCallback *f;
651 f = va_arg( ap, BERDecodeCallback * );
652 p = va_arg( ap, void * );
654 (void) (*f)( ber, p, 1 );
657 case 'a': /* octet string - allocate storage as needed */
658 ss = va_arg( ap, char ** );
665 case 'b': /* boolean */
666 (void) va_arg( ap, int * );
669 case 's': /* octet string - in a buffer */
670 (void) va_arg( ap, char * );
671 (void) va_arg( ap, long * );
674 case 'e': /* enumerated */
676 case 'l': /* length of next item */
677 case 't': /* tag of next item */
678 case 'T': /* skip tag of next item */
679 (void) va_arg( ap, long * );
682 case 'o': /* octet string in a supplied berval */
683 bval = va_arg( ap, struct berval * );
684 if ( bval->bv_val != NULL ) {
685 LBER_FREE( bval->bv_val );
691 case 'O': /* octet string - allocate & include length */
692 bvp = va_arg( ap, struct berval ** );
699 case 'B': /* bit string - allocate storage as needed */
700 ss = va_arg( ap, char ** );
705 *(va_arg( ap, long * )) = 0; /* for length, in bits */
708 case 'v': /* sequence of strings */
709 sss = va_arg( ap, char *** );
711 for (j = 0; (*sss)[j]; j++) {
712 LBER_FREE( (*sss)[j] );
720 case 'V': /* sequence of strings + lengths */
721 bv = va_arg( ap, struct berval *** );
729 case 'x': /* skip the next element - whatever it is */
730 case '{': /* begin sequence */
731 case '[': /* begin set */
732 case '}': /* end sequence */
733 case ']': /* end set */
737 /* format should be good */
749 ber_bvfree( struct berval *bv )
751 assert(bv != NULL); /* bv damn better point to something */
753 ber_int_options.lbo_valid = LBER_INITIALIZED;
755 if ( bv->bv_val != NULL )
756 LBER_FREE( bv->bv_val );
757 LBER_FREE( (char *) bv );
761 ber_bvecfree( struct berval **bv )
765 assert(bv != NULL); /* bv damn better point to something */
767 ber_int_options.lbo_valid = LBER_INITIALIZED;
769 for ( i = 0; bv[i] != NULL; i++ )
771 LBER_FREE( (char *) bv );
776 LDAP_CONST struct berval *bv )
780 assert( bv != NULL );
782 ber_int_options.lbo_valid = LBER_INITIALIZED;
788 if ( (new = (struct berval *) LBER_MALLOC( sizeof(struct berval) ))
793 if ( bv->bv_val == NULL ) {
799 if ( (new->bv_val = (char *) LBER_MALLOC( bv->bv_len + 1 )) == NULL ) {
804 SAFEMEMCPY( new->bv_val, bv->bv_val, (size_t) bv->bv_len );
805 new->bv_val[bv->bv_len] = '\0';
806 new->bv_len = bv->bv_len;
812 #ifdef STR_TRANSLATION
814 ber_set_string_translators( BerElement *ber, BERTranslateProc encode_proc,
815 BERTranslateProc decode_proc )
817 assert( ber != NULL );
818 assert( BER_VALID( ber ) );
820 ber->ber_encode_translate_proc = encode_proc;
821 ber->ber_decode_translate_proc = decode_proc;
823 #endif /* STR_TRANSLATION */