Debian Codegraph @

src/asn1-func.c

raw
1 /* asn1-func.c - Fucntions for the ASN.1 data structures.
2 * Copyright (C) 2000, 2001 Fabio Fiorina
3 * Copyright (C) 2001 Free Software Foundation, Inc.
4 * Copyright (C) 2002, 2003, 2006, 2007, 2010, 2012 g10 Code GmbH
5 *
6 * KSBA is free software; you can redistribute it and/or modify
7 * it under the terms of either
8 *
9 * - the GNU Lesser General Public License as published by the Free
10 * Software Foundation; either version 3 of the License, or (at
11 * your option) any later version.
12 *
13 * or
14 *
15 * - the GNU General Public License as published by the Free
16 * Software Foundation; either version 2 of the License, or (at
17 * your option) any later version.
18 *
19 * or both in parallel, as here.
20 *
21 * KSBA is distributed in the hope that it will be useful, but WITHOUT
22 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
23 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
24 * License for more details.
25 *
26 * You should have received a copies of the GNU General Public License
27 * and the GNU Lesser General Public License along with this program;
28 * if not, see <http://www.gnu.org/licenses/>.
29 */
30
31 #ifndef BUILD_GENTOOLS
32 #include <config.h>
33 #endif
34
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <ctype.h>
39 #include <assert.h>
40
41 #ifdef BUILD_GENTOOLS
42 # include "gen-help.h"
43 #else
44 # include "util.h"
45 # include "ksba.h"
46 #endif
47
48 #include "asn1-func.h"
49
50 #ifdef BUILD_GENTOOLS
51 #define gpgrt_log_debug(...) /**/
52 #endif
53
54
55 static AsnNode resolve_identifier (AsnNode root, AsnNode node, int nestlevel);
56
57
58 static AsnNode
59 add_node (node_type_t type)
60 {
61 AsnNode punt;
62
63 punt = xmalloc (sizeof *punt);
64
65 punt->left = NULL;
66 punt->name = NULL;
67 punt->type = type;
68 punt->valuetype = VALTYPE_NULL;
69 punt->value.v_cstr = NULL;
70 punt->off = -1;
71 punt->nhdr = 0;
72 punt->len = 0;
73 punt->down = NULL;
74 punt->right = NULL;
75 punt->link_next = NULL;
76 return punt;
77 }
78
79 AsnNode
80 _ksba_asn_new_node (node_type_t type)
81 {
82 return add_node (type);
83 }
84
85
86 int
87 _ksba_asn_is_primitive (node_type_t type)
88 {
89 switch (type)
90 {
91 case TYPE_BOOLEAN:
92 case TYPE_INTEGER:
93 case TYPE_BIT_STRING:
94 case TYPE_OCTET_STRING:
95 case TYPE_NULL:
96 case TYPE_OBJECT_ID:
97 case TYPE_OBJECT_DESCRIPTOR:
98 case TYPE_REAL:
99 case TYPE_ENUMERATED:
100 case TYPE_UTF8_STRING:
101 case TYPE_REALTIVE_OID:
102 case TYPE_NUMERIC_STRING:
103 case TYPE_PRINTABLE_STRING:
104 case TYPE_TELETEX_STRING:
105 case TYPE_VIDEOTEX_STRING:
106 case TYPE_IA5_STRING:
107 case TYPE_UTC_TIME:
108 case TYPE_GENERALIZED_TIME:
109 case TYPE_GRAPHIC_STRING:
110 case TYPE_VISIBLE_STRING:
111 case TYPE_GENERAL_STRING:
112 case TYPE_UNIVERSAL_STRING:
113 case TYPE_CHARACTER_STRING:
114 case TYPE_BMP_STRING:
115 case TYPE_PRE_SEQUENCE:
116 case TYPE_PRE_SET_OF:
117 return 1;
118 default:
119 return 0;
120 }
121 }
122
123
124 /* Change the value field of the node to the content of buffer value
125 of size LEN. With VALUE of NULL or LEN of 0 and a VTYPE of
126 VALTYPE_NULL the value field is deleted */
127 void
128 _ksba_asn_set_value (AsnNode node,
129 enum asn_value_type vtype, const void *value, size_t len)
130 {
131 return_if_fail (node);
132
133 if (node->valuetype)
134 {
135 if (node->valuetype == VALTYPE_CSTR)
136 xfree (node->value.v_cstr);
137 else if (node->valuetype == VALTYPE_MEM)
138 xfree (node->value.v_mem.buf);
139 node->valuetype = 0;
140 }
141
142 switch (vtype)
143 {
144 case VALTYPE_NULL:
145 break;
146 case VALTYPE_BOOL:
147 return_if_fail (len && value);
148 node->value.v_bool = !!*(const unsigned *)value;
149 break;
150 case VALTYPE_CSTR:
151 return_if_fail (value);
152 node->value.v_cstr = xstrdup (value);
153 break;
154 case VALTYPE_MEM:
155 node->value.v_mem.len = len;
156 if (len && value)
157 {
158 node->value.v_mem.buf = xmalloc (len);
159 memcpy (node->value.v_mem.buf, value, len);
160 }
161 else
162 node->value.v_mem.buf = NULL;
163 break;
164 case VALTYPE_LONG:
165 return_if_fail (sizeof (long) == len && value);
166 node->value.v_long = *(long *)value;
167 break;
168
169 case VALTYPE_ULONG:
170 return_if_fail (sizeof (unsigned long) == len && value);
171 node->value.v_ulong = *(unsigned long *)value;
172 break;
173
174 default:
175 return_if_fail (0);
176 }
177 node->valuetype = vtype;
178 }
179
180 static void
181 copy_value (AsnNode d, const AsnNode s)
182 {
183 char helpbuf[1];
184 const void *buf = NULL;
185 size_t len = 0;
186
187 return_if_fail (d != s);
188
189 switch (s->valuetype)
190 {
191 case VALTYPE_NULL:
192 break;
193 case VALTYPE_BOOL:
194 len = 1;
195 helpbuf[0] = s->value.v_bool;
196 buf = helpbuf;
197 break;
198 case VALTYPE_CSTR:
199 buf = s->value.v_cstr;
200 break;
201 case VALTYPE_MEM:
202 len = s->value.v_mem.len;
203 buf = len? s->value.v_mem.buf : NULL;
204 break;
205 case VALTYPE_LONG:
206 len = sizeof (long);
207 buf = &s->value.v_long;
208 break;
209 case VALTYPE_ULONG:
210 len = sizeof (unsigned long);
211 buf = &s->value.v_ulong;
212 break;
213
214 default:
215 return_if_fail (0);
216 }
217 _ksba_asn_set_value (d, s->valuetype, buf, len);
218 d->off = s->off;
219 d->nhdr = s->nhdr;
220 d->len = s->len;
221 }
222
223 static AsnNode
224 copy_node (const AsnNode s)
225 {
226 AsnNode d = add_node (s->type);
227
228 if (s->name)
229 d->name = xstrdup (s->name);
230 d->flags = s->flags;
231 copy_value (d, s);
232 return d;
233 }
234
235
236
237
238 /* Change the name field of the node to NAME.
239 NAME may be NULL */
240 void
241 _ksba_asn_set_name (AsnNode node, const char *name)
242 {
243 return_if_fail (node);
244
245 if (node->name)
246 {
247 xfree (node->name);
248 node->name = NULL;
249 }
250
251 if (name && *name)
252 node->name = xstrdup (name);
253 }
254
255
256 static AsnNode
257 set_right (AsnNode node, AsnNode right)
258 {
259 if (node == NULL)
260 return node;
261
262 node->right = right;
263 if (right)
264 right->left = node;
265 return node;
266 }
267
268
269 static AsnNode
270 set_down (AsnNode node, AsnNode down)
271 {
272 if (node == NULL)
273 return node;
274
275 node->down = down;
276 if (down)
277 down->left = node;
278 return node;
279 }
280
281
282 void
283 _ksba_asn_remove_node (AsnNode node)
284 {
285 if (node == NULL)
286 return;
287
288 xfree (node->name);
289 if (node->valuetype == VALTYPE_CSTR)
290 xfree (node->value.v_cstr);
291 else if (node->valuetype == VALTYPE_MEM)
292 xfree (node->value.v_mem.buf);
293 xfree (node);
294 }
295
296
297 /* find the node with the given name. A name part of "?LAST" matches
298 the last element of a SET_OF. A "+" matches the CHOICE with values
299 set. */
300 static AsnNode
301 find_node (AsnNode root, const char *name, int resolve)
302 {
303 AsnNode p;
304 const char *s;
305 char buf[129];
306 int i;
307
308 if (!name || !name[0])
309 return NULL;
310
311 /* gpgrt_log_debug ("%s: looking for '%s'\n", __func__, name); */
312 /* find the first part */
313 s = name;
314 for (i=0; *s && *s != '.' && i < DIM(buf)-1; s++)
315 buf[i++] = *s;
316 buf[i] = 0;
317 return_null_if_fail (i < DIM(buf)-1);
318
319 for (p = root; p && (!p->name || strcmp (p->name, buf)); p = p->right)
320 ;
321
322 /* find other parts */
323 while (p && *s)
324 {
325 assert (*s == '.');
326 s++; /* skip the dot */
327
328 if (!p->down)
329 return NULL; /* not found */
330 p = p->down;
331
332 for (i=0; *s && *s != '.' && i < DIM(buf)-1; s++)
333 buf[i++] = *s;
334 buf[i] = 0;
335 return_null_if_fail (i < DIM(buf)-1);
336
337 if (!*buf)
338 {
339 /* a double dot can be used to get over an unnamed sequence
340 in a set - Actually a hack to workaround a bug. We should
341 rethink the entire node naming issue */
342 /* gpgrt_log_debug ("%s: .. to '%s'\n", __func__, p?p->name:""); */
343 }
344 else if (!strcmp (buf, "?LAST"))
345 {
346 if (!p)
347 return NULL;
348 while (p->right)
349 p = p->right;
350 }
351 else if (*buf == '+' && !buf[1])
352 {
353 for (; p ; p = p->right)
354 if (p->off != -1)
355 break;
356 /* gpgrt_log_debug ("%s: + to '%s'\n", __func__, p?p->name:""); */
357 }
358 else
359 {
360 for (; p ; p = p->right)
361 {
362 /* gpgrt_log_debug ("%s: '%s' to '%s'\n", */
363 /* __func__, buf, p?p->name:""); */
364 if (p->name && !strcmp (p->name, buf))
365 break;
366 if (resolve && p->name && p->type == TYPE_IDENTIFIER)
367 {
368 AsnNode p2;
369
370 p2 = resolve_identifier (root, p, 0);
371 if (p2 && p2->name && !strcmp (p2->name, buf))
372 break;
373 }
374 }
375
376 if (resolve && p && p->type == TYPE_IDENTIFIER)
377 p = resolve_identifier (root, p, 0);
378 }
379 }
380
381 return p;
382 }
383
384 AsnNode
385 _ksba_asn_find_node (AsnNode root, const char *name)
386 {
387 return find_node (root, name, 0);
388 }
389
390
391 static AsnNode
392 _asn1_find_left (AsnNode node)
393 {
394 if ((node == NULL) || (node->left == NULL) || (node->left->down == node))
395 return NULL;
396
397 return node->left;
398 }
399
400
401 static AsnNode
402 find_up (AsnNode node)
403 {
404 AsnNode p;
405
406 if (node == NULL)
407 return NULL;
408
409 p = node;
410 while ((p->left != NULL) && (p->left->right == p))
411 p = p->left;
412
413 return p->left;
414 }
415
416
417
418 static void
419 print_value (AsnNode node, FILE *fp)
420 {
421 if (!node->valuetype)
422 return;
423 fprintf (fp, " vt=%d val=", node->valuetype);
424 switch (node->valuetype)
425 {
426 case VALTYPE_BOOL:
427 fputs (node->value.v_bool? "True":"False", fp);
428 break;
429 case VALTYPE_CSTR:
430 fputs (node->value.v_cstr, fp);
431 break;
432 case VALTYPE_MEM:
433 {
434 size_t n;
435 unsigned char *p;
436 for (p=node->value.v_mem.buf, n=node->value.v_mem.len; n; n--, p++)
437 fprintf (fp, "%02X", *p);
438 }
439 break;
440 case VALTYPE_LONG:
441 fprintf (fp, "%ld", node->value.v_long);
442 break;
443 case VALTYPE_ULONG:
444 fprintf (fp, "%lu", node->value.v_ulong);
445 break;
446 default:
447 return_if_fail (0);
448 }
449 }
450
451 void
452 _ksba_asn_node_dump (AsnNode p, FILE *fp)
453 {
454 const char *typestr;
455
456 switch (p->type)
457 {
458 case TYPE_NULL: typestr = "NULL"; break;
459 case TYPE_CONSTANT: typestr = "CONST"; break;
460 case TYPE_IDENTIFIER: typestr = "IDENTIFIER"; break;
461 case TYPE_INTEGER: typestr = "INTEGER"; break;
462 case TYPE_ENUMERATED: typestr = "ENUMERATED"; break;
463 case TYPE_UTC_TIME: typestr = "UTCTIME"; break;
464 case TYPE_GENERALIZED_TIME: typestr = "GENERALIZEDTIME"; break;
465 case TYPE_BOOLEAN: typestr = "BOOLEAN"; break;
466 case TYPE_SEQUENCE: typestr = "SEQUENCE"; break;
467 case TYPE_PRE_SEQUENCE: typestr = "PRE_SEQUENCE"; break;
468 case TYPE_PRE_SET_OF: typestr = "PRE_SET_OF"; break;
469 case TYPE_BIT_STRING: typestr = "BIT_STR"; break;
470 case TYPE_OCTET_STRING: typestr = "OCT_STR"; break;
471 case TYPE_TAG: typestr = "TAG"; break;
472 case TYPE_DEFAULT: typestr = "DEFAULT"; break;
473 case TYPE_SIZE: typestr = "SIZE"; break;
474 case TYPE_SEQUENCE_OF: typestr = "SEQ_OF"; break;
475 case TYPE_OBJECT_ID: typestr = "OBJ_ID"; break;
476 case TYPE_ANY: typestr = "ANY"; break;
477 case TYPE_SET: typestr = "SET"; break;
478 case TYPE_SET_OF: typestr = "SET_OF"; break;
479 case TYPE_CHOICE: typestr = "CHOICE"; break;
480 case TYPE_DEFINITIONS: typestr = "DEFINITIONS"; break;
481 case TYPE_UTF8_STRING: typestr = "UTF8_STRING"; break;
482 case TYPE_NUMERIC_STRING: typestr = "NUMERIC_STRING"; break;
483 case TYPE_PRINTABLE_STRING: typestr = "PRINTABLE_STRING"; break;
484 case TYPE_TELETEX_STRING: typestr = "TELETEX_STRING"; break;
485 case TYPE_IA5_STRING: typestr = "IA5_STRING"; break;
486 default: typestr = "ERROR\n"; break;
487 }
488
489 fprintf (fp, "%s", typestr);
490 if (p->name)
491 fprintf (fp, " `%s'", p->name);
492 print_value (p, fp);
493 fputs (" ", fp);
494 switch (p->flags.class)
495 {
496 case CLASS_UNIVERSAL: fputs ("U", fp); break;
497 case CLASS_PRIVATE: fputs ("P", fp); break;
498 case CLASS_APPLICATION: fputs ("A", fp); break;
499 case CLASS_CONTEXT: fputs ("C", fp); break;
500 }
501
502 if (p->flags.explicit)
503 fputs (",explicit", fp);
504 if (p->flags.implicit)
505 fputs (",implicit", fp);
506 if (p->flags.is_implicit)
507 fputs (",is_implicit", fp);
508 if (p->flags.has_tag)
509 fputs (",tag", fp);
510 if (p->flags.has_default)
511 fputs (",default", fp);
512 if (p->flags.is_true)
513 fputs (",true", fp);
514 if (p->flags.is_false)
515 fputs (",false", fp);
516 if (p->flags.has_list)
517 fputs (",list", fp);
518 if (p->flags.has_min_max)
519 fputs (",min_max", fp);
520 if (p->flags.is_optional)
521 fputs (",optional", fp);
522 if (p->flags.one_param)
523 fputs (",1_param", fp);
524 if (p->flags.has_size)
525 fputs (",size", fp);
526 if (p->flags.has_defined_by)
527 fputs (",def_by", fp);
528 if (p->flags.has_imports)
529 fputs (",imports", fp);
530 if (p->flags.assignment)
531 fputs (",assign",fp);
532 if (p->flags.in_set)
533 fputs (",in_set",fp);
534 if (p->flags.in_choice)
535 fputs (",in_choice",fp);
536 if (p->flags.in_array)
537 fputs (",in_array",fp);
538 if (p->flags.not_used)
539 fputs (",not_used",fp);
540 if (p->flags.skip_this)
541 fputs (",[skip]",fp);
542 if (p->flags.is_any)
543 fputs (",is_any",fp);
544 if (p->off != -1 )
545 fprintf (fp, " %d.%d.%d", p->off, p->nhdr, p->len );
546
547 }
548
549 void
550 _ksba_asn_node_dump_all (AsnNode root, FILE *fp)
551 {
552 AsnNode p = root;
553 int indent = 0;
554
555 while (p)
556 {
557 fprintf (fp, "%*s", indent, "");
558 _ksba_asn_node_dump (p, fp);
559 putc ('\n', fp);
560
561 if (p->down)
562 {
563 p = p->down;
564 indent += 2;
565 }
566 else if (p == root)
567 {
568 p = NULL;
569 break;
570 }
571 else if (p->right)
572 p = p->right;
573 else
574 {
575 while (1)
576 {
577 p = find_up (p);
578 if (p == root)
579 {
580 p = NULL;
581 break;
582 }
583 indent -= 2;
584 if (p->right)
585 {
586 p = p->right;
587 break;
588 }
589 }
590 }
591 }
592 }
593
594 /**
595 * ksba_asn_tree_dump:
596 * @tree: A Parse Tree
597 * @name: Name of the element or NULL
598 * @fp: dump to this stream
599 *
600 * If the first character of the name is a '<' the expanded version of
601 * the tree will be printed.
602 *
603 * This function is a debugging aid.
604 **/
605 void
606 ksba_asn_tree_dump (ksba_asn_tree_t tree, const char *name, FILE *fp)
607 {
608 AsnNode p, root;
609 int k, expand=0, indent = 0;
610
611 if (!tree || !tree->parse_tree)
612 return;
613
614 if ( name && *name== '<')
615 {
616 expand = 1;
617 name++;
618 if (!*name)
619 name = NULL;
620 }
621
622 root = name? _ksba_asn_find_node (tree->parse_tree, name) : tree->parse_tree;
623 if (!root)
624 return;
625
626 if (expand)
627 root = _ksba_asn_expand_tree (root, NULL);
628
629 p = root;
630 while (p)
631 {
632 for (k = 0; k < indent; k++)
633 fprintf (fp, " ");
634 _ksba_asn_node_dump (p, fp);
635 putc ('\n', fp);
636
637 if (p->down)
638 {
639 p = p->down;
640 indent += 2;
641 }
642 else if (p == root)
643 {
644 p = NULL;
645 break;
646 }
647 else if (p->right)
648 p = p->right;
649 else
650 {
651 while (1)
652 {
653 p = find_up (p);
654 if (p == root)
655 {
656 p = NULL;
657 break;
658 }
659 indent -= 2;
660 if (p->right)
661 {
662 p = p->right;
663 break;
664 }
665 }
666 }
667 }
668
669 if (expand)
670 _ksba_asn_release_nodes (root);
671 }
672
673 int
674 _ksba_asn_delete_structure (AsnNode root)
675 {
676 AsnNode p, p2, p3;
677
678 if (root == NULL)
679 return gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
680
681 p = root;
682 while (p)
683 {
684 if (p->down)
685 {
686 p = p->down;
687 }
688 else
689 { /* no down */
690 p2 = p->right;
691 if (p != root)
692 {
693 p3 = find_up (p);
694 set_down (p3, p2);
695 _ksba_asn_remove_node (p);
696 p = p3;
697 }
698 else
699 { /* p==root */
700 p3 = _asn1_find_left (p);
701 if (!p3)
702 {
703 p3 = find_up (p);
704 if (p3)
705 set_down (p3, p2);
706 else
707 {
708 if (p->right)
709 p->right->left = NULL;
710 }
711 }
712 else
713 set_right (p3, p2);
714 _ksba_asn_remove_node (p);
715 p = NULL;
716 }
717 }
718 }
719 return 0;
720 }
721
722
723 /* check that all identifiers referenced in the tree are available */
724 int
725 _ksba_asn_check_identifier (AsnNode node)
726 {
727 AsnNode p, p2;
728 char name2[129];
729
730 if (!node)
731 return gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
732
733 for (p = node; p; p = _ksba_asn_walk_tree (node, p))
734 {
735 if (p->type == TYPE_IDENTIFIER && p->valuetype == VALTYPE_CSTR)
736 {
737 if (strlen (node->name)+strlen(p->value.v_cstr)+2 > DIM(name2))
738 return gpg_error (GPG_ERR_BUG); /* well identifier too long */
739 strcpy (name2, node->name);
740 strcat (name2, ".");
741 strcat (name2, p->value.v_cstr);
742 p2 = _ksba_asn_find_node (node, name2);
743 if (!p2)
744 {
745 fprintf (stderr,"reference to `%s' not found\n", name2);
746 return gpg_error (GPG_ERR_IDENTIFIER_NOT_FOUND);
747 }
748 /* fprintf (stdout,"found reference for `%s' (", name2); */
749 /* print_node (p2, stdout); */
750 /* fputs (")\n", stdout); */
751 }
752 else if (p->type == TYPE_OBJECT_ID && p->flags.assignment)
753 { /* an object ID in an assignment */
754 p2 = p->down;
755 if (p2 && (p2->type == TYPE_CONSTANT))
756 {
757 if (p2->valuetype == VALTYPE_CSTR && !isdigit (p2->value.v_cstr[0]))
758 { /* the first constand below is a reference */
759 if (strlen (node->name)
760 +strlen(p->value.v_cstr)+2 > DIM(name2))
761 return gpg_error (GPG_ERR_BUG); /* well identifier too long */
762 strcpy (name2, node->name);
763 strcat (name2, ".");
764 strcat (name2, p2->value.v_cstr);
765 p2 = _ksba_asn_find_node (node, name2);
766 if (!p2)
767 {
768 fprintf (stderr,"object id reference `%s' not found\n",
769 name2);
770 return gpg_error (GPG_ERR_IDENTIFIER_NOT_FOUND);
771 }
772 else if ( p2->type != TYPE_OBJECT_ID
773 || !p2->flags.assignment )
774 {
775 fprintf (stderr,"`%s' is not an object id\n", name2);
776 return gpg_error (GPG_ERR_IDENTIFIER_NOT_FOUND);
777 }
778 /* fprintf (stdout,"found objid reference for `%s' (", name2); */
779 /* print_node (p2, stdout); */
780 /* fputs (")\n", stdout); */
781 }
782 }
783 }
784 }
785
786 return 0;
787 }
788
789
790 /* Get the next node until root is reached in which case NULL is
791 returned */
792 AsnNode
793 _ksba_asn_walk_tree (AsnNode root, AsnNode node)
794 {
795 if (!node)
796 ;
797 else if (node->down)
798 node = node->down;
799 else
800 {
801 if (node == root)
802 node = NULL;
803 else if (node->right)
804 node = node->right;
805 else
806 {
807 for (;;)
808 {
809 node = find_up (node);
810 if (node == root)
811 {
812 node = NULL;
813 break;
814 }
815 if (node->right)
816 {
817 node = node->right;
818 break;
819 }
820 }
821 }
822 }
823
824 return node;
825 }
826
827 AsnNode
828 _ksba_asn_walk_tree_up_right (AsnNode root, AsnNode node)
829 {
830 if (node)
831 {
832 if (node == root)
833 node = NULL;
834 else
835 {
836 for (;;)
837 {
838 node = find_up (node);
839 if (node == root)
840 {
841 node = NULL;
842 break;
843 }
844 if (node->right)
845 {
846 node = node->right;
847 break;
848 }
849 }
850 }
851 }
852
853 return node;
854 }
855
856 /* walk over the tree and change the value type of all integer types
857 from string to long. */
858 int
859 _ksba_asn_change_integer_value (AsnNode node)
860 {
861 AsnNode p;
862
863 if (node == NULL)
864 return gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
865
866 for (p = node; p; p = _ksba_asn_walk_tree (node, p))
867 {
868 if (p->type == TYPE_INTEGER && p->flags.assignment)
869 {
870 if (p->valuetype == VALTYPE_CSTR)
871 {
872 long val = strtol (p->value.v_cstr, NULL, 10);
873 _ksba_asn_set_value (p, VALTYPE_LONG, &val, sizeof(val));
874 }
875 }
876 }
877
878 return 0;
879 }
880
881
882
883 /* Expand all object ID constants */
884 int
885 _ksba_asn_expand_object_id (AsnNode node)
886 {
887 AsnNode p, p2, p3, p4, p5;
888 char name_root[129], name2[129*2+1] = "";
889
890 /* Fixme: Make a cleaner implementation */
891 if (!node)
892 return gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
893 if (!node->name)
894 return gpg_error (GPG_ERR_INV_VALUE);
895 if (strlen(node->name) >= DIM(name_root)-1)
896 return gpg_error (GPG_ERR_GENERAL);
897 strcpy (name_root, node->name);
898
899 restart:
900 for (p = node; p; p = _ksba_asn_walk_tree (node, p))
901 {
902 if (p->type == TYPE_OBJECT_ID && p->flags.assignment)
903 {
904 p2 = p->down;
905 if (p2 && p2->type == TYPE_CONSTANT)
906 {
907 if (p2->valuetype == VALTYPE_CSTR
908 && !isdigit (p2->value.v_cstr[0]))
909 {
910 if (strlen(p2->value.v_cstr)+1+strlen(name2) >= DIM(name2)-1)
911 return gpg_error (GPG_ERR_GENERAL);
912 strcpy (name2, name_root);
913 strcat (name2, ".");
914 strcat (name2, p2->value.v_cstr);
915 p3 = _ksba_asn_find_node (node, name2);
916 if (!p3 || p3->type != TYPE_OBJECT_ID ||
917 !p3->flags.assignment)
918 return gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
919 set_down (p, p2->right);
920 _ksba_asn_remove_node (p2);
921 p2 = p;
922 p4 = p3->down;
923 while (p4)
924 {
925 if (p4->type == TYPE_CONSTANT)
926 {
927 p5 = add_node (TYPE_CONSTANT);
928 _ksba_asn_set_name (p5, p4->name);
929 _ksba_asn_set_value (p5, VALTYPE_CSTR,
930 p4->value.v_cstr, 0);
931 if (p2 == p)
932 {
933 set_right (p5, p->down);
934 set_down (p, p5);
935 }
936 else
937 {
938 set_right (p5, p2->right);
939 set_right (p2, p5);
940 }
941 p2 = p5;
942 }
943 p4 = p4->right;
944 }
945 goto restart; /* the most simple way to get it right ;-) */
946 }
947 }
948 }
949 }
950 return 0;
951 }
952
953 /* Walk the parse tree and set the default tag where appropriate. The
954 node must be of type DEFINITIONS */
955 void
956 _ksba_asn_set_default_tag (AsnNode node)
957 {
958 AsnNode p;
959
960 return_if_fail (node && node->type == TYPE_DEFINITIONS);
961
962 for (p = node; p; p = _ksba_asn_walk_tree (node, p))
963 {
964 if ( p->type == TYPE_TAG
965 && !p->flags.explicit && !p->flags.implicit)
966 {
967 if (node->flags.explicit)
968 p->flags.explicit = 1;
969 else
970 p->flags.implicit = 1;
971 }
972 }
973 /* now mark the nodes which are implicit */
974 for (p = node; p; p = _ksba_asn_walk_tree (node, p))
975 {
976 if ( p->type == TYPE_TAG && p->flags.implicit && p->down)
977 {
978 if (p->down->type == TYPE_CHOICE)
979 ; /* a CHOICE is per se implicit */
980 else if (p->down->type != TYPE_TAG)
981 p->down->flags.is_implicit = 1;
982 }
983 }
984 }
985
986 /* Walk the tree and set the is_set and not_used flags for all nodes below
987 a node of type SET. */
988 void
989 _ksba_asn_type_set_config (AsnNode node)
990 {
991 AsnNode p, p2;
992
993 return_if_fail (node && node->type == TYPE_DEFINITIONS);
994
995 for (p = node; p; p = _ksba_asn_walk_tree (node, p))
996 {
997 if (p->type == TYPE_SET)
998 {
999 for (p2 = p->down; p2; p2 = p2->right)
1000 {
1001 if (p2->type != TYPE_TAG)
1002 {
1003 p2->flags.in_set = 1;
1004 p2->flags.not_used = 1;
1005 }
1006 }
1007 }
1008 else if (p->type == TYPE_CHOICE)
1009 {
1010 for (p2 = p->down; p2; p2 = p2->right)
1011 {
1012 p2->flags.in_choice = 1;
1013 }
1014 }
1015 else if (p->type == TYPE_SEQUENCE_OF || p->type == TYPE_SET_OF)
1016 {
1017 for (p2 = p->down; p2; p2 = p2->right)
1018 p2->flags.in_array = 1;
1019 }
1020 else if (p->type == TYPE_ANY)
1021 { /* Help the DER encoder to track ANY tags */
1022 p->flags.is_any = 1;
1023 }
1024 }
1025 }
1026
1027 /* Create a copy the tree at SRC_ROOT. s is a helper which should be
1028 set to SRC_ROOT by the caller */
1029 static AsnNode
1030 copy_tree (AsnNode src_root, AsnNode s)
1031 {
1032 AsnNode first=NULL, dprev=NULL, d, down, tmp;
1033 AsnNode *link_nextp = NULL;
1034
1035 for (; s; s=s->right )
1036 {
1037 down = s->down;
1038 d = copy_node (s);
1039 if (link_nextp)
1040 *link_nextp = d;
1041 link_nextp = &d->link_next;
1042
1043 if (!first)
1044 first = d;
1045 else
1046 {
1047 dprev->right = d;
1048 d->left = dprev;
1049 }
1050 dprev = d;
1051 if (down)
1052 {
1053 tmp = copy_tree (src_root, down);
1054 if (tmp)
1055 {
1056 if (link_nextp)
1057 *link_nextp = tmp;
1058 link_nextp = &tmp->link_next;
1059 while (*link_nextp)
1060 link_nextp = &(*link_nextp)->link_next;
1061 }
1062
1063 if (d->down && tmp)
1064 { /* Need to merge it with the existing down */
1065 AsnNode x;
1066
1067 for (x=d->down; x->right; x = x->right)
1068 ;
1069 x->right = tmp;
1070 tmp->left = x;
1071 }
1072 else
1073 {
1074 d->down = tmp;
1075 if (d->down)
1076 d->down->left = d;
1077 }
1078 }
1079 }
1080 return first;
1081 }
1082
1083
1084
1085 static AsnNode
1086 resolve_identifier (AsnNode root, AsnNode node, int nestlevel)
1087 {
1088 char buf_space[50];
1089 char *buf;
1090 AsnNode n;
1091 size_t bufsize;
1092
1093 if (nestlevel > 20)
1094 return NULL;
1095
1096 return_null_if_fail (root);
1097 return_null_if_fail (node->valuetype == VALTYPE_CSTR);
1098
1099 bufsize = strlen (root->name) + strlen (node->value.v_cstr) + 2;
1100 if (bufsize <= sizeof buf_space)
1101 buf = buf_space;
1102 else
1103 {
1104 buf = xtrymalloc (bufsize);
1105 return_null_if_fail (buf);
1106 }
1107 strcpy (stpcpy (stpcpy (buf, root->name), "."), node->value.v_cstr);
1108 n = _ksba_asn_find_node (root, buf);
1109
1110 /* We do just a simple indirection. */
1111 if (n && n->type == TYPE_IDENTIFIER)
1112 n = resolve_identifier (root, n, nestlevel+1);
1113
1114 if (buf != buf_space)
1115 xfree (buf);
1116
1117 return n;
1118 }
1119
1120
1121 static AsnNode
1122 do_expand_tree (AsnNode src_root, AsnNode s, int depth)
1123 {
1124 AsnNode first=NULL, dprev=NULL, d, down, tmp;
1125 AsnNode *link_nextp = NULL;
1126
1127 /* On the very first level we do not follow the right pointer so that
1128 we can break out a valid subtree. */
1129 for (; s; s=depth?s->right:NULL )
1130 {
1131 if (s->type == TYPE_SIZE)
1132 continue; /* this node gets in the way all the time. It
1133 should be an attribute to a node */
1134
1135 down = s->down;
1136 if (s->type == TYPE_IDENTIFIER)
1137 {
1138 AsnNode s2, *dp;
1139
1140 d = resolve_identifier (src_root, s, 0);
1141 if (!d)
1142 {
1143 fprintf (stderr, "RESOLVING IDENTIFIER FAILED\n");
1144 continue;
1145 }
1146 down = d->down;
1147 d = copy_node (d);
1148 if (link_nextp)
1149 *link_nextp = d;
1150 link_nextp = &d->link_next;
1151 if (s->flags.is_optional)
1152 d->flags.is_optional = 1;
1153 if (s->flags.in_choice)
1154 d->flags.in_choice = 1;
1155 if (s->flags.in_array)
1156 d->flags.in_array = 1;
1157 if (s->flags.is_implicit)
1158 d->flags.is_implicit = 1;
1159 if (s->flags.is_any)
1160 d->flags.is_any = 1;
1161 /* we don't want the resolved name - change it back */
1162 _ksba_asn_set_name (d, s->name);
1163 /* copy the default and tag attributes */
1164 tmp = NULL;
1165 dp = &tmp;
1166 for (s2=s->down; s2; s2=s2->right)
1167 {
1168 AsnNode x;
1169
1170 x = copy_node (s2);
1171 if (link_nextp)
1172 *link_nextp = x;
1173 link_nextp = &x->link_next;
1174 x->left = *dp? *dp : d;
1175 *dp = x;
1176 dp = &(*dp)->right;
1177
1178 if (x->type == TYPE_TAG)
1179 d->flags.has_tag =1;
1180 else if (x->type == TYPE_DEFAULT)
1181 d->flags.has_default =1;
1182 }
1183 d->down = tmp;
1184 }
1185 else
1186 {
1187 d = copy_node (s);
1188 if (link_nextp)
1189 *link_nextp = d;
1190 link_nextp = &d->link_next;
1191 }
1192
1193 if (!first)
1194 first = d;
1195 else
1196 {
1197 dprev->right = d;
1198 d->left = dprev;
1199 }
1200 dprev = d;
1201 if (down)
1202 {
1203 if (depth >= 1000)
1204 {
1205 fprintf (stderr, "ASN.1 TREE TOO TALL!\n");
1206 tmp = NULL;
1207 }
1208 else
1209 {
1210 tmp = do_expand_tree (src_root, down, depth+1);
1211 if (tmp)
1212 {
1213 if (link_nextp)
1214 *link_nextp = tmp;
1215 link_nextp = &tmp->link_next;
1216 while (*link_nextp)
1217 link_nextp = &(*link_nextp)->link_next;
1218 }
1219 }
1220 if (d->down && tmp)
1221 { /* Need to merge it with the existing down */
1222 AsnNode x;
1223
1224 for (x=d->down; x->right; x = x->right)
1225 ;
1226 x->right = tmp;
1227 tmp->left = x;
1228 }
1229 else
1230 {
1231 d->down = tmp;
1232 if (d->down)
1233 d->down->left = d;
1234 }
1235 }
1236 }
1237
1238 return first;
1239 }
1240
1241
1242 /* Expand the syntax tree so that all references are resolved and we
1243 are able to store values right in the tree (except for set/sequence
1244 of). This expanded tree is also an requirement for doing the DER
1245 decoding as the resolving of identifiers leads to a lot of
1246 problems. We use more memory of course, but this is negligible
1247 because the entire code will be simpler and faster */
1248 AsnNode
1249 _ksba_asn_expand_tree (AsnNode parse_tree, const char *name)
1250 {
1251 AsnNode root;
1252
1253 root = name? find_node (parse_tree, name, 1) : parse_tree;
1254 return do_expand_tree (parse_tree, root, 0);
1255 }
1256
1257
1258 /* Insert a copy of the entire tree at NODE as the sibling of itself
1259 and return the copy */
1260 AsnNode
1261 _ksba_asn_insert_copy (AsnNode node)
1262 {
1263 AsnNode n;
1264 AsnNode *link_nextp;
1265
1266 n = copy_tree (node, node);
1267 if (!n)
1268 return NULL; /* out of core */
1269 return_null_if_fail (n->right == node->right);
1270 node->right = n;
1271 n->left = node;
1272
1273 /* FIXME: Consider tail pointer for faster insertion. */
1274 link_nextp = &node->link_next;
1275 while (*link_nextp)
1276 link_nextp = &(*link_nextp)->link_next;
1277 *link_nextp = n;
1278
1279 return n;
1280 }
1281
1282
1283 /* Locate a type value sequence like
1284
1285 SEQUENCE {
1286 type OBJECT IDENTIFIER
1287 value ANY
1288 }
1289
1290 below root and return the 'value' node. OIDBUF should contain the
1291 DER encoding of an OID value. idx is the number of OIDs to skip;
1292 this can be used to enumerate structures with the same OID */
1293 AsnNode
1294 _ksba_asn_find_type_value (const unsigned char *image, AsnNode root, int idx,
1295 const void *oidbuf, size_t oidlen)
1296 {
1297 AsnNode n, noid;
1298
1299 if (!image || !root)
1300 return NULL;
1301
1302 for (n = root; n; n = _ksba_asn_walk_tree (root, n) )
1303 {
1304 if ( n->type == TYPE_SEQUENCE
1305 && n->down && n->down->type == TYPE_OBJECT_ID)
1306 {
1307 noid = n->down;
1308 if (noid->off != -1 && noid->len == oidlen
1309 && !memcmp (image + noid->off + noid->nhdr, oidbuf, oidlen)
1310 && noid->right)
1311 {
1312 if ( !idx-- )
1313 return noid->right;
1314 }
1315
1316 }
1317 }
1318 return NULL;
1319 }