![[BACK]](/icons/back.gif){kind=icon}
Return to ber.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / ldap|
Return to ber.c CVS log | Up to [local] / src / usr.bin / ldap |
1.1 reyk 1: /* $OpenBSD: ber.c,v 1.13 2018/02/08 18:02:06 jca Exp $ */
2:
3: /*
4: * Copyright (c) 2007 Reyk Floeter <reyk@vantronix.net>
5: * Copyright (c) 2006, 2007 Claudio Jeker <claudio@openbsd.org>
6: * Copyright (c) 2006, 2007 Marc Balmer <mbalmer@openbsd.org>
7: *
8: * Permission to use, copy, modify, and distribute this software for any
9: * purpose with or without fee is hereby granted, provided that the above
10: * copyright notice and this permission notice appear in all copies.
11: *
12: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19: */
20:
21: #include <sys/types.h>
22:
23: #include <errno.h>
24: #include <limits.h>
25: #include <stdlib.h>
26: #include <err.h> /* XXX for debug output */
27: #include <stdio.h> /* XXX for debug output */
28: #include <string.h>
29: #include <unistd.h>
30: #include <stdarg.h>
31:
32: #include "ber.h"
33:
34: #define MINIMUM(a, b) (((a) < (b)) ? (a) : (b))
35:
36: #define BER_TYPE_CONSTRUCTED 0x20 /* otherwise primitive */
37: #define BER_TYPE_SINGLE_MAX 30
38: #define BER_TAG_MASK 0x1f
39: #define BER_TAG_MORE 0x80 /* more subsequent octets */
40: #define BER_TAG_TYPE_MASK 0x7f
41: #define BER_CLASS_SHIFT 6
42:
43: static int ber_dump_element(struct ber *ber, struct ber_element *root);
44: static void ber_dump_header(struct ber *ber, struct ber_element *root);
45: static void ber_putc(struct ber *ber, u_char c);
46: static void ber_write(struct ber *ber, void *buf, size_t len);
47: static ssize_t get_id(struct ber *b, unsigned long *tag, int *class,
48: int *cstruct);
49: static ssize_t get_len(struct ber *b, ssize_t *len);
50: static ssize_t ber_read_element(struct ber *ber, struct ber_element *elm);
51: static ssize_t ber_readbuf(struct ber *b, void *buf, size_t nbytes);
52: static ssize_t ber_getc(struct ber *b, u_char *c);
53: static ssize_t ber_read(struct ber *ber, void *buf, size_t len);
54:
55: #ifdef DEBUG
56: #define DPRINTF(...) printf(__VA_ARGS__)
57: #else
58: #define DPRINTF(...) do { } while (0)
59: #endif
60:
61: struct ber_element *
62: ber_get_element(unsigned long encoding)
63: {
64: struct ber_element *elm;
65:
66: if ((elm = calloc(1, sizeof(*elm))) == NULL)
67: return NULL;
68:
69: elm->be_encoding = encoding;
70: ber_set_header(elm, BER_CLASS_UNIVERSAL, BER_TYPE_DEFAULT);
71:
72: return elm;
73: }
74:
75: void
76: ber_set_header(struct ber_element *elm, int class, unsigned long type)
77: {
78: elm->be_class = class & BER_CLASS_MASK;
79: if (type == BER_TYPE_DEFAULT)
80: type = elm->be_encoding;
81: elm->be_type = type;
82: }
83:
84: void
85: ber_link_elements(struct ber_element *prev, struct ber_element *elm)
86: {
87: if (prev != NULL) {
88: if ((prev->be_encoding == BER_TYPE_SEQUENCE ||
89: prev->be_encoding == BER_TYPE_SET) &&
90: prev->be_sub == NULL)
91: prev->be_sub = elm;
92: else
93: prev->be_next = elm;
94: }
95: }
96:
97: struct ber_element *
98: ber_unlink_elements(struct ber_element *prev)
99: {
100: struct ber_element *elm;
101:
102: if ((prev->be_encoding == BER_TYPE_SEQUENCE ||
103: prev->be_encoding == BER_TYPE_SET) &&
104: prev->be_sub != NULL) {
105: elm = prev->be_sub;
106: prev->be_sub = NULL;
107: } else {
108: elm = prev->be_next;
109: prev->be_next = NULL;
110: }
111:
112: return (elm);
113: }
114:
115: void
116: ber_replace_elements(struct ber_element *prev, struct ber_element *new)
117: {
118: struct ber_element *ber, *next;
119:
120: ber = ber_unlink_elements(prev);
121: next = ber_unlink_elements(ber);
122: ber_link_elements(new, next);
123: ber_link_elements(prev, new);
124:
125: /* cleanup old element */
126: ber_free_elements(ber);
127: }
128:
129: struct ber_element *
130: ber_add_sequence(struct ber_element *prev)
131: {
132: struct ber_element *elm;
133:
134: if ((elm = ber_get_element(BER_TYPE_SEQUENCE)) == NULL)
135: return NULL;
136:
137: ber_link_elements(prev, elm);
138:
139: return elm;
140: }
141:
142: struct ber_element *
143: ber_add_set(struct ber_element *prev)
144: {
145: struct ber_element *elm;
146:
147: if ((elm = ber_get_element(BER_TYPE_SET)) == NULL)
148: return NULL;
149:
150: ber_link_elements(prev, elm);
151:
152: return elm;
153: }
154:
155: struct ber_element *
156: ber_add_enumerated(struct ber_element *prev, long long val)
157: {
158: struct ber_element *elm;
159: u_int i, len = 0;
160: u_char cur, last = 0;
161:
162: if ((elm = ber_get_element(BER_TYPE_ENUMERATED)) == NULL)
163: return NULL;
164:
165: elm->be_numeric = val;
166:
167: for (i = 0; i < sizeof(long long); i++) {
168: cur = val & 0xff;
169: if (cur != 0 && cur != 0xff)
170: len = i;
171: if ((cur == 0 && last & 0x80) ||
172: (cur == 0xff && (last & 0x80) == 0))
173: len = i;
174: val >>= 8;
175: last = cur;
176: }
177: elm->be_len = len + 1;
178:
179: ber_link_elements(prev, elm);
180:
181: return elm;
182: }
183:
184: struct ber_element *
185: ber_add_integer(struct ber_element *prev, long long val)
186: {
187: struct ber_element *elm;
188: u_int i, len = 0;
189: u_char cur, last = 0;
190:
191: if ((elm = ber_get_element(BER_TYPE_INTEGER)) == NULL)
192: return NULL;
193:
194: elm->be_numeric = val;
195:
196: for (i = 0; i < sizeof(long long); i++) {
197: cur = val & 0xff;
198: if (cur != 0 && cur != 0xff)
199: len = i;
200: if ((cur == 0 && last & 0x80) ||
201: (cur == 0xff && (last & 0x80) == 0))
202: len = i;
203: val >>= 8;
204: last = cur;
205: }
206: elm->be_len = len + 1;
207:
208: ber_link_elements(prev, elm);
209:
210: return elm;
211: }
212:
213: int
214: ber_get_integer(struct ber_element *elm, long long *n)
215: {
216: if (elm->be_encoding != BER_TYPE_INTEGER)
217: return -1;
218:
219: *n = elm->be_numeric;
220: return 0;
221: }
222:
223: int
224: ber_get_enumerated(struct ber_element *elm, long long *n)
225: {
226: if (elm->be_encoding != BER_TYPE_ENUMERATED)
227: return -1;
228:
229: *n = elm->be_numeric;
230: return 0;
231: }
232:
233:
234: struct ber_element *
235: ber_add_boolean(struct ber_element *prev, int bool)
236: {
237: struct ber_element *elm;
238:
239: if ((elm = ber_get_element(BER_TYPE_BOOLEAN)) == NULL)
240: return NULL;
241:
242: elm->be_numeric = bool ? 0xff : 0;
243: elm->be_len = 1;
244:
245: ber_link_elements(prev, elm);
246:
247: return elm;
248: }
249:
250: int
251: ber_get_boolean(struct ber_element *elm, int *b)
252: {
253: if (elm->be_encoding != BER_TYPE_BOOLEAN)
254: return -1;
255:
256: *b = !(elm->be_numeric == 0);
257: return 0;
258: }
259:
260: struct ber_element *
261: ber_add_string(struct ber_element *prev, const char *string)
262: {
263: return ber_add_nstring(prev, string, strlen(string));
264: }
265:
266: struct ber_element *
267: ber_add_nstring(struct ber_element *prev, const char *string0, size_t len)
268: {
269: struct ber_element *elm;
270: char *string;
271:
272: if ((string = calloc(1, len)) == NULL)
273: return NULL;
274: if ((elm = ber_get_element(BER_TYPE_OCTETSTRING)) == NULL) {
275: free(string);
276: return NULL;
277: }
278:
279: bcopy(string0, string, len);
280: elm->be_val = string;
281: elm->be_len = len;
282: elm->be_free = 1; /* free string on cleanup */
283:
284: ber_link_elements(prev, elm);
285:
286: return elm;
287: }
288:
289: int
290: ber_get_string(struct ber_element *elm, char **s)
291: {
292: if (elm->be_encoding != BER_TYPE_OCTETSTRING)
293: return -1;
294:
295: *s = elm->be_val;
296: return 0;
297: }
298:
299: int
300: ber_get_nstring(struct ber_element *elm, void **p, size_t *len)
301: {
302: if (elm->be_encoding != BER_TYPE_OCTETSTRING)
303: return -1;
304:
305: *p = elm->be_val;
306: *len = elm->be_len;
307: return 0;
308: }
309:
310: struct ber_element *
311: ber_add_bitstring(struct ber_element *prev, const void *v0, size_t len)
312: {
313: struct ber_element *elm;
314: void *v;
315:
316: if ((v = calloc(1, len)) == NULL)
317: return NULL;
318: if ((elm = ber_get_element(BER_TYPE_BITSTRING)) == NULL) {
319: free(v);
320: return NULL;
321: }
322:
323: bcopy(v0, v, len);
324: elm->be_val = v;
325: elm->be_len = len;
326: elm->be_free = 1; /* free string on cleanup */
327:
328: ber_link_elements(prev, elm);
329:
330: return elm;
331: }
332:
333: int
334: ber_get_bitstring(struct ber_element *elm, void **v, size_t *len)
335: {
336: if (elm->be_encoding != BER_TYPE_BITSTRING)
337: return -1;
338:
339: *v = elm->be_val;
340: *len = elm->be_len;
341: return 0;
342: }
343:
344: struct ber_element *
345: ber_add_null(struct ber_element *prev)
346: {
347: struct ber_element *elm;
348:
349: if ((elm = ber_get_element(BER_TYPE_NULL)) == NULL)
350: return NULL;
351:
352: ber_link_elements(prev, elm);
353:
354: return elm;
355: }
356:
357: int
358: ber_get_null(struct ber_element *elm)
359: {
360: if (elm->be_encoding != BER_TYPE_NULL)
361: return -1;
362:
363: return 0;
364: }
365:
366: struct ber_element *
367: ber_add_eoc(struct ber_element *prev)
368: {
369: struct ber_element *elm;
370:
371: if ((elm = ber_get_element(BER_TYPE_EOC)) == NULL)
372: return NULL;
373:
374: ber_link_elements(prev, elm);
375:
376: return elm;
377: }
378:
379: int
380: ber_get_eoc(struct ber_element *elm)
381: {
382: if (elm->be_encoding != BER_TYPE_EOC)
383: return -1;
384:
385: return 0;
386: }
387:
388: size_t
389: ber_oid2ber(struct ber_oid *o, u_int8_t *buf, size_t len)
390: {
391: u_int32_t v;
392: u_int i, j = 0, k;
393:
394: if (o->bo_n < BER_MIN_OID_LEN || o->bo_n > BER_MAX_OID_LEN ||
395: o->bo_id[0] > 2 || o->bo_id[1] > 40)
396: return (0);
397:
398: v = (o->bo_id[0] * 40) + o->bo_id[1];
399: for (i = 2, j = 0; i <= o->bo_n; v = o->bo_id[i], i++) {
400: for (k = 28; k >= 7; k -= 7) {
401: if (v >= (u_int)(1 << k)) {
402: if (len)
403: buf[j] = v >> k | BER_TAG_MORE;
404: j++;
405: }
406: }
407: if (len)
408: buf[j] = v & BER_TAG_TYPE_MASK;
409: j++;
410: }
411:
412: return (j);
413: }
414:
415: int
416: ber_string2oid(const char *oidstr, struct ber_oid *o)
417: {
418: char *sp, *p, str[BUFSIZ];
419: const char *errstr;
420:
421: if (strlcpy(str, oidstr, sizeof(str)) >= sizeof(str))
422: return (-1);
423: memset(o, 0, sizeof(*o));
424:
425: /* Parse OID strings in the common forms n.n.n, n_n_n_n, or n-n-n */
426: for (p = sp = str; p != NULL; sp = p) {
427: if ((p = strpbrk(p, "._-")) != NULL)
428: *p++ = '\0';
429: o->bo_id[o->bo_n++] = strtonum(sp, 0, UINT_MAX, &errstr);
430: if (errstr || o->bo_n > BER_MAX_OID_LEN)
431: return (-1);
432: }
433:
434: return (0);
435: }
436:
437: struct ber_element *
438: ber_add_oid(struct ber_element *prev, struct ber_oid *o)
439: {
440: struct ber_element *elm;
441: u_int8_t *buf;
442: size_t len;
443:
444: if ((elm = ber_get_element(BER_TYPE_OBJECT)) == NULL)
445: return (NULL);
446:
447: if ((len = ber_oid2ber(o, NULL, 0)) == 0)
448: goto fail;
449:
450: if ((buf = calloc(1, len)) == NULL)
451: goto fail;
452:
453: elm->be_val = buf;
454: elm->be_len = len;
455: elm->be_free = 1;
456:
457: if (ber_oid2ber(o, buf, len) != len)
458: goto fail;
459:
460: ber_link_elements(prev, elm);
461:
462: return (elm);
463:
464: fail:
465: ber_free_elements(elm);
466: return (NULL);
467: }
468:
469: struct ber_element *
470: ber_add_noid(struct ber_element *prev, struct ber_oid *o, int n)
471: {
472: struct ber_oid no;
473:
474: if (n > BER_MAX_OID_LEN)
475: return (NULL);
476: no.bo_n = n;
477: bcopy(&o->bo_id, &no.bo_id, sizeof(no.bo_id));
478:
479: return (ber_add_oid(prev, &no));
480: }
481:
482: struct ber_element *
483: ber_add_oidstring(struct ber_element *prev, const char *oidstr)
484: {
485: struct ber_oid o;
486:
487: if (ber_string2oid(oidstr, &o) == -1)
488: return (NULL);
489:
490: return (ber_add_oid(prev, &o));
491: }
492:
493: int
494: ber_get_oid(struct ber_element *elm, struct ber_oid *o)
495: {
496: u_int8_t *buf;
497: size_t len, i = 0, j = 0;
498:
499: if (elm->be_encoding != BER_TYPE_OBJECT)
500: return (-1);
501:
502: buf = elm->be_val;
503: len = elm->be_len;
504:
505: if (!buf[i])
506: return (-1);
507:
508: memset(o, 0, sizeof(*o));
509: o->bo_id[j++] = buf[i] / 40;
510: o->bo_id[j++] = buf[i++] % 40;
511: for (; i < len && j < BER_MAX_OID_LEN; i++) {
512: o->bo_id[j] = (o->bo_id[j] << 7) + (buf[i] & ~0x80);
513: if (buf[i] & 0x80)
514: continue;
515: j++;
516: }
517: o->bo_n = j;
518:
519: return (0);
520: }
521:
522: struct ber_element *
523: ber_printf_elements(struct ber_element *ber, char *fmt, ...)
524: {
525: va_list ap;
526: int d, class;
527: size_t len;
528: unsigned long type;
529: long long i;
530: char *s;
531: void *p;
532: struct ber_oid *o;
533: struct ber_element *sub = ber, *e;
534:
535: va_start(ap, fmt);
536: while (*fmt) {
537: switch (*fmt++) {
538: case 'B':
539: p = va_arg(ap, void *);
540: len = va_arg(ap, size_t);
541: if ((ber = ber_add_bitstring(ber, p, len)) == NULL)
542: goto fail;
543: break;
544: case 'b':
545: d = va_arg(ap, int);
546: if ((ber = ber_add_boolean(ber, d)) == NULL)
547: goto fail;
548: break;
549: case 'd':
550: d = va_arg(ap, int);
551: if ((ber = ber_add_integer(ber, d)) == NULL)
552: goto fail;
553: break;
554: case 'e':
555: e = va_arg(ap, struct ber_element *);
556: ber_link_elements(ber, e);
557: break;
558: case 'E':
559: i = va_arg(ap, long long);
560: if ((ber = ber_add_enumerated(ber, i)) == NULL)
561: goto fail;
562: break;
563: case 'i':
564: i = va_arg(ap, long long);
565: if ((ber = ber_add_integer(ber, i)) == NULL)
566: goto fail;
567: break;
568: case 'O':
569: o = va_arg(ap, struct ber_oid *);
570: if ((ber = ber_add_oid(ber, o)) == NULL)
571: goto fail;
572: break;
573: case 'o':
574: s = va_arg(ap, char *);
575: if ((ber = ber_add_oidstring(ber, s)) == NULL)
576: goto fail;
577: break;
578: case 's':
579: s = va_arg(ap, char *);
580: if ((ber = ber_add_string(ber, s)) == NULL)
581: goto fail;
582: break;
583: case 't':
584: class = va_arg(ap, int);
585: type = va_arg(ap, unsigned long);
586: ber_set_header(ber, class, type);
587: break;
588: case 'x':
589: s = va_arg(ap, char *);
590: len = va_arg(ap, size_t);
591: if ((ber = ber_add_nstring(ber, s, len)) == NULL)
592: goto fail;
593: break;
594: case '0':
595: if ((ber = ber_add_null(ber)) == NULL)
596: goto fail;
597: break;
598: case '{':
599: if ((ber = sub = ber_add_sequence(ber)) == NULL)
600: goto fail;
601: break;
602: case '(':
603: if ((ber = sub = ber_add_set(ber)) == NULL)
604: goto fail;
605: break;
606: case '}':
607: case ')':
608: ber = sub;
609: break;
610: case '.':
611: if ((e = ber_add_eoc(ber)) == NULL)
612: goto fail;
613: ber = e;
614: break;
615: default:
616: break;
617: }
618: }
619: va_end(ap);
620:
621: return (ber);
622: fail:
623: ber_free_elements(ber);
624: return (NULL);
625: }
626:
627: int
628: ber_scanf_elements(struct ber_element *ber, char *fmt, ...)
629: {
630: #define _MAX_SEQ 128
631: va_list ap;
632: int *d, level = -1;
633: unsigned long *t;
634: long long *i;
635: void **ptr;
636: size_t *len, ret = 0, n = strlen(fmt);
637: char **s;
638: struct ber_oid *o;
639: struct ber_element *parent[_MAX_SEQ], **e;
640:
641: memset(parent, 0, sizeof(struct ber_element *) * _MAX_SEQ);
642:
643: va_start(ap, fmt);
644: while (*fmt) {
645: switch (*fmt++) {
646: case 'B':
647: ptr = va_arg(ap, void **);
648: len = va_arg(ap, size_t *);
649: if (ber_get_bitstring(ber, ptr, len) == -1)
650: goto fail;
651: ret++;
652: break;
653: case 'b':
654: d = va_arg(ap, int *);
655: if (ber_get_boolean(ber, d) == -1)
656: goto fail;
657: ret++;
658: break;
659: case 'e':
660: e = va_arg(ap, struct ber_element **);
661: *e = ber;
662: ret++;
663: continue;
664: case 'E':
665: i = va_arg(ap, long long *);
666: if (ber_get_enumerated(ber, i) == -1)
667: goto fail;
668: ret++;
669: break;
670: case 'i':
671: i = va_arg(ap, long long *);
672: if (ber_get_integer(ber, i) == -1)
673: goto fail;
674: ret++;
675: break;
676: case 'o':
677: o = va_arg(ap, struct ber_oid *);
678: if (ber_get_oid(ber, o) == -1)
679: goto fail;
680: ret++;
681: break;
682: case 'S':
683: ret++;
684: break;
685: case 's':
686: s = va_arg(ap, char **);
687: if (ber_get_string(ber, s) == -1)
688: goto fail;
689: ret++;
690: break;
691: case 't':
692: d = va_arg(ap, int *);
693: t = va_arg(ap, unsigned long *);
694: *d = ber->be_class;
695: *t = ber->be_type;
696: ret++;
697: continue;
698: case 'x':
699: ptr = va_arg(ap, void **);
700: len = va_arg(ap, size_t *);
701: if (ber_get_nstring(ber, ptr, len) == -1)
702: goto fail;
703: ret++;
704: break;
705: case '0':
706: if (ber->be_encoding != BER_TYPE_NULL)
707: goto fail;
708: ret++;
709: break;
710: case '.':
711: if (ber->be_encoding != BER_TYPE_EOC)
712: goto fail;
713: ret++;
714: break;
715: case '{':
716: case '(':
717: if (ber->be_encoding != BER_TYPE_SEQUENCE &&
718: ber->be_encoding != BER_TYPE_SET)
719: goto fail;
720: if (ber->be_sub == NULL || level >= _MAX_SEQ-1)
721: goto fail;
722: parent[++level] = ber;
723: ber = ber->be_sub;
724: ret++;
725: continue;
726: case '}':
727: case ')':
728: if (parent[level] == NULL)
729: goto fail;
730: ber = parent[level--];
731: ret++;
732: continue;
733: default:
734: goto fail;
735: }
736:
737: if (ber->be_next == NULL)
738: continue;
739: ber = ber->be_next;
740: }
741: va_end(ap);
742: return (ret == n ? 0 : -1);
743:
744: fail:
745: va_end(ap);
746: return (-1);
747:
748: }
749:
750: /*
751: * write ber elements to the socket
752: *
753: * params:
754: * ber holds the socket
755: * root fully populated element tree
756: *
757: * returns:
758: * >=0 number of bytes written
759: * -1 on failure and sets errno
760: */
761: int
762: ber_write_elements(struct ber *ber, struct ber_element *root)
763: {
764: size_t len;
765:
766: /* calculate length because only the definite form is required */
767: len = ber_calc_len(root);
768: DPRINTF("write ber element of %zd bytes length\n", len);
769:
770: if (ber->br_wbuf != NULL && ber->br_wbuf + len > ber->br_wend) {
771: free(ber->br_wbuf);
772: ber->br_wbuf = NULL;
773: }
774: if (ber->br_wbuf == NULL) {
775: if ((ber->br_wbuf = malloc(len)) == NULL)
776: return -1;
777: ber->br_wend = ber->br_wbuf + len;
778: }
779:
780: /* reset write pointer */
781: ber->br_wptr = ber->br_wbuf;
782:
783: if (ber_dump_element(ber, root) == -1)
784: return -1;
785:
786: return (len);
787: }
788:
789: /*
790: * read ber elements from the socket
791: *
792: * params:
793: * ber holds the socket and lot more
794: * root if NULL, build up an element tree from what we receive on
795: * the wire. If not null, use the specified encoding for the
796: * elements received.
797: *
798: * returns:
799: * !=NULL, elements read and store in the ber_element tree
800: * NULL, type mismatch or read error
801: */
802: struct ber_element *
803: ber_read_elements(struct ber *ber, struct ber_element *elm)
804: {
805: struct ber_element *root = elm;
806:
807: if (root == NULL) {
808: if ((root = ber_get_element(0)) == NULL)
809: return NULL;
810: }
811:
812: DPRINTF("read ber elements, root %p\n", root);
813:
814: if (ber_read_element(ber, root) == -1) {
815: /* Cleanup if root was allocated by us */
816: if (elm == NULL)
817: ber_free_elements(root);
818: return NULL;
819: }
820:
821: return root;
822: }
823:
824: void
825: ber_free_elements(struct ber_element *root)
826: {
827: if (root->be_sub && (root->be_encoding == BER_TYPE_SEQUENCE ||
828: root->be_encoding == BER_TYPE_SET))
829: ber_free_elements(root->be_sub);
830: if (root->be_next)
831: ber_free_elements(root->be_next);
832: if (root->be_free && (root->be_encoding == BER_TYPE_OCTETSTRING ||
833: root->be_encoding == BER_TYPE_BITSTRING ||
834: root->be_encoding == BER_TYPE_OBJECT))
835: free(root->be_val);
836: free(root);
837: }
838:
839: size_t
840: ber_calc_len(struct ber_element *root)
841: {
842: unsigned long t;
843: size_t s;
844: size_t size = 2; /* minimum 1 byte head and 1 byte size */
845:
846: /* calculate the real length of a sequence or set */
847: if (root->be_sub && (root->be_encoding == BER_TYPE_SEQUENCE ||
848: root->be_encoding == BER_TYPE_SET))
849: root->be_len = ber_calc_len(root->be_sub);
850:
851: /* fix header length for extended types */
852: if (root->be_type > BER_TYPE_SINGLE_MAX)
853: for (t = root->be_type; t > 0; t >>= 7)
854: size++;
855: if (root->be_len >= BER_TAG_MORE)
856: for (s = root->be_len; s > 0; s >>= 8)
857: size++;
858:
859: /* calculate the length of the following elements */
860: if (root->be_next)
861: size += ber_calc_len(root->be_next);
862:
863: /* This is an empty element, do not use a minimal size */
864: if (root->be_type == BER_TYPE_EOC && root->be_len == 0)
865: return (0);
866:
867: return (root->be_len + size);
868: }
869:
870: /*
871: * internal functions
872: */
873:
874: static int
875: ber_dump_element(struct ber *ber, struct ber_element *root)
876: {
877: unsigned long long l;
878: int i;
879: uint8_t u;
880:
881: ber_dump_header(ber, root);
882:
883: switch (root->be_encoding) {
884: case BER_TYPE_BOOLEAN:
885: case BER_TYPE_INTEGER:
886: case BER_TYPE_ENUMERATED:
887: l = (unsigned long long)root->be_numeric;
888: for (i = root->be_len; i > 0; i--) {
889: u = (l >> ((i - 1) * 8)) & 0xff;
890: ber_putc(ber, u);
891: }
892: break;
893: case BER_TYPE_BITSTRING:
894: return -1;
895: case BER_TYPE_OCTETSTRING:
896: case BER_TYPE_OBJECT:
897: ber_write(ber, root->be_val, root->be_len);
898: break;
899: case BER_TYPE_NULL: /* no payload */
900: case BER_TYPE_EOC:
901: break;
902: case BER_TYPE_SEQUENCE:
903: case BER_TYPE_SET:
904: if (root->be_sub && ber_dump_element(ber, root->be_sub) == -1)
905: return -1;
906: break;
907: }
908:
909: if (root->be_next == NULL)
910: return 0;
911: return ber_dump_element(ber, root->be_next);
912: }
913:
914: static void
915: ber_dump_header(struct ber *ber, struct ber_element *root)
916: {
917: u_char id = 0, t, buf[8];
918: unsigned long type;
919: size_t size;
920:
921: /* class universal, type encoding depending on type value */
922: /* length encoding */
923: if (root->be_type <= BER_TYPE_SINGLE_MAX) {
924: id = root->be_type | (root->be_class << BER_CLASS_SHIFT);
925: if (root->be_encoding == BER_TYPE_SEQUENCE ||
926: root->be_encoding == BER_TYPE_SET)
927: id |= BER_TYPE_CONSTRUCTED;
928:
929: ber_putc(ber, id);
930: } else {
931: id = BER_TAG_MASK | (root->be_class << BER_CLASS_SHIFT);
932: if (root->be_encoding == BER_TYPE_SEQUENCE ||
933: root->be_encoding == BER_TYPE_SET)
934: id |= BER_TYPE_CONSTRUCTED;
935:
936: ber_putc(ber, id);
937:
938: for (t = 0, type = root->be_type; type > 0; type >>= 7)
939: buf[t++] = type & ~BER_TAG_MORE;
940:
941: while (t-- > 0) {
942: if (t > 0)
943: buf[t] |= BER_TAG_MORE;
944: ber_putc(ber, buf[t]);
945: }
946: }
947:
948: if (root->be_len < BER_TAG_MORE) {
949: /* short form */
950: ber_putc(ber, root->be_len);
951: } else {
952: for (t = 0, size = root->be_len; size > 0; size >>= 8)
953: buf[t++] = size & 0xff;
954:
955: ber_putc(ber, t | BER_TAG_MORE);
956:
957: while (t > 0)
958: ber_putc(ber, buf[--t]);
959: }
960: }
961:
962: static void
963: ber_putc(struct ber *ber, u_char c)
964: {
965: if (ber->br_wptr + 1 <= ber->br_wend)
966: *ber->br_wptr = c;
967: ber->br_wptr++;
968: }
969:
970: static void
971: ber_write(struct ber *ber, void *buf, size_t len)
972: {
973: if (ber->br_wptr + len <= ber->br_wend)
974: bcopy(buf, ber->br_wptr, len);
975: ber->br_wptr += len;
976: }
977:
978: /*
979: * extract a BER encoded tag. There are two types, a short and long form.
980: */
981: static ssize_t
982: get_id(struct ber *b, unsigned long *tag, int *class, int *cstruct)
983: {
984: u_char u;
985: size_t i = 0;
986: unsigned long t = 0;
987:
988: if (ber_getc(b, &u) == -1)
989: return -1;
990:
991: *class = (u >> BER_CLASS_SHIFT) & BER_CLASS_MASK;
992: *cstruct = (u & BER_TYPE_CONSTRUCTED) == BER_TYPE_CONSTRUCTED;
993:
994: if ((u & BER_TAG_MASK) != BER_TAG_MASK) {
995: *tag = u & BER_TAG_MASK;
996: return 1;
997: }
998:
999: do {
1000: if (ber_getc(b, &u) == -1)
1001: return -1;
1002: t = (t << 7) | (u & ~BER_TAG_MORE);
1003: i++;
1004: } while (u & BER_TAG_MORE);
1005:
1006: if (i > sizeof(unsigned long)) {
1007: errno = ERANGE;
1008: return -1;
1009: }
1010:
1011: *tag = t;
1012: return i + 1;
1013: }
1014:
1015: /*
1016: * extract length of a ber object -- if length is unknown an error is returned.
1017: */
1018: static ssize_t
1019: get_len(struct ber *b, ssize_t *len)
1020: {
1021: u_char u, n;
1022: ssize_t s, r;
1023:
1024: if (ber_getc(b, &u) == -1)
1025: return -1;
1026: if ((u & BER_TAG_MORE) == 0) {
1027: /* short form */
1028: *len = u;
1029: return 1;
1030: }
1031:
1032: n = u & ~BER_TAG_MORE;
1033: if (sizeof(ssize_t) < n) {
1034: errno = ERANGE;
1035: return -1;
1036: }
1037: r = n + 1;
1038:
1039: for (s = 0; n > 0; n--) {
1040: if (ber_getc(b, &u) == -1)
1041: return -1;
1042: s = (s << 8) | u;
1043: }
1044:
1045: if (s < 0) {
1046: /* overflow */
1047: errno = ERANGE;
1048: return -1;
1049: }
1050:
1051: if (s == 0) {
1052: /* invalid encoding */
1053: errno = EINVAL;
1054: return -1;
1055: }
1056:
1057: *len = s;
1058: return r;
1059: }
1060:
1061: static ssize_t
1062: ber_read_element(struct ber *ber, struct ber_element *elm)
1063: {
1064: long long val = 0;
1065: struct ber_element *next;
1066: unsigned long type;
1067: int i, class, cstruct;
1068: ssize_t len, r, totlen = 0;
1069: u_char c;
1070:
1071: if ((r = get_id(ber, &type, &class, &cstruct)) == -1)
1072: return -1;
1073: DPRINTF("ber read got class %d type %lu, %s\n",
1074: class, type, cstruct ? "constructive" : "primitive");
1075: totlen += r;
1076: if ((r = get_len(ber, &len)) == -1)
1077: return -1;
1078: DPRINTF("ber read element size %zd\n", len);
1079: totlen += r + len;
1080:
1081: /* If the total size of the element is larger than external
1082: * buffer don't bother to continue. */
1083: if (len > ber->br_rend - ber->br_rptr) {
1084: errno = ECANCELED;
1085: return -1;
1086: }
1087:
1088: elm->be_type = type;
1089: elm->be_len = len;
1090: elm->be_class = class;
1091:
1092: if (elm->be_encoding == 0) {
1093: /* try to figure out the encoding via class, type and cstruct */
1094: if (cstruct)
1095: elm->be_encoding = BER_TYPE_SEQUENCE;
1096: else if (class == BER_CLASS_UNIVERSAL)
1097: elm->be_encoding = type;
1098: else if (ber->br_application != NULL) {
1099: /*
1100: * Ask the application to map the encoding to a
1101: * universal type. For example, a SMI IpAddress
1102: * type is defined as 4 byte OCTET STRING.
1103: */
1104: elm->be_encoding = (*ber->br_application)(elm);
1105: } else
1106: /* last resort option */
1107: elm->be_encoding = BER_TYPE_NULL;
1108: }
1109:
1110: switch (elm->be_encoding) {
1111: case BER_TYPE_EOC: /* End-Of-Content */
1112: break;
1113: case BER_TYPE_BOOLEAN:
1114: case BER_TYPE_INTEGER:
1115: case BER_TYPE_ENUMERATED:
1116: if (len > (ssize_t)sizeof(long long))
1117: return -1;
1118: for (i = 0; i < len; i++) {
1119: if (ber_getc(ber, &c) != 1)
1120: return -1;
1121: val <<= 8;
1122: val |= c;
1123: }
1124:
1125: /* sign extend if MSB is set */
1126: if (val >> ((i - 1) * 8) & 0x80)
1127: val |= ULLONG_MAX << (i * 8);
1128: elm->be_numeric = val;
1129: break;
1130: case BER_TYPE_BITSTRING:
1131: elm->be_val = malloc(len);
1132: if (elm->be_val == NULL)
1133: return -1;
1134: elm->be_free = 1;
1135: elm->be_len = len;
1136: ber_read(ber, elm->be_val, len);
1137: break;
1138: case BER_TYPE_OCTETSTRING:
1139: case BER_TYPE_OBJECT:
1140: elm->be_val = malloc(len + 1);
1141: if (elm->be_val == NULL)
1142: return -1;
1143: elm->be_free = 1;
1144: elm->be_len = len;
1145: ber_read(ber, elm->be_val, len);
1146: ((u_char *)elm->be_val)[len] = '\0';
1147: break;
1148: case BER_TYPE_NULL: /* no payload */
1149: if (len != 0)
1150: return -1;
1151: break;
1152: case BER_TYPE_SEQUENCE:
1153: case BER_TYPE_SET:
1154: if (elm->be_sub == NULL) {
1155: if ((elm->be_sub = ber_get_element(0)) == NULL)
1156: return -1;
1157: }
1158: next = elm->be_sub;
1159: while (len > 0) {
1160: r = ber_read_element(ber, next);
1161: if (r == -1)
1162: return -1;
1163: len -= r;
1164: if (len > 0 && next->be_next == NULL) {
1165: if ((next->be_next = ber_get_element(0)) ==
1166: NULL)
1167: return -1;
1168: }
1169: next = next->be_next;
1170: }
1171: break;
1172: }
1173: return totlen;
1174: }
1175:
1176: static ssize_t
1177: ber_readbuf(struct ber *b, void *buf, size_t nbytes)
1178: {
1179: size_t sz;
1180: size_t len;
1181:
1182: if (b->br_rbuf == NULL)
1183: return -1;
1184:
1185: sz = b->br_rend - b->br_rptr;
1186: len = MINIMUM(nbytes, sz);
1187: if (len == 0) {
1188: errno = ECANCELED;
1189: return (-1); /* end of buffer and parser wants more data */
1190: }
1191:
1192: bcopy(b->br_rptr, buf, len);
1193: b->br_rptr += len;
1194:
1195: return (len);
1196: }
1197:
1198: void
1199: ber_set_readbuf(struct ber *b, void *buf, size_t len)
1200: {
1201: b->br_rbuf = b->br_rptr = buf;
1202: b->br_rend = (u_int8_t *)buf + len;
1203: }
1204:
1205: ssize_t
1206: ber_get_writebuf(struct ber *b, void **buf)
1207: {
1208: if (b->br_wbuf == NULL)
1209: return -1;
1210: *buf = b->br_wbuf;
1211: return (b->br_wend - b->br_wbuf);
1212: }
1213:
1214: void
1215: ber_set_application(struct ber *b, unsigned long (*cb)(struct ber_element *))
1216: {
1217: b->br_application = cb;
1218: }
1219:
1220: void
1221: ber_free(struct ber *b)
1222: {
1223: free(b->br_wbuf);
1224: }
1225:
1226: static ssize_t
1227: ber_getc(struct ber *b, u_char *c)
1228: {
1229: return ber_readbuf(b, c, 1);
1230: }
1231:
1232: static ssize_t
1233: ber_read(struct ber *ber, void *buf, size_t len)
1234: {
1235: u_char *b = buf;
1236: ssize_t r, remain = len;
1237:
1238: while (remain > 0) {
1239: r = ber_readbuf(ber, b, remain);
1240: if (r == -1)
1241: return -1;
1242: if (r == 0)
1243: return (b - (u_char *)buf);
1244: b += r;
1245: remain -= r;
1246: }
1247: return (b - (u_char *)buf);
1248: }