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 )
163 * The tag and length have already been stripped off. We should
164 * be sitting right before len bytes of 2's complement integer,
165 * ready to be read straight into an int. We may have to sign
166 * extend after we read it in.
169 if ( len > sizeof(long) )
173 diff = sizeof(long) - len;
174 /* read into the low-order bytes of netnum */
175 if ( ber_read( ber, ((char *) &netnum) + diff, len ) != len )
178 /* sign extend if necessary */
179 p = (char *) &netnum;
180 sign = (0x80 & *(p+diff) );
181 if ( sign && len < sizeof(long) ) {
182 for ( i = 0; i < diff; i++ ) {
186 *num = LBER_NTOHL( netnum );
192 ber_get_int( BerElement *ber, long *num )
194 unsigned long tag, len;
196 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
197 return( LBER_DEFAULT );
199 if ( ber_getnint( ber, num, (int)len ) != len )
200 return( LBER_DEFAULT );
206 ber_get_stringb( BerElement *ber, char *buf, unsigned long *len )
208 unsigned long datalen, tag;
209 #ifdef STR_TRANSLATION
211 #endif /* STR_TRANSLATION */
213 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
214 return( LBER_DEFAULT );
215 if ( datalen > (*len - 1) )
216 return( LBER_DEFAULT );
218 if ( ber_read( ber, buf, datalen ) != datalen )
219 return( LBER_DEFAULT );
223 #ifdef STR_TRANSLATION
224 if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
225 && ber->ber_decode_translate_proc != NULL ) {
228 if ( (*(ber->ber_decode_translate_proc))( &transbuf, &datalen,
230 return( LBER_DEFAULT );
232 if ( datalen > *len ) {
234 return( LBER_DEFAULT );
236 SAFEMEMCPY( buf, transbuf, datalen );
240 #endif /* STR_TRANSLATION */
247 ber_get_stringa( BerElement *ber, char **buf )
249 unsigned long datalen, tag;
251 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
252 return( LBER_DEFAULT );
254 if ( (*buf = (char *) malloc( (size_t)datalen + 1 )) == NULL )
255 return( LBER_DEFAULT );
257 if ( ber_read( ber, *buf, datalen ) != datalen )
258 return( LBER_DEFAULT );
259 (*buf)[datalen] = '\0';
261 #ifdef STR_TRANSLATION
262 if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
263 && ber->ber_decode_translate_proc != NULL ) {
265 if ( (*(ber->ber_decode_translate_proc))( buf, &datalen, 1 )
268 return( LBER_DEFAULT );
271 #endif /* STR_TRANSLATION */
277 ber_get_stringal( BerElement *ber, struct berval **bv )
279 unsigned long len, tag;
281 if ( (*bv = (struct berval *) malloc( sizeof(struct berval) )) == NULL )
282 return( LBER_DEFAULT );
284 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
285 return( LBER_DEFAULT );
287 if ( ((*bv)->bv_val = (char *) malloc( (size_t)len + 1 )) == NULL )
288 return( LBER_DEFAULT );
290 if ( ber_read( ber, (*bv)->bv_val, len ) != len )
291 return( LBER_DEFAULT );
292 ((*bv)->bv_val)[len] = '\0';
295 #ifdef STR_TRANSLATION
296 if ( len > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
297 && ber->ber_decode_translate_proc != NULL ) {
299 if ( (*(ber->ber_decode_translate_proc))( &((*bv)->bv_val),
301 free( (*bv)->bv_val );
302 return( LBER_DEFAULT );
304 (*bv)->bv_len = len - 1;
306 #endif /* STR_TRANSLATION */
312 ber_get_bitstringa( BerElement *ber, char **buf, unsigned long *blen )
314 unsigned long datalen, tag;
315 unsigned char unusedbits;
317 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
318 return( LBER_DEFAULT );
321 if ( (*buf = (char *) malloc( (size_t)datalen )) == NULL )
322 return( LBER_DEFAULT );
324 if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 )
325 return( LBER_DEFAULT );
327 if ( ber_read( ber, *buf, datalen ) != datalen )
328 return( LBER_DEFAULT );
330 *blen = datalen * 8 - unusedbits;
335 ber_get_null( BerElement *ber )
337 unsigned long len, tag;
339 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
340 return( LBER_DEFAULT );
343 return( LBER_DEFAULT );
349 ber_get_boolean( BerElement *ber, int *boolval )
354 rc = ber_get_int( ber, &longbool );
361 ber_first_element( BerElement *ber, unsigned long *len, char **last )
363 /* skip the sequence header, use the len to mark where to stop */
364 if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) {
365 return( LBER_DEFAULT );
368 *last = ber->ber_ptr + *len;
370 if ( *last == ber->ber_ptr ) {
371 return( LBER_DEFAULT );
374 return( ber_peek_tag( ber, len ) );
378 ber_next_element( BerElement *ber, unsigned long *len, char *last )
380 if ( ber->ber_ptr == last ) {
381 return( LBER_DEFAULT );
384 return( ber_peek_tag( ber, len ) );
390 #if defined( MACOS ) || defined( BC31 ) || defined( _WIN32 )
391 BerElement *ber, char *fmt, ... )
398 #if !defined( MACOS ) && !defined( BC31 ) && !defined( _WIN32 )
403 char *s, **ss, ***sss;
404 struct berval ***bv, **bvp, *bval;
409 #if defined( MACOS ) || defined( BC31 ) || defined( _WIN32 )
413 ber = va_arg( ap, BerElement * );
414 fmt = va_arg( ap, char * );
418 if ( lber_debug & 64 ) {
419 fprintf( stderr, "ber_scanf fmt (%s) ber:\n", fmt );
424 for ( rc = 0; *fmt && rc != LBER_DEFAULT; fmt++ ) {
426 case 'a': /* octet string - allocate storage as needed */
427 ss = va_arg( ap, char ** );
428 rc = ber_get_stringa( ber, ss );
431 case 'b': /* boolean */
432 i = va_arg( ap, int * );
433 rc = ber_get_boolean( ber, i );
436 case 'e': /* enumerated */
438 l = va_arg( ap, long * );
439 rc = ber_get_int( ber, l );
442 case 'l': /* length of next item */
443 l = va_arg( ap, long * );
444 rc = ber_peek_tag( ber, (unsigned long *)l );
448 rc = ber_get_null( ber );
451 case 's': /* octet string - in a buffer */
452 s = va_arg( ap, char * );
453 l = va_arg( ap, long * );
454 rc = ber_get_stringb( ber, s, (unsigned long *)l );
457 case 'o': /* octet string in a supplied berval */
458 bval = va_arg( ap, struct berval * );
459 ber_peek_tag( ber, &bval->bv_len );
460 rc = ber_get_stringa( ber, &bval->bv_val );
463 case 'O': /* octet string - allocate & include length */
464 bvp = va_arg( ap, struct berval ** );
465 rc = ber_get_stringal( ber, bvp );
468 case 'B': /* bit string - allocate storage as needed */
469 ss = va_arg( ap, char ** );
470 l = va_arg( ap, long * ); /* for length, in bits */
471 rc = ber_get_bitstringa( ber, ss, (unsigned long *)l );
474 case 't': /* tag of next item */
475 i = va_arg( ap, int * );
476 *i = rc = ber_peek_tag( ber, &len );
479 case 'T': /* skip tag of next item */
480 i = va_arg( ap, int * );
481 *i = rc = ber_skip_tag( ber, &len );
484 case 'v': /* sequence of strings */
485 sss = va_arg( ap, char *** );
488 for ( tag = ber_first_element( ber, &len, &last );
489 tag != LBER_DEFAULT && rc != LBER_DEFAULT;
490 tag = ber_next_element( ber, &len, last ) ) {
491 if ( *sss == NULL ) {
492 *sss = (char **) malloc(
493 2 * sizeof(char *) );
495 *sss = (char **) realloc( *sss,
496 (j + 2) * sizeof(char *) );
498 rc = ber_get_stringa( ber, &((*sss)[j]) );
505 case 'V': /* sequence of strings + lengths */
506 bv = va_arg( ap, struct berval *** );
509 for ( tag = ber_first_element( ber, &len, &last );
510 tag != LBER_DEFAULT && rc != LBER_DEFAULT;
511 tag = ber_next_element( ber, &len, last ) ) {
513 *bv = (struct berval **) malloc(
514 2 * sizeof(struct berval *) );
516 *bv = (struct berval **) realloc( *bv,
517 (j + 2) * sizeof(struct berval *) );
519 rc = ber_get_stringal( ber, &((*bv)[j]) );
526 case 'x': /* skip the next element - whatever it is */
527 if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
532 case '{': /* begin sequence */
533 case '[': /* begin set */
534 if ( *(fmt + 1) != 'v' && *(fmt + 1) != 'V' )
535 rc = ber_skip_tag( ber, &len );
538 case '}': /* end sequence */
539 case ']': /* end set */
543 #ifndef NO_USERINTERFACE
544 fprintf( stderr, "unknown fmt %c\n", *fmt );
545 #endif /* NO_USERINTERFACE */
557 ber_bvfree( struct berval *bv )
559 if ( bv->bv_val != NULL )
565 ber_bvecfree( struct berval **bv )
569 for ( i = 0; bv[i] != NULL; i++ )
575 ber_bvdup( struct berval *bv )
579 if ( (new = (struct berval *) malloc( sizeof(struct berval) ))
583 if ( (new->bv_val = (char *) malloc( bv->bv_len + 1 )) == NULL ) {
586 SAFEMEMCPY( new->bv_val, bv->bv_val, (size_t) bv->bv_len );
587 new->bv_val[bv->bv_len] = '\0';
588 new->bv_len = bv->bv_len;
594 #ifdef STR_TRANSLATION
596 ber_set_string_translators( BerElement *ber, BERTranslateProc encode_proc,
597 BERTranslateProc decode_proc )
599 ber->ber_encode_translate_proc = encode_proc;
600 ber->ber_decode_translate_proc = decode_proc;
602 #endif /* STR_TRANSLATION */