Debian Codegraph @

src/asn1-gentables.c

raw
1 /* asn1-gentables.c - Tool to create required ASN tables
2 * Copyright (C) 2001, 2008 g10 Code GmbH
3 *
4 * This file is part of KSBA.
5 *
6 * KSBA is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * KSBA is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <errno.h>
24 #include <stdarg.h>
25
26 #include "gen-help.h"
27 #include "asn1-func.h"
28
29 #define PGMNAME "asn1-gentables"
30
31 #if (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
32 # define ATTR_PRINTF(a,b) __attribute__ ((format (printf,a,b)))
33 #else
34 # define ATTR_PRINTF(a,b)
35 #endif
36
37 #ifdef _WIN32
38 #define DEVNULL_NAME "nul"
39 #else
40 #define DEVNULL_NAME "/dev/null"
41 #endif
42
43
44 /* keep track of parsing error */
45 static int error_counter;
46
47 /* option --dump */
48 static int dump_only;
49 /* option --check */
50 static int check_only;
51
52 struct name_list_s {
53 struct name_list_s *next;
54 char name[1];
55 };
56
57 static struct name_list_s *string_table, **string_table_tail;
58 static size_t string_table_offset;
59
60 static void print_error (const char *fmt, ... ) ATTR_PRINTF(1,2);
61
62
63 static void
64 print_error (const char *fmt, ... )
65 {
66 va_list arg_ptr ;
67
68 va_start (arg_ptr, fmt);
69 fputs (PGMNAME ": ", stderr);
70 vfprintf (stderr, fmt, arg_ptr);
71 va_end (arg_ptr);
72 error_counter++;
73
74 }
75
76 static size_t
77 insert_string (const char *name)
78 {
79 struct name_list_s *item;
80 size_t off, n;
81
82 if (!string_table_tail)
83 {
84 string_table_tail = &string_table;
85 insert_string ("");
86 }
87
88 if (string_table_offset && !*name)
89 return 0;
90
91 for (item = string_table,off = 0; item; item = item->next)
92 {
93 for (n=0; item->name[n]; n++)
94 if (!strcmp (item->name+n, name))
95 return off + n;
96 off += strlen (item->name) + 1;
97 }
98
99 item = xmalloc ( sizeof *item + strlen (name));
100 strcpy (item->name, name);
101 item->next = NULL;
102 *string_table_tail = item;
103 string_table_tail = &item->next;
104 off = string_table_offset;
105 string_table_offset += strlen (name) + 1;
106 return off;
107 }
108
109 static int
110 cmp_string (const void *aptr, const void *bptr)
111 {
112 const char *a = (*(const struct name_list_s **)aptr)->name;
113 const char *b = (*(const struct name_list_s **)bptr)->name;
114
115 const size_t len_a = strlen(a);
116 const size_t len_b = strlen(b);
117
118 if (len_a < len_b)
119 return -1;
120 if (len_a > len_b)
121 return +1;
122 return strcmp(a, b);
123 }
124
125 static void
126 sort_string_table (void)
127 {
128 struct name_list_s *item;
129 struct name_list_s **array;
130 size_t i, arraylen;
131
132 if (!string_table || !string_table->next)
133 return; /* Nothing to sort. */
134
135 for (item = string_table,arraylen = 0; item; item = item->next)
136 arraylen++;
137 array = xcalloc (arraylen, sizeof *array);
138 for (item = string_table,arraylen = 0; item; item = item->next)
139 array[arraylen++] = item;
140 qsort (array, arraylen, sizeof *array, cmp_string);
141 /* Replace table by sorted one. */
142 string_table_tail = NULL;
143 string_table = NULL;
144 string_table_offset = 0;
145 for (i=0; i < arraylen; i++)
146 insert_string (array[i]->name);
147 xfree (array);
148 /* for (item = string_table,arraylen = 0; item; item = item->next) */
149 /* fprintf (stderr, " `%s'\n", item->name); */
150 }
151
152
153 static void
154 write_string_table (FILE *fp)
155 {
156 struct name_list_s *item;
157 const char *s;
158 int count = 0;
159 int pos;
160
161 if (!string_table)
162 insert_string ("");
163
164 fputs ("static const char string_table[] = {\n ", fp);
165 for (item = string_table; item; item = item->next)
166 {
167 for (s=item->name, pos=0; *s; s++)
168 {
169 if (!(pos++ % 16))
170 fprintf (fp, "%s ", pos>1? "\n":"");
171 fprintf (fp, "'%c',", *s);
172 }
173 fputs ("'\\0',\n", fp);
174 count++;
175 }
176 /* (we use an extra \0 to get rid of the last comma) */
177 fprintf (fp, " '\\0' };\n/* (%d strings) */\n", count);
178 }
179
180
181 static struct name_list_s *
182 create_static_structure (AsnNode pointer, const char *file_name, FILE *fp)
183 {
184 AsnNode p;
185 struct name_list_s *structure_name;
186 const char *char_p, *slash_p, *dot_p;
187 char numbuf[50];
188
189 char_p = file_name;
190 slash_p = file_name;
191 while ((char_p = strchr (char_p, '/')))
192 {
193 char_p++;
194 slash_p = char_p;
195 }
196
197 char_p = slash_p;
198 dot_p = file_name + strlen (file_name);
199
200 while ((char_p = strchr (char_p, '.')))
201 {
202 dot_p = char_p;
203 char_p++;
204 }
205
206 structure_name = xmalloc (sizeof *structure_name + dot_p - slash_p + 100);
207 structure_name->next = NULL;
208 memcpy (structure_name->name, slash_p, dot_p - slash_p);
209 structure_name->name[dot_p - slash_p] = 0;
210
211 fprintf (fp, "static const static_asn %s_asn1_tab[] = {\n",
212 structure_name->name);
213
214 for (p = pointer; p; p = _ksba_asn_walk_tree (pointer, p))
215 {
216 /* set the help flags */
217 p->flags.help_down = !!p->down;
218 p->flags.help_right = !!p->right;
219
220 /* write a structure line */
221 fputs (" {", fp);
222 if (p->name)
223 fprintf (fp, "%u", (unsigned int)insert_string (p->name));
224 else
225 fprintf (fp, "0");
226 fprintf (fp, ",%u", p->type);
227
228 fputs (", {", fp);
229 fprintf (fp, "%u", p->flags.class);
230 fputs (p->flags.explicit ? ",1":",0", fp);
231 fputs (p->flags.implicit ? ",1":",0", fp);
232 fputs (p->flags.has_imports ? ",1":",0", fp);
233 fputs (p->flags.assignment ? ",1":",0", fp);
234 fputs (p->flags.one_param ? ",1":",0", fp);
235 fputs (p->flags.has_tag ? ",1":",0", fp);
236 fputs (p->flags.has_size ? ",1":",0", fp);
237 fputs (p->flags.has_list ? ",1":",0", fp);
238 fputs (p->flags.has_min_max ? ",1":",0", fp);
239 fputs (p->flags.has_defined_by ? ",1":",0", fp);
240 fputs (p->flags.is_false ? ",1":",0", fp);
241 fputs (p->flags.is_true ? ",1":",0", fp);
242 fputs (p->flags.has_default ? ",1":",0", fp);
243 fputs (p->flags.is_optional ? ",1":",0", fp);
244 fputs (p->flags.is_implicit ? ",1":",0", fp);
245 fputs (p->flags.in_set ? ",1":",0", fp);
246 fputs (p->flags.in_choice ? ",1":",0", fp);
247 fputs (p->flags.in_array ? ",1":",0", fp);
248 fputs (p->flags.is_any ? ",1":",0", fp);
249 fputs (p->flags.not_used ? ",1":",0", fp);
250 fputs (p->flags.help_down ? ",1":",0", fp);
251 fputs (p->flags.help_right ? ",1":",0", fp);
252 fputs ("}", fp);
253
254 if (p->valuetype == VALTYPE_CSTR)
255 fprintf (fp, ",%u",
256 (unsigned int)insert_string (p->value.v_cstr));
257 else if (p->valuetype == VALTYPE_LONG
258 && p->type == TYPE_INTEGER && p->flags.assignment)
259 {
260 snprintf (numbuf, sizeof numbuf, "%ld", p->value.v_long);
261 fprintf (fp, ",%u", (unsigned int)insert_string (numbuf));
262 }
263 else if (p->valuetype == VALTYPE_ULONG)
264 {
265 snprintf (numbuf, sizeof numbuf, "%lu", p->value.v_ulong);
266 fprintf (fp, ",%u", (unsigned int)insert_string (numbuf));
267 }
268 else
269 {
270 if (p->valuetype)
271 print_error ("can't store a value of type %d\n", p->valuetype);
272 fprintf (fp, ",0");
273 }
274 fputs ("},\n", fp);
275 }
276
277 fprintf (fp, " {0,0}\n};\n");
278
279 return structure_name;
280 }
281
282
283
284 static struct name_list_s *
285 one_file (const char *fname, int *count, FILE *fp)
286 {
287 ksba_asn_tree_t tree;
288 int rc;
289
290 rc = ksba_asn_parse_file (fname, &tree, check_only);
291 if (rc)
292 print_error ("error parsing `%s': %s\n", fname, gpg_strerror (rc) );
293 else if (!check_only)
294 {
295 if (dump_only)
296 ksba_asn_tree_dump (tree, dump_only==2? "<":NULL, fp);
297 else
298 {
299 if (!*count)
300 fprintf (fp,"\n"
301 "#include <config.h>\n"
302 "#include <stdio.h>\n"
303 "#include <string.h>\n"
304 "#include \"ksba.h\"\n"
305 "#include \"asn1-func.h\"\n"
306 "\n");
307 ++*count;
308 return create_static_structure (tree->parse_tree, fname, fp);
309 }
310 }
311 return 0;
312 }
313
314
315 int
316 main (int argc, char **argv)
317 {
318 int count = 0;
319 struct name_list_s *all_names = NULL, *nl;
320 int i;
321
322 if (!argc || (argc > 1 &&
323 (!strcmp (argv[1],"--help") || !strcmp (argv[1],"-h"))) )
324 {
325 fputs ("usage: asn1-gentables [--check] [--dump[-expanded]] [files.asn]\n",
326 stderr);
327 return 0;
328 }
329
330 argc--; argv++;
331 if (argc && !strcmp (*argv,"--check"))
332 {
333 argc--; argv++;
334 check_only = 1;
335 }
336 else if (argc && !strcmp (*argv,"--dump"))
337 {
338 argc--; argv++;
339 dump_only = 1;
340 }
341 else if (argc && !strcmp (*argv,"--dump-expanded"))
342 {
343 argc--; argv++;
344 dump_only = 2;
345 }
346
347
348 if (!argc)
349 all_names = one_file ("-", &count, stdout);
350 else
351 {
352 FILE *nullfp;
353
354 /* We first parse it to /dev/null to build up the string table. */
355 nullfp = fopen (DEVNULL_NAME, "w");
356 if (!nullfp)
357 {
358 print_error ("can't open `%s': %s\n", DEVNULL_NAME, strerror (errno));
359 exit (2);
360 }
361 for (i=0; i < argc; i++)
362 one_file (argv[i], &count, nullfp);
363 fclose (nullfp);
364
365 sort_string_table ();
366
367 count = 0;
368 for (; argc; argc--, argv++)
369 {
370 nl = one_file (*argv, &count, stdout);
371 if (nl)
372 {
373 nl->next = all_names;
374 all_names = nl;
375 }
376 }
377 }
378
379 if (all_names && !error_counter)
380 {
381 /* Write the string table. */
382 putchar ('\n');
383 write_string_table (stdout);
384 /* Write the lookup function */
385 printf ("\n\nconst static_asn *\n"
386 "_ksba_asn_lookup_table (const char *name,"
387 " const char **stringtbl)\n"
388 "{\n"
389 " *stringtbl = string_table;\n"
390 );
391 for (nl=all_names; nl; nl = nl->next)
392 printf (" if (!strcmp (name, \"%s\"))\n"
393 " return %s_asn1_tab;\n", nl->name, nl->name);
394 printf ("\n return NULL;\n}\n");
395 }
396
397 return error_counter? 1:0;
398 }