]> git.sur5r.net Git - openldap/blob - libraries/liblber/decode.c
Initial revision
[openldap] / libraries / liblber / decode.c
1 /* decode.c - ber input decoding routines */
2 /*
3  * Copyright (c) 1990 Regents of the University of Michigan.
4  * All rights reserved.
5  *
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.
12  */
13
14 #include <stdio.h>
15 #ifdef MACOS
16 #include <stdlib.h>
17 #include <stdarg.h>
18 #include "macos.h"
19 #else /* MACOS */
20 #if defined(NeXT) || defined(VMS)
21 #include <stdlib.h>
22 #else /* next || vms */
23 #include <malloc.h>
24 #endif /* next || vms */
25 #if defined(BC31) || defined(_WIN32)
26 #include <stdarg.h>
27 #else /* BC31 || _WIN32 */
28 #include <varargs.h>
29 #endif /* BC31 || _WIN32 */
30 #include <sys/types.h>
31 #include <sys/socket.h>
32 #include <netinet/in.h>
33 #ifdef PCNFS
34 #include <tklib.h>
35 #endif /* PCNFS */
36 #endif /* MACOS */
37
38 #if defined( DOS ) || defined( _WIN32 )
39 #include "msdos.h"
40 #endif /* DOS */
41
42 #include <string.h>
43 #include "lber.h"
44
45 #ifdef LDAP_DEBUG
46 int     lber_debug;
47 #endif
48
49 #ifdef NEEDPROTOS
50 static int ber_getnint( BerElement *ber, long *num, int len );
51 #endif /* NEEDPROTOS */
52
53
54 /* return the tag - LBER_DEFAULT returned means trouble */
55 unsigned long
56 ber_get_tag( BerElement *ber )
57 {
58         unsigned char   xbyte;
59         unsigned long   tag;
60         char            *tagp;
61         int             i;
62
63         if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
64                 return( LBER_DEFAULT );
65
66         if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
67                 return( (unsigned long) xbyte );
68
69         tagp = (char *) &tag;
70         tagp[0] = xbyte;
71         for ( i = 1; i < sizeof(long); i++ ) {
72                 if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
73                         return( LBER_DEFAULT );
74
75                 tagp[i] = xbyte;
76
77                 if ( ! (xbyte & LBER_MORE_TAG_MASK) )
78                         break;
79         }
80
81         /* tag too big! */
82         if ( i == sizeof(long) )
83                 return( LBER_DEFAULT );
84
85         /* want leading, not trailing 0's */
86         return( tag >> (sizeof(long) - i - 1) );
87 }
88
89 unsigned long
90 ber_skip_tag( BerElement *ber, unsigned long *len )
91 {
92         unsigned long   tag;
93         unsigned char   lc;
94         int             noctets, diff;
95         unsigned long   netlen;
96
97         /*
98          * Any ber element looks like this: tag length contents.
99          * Assuming everything's ok, we return the tag byte (we
100          * can assume a single byte), and return the length in len.
101          *
102          * Assumptions:
103          *      1) definite lengths
104          *      2) primitive encodings used whenever possible
105          */
106
107         /*
108          * First, we read the tag.
109          */
110
111         if ( (tag = ber_get_tag( ber )) == LBER_DEFAULT )
112                 return( LBER_DEFAULT );
113
114         /*
115          * Next, read the length.  The first byte contains the length of
116          * the length.  If bit 8 is set, the length is the long form,
117          * otherwise it's the short form.  We don't allow a length that's
118          * greater than what we can hold in an unsigned long.
119          */
120
121         *len = netlen = 0;
122         if ( ber_read( ber, (char *) &lc, 1 ) != 1 )
123                 return( LBER_DEFAULT );
124         if ( lc & 0x80 ) {
125                 noctets = (lc & 0x7f);
126                 if ( noctets > sizeof(unsigned long) )
127                         return( LBER_DEFAULT );
128                 diff = sizeof(unsigned long) - noctets;
129                 if ( ber_read( ber, (char *) &netlen + diff, noctets )
130                     != noctets )
131                         return( LBER_DEFAULT );
132                 *len = LBER_NTOHL( netlen );
133         } else {
134                 *len = lc;
135         }
136
137         return( tag );
138 }
139
140 unsigned long
141 ber_peek_tag( BerElement *ber, unsigned long *len )
142 {
143         char            *save;
144         unsigned long   tag;
145
146         save = ber->ber_ptr;
147         tag = ber_skip_tag( ber, len );
148         ber->ber_ptr = save;
149
150         return( tag );
151 }
152
153 static int
154 ber_getnint( BerElement *ber, long *num, int len )
155 {
156         int     diff, sign, i;
157         long    netnum;
158
159         /*
160          * The tag and length have already been stripped off.  We should
161          * be sitting right before len bytes of 2's complement integer,
162          * ready to be read straight into an int.  We may have to sign
163          * extend after we read it in.
164          */
165
166         if ( len > sizeof(long) )
167                 return( -1 );
168
169         netnum = 0;
170         diff = sizeof(long) - len;
171         /* read into the low-order bytes of netnum */
172         if ( ber_read( ber, ((char *) &netnum) + diff, len ) != len )
173                 return( -1 );
174
175         /* sign extend if necessary */
176         sign = ((0x80 << ((len - 1) * 8)) & netnum);
177         if ( sign && len < sizeof(long) ) {
178                 for ( i = sizeof(long) - 1; i > len - 1; i-- ) {
179                         netnum |= (0xffL << (i * 8));
180                 }
181         }
182         *num = LBER_NTOHL( netnum );
183
184         return( len );
185 }
186
187 unsigned long
188 ber_get_int( BerElement *ber, long *num )
189 {
190         unsigned long   tag, len;
191
192         if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
193                 return( LBER_DEFAULT );
194
195         if ( ber_getnint( ber, num, (int)len ) != len )
196                 return( LBER_DEFAULT );
197         else
198                 return( tag );
199 }
200
201 unsigned long
202 ber_get_stringb( BerElement *ber, char *buf, unsigned long *len )
203 {
204         unsigned long   datalen, tag;
205 #ifdef STR_TRANSLATION
206         char            *transbuf;
207 #endif /* STR_TRANSLATION */
208
209         if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
210                 return( LBER_DEFAULT );
211         if ( datalen > (*len - 1) )
212                 return( LBER_DEFAULT );
213
214         if ( ber_read( ber, buf, datalen ) != datalen )
215                 return( LBER_DEFAULT );
216
217         buf[datalen] = '\0';
218
219 #ifdef STR_TRANSLATION
220         if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
221             && ber->ber_decode_translate_proc != NULL ) {
222                 transbuf = buf;
223                 ++datalen;
224                 if ( (*(ber->ber_decode_translate_proc))( &transbuf, &datalen,
225                     0 ) != 0 ) {
226                         return( LBER_DEFAULT );
227                 }
228                 if ( datalen > *len ) {
229                         free( transbuf );
230                         return( LBER_DEFAULT );
231                 }
232                 SAFEMEMCPY( buf, transbuf, datalen );
233                 free( transbuf );
234                 --datalen;
235         }
236 #endif /* STR_TRANSLATION */
237
238         *len = datalen;
239         return( tag );
240 }
241
242 unsigned long
243 ber_get_stringa( BerElement *ber, char **buf )
244 {
245         unsigned long   datalen, tag;
246
247         if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
248                 return( LBER_DEFAULT );
249
250         if ( (*buf = (char *) malloc( (size_t)datalen + 1 )) == NULL )
251                 return( LBER_DEFAULT );
252
253         if ( ber_read( ber, *buf, datalen ) != datalen )
254                 return( LBER_DEFAULT );
255         (*buf)[datalen] = '\0';
256
257 #ifdef STR_TRANSLATION
258         if ( datalen > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
259             && ber->ber_decode_translate_proc != NULL ) {
260                 ++datalen;
261                 if ( (*(ber->ber_decode_translate_proc))( buf, &datalen, 1 )
262                     != 0 ) {
263                         free( *buf );
264                         return( LBER_DEFAULT );
265                 }
266         }
267 #endif /* STR_TRANSLATION */
268
269         return( tag );
270 }
271
272 unsigned long
273 ber_get_stringal( BerElement *ber, struct berval **bv )
274 {
275         unsigned long   len, tag;
276
277         if ( (*bv = (struct berval *) malloc( sizeof(struct berval) )) == NULL )
278                 return( LBER_DEFAULT );
279
280         if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
281                 return( LBER_DEFAULT );
282
283         if ( ((*bv)->bv_val = (char *) malloc( (size_t)len + 1 )) == NULL )
284                 return( LBER_DEFAULT );
285
286         if ( ber_read( ber, (*bv)->bv_val, len ) != len )
287                 return( LBER_DEFAULT );
288         ((*bv)->bv_val)[len] = '\0';
289         (*bv)->bv_len = len;
290
291 #ifdef STR_TRANSLATION
292         if ( len > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0
293             && ber->ber_decode_translate_proc != NULL ) {
294                 ++len;
295                 if ( (*(ber->ber_decode_translate_proc))( &((*bv)->bv_val),
296                     &len, 1 ) != 0 ) {
297                         free( (*bv)->bv_val );
298                         return( LBER_DEFAULT );
299                 }
300                 (*bv)->bv_len = len - 1;
301         }
302 #endif /* STR_TRANSLATION */
303
304         return( tag );
305 }
306
307 unsigned long
308 ber_get_bitstringa( BerElement *ber, char **buf, unsigned long *blen )
309 {
310         unsigned long   datalen, tag;
311         unsigned char   unusedbits;
312
313         if ( (tag = ber_skip_tag( ber, &datalen )) == LBER_DEFAULT )
314                 return( LBER_DEFAULT );
315         --datalen;
316
317         if ( (*buf = (char *) malloc( (size_t)datalen )) == NULL )
318                 return( LBER_DEFAULT );
319
320         if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 )
321                 return( LBER_DEFAULT );
322
323         if ( ber_read( ber, *buf, datalen ) != datalen )
324                 return( LBER_DEFAULT );
325
326         *blen = datalen * 8 - unusedbits;
327         return( tag );
328 }
329
330 unsigned long
331 ber_get_null( BerElement *ber )
332 {
333         unsigned long   len, tag;
334
335         if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
336                 return( LBER_DEFAULT );
337
338         if ( len != 0 )
339                 return( LBER_DEFAULT );
340
341         return( tag );
342 }
343
344 unsigned long
345 ber_get_boolean( BerElement *ber, int *boolval )
346 {
347         long    longbool;
348         int     rc;
349
350         rc = ber_get_int( ber, &longbool );
351         *boolval = longbool;
352
353         return( rc );
354 }
355
356 unsigned long
357 ber_first_element( BerElement *ber, unsigned long *len, char **last )
358 {
359         /* skip the sequence header, use the len to mark where to stop */
360         if ( ber_skip_tag( ber, len ) == LBER_DEFAULT ) {
361                 return( LBER_DEFAULT );
362         }
363
364         *last = ber->ber_ptr + *len;
365
366         if ( *last == ber->ber_ptr ) {
367                 return( LBER_DEFAULT );
368         }
369
370         return( ber_peek_tag( ber, len ) );
371 }
372
373 unsigned long
374 ber_next_element( BerElement *ber, unsigned long *len, char *last )
375 {
376         if ( ber->ber_ptr == last ) {
377                 return( LBER_DEFAULT );
378         }
379
380         return( ber_peek_tag( ber, len ) );
381 }
382
383 /* VARARGS */
384 unsigned long
385 ber_scanf(
386 #if defined( MACOS ) || defined( BC31 ) || defined( _WIN32 )
387         BerElement *ber, char *fmt, ... )
388 #else
389         va_alist )
390 va_dcl
391 #endif
392 {
393         va_list         ap;
394 #if !defined( MACOS ) && !defined( BC31 ) && !defined( _WIN32 )
395         BerElement      *ber;
396         char            *fmt;
397 #endif
398         char            *last;
399         char            *s, **ss, ***sss;
400         struct berval   ***bv, **bvp, *bval;
401         int             *i, j;
402         long            *l, rc, tag;
403         unsigned long   len;
404
405 #if defined( MACOS ) || defined( BC31 ) || defined( _WIN32 )
406         va_start( ap, fmt );
407 #else
408         va_start( ap );
409         ber = va_arg( ap, BerElement * );
410         fmt = va_arg( ap, char * );
411 #endif
412
413 #ifdef LDAP_DEBUG
414         if ( lber_debug & 64 ) {
415                 fprintf( stderr, "ber_scanf fmt (%s) ber:\n", fmt );
416                 ber_dump( ber, 1 );
417         }
418 #endif
419
420         for ( rc = 0; *fmt && rc != LBER_DEFAULT; fmt++ ) {
421                 switch ( *fmt ) {
422                 case 'a':       /* octet string - allocate storage as needed */
423                         ss = va_arg( ap, char ** );
424                         rc = ber_get_stringa( ber, ss );
425                         break;
426
427                 case 'b':       /* boolean */
428                         i = va_arg( ap, int * );
429                         rc = ber_get_boolean( ber, i );
430                         break;
431
432                 case 'e':       /* enumerated */
433                 case 'i':       /* int */
434                         l = va_arg( ap, long * );
435                         rc = ber_get_int( ber, l );
436                         break;
437
438                 case 'l':       /* length of next item */
439                         l = va_arg( ap, long * );
440                         rc = ber_peek_tag( ber, (unsigned long *)l );
441                         break;
442
443                 case 'n':       /* null */
444                         rc = ber_get_null( ber );
445                         break;
446
447                 case 's':       /* octet string - in a buffer */
448                         s = va_arg( ap, char * );
449                         l = va_arg( ap, long * );
450                         rc = ber_get_stringb( ber, s, (unsigned long *)l );
451                         break;
452
453                 case 'o':       /* octet string in a supplied berval */
454                         bval = va_arg( ap, struct berval * );
455                         ber_peek_tag( ber, &bval->bv_len );
456                         rc = ber_get_stringa( ber, &bval->bv_val );
457                         break;
458
459                 case 'O':       /* octet string - allocate & include length */
460                         bvp = va_arg( ap, struct berval ** );
461                         rc = ber_get_stringal( ber, bvp );
462                         break;
463
464                 case 'B':       /* bit string - allocate storage as needed */
465                         ss = va_arg( ap, char ** );
466                         l = va_arg( ap, long * ); /* for length, in bits */
467                         rc = ber_get_bitstringa( ber, ss, (unsigned long *)l );
468                         break;
469
470                 case 't':       /* tag of next item */
471                         i = va_arg( ap, int * );
472                         *i = rc = ber_peek_tag( ber, &len );
473                         break;
474
475                 case 'T':       /* skip tag of next item */
476                         i = va_arg( ap, int * );
477                         *i = rc = ber_skip_tag( ber, &len );
478                         break;
479
480                 case 'v':       /* sequence of strings */
481                         sss = va_arg( ap, char *** );
482                         *sss = NULL;
483                         j = 0;
484                         for ( tag = ber_first_element( ber, &len, &last );
485                             tag != LBER_DEFAULT && rc != LBER_DEFAULT;
486                             tag = ber_next_element( ber, &len, last ) ) {
487                                 if ( *sss == NULL ) {
488                                         *sss = (char **) malloc(
489                                             2 * sizeof(char *) );
490                                 } else {
491                                         *sss = (char **) realloc( *sss,
492                                             (j + 2) * sizeof(char *) );
493                                 }
494                                 rc = ber_get_stringa( ber, &((*sss)[j]) );
495                                 j++;
496                         }
497                         if ( j > 0 )
498                                 (*sss)[j] = NULL;
499                         break;
500
501                 case 'V':       /* sequence of strings + lengths */
502                         bv = va_arg( ap, struct berval *** );
503                         *bv = NULL;
504                         j = 0;
505                         for ( tag = ber_first_element( ber, &len, &last );
506                             tag != LBER_DEFAULT && rc != LBER_DEFAULT;
507                             tag = ber_next_element( ber, &len, last ) ) {
508                                 if ( *bv == NULL ) {
509                                         *bv = (struct berval **) malloc(
510                                             2 * sizeof(struct berval *) );
511                                 } else {
512                                         *bv = (struct berval **) realloc( *bv,
513                                             (j + 2) * sizeof(struct berval *) );
514                                 }
515                                 rc = ber_get_stringal( ber, &((*bv)[j]) );
516                                 j++;
517                         }
518                         if ( j > 0 )
519                                 (*bv)[j] = NULL;
520                         break;
521
522                 case 'x':       /* skip the next element - whatever it is */
523                         if ( (rc = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
524                                 break;
525                         ber->ber_ptr += len;
526                         break;
527
528                 case '{':       /* begin sequence */
529                 case '[':       /* begin set */
530                         if ( *(fmt + 1) != 'v' && *(fmt + 1) != 'V' )
531                                 rc = ber_skip_tag( ber, &len );
532                         break;
533
534                 case '}':       /* end sequence */
535                 case ']':       /* end set */
536                         break;
537
538                 default:
539 #ifndef NO_USERINTERFACE
540                         fprintf( stderr, "unknown fmt %c\n", *fmt );
541 #endif /* NO_USERINTERFACE */
542                         rc = LBER_DEFAULT;
543                         break;
544                 }
545         }
546
547         va_end( ap );
548
549         return( rc );
550 }
551
552 void
553 ber_bvfree( struct berval *bv )
554 {
555         if ( bv->bv_val != NULL )
556                 free( bv->bv_val );
557         free( (char *) bv );
558 }
559
560 void
561 ber_bvecfree( struct berval **bv )
562 {
563         int     i;
564
565         for ( i = 0; bv[i] != NULL; i++ )
566                 ber_bvfree( bv[i] );
567         free( (char *) bv );
568 }
569
570 struct berval *
571 ber_bvdup( struct berval *bv )
572 {
573         struct berval   *new;
574
575         if ( (new = (struct berval *) malloc( sizeof(struct berval) ))
576             == NULL ) {
577                 return( NULL );
578         }
579         if ( (new->bv_val = (char *) malloc( bv->bv_len + 1 )) == NULL ) {
580                 return( NULL );
581         }
582         SAFEMEMCPY( new->bv_val, bv->bv_val, (size_t) bv->bv_len );
583         new->bv_val[bv->bv_len] = '\0';
584         new->bv_len = bv->bv_len;
585
586         return( new );
587 }
588
589
590 #ifdef STR_TRANSLATION
591 void
592 ber_set_string_translators( BerElement *ber, BERTranslateProc encode_proc,
593         BERTranslateProc decode_proc )
594 {
595     ber->ber_encode_translate_proc = encode_proc;
596     ber->ber_decode_translate_proc = decode_proc;
597 }
598 #endif /* STR_TRANSLATION */