1 /* 2 * Copyright (c) 1997 - 2002 Kungliga Tekniska H�gskolan 3 * (Royal Institute of Technology, Stockholm, Sweden). 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * 3. Neither the name of the Institute nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #include "gen_locl.h" 35 36 RCSID("$Id: gen.c,v 1.50 2003/04/17 07:09:18 lha Exp $"); 37 38 FILE *headerfile, *codefile, *logfile; 39 40 #define STEM "asn1" 41 42 static const char *orig_filename; 43 static char *header; 44 static char *headerbase = STEM; 45 46 /* 47 * list of all IMPORTs 48 */ 49 50 struct import { 51 const char *module; 52 struct import *next; 53 }; 54 55 static struct import *imports = NULL; 56 57 void 58 add_import (const char *module) 59 { 60 struct import *tmp = emalloc (sizeof(*tmp)); 61 62 tmp->module = module; 63 tmp->next = imports; 64 imports = tmp; 65 } 66 67 const char * 68 filename (void) 69 { 70 return orig_filename; 71 } 72 73 void 74 init_generate (const char *filename, const char *base) 75 { 76 orig_filename = filename; 77 if(base) 78 asprintf(&headerbase, "%s", base); 79 asprintf(&header, "%s.h", headerbase); 80 headerfile = fopen (header, "w"); 81 if (headerfile == NULL) 82 err (1, "open %s", header); 83 fprintf (headerfile, 84 "/* Generated from %s */\n" 85 "/* Do not edit */\n\n", 86 filename); 87 fprintf (headerfile, 88 "#ifndef __%s_h__\n" 89 "#define __%s_h__\n\n", headerbase, headerbase); 90 fprintf (headerfile, 91 "#include <stddef.h>\n" 92 "#include <time.h>\n\n"); 93 #ifndef HAVE_TIMEGM 94 fprintf (headerfile, "time_t timegm (struct tm*);\n\n"); 95 #endif 96 fprintf (headerfile, 97 "#ifndef __asn1_common_definitions__\n" 98 "#define __asn1_common_definitions__\n\n"); 99 fprintf (headerfile, 100 "typedef struct octet_string {\n" 101 " size_t length;\n" 102 " void *data;\n" 103 "} octet_string;\n\n"); 104 fprintf (headerfile, 105 "typedef char *general_string;\n\n" 106 ); 107 fprintf (headerfile, 108 "typedef struct oid {\n" 109 " size_t length;\n" 110 " unsigned *components;\n" 111 "} oid;\n\n"); 112 fputs("#define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \\\n" 113 " do { \\\n" 114 " (BL) = length_##T((S)); \\\n" 115 " (B) = malloc((BL)); \\\n" 116 " if((B) == NULL) { \\\n" 117 " (R) = ENOMEM; \\\n" 118 " } else { \\\n" 119 " (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \\\n" 120 " (S), (L)); \\\n" 121 " if((R) != 0) { \\\n" 122 " free((B)); \\\n" 123 " (B) = NULL; \\\n" 124 " } \\\n" 125 " } \\\n" 126 " } while (0)\n\n", 127 headerfile); 128 fprintf (headerfile, "#endif\n\n"); 129 logfile = fopen(STEM "_files", "w"); 130 if (logfile == NULL) 131 err (1, "open " STEM "_files"); 132 } 133 134 void 135 close_generate (void) 136 { 137 fprintf (headerfile, "#endif /* __%s_h__ */\n", headerbase); 138 139 fclose (headerfile); 140 fprintf (logfile, "\n"); 141 fclose (logfile); 142 } 143 144 void 145 generate_constant (const Symbol *s) 146 { 147 fprintf (headerfile, "enum { %s = %d };\n\n", 148 s->gen_name, s->constant); 149 } 150 151 static void 152 space(int level) 153 { 154 while(level-- > 0) 155 fprintf(headerfile, " "); 156 } 157 158 static void 159 define_asn1 (int level, Type *t) 160 { 161 switch (t->type) { 162 case TType: 163 space(level); 164 fprintf (headerfile, "%s", t->symbol->name); 165 break; 166 case TInteger: 167 space(level); 168 fprintf (headerfile, "INTEGER"); 169 break; 170 case TUInteger: 171 space(level); 172 fprintf (headerfile, "UNSIGNED INTEGER"); 173 break; 174 case TOctetString: 175 space(level); 176 fprintf (headerfile, "OCTET STRING"); 177 break; 178 case TOID : 179 space(level); 180 fprintf(headerfile, "OBJECT IDENTIFIER"); 181 break; 182 case TBitString: { 183 Member *m; 184 int tag = -1; 185 186 space(level); 187 fprintf (headerfile, "BIT STRING {\n"); 188 for (m = t->members; m && m->val != tag; m = m->next) { 189 if (tag == -1) 190 tag = m->val; 191 space(level + 1); 192 fprintf (headerfile, "%s(%d)%s\n", m->name, m->val, 193 m->next->val == tag?"":","); 194 195 } 196 space(level); 197 fprintf (headerfile, "}"); 198 break; 199 } 200 case TEnumerated : { 201 Member *m; 202 int tag = -1; 203 204 space(level); 205 fprintf (headerfile, "ENUMERATED {\n"); 206 for (m = t->members; m && m->val != tag; m = m->next) { 207 if (tag == -1) 208 tag = m->val; 209 space(level + 1); 210 fprintf (headerfile, "%s(%d)%s\n", m->name, m->val, 211 m->next->val == tag?"":","); 212 213 } 214 space(level); 215 fprintf (headerfile, "}"); 216 break; 217 } 218 case TSequence: { 219 Member *m; 220 int tag; 221 int max_width = 0; 222 223 space(level); 224 fprintf (headerfile, "SEQUENCE {\n"); 225 for (m = t->members, tag = -1; m && m->val != tag; m = m->next) { 226 if (tag == -1) 227 tag = m->val; 228 if(strlen(m->name) + (m->val > 9) > max_width) 229 max_width = strlen(m->name) + (m->val > 9); 230 } 231 max_width += 3 + 2; 232 if(max_width < 16) max_width = 16; 233 for (m = t->members, tag = -1 ; m && m->val != tag; m = m->next) { 234 int width; 235 if (tag == -1) 236 tag = m->val; 237 space(level + 1); 238 fprintf(headerfile, "%s[%d]", m->name, m->val); 239 width = max_width - strlen(m->name) - 3 - (m->val > 9) - 2; 240 fprintf(headerfile, "%*s", width, ""); 241 define_asn1(level + 1, m->type); 242 if(m->optional) 243 fprintf(headerfile, " OPTIONAL"); 244 if(m->next->val != tag) 245 fprintf (headerfile, ","); 246 fprintf (headerfile, "\n"); 247 } 248 space(level); 249 fprintf (headerfile, "}"); 250 break; 251 } 252 case TSequenceOf: { 253 space(level); 254 fprintf (headerfile, "SEQUENCE OF "); 255 define_asn1 (0, t->subtype); 256 break; 257 } 258 case TGeneralizedTime: 259 space(level); 260 fprintf (headerfile, "GeneralizedTime"); 261 break; 262 case TGeneralString: 263 space(level); 264 fprintf (headerfile, "GeneralString"); 265 break; 266 case TApplication: 267 fprintf (headerfile, "[APPLICATION %d] ", t->application); 268 define_asn1 (level, t->subtype); 269 break; 270 default: 271 abort (); 272 } 273 } 274 275 static void 276 define_type (int level, char *name, Type *t, int typedefp) 277 { 278 switch (t->type) { 279 case TType: 280 space(level); 281 fprintf (headerfile, "%s %s;\n", t->symbol->gen_name, name); 282 break; 283 case TInteger: 284 space(level); 285 if(t->members == NULL) { 286 fprintf (headerfile, "int %s;\n", name); 287 } else { 288 Member *m; 289 int tag = -1; 290 fprintf (headerfile, "enum %s {\n", typedefp ? name : ""); 291 for (m = t->members; m && m->val != tag; m = m->next) { 292 if(tag == -1) 293 tag = m->val; 294 space (level + 1); 295 fprintf(headerfile, "%s = %d%s\n", m->gen_name, m->val, 296 m->next->val == tag ? "" : ","); 297 } 298 fprintf (headerfile, "} %s;\n", name); 299 } 300 break; 301 case TUInteger: 302 space(level); 303 fprintf (headerfile, "unsigned int %s;\n", name); 304 break; 305 case TOctetString: 306 space(level); 307 fprintf (headerfile, "octet_string %s;\n", name); 308 break; 309 case TOID : 310 space(level); 311 fprintf (headerfile, "oid %s;\n", name); 312 break; 313 case TBitString: { 314 Member *m; 315 Type i; 316 int tag = -1; 317 318 i.type = TUInteger; 319 space(level); 320 fprintf (headerfile, "struct %s {\n", typedefp ? name : ""); 321 for (m = t->members; m && m->val != tag; m = m->next) { 322 char *n; 323 324 asprintf (&n, "%s:1", m->gen_name); 325 define_type (level + 1, n, &i, FALSE); 326 free (n); 327 if (tag == -1) 328 tag = m->val; 329 } 330 space(level); 331 fprintf (headerfile, "} %s;\n\n", name); 332 break; 333 } 334 case TEnumerated: { 335 Member *m; 336 int tag = -1; 337 338 space(level); 339 fprintf (headerfile, "enum %s {\n", typedefp ? name : ""); 340 for (m = t->members; m && m->val != tag; m = m->next) { 341 if (tag == -1) 342 tag = m->val; 343 space(level + 1); 344 fprintf (headerfile, "%s = %d%s\n", m->gen_name, m->val, 345 m->next->val == tag ? "" : ","); 346 } 347 space(level); 348 fprintf (headerfile, "} %s;\n\n", name); 349 break; 350 } 351 case TSequence: { 352 Member *m; 353 int tag = -1; 354 355 space(level); 356 fprintf (headerfile, "struct %s {\n", typedefp ? name : ""); 357 for (m = t->members; m && m->val != tag; m = m->next) { 358 if (m->optional) { 359 char *n; 360 361 asprintf (&n, "*%s", m->gen_name); 362 define_type (level + 1, n, m->type, FALSE); 363 free (n); 364 } else 365 define_type (level + 1, m->gen_name, m->type, FALSE); 366 if (tag == -1) 367 tag = m->val; 368 } 369 space(level); 370 fprintf (headerfile, "} %s;\n", name); 371 break; 372 } 373 case TSequenceOf: { 374 Type i; 375 376 i.type = TUInteger; 377 i.application = 0; 378 379 space(level); 380 fprintf (headerfile, "struct %s {\n", typedefp ? name : ""); 381 define_type (level + 1, "len", &i, FALSE); 382 define_type (level + 1, "*val", t->subtype, FALSE); 383 space(level); 384 fprintf (headerfile, "} %s;\n", name); 385 break; 386 } 387 case TGeneralizedTime: 388 space(level); 389 fprintf (headerfile, "time_t %s;\n", name); 390 break; 391 case TGeneralString: 392 space(level); 393 fprintf (headerfile, "general_string %s;\n", name); 394 break; 395 case TApplication: 396 define_type (level, name, t->subtype, FALSE); 397 break; 398 default: 399 abort (); 400 } 401 } 402 403 static void 404 generate_type_header (const Symbol *s) 405 { 406 fprintf (headerfile, "/*\n"); 407 fprintf (headerfile, "%s ::= ", s->name); 408 define_asn1 (0, s->type); 409 fprintf (headerfile, "\n*/\n\n"); 410 411 fprintf (headerfile, "typedef "); 412 define_type (0, s->gen_name, s->type, TRUE); 413 414 fprintf (headerfile, "\n"); 415 } 416 417 418 void 419 generate_type (const Symbol *s) 420 { 421 struct import *i; 422 char *filename; 423 424 asprintf (&filename, "%s_%s.x", STEM, s->gen_name); 425 codefile = fopen (filename, "w"); 426 if (codefile == NULL) 427 err (1, "fopen %s", filename); 428 fprintf(logfile, "%s ", filename); 429 free(filename); 430 fprintf (codefile, 431 "/* Generated from %s */\n" 432 "/* Do not edit */\n\n" 433 "#include <stdio.h>\n" 434 "#include <stdlib.h>\n" 435 "#include <time.h>\n" 436 "#include <string.h>\n" 437 "#include <errno.h>\n", 438 orig_filename); 439 440 for (i = imports; i != NULL; i = i->next) 441 fprintf (codefile, 442 "#include <%s_asn1.h>\n", 443 i->module); 444 fprintf (codefile, 445 "#include <%s.h>\n", 446 headerbase); 447 fprintf (codefile, 448 "#include <asn1_err.h>\n" 449 "#include <der.h>\n" 450 "#include <parse_units.h>\n\n"); 451 generate_type_header (s); 452 generate_type_encode (s); 453 generate_type_decode (s); 454 generate_type_free (s); 455 generate_type_length (s); 456 generate_type_copy (s); 457 generate_glue (s); 458 fprintf(headerfile, "\n\n"); 459 fclose(codefile); 460 } 461