1 /* decode.c - ber input decoding routines */
3 * Copyright (c) 1990 Regents of the University of Michigan.
6 * Redistribution and use in source and binary forms are permitted
7 * provided that this notice is preserved and that due credit is given
8 * to the University of Michigan at Ann Arbor. The name of the University
9 * may not be used to endorse or promote products derived from this
10 * software without specific prior written permission. This software
11 * is provided ``as is'' without express or implied warranty.
20 #if defined(NeXT) || defined(VMS)
22 #else /* next || vms */
26 #endif /* next || vms */
27 #if defined(BC31) || defined(_WIN32)
29 #else /* BC31 || _WIN32 */
31 #endif /* BC31 || _WIN32 */
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #include <netinet/in.h>
40 #if defined( DOS ) || defined( _WIN32 )
52 static int ber_getnint( BerElement *ber, long *num, int len );
53 #endif /* NEEDPROTOS */
56 /* return the tag - LBER_DEFAULT returned means trouble */
58 ber_get_tag( BerElement *ber )
65 if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
66 return( LBER_DEFAULT );
68 if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
69 return( (unsigned long) xbyte );
73 for ( i = 1; i < sizeof(long); i++ ) {
74 if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
75 return( LBER_DEFAULT );
79 if ( ! (xbyte & LBER_MORE_TAG_MASK) )
84 if ( i == sizeof(long) )
85 return( LBER_DEFAULT );
87 /* want leading, not trailing 0's */
88 return( tag >> (sizeof(long) - i - 1) );
92 ber_skip_tag( BerElement *ber, unsigned long *len )
100 * Any ber element looks like this: tag length contents.
101 * Assuming everything's ok, we return the tag byte (we
102 * can assume a single byte), and return the length in len.
105 * 1) definite lengths
106 * 2) primitive encodings used whenever possible
110 * First, we read the tag.
113 if ( (tag = ber_get_tag( ber )) == LBER_DEFAULT )
114 return( LBER_DEFAULT );
117 * Next, read the length. The first byte contains the length of
118 * the length. If bit 8 is set, the length is the long form,
119 * otherwise it's the short form. We don't allow a length that's
120 * greater than what we can hold in an unsigned long.
124 if ( ber_read( ber, (char *) &lc, 1 ) != 1 )
125 return( LBER_DEFAULT );
127 noctets = (lc & 0x7f);
128 if ( noctets > sizeof(unsigned long) )
129 return( LBER_DEFAULT );
130 diff = sizeof(unsigned long) - noctets;
131 if ( ber_read( ber, (char *) &netlen + diff, noctets )
133 return( LBER_DEFAULT );
134 *len = LBER_NTOHL( netlen );
143 ber_peek_tag( BerElement *ber, unsigned long *len )
149 tag = ber_skip_tag( ber, len );
156 ber_getnint( BerElement *ber, long *num, int len )
162 * The tag and length have already been stripped off. We should
163 * be sitting right before len bytes of 2's complement integer,
164 * ready to be read straight into an int. We may have to sign
165 * extend after we read it in.
168 if ( len > sizeof(long) )
172 diff = sizeof(long) - len;
173 /* read into the low-order bytes of netnum */
174 if ( ber_read( ber, ((char *) &netnum) + diff, len ) != len )
177 /* sign extend if necessary */
178 sign = ((0x80 << ((len - 1) * 8)) & netnum);
179 if ( sign && len < sizeof(long) ) {
180 for ( i = sizeof(long) - 1; i > len - 1; i-- ) {
181 netnum |= (0xffL << (i * 8));
184 *num = LBER_NTOHL( netnum );
190 ber_get_int( BerElement *ber, long *num )
192 unsigned long tag, len;
194 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
195 return( LBER_DEFAULT );
197 if ( ber_getnint( ber, num, (int)len ) != len )
198 return( LBER_DEFAULT );
204 ber_get_stringb( BerElement *ber, char *buf, unsigned long *len )
206 unsigned long datalen, tag;
207 #ifdef STR_TRANSLATION
209 #endif /* STR_TRANSLATION */
211 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
212 return( LBER_DEFAULT );
213 if ( datalen > (*len - 1) )
214 return( LBER_DEFAULT );
216 if ( ber_read( ber, buf, datalen ) != datalen )
217 return( LBER_DEFAULT );
221 #ifdef STR_TRANSLATION
222 if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
223 && ber->ber_decode_translate_proc != NULL ) {
226 if ( (*(ber->ber_decode_translate_proc))( &transbuf, &datalen,
228 return( LBER_DEFAULT );
230 if ( datalen > *len ) {
232 return( LBER_DEFAULT );
234 SAFEMEMCPY( buf, transbuf, datalen );
238 #endif /* STR_TRANSLATION */
245 ber_get_stringa( BerElement *ber, char **buf )
247 unsigned long datalen, tag;
249 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
250 return( LBER_DEFAULT );
252 if ( (*buf = (char *) malloc( (size_t)datalen + 1 )) == NULL )
253 return( LBER_DEFAULT );
255 if ( ber_read( ber, *buf, datalen ) != datalen )
256 return( LBER_DEFAULT );
257 (*buf)[datalen] = '\0';
259 #ifdef STR_TRANSLATION
260 if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
261 && ber->ber_decode_translate_proc != NULL ) {
263 if ( (*(ber->ber_decode_translate_proc))( buf, &datalen, 1 )
266 return( LBER_DEFAULT );
269 #endif /* STR_TRANSLATION */
275 ber_get_stringal( BerElement *ber, struct berval **bv )
277 unsigned long len, tag;
279 if ( (*bv = (struct berval *) malloc( sizeof(struct berval) )) == NULL )
280 return( LBER_DEFAULT );
282 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
283 return( LBER_DEFAULT );
285 if ( ((*bv)->bv_val = (char *) malloc( (size_t)len + 1 )) == NULL )
286 return( LBER_DEFAULT );
288 if ( ber_read( ber, (*bv)->bv_val, len ) != len )
289 return( LBER_DEFAULT );
290 ((*bv)->bv_val)[len] = '\0';
293 #ifdef STR_TRANSLATION
294 if ( len > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
295 && ber->ber_decode_translate_proc != NULL ) {
297 if ( (*(ber->ber_decode_translate_proc))( &((*bv)->bv_val),
299 free( (*bv)->bv_val );
300 return( LBER_DEFAULT );
302 (*bv)->bv_len = len - 1;
304 #endif /* STR_TRANSLATION */
310 ber_get_bitstringa( BerElement *ber, char **buf, unsigned long *blen )
312 unsigned long datalen, tag;
313 unsigned char unusedbits;
315 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
316 return( LBER_DEFAULT );
319 if ( (*buf = (char *) malloc( (size_t)datalen )) == NULL )
320 return( LBER_DEFAULT );
322 if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 )
323 return( LBER_DEFAULT );
325 if ( ber_read( ber, *buf, datalen ) != datalen )
326 return( LBER_DEFAULT );
328 *blen = datalen * 8 - unusedbits;
333 ber_get_null( BerElement *ber )
335 unsigned long len, tag;
337 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
338 return( LBER_DEFAULT );
341 return( LBER_DEFAULT );
347 ber_get_boolean( BerElement *ber, int *boolval )
352 rc = ber_get_int( ber, &longbool );
359 ber_first_element( BerElement *ber, unsigned long *len, char **last )
361 /* skip the sequence header, use the len to mark where to stop */
362 if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) {
363 return( LBER_DEFAULT );
366 *last = ber->ber_ptr + *len;
368 if ( *last == ber->ber_ptr ) {
369 return( LBER_DEFAULT );
372 return( ber_peek_tag( ber, len ) );
376 ber_next_element( BerElement *ber, unsigned long *len, char *last )
378 if ( ber->ber_ptr == last ) {
379 return( LBER_DEFAULT );
382 return( ber_peek_tag( ber, len ) );
388 #if defined( MACOS ) || defined( BC31 ) || defined( _WIN32 )
389 BerElement *ber, char *fmt, ... )
396 #if !defined( MACOS ) && !defined( BC31 ) && !defined( _WIN32 )
401 char *s, **ss, ***sss;
402 struct berval ***bv, **bvp, *bval;
407 #if defined( MACOS ) || defined( BC31 ) || defined( _WIN32 )
411 ber = va_arg( ap, BerElement * );
412 fmt = va_arg( ap, char * );
416 if ( lber_debug & 64 ) {
417 fprintf( stderr, "ber_scanf fmt (%s) ber:\n", fmt );
422 for ( rc = 0; *fmt && rc != LBER_DEFAULT; fmt++ ) {
424 case 'a': /* octet string - allocate storage as needed */
425 ss = va_arg( ap, char ** );
426 rc = ber_get_stringa( ber, ss );
429 case 'b': /* boolean */
430 i = va_arg( ap, int * );
431 rc = ber_get_boolean( ber, i );
434 case 'e': /* enumerated */
436 l = va_arg( ap, long * );
437 rc = ber_get_int( ber, l );
440 case 'l': /* length of next item */
441 l = va_arg( ap, long * );
442 rc = ber_peek_tag( ber, (unsigned long *)l );
446 rc = ber_get_null( ber );
449 case 's': /* octet string - in a buffer */
450 s = va_arg( ap, char * );
451 l = va_arg( ap, long * );
452 rc = ber_get_stringb( ber, s, (unsigned long *)l );
455 case 'o': /* octet string in a supplied berval */
456 bval = va_arg( ap, struct berval * );
457 ber_peek_tag( ber, &bval->bv_len );
458 rc = ber_get_stringa( ber, &bval->bv_val );
461 case 'O': /* octet string - allocate & include length */
462 bvp = va_arg( ap, struct berval ** );
463 rc = ber_get_stringal( ber, bvp );
466 case 'B': /* bit string - allocate storage as needed */
467 ss = va_arg( ap, char ** );
468 l = va_arg( ap, long * ); /* for length, in bits */
469 rc = ber_get_bitstringa( ber, ss, (unsigned long *)l );
472 case 't': /* tag of next item */
473 i = va_arg( ap, int * );
474 *i = rc = ber_peek_tag( ber, &len );
477 case 'T': /* skip tag of next item */
478 i = va_arg( ap, int * );
479 *i = rc = ber_skip_tag( ber, &len );
482 case 'v': /* sequence of strings */
483 sss = va_arg( ap, char *** );
486 for ( tag = ber_first_element( ber, &len, &last );
487 tag != LBER_DEFAULT && rc != LBER_DEFAULT;
488 tag = ber_next_element( ber, &len, last ) ) {
489 if ( *sss == NULL ) {
490 *sss = (char **) malloc(
491 2 * sizeof(char *) );
493 *sss = (char **) realloc( *sss,
494 (j + 2) * sizeof(char *) );
496 rc = ber_get_stringa( ber, &((*sss)[j]) );
503 case 'V': /* sequence of strings + lengths */
504 bv = va_arg( ap, struct berval *** );
507 for ( tag = ber_first_element( ber, &len, &last );
508 tag != LBER_DEFAULT && rc != LBER_DEFAULT;
509 tag = ber_next_element( ber, &len, last ) ) {
511 *bv = (struct berval **) malloc(
512 2 * sizeof(struct berval *) );
514 *bv = (struct berval **) realloc( *bv,
515 (j + 2) * sizeof(struct berval *) );
517 rc = ber_get_stringal( ber, &((*bv)[j]) );
524 case 'x': /* skip the next element - whatever it is */
525 if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
530 case '{': /* begin sequence */
531 case '[': /* begin set */
532 if ( *(fmt + 1) != 'v' && *(fmt + 1) != 'V' )
533 rc = ber_skip_tag( ber, &len );
536 case '}': /* end sequence */
537 case ']': /* end set */
541 #ifndef NO_USERINTERFACE
542 fprintf( stderr, "unknown fmt %c\n", *fmt );
543 #endif /* NO_USERINTERFACE */
555 ber_bvfree( struct berval *bv )
557 if ( bv->bv_val != NULL )
563 ber_bvecfree( struct berval **bv )
567 for ( i = 0; bv[i] != NULL; i++ )
573 ber_bvdup( struct berval *bv )
577 if ( (new = (struct berval *) malloc( sizeof(struct berval) ))
581 if ( (new->bv_val = (char *) malloc( bv->bv_len + 1 )) == NULL ) {
584 SAFEMEMCPY( new->bv_val, bv->bv_val, (size_t) bv->bv_len );
585 new->bv_val[bv->bv_len] = '\0';
586 new->bv_len = bv->bv_len;
592 #ifdef STR_TRANSLATION
594 ber_set_string_translators( BerElement *ber, BERTranslateProc encode_proc,
595 BERTranslateProc decode_proc )
597 ber->ber_encode_translate_proc = encode_proc;
598 ber->ber_decode_translate_proc = decode_proc;
600 #endif /* STR_TRANSLATION */