-= add parser/generate glue for UTF8String and NULL

(DER primitive encode/decode functions missing)
- handle parsing of DEFAULT and, ...


git-svn-id: svn://svn.h5l.se/heimdal/trunk/heimdal@12311 ec53bebd-3082-4978-b11e-865c3cabbd6b

lib/asn1/asn1-common.h

@@ -12,6 +12,7 @@ typedef struct octet_string {
 } octet_string;
 
 typedef char *general_string;
+typedef char *utf8_string;
 
 typedef struct oid {
     size_t length;

lib/asn1/der.h

@@ -52,6 +52,7 @@ enum {
      UT_Null		= 5,
      UT_OID		= 6,
      UT_Enumerated	= 10,
+     UT_UTF8String	= 12,
      UT_Sequence	= 16,
      UT_Set		= 17,
      UT_PrintableString	= 19,
@@ -99,6 +100,8 @@ int decode_oid (const unsigned char *p, size_t len,
 		oid *k, size_t *size);
 int decode_octet_string (const unsigned char*, size_t, octet_string*, size_t*);
 int decode_generalized_time (const unsigned char*, size_t, time_t*, size_t*);
+int decode_nulltype (const unsigned char*, size_t, size_t*);
+int decode_utf8string (const unsigned char*, size_t, utf8_string*, size_t*);
 
 int der_put_int (unsigned char *p, size_t len, int val, size_t*);
 int der_put_length (unsigned char *p, size_t len, size_t val, size_t*);
@@ -127,12 +130,15 @@ int encode_oid (unsigned char *p, size_t len,
 		const oid *k, size_t*);
 int encode_generalized_time (unsigned char *p, size_t len,
 			     const time_t *t, size_t*);
+int encode_nulltype (unsigned char*, size_t, size_t*);
+int encode_utf8string (unsigned char*, size_t, utf8_string*, size_t*);
 
 void free_integer (int *num);
 void free_general_string (general_string *str);
 void free_octet_string (octet_string *k);
 void free_oid (oid *k);
 void free_generalized_time (time_t *t);
+void free_utf8string (utf8_string*);
 
 size_t length_len (size_t len);
 size_t length_integer (const int *data);
@@ -142,10 +148,14 @@ size_t length_general_string (const general_string *data);
 size_t length_octet_string (const octet_string *k);
 size_t length_oid (const oid *k);
 size_t length_generalized_time (const time_t *t);
+size_t length_nulltype (void);
+size_t length_utf8string (const utf8_string*);
 
 int copy_general_string (const general_string *from, general_string *to);
 int copy_octet_string (const octet_string *from, octet_string *to);
 int copy_oid (const oid *from, oid *to);
+int copy_nulltype (void *, void *);
+int copy_utf8string (const utf8_string*, utf8_string*);
 
 int fix_dce(size_t reallen, size_t *len);
 

lib/asn1/gen.c

@@ -104,6 +104,9 @@ init_generate (const char *filename, const char *base)
     fprintf (headerfile,
 	     "typedef char *general_string;\n\n"
 	     );
+    fprintf (headerfile,
+	     "typedef char *utf8_string;\n\n"
+	     );
     fprintf (headerfile,
 	     "typedef struct oid {\n"
 	     "  size_t length;\n"
@@ -267,6 +270,14 @@ define_asn1 (int level, Type *t)
 	fprintf (headerfile, "[APPLICATION %d] ", t->application);
 	define_asn1 (level, t->subtype);
 	break;
+    case TUTF8String:
+	space(level);
+	fprintf (headerfile, "UTF8String");
+	break;
+    case TNull:
+	space(level);
+	fprintf (headerfile, "NULL");
+	break;
     default:
 	abort ();
     }
@@ -392,6 +403,14 @@ define_type (int level, char *name, Type *t, int typedefp)
 	space(level);
 	fprintf (headerfile, "general_string %s;\n", name);
 	break;
+    case TUTF8String:
+	space(level);
+	fprintf (headerfile, "UTF8String %s;\n", name);
+	break;
+    case TNull:
+	space(level);
+	fprintf (headerfile, "NULL %s;\n", name);
+	break;
     case TApplication:
 	define_type (level, name, t->subtype, FALSE);
 	break;

lib/asn1/gen_copy.c

@@ -125,6 +125,11 @@ copy_type (const char *from, const char *to, const Type *t)
   case TGeneralString:
       copy_primitive ("general_string", from, to);
       break;
+  case TUTF8String:
+      copy_primitive ("utf8string", from, to);
+      break;
+  case TNull:
+      break;
   case TApplication:
       copy_type (from, to, t->subtype);
       break;

lib/asn1/gen_decode.c

@@ -253,6 +253,14 @@ decode_type (const char *name, const Type *t)
     case TGeneralString:
 	decode_primitive ("general_string", name);
 	break;
+    case TUTF8String:
+	decode_primitive ("utf8string", name);
+	break;
+    case TNull:
+	fprintf (codefile,
+		 "e = decode_nulltype(p, len, &l);\n"
+		 "FORW;\n");
+	break;
     case TApplication:
 	fprintf (codefile,
 		 "e = der_match_tag_and_length (p, len, APPL, CONS, %d, "
@@ -306,6 +314,9 @@ generate_type_decode (const Symbol *s)
   case TOID:
   case TGeneralizedTime:
   case TGeneralString:
+  case TUTF8String:
+  case TNull:
+  case TEnumerated:
   case TBitString:
   case TSequence:
   case TSequenceOf:

lib/asn1/gen_encode.c

@@ -205,6 +205,14 @@ encode_type (const char *name, const Type *t)
     case TGeneralString:
 	encode_primitive ("general_string", name);
 	break;
+    case TUTF8String:
+	encode_primitive ("utf8string", name);
+	break;
+    case TNull:
+	fprintf (codefile,
+		 "e = encode_nulltype(p, len, &l);\n"
+		 "BACK;\n");
+	break;
     case TApplication:
 	encode_type (name, t->subtype);
 	fprintf (codefile,
@@ -240,6 +248,8 @@ generate_type_encode (const Symbol *s)
   case TOctetString:
   case TGeneralizedTime:
   case TGeneralString:
+  case TUTF8String:
+  case TNull:
   case TBitString:
   case TEnumerated:
   case TOID:

lib/asn1/gen_free.c

@@ -109,6 +109,11 @@ free_type (const char *name, const Type *t)
   case TGeneralString:
       free_primitive ("general_string", name);
       break;
+  case TUTF8String:
+      free_primitive ("utf8string", name);
+      break;
+  case TNull:
+      break;
   case TApplication:
       free_type (name, t->subtype);
       break;

lib/asn1/gen_length.c

@@ -142,6 +142,12 @@ length_type (const char *name, const Type *t, const char *variable)
     case TGeneralString:
 	length_primitive ("general_string", name, variable);
 	break;
+    case TUTF8String:
+	length_primitive ("utf8string", name, variable);
+	break;
+    case TNull:
+	fprintf (codefile, "%s += length_nulltype();\n", variable);
+	break;
     case TApplication:
 	length_type (name, t->subtype, variable);
 	fprintf (codefile, "ret += 1 + length_len (ret);\n");

lib/asn1/lex.l

@@ -69,17 +69,20 @@ OCTET			{ return OCTET; }
 STRING			{ return STRING; }
 GeneralizedTime		{ return GeneralizedTime; }
 GeneralString		{ return GeneralString; }
+UTF8String		{ return UTF8String; }
+NULL			{ return NULLTYPE; }
 BIT			{ return BIT; }
 APPLICATION		{ return APPLICATION; }
 OPTIONAL		{ return OPTIONAL; }
 BEGIN			{ return TBEGIN; }
 END			{ return END; }
+DEFAULT			{ return DEFAULT; }
 DEFINITIONS		{ return DEFINITIONS; }
 ENUMERATED		{ return ENUMERATED; }
 EXTERNAL		{ return EXTERNAL; }
 OBJECT			{ return OBJECT; }
 IDENTIFIER		{ return IDENTIFIER; }
-[,;{}()|]		{ return *yytext; }
+[,;{}()|\"]		{ return *yytext; }
 "["			{ return *yytext; }
 "]"			{ return *yytext; }
 ::=			{ return EEQUAL; }
@@ -98,6 +101,7 @@ IDENTIFIER		{ return IDENTIFIER; }
 			}
 [ \t]			;
 \n			{ ++lineno; }
+\.\.\.			{ return DOTDOTDOT; }
 \.\.			{ return DOTDOT; }
 .			{ error_message("Ignoring char(%c)\n", *yytext); }
 %%

lib/asn1/parse.y

@@ -58,12 +58,14 @@ static void append (Member *l, Member *r);
   char *name;
   Type *type;
   Member *member;
+  char *defval;
 }
 
-%token INTEGER SEQUENCE OF OCTET STRING GeneralizedTime GeneralString
+%token INTEGER SEQUENCE OF OCTET STRING GeneralizedTime GeneralString 
 %token BIT APPLICATION OPTIONAL EEQUAL TBEGIN END DEFINITIONS ENUMERATED
-%token EXTERNAL
+%token UTF8String NULLTYPE
-%token DOTDOT
+%token EXTERNAL DEFAULT
+%token DOTDOT DOTDOTDOT
 %token IMPORTS FROM
 %token OBJECT IDENTIFIER
 %token <name> IDENT 
@@ -71,7 +73,9 @@ static void append (Member *l, Member *r);
 
 %type <constant> constant optional2
 %type <type> type
-%type <member> memberdecls memberdecl bitdecls bitdecl
+%type <member> memberdecls memberdecl memberdeclstart bitdecls bitdecl
+
+%type <defval> defvalue
 
 %start envelope
 
@@ -145,6 +149,8 @@ type		: INTEGER     { $$ = new_type(TInteger); }
 		}
 		| OCTET STRING { $$ = new_type(TOctetString); }
 		| GeneralString { $$ = new_type(TGeneralString); }
+		| UTF8String { $$ = new_type(TUTF8String); }
+                | NULLTYPE { $$ = new_type(TNull); }
 		| GeneralizedTime { $$ = new_type(TGeneralizedTime); }
 		| SEQUENCE OF type
 		{
@@ -180,28 +186,46 @@ type		: INTEGER     { $$ = new_type(TInteger); }
 
 memberdecls	: { $$ = NULL; }
 		| memberdecl	{ $$ = $1; }
+		| memberdecls  ',' DOTDOTDOT { $$ = $1; }
 		| memberdecls ',' memberdecl { $$ = $1; append($$, $3); }
 		;
 
-memberdecl	: IDENT '[' constant ']' type optional2
+memberdeclstart : IDENT '[' constant ']' type
 		{
 		  $$ = malloc(sizeof(*$$));
 		  $$->name = $1;
 		  $$->gen_name = strdup($1);
 		  output_name ($$->gen_name);
 		  $$->val = $3;
-		  $$->optional = $6;
+		  $$->optional = 0;
+		  $$->defval = NULL;
 		  $$->type = $5;
 		  $$->next = $$->prev = $$;
 		}
 		;
 
-optional2	: { $$ = 0; }
+
-		| OPTIONAL { $$ = 1; }
+memberdecl	: memberdeclstart optional2
+		{ $1->optional = $2 ; $$ = $1; }
+		| memberdeclstart defvalue
+		{ $1->defval = $2 ; $$ = $1; }
+		| memberdeclstart
+		{ $$ = $1; }
+		;
+
+
+optional2	: OPTIONAL { $$ = 1; }
+		;
+
+defvalue	: DEFAULT constant
+		{ asprintf(&$$, "%d", $2); }
+		| DEFAULT '"' IDENT '"'
+		{ $$ = strdup ($3); }
 		;
 
 bitdecls	: { $$ = NULL; }
 		| bitdecl { $$ = $1; }
+		| bitdecls ',' DOTDOTDOT { $$ = $1; }
 		| bitdecls ',' bitdecl { $$ = $1; append($$, $3); }
 		;
 

lib/asn1/symbol.h

@@ -38,7 +38,7 @@
 
 enum typetype { TInteger, TOctetString, TBitString, TSequence, TSequenceOf,
 		TGeneralizedTime, TGeneralString, TApplication, TType, 
-		TUInteger, TEnumerated, TOID };
+		TUInteger, TEnumerated, TOID, TUTF8String, TNull, TChoice };
 
 typedef enum typetype Typetype;
 
@@ -51,6 +51,7 @@ struct member {
   int optional;
   struct type *type;
   struct member *next, *prev;
+  char *defval;
 };
 
 typedef struct member Member;