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.
25 #include <ac/string.h>
26 #include <sys/types.h>
27 #include <ac/socket.h>
35 static int ber_getnint LDAP_P(( BerElement *ber, long *num, int len ));
37 /* return the tag - LBER_DEFAULT returned means trouble */
39 ber_get_tag( BerElement *ber )
46 if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
47 return( LBER_DEFAULT );
49 if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
50 return( (unsigned long) xbyte );
54 for ( i = 1; i < sizeof(long); i++ ) {
55 if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
56 return( LBER_DEFAULT );
60 if ( ! (xbyte & LBER_MORE_TAG_MASK) )
65 if ( i == sizeof(long) )
66 return( LBER_DEFAULT );
68 /* want leading, not trailing 0's */
69 return( tag >> (sizeof(long) - i - 1) );
73 ber_skip_tag( BerElement *ber, unsigned long *len )
81 * Any ber element looks like this: tag length contents.
82 * Assuming everything's ok, we return the tag byte (we
83 * can assume a single byte), and return the length in len.
87 * 2) primitive encodings used whenever possible
91 * First, we read the tag.
94 if ( (tag = ber_get_tag( ber )) == LBER_DEFAULT )
95 return( LBER_DEFAULT );
98 * Next, read the length. The first byte contains the length of
99 * the length. If bit 8 is set, the length is the long form,
100 * otherwise it's the short form. We don't allow a length that's
101 * greater than what we can hold in an unsigned long.
105 if ( ber_read( ber, (char *) &lc, 1 ) != 1 )
106 return( LBER_DEFAULT );
108 noctets = (lc & 0x7f);
109 if ( noctets > sizeof(unsigned long) )
110 return( LBER_DEFAULT );
111 diff = sizeof(unsigned long) - noctets;
112 if ( ber_read( ber, (char *) &netlen + diff, noctets )
114 return( LBER_DEFAULT );
115 *len = NTOHL( netlen );
124 ber_peek_tag( BerElement *ber, unsigned long *len )
130 tag = ber_skip_tag( ber, len );
137 ber_getnint( BerElement *ber, long *num, int len )
144 * The tag and length have already been stripped off. We should
145 * be sitting right before len bytes of 2's complement integer,
146 * ready to be read straight into an int. We may have to sign
147 * extend after we read it in.
150 if ( len > sizeof(long) )
154 diff = sizeof(long) - len;
155 /* read into the low-order bytes of netnum */
156 if ( ber_read( ber, ((char *) &netnum) + diff, len ) != len )
159 /* sign extend if necessary */
160 p = (char *) &netnum;
161 sign = (0x80 & *(p+diff) );
162 if ( sign && len < sizeof(long) ) {
163 for ( i = 0; i < diff; i++ ) {
164 *(p+i) = (char) 0xff;
167 *num = NTOHL( netnum );
173 ber_get_int( BerElement *ber, long *num )
175 unsigned long tag, len;
177 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
178 return( LBER_DEFAULT );
180 if ( (unsigned long) ber_getnint( ber, num, (int)len ) != len )
181 return( LBER_DEFAULT );
187 ber_get_stringb( BerElement *ber, char *buf, unsigned long *len )
189 unsigned long datalen, tag;
190 #ifdef STR_TRANSLATION
192 #endif /* STR_TRANSLATION */
194 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
195 return( LBER_DEFAULT );
196 if ( datalen > (*len - 1) )
197 return( LBER_DEFAULT );
199 if ( (unsigned long) ber_read( ber, buf, datalen ) != datalen )
200 return( LBER_DEFAULT );
204 #ifdef STR_TRANSLATION
205 if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
206 && ber->ber_decode_translate_proc != NULL ) {
209 if ( (*(ber->ber_decode_translate_proc))( &transbuf, &datalen,
211 return( LBER_DEFAULT );
213 if ( datalen > *len ) {
215 return( LBER_DEFAULT );
217 SAFEMEMCPY( buf, transbuf, datalen );
221 #endif /* STR_TRANSLATION */
228 ber_get_stringa( BerElement *ber, char **buf )
230 unsigned long datalen, tag;
232 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
233 return( LBER_DEFAULT );
235 if ( (*buf = (char *) malloc( (size_t)datalen + 1 )) == NULL )
236 return( LBER_DEFAULT );
238 if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen )
239 return( LBER_DEFAULT );
240 (*buf)[datalen] = '\0';
242 #ifdef STR_TRANSLATION
243 if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
244 && ber->ber_decode_translate_proc != NULL ) {
246 if ( (*(ber->ber_decode_translate_proc))( buf, &datalen, 1 )
249 return( LBER_DEFAULT );
252 #endif /* STR_TRANSLATION */
258 ber_get_stringal( BerElement *ber, struct berval **bv )
260 unsigned long len, tag;
262 if ( (*bv = (struct berval *) malloc( sizeof(struct berval) )) == NULL )
263 return( LBER_DEFAULT );
265 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
266 return( LBER_DEFAULT );
268 if ( ((*bv)->bv_val = (char *) malloc( (size_t)len + 1 )) == NULL )
269 return( LBER_DEFAULT );
271 if ( (unsigned long) ber_read( ber, (*bv)->bv_val, len ) != len )
272 return( LBER_DEFAULT );
273 ((*bv)->bv_val)[len] = '\0';
276 #ifdef STR_TRANSLATION
277 if ( len > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
278 && ber->ber_decode_translate_proc != NULL ) {
280 if ( (*(ber->ber_decode_translate_proc))( &((*bv)->bv_val),
282 free( (*bv)->bv_val );
283 return( LBER_DEFAULT );
285 (*bv)->bv_len = len - 1;
287 #endif /* STR_TRANSLATION */
293 ber_get_bitstringa( BerElement *ber, char **buf, unsigned long *blen )
295 unsigned long datalen, tag;
296 unsigned char unusedbits;
298 if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
299 return( LBER_DEFAULT );
302 if ( (*buf = (char *) malloc( (size_t)datalen )) == NULL )
303 return( LBER_DEFAULT );
305 if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 )
306 return( LBER_DEFAULT );
308 if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen )
309 return( LBER_DEFAULT );
311 *blen = datalen * 8 - unusedbits;
316 ber_get_null( BerElement *ber )
318 unsigned long len, tag;
320 if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
321 return( LBER_DEFAULT );
324 return( LBER_DEFAULT );
330 ber_get_boolean( BerElement *ber, int *boolval )
335 rc = ber_get_int( ber, &longbool );
342 ber_first_element( BerElement *ber, unsigned long *len, char **last )
344 /* skip the sequence header, use the len to mark where to stop */
345 if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) {
346 return( LBER_DEFAULT );
349 *last = ber->ber_ptr + *len;
351 if ( *last == ber->ber_ptr ) {
352 return( LBER_DEFAULT );
355 return( ber_peek_tag( ber, len ) );
359 ber_next_element( BerElement *ber, unsigned long *len, char *last )
361 if ( ber->ber_ptr == last ) {
362 return( LBER_DEFAULT );
365 return( ber_peek_tag( ber, len ) );
372 ( BerElement *ber, char *fmt, ... )
384 char *s, **ss, ***sss;
385 struct berval ***bv, **bvp, *bval;
394 ber = va_arg( ap, BerElement * );
395 fmt = va_arg( ap, char * );
399 if ( lber_debug & 64 ) {
400 fprintf( stderr, "ber_scanf fmt (%s) ber:\n", fmt );
405 for ( rc = 0; *fmt && rc != LBER_DEFAULT; fmt++ ) {
407 case 'a': /* octet string - allocate storage as needed */
408 ss = va_arg( ap, char ** );
409 rc = ber_get_stringa( ber, ss );
412 case 'b': /* boolean */
413 i = va_arg( ap, int * );
414 rc = ber_get_boolean( ber, i );
417 case 'e': /* enumerated */
419 l = va_arg( ap, long * );
420 rc = ber_get_int( ber, l );
423 case 'l': /* length of next item */
424 l = va_arg( ap, long * );
425 rc = ber_peek_tag( ber, (unsigned long *)l );
429 rc = ber_get_null( ber );
432 case 's': /* octet string - in a buffer */
433 s = va_arg( ap, char * );
434 l = va_arg( ap, long * );
435 rc = ber_get_stringb( ber, s, (unsigned long *)l );
438 case 'o': /* octet string in a supplied berval */
439 bval = va_arg( ap, struct berval * );
440 ber_peek_tag( ber, &bval->bv_len );
441 rc = ber_get_stringa( ber, &bval->bv_val );
444 case 'O': /* octet string - allocate & include length */
445 bvp = va_arg( ap, struct berval ** );
446 rc = ber_get_stringal( ber, bvp );
449 case 'B': /* bit string - allocate storage as needed */
450 ss = va_arg( ap, char ** );
451 l = va_arg( ap, long * ); /* for length, in bits */
452 rc = ber_get_bitstringa( ber, ss, (unsigned long *)l );
455 case 't': /* tag of next item */
456 i = va_arg( ap, int * );
457 *i = rc = ber_peek_tag( ber, &len );
460 case 'T': /* skip tag of next item */
461 i = va_arg( ap, int * );
462 *i = rc = ber_skip_tag( ber, &len );
465 case 'v': /* sequence of strings */
466 sss = va_arg( ap, char *** );
469 for ( tag = ber_first_element( ber, &len, &last );
470 tag != LBER_DEFAULT && rc != LBER_DEFAULT;
471 tag = ber_next_element( ber, &len, last ) ) {
472 if ( *sss == NULL ) {
473 *sss = (char **) malloc(
474 2 * sizeof(char *) );
476 *sss = (char **) realloc( *sss,
477 (j + 2) * sizeof(char *) );
479 rc = ber_get_stringa( ber, &((*sss)[j]) );
486 case 'V': /* sequence of strings + lengths */
487 bv = va_arg( ap, struct berval *** );
490 for ( tag = ber_first_element( ber, &len, &last );
491 tag != LBER_DEFAULT && rc != LBER_DEFAULT;
492 tag = ber_next_element( ber, &len, last ) ) {
494 *bv = (struct berval **) malloc(
495 2 * sizeof(struct berval *) );
497 *bv = (struct berval **) realloc( *bv,
498 (j + 2) * sizeof(struct berval *) );
500 rc = ber_get_stringal( ber, &((*bv)[j]) );
507 case 'x': /* skip the next element - whatever it is */
508 if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
513 case '{': /* begin sequence */
514 case '[': /* begin set */
515 if ( *(fmt + 1) != 'v' && *(fmt + 1) != 'V' )
516 rc = ber_skip_tag( ber, &len );
519 case '}': /* end sequence */
520 case ']': /* end set */
525 fprintf( stderr, "unknown fmt %c\n", *fmt );
526 #endif /* LDAP_LIBUI */
538 ber_bvfree( struct berval *bv )
540 if ( bv->bv_val != NULL )
546 ber_bvecfree( struct berval **bv )
550 for ( i = 0; bv[i] != NULL; i++ )
556 ber_bvdup( struct berval *bv )
560 if ( (new = (struct berval *) malloc( sizeof(struct berval) ))
564 if ( (new->bv_val = (char *) malloc( bv->bv_len + 1 )) == NULL ) {
567 SAFEMEMCPY( new->bv_val, bv->bv_val, (size_t) bv->bv_len );
568 new->bv_val[bv->bv_len] = '\0';
569 new->bv_len = bv->bv_len;
575 #ifdef STR_TRANSLATION
577 ber_set_string_translators( BerElement *ber, BERTranslateProc encode_proc,
578 BERTranslateProc decode_proc )
580 ber->ber_encode_translate_proc = encode_proc;
581 ber->ber_decode_translate_proc = decode_proc;
583 #endif /* STR_TRANSLATION */