diff mbox series

[U-Boot,v1,04/11] cmd: add asn1_compiler

Message ID 20191011074200.30269-5-takahiro.akashi@linaro.org
State Superseded
Delegated to: Tom Rini
Headers show
Series import x509/pkcs7 parsers from linux | expand

Commit Message

Takahiro Akashi Oct. 11, 2019, 7:41 a.m. UTC
Imported from linux kernel v5.3.

This host command will be used to create a ASN1 parser, for example,
for pkcs7 or x509.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 cmd/Kconfig                       |    3 +
 include/linux/asn1.h              |   65 ++
 include/linux/asn1_ber_bytecode.h |   89 ++
 include/linux/asn1_decoder.h      |   20 +
 scripts/Makefile                  |    3 +
 scripts/asn1_compiler.c           | 1611 +++++++++++++++++++++++++++++
 6 files changed, 1791 insertions(+)
 create mode 100644 include/linux/asn1.h
 create mode 100644 include/linux/asn1_ber_bytecode.h
 create mode 100644 include/linux/asn1_decoder.h
 create mode 100644 scripts/asn1_compiler.c

Comments

Heinrich Schuchardt Oct. 12, 2019, 12:22 p.m. UTC | #1
On 10/11/19 9:41 AM, AKASHI Takahiro wrote:
> Imported from linux kernel v5.3.
>
> This host command will be used to create a ASN1 parser, for example,
> for pkcs7 or x509.
>
> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> ---
>   cmd/Kconfig                       |    3 +
>   include/linux/asn1.h              |   65 ++
>   include/linux/asn1_ber_bytecode.h |   89 ++
>   include/linux/asn1_decoder.h      |   20 +
>   scripts/Makefile                  |    3 +
>   scripts/asn1_compiler.c           | 1611 +++++++++++++++++++++++++++++

Except for Makefile and Kconfig these are verbatime copies of the Linux
files. OK.

>   6 files changed, 1791 insertions(+)
>   create mode 100644 include/linux/asn1.h
>   create mode 100644 include/linux/asn1_ber_bytecode.h
>   create mode 100644 include/linux/asn1_decoder.h
>   create mode 100644 scripts/asn1_compiler.c
>
> diff --git a/cmd/Kconfig b/cmd/Kconfig
> index 4e61565aab16..605dcfdf4282 100644
> --- a/cmd/Kconfig
> +++ b/cmd/Kconfig
> @@ -184,6 +184,9 @@ endmenu
>   config BUILD_BIN2C
>   	bool
>
> +config BUILD_ASN1
> +	bool
> +
>   comment "Commands"
>
>   menu "Info commands"
> diff --git a/include/linux/asn1.h b/include/linux/asn1.h
> new file mode 100644
> index 000000000000..a4d0bdd10711
> --- /dev/null
> +++ b/include/linux/asn1.h
> @@ -0,0 +1,65 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/* ASN.1 BER/DER/CER encoding definitions
> + *
> + * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
> + * Written by David Howells (dhowells@redhat.com)
> + */
> +
> +#ifndef _LINUX_ASN1_H
> +#define _LINUX_ASN1_H
> +
> +/* Class */
> +enum asn1_class {
> +	ASN1_UNIV	= 0,	/* Universal */
> +	ASN1_APPL	= 1,	/* Application */
> +	ASN1_CONT	= 2,	/* Context */
> +	ASN1_PRIV	= 3	/* Private */
> +};
> +#define ASN1_CLASS_BITS	0xc0
> +
> +
> +enum asn1_method {
> +	ASN1_PRIM	= 0,	/* Primitive */
> +	ASN1_CONS	= 1	/* Constructed */
> +};
> +#define ASN1_CONS_BIT	0x20
> +
> +/* Tag */
> +enum asn1_tag {
> +	ASN1_EOC	= 0,	/* End Of Contents or N/A */
> +	ASN1_BOOL	= 1,	/* Boolean */
> +	ASN1_INT	= 2,	/* Integer */
> +	ASN1_BTS	= 3,	/* Bit String */
> +	ASN1_OTS	= 4,	/* Octet String */
> +	ASN1_NULL	= 5,	/* Null */
> +	ASN1_OID	= 6,	/* Object Identifier  */
> +	ASN1_ODE	= 7,	/* Object Description */
> +	ASN1_EXT	= 8,	/* External */
> +	ASN1_REAL	= 9,	/* Real float */
> +	ASN1_ENUM	= 10,	/* Enumerated */
> +	ASN1_EPDV	= 11,	/* Embedded PDV */
> +	ASN1_UTF8STR	= 12,	/* UTF8 String */
> +	ASN1_RELOID	= 13,	/* Relative OID */
> +	/* 14 - Reserved */
> +	/* 15 - Reserved */
> +	ASN1_SEQ	= 16,	/* Sequence and Sequence of */
> +	ASN1_SET	= 17,	/* Set and Set of */
> +	ASN1_NUMSTR	= 18,	/* Numerical String */
> +	ASN1_PRNSTR	= 19,	/* Printable String */
> +	ASN1_TEXSTR	= 20,	/* T61 String / Teletext String */
> +	ASN1_VIDSTR	= 21,	/* Videotex String */
> +	ASN1_IA5STR	= 22,	/* IA5 String */
> +	ASN1_UNITIM	= 23,	/* Universal Time */
> +	ASN1_GENTIM	= 24,	/* General Time */
> +	ASN1_GRASTR	= 25,	/* Graphic String */
> +	ASN1_VISSTR	= 26,	/* Visible String */
> +	ASN1_GENSTR	= 27,	/* General String */
> +	ASN1_UNISTR	= 28,	/* Universal String */
> +	ASN1_CHRSTR	= 29,	/* Character String */
> +	ASN1_BMPSTR	= 30,	/* BMP String */
> +	ASN1_LONG_TAG	= 31	/* Long form tag */
> +};
> +
> +#define ASN1_INDEFINITE_LENGTH 0x80
> +
> +#endif /* _LINUX_ASN1_H */
> diff --git a/include/linux/asn1_ber_bytecode.h b/include/linux/asn1_ber_bytecode.h
> new file mode 100644
> index 000000000000..b38361953a48
> --- /dev/null
> +++ b/include/linux/asn1_ber_bytecode.h
> @@ -0,0 +1,89 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/* ASN.1 BER/DER/CER parsing state machine internal definitions
> + *
> + * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
> + * Written by David Howells (dhowells@redhat.com)
> + */
> +
> +#ifndef _LINUX_ASN1_BER_BYTECODE_H
> +#define _LINUX_ASN1_BER_BYTECODE_H
> +
> +#ifdef __KERNEL__
> +#include <linux/types.h>
> +#endif
> +#include <linux/asn1.h>
> +
> +typedef int (*asn1_action_t)(void *context,
> +			     size_t hdrlen, /* In case of ANY type */
> +			     unsigned char tag, /* In case of ANY type */
> +			     const void *value, size_t vlen);
> +
> +struct asn1_decoder {
> +	const unsigned char *machine;
> +	size_t machlen;
> +	const asn1_action_t *actions;
> +};
> +
> +enum asn1_opcode {
> +	/* The tag-matching ops come first and the odd-numbered slots
> +	 * are for OR_SKIP ops.
> +	 */
> +#define ASN1_OP_MATCH__SKIP		  0x01
> +#define ASN1_OP_MATCH__ACT		  0x02
> +#define ASN1_OP_MATCH__JUMP		  0x04
> +#define ASN1_OP_MATCH__ANY		  0x08
> +#define ASN1_OP_MATCH__COND		  0x10
> +
> +	ASN1_OP_MATCH			= 0x00,
> +	ASN1_OP_MATCH_OR_SKIP		= 0x01,
> +	ASN1_OP_MATCH_ACT		= 0x02,
> +	ASN1_OP_MATCH_ACT_OR_SKIP	= 0x03,
> +	ASN1_OP_MATCH_JUMP		= 0x04,
> +	ASN1_OP_MATCH_JUMP_OR_SKIP	= 0x05,
> +	ASN1_OP_MATCH_ANY		= 0x08,
> +	ASN1_OP_MATCH_ANY_OR_SKIP	= 0x09,
> +	ASN1_OP_MATCH_ANY_ACT		= 0x0a,
> +	ASN1_OP_MATCH_ANY_ACT_OR_SKIP	= 0x0b,
> +	/* Everything before here matches unconditionally */
> +
> +	ASN1_OP_COND_MATCH_OR_SKIP	= 0x11,
> +	ASN1_OP_COND_MATCH_ACT_OR_SKIP	= 0x13,
> +	ASN1_OP_COND_MATCH_JUMP_OR_SKIP	= 0x15,
> +	ASN1_OP_COND_MATCH_ANY		= 0x18,
> +	ASN1_OP_COND_MATCH_ANY_OR_SKIP	= 0x19,
> +	ASN1_OP_COND_MATCH_ANY_ACT	= 0x1a,
> +	ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP = 0x1b,
> +
> +	/* Everything before here will want a tag from the data */
> +#define ASN1_OP__MATCHES_TAG ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP
> +
> +	/* These are here to help fill up space */
> +	ASN1_OP_COND_FAIL		= 0x1c,
> +	ASN1_OP_COMPLETE		= 0x1d,
> +	ASN1_OP_ACT			= 0x1e,
> +	ASN1_OP_MAYBE_ACT		= 0x1f,
> +
> +	/* The following eight have bit 0 -> SET, 1 -> OF, 2 -> ACT */
> +	ASN1_OP_END_SEQ			= 0x20,
> +	ASN1_OP_END_SET			= 0x21,
> +	ASN1_OP_END_SEQ_OF		= 0x22,
> +	ASN1_OP_END_SET_OF		= 0x23,
> +	ASN1_OP_END_SEQ_ACT		= 0x24,
> +	ASN1_OP_END_SET_ACT		= 0x25,
> +	ASN1_OP_END_SEQ_OF_ACT		= 0x26,
> +	ASN1_OP_END_SET_OF_ACT		= 0x27,
> +#define ASN1_OP_END__SET		  0x01
> +#define ASN1_OP_END__OF			  0x02
> +#define ASN1_OP_END__ACT		  0x04
> +
> +	ASN1_OP_RETURN			= 0x28,
> +
> +	ASN1_OP__NR
> +};
> +
> +#define _tag(CLASS, CP, TAG) ((ASN1_##CLASS << 6) | (ASN1_##CP << 5) | ASN1_##TAG)
> +#define _tagn(CLASS, CP, TAG) ((ASN1_##CLASS << 6) | (ASN1_##CP << 5) | TAG)
> +#define _jump_target(N) (N)
> +#define _action(N) (N)
> +
> +#endif /* _LINUX_ASN1_BER_BYTECODE_H */
> diff --git a/include/linux/asn1_decoder.h b/include/linux/asn1_decoder.h
> new file mode 100644
> index 000000000000..83f9c6e1e5e9
> --- /dev/null
> +++ b/include/linux/asn1_decoder.h
> @@ -0,0 +1,20 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/* ASN.1 decoder
> + *
> + * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
> + * Written by David Howells (dhowells@redhat.com)
> + */
> +
> +#ifndef _LINUX_ASN1_DECODER_H
> +#define _LINUX_ASN1_DECODER_H
> +
> +#include <linux/asn1.h>
> +
> +struct asn1_decoder;
> +
> +extern int asn1_ber_decoder(const struct asn1_decoder *decoder,
> +			    void *context,
> +			    const unsigned char *data,
> +			    size_t datalen);
> +
> +#endif /* _LINUX_ASN1_DECODER_H */
> diff --git a/scripts/Makefile b/scripts/Makefile
> index e7b353f77f43..c4e2ae5db2ea 100644
> --- a/scripts/Makefile
> +++ b/scripts/Makefile
> @@ -5,6 +5,9 @@
>   # ---------------------------------------------------------------------------
>
>   hostprogs-$(CONFIG_BUILD_BIN2C)		+= bin2c
> +hostprogs-$(CONFIG_BUILD_ASN1)		+= asn1_compiler
> +
> +HOSTCFLAGS_asn1_compiler.o = -idirafter $(srctree)/include

Which problems did you run into that make you use -idirafter here?

Otherwise

Reviewed-by: Heinrich Schuchardt <xypron.glpk@gmx.de>


>
>   always		:= $(hostprogs-y)
>
> diff --git a/scripts/asn1_compiler.c b/scripts/asn1_compiler.c
> new file mode 100644
> index 000000000000..adabd4145264
> --- /dev/null
> +++ b/scripts/asn1_compiler.c
> @@ -0,0 +1,1611 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/* Simplified ASN.1 notation parser
> + *
> + * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
> + * Written by David Howells (dhowells@redhat.com)
> + */
> +
> +#include <stdarg.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <stdint.h>
> +#include <stdbool.h>
> +#include <string.h>
> +#include <ctype.h>
> +#include <unistd.h>
> +#include <fcntl.h>
> +#include <sys/stat.h>
> +#include <linux/asn1_ber_bytecode.h>
> +
> +enum token_type {
> +	DIRECTIVE_ABSENT,
> +	DIRECTIVE_ALL,
> +	DIRECTIVE_ANY,
> +	DIRECTIVE_APPLICATION,
> +	DIRECTIVE_AUTOMATIC,
> +	DIRECTIVE_BEGIN,
> +	DIRECTIVE_BIT,
> +	DIRECTIVE_BMPString,
> +	DIRECTIVE_BOOLEAN,
> +	DIRECTIVE_BY,
> +	DIRECTIVE_CHARACTER,
> +	DIRECTIVE_CHOICE,
> +	DIRECTIVE_CLASS,
> +	DIRECTIVE_COMPONENT,
> +	DIRECTIVE_COMPONENTS,
> +	DIRECTIVE_CONSTRAINED,
> +	DIRECTIVE_CONTAINING,
> +	DIRECTIVE_DEFAULT,
> +	DIRECTIVE_DEFINED,
> +	DIRECTIVE_DEFINITIONS,
> +	DIRECTIVE_EMBEDDED,
> +	DIRECTIVE_ENCODED,
> +	DIRECTIVE_ENCODING_CONTROL,
> +	DIRECTIVE_END,
> +	DIRECTIVE_ENUMERATED,
> +	DIRECTIVE_EXCEPT,
> +	DIRECTIVE_EXPLICIT,
> +	DIRECTIVE_EXPORTS,
> +	DIRECTIVE_EXTENSIBILITY,
> +	DIRECTIVE_EXTERNAL,
> +	DIRECTIVE_FALSE,
> +	DIRECTIVE_FROM,
> +	DIRECTIVE_GeneralString,
> +	DIRECTIVE_GeneralizedTime,
> +	DIRECTIVE_GraphicString,
> +	DIRECTIVE_IA5String,
> +	DIRECTIVE_IDENTIFIER,
> +	DIRECTIVE_IMPLICIT,
> +	DIRECTIVE_IMPLIED,
> +	DIRECTIVE_IMPORTS,
> +	DIRECTIVE_INCLUDES,
> +	DIRECTIVE_INSTANCE,
> +	DIRECTIVE_INSTRUCTIONS,
> +	DIRECTIVE_INTEGER,
> +	DIRECTIVE_INTERSECTION,
> +	DIRECTIVE_ISO646String,
> +	DIRECTIVE_MAX,
> +	DIRECTIVE_MIN,
> +	DIRECTIVE_MINUS_INFINITY,
> +	DIRECTIVE_NULL,
> +	DIRECTIVE_NumericString,
> +	DIRECTIVE_OBJECT,
> +	DIRECTIVE_OCTET,
> +	DIRECTIVE_OF,
> +	DIRECTIVE_OPTIONAL,
> +	DIRECTIVE_ObjectDescriptor,
> +	DIRECTIVE_PATTERN,
> +	DIRECTIVE_PDV,
> +	DIRECTIVE_PLUS_INFINITY,
> +	DIRECTIVE_PRESENT,
> +	DIRECTIVE_PRIVATE,
> +	DIRECTIVE_PrintableString,
> +	DIRECTIVE_REAL,
> +	DIRECTIVE_RELATIVE_OID,
> +	DIRECTIVE_SEQUENCE,
> +	DIRECTIVE_SET,
> +	DIRECTIVE_SIZE,
> +	DIRECTIVE_STRING,
> +	DIRECTIVE_SYNTAX,
> +	DIRECTIVE_T61String,
> +	DIRECTIVE_TAGS,
> +	DIRECTIVE_TRUE,
> +	DIRECTIVE_TeletexString,
> +	DIRECTIVE_UNION,
> +	DIRECTIVE_UNIQUE,
> +	DIRECTIVE_UNIVERSAL,
> +	DIRECTIVE_UTCTime,
> +	DIRECTIVE_UTF8String,
> +	DIRECTIVE_UniversalString,
> +	DIRECTIVE_VideotexString,
> +	DIRECTIVE_VisibleString,
> +	DIRECTIVE_WITH,
> +	NR__DIRECTIVES,
> +	TOKEN_ASSIGNMENT = NR__DIRECTIVES,
> +	TOKEN_OPEN_CURLY,
> +	TOKEN_CLOSE_CURLY,
> +	TOKEN_OPEN_SQUARE,
> +	TOKEN_CLOSE_SQUARE,
> +	TOKEN_OPEN_ACTION,
> +	TOKEN_CLOSE_ACTION,
> +	TOKEN_COMMA,
> +	TOKEN_NUMBER,
> +	TOKEN_TYPE_NAME,
> +	TOKEN_ELEMENT_NAME,
> +	NR__TOKENS
> +};
> +
> +static const unsigned char token_to_tag[NR__TOKENS] = {
> +	/* EOC goes first */
> +	[DIRECTIVE_BOOLEAN]		= ASN1_BOOL,
> +	[DIRECTIVE_INTEGER]		= ASN1_INT,
> +	[DIRECTIVE_BIT]			= ASN1_BTS,
> +	[DIRECTIVE_OCTET]		= ASN1_OTS,
> +	[DIRECTIVE_NULL]		= ASN1_NULL,
> +	[DIRECTIVE_OBJECT]		= ASN1_OID,
> +	[DIRECTIVE_ObjectDescriptor]	= ASN1_ODE,
> +	[DIRECTIVE_EXTERNAL]		= ASN1_EXT,
> +	[DIRECTIVE_REAL]		= ASN1_REAL,
> +	[DIRECTIVE_ENUMERATED]		= ASN1_ENUM,
> +	[DIRECTIVE_EMBEDDED]		= 0,
> +	[DIRECTIVE_UTF8String]		= ASN1_UTF8STR,
> +	[DIRECTIVE_RELATIVE_OID]	= ASN1_RELOID,
> +	/* 14 */
> +	/* 15 */
> +	[DIRECTIVE_SEQUENCE]		= ASN1_SEQ,
> +	[DIRECTIVE_SET]			= ASN1_SET,
> +	[DIRECTIVE_NumericString]	= ASN1_NUMSTR,
> +	[DIRECTIVE_PrintableString]	= ASN1_PRNSTR,
> +	[DIRECTIVE_T61String]		= ASN1_TEXSTR,
> +	[DIRECTIVE_TeletexString]	= ASN1_TEXSTR,
> +	[DIRECTIVE_VideotexString]	= ASN1_VIDSTR,
> +	[DIRECTIVE_IA5String]		= ASN1_IA5STR,
> +	[DIRECTIVE_UTCTime]		= ASN1_UNITIM,
> +	[DIRECTIVE_GeneralizedTime]	= ASN1_GENTIM,
> +	[DIRECTIVE_GraphicString]	= ASN1_GRASTR,
> +	[DIRECTIVE_VisibleString]	= ASN1_VISSTR,
> +	[DIRECTIVE_GeneralString]	= ASN1_GENSTR,
> +	[DIRECTIVE_UniversalString]	= ASN1_UNITIM,
> +	[DIRECTIVE_CHARACTER]		= ASN1_CHRSTR,
> +	[DIRECTIVE_BMPString]		= ASN1_BMPSTR,
> +};
> +
> +static const char asn1_classes[4][5] = {
> +	[ASN1_UNIV]	= "UNIV",
> +	[ASN1_APPL]	= "APPL",
> +	[ASN1_CONT]	= "CONT",
> +	[ASN1_PRIV]	= "PRIV"
> +};
> +
> +static const char asn1_methods[2][5] = {
> +	[ASN1_UNIV]	= "PRIM",
> +	[ASN1_APPL]	= "CONS"
> +};
> +
> +static const char *const asn1_universal_tags[32] = {
> +	"EOC",
> +	"BOOL",
> +	"INT",
> +	"BTS",
> +	"OTS",
> +	"NULL",
> +	"OID",
> +	"ODE",
> +	"EXT",
> +	"REAL",
> +	"ENUM",
> +	"EPDV",
> +	"UTF8STR",
> +	"RELOID",
> +	NULL,		/* 14 */
> +	NULL,		/* 15 */
> +	"SEQ",
> +	"SET",
> +	"NUMSTR",
> +	"PRNSTR",
> +	"TEXSTR",
> +	"VIDSTR",
> +	"IA5STR",
> +	"UNITIM",
> +	"GENTIM",
> +	"GRASTR",
> +	"VISSTR",
> +	"GENSTR",
> +	"UNISTR",
> +	"CHRSTR",
> +	"BMPSTR",
> +	NULL		/* 31 */
> +};
> +
> +static const char *filename;
> +static const char *grammar_name;
> +static const char *outputname;
> +static const char *headername;
> +
> +static const char *const directives[NR__DIRECTIVES] = {
> +#define _(X) [DIRECTIVE_##X] = #X
> +	_(ABSENT),
> +	_(ALL),
> +	_(ANY),
> +	_(APPLICATION),
> +	_(AUTOMATIC),
> +	_(BEGIN),
> +	_(BIT),
> +	_(BMPString),
> +	_(BOOLEAN),
> +	_(BY),
> +	_(CHARACTER),
> +	_(CHOICE),
> +	_(CLASS),
> +	_(COMPONENT),
> +	_(COMPONENTS),
> +	_(CONSTRAINED),
> +	_(CONTAINING),
> +	_(DEFAULT),
> +	_(DEFINED),
> +	_(DEFINITIONS),
> +	_(EMBEDDED),
> +	_(ENCODED),
> +	[DIRECTIVE_ENCODING_CONTROL] = "ENCODING-CONTROL",
> +	_(END),
> +	_(ENUMERATED),
> +	_(EXCEPT),
> +	_(EXPLICIT),
> +	_(EXPORTS),
> +	_(EXTENSIBILITY),
> +	_(EXTERNAL),
> +	_(FALSE),
> +	_(FROM),
> +	_(GeneralString),
> +	_(GeneralizedTime),
> +	_(GraphicString),
> +	_(IA5String),
> +	_(IDENTIFIER),
> +	_(IMPLICIT),
> +	_(IMPLIED),
> +	_(IMPORTS),
> +	_(INCLUDES),
> +	_(INSTANCE),
> +	_(INSTRUCTIONS),
> +	_(INTEGER),
> +	_(INTERSECTION),
> +	_(ISO646String),
> +	_(MAX),
> +	_(MIN),
> +	[DIRECTIVE_MINUS_INFINITY] = "MINUS-INFINITY",
> +	[DIRECTIVE_NULL] = "NULL",
> +	_(NumericString),
> +	_(OBJECT),
> +	_(OCTET),
> +	_(OF),
> +	_(OPTIONAL),
> +	_(ObjectDescriptor),
> +	_(PATTERN),
> +	_(PDV),
> +	[DIRECTIVE_PLUS_INFINITY] = "PLUS-INFINITY",
> +	_(PRESENT),
> +	_(PRIVATE),
> +	_(PrintableString),
> +	_(REAL),
> +	[DIRECTIVE_RELATIVE_OID] = "RELATIVE-OID",
> +	_(SEQUENCE),
> +	_(SET),
> +	_(SIZE),
> +	_(STRING),
> +	_(SYNTAX),
> +	_(T61String),
> +	_(TAGS),
> +	_(TRUE),
> +	_(TeletexString),
> +	_(UNION),
> +	_(UNIQUE),
> +	_(UNIVERSAL),
> +	_(UTCTime),
> +	_(UTF8String),
> +	_(UniversalString),
> +	_(VideotexString),
> +	_(VisibleString),
> +	_(WITH)
> +};
> +
> +struct action {
> +	struct action	*next;
> +	char		*name;
> +	unsigned char	index;
> +};
> +
> +static struct action *action_list;
> +static unsigned nr_actions;
> +
> +struct token {
> +	unsigned short	line;
> +	enum token_type	token_type : 8;
> +	unsigned char	size;
> +	struct action	*action;
> +	char		*content;
> +	struct type	*type;
> +};
> +
> +static struct token *token_list;
> +static unsigned nr_tokens;
> +static bool verbose_opt;
> +static bool debug_opt;
> +
> +#define verbose(fmt, ...) do { if (verbose_opt) printf(fmt, ## __VA_ARGS__); } while (0)
> +#define debug(fmt, ...) do { if (debug_opt) printf(fmt, ## __VA_ARGS__); } while (0)
> +
> +static int directive_compare(const void *_key, const void *_pdir)
> +{
> +	const struct token *token = _key;
> +	const char *const *pdir = _pdir, *dir = *pdir;
> +	size_t dlen, clen;
> +	int val;
> +
> +	dlen = strlen(dir);
> +	clen = (dlen < token->size) ? dlen : token->size;
> +
> +	//debug("cmp(%s,%s) = ", token->content, dir);
> +
> +	val = memcmp(token->content, dir, clen);
> +	if (val != 0) {
> +		//debug("%d [cmp]\n", val);
> +		return val;
> +	}
> +
> +	if (dlen == token->size) {
> +		//debug("0\n");
> +		return 0;
> +	}
> +	//debug("%d\n", (int)dlen - (int)token->size);
> +	return dlen - token->size; /* shorter -> negative */
> +}
> +
> +/*
> + * Tokenise an ASN.1 grammar
> + */
> +static void tokenise(char *buffer, char *end)
> +{
> +	struct token *tokens;
> +	char *line, *nl, *start, *p, *q;
> +	unsigned tix, lineno;
> +
> +	/* Assume we're going to have half as many tokens as we have
> +	 * characters
> +	 */
> +	token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token));
> +	if (!tokens) {
> +		perror(NULL);
> +		exit(1);
> +	}
> +	tix = 0;
> +
> +	lineno = 0;
> +	while (buffer < end) {
> +		/* First of all, break out a line */
> +		lineno++;
> +		line = buffer;
> +		nl = memchr(line, '\n', end - buffer);
> +		if (!nl) {
> +			buffer = nl = end;
> +		} else {
> +			buffer = nl + 1;
> +			*nl = '\0';
> +		}
> +
> +		/* Remove "--" comments */
> +		p = line;
> +	next_comment:
> +		while ((p = memchr(p, '-', nl - p))) {
> +			if (p[1] == '-') {
> +				/* Found a comment; see if there's a terminator */
> +				q = p + 2;
> +				while ((q = memchr(q, '-', nl - q))) {
> +					if (q[1] == '-') {
> +						/* There is - excise the comment */
> +						q += 2;
> +						memmove(p, q, nl - q);
> +						goto next_comment;
> +					}
> +					q++;
> +				}
> +				*p = '\0';
> +				nl = p;
> +				break;
> +			} else {
> +				p++;
> +			}
> +		}
> +
> +		p = line;
> +		while (p < nl) {
> +			/* Skip white space */
> +			while (p < nl && isspace(*p))
> +				*(p++) = 0;
> +			if (p >= nl)
> +				break;
> +
> +			tokens[tix].line = lineno;
> +			start = p;
> +
> +			/* Handle string tokens */
> +			if (isalpha(*p)) {
> +				const char **dir;
> +
> +				/* Can be a directive, type name or element
> +				 * name.  Find the end of the name.
> +				 */
> +				q = p + 1;
> +				while (q < nl && (isalnum(*q) || *q == '-' || *q == '_'))
> +					q++;
> +				tokens[tix].size = q - p;
> +				p = q;
> +
> +				tokens[tix].content = malloc(tokens[tix].size + 1);
> +				if (!tokens[tix].content) {
> +					perror(NULL);
> +					exit(1);
> +				}
> +				memcpy(tokens[tix].content, start, tokens[tix].size);
> +				tokens[tix].content[tokens[tix].size] = 0;
> +
> +				/* If it begins with a lowercase letter then
> +				 * it's an element name
> +				 */
> +				if (islower(tokens[tix].content[0])) {
> +					tokens[tix++].token_type = TOKEN_ELEMENT_NAME;
> +					continue;
> +				}
> +
> +				/* Otherwise we need to search the directive
> +				 * table
> +				 */
> +				dir = bsearch(&tokens[tix], directives,
> +					      sizeof(directives) / sizeof(directives[1]),
> +					      sizeof(directives[1]),
> +					      directive_compare);
> +				if (dir) {
> +					tokens[tix++].token_type = dir - directives;
> +					continue;
> +				}
> +
> +				tokens[tix++].token_type = TOKEN_TYPE_NAME;
> +				continue;
> +			}
> +
> +			/* Handle numbers */
> +			if (isdigit(*p)) {
> +				/* Find the end of the number */
> +				q = p + 1;
> +				while (q < nl && (isdigit(*q)))
> +					q++;
> +				tokens[tix].size = q - p;
> +				p = q;
> +				tokens[tix].content = malloc(tokens[tix].size + 1);
> +				if (!tokens[tix].content) {
> +					perror(NULL);
> +					exit(1);
> +				}
> +				memcpy(tokens[tix].content, start, tokens[tix].size);
> +				tokens[tix].content[tokens[tix].size] = 0;
> +				tokens[tix++].token_type = TOKEN_NUMBER;
> +				continue;
> +			}
> +
> +			if (nl - p >= 3) {
> +				if (memcmp(p, "::=", 3) == 0) {
> +					p += 3;
> +					tokens[tix].size = 3;
> +					tokens[tix].content = "::=";
> +					tokens[tix++].token_type = TOKEN_ASSIGNMENT;
> +					continue;
> +				}
> +			}
> +
> +			if (nl - p >= 2) {
> +				if (memcmp(p, "({", 2) == 0) {
> +					p += 2;
> +					tokens[tix].size = 2;
> +					tokens[tix].content = "({";
> +					tokens[tix++].token_type = TOKEN_OPEN_ACTION;
> +					continue;
> +				}
> +				if (memcmp(p, "})", 2) == 0) {
> +					p += 2;
> +					tokens[tix].size = 2;
> +					tokens[tix].content = "})";
> +					tokens[tix++].token_type = TOKEN_CLOSE_ACTION;
> +					continue;
> +				}
> +			}
> +
> +			if (nl - p >= 1) {
> +				tokens[tix].size = 1;
> +				switch (*p) {
> +				case '{':
> +					p += 1;
> +					tokens[tix].content = "{";
> +					tokens[tix++].token_type = TOKEN_OPEN_CURLY;
> +					continue;
> +				case '}':
> +					p += 1;
> +					tokens[tix].content = "}";
> +					tokens[tix++].token_type = TOKEN_CLOSE_CURLY;
> +					continue;
> +				case '[':
> +					p += 1;
> +					tokens[tix].content = "[";
> +					tokens[tix++].token_type = TOKEN_OPEN_SQUARE;
> +					continue;
> +				case ']':
> +					p += 1;
> +					tokens[tix].content = "]";
> +					tokens[tix++].token_type = TOKEN_CLOSE_SQUARE;
> +					continue;
> +				case ',':
> +					p += 1;
> +					tokens[tix].content = ",";
> +					tokens[tix++].token_type = TOKEN_COMMA;
> +					continue;
> +				default:
> +					break;
> +				}
> +			}
> +
> +			fprintf(stderr, "%s:%u: Unknown character in grammar: '%c'\n",
> +				filename, lineno, *p);
> +			exit(1);
> +		}
> +	}
> +
> +	nr_tokens = tix;
> +	verbose("Extracted %u tokens\n", nr_tokens);
> +
> +#if 0
> +	{
> +		int n;
> +		for (n = 0; n < nr_tokens; n++)
> +			debug("Token %3u: '%s'\n", n, token_list[n].content);
> +	}
> +#endif
> +}
> +
> +static void build_type_list(void);
> +static void parse(void);
> +static void dump_elements(void);
> +static void render(FILE *out, FILE *hdr);
> +
> +/*
> + *
> + */
> +int main(int argc, char **argv)
> +{
> +	struct stat st;
> +	ssize_t readlen;
> +	FILE *out, *hdr;
> +	char *buffer, *p;
> +	char *kbuild_verbose;
> +	int fd;
> +
> +	kbuild_verbose = getenv("KBUILD_VERBOSE");
> +	if (kbuild_verbose)
> +		verbose_opt = atoi(kbuild_verbose);
> +
> +	while (argc > 4) {
> +		if (strcmp(argv[1], "-v") == 0)
> +			verbose_opt = true;
> +		else if (strcmp(argv[1], "-d") == 0)
> +			debug_opt = true;
> +		else
> +			break;
> +		memmove(&argv[1], &argv[2], (argc - 2) * sizeof(char *));
> +		argc--;
> +	}
> +
> +	if (argc != 4) {
> +		fprintf(stderr, "Format: %s [-v] [-d] <grammar-file> <c-file> <hdr-file>\n",
> +			argv[0]);
> +		exit(2);
> +	}
> +
> +	filename = argv[1];
> +	outputname = argv[2];
> +	headername = argv[3];
> +
> +	fd = open(filename, O_RDONLY);
> +	if (fd < 0) {
> +		perror(filename);
> +		exit(1);
> +	}
> +
> +	if (fstat(fd, &st) < 0) {
> +		perror(filename);
> +		exit(1);
> +	}
> +
> +	if (!(buffer = malloc(st.st_size + 1))) {
> +		perror(NULL);
> +		exit(1);
> +	}
> +
> +	if ((readlen = read(fd, buffer, st.st_size)) < 0) {
> +		perror(filename);
> +		exit(1);
> +	}
> +
> +	if (close(fd) < 0) {
> +		perror(filename);
> +		exit(1);
> +	}
> +
> +	if (readlen != st.st_size) {
> +		fprintf(stderr, "%s: Short read\n", filename);
> +		exit(1);
> +	}
> +
> +	p = strrchr(argv[1], '/');
> +	p = p ? p + 1 : argv[1];
> +	grammar_name = strdup(p);
> +	if (!p) {
> +		perror(NULL);
> +		exit(1);
> +	}
> +	p = strchr(grammar_name, '.');
> +	if (p)
> +		*p = '\0';
> +
> +	buffer[readlen] = 0;
> +	tokenise(buffer, buffer + readlen);
> +	build_type_list();
> +	parse();
> +	dump_elements();
> +
> +	out = fopen(outputname, "w");
> +	if (!out) {
> +		perror(outputname);
> +		exit(1);
> +	}
> +
> +	hdr = fopen(headername, "w");
> +	if (!hdr) {
> +		perror(headername);
> +		exit(1);
> +	}
> +
> +	render(out, hdr);
> +
> +	if (fclose(out) < 0) {
> +		perror(outputname);
> +		exit(1);
> +	}
> +
> +	if (fclose(hdr) < 0) {
> +		perror(headername);
> +		exit(1);
> +	}
> +
> +	return 0;
> +}
> +
> +enum compound {
> +	NOT_COMPOUND,
> +	SET,
> +	SET_OF,
> +	SEQUENCE,
> +	SEQUENCE_OF,
> +	CHOICE,
> +	ANY,
> +	TYPE_REF,
> +	TAG_OVERRIDE
> +};
> +
> +struct element {
> +	struct type	*type_def;
> +	struct token	*name;
> +	struct token	*type;
> +	struct action	*action;
> +	struct element	*children;
> +	struct element	*next;
> +	struct element	*render_next;
> +	struct element	*list_next;
> +	uint8_t		n_elements;
> +	enum compound	compound : 8;
> +	enum asn1_class	class : 8;
> +	enum asn1_method method : 8;
> +	uint8_t		tag;
> +	unsigned	entry_index;
> +	unsigned	flags;
> +#define ELEMENT_IMPLICIT	0x0001
> +#define ELEMENT_EXPLICIT	0x0002
> +#define ELEMENT_TAG_SPECIFIED	0x0004
> +#define ELEMENT_RENDERED	0x0008
> +#define ELEMENT_SKIPPABLE	0x0010
> +#define ELEMENT_CONDITIONAL	0x0020
> +};
> +
> +struct type {
> +	struct token	*name;
> +	struct token	*def;
> +	struct element	*element;
> +	unsigned	ref_count;
> +	unsigned	flags;
> +#define TYPE_STOP_MARKER	0x0001
> +#define TYPE_BEGIN		0x0002
> +};
> +
> +static struct type *type_list;
> +static struct type **type_index;
> +static unsigned nr_types;
> +
> +static int type_index_compare(const void *_a, const void *_b)
> +{
> +	const struct type *const *a = _a, *const *b = _b;
> +
> +	if ((*a)->name->size != (*b)->name->size)
> +		return (*a)->name->size - (*b)->name->size;
> +	else
> +		return memcmp((*a)->name->content, (*b)->name->content,
> +			      (*a)->name->size);
> +}
> +
> +static int type_finder(const void *_key, const void *_ti)
> +{
> +	const struct token *token = _key;
> +	const struct type *const *ti = _ti;
> +	const struct type *type = *ti;
> +
> +	if (token->size != type->name->size)
> +		return token->size - type->name->size;
> +	else
> +		return memcmp(token->content, type->name->content,
> +			      token->size);
> +}
> +
> +/*
> + * Build up a list of types and a sorted index to that list.
> + */
> +static void build_type_list(void)
> +{
> +	struct type *types;
> +	unsigned nr, t, n;
> +
> +	nr = 0;
> +	for (n = 0; n < nr_tokens - 1; n++)
> +		if (token_list[n + 0].token_type == TOKEN_TYPE_NAME &&
> +		    token_list[n + 1].token_type == TOKEN_ASSIGNMENT)
> +			nr++;
> +
> +	if (nr == 0) {
> +		fprintf(stderr, "%s: No defined types\n", filename);
> +		exit(1);
> +	}
> +
> +	nr_types = nr;
> +	types = type_list = calloc(nr + 1, sizeof(type_list[0]));
> +	if (!type_list) {
> +		perror(NULL);
> +		exit(1);
> +	}
> +	type_index = calloc(nr, sizeof(type_index[0]));
> +	if (!type_index) {
> +		perror(NULL);
> +		exit(1);
> +	}
> +
> +	t = 0;
> +	types[t].flags |= TYPE_BEGIN;
> +	for (n = 0; n < nr_tokens - 1; n++) {
> +		if (token_list[n + 0].token_type == TOKEN_TYPE_NAME &&
> +		    token_list[n + 1].token_type == TOKEN_ASSIGNMENT) {
> +			types[t].name = &token_list[n];
> +			type_index[t] = &types[t];
> +			t++;
> +		}
> +	}
> +	types[t].name = &token_list[n + 1];
> +	types[t].flags |= TYPE_STOP_MARKER;
> +
> +	qsort(type_index, nr, sizeof(type_index[0]), type_index_compare);
> +
> +	verbose("Extracted %u types\n", nr_types);
> +#if 0
> +	for (n = 0; n < nr_types; n++) {
> +		struct type *type = type_index[n];
> +		debug("- %*.*s\n", type->name->content);
> +	}
> +#endif
> +}
> +
> +static struct element *parse_type(struct token **_cursor, struct token *stop,
> +				  struct token *name);
> +
> +/*
> + * Parse the token stream
> + */
> +static void parse(void)
> +{
> +	struct token *cursor;
> +	struct type *type;
> +
> +	/* Parse one type definition statement at a time */
> +	type = type_list;
> +	do {
> +		cursor = type->name;
> +
> +		if (cursor[0].token_type != TOKEN_TYPE_NAME ||
> +		    cursor[1].token_type != TOKEN_ASSIGNMENT)
> +			abort();
> +		cursor += 2;
> +
> +		type->element = parse_type(&cursor, type[1].name, NULL);
> +		type->element->type_def = type;
> +
> +		if (cursor != type[1].name) {
> +			fprintf(stderr, "%s:%d: Parse error at token '%s'\n",
> +				filename, cursor->line, cursor->content);
> +			exit(1);
> +		}
> +
> +	} while (type++, !(type->flags & TYPE_STOP_MARKER));
> +
> +	verbose("Extracted %u actions\n", nr_actions);
> +}
> +
> +static struct element *element_list;
> +
> +static struct element *alloc_elem(struct token *type)
> +{
> +	struct element *e = calloc(1, sizeof(*e));
> +	if (!e) {
> +		perror(NULL);
> +		exit(1);
> +	}
> +	e->list_next = element_list;
> +	element_list = e;
> +	return e;
> +}
> +
> +static struct element *parse_compound(struct token **_cursor, struct token *end,
> +				      int alternates);
> +
> +/*
> + * Parse one type definition statement
> + */
> +static struct element *parse_type(struct token **_cursor, struct token *end,
> +				  struct token *name)
> +{
> +	struct element *top, *element;
> +	struct action *action, **ppaction;
> +	struct token *cursor = *_cursor;
> +	struct type **ref;
> +	char *p;
> +	int labelled = 0, implicit = 0;
> +
> +	top = element = alloc_elem(cursor);
> +	element->class = ASN1_UNIV;
> +	element->method = ASN1_PRIM;
> +	element->tag = token_to_tag[cursor->token_type];
> +	element->name = name;
> +
> +	/* Extract the tag value if one given */
> +	if (cursor->token_type == TOKEN_OPEN_SQUARE) {
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +		switch (cursor->token_type) {
> +		case DIRECTIVE_UNIVERSAL:
> +			element->class = ASN1_UNIV;
> +			cursor++;
> +			break;
> +		case DIRECTIVE_APPLICATION:
> +			element->class = ASN1_APPL;
> +			cursor++;
> +			break;
> +		case TOKEN_NUMBER:
> +			element->class = ASN1_CONT;
> +			break;
> +		case DIRECTIVE_PRIVATE:
> +			element->class = ASN1_PRIV;
> +			cursor++;
> +			break;
> +		default:
> +			fprintf(stderr, "%s:%d: Unrecognised tag class token '%s'\n",
> +				filename, cursor->line, cursor->content);
> +			exit(1);
> +		}
> +
> +		if (cursor >= end)
> +			goto overrun_error;
> +		if (cursor->token_type != TOKEN_NUMBER) {
> +			fprintf(stderr, "%s:%d: Missing tag number '%s'\n",
> +				filename, cursor->line, cursor->content);
> +			exit(1);
> +		}
> +
> +		element->tag &= ~0x1f;
> +		element->tag |= strtoul(cursor->content, &p, 10);
> +		element->flags |= ELEMENT_TAG_SPECIFIED;
> +		if (p - cursor->content != cursor->size)
> +			abort();
> +		cursor++;
> +
> +		if (cursor >= end)
> +			goto overrun_error;
> +		if (cursor->token_type != TOKEN_CLOSE_SQUARE) {
> +			fprintf(stderr, "%s:%d: Missing closing square bracket '%s'\n",
> +				filename, cursor->line, cursor->content);
> +			exit(1);
> +		}
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +		labelled = 1;
> +	}
> +
> +	/* Handle implicit and explicit markers */
> +	if (cursor->token_type == DIRECTIVE_IMPLICIT) {
> +		element->flags |= ELEMENT_IMPLICIT;
> +		implicit = 1;
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +	} else if (cursor->token_type == DIRECTIVE_EXPLICIT) {
> +		element->flags |= ELEMENT_EXPLICIT;
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +	}
> +
> +	if (labelled) {
> +		if (!implicit)
> +			element->method |= ASN1_CONS;
> +		element->compound = implicit ? TAG_OVERRIDE : SEQUENCE;
> +		element->children = alloc_elem(cursor);
> +		element = element->children;
> +		element->class = ASN1_UNIV;
> +		element->method = ASN1_PRIM;
> +		element->tag = token_to_tag[cursor->token_type];
> +		element->name = name;
> +	}
> +
> +	/* Extract the type we're expecting here */
> +	element->type = cursor;
> +	switch (cursor->token_type) {
> +	case DIRECTIVE_ANY:
> +		element->compound = ANY;
> +		cursor++;
> +		break;
> +
> +	case DIRECTIVE_NULL:
> +	case DIRECTIVE_BOOLEAN:
> +	case DIRECTIVE_ENUMERATED:
> +	case DIRECTIVE_INTEGER:
> +		element->compound = NOT_COMPOUND;
> +		cursor++;
> +		break;
> +
> +	case DIRECTIVE_EXTERNAL:
> +		element->method = ASN1_CONS;
> +
> +	case DIRECTIVE_BMPString:
> +	case DIRECTIVE_GeneralString:
> +	case DIRECTIVE_GraphicString:
> +	case DIRECTIVE_IA5String:
> +	case DIRECTIVE_ISO646String:
> +	case DIRECTIVE_NumericString:
> +	case DIRECTIVE_PrintableString:
> +	case DIRECTIVE_T61String:
> +	case DIRECTIVE_TeletexString:
> +	case DIRECTIVE_UniversalString:
> +	case DIRECTIVE_UTF8String:
> +	case DIRECTIVE_VideotexString:
> +	case DIRECTIVE_VisibleString:
> +	case DIRECTIVE_ObjectDescriptor:
> +	case DIRECTIVE_GeneralizedTime:
> +	case DIRECTIVE_UTCTime:
> +		element->compound = NOT_COMPOUND;
> +		cursor++;
> +		break;
> +
> +	case DIRECTIVE_BIT:
> +	case DIRECTIVE_OCTET:
> +		element->compound = NOT_COMPOUND;
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +		if (cursor->token_type != DIRECTIVE_STRING)
> +			goto parse_error;
> +		cursor++;
> +		break;
> +
> +	case DIRECTIVE_OBJECT:
> +		element->compound = NOT_COMPOUND;
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +		if (cursor->token_type != DIRECTIVE_IDENTIFIER)
> +			goto parse_error;
> +		cursor++;
> +		break;
> +
> +	case TOKEN_TYPE_NAME:
> +		element->compound = TYPE_REF;
> +		ref = bsearch(cursor, type_index, nr_types, sizeof(type_index[0]),
> +			      type_finder);
> +		if (!ref) {
> +			fprintf(stderr, "%s:%d: Type '%s' undefined\n",
> +				filename, cursor->line, cursor->content);
> +			exit(1);
> +		}
> +		cursor->type = *ref;
> +		(*ref)->ref_count++;
> +		cursor++;
> +		break;
> +
> +	case DIRECTIVE_CHOICE:
> +		element->compound = CHOICE;
> +		cursor++;
> +		element->children = parse_compound(&cursor, end, 1);
> +		break;
> +
> +	case DIRECTIVE_SEQUENCE:
> +		element->compound = SEQUENCE;
> +		element->method = ASN1_CONS;
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +		if (cursor->token_type == DIRECTIVE_OF) {
> +			element->compound = SEQUENCE_OF;
> +			cursor++;
> +			if (cursor >= end)
> +				goto overrun_error;
> +			element->children = parse_type(&cursor, end, NULL);
> +		} else {
> +			element->children = parse_compound(&cursor, end, 0);
> +		}
> +		break;
> +
> +	case DIRECTIVE_SET:
> +		element->compound = SET;
> +		element->method = ASN1_CONS;
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +		if (cursor->token_type == DIRECTIVE_OF) {
> +			element->compound = SET_OF;
> +			cursor++;
> +			if (cursor >= end)
> +				goto parse_error;
> +			element->children = parse_type(&cursor, end, NULL);
> +		} else {
> +			element->children = parse_compound(&cursor, end, 1);
> +		}
> +		break;
> +
> +	default:
> +		fprintf(stderr, "%s:%d: Token '%s' does not introduce a type\n",
> +			filename, cursor->line, cursor->content);
> +		exit(1);
> +	}
> +
> +	/* Handle elements that are optional */
> +	if (cursor < end && (cursor->token_type == DIRECTIVE_OPTIONAL ||
> +			     cursor->token_type == DIRECTIVE_DEFAULT)
> +	    ) {
> +		cursor++;
> +		top->flags |= ELEMENT_SKIPPABLE;
> +	}
> +
> +	if (cursor < end && cursor->token_type == TOKEN_OPEN_ACTION) {
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +		if (cursor->token_type != TOKEN_ELEMENT_NAME) {
> +			fprintf(stderr, "%s:%d: Token '%s' is not an action function name\n",
> +				filename, cursor->line, cursor->content);
> +			exit(1);
> +		}
> +
> +		action = malloc(sizeof(struct action));
> +		if (!action) {
> +			perror(NULL);
> +			exit(1);
> +		}
> +		action->index = 0;
> +		action->name = cursor->content;
> +
> +		for (ppaction = &action_list;
> +		     *ppaction;
> +		     ppaction = &(*ppaction)->next
> +		     ) {
> +			int cmp = strcmp(action->name, (*ppaction)->name);
> +			if (cmp == 0) {
> +				free(action);
> +				action = *ppaction;
> +				goto found;
> +			}
> +			if (cmp < 0) {
> +				action->next = *ppaction;
> +				*ppaction = action;
> +				nr_actions++;
> +				goto found;
> +			}
> +		}
> +		action->next = NULL;
> +		*ppaction = action;
> +		nr_actions++;
> +	found:
> +
> +		element->action = action;
> +		cursor->action = action;
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +		if (cursor->token_type != TOKEN_CLOSE_ACTION) {
> +			fprintf(stderr, "%s:%d: Missing close action, got '%s'\n",
> +				filename, cursor->line, cursor->content);
> +			exit(1);
> +		}
> +		cursor++;
> +	}
> +
> +	*_cursor = cursor;
> +	return top;
> +
> +parse_error:
> +	fprintf(stderr, "%s:%d: Unexpected token '%s'\n",
> +		filename, cursor->line, cursor->content);
> +	exit(1);
> +
> +overrun_error:
> +	fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename);
> +	exit(1);
> +}
> +
> +/*
> + * Parse a compound type list
> + */
> +static struct element *parse_compound(struct token **_cursor, struct token *end,
> +				      int alternates)
> +{
> +	struct element *children, **child_p = &children, *element;
> +	struct token *cursor = *_cursor, *name;
> +
> +	if (cursor->token_type != TOKEN_OPEN_CURLY) {
> +		fprintf(stderr, "%s:%d: Expected compound to start with brace not '%s'\n",
> +			filename, cursor->line, cursor->content);
> +		exit(1);
> +	}
> +	cursor++;
> +	if (cursor >= end)
> +		goto overrun_error;
> +
> +	if (cursor->token_type == TOKEN_OPEN_CURLY) {
> +		fprintf(stderr, "%s:%d: Empty compound\n",
> +			filename, cursor->line);
> +		exit(1);
> +	}
> +
> +	for (;;) {
> +		name = NULL;
> +		if (cursor->token_type == TOKEN_ELEMENT_NAME) {
> +			name = cursor;
> +			cursor++;
> +			if (cursor >= end)
> +				goto overrun_error;
> +		}
> +
> +		element = parse_type(&cursor, end, name);
> +		if (alternates)
> +			element->flags |= ELEMENT_SKIPPABLE | ELEMENT_CONDITIONAL;
> +
> +		*child_p = element;
> +		child_p = &element->next;
> +
> +		if (cursor >= end)
> +			goto overrun_error;
> +		if (cursor->token_type != TOKEN_COMMA)
> +			break;
> +		cursor++;
> +		if (cursor >= end)
> +			goto overrun_error;
> +	}
> +
> +	children->flags &= ~ELEMENT_CONDITIONAL;
> +
> +	if (cursor->token_type != TOKEN_CLOSE_CURLY) {
> +		fprintf(stderr, "%s:%d: Expected compound closure, got '%s'\n",
> +			filename, cursor->line, cursor->content);
> +		exit(1);
> +	}
> +	cursor++;
> +
> +	*_cursor = cursor;
> +	return children;
> +
> +overrun_error:
> +	fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename);
> +	exit(1);
> +}
> +
> +static void dump_element(const struct element *e, int level)
> +{
> +	const struct element *c;
> +	const struct type *t = e->type_def;
> +	const char *name = e->name ? e->name->content : ".";
> +	const char *tname = t && t->name ? t->name->content : ".";
> +	char tag[32];
> +
> +	if (e->class == 0 && e->method == 0 && e->tag == 0)
> +		strcpy(tag, "<...>");
> +	else if (e->class == ASN1_UNIV)
> +		sprintf(tag, "%s %s %s",
> +			asn1_classes[e->class],
> +			asn1_methods[e->method],
> +			asn1_universal_tags[e->tag]);
> +	else
> +		sprintf(tag, "%s %s %u",
> +			asn1_classes[e->class],
> +			asn1_methods[e->method],
> +			e->tag);
> +
> +	printf("%c%c%c%c%c %c %*s[*] \e[33m%s\e[m %s %s \e[35m%s\e[m\n",
> +	       e->flags & ELEMENT_IMPLICIT ? 'I' : '-',
> +	       e->flags & ELEMENT_EXPLICIT ? 'E' : '-',
> +	       e->flags & ELEMENT_TAG_SPECIFIED ? 'T' : '-',
> +	       e->flags & ELEMENT_SKIPPABLE ? 'S' : '-',
> +	       e->flags & ELEMENT_CONDITIONAL ? 'C' : '-',
> +	       "-tTqQcaro"[e->compound],
> +	       level, "",
> +	       tag,
> +	       tname,
> +	       name,
> +	       e->action ? e->action->name : "");
> +	if (e->compound == TYPE_REF)
> +		dump_element(e->type->type->element, level + 3);
> +	else
> +		for (c = e->children; c; c = c->next)
> +			dump_element(c, level + 3);
> +}
> +
> +static void dump_elements(void)
> +{
> +	if (debug_opt)
> +		dump_element(type_list[0].element, 0);
> +}
> +
> +static void render_element(FILE *out, struct element *e, struct element *tag);
> +static void render_out_of_line_list(FILE *out);
> +
> +static int nr_entries;
> +static int render_depth = 1;
> +static struct element *render_list, **render_list_p = &render_list;
> +
> +__attribute__((format(printf, 2, 3)))
> +static void render_opcode(FILE *out, const char *fmt, ...)
> +{
> +	va_list va;
> +
> +	if (out) {
> +		fprintf(out, "\t[%4d] =%*s", nr_entries, render_depth, "");
> +		va_start(va, fmt);
> +		vfprintf(out, fmt, va);
> +		va_end(va);
> +	}
> +	nr_entries++;
> +}
> +
> +__attribute__((format(printf, 2, 3)))
> +static void render_more(FILE *out, const char *fmt, ...)
> +{
> +	va_list va;
> +
> +	if (out) {
> +		va_start(va, fmt);
> +		vfprintf(out, fmt, va);
> +		va_end(va);
> +	}
> +}
> +
> +/*
> + * Render the grammar into a state machine definition.
> + */
> +static void render(FILE *out, FILE *hdr)
> +{
> +	struct element *e;
> +	struct action *action;
> +	struct type *root;
> +	int index;
> +
> +	fprintf(hdr, "/*\n");
> +	fprintf(hdr, " * Automatically generated by asn1_compiler.  Do not edit\n");
> +	fprintf(hdr, " *\n");
> +	fprintf(hdr, " * ASN.1 parser for %s\n", grammar_name);
> +	fprintf(hdr, " */\n");
> +	fprintf(hdr, "#include <linux/asn1_decoder.h>\n");
> +	fprintf(hdr, "\n");
> +	fprintf(hdr, "extern const struct asn1_decoder %s_decoder;\n", grammar_name);
> +	if (ferror(hdr)) {
> +		perror(headername);
> +		exit(1);
> +	}
> +
> +	fprintf(out, "/*\n");
> +	fprintf(out, " * Automatically generated by asn1_compiler.  Do not edit\n");
> +	fprintf(out, " *\n");
> +	fprintf(out, " * ASN.1 parser for %s\n", grammar_name);
> +	fprintf(out, " */\n");
> +	fprintf(out, "#include <linux/asn1_ber_bytecode.h>\n");
> +	fprintf(out, "#include \"%s.asn1.h\"\n", grammar_name);
> +	fprintf(out, "\n");
> +	if (ferror(out)) {
> +		perror(outputname);
> +		exit(1);
> +	}
> +
> +	/* Tabulate the action functions we might have to call */
> +	fprintf(hdr, "\n");
> +	index = 0;
> +	for (action = action_list; action; action = action->next) {
> +		action->index = index++;
> +		fprintf(hdr,
> +			"extern int %s(void *, size_t, unsigned char,"
> +			" const void *, size_t);\n",
> +			action->name);
> +	}
> +	fprintf(hdr, "\n");
> +
> +	fprintf(out, "enum %s_actions {\n", grammar_name);
> +	for (action = action_list; action; action = action->next)
> +		fprintf(out, "\tACT_%s = %u,\n",
> +			action->name, action->index);
> +	fprintf(out, "\tNR__%s_actions = %u\n", grammar_name, nr_actions);
> +	fprintf(out, "};\n");
> +
> +	fprintf(out, "\n");
> +	fprintf(out, "static const asn1_action_t %s_action_table[NR__%s_actions] = {\n",
> +		grammar_name, grammar_name);
> +	for (action = action_list; action; action = action->next)
> +		fprintf(out, "\t[%4u] = %s,\n", action->index, action->name);
> +	fprintf(out, "};\n");
> +
> +	if (ferror(out)) {
> +		perror(outputname);
> +		exit(1);
> +	}
> +
> +	/* We do two passes - the first one calculates all the offsets */
> +	verbose("Pass 1\n");
> +	nr_entries = 0;
> +	root = &type_list[0];
> +	render_element(NULL, root->element, NULL);
> +	render_opcode(NULL, "ASN1_OP_COMPLETE,\n");
> +	render_out_of_line_list(NULL);
> +
> +	for (e = element_list; e; e = e->list_next)
> +		e->flags &= ~ELEMENT_RENDERED;
> +
> +	/* And then we actually render */
> +	verbose("Pass 2\n");
> +	fprintf(out, "\n");
> +	fprintf(out, "static const unsigned char %s_machine[] = {\n",
> +		grammar_name);
> +
> +	nr_entries = 0;
> +	root = &type_list[0];
> +	render_element(out, root->element, NULL);
> +	render_opcode(out, "ASN1_OP_COMPLETE,\n");
> +	render_out_of_line_list(out);
> +
> +	fprintf(out, "};\n");
> +
> +	fprintf(out, "\n");
> +	fprintf(out, "const struct asn1_decoder %s_decoder = {\n", grammar_name);
> +	fprintf(out, "\t.machine = %s_machine,\n", grammar_name);
> +	fprintf(out, "\t.machlen = sizeof(%s_machine),\n", grammar_name);
> +	fprintf(out, "\t.actions = %s_action_table,\n", grammar_name);
> +	fprintf(out, "};\n");
> +}
> +
> +/*
> + * Render the out-of-line elements
> + */
> +static void render_out_of_line_list(FILE *out)
> +{
> +	struct element *e, *ce;
> +	const char *act;
> +	int entry;
> +
> +	while ((e = render_list)) {
> +		render_list = e->render_next;
> +		if (!render_list)
> +			render_list_p = &render_list;
> +
> +		render_more(out, "\n");
> +		e->entry_index = entry = nr_entries;
> +		render_depth++;
> +		for (ce = e->children; ce; ce = ce->next)
> +			render_element(out, ce, NULL);
> +		render_depth--;
> +
> +		act = e->action ? "_ACT" : "";
> +		switch (e->compound) {
> +		case SEQUENCE:
> +			render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act);
> +			break;
> +		case SEQUENCE_OF:
> +			render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act);
> +			render_opcode(out, "_jump_target(%u),\n", entry);
> +			break;
> +		case SET:
> +			render_opcode(out, "ASN1_OP_END_SET%s,\n", act);
> +			break;
> +		case SET_OF:
> +			render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act);
> +			render_opcode(out, "_jump_target(%u),\n", entry);
> +			break;
> +		default:
> +			break;
> +		}
> +		if (e->action)
> +			render_opcode(out, "_action(ACT_%s),\n",
> +				      e->action->name);
> +		render_opcode(out, "ASN1_OP_RETURN,\n");
> +	}
> +}
> +
> +/*
> + * Render an element.
> + */
> +static void render_element(FILE *out, struct element *e, struct element *tag)
> +{
> +	struct element *ec, *x;
> +	const char *cond, *act;
> +	int entry, skippable = 0, outofline = 0;
> +
> +	if (e->flags & ELEMENT_SKIPPABLE ||
> +	    (tag && tag->flags & ELEMENT_SKIPPABLE))
> +		skippable = 1;
> +
> +	if ((e->type_def && e->type_def->ref_count > 1) ||
> +	    skippable)
> +		outofline = 1;
> +
> +	if (e->type_def && out) {
> +		render_more(out, "\t// %s\n", e->type_def->name->content);
> +	}
> +
> +	/* Render the operation */
> +	cond = (e->flags & ELEMENT_CONDITIONAL ||
> +		(tag && tag->flags & ELEMENT_CONDITIONAL)) ? "COND_" : "";
> +	act = e->action ? "_ACT" : "";
> +	switch (e->compound) {
> +	case ANY:
> +		render_opcode(out, "ASN1_OP_%sMATCH_ANY%s%s,",
> +			      cond, act, skippable ? "_OR_SKIP" : "");
> +		if (e->name)
> +			render_more(out, "\t\t// %s", e->name->content);
> +		render_more(out, "\n");
> +		goto dont_render_tag;
> +
> +	case TAG_OVERRIDE:
> +		render_element(out, e->children, e);
> +		return;
> +
> +	case SEQUENCE:
> +	case SEQUENCE_OF:
> +	case SET:
> +	case SET_OF:
> +		render_opcode(out, "ASN1_OP_%sMATCH%s%s,",
> +			      cond,
> +			      outofline ? "_JUMP" : "",
> +			      skippable ? "_OR_SKIP" : "");
> +		break;
> +
> +	case CHOICE:
> +		goto dont_render_tag;
> +
> +	case TYPE_REF:
> +		if (e->class == ASN1_UNIV && e->method == ASN1_PRIM && e->tag == 0)
> +			goto dont_render_tag;
> +	default:
> +		render_opcode(out, "ASN1_OP_%sMATCH%s%s,",
> +			      cond, act,
> +			      skippable ? "_OR_SKIP" : "");
> +		break;
> +	}
> +
> +	x = tag ?: e;
> +	if (x->name)
> +		render_more(out, "\t\t// %s", x->name->content);
> +	render_more(out, "\n");
> +
> +	/* Render the tag */
> +	if (!tag || !(tag->flags & ELEMENT_TAG_SPECIFIED))
> +		tag = e;
> +
> +	if (tag->class == ASN1_UNIV &&
> +	    tag->tag != 14 &&
> +	    tag->tag != 15 &&
> +	    tag->tag != 31)
> +		render_opcode(out, "_tag(%s, %s, %s),\n",
> +			      asn1_classes[tag->class],
> +			      asn1_methods[tag->method | e->method],
> +			      asn1_universal_tags[tag->tag]);
> +	else
> +		render_opcode(out, "_tagn(%s, %s, %2u),\n",
> +			      asn1_classes[tag->class],
> +			      asn1_methods[tag->method | e->method],
> +			      tag->tag);
> +	tag = NULL;
> +dont_render_tag:
> +
> +	/* Deal with compound types */
> +	switch (e->compound) {
> +	case TYPE_REF:
> +		render_element(out, e->type->type->element, tag);
> +		if (e->action)
> +			render_opcode(out, "ASN1_OP_%sACT,\n",
> +				      skippable ? "MAYBE_" : "");
> +		break;
> +
> +	case SEQUENCE:
> +		if (outofline) {
> +			/* Render out-of-line for multiple use or
> +			 * skipability */
> +			render_opcode(out, "_jump_target(%u),", e->entry_index);
> +			if (e->type_def && e->type_def->name)
> +				render_more(out, "\t\t// --> %s",
> +					    e->type_def->name->content);
> +			render_more(out, "\n");
> +			if (!(e->flags & ELEMENT_RENDERED)) {
> +				e->flags |= ELEMENT_RENDERED;
> +				*render_list_p = e;
> +				render_list_p = &e->render_next;
> +			}
> +			return;
> +		} else {
> +			/* Render inline for single use */
> +			render_depth++;
> +			for (ec = e->children; ec; ec = ec->next)
> +				render_element(out, ec, NULL);
> +			render_depth--;
> +			render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act);
> +		}
> +		break;
> +
> +	case SEQUENCE_OF:
> +	case SET_OF:
> +		if (outofline) {
> +			/* Render out-of-line for multiple use or
> +			 * skipability */
> +			render_opcode(out, "_jump_target(%u),", e->entry_index);
> +			if (e->type_def && e->type_def->name)
> +				render_more(out, "\t\t// --> %s",
> +					    e->type_def->name->content);
> +			render_more(out, "\n");
> +			if (!(e->flags & ELEMENT_RENDERED)) {
> +				e->flags |= ELEMENT_RENDERED;
> +				*render_list_p = e;
> +				render_list_p = &e->render_next;
> +			}
> +			return;
> +		} else {
> +			/* Render inline for single use */
> +			entry = nr_entries;
> +			render_depth++;
> +			render_element(out, e->children, NULL);
> +			render_depth--;
> +			if (e->compound == SEQUENCE_OF)
> +				render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act);
> +			else
> +				render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act);
> +			render_opcode(out, "_jump_target(%u),\n", entry);
> +		}
> +		break;
> +
> +	case SET:
> +		/* I can't think of a nice way to do SET support without having
> +		 * a stack of bitmasks to make sure no element is repeated.
> +		 * The bitmask has also to be checked that no non-optional
> +		 * elements are left out whilst not preventing optional
> +		 * elements from being left out.
> +		 */
> +		fprintf(stderr, "The ASN.1 SET type is not currently supported.\n");
> +		exit(1);
> +
> +	case CHOICE:
> +		for (ec = e->children; ec; ec = ec->next)
> +			render_element(out, ec, ec);
> +		if (!skippable)
> +			render_opcode(out, "ASN1_OP_COND_FAIL,\n");
> +		if (e->action)
> +			render_opcode(out, "ASN1_OP_ACT,\n");
> +		break;
> +
> +	default:
> +		break;
> +	}
> +
> +	if (e->action)
> +		render_opcode(out, "_action(ACT_%s),\n", e->action->name);
> +}
>
Takahiro Akashi Oct. 17, 2019, 6:25 a.m. UTC | #2
On Sat, Oct 12, 2019 at 02:22:14PM +0200, Heinrich Schuchardt wrote:
> On 10/11/19 9:41 AM, AKASHI Takahiro wrote:
> >Imported from linux kernel v5.3.
> >
> >This host command will be used to create a ASN1 parser, for example,
> >for pkcs7 or x509.
> >
> >Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> >---
> >  cmd/Kconfig                       |    3 +
> >  include/linux/asn1.h              |   65 ++
> >  include/linux/asn1_ber_bytecode.h |   89 ++
> >  include/linux/asn1_decoder.h      |   20 +
> >  scripts/Makefile                  |    3 +
> >  scripts/asn1_compiler.c           | 1611 +++++++++++++++++++++++++++++
> 
> Except for Makefile and Kconfig these are verbatime copies of the Linux
> files. OK.
> 
> >  6 files changed, 1791 insertions(+)
> >  create mode 100644 include/linux/asn1.h
> >  create mode 100644 include/linux/asn1_ber_bytecode.h
> >  create mode 100644 include/linux/asn1_decoder.h
> >  create mode 100644 scripts/asn1_compiler.c
> >
> >diff --git a/cmd/Kconfig b/cmd/Kconfig
> >index 4e61565aab16..605dcfdf4282 100644
> >--- a/cmd/Kconfig
> >+++ b/cmd/Kconfig
> >@@ -184,6 +184,9 @@ endmenu
> >  config BUILD_BIN2C
> >  	bool
> >
> >+config BUILD_ASN1
> >+	bool
> >+
> >  comment "Commands"
> >
> >  menu "Info commands"
> >diff --git a/include/linux/asn1.h b/include/linux/asn1.h
> >new file mode 100644
> >index 000000000000..a4d0bdd10711
> >--- /dev/null
> >+++ b/include/linux/asn1.h
> >@@ -0,0 +1,65 @@
> >+/* SPDX-License-Identifier: GPL-2.0-or-later */
> >+/* ASN.1 BER/DER/CER encoding definitions
> >+ *
> >+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
> >+ * Written by David Howells (dhowells@redhat.com)
> >+ */
> >+
> >+#ifndef _LINUX_ASN1_H
> >+#define _LINUX_ASN1_H
> >+
> >+/* Class */
> >+enum asn1_class {
> >+	ASN1_UNIV	= 0,	/* Universal */
> >+	ASN1_APPL	= 1,	/* Application */
> >+	ASN1_CONT	= 2,	/* Context */
> >+	ASN1_PRIV	= 3	/* Private */
> >+};
> >+#define ASN1_CLASS_BITS	0xc0
> >+
> >+
> >+enum asn1_method {
> >+	ASN1_PRIM	= 0,	/* Primitive */
> >+	ASN1_CONS	= 1	/* Constructed */
> >+};
> >+#define ASN1_CONS_BIT	0x20
> >+
> >+/* Tag */
> >+enum asn1_tag {
> >+	ASN1_EOC	= 0,	/* End Of Contents or N/A */
> >+	ASN1_BOOL	= 1,	/* Boolean */
> >+	ASN1_INT	= 2,	/* Integer */
> >+	ASN1_BTS	= 3,	/* Bit String */
> >+	ASN1_OTS	= 4,	/* Octet String */
> >+	ASN1_NULL	= 5,	/* Null */
> >+	ASN1_OID	= 6,	/* Object Identifier  */
> >+	ASN1_ODE	= 7,	/* Object Description */
> >+	ASN1_EXT	= 8,	/* External */
> >+	ASN1_REAL	= 9,	/* Real float */
> >+	ASN1_ENUM	= 10,	/* Enumerated */
> >+	ASN1_EPDV	= 11,	/* Embedded PDV */
> >+	ASN1_UTF8STR	= 12,	/* UTF8 String */
> >+	ASN1_RELOID	= 13,	/* Relative OID */
> >+	/* 14 - Reserved */
> >+	/* 15 - Reserved */
> >+	ASN1_SEQ	= 16,	/* Sequence and Sequence of */
> >+	ASN1_SET	= 17,	/* Set and Set of */
> >+	ASN1_NUMSTR	= 18,	/* Numerical String */
> >+	ASN1_PRNSTR	= 19,	/* Printable String */
> >+	ASN1_TEXSTR	= 20,	/* T61 String / Teletext String */
> >+	ASN1_VIDSTR	= 21,	/* Videotex String */
> >+	ASN1_IA5STR	= 22,	/* IA5 String */
> >+	ASN1_UNITIM	= 23,	/* Universal Time */
> >+	ASN1_GENTIM	= 24,	/* General Time */
> >+	ASN1_GRASTR	= 25,	/* Graphic String */
> >+	ASN1_VISSTR	= 26,	/* Visible String */
> >+	ASN1_GENSTR	= 27,	/* General String */
> >+	ASN1_UNISTR	= 28,	/* Universal String */
> >+	ASN1_CHRSTR	= 29,	/* Character String */
> >+	ASN1_BMPSTR	= 30,	/* BMP String */
> >+	ASN1_LONG_TAG	= 31	/* Long form tag */
> >+};
> >+
> >+#define ASN1_INDEFINITE_LENGTH 0x80
> >+
> >+#endif /* _LINUX_ASN1_H */
> >diff --git a/include/linux/asn1_ber_bytecode.h b/include/linux/asn1_ber_bytecode.h
> >new file mode 100644
> >index 000000000000..b38361953a48
> >--- /dev/null
> >+++ b/include/linux/asn1_ber_bytecode.h
> >@@ -0,0 +1,89 @@
> >+/* SPDX-License-Identifier: GPL-2.0-or-later */
> >+/* ASN.1 BER/DER/CER parsing state machine internal definitions
> >+ *
> >+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
> >+ * Written by David Howells (dhowells@redhat.com)
> >+ */
> >+
> >+#ifndef _LINUX_ASN1_BER_BYTECODE_H
> >+#define _LINUX_ASN1_BER_BYTECODE_H
> >+
> >+#ifdef __KERNEL__
> >+#include <linux/types.h>
> >+#endif
> >+#include <linux/asn1.h>
> >+
> >+typedef int (*asn1_action_t)(void *context,
> >+			     size_t hdrlen, /* In case of ANY type */
> >+			     unsigned char tag, /* In case of ANY type */
> >+			     const void *value, size_t vlen);
> >+
> >+struct asn1_decoder {
> >+	const unsigned char *machine;
> >+	size_t machlen;
> >+	const asn1_action_t *actions;
> >+};
> >+
> >+enum asn1_opcode {
> >+	/* The tag-matching ops come first and the odd-numbered slots
> >+	 * are for OR_SKIP ops.
> >+	 */
> >+#define ASN1_OP_MATCH__SKIP		  0x01
> >+#define ASN1_OP_MATCH__ACT		  0x02
> >+#define ASN1_OP_MATCH__JUMP		  0x04
> >+#define ASN1_OP_MATCH__ANY		  0x08
> >+#define ASN1_OP_MATCH__COND		  0x10
> >+
> >+	ASN1_OP_MATCH			= 0x00,
> >+	ASN1_OP_MATCH_OR_SKIP		= 0x01,
> >+	ASN1_OP_MATCH_ACT		= 0x02,
> >+	ASN1_OP_MATCH_ACT_OR_SKIP	= 0x03,
> >+	ASN1_OP_MATCH_JUMP		= 0x04,
> >+	ASN1_OP_MATCH_JUMP_OR_SKIP	= 0x05,
> >+	ASN1_OP_MATCH_ANY		= 0x08,
> >+	ASN1_OP_MATCH_ANY_OR_SKIP	= 0x09,
> >+	ASN1_OP_MATCH_ANY_ACT		= 0x0a,
> >+	ASN1_OP_MATCH_ANY_ACT_OR_SKIP	= 0x0b,
> >+	/* Everything before here matches unconditionally */
> >+
> >+	ASN1_OP_COND_MATCH_OR_SKIP	= 0x11,
> >+	ASN1_OP_COND_MATCH_ACT_OR_SKIP	= 0x13,
> >+	ASN1_OP_COND_MATCH_JUMP_OR_SKIP	= 0x15,
> >+	ASN1_OP_COND_MATCH_ANY		= 0x18,
> >+	ASN1_OP_COND_MATCH_ANY_OR_SKIP	= 0x19,
> >+	ASN1_OP_COND_MATCH_ANY_ACT	= 0x1a,
> >+	ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP = 0x1b,
> >+
> >+	/* Everything before here will want a tag from the data */
> >+#define ASN1_OP__MATCHES_TAG ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP
> >+
> >+	/* These are here to help fill up space */
> >+	ASN1_OP_COND_FAIL		= 0x1c,
> >+	ASN1_OP_COMPLETE		= 0x1d,
> >+	ASN1_OP_ACT			= 0x1e,
> >+	ASN1_OP_MAYBE_ACT		= 0x1f,
> >+
> >+	/* The following eight have bit 0 -> SET, 1 -> OF, 2 -> ACT */
> >+	ASN1_OP_END_SEQ			= 0x20,
> >+	ASN1_OP_END_SET			= 0x21,
> >+	ASN1_OP_END_SEQ_OF		= 0x22,
> >+	ASN1_OP_END_SET_OF		= 0x23,
> >+	ASN1_OP_END_SEQ_ACT		= 0x24,
> >+	ASN1_OP_END_SET_ACT		= 0x25,
> >+	ASN1_OP_END_SEQ_OF_ACT		= 0x26,
> >+	ASN1_OP_END_SET_OF_ACT		= 0x27,
> >+#define ASN1_OP_END__SET		  0x01
> >+#define ASN1_OP_END__OF			  0x02
> >+#define ASN1_OP_END__ACT		  0x04
> >+
> >+	ASN1_OP_RETURN			= 0x28,
> >+
> >+	ASN1_OP__NR
> >+};
> >+
> >+#define _tag(CLASS, CP, TAG) ((ASN1_##CLASS << 6) | (ASN1_##CP << 5) | ASN1_##TAG)
> >+#define _tagn(CLASS, CP, TAG) ((ASN1_##CLASS << 6) | (ASN1_##CP << 5) | TAG)
> >+#define _jump_target(N) (N)
> >+#define _action(N) (N)
> >+
> >+#endif /* _LINUX_ASN1_BER_BYTECODE_H */
> >diff --git a/include/linux/asn1_decoder.h b/include/linux/asn1_decoder.h
> >new file mode 100644
> >index 000000000000..83f9c6e1e5e9
> >--- /dev/null
> >+++ b/include/linux/asn1_decoder.h
> >@@ -0,0 +1,20 @@
> >+/* SPDX-License-Identifier: GPL-2.0-or-later */
> >+/* ASN.1 decoder
> >+ *
> >+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
> >+ * Written by David Howells (dhowells@redhat.com)
> >+ */
> >+
> >+#ifndef _LINUX_ASN1_DECODER_H
> >+#define _LINUX_ASN1_DECODER_H
> >+
> >+#include <linux/asn1.h>
> >+
> >+struct asn1_decoder;
> >+
> >+extern int asn1_ber_decoder(const struct asn1_decoder *decoder,
> >+			    void *context,
> >+			    const unsigned char *data,
> >+			    size_t datalen);
> >+
> >+#endif /* _LINUX_ASN1_DECODER_H */
> >diff --git a/scripts/Makefile b/scripts/Makefile
> >index e7b353f77f43..c4e2ae5db2ea 100644
> >--- a/scripts/Makefile
> >+++ b/scripts/Makefile
> >@@ -5,6 +5,9 @@
> >  # ---------------------------------------------------------------------------
> >
> >  hostprogs-$(CONFIG_BUILD_BIN2C)		+= bin2c
> >+hostprogs-$(CONFIG_BUILD_ASN1)		+= asn1_compiler
> >+
> >+HOSTCFLAGS_asn1_compiler.o = -idirafter $(srctree)/include
> 
> Which problems did you run into that make you use -idirafter here?

Without this directive, a compiler supersedes *host's* include
over U-Boot's include in matching "linux/", then it will miss out
include/linux/asn1_ber_bytecode.h.

-Takahiro Akashi


> Otherwise
> 
> Reviewed-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
> 
> 
> >
> >  always		:= $(hostprogs-y)
> >
> >diff --git a/scripts/asn1_compiler.c b/scripts/asn1_compiler.c
> >new file mode 100644
> >index 000000000000..adabd4145264
> >--- /dev/null
> >+++ b/scripts/asn1_compiler.c
> >@@ -0,0 +1,1611 @@
> >+// SPDX-License-Identifier: GPL-2.0-or-later
> >+/* Simplified ASN.1 notation parser
> >+ *
> >+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
> >+ * Written by David Howells (dhowells@redhat.com)
> >+ */
> >+
> >+#include <stdarg.h>
> >+#include <stdio.h>
> >+#include <stdlib.h>
> >+#include <stdint.h>
> >+#include <stdbool.h>
> >+#include <string.h>
> >+#include <ctype.h>
> >+#include <unistd.h>
> >+#include <fcntl.h>
> >+#include <sys/stat.h>
> >+#include <linux/asn1_ber_bytecode.h>
> >+
> >+enum token_type {
> >+	DIRECTIVE_ABSENT,
> >+	DIRECTIVE_ALL,
> >+	DIRECTIVE_ANY,
> >+	DIRECTIVE_APPLICATION,
> >+	DIRECTIVE_AUTOMATIC,
> >+	DIRECTIVE_BEGIN,
> >+	DIRECTIVE_BIT,
> >+	DIRECTIVE_BMPString,
> >+	DIRECTIVE_BOOLEAN,
> >+	DIRECTIVE_BY,
> >+	DIRECTIVE_CHARACTER,
> >+	DIRECTIVE_CHOICE,
> >+	DIRECTIVE_CLASS,
> >+	DIRECTIVE_COMPONENT,
> >+	DIRECTIVE_COMPONENTS,
> >+	DIRECTIVE_CONSTRAINED,
> >+	DIRECTIVE_CONTAINING,
> >+	DIRECTIVE_DEFAULT,
> >+	DIRECTIVE_DEFINED,
> >+	DIRECTIVE_DEFINITIONS,
> >+	DIRECTIVE_EMBEDDED,
> >+	DIRECTIVE_ENCODED,
> >+	DIRECTIVE_ENCODING_CONTROL,
> >+	DIRECTIVE_END,
> >+	DIRECTIVE_ENUMERATED,
> >+	DIRECTIVE_EXCEPT,
> >+	DIRECTIVE_EXPLICIT,
> >+	DIRECTIVE_EXPORTS,
> >+	DIRECTIVE_EXTENSIBILITY,
> >+	DIRECTIVE_EXTERNAL,
> >+	DIRECTIVE_FALSE,
> >+	DIRECTIVE_FROM,
> >+	DIRECTIVE_GeneralString,
> >+	DIRECTIVE_GeneralizedTime,
> >+	DIRECTIVE_GraphicString,
> >+	DIRECTIVE_IA5String,
> >+	DIRECTIVE_IDENTIFIER,
> >+	DIRECTIVE_IMPLICIT,
> >+	DIRECTIVE_IMPLIED,
> >+	DIRECTIVE_IMPORTS,
> >+	DIRECTIVE_INCLUDES,
> >+	DIRECTIVE_INSTANCE,
> >+	DIRECTIVE_INSTRUCTIONS,
> >+	DIRECTIVE_INTEGER,
> >+	DIRECTIVE_INTERSECTION,
> >+	DIRECTIVE_ISO646String,
> >+	DIRECTIVE_MAX,
> >+	DIRECTIVE_MIN,
> >+	DIRECTIVE_MINUS_INFINITY,
> >+	DIRECTIVE_NULL,
> >+	DIRECTIVE_NumericString,
> >+	DIRECTIVE_OBJECT,
> >+	DIRECTIVE_OCTET,
> >+	DIRECTIVE_OF,
> >+	DIRECTIVE_OPTIONAL,
> >+	DIRECTIVE_ObjectDescriptor,
> >+	DIRECTIVE_PATTERN,
> >+	DIRECTIVE_PDV,
> >+	DIRECTIVE_PLUS_INFINITY,
> >+	DIRECTIVE_PRESENT,
> >+	DIRECTIVE_PRIVATE,
> >+	DIRECTIVE_PrintableString,
> >+	DIRECTIVE_REAL,
> >+	DIRECTIVE_RELATIVE_OID,
> >+	DIRECTIVE_SEQUENCE,
> >+	DIRECTIVE_SET,
> >+	DIRECTIVE_SIZE,
> >+	DIRECTIVE_STRING,
> >+	DIRECTIVE_SYNTAX,
> >+	DIRECTIVE_T61String,
> >+	DIRECTIVE_TAGS,
> >+	DIRECTIVE_TRUE,
> >+	DIRECTIVE_TeletexString,
> >+	DIRECTIVE_UNION,
> >+	DIRECTIVE_UNIQUE,
> >+	DIRECTIVE_UNIVERSAL,
> >+	DIRECTIVE_UTCTime,
> >+	DIRECTIVE_UTF8String,
> >+	DIRECTIVE_UniversalString,
> >+	DIRECTIVE_VideotexString,
> >+	DIRECTIVE_VisibleString,
> >+	DIRECTIVE_WITH,
> >+	NR__DIRECTIVES,
> >+	TOKEN_ASSIGNMENT = NR__DIRECTIVES,
> >+	TOKEN_OPEN_CURLY,
> >+	TOKEN_CLOSE_CURLY,
> >+	TOKEN_OPEN_SQUARE,
> >+	TOKEN_CLOSE_SQUARE,
> >+	TOKEN_OPEN_ACTION,
> >+	TOKEN_CLOSE_ACTION,
> >+	TOKEN_COMMA,
> >+	TOKEN_NUMBER,
> >+	TOKEN_TYPE_NAME,
> >+	TOKEN_ELEMENT_NAME,
> >+	NR__TOKENS
> >+};
> >+
> >+static const unsigned char token_to_tag[NR__TOKENS] = {
> >+	/* EOC goes first */
> >+	[DIRECTIVE_BOOLEAN]		= ASN1_BOOL,
> >+	[DIRECTIVE_INTEGER]		= ASN1_INT,
> >+	[DIRECTIVE_BIT]			= ASN1_BTS,
> >+	[DIRECTIVE_OCTET]		= ASN1_OTS,
> >+	[DIRECTIVE_NULL]		= ASN1_NULL,
> >+	[DIRECTIVE_OBJECT]		= ASN1_OID,
> >+	[DIRECTIVE_ObjectDescriptor]	= ASN1_ODE,
> >+	[DIRECTIVE_EXTERNAL]		= ASN1_EXT,
> >+	[DIRECTIVE_REAL]		= ASN1_REAL,
> >+	[DIRECTIVE_ENUMERATED]		= ASN1_ENUM,
> >+	[DIRECTIVE_EMBEDDED]		= 0,
> >+	[DIRECTIVE_UTF8String]		= ASN1_UTF8STR,
> >+	[DIRECTIVE_RELATIVE_OID]	= ASN1_RELOID,
> >+	/* 14 */
> >+	/* 15 */
> >+	[DIRECTIVE_SEQUENCE]		= ASN1_SEQ,
> >+	[DIRECTIVE_SET]			= ASN1_SET,
> >+	[DIRECTIVE_NumericString]	= ASN1_NUMSTR,
> >+	[DIRECTIVE_PrintableString]	= ASN1_PRNSTR,
> >+	[DIRECTIVE_T61String]		= ASN1_TEXSTR,
> >+	[DIRECTIVE_TeletexString]	= ASN1_TEXSTR,
> >+	[DIRECTIVE_VideotexString]	= ASN1_VIDSTR,
> >+	[DIRECTIVE_IA5String]		= ASN1_IA5STR,
> >+	[DIRECTIVE_UTCTime]		= ASN1_UNITIM,
> >+	[DIRECTIVE_GeneralizedTime]	= ASN1_GENTIM,
> >+	[DIRECTIVE_GraphicString]	= ASN1_GRASTR,
> >+	[DIRECTIVE_VisibleString]	= ASN1_VISSTR,
> >+	[DIRECTIVE_GeneralString]	= ASN1_GENSTR,
> >+	[DIRECTIVE_UniversalString]	= ASN1_UNITIM,
> >+	[DIRECTIVE_CHARACTER]		= ASN1_CHRSTR,
> >+	[DIRECTIVE_BMPString]		= ASN1_BMPSTR,
> >+};
> >+
> >+static const char asn1_classes[4][5] = {
> >+	[ASN1_UNIV]	= "UNIV",
> >+	[ASN1_APPL]	= "APPL",
> >+	[ASN1_CONT]	= "CONT",
> >+	[ASN1_PRIV]	= "PRIV"
> >+};
> >+
> >+static const char asn1_methods[2][5] = {
> >+	[ASN1_UNIV]	= "PRIM",
> >+	[ASN1_APPL]	= "CONS"
> >+};
> >+
> >+static const char *const asn1_universal_tags[32] = {
> >+	"EOC",
> >+	"BOOL",
> >+	"INT",
> >+	"BTS",
> >+	"OTS",
> >+	"NULL",
> >+	"OID",
> >+	"ODE",
> >+	"EXT",
> >+	"REAL",
> >+	"ENUM",
> >+	"EPDV",
> >+	"UTF8STR",
> >+	"RELOID",
> >+	NULL,		/* 14 */
> >+	NULL,		/* 15 */
> >+	"SEQ",
> >+	"SET",
> >+	"NUMSTR",
> >+	"PRNSTR",
> >+	"TEXSTR",
> >+	"VIDSTR",
> >+	"IA5STR",
> >+	"UNITIM",
> >+	"GENTIM",
> >+	"GRASTR",
> >+	"VISSTR",
> >+	"GENSTR",
> >+	"UNISTR",
> >+	"CHRSTR",
> >+	"BMPSTR",
> >+	NULL		/* 31 */
> >+};
> >+
> >+static const char *filename;
> >+static const char *grammar_name;
> >+static const char *outputname;
> >+static const char *headername;
> >+
> >+static const char *const directives[NR__DIRECTIVES] = {
> >+#define _(X) [DIRECTIVE_##X] = #X
> >+	_(ABSENT),
> >+	_(ALL),
> >+	_(ANY),
> >+	_(APPLICATION),
> >+	_(AUTOMATIC),
> >+	_(BEGIN),
> >+	_(BIT),
> >+	_(BMPString),
> >+	_(BOOLEAN),
> >+	_(BY),
> >+	_(CHARACTER),
> >+	_(CHOICE),
> >+	_(CLASS),
> >+	_(COMPONENT),
> >+	_(COMPONENTS),
> >+	_(CONSTRAINED),
> >+	_(CONTAINING),
> >+	_(DEFAULT),
> >+	_(DEFINED),
> >+	_(DEFINITIONS),
> >+	_(EMBEDDED),
> >+	_(ENCODED),
> >+	[DIRECTIVE_ENCODING_CONTROL] = "ENCODING-CONTROL",
> >+	_(END),
> >+	_(ENUMERATED),
> >+	_(EXCEPT),
> >+	_(EXPLICIT),
> >+	_(EXPORTS),
> >+	_(EXTENSIBILITY),
> >+	_(EXTERNAL),
> >+	_(FALSE),
> >+	_(FROM),
> >+	_(GeneralString),
> >+	_(GeneralizedTime),
> >+	_(GraphicString),
> >+	_(IA5String),
> >+	_(IDENTIFIER),
> >+	_(IMPLICIT),
> >+	_(IMPLIED),
> >+	_(IMPORTS),
> >+	_(INCLUDES),
> >+	_(INSTANCE),
> >+	_(INSTRUCTIONS),
> >+	_(INTEGER),
> >+	_(INTERSECTION),
> >+	_(ISO646String),
> >+	_(MAX),
> >+	_(MIN),
> >+	[DIRECTIVE_MINUS_INFINITY] = "MINUS-INFINITY",
> >+	[DIRECTIVE_NULL] = "NULL",
> >+	_(NumericString),
> >+	_(OBJECT),
> >+	_(OCTET),
> >+	_(OF),
> >+	_(OPTIONAL),
> >+	_(ObjectDescriptor),
> >+	_(PATTERN),
> >+	_(PDV),
> >+	[DIRECTIVE_PLUS_INFINITY] = "PLUS-INFINITY",
> >+	_(PRESENT),
> >+	_(PRIVATE),
> >+	_(PrintableString),
> >+	_(REAL),
> >+	[DIRECTIVE_RELATIVE_OID] = "RELATIVE-OID",
> >+	_(SEQUENCE),
> >+	_(SET),
> >+	_(SIZE),
> >+	_(STRING),
> >+	_(SYNTAX),
> >+	_(T61String),
> >+	_(TAGS),
> >+	_(TRUE),
> >+	_(TeletexString),
> >+	_(UNION),
> >+	_(UNIQUE),
> >+	_(UNIVERSAL),
> >+	_(UTCTime),
> >+	_(UTF8String),
> >+	_(UniversalString),
> >+	_(VideotexString),
> >+	_(VisibleString),
> >+	_(WITH)
> >+};
> >+
> >+struct action {
> >+	struct action	*next;
> >+	char		*name;
> >+	unsigned char	index;
> >+};
> >+
> >+static struct action *action_list;
> >+static unsigned nr_actions;
> >+
> >+struct token {
> >+	unsigned short	line;
> >+	enum token_type	token_type : 8;
> >+	unsigned char	size;
> >+	struct action	*action;
> >+	char		*content;
> >+	struct type	*type;
> >+};
> >+
> >+static struct token *token_list;
> >+static unsigned nr_tokens;
> >+static bool verbose_opt;
> >+static bool debug_opt;
> >+
> >+#define verbose(fmt, ...) do { if (verbose_opt) printf(fmt, ## __VA_ARGS__); } while (0)
> >+#define debug(fmt, ...) do { if (debug_opt) printf(fmt, ## __VA_ARGS__); } while (0)
> >+
> >+static int directive_compare(const void *_key, const void *_pdir)
> >+{
> >+	const struct token *token = _key;
> >+	const char *const *pdir = _pdir, *dir = *pdir;
> >+	size_t dlen, clen;
> >+	int val;
> >+
> >+	dlen = strlen(dir);
> >+	clen = (dlen < token->size) ? dlen : token->size;
> >+
> >+	//debug("cmp(%s,%s) = ", token->content, dir);
> >+
> >+	val = memcmp(token->content, dir, clen);
> >+	if (val != 0) {
> >+		//debug("%d [cmp]\n", val);
> >+		return val;
> >+	}
> >+
> >+	if (dlen == token->size) {
> >+		//debug("0\n");
> >+		return 0;
> >+	}
> >+	//debug("%d\n", (int)dlen - (int)token->size);
> >+	return dlen - token->size; /* shorter -> negative */
> >+}
> >+
> >+/*
> >+ * Tokenise an ASN.1 grammar
> >+ */
> >+static void tokenise(char *buffer, char *end)
> >+{
> >+	struct token *tokens;
> >+	char *line, *nl, *start, *p, *q;
> >+	unsigned tix, lineno;
> >+
> >+	/* Assume we're going to have half as many tokens as we have
> >+	 * characters
> >+	 */
> >+	token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token));
> >+	if (!tokens) {
> >+		perror(NULL);
> >+		exit(1);
> >+	}
> >+	tix = 0;
> >+
> >+	lineno = 0;
> >+	while (buffer < end) {
> >+		/* First of all, break out a line */
> >+		lineno++;
> >+		line = buffer;
> >+		nl = memchr(line, '\n', end - buffer);
> >+		if (!nl) {
> >+			buffer = nl = end;
> >+		} else {
> >+			buffer = nl + 1;
> >+			*nl = '\0';
> >+		}
> >+
> >+		/* Remove "--" comments */
> >+		p = line;
> >+	next_comment:
> >+		while ((p = memchr(p, '-', nl - p))) {
> >+			if (p[1] == '-') {
> >+				/* Found a comment; see if there's a terminator */
> >+				q = p + 2;
> >+				while ((q = memchr(q, '-', nl - q))) {
> >+					if (q[1] == '-') {
> >+						/* There is - excise the comment */
> >+						q += 2;
> >+						memmove(p, q, nl - q);
> >+						goto next_comment;
> >+					}
> >+					q++;
> >+				}
> >+				*p = '\0';
> >+				nl = p;
> >+				break;
> >+			} else {
> >+				p++;
> >+			}
> >+		}
> >+
> >+		p = line;
> >+		while (p < nl) {
> >+			/* Skip white space */
> >+			while (p < nl && isspace(*p))
> >+				*(p++) = 0;
> >+			if (p >= nl)
> >+				break;
> >+
> >+			tokens[tix].line = lineno;
> >+			start = p;
> >+
> >+			/* Handle string tokens */
> >+			if (isalpha(*p)) {
> >+				const char **dir;
> >+
> >+				/* Can be a directive, type name or element
> >+				 * name.  Find the end of the name.
> >+				 */
> >+				q = p + 1;
> >+				while (q < nl && (isalnum(*q) || *q == '-' || *q == '_'))
> >+					q++;
> >+				tokens[tix].size = q - p;
> >+				p = q;
> >+
> >+				tokens[tix].content = malloc(tokens[tix].size + 1);
> >+				if (!tokens[tix].content) {
> >+					perror(NULL);
> >+					exit(1);
> >+				}
> >+				memcpy(tokens[tix].content, start, tokens[tix].size);
> >+				tokens[tix].content[tokens[tix].size] = 0;
> >+
> >+				/* If it begins with a lowercase letter then
> >+				 * it's an element name
> >+				 */
> >+				if (islower(tokens[tix].content[0])) {
> >+					tokens[tix++].token_type = TOKEN_ELEMENT_NAME;
> >+					continue;
> >+				}
> >+
> >+				/* Otherwise we need to search the directive
> >+				 * table
> >+				 */
> >+				dir = bsearch(&tokens[tix], directives,
> >+					      sizeof(directives) / sizeof(directives[1]),
> >+					      sizeof(directives[1]),
> >+					      directive_compare);
> >+				if (dir) {
> >+					tokens[tix++].token_type = dir - directives;
> >+					continue;
> >+				}
> >+
> >+				tokens[tix++].token_type = TOKEN_TYPE_NAME;
> >+				continue;
> >+			}
> >+
> >+			/* Handle numbers */
> >+			if (isdigit(*p)) {
> >+				/* Find the end of the number */
> >+				q = p + 1;
> >+				while (q < nl && (isdigit(*q)))
> >+					q++;
> >+				tokens[tix].size = q - p;
> >+				p = q;
> >+				tokens[tix].content = malloc(tokens[tix].size + 1);
> >+				if (!tokens[tix].content) {
> >+					perror(NULL);
> >+					exit(1);
> >+				}
> >+				memcpy(tokens[tix].content, start, tokens[tix].size);
> >+				tokens[tix].content[tokens[tix].size] = 0;
> >+				tokens[tix++].token_type = TOKEN_NUMBER;
> >+				continue;
> >+			}
> >+
> >+			if (nl - p >= 3) {
> >+				if (memcmp(p, "::=", 3) == 0) {
> >+					p += 3;
> >+					tokens[tix].size = 3;
> >+					tokens[tix].content = "::=";
> >+					tokens[tix++].token_type = TOKEN_ASSIGNMENT;
> >+					continue;
> >+				}
> >+			}
> >+
> >+			if (nl - p >= 2) {
> >+				if (memcmp(p, "({", 2) == 0) {
> >+					p += 2;
> >+					tokens[tix].size = 2;
> >+					tokens[tix].content = "({";
> >+					tokens[tix++].token_type = TOKEN_OPEN_ACTION;
> >+					continue;
> >+				}
> >+				if (memcmp(p, "})", 2) == 0) {
> >+					p += 2;
> >+					tokens[tix].size = 2;
> >+					tokens[tix].content = "})";
> >+					tokens[tix++].token_type = TOKEN_CLOSE_ACTION;
> >+					continue;
> >+				}
> >+			}
> >+
> >+			if (nl - p >= 1) {
> >+				tokens[tix].size = 1;
> >+				switch (*p) {
> >+				case '{':
> >+					p += 1;
> >+					tokens[tix].content = "{";
> >+					tokens[tix++].token_type = TOKEN_OPEN_CURLY;
> >+					continue;
> >+				case '}':
> >+					p += 1;
> >+					tokens[tix].content = "}";
> >+					tokens[tix++].token_type = TOKEN_CLOSE_CURLY;
> >+					continue;
> >+				case '[':
> >+					p += 1;
> >+					tokens[tix].content = "[";
> >+					tokens[tix++].token_type = TOKEN_OPEN_SQUARE;
> >+					continue;
> >+				case ']':
> >+					p += 1;
> >+					tokens[tix].content = "]";
> >+					tokens[tix++].token_type = TOKEN_CLOSE_SQUARE;
> >+					continue;
> >+				case ',':
> >+					p += 1;
> >+					tokens[tix].content = ",";
> >+					tokens[tix++].token_type = TOKEN_COMMA;
> >+					continue;
> >+				default:
> >+					break;
> >+				}
> >+			}
> >+
> >+			fprintf(stderr, "%s:%u: Unknown character in grammar: '%c'\n",
> >+				filename, lineno, *p);
> >+			exit(1);
> >+		}
> >+	}
> >+
> >+	nr_tokens = tix;
> >+	verbose("Extracted %u tokens\n", nr_tokens);
> >+
> >+#if 0
> >+	{
> >+		int n;
> >+		for (n = 0; n < nr_tokens; n++)
> >+			debug("Token %3u: '%s'\n", n, token_list[n].content);
> >+	}
> >+#endif
> >+}
> >+
> >+static void build_type_list(void);
> >+static void parse(void);
> >+static void dump_elements(void);
> >+static void render(FILE *out, FILE *hdr);
> >+
> >+/*
> >+ *
> >+ */
> >+int main(int argc, char **argv)
> >+{
> >+	struct stat st;
> >+	ssize_t readlen;
> >+	FILE *out, *hdr;
> >+	char *buffer, *p;
> >+	char *kbuild_verbose;
> >+	int fd;
> >+
> >+	kbuild_verbose = getenv("KBUILD_VERBOSE");
> >+	if (kbuild_verbose)
> >+		verbose_opt = atoi(kbuild_verbose);
> >+
> >+	while (argc > 4) {
> >+		if (strcmp(argv[1], "-v") == 0)
> >+			verbose_opt = true;
> >+		else if (strcmp(argv[1], "-d") == 0)
> >+			debug_opt = true;
> >+		else
> >+			break;
> >+		memmove(&argv[1], &argv[2], (argc - 2) * sizeof(char *));
> >+		argc--;
> >+	}
> >+
> >+	if (argc != 4) {
> >+		fprintf(stderr, "Format: %s [-v] [-d] <grammar-file> <c-file> <hdr-file>\n",
> >+			argv[0]);
> >+		exit(2);
> >+	}
> >+
> >+	filename = argv[1];
> >+	outputname = argv[2];
> >+	headername = argv[3];
> >+
> >+	fd = open(filename, O_RDONLY);
> >+	if (fd < 0) {
> >+		perror(filename);
> >+		exit(1);
> >+	}
> >+
> >+	if (fstat(fd, &st) < 0) {
> >+		perror(filename);
> >+		exit(1);
> >+	}
> >+
> >+	if (!(buffer = malloc(st.st_size + 1))) {
> >+		perror(NULL);
> >+		exit(1);
> >+	}
> >+
> >+	if ((readlen = read(fd, buffer, st.st_size)) < 0) {
> >+		perror(filename);
> >+		exit(1);
> >+	}
> >+
> >+	if (close(fd) < 0) {
> >+		perror(filename);
> >+		exit(1);
> >+	}
> >+
> >+	if (readlen != st.st_size) {
> >+		fprintf(stderr, "%s: Short read\n", filename);
> >+		exit(1);
> >+	}
> >+
> >+	p = strrchr(argv[1], '/');
> >+	p = p ? p + 1 : argv[1];
> >+	grammar_name = strdup(p);
> >+	if (!p) {
> >+		perror(NULL);
> >+		exit(1);
> >+	}
> >+	p = strchr(grammar_name, '.');
> >+	if (p)
> >+		*p = '\0';
> >+
> >+	buffer[readlen] = 0;
> >+	tokenise(buffer, buffer + readlen);
> >+	build_type_list();
> >+	parse();
> >+	dump_elements();
> >+
> >+	out = fopen(outputname, "w");
> >+	if (!out) {
> >+		perror(outputname);
> >+		exit(1);
> >+	}
> >+
> >+	hdr = fopen(headername, "w");
> >+	if (!hdr) {
> >+		perror(headername);
> >+		exit(1);
> >+	}
> >+
> >+	render(out, hdr);
> >+
> >+	if (fclose(out) < 0) {
> >+		perror(outputname);
> >+		exit(1);
> >+	}
> >+
> >+	if (fclose(hdr) < 0) {
> >+		perror(headername);
> >+		exit(1);
> >+	}
> >+
> >+	return 0;
> >+}
> >+
> >+enum compound {
> >+	NOT_COMPOUND,
> >+	SET,
> >+	SET_OF,
> >+	SEQUENCE,
> >+	SEQUENCE_OF,
> >+	CHOICE,
> >+	ANY,
> >+	TYPE_REF,
> >+	TAG_OVERRIDE
> >+};
> >+
> >+struct element {
> >+	struct type	*type_def;
> >+	struct token	*name;
> >+	struct token	*type;
> >+	struct action	*action;
> >+	struct element	*children;
> >+	struct element	*next;
> >+	struct element	*render_next;
> >+	struct element	*list_next;
> >+	uint8_t		n_elements;
> >+	enum compound	compound : 8;
> >+	enum asn1_class	class : 8;
> >+	enum asn1_method method : 8;
> >+	uint8_t		tag;
> >+	unsigned	entry_index;
> >+	unsigned	flags;
> >+#define ELEMENT_IMPLICIT	0x0001
> >+#define ELEMENT_EXPLICIT	0x0002
> >+#define ELEMENT_TAG_SPECIFIED	0x0004
> >+#define ELEMENT_RENDERED	0x0008
> >+#define ELEMENT_SKIPPABLE	0x0010
> >+#define ELEMENT_CONDITIONAL	0x0020
> >+};
> >+
> >+struct type {
> >+	struct token	*name;
> >+	struct token	*def;
> >+	struct element	*element;
> >+	unsigned	ref_count;
> >+	unsigned	flags;
> >+#define TYPE_STOP_MARKER	0x0001
> >+#define TYPE_BEGIN		0x0002
> >+};
> >+
> >+static struct type *type_list;
> >+static struct type **type_index;
> >+static unsigned nr_types;
> >+
> >+static int type_index_compare(const void *_a, const void *_b)
> >+{
> >+	const struct type *const *a = _a, *const *b = _b;
> >+
> >+	if ((*a)->name->size != (*b)->name->size)
> >+		return (*a)->name->size - (*b)->name->size;
> >+	else
> >+		return memcmp((*a)->name->content, (*b)->name->content,
> >+			      (*a)->name->size);
> >+}
> >+
> >+static int type_finder(const void *_key, const void *_ti)
> >+{
> >+	const struct token *token = _key;
> >+	const struct type *const *ti = _ti;
> >+	const struct type *type = *ti;
> >+
> >+	if (token->size != type->name->size)
> >+		return token->size - type->name->size;
> >+	else
> >+		return memcmp(token->content, type->name->content,
> >+			      token->size);
> >+}
> >+
> >+/*
> >+ * Build up a list of types and a sorted index to that list.
> >+ */
> >+static void build_type_list(void)
> >+{
> >+	struct type *types;
> >+	unsigned nr, t, n;
> >+
> >+	nr = 0;
> >+	for (n = 0; n < nr_tokens - 1; n++)
> >+		if (token_list[n + 0].token_type == TOKEN_TYPE_NAME &&
> >+		    token_list[n + 1].token_type == TOKEN_ASSIGNMENT)
> >+			nr++;
> >+
> >+	if (nr == 0) {
> >+		fprintf(stderr, "%s: No defined types\n", filename);
> >+		exit(1);
> >+	}
> >+
> >+	nr_types = nr;
> >+	types = type_list = calloc(nr + 1, sizeof(type_list[0]));
> >+	if (!type_list) {
> >+		perror(NULL);
> >+		exit(1);
> >+	}
> >+	type_index = calloc(nr, sizeof(type_index[0]));
> >+	if (!type_index) {
> >+		perror(NULL);
> >+		exit(1);
> >+	}
> >+
> >+	t = 0;
> >+	types[t].flags |= TYPE_BEGIN;
> >+	for (n = 0; n < nr_tokens - 1; n++) {
> >+		if (token_list[n + 0].token_type == TOKEN_TYPE_NAME &&
> >+		    token_list[n + 1].token_type == TOKEN_ASSIGNMENT) {
> >+			types[t].name = &token_list[n];
> >+			type_index[t] = &types[t];
> >+			t++;
> >+		}
> >+	}
> >+	types[t].name = &token_list[n + 1];
> >+	types[t].flags |= TYPE_STOP_MARKER;
> >+
> >+	qsort(type_index, nr, sizeof(type_index[0]), type_index_compare);
> >+
> >+	verbose("Extracted %u types\n", nr_types);
> >+#if 0
> >+	for (n = 0; n < nr_types; n++) {
> >+		struct type *type = type_index[n];
> >+		debug("- %*.*s\n", type->name->content);
> >+	}
> >+#endif
> >+}
> >+
> >+static struct element *parse_type(struct token **_cursor, struct token *stop,
> >+				  struct token *name);
> >+
> >+/*
> >+ * Parse the token stream
> >+ */
> >+static void parse(void)
> >+{
> >+	struct token *cursor;
> >+	struct type *type;
> >+
> >+	/* Parse one type definition statement at a time */
> >+	type = type_list;
> >+	do {
> >+		cursor = type->name;
> >+
> >+		if (cursor[0].token_type != TOKEN_TYPE_NAME ||
> >+		    cursor[1].token_type != TOKEN_ASSIGNMENT)
> >+			abort();
> >+		cursor += 2;
> >+
> >+		type->element = parse_type(&cursor, type[1].name, NULL);
> >+		type->element->type_def = type;
> >+
> >+		if (cursor != type[1].name) {
> >+			fprintf(stderr, "%s:%d: Parse error at token '%s'\n",
> >+				filename, cursor->line, cursor->content);
> >+			exit(1);
> >+		}
> >+
> >+	} while (type++, !(type->flags & TYPE_STOP_MARKER));
> >+
> >+	verbose("Extracted %u actions\n", nr_actions);
> >+}
> >+
> >+static struct element *element_list;
> >+
> >+static struct element *alloc_elem(struct token *type)
> >+{
> >+	struct element *e = calloc(1, sizeof(*e));
> >+	if (!e) {
> >+		perror(NULL);
> >+		exit(1);
> >+	}
> >+	e->list_next = element_list;
> >+	element_list = e;
> >+	return e;
> >+}
> >+
> >+static struct element *parse_compound(struct token **_cursor, struct token *end,
> >+				      int alternates);
> >+
> >+/*
> >+ * Parse one type definition statement
> >+ */
> >+static struct element *parse_type(struct token **_cursor, struct token *end,
> >+				  struct token *name)
> >+{
> >+	struct element *top, *element;
> >+	struct action *action, **ppaction;
> >+	struct token *cursor = *_cursor;
> >+	struct type **ref;
> >+	char *p;
> >+	int labelled = 0, implicit = 0;
> >+
> >+	top = element = alloc_elem(cursor);
> >+	element->class = ASN1_UNIV;
> >+	element->method = ASN1_PRIM;
> >+	element->tag = token_to_tag[cursor->token_type];
> >+	element->name = name;
> >+
> >+	/* Extract the tag value if one given */
> >+	if (cursor->token_type == TOKEN_OPEN_SQUARE) {
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		switch (cursor->token_type) {
> >+		case DIRECTIVE_UNIVERSAL:
> >+			element->class = ASN1_UNIV;
> >+			cursor++;
> >+			break;
> >+		case DIRECTIVE_APPLICATION:
> >+			element->class = ASN1_APPL;
> >+			cursor++;
> >+			break;
> >+		case TOKEN_NUMBER:
> >+			element->class = ASN1_CONT;
> >+			break;
> >+		case DIRECTIVE_PRIVATE:
> >+			element->class = ASN1_PRIV;
> >+			cursor++;
> >+			break;
> >+		default:
> >+			fprintf(stderr, "%s:%d: Unrecognised tag class token '%s'\n",
> >+				filename, cursor->line, cursor->content);
> >+			exit(1);
> >+		}
> >+
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		if (cursor->token_type != TOKEN_NUMBER) {
> >+			fprintf(stderr, "%s:%d: Missing tag number '%s'\n",
> >+				filename, cursor->line, cursor->content);
> >+			exit(1);
> >+		}
> >+
> >+		element->tag &= ~0x1f;
> >+		element->tag |= strtoul(cursor->content, &p, 10);
> >+		element->flags |= ELEMENT_TAG_SPECIFIED;
> >+		if (p - cursor->content != cursor->size)
> >+			abort();
> >+		cursor++;
> >+
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		if (cursor->token_type != TOKEN_CLOSE_SQUARE) {
> >+			fprintf(stderr, "%s:%d: Missing closing square bracket '%s'\n",
> >+				filename, cursor->line, cursor->content);
> >+			exit(1);
> >+		}
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		labelled = 1;
> >+	}
> >+
> >+	/* Handle implicit and explicit markers */
> >+	if (cursor->token_type == DIRECTIVE_IMPLICIT) {
> >+		element->flags |= ELEMENT_IMPLICIT;
> >+		implicit = 1;
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+	} else if (cursor->token_type == DIRECTIVE_EXPLICIT) {
> >+		element->flags |= ELEMENT_EXPLICIT;
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+	}
> >+
> >+	if (labelled) {
> >+		if (!implicit)
> >+			element->method |= ASN1_CONS;
> >+		element->compound = implicit ? TAG_OVERRIDE : SEQUENCE;
> >+		element->children = alloc_elem(cursor);
> >+		element = element->children;
> >+		element->class = ASN1_UNIV;
> >+		element->method = ASN1_PRIM;
> >+		element->tag = token_to_tag[cursor->token_type];
> >+		element->name = name;
> >+	}
> >+
> >+	/* Extract the type we're expecting here */
> >+	element->type = cursor;
> >+	switch (cursor->token_type) {
> >+	case DIRECTIVE_ANY:
> >+		element->compound = ANY;
> >+		cursor++;
> >+		break;
> >+
> >+	case DIRECTIVE_NULL:
> >+	case DIRECTIVE_BOOLEAN:
> >+	case DIRECTIVE_ENUMERATED:
> >+	case DIRECTIVE_INTEGER:
> >+		element->compound = NOT_COMPOUND;
> >+		cursor++;
> >+		break;
> >+
> >+	case DIRECTIVE_EXTERNAL:
> >+		element->method = ASN1_CONS;
> >+
> >+	case DIRECTIVE_BMPString:
> >+	case DIRECTIVE_GeneralString:
> >+	case DIRECTIVE_GraphicString:
> >+	case DIRECTIVE_IA5String:
> >+	case DIRECTIVE_ISO646String:
> >+	case DIRECTIVE_NumericString:
> >+	case DIRECTIVE_PrintableString:
> >+	case DIRECTIVE_T61String:
> >+	case DIRECTIVE_TeletexString:
> >+	case DIRECTIVE_UniversalString:
> >+	case DIRECTIVE_UTF8String:
> >+	case DIRECTIVE_VideotexString:
> >+	case DIRECTIVE_VisibleString:
> >+	case DIRECTIVE_ObjectDescriptor:
> >+	case DIRECTIVE_GeneralizedTime:
> >+	case DIRECTIVE_UTCTime:
> >+		element->compound = NOT_COMPOUND;
> >+		cursor++;
> >+		break;
> >+
> >+	case DIRECTIVE_BIT:
> >+	case DIRECTIVE_OCTET:
> >+		element->compound = NOT_COMPOUND;
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		if (cursor->token_type != DIRECTIVE_STRING)
> >+			goto parse_error;
> >+		cursor++;
> >+		break;
> >+
> >+	case DIRECTIVE_OBJECT:
> >+		element->compound = NOT_COMPOUND;
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		if (cursor->token_type != DIRECTIVE_IDENTIFIER)
> >+			goto parse_error;
> >+		cursor++;
> >+		break;
> >+
> >+	case TOKEN_TYPE_NAME:
> >+		element->compound = TYPE_REF;
> >+		ref = bsearch(cursor, type_index, nr_types, sizeof(type_index[0]),
> >+			      type_finder);
> >+		if (!ref) {
> >+			fprintf(stderr, "%s:%d: Type '%s' undefined\n",
> >+				filename, cursor->line, cursor->content);
> >+			exit(1);
> >+		}
> >+		cursor->type = *ref;
> >+		(*ref)->ref_count++;
> >+		cursor++;
> >+		break;
> >+
> >+	case DIRECTIVE_CHOICE:
> >+		element->compound = CHOICE;
> >+		cursor++;
> >+		element->children = parse_compound(&cursor, end, 1);
> >+		break;
> >+
> >+	case DIRECTIVE_SEQUENCE:
> >+		element->compound = SEQUENCE;
> >+		element->method = ASN1_CONS;
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		if (cursor->token_type == DIRECTIVE_OF) {
> >+			element->compound = SEQUENCE_OF;
> >+			cursor++;
> >+			if (cursor >= end)
> >+				goto overrun_error;
> >+			element->children = parse_type(&cursor, end, NULL);
> >+		} else {
> >+			element->children = parse_compound(&cursor, end, 0);
> >+		}
> >+		break;
> >+
> >+	case DIRECTIVE_SET:
> >+		element->compound = SET;
> >+		element->method = ASN1_CONS;
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		if (cursor->token_type == DIRECTIVE_OF) {
> >+			element->compound = SET_OF;
> >+			cursor++;
> >+			if (cursor >= end)
> >+				goto parse_error;
> >+			element->children = parse_type(&cursor, end, NULL);
> >+		} else {
> >+			element->children = parse_compound(&cursor, end, 1);
> >+		}
> >+		break;
> >+
> >+	default:
> >+		fprintf(stderr, "%s:%d: Token '%s' does not introduce a type\n",
> >+			filename, cursor->line, cursor->content);
> >+		exit(1);
> >+	}
> >+
> >+	/* Handle elements that are optional */
> >+	if (cursor < end && (cursor->token_type == DIRECTIVE_OPTIONAL ||
> >+			     cursor->token_type == DIRECTIVE_DEFAULT)
> >+	    ) {
> >+		cursor++;
> >+		top->flags |= ELEMENT_SKIPPABLE;
> >+	}
> >+
> >+	if (cursor < end && cursor->token_type == TOKEN_OPEN_ACTION) {
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		if (cursor->token_type != TOKEN_ELEMENT_NAME) {
> >+			fprintf(stderr, "%s:%d: Token '%s' is not an action function name\n",
> >+				filename, cursor->line, cursor->content);
> >+			exit(1);
> >+		}
> >+
> >+		action = malloc(sizeof(struct action));
> >+		if (!action) {
> >+			perror(NULL);
> >+			exit(1);
> >+		}
> >+		action->index = 0;
> >+		action->name = cursor->content;
> >+
> >+		for (ppaction = &action_list;
> >+		     *ppaction;
> >+		     ppaction = &(*ppaction)->next
> >+		     ) {
> >+			int cmp = strcmp(action->name, (*ppaction)->name);
> >+			if (cmp == 0) {
> >+				free(action);
> >+				action = *ppaction;
> >+				goto found;
> >+			}
> >+			if (cmp < 0) {
> >+				action->next = *ppaction;
> >+				*ppaction = action;
> >+				nr_actions++;
> >+				goto found;
> >+			}
> >+		}
> >+		action->next = NULL;
> >+		*ppaction = action;
> >+		nr_actions++;
> >+	found:
> >+
> >+		element->action = action;
> >+		cursor->action = action;
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		if (cursor->token_type != TOKEN_CLOSE_ACTION) {
> >+			fprintf(stderr, "%s:%d: Missing close action, got '%s'\n",
> >+				filename, cursor->line, cursor->content);
> >+			exit(1);
> >+		}
> >+		cursor++;
> >+	}
> >+
> >+	*_cursor = cursor;
> >+	return top;
> >+
> >+parse_error:
> >+	fprintf(stderr, "%s:%d: Unexpected token '%s'\n",
> >+		filename, cursor->line, cursor->content);
> >+	exit(1);
> >+
> >+overrun_error:
> >+	fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename);
> >+	exit(1);
> >+}
> >+
> >+/*
> >+ * Parse a compound type list
> >+ */
> >+static struct element *parse_compound(struct token **_cursor, struct token *end,
> >+				      int alternates)
> >+{
> >+	struct element *children, **child_p = &children, *element;
> >+	struct token *cursor = *_cursor, *name;
> >+
> >+	if (cursor->token_type != TOKEN_OPEN_CURLY) {
> >+		fprintf(stderr, "%s:%d: Expected compound to start with brace not '%s'\n",
> >+			filename, cursor->line, cursor->content);
> >+		exit(1);
> >+	}
> >+	cursor++;
> >+	if (cursor >= end)
> >+		goto overrun_error;
> >+
> >+	if (cursor->token_type == TOKEN_OPEN_CURLY) {
> >+		fprintf(stderr, "%s:%d: Empty compound\n",
> >+			filename, cursor->line);
> >+		exit(1);
> >+	}
> >+
> >+	for (;;) {
> >+		name = NULL;
> >+		if (cursor->token_type == TOKEN_ELEMENT_NAME) {
> >+			name = cursor;
> >+			cursor++;
> >+			if (cursor >= end)
> >+				goto overrun_error;
> >+		}
> >+
> >+		element = parse_type(&cursor, end, name);
> >+		if (alternates)
> >+			element->flags |= ELEMENT_SKIPPABLE | ELEMENT_CONDITIONAL;
> >+
> >+		*child_p = element;
> >+		child_p = &element->next;
> >+
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+		if (cursor->token_type != TOKEN_COMMA)
> >+			break;
> >+		cursor++;
> >+		if (cursor >= end)
> >+			goto overrun_error;
> >+	}
> >+
> >+	children->flags &= ~ELEMENT_CONDITIONAL;
> >+
> >+	if (cursor->token_type != TOKEN_CLOSE_CURLY) {
> >+		fprintf(stderr, "%s:%d: Expected compound closure, got '%s'\n",
> >+			filename, cursor->line, cursor->content);
> >+		exit(1);
> >+	}
> >+	cursor++;
> >+
> >+	*_cursor = cursor;
> >+	return children;
> >+
> >+overrun_error:
> >+	fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename);
> >+	exit(1);
> >+}
> >+
> >+static void dump_element(const struct element *e, int level)
> >+{
> >+	const struct element *c;
> >+	const struct type *t = e->type_def;
> >+	const char *name = e->name ? e->name->content : ".";
> >+	const char *tname = t && t->name ? t->name->content : ".";
> >+	char tag[32];
> >+
> >+	if (e->class == 0 && e->method == 0 && e->tag == 0)
> >+		strcpy(tag, "<...>");
> >+	else if (e->class == ASN1_UNIV)
> >+		sprintf(tag, "%s %s %s",
> >+			asn1_classes[e->class],
> >+			asn1_methods[e->method],
> >+			asn1_universal_tags[e->tag]);
> >+	else
> >+		sprintf(tag, "%s %s %u",
> >+			asn1_classes[e->class],
> >+			asn1_methods[e->method],
> >+			e->tag);
> >+
> >+	printf("%c%c%c%c%c %c %*s[*] \e[33m%s\e[m %s %s \e[35m%s\e[m\n",
> >+	       e->flags & ELEMENT_IMPLICIT ? 'I' : '-',
> >+	       e->flags & ELEMENT_EXPLICIT ? 'E' : '-',
> >+	       e->flags & ELEMENT_TAG_SPECIFIED ? 'T' : '-',
> >+	       e->flags & ELEMENT_SKIPPABLE ? 'S' : '-',
> >+	       e->flags & ELEMENT_CONDITIONAL ? 'C' : '-',
> >+	       "-tTqQcaro"[e->compound],
> >+	       level, "",
> >+	       tag,
> >+	       tname,
> >+	       name,
> >+	       e->action ? e->action->name : "");
> >+	if (e->compound == TYPE_REF)
> >+		dump_element(e->type->type->element, level + 3);
> >+	else
> >+		for (c = e->children; c; c = c->next)
> >+			dump_element(c, level + 3);
> >+}
> >+
> >+static void dump_elements(void)
> >+{
> >+	if (debug_opt)
> >+		dump_element(type_list[0].element, 0);
> >+}
> >+
> >+static void render_element(FILE *out, struct element *e, struct element *tag);
> >+static void render_out_of_line_list(FILE *out);
> >+
> >+static int nr_entries;
> >+static int render_depth = 1;
> >+static struct element *render_list, **render_list_p = &render_list;
> >+
> >+__attribute__((format(printf, 2, 3)))
> >+static void render_opcode(FILE *out, const char *fmt, ...)
> >+{
> >+	va_list va;
> >+
> >+	if (out) {
> >+		fprintf(out, "\t[%4d] =%*s", nr_entries, render_depth, "");
> >+		va_start(va, fmt);
> >+		vfprintf(out, fmt, va);
> >+		va_end(va);
> >+	}
> >+	nr_entries++;
> >+}
> >+
> >+__attribute__((format(printf, 2, 3)))
> >+static void render_more(FILE *out, const char *fmt, ...)
> >+{
> >+	va_list va;
> >+
> >+	if (out) {
> >+		va_start(va, fmt);
> >+		vfprintf(out, fmt, va);
> >+		va_end(va);
> >+	}
> >+}
> >+
> >+/*
> >+ * Render the grammar into a state machine definition.
> >+ */
> >+static void render(FILE *out, FILE *hdr)
> >+{
> >+	struct element *e;
> >+	struct action *action;
> >+	struct type *root;
> >+	int index;
> >+
> >+	fprintf(hdr, "/*\n");
> >+	fprintf(hdr, " * Automatically generated by asn1_compiler.  Do not edit\n");
> >+	fprintf(hdr, " *\n");
> >+	fprintf(hdr, " * ASN.1 parser for %s\n", grammar_name);
> >+	fprintf(hdr, " */\n");
> >+	fprintf(hdr, "#include <linux/asn1_decoder.h>\n");
> >+	fprintf(hdr, "\n");
> >+	fprintf(hdr, "extern const struct asn1_decoder %s_decoder;\n", grammar_name);
> >+	if (ferror(hdr)) {
> >+		perror(headername);
> >+		exit(1);
> >+	}
> >+
> >+	fprintf(out, "/*\n");
> >+	fprintf(out, " * Automatically generated by asn1_compiler.  Do not edit\n");
> >+	fprintf(out, " *\n");
> >+	fprintf(out, " * ASN.1 parser for %s\n", grammar_name);
> >+	fprintf(out, " */\n");
> >+	fprintf(out, "#include <linux/asn1_ber_bytecode.h>\n");
> >+	fprintf(out, "#include \"%s.asn1.h\"\n", grammar_name);
> >+	fprintf(out, "\n");
> >+	if (ferror(out)) {
> >+		perror(outputname);
> >+		exit(1);
> >+	}
> >+
> >+	/* Tabulate the action functions we might have to call */
> >+	fprintf(hdr, "\n");
> >+	index = 0;
> >+	for (action = action_list; action; action = action->next) {
> >+		action->index = index++;
> >+		fprintf(hdr,
> >+			"extern int %s(void *, size_t, unsigned char,"
> >+			" const void *, size_t);\n",
> >+			action->name);
> >+	}
> >+	fprintf(hdr, "\n");
> >+
> >+	fprintf(out, "enum %s_actions {\n", grammar_name);
> >+	for (action = action_list; action; action = action->next)
> >+		fprintf(out, "\tACT_%s = %u,\n",
> >+			action->name, action->index);
> >+	fprintf(out, "\tNR__%s_actions = %u\n", grammar_name, nr_actions);
> >+	fprintf(out, "};\n");
> >+
> >+	fprintf(out, "\n");
> >+	fprintf(out, "static const asn1_action_t %s_action_table[NR__%s_actions] = {\n",
> >+		grammar_name, grammar_name);
> >+	for (action = action_list; action; action = action->next)
> >+		fprintf(out, "\t[%4u] = %s,\n", action->index, action->name);
> >+	fprintf(out, "};\n");
> >+
> >+	if (ferror(out)) {
> >+		perror(outputname);
> >+		exit(1);
> >+	}
> >+
> >+	/* We do two passes - the first one calculates all the offsets */
> >+	verbose("Pass 1\n");
> >+	nr_entries = 0;
> >+	root = &type_list[0];
> >+	render_element(NULL, root->element, NULL);
> >+	render_opcode(NULL, "ASN1_OP_COMPLETE,\n");
> >+	render_out_of_line_list(NULL);
> >+
> >+	for (e = element_list; e; e = e->list_next)
> >+		e->flags &= ~ELEMENT_RENDERED;
> >+
> >+	/* And then we actually render */
> >+	verbose("Pass 2\n");
> >+	fprintf(out, "\n");
> >+	fprintf(out, "static const unsigned char %s_machine[] = {\n",
> >+		grammar_name);
> >+
> >+	nr_entries = 0;
> >+	root = &type_list[0];
> >+	render_element(out, root->element, NULL);
> >+	render_opcode(out, "ASN1_OP_COMPLETE,\n");
> >+	render_out_of_line_list(out);
> >+
> >+	fprintf(out, "};\n");
> >+
> >+	fprintf(out, "\n");
> >+	fprintf(out, "const struct asn1_decoder %s_decoder = {\n", grammar_name);
> >+	fprintf(out, "\t.machine = %s_machine,\n", grammar_name);
> >+	fprintf(out, "\t.machlen = sizeof(%s_machine),\n", grammar_name);
> >+	fprintf(out, "\t.actions = %s_action_table,\n", grammar_name);
> >+	fprintf(out, "};\n");
> >+}
> >+
> >+/*
> >+ * Render the out-of-line elements
> >+ */
> >+static void render_out_of_line_list(FILE *out)
> >+{
> >+	struct element *e, *ce;
> >+	const char *act;
> >+	int entry;
> >+
> >+	while ((e = render_list)) {
> >+		render_list = e->render_next;
> >+		if (!render_list)
> >+			render_list_p = &render_list;
> >+
> >+		render_more(out, "\n");
> >+		e->entry_index = entry = nr_entries;
> >+		render_depth++;
> >+		for (ce = e->children; ce; ce = ce->next)
> >+			render_element(out, ce, NULL);
> >+		render_depth--;
> >+
> >+		act = e->action ? "_ACT" : "";
> >+		switch (e->compound) {
> >+		case SEQUENCE:
> >+			render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act);
> >+			break;
> >+		case SEQUENCE_OF:
> >+			render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act);
> >+			render_opcode(out, "_jump_target(%u),\n", entry);
> >+			break;
> >+		case SET:
> >+			render_opcode(out, "ASN1_OP_END_SET%s,\n", act);
> >+			break;
> >+		case SET_OF:
> >+			render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act);
> >+			render_opcode(out, "_jump_target(%u),\n", entry);
> >+			break;
> >+		default:
> >+			break;
> >+		}
> >+		if (e->action)
> >+			render_opcode(out, "_action(ACT_%s),\n",
> >+				      e->action->name);
> >+		render_opcode(out, "ASN1_OP_RETURN,\n");
> >+	}
> >+}
> >+
> >+/*
> >+ * Render an element.
> >+ */
> >+static void render_element(FILE *out, struct element *e, struct element *tag)
> >+{
> >+	struct element *ec, *x;
> >+	const char *cond, *act;
> >+	int entry, skippable = 0, outofline = 0;
> >+
> >+	if (e->flags & ELEMENT_SKIPPABLE ||
> >+	    (tag && tag->flags & ELEMENT_SKIPPABLE))
> >+		skippable = 1;
> >+
> >+	if ((e->type_def && e->type_def->ref_count > 1) ||
> >+	    skippable)
> >+		outofline = 1;
> >+
> >+	if (e->type_def && out) {
> >+		render_more(out, "\t// %s\n", e->type_def->name->content);
> >+	}
> >+
> >+	/* Render the operation */
> >+	cond = (e->flags & ELEMENT_CONDITIONAL ||
> >+		(tag && tag->flags & ELEMENT_CONDITIONAL)) ? "COND_" : "";
> >+	act = e->action ? "_ACT" : "";
> >+	switch (e->compound) {
> >+	case ANY:
> >+		render_opcode(out, "ASN1_OP_%sMATCH_ANY%s%s,",
> >+			      cond, act, skippable ? "_OR_SKIP" : "");
> >+		if (e->name)
> >+			render_more(out, "\t\t// %s", e->name->content);
> >+		render_more(out, "\n");
> >+		goto dont_render_tag;
> >+
> >+	case TAG_OVERRIDE:
> >+		render_element(out, e->children, e);
> >+		return;
> >+
> >+	case SEQUENCE:
> >+	case SEQUENCE_OF:
> >+	case SET:
> >+	case SET_OF:
> >+		render_opcode(out, "ASN1_OP_%sMATCH%s%s,",
> >+			      cond,
> >+			      outofline ? "_JUMP" : "",
> >+			      skippable ? "_OR_SKIP" : "");
> >+		break;
> >+
> >+	case CHOICE:
> >+		goto dont_render_tag;
> >+
> >+	case TYPE_REF:
> >+		if (e->class == ASN1_UNIV && e->method == ASN1_PRIM && e->tag == 0)
> >+			goto dont_render_tag;
> >+	default:
> >+		render_opcode(out, "ASN1_OP_%sMATCH%s%s,",
> >+			      cond, act,
> >+			      skippable ? "_OR_SKIP" : "");
> >+		break;
> >+	}
> >+
> >+	x = tag ?: e;
> >+	if (x->name)
> >+		render_more(out, "\t\t// %s", x->name->content);
> >+	render_more(out, "\n");
> >+
> >+	/* Render the tag */
> >+	if (!tag || !(tag->flags & ELEMENT_TAG_SPECIFIED))
> >+		tag = e;
> >+
> >+	if (tag->class == ASN1_UNIV &&
> >+	    tag->tag != 14 &&
> >+	    tag->tag != 15 &&
> >+	    tag->tag != 31)
> >+		render_opcode(out, "_tag(%s, %s, %s),\n",
> >+			      asn1_classes[tag->class],
> >+			      asn1_methods[tag->method | e->method],
> >+			      asn1_universal_tags[tag->tag]);
> >+	else
> >+		render_opcode(out, "_tagn(%s, %s, %2u),\n",
> >+			      asn1_classes[tag->class],
> >+			      asn1_methods[tag->method | e->method],
> >+			      tag->tag);
> >+	tag = NULL;
> >+dont_render_tag:
> >+
> >+	/* Deal with compound types */
> >+	switch (e->compound) {
> >+	case TYPE_REF:
> >+		render_element(out, e->type->type->element, tag);
> >+		if (e->action)
> >+			render_opcode(out, "ASN1_OP_%sACT,\n",
> >+				      skippable ? "MAYBE_" : "");
> >+		break;
> >+
> >+	case SEQUENCE:
> >+		if (outofline) {
> >+			/* Render out-of-line for multiple use or
> >+			 * skipability */
> >+			render_opcode(out, "_jump_target(%u),", e->entry_index);
> >+			if (e->type_def && e->type_def->name)
> >+				render_more(out, "\t\t// --> %s",
> >+					    e->type_def->name->content);
> >+			render_more(out, "\n");
> >+			if (!(e->flags & ELEMENT_RENDERED)) {
> >+				e->flags |= ELEMENT_RENDERED;
> >+				*render_list_p = e;
> >+				render_list_p = &e->render_next;
> >+			}
> >+			return;
> >+		} else {
> >+			/* Render inline for single use */
> >+			render_depth++;
> >+			for (ec = e->children; ec; ec = ec->next)
> >+				render_element(out, ec, NULL);
> >+			render_depth--;
> >+			render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act);
> >+		}
> >+		break;
> >+
> >+	case SEQUENCE_OF:
> >+	case SET_OF:
> >+		if (outofline) {
> >+			/* Render out-of-line for multiple use or
> >+			 * skipability */
> >+			render_opcode(out, "_jump_target(%u),", e->entry_index);
> >+			if (e->type_def && e->type_def->name)
> >+				render_more(out, "\t\t// --> %s",
> >+					    e->type_def->name->content);
> >+			render_more(out, "\n");
> >+			if (!(e->flags & ELEMENT_RENDERED)) {
> >+				e->flags |= ELEMENT_RENDERED;
> >+				*render_list_p = e;
> >+				render_list_p = &e->render_next;
> >+			}
> >+			return;
> >+		} else {
> >+			/* Render inline for single use */
> >+			entry = nr_entries;
> >+			render_depth++;
> >+			render_element(out, e->children, NULL);
> >+			render_depth--;
> >+			if (e->compound == SEQUENCE_OF)
> >+				render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act);
> >+			else
> >+				render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act);
> >+			render_opcode(out, "_jump_target(%u),\n", entry);
> >+		}
> >+		break;
> >+
> >+	case SET:
> >+		/* I can't think of a nice way to do SET support without having
> >+		 * a stack of bitmasks to make sure no element is repeated.
> >+		 * The bitmask has also to be checked that no non-optional
> >+		 * elements are left out whilst not preventing optional
> >+		 * elements from being left out.
> >+		 */
> >+		fprintf(stderr, "The ASN.1 SET type is not currently supported.\n");
> >+		exit(1);
> >+
> >+	case CHOICE:
> >+		for (ec = e->children; ec; ec = ec->next)
> >+			render_element(out, ec, ec);
> >+		if (!skippable)
> >+			render_opcode(out, "ASN1_OP_COND_FAIL,\n");
> >+		if (e->action)
> >+			render_opcode(out, "ASN1_OP_ACT,\n");
> >+		break;
> >+
> >+	default:
> >+		break;
> >+	}
> >+
> >+	if (e->action)
> >+		render_opcode(out, "_action(ACT_%s),\n", e->action->name);
> >+}
> >
>
diff mbox series

Patch

diff --git a/cmd/Kconfig b/cmd/Kconfig
index 4e61565aab16..605dcfdf4282 100644
--- a/cmd/Kconfig
+++ b/cmd/Kconfig
@@ -184,6 +184,9 @@  endmenu
 config BUILD_BIN2C
 	bool
 
+config BUILD_ASN1
+	bool
+
 comment "Commands"
 
 menu "Info commands"
diff --git a/include/linux/asn1.h b/include/linux/asn1.h
new file mode 100644
index 000000000000..a4d0bdd10711
--- /dev/null
+++ b/include/linux/asn1.h
@@ -0,0 +1,65 @@ 
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/* ASN.1 BER/DER/CER encoding definitions
+ *
+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ */
+
+#ifndef _LINUX_ASN1_H
+#define _LINUX_ASN1_H
+
+/* Class */
+enum asn1_class {
+	ASN1_UNIV	= 0,	/* Universal */
+	ASN1_APPL	= 1,	/* Application */
+	ASN1_CONT	= 2,	/* Context */
+	ASN1_PRIV	= 3	/* Private */
+};
+#define ASN1_CLASS_BITS	0xc0
+
+
+enum asn1_method {
+	ASN1_PRIM	= 0,	/* Primitive */
+	ASN1_CONS	= 1	/* Constructed */
+};
+#define ASN1_CONS_BIT	0x20
+
+/* Tag */
+enum asn1_tag {
+	ASN1_EOC	= 0,	/* End Of Contents or N/A */
+	ASN1_BOOL	= 1,	/* Boolean */
+	ASN1_INT	= 2,	/* Integer */
+	ASN1_BTS	= 3,	/* Bit String */
+	ASN1_OTS	= 4,	/* Octet String */
+	ASN1_NULL	= 5,	/* Null */
+	ASN1_OID	= 6,	/* Object Identifier  */
+	ASN1_ODE	= 7,	/* Object Description */
+	ASN1_EXT	= 8,	/* External */
+	ASN1_REAL	= 9,	/* Real float */
+	ASN1_ENUM	= 10,	/* Enumerated */
+	ASN1_EPDV	= 11,	/* Embedded PDV */
+	ASN1_UTF8STR	= 12,	/* UTF8 String */
+	ASN1_RELOID	= 13,	/* Relative OID */
+	/* 14 - Reserved */
+	/* 15 - Reserved */
+	ASN1_SEQ	= 16,	/* Sequence and Sequence of */
+	ASN1_SET	= 17,	/* Set and Set of */
+	ASN1_NUMSTR	= 18,	/* Numerical String */
+	ASN1_PRNSTR	= 19,	/* Printable String */
+	ASN1_TEXSTR	= 20,	/* T61 String / Teletext String */
+	ASN1_VIDSTR	= 21,	/* Videotex String */
+	ASN1_IA5STR	= 22,	/* IA5 String */
+	ASN1_UNITIM	= 23,	/* Universal Time */
+	ASN1_GENTIM	= 24,	/* General Time */
+	ASN1_GRASTR	= 25,	/* Graphic String */
+	ASN1_VISSTR	= 26,	/* Visible String */
+	ASN1_GENSTR	= 27,	/* General String */
+	ASN1_UNISTR	= 28,	/* Universal String */
+	ASN1_CHRSTR	= 29,	/* Character String */
+	ASN1_BMPSTR	= 30,	/* BMP String */
+	ASN1_LONG_TAG	= 31	/* Long form tag */
+};
+
+#define ASN1_INDEFINITE_LENGTH 0x80
+
+#endif /* _LINUX_ASN1_H */
diff --git a/include/linux/asn1_ber_bytecode.h b/include/linux/asn1_ber_bytecode.h
new file mode 100644
index 000000000000..b38361953a48
--- /dev/null
+++ b/include/linux/asn1_ber_bytecode.h
@@ -0,0 +1,89 @@ 
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/* ASN.1 BER/DER/CER parsing state machine internal definitions
+ *
+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ */
+
+#ifndef _LINUX_ASN1_BER_BYTECODE_H
+#define _LINUX_ASN1_BER_BYTECODE_H
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#endif
+#include <linux/asn1.h>
+
+typedef int (*asn1_action_t)(void *context,
+			     size_t hdrlen, /* In case of ANY type */
+			     unsigned char tag, /* In case of ANY type */
+			     const void *value, size_t vlen);
+
+struct asn1_decoder {
+	const unsigned char *machine;
+	size_t machlen;
+	const asn1_action_t *actions;
+};
+
+enum asn1_opcode {
+	/* The tag-matching ops come first and the odd-numbered slots
+	 * are for OR_SKIP ops.
+	 */
+#define ASN1_OP_MATCH__SKIP		  0x01
+#define ASN1_OP_MATCH__ACT		  0x02
+#define ASN1_OP_MATCH__JUMP		  0x04
+#define ASN1_OP_MATCH__ANY		  0x08
+#define ASN1_OP_MATCH__COND		  0x10
+
+	ASN1_OP_MATCH			= 0x00,
+	ASN1_OP_MATCH_OR_SKIP		= 0x01,
+	ASN1_OP_MATCH_ACT		= 0x02,
+	ASN1_OP_MATCH_ACT_OR_SKIP	= 0x03,
+	ASN1_OP_MATCH_JUMP		= 0x04,
+	ASN1_OP_MATCH_JUMP_OR_SKIP	= 0x05,
+	ASN1_OP_MATCH_ANY		= 0x08,
+	ASN1_OP_MATCH_ANY_OR_SKIP	= 0x09,
+	ASN1_OP_MATCH_ANY_ACT		= 0x0a,
+	ASN1_OP_MATCH_ANY_ACT_OR_SKIP	= 0x0b,
+	/* Everything before here matches unconditionally */
+
+	ASN1_OP_COND_MATCH_OR_SKIP	= 0x11,
+	ASN1_OP_COND_MATCH_ACT_OR_SKIP	= 0x13,
+	ASN1_OP_COND_MATCH_JUMP_OR_SKIP	= 0x15,
+	ASN1_OP_COND_MATCH_ANY		= 0x18,
+	ASN1_OP_COND_MATCH_ANY_OR_SKIP	= 0x19,
+	ASN1_OP_COND_MATCH_ANY_ACT	= 0x1a,
+	ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP = 0x1b,
+
+	/* Everything before here will want a tag from the data */
+#define ASN1_OP__MATCHES_TAG ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP
+
+	/* These are here to help fill up space */
+	ASN1_OP_COND_FAIL		= 0x1c,
+	ASN1_OP_COMPLETE		= 0x1d,
+	ASN1_OP_ACT			= 0x1e,
+	ASN1_OP_MAYBE_ACT		= 0x1f,
+
+	/* The following eight have bit 0 -> SET, 1 -> OF, 2 -> ACT */
+	ASN1_OP_END_SEQ			= 0x20,
+	ASN1_OP_END_SET			= 0x21,
+	ASN1_OP_END_SEQ_OF		= 0x22,
+	ASN1_OP_END_SET_OF		= 0x23,
+	ASN1_OP_END_SEQ_ACT		= 0x24,
+	ASN1_OP_END_SET_ACT		= 0x25,
+	ASN1_OP_END_SEQ_OF_ACT		= 0x26,
+	ASN1_OP_END_SET_OF_ACT		= 0x27,
+#define ASN1_OP_END__SET		  0x01
+#define ASN1_OP_END__OF			  0x02
+#define ASN1_OP_END__ACT		  0x04
+
+	ASN1_OP_RETURN			= 0x28,
+
+	ASN1_OP__NR
+};
+
+#define _tag(CLASS, CP, TAG) ((ASN1_##CLASS << 6) | (ASN1_##CP << 5) | ASN1_##TAG)
+#define _tagn(CLASS, CP, TAG) ((ASN1_##CLASS << 6) | (ASN1_##CP << 5) | TAG)
+#define _jump_target(N) (N)
+#define _action(N) (N)
+
+#endif /* _LINUX_ASN1_BER_BYTECODE_H */
diff --git a/include/linux/asn1_decoder.h b/include/linux/asn1_decoder.h
new file mode 100644
index 000000000000..83f9c6e1e5e9
--- /dev/null
+++ b/include/linux/asn1_decoder.h
@@ -0,0 +1,20 @@ 
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/* ASN.1 decoder
+ *
+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ */
+
+#ifndef _LINUX_ASN1_DECODER_H
+#define _LINUX_ASN1_DECODER_H
+
+#include <linux/asn1.h>
+
+struct asn1_decoder;
+
+extern int asn1_ber_decoder(const struct asn1_decoder *decoder,
+			    void *context,
+			    const unsigned char *data,
+			    size_t datalen);
+
+#endif /* _LINUX_ASN1_DECODER_H */
diff --git a/scripts/Makefile b/scripts/Makefile
index e7b353f77f43..c4e2ae5db2ea 100644
--- a/scripts/Makefile
+++ b/scripts/Makefile
@@ -5,6 +5,9 @@ 
 # ---------------------------------------------------------------------------
 
 hostprogs-$(CONFIG_BUILD_BIN2C)		+= bin2c
+hostprogs-$(CONFIG_BUILD_ASN1)		+= asn1_compiler
+
+HOSTCFLAGS_asn1_compiler.o = -idirafter $(srctree)/include
 
 always		:= $(hostprogs-y)
 
diff --git a/scripts/asn1_compiler.c b/scripts/asn1_compiler.c
new file mode 100644
index 000000000000..adabd4145264
--- /dev/null
+++ b/scripts/asn1_compiler.c
@@ -0,0 +1,1611 @@ 
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* Simplified ASN.1 notation parser
+ *
+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <linux/asn1_ber_bytecode.h>
+
+enum token_type {
+	DIRECTIVE_ABSENT,
+	DIRECTIVE_ALL,
+	DIRECTIVE_ANY,
+	DIRECTIVE_APPLICATION,
+	DIRECTIVE_AUTOMATIC,
+	DIRECTIVE_BEGIN,
+	DIRECTIVE_BIT,
+	DIRECTIVE_BMPString,
+	DIRECTIVE_BOOLEAN,
+	DIRECTIVE_BY,
+	DIRECTIVE_CHARACTER,
+	DIRECTIVE_CHOICE,
+	DIRECTIVE_CLASS,
+	DIRECTIVE_COMPONENT,
+	DIRECTIVE_COMPONENTS,
+	DIRECTIVE_CONSTRAINED,
+	DIRECTIVE_CONTAINING,
+	DIRECTIVE_DEFAULT,
+	DIRECTIVE_DEFINED,
+	DIRECTIVE_DEFINITIONS,
+	DIRECTIVE_EMBEDDED,
+	DIRECTIVE_ENCODED,
+	DIRECTIVE_ENCODING_CONTROL,
+	DIRECTIVE_END,
+	DIRECTIVE_ENUMERATED,
+	DIRECTIVE_EXCEPT,
+	DIRECTIVE_EXPLICIT,
+	DIRECTIVE_EXPORTS,
+	DIRECTIVE_EXTENSIBILITY,
+	DIRECTIVE_EXTERNAL,
+	DIRECTIVE_FALSE,
+	DIRECTIVE_FROM,
+	DIRECTIVE_GeneralString,
+	DIRECTIVE_GeneralizedTime,
+	DIRECTIVE_GraphicString,
+	DIRECTIVE_IA5String,
+	DIRECTIVE_IDENTIFIER,
+	DIRECTIVE_IMPLICIT,
+	DIRECTIVE_IMPLIED,
+	DIRECTIVE_IMPORTS,
+	DIRECTIVE_INCLUDES,
+	DIRECTIVE_INSTANCE,
+	DIRECTIVE_INSTRUCTIONS,
+	DIRECTIVE_INTEGER,
+	DIRECTIVE_INTERSECTION,
+	DIRECTIVE_ISO646String,
+	DIRECTIVE_MAX,
+	DIRECTIVE_MIN,
+	DIRECTIVE_MINUS_INFINITY,
+	DIRECTIVE_NULL,
+	DIRECTIVE_NumericString,
+	DIRECTIVE_OBJECT,
+	DIRECTIVE_OCTET,
+	DIRECTIVE_OF,
+	DIRECTIVE_OPTIONAL,
+	DIRECTIVE_ObjectDescriptor,
+	DIRECTIVE_PATTERN,
+	DIRECTIVE_PDV,
+	DIRECTIVE_PLUS_INFINITY,
+	DIRECTIVE_PRESENT,
+	DIRECTIVE_PRIVATE,
+	DIRECTIVE_PrintableString,
+	DIRECTIVE_REAL,
+	DIRECTIVE_RELATIVE_OID,
+	DIRECTIVE_SEQUENCE,
+	DIRECTIVE_SET,
+	DIRECTIVE_SIZE,
+	DIRECTIVE_STRING,
+	DIRECTIVE_SYNTAX,
+	DIRECTIVE_T61String,
+	DIRECTIVE_TAGS,
+	DIRECTIVE_TRUE,
+	DIRECTIVE_TeletexString,
+	DIRECTIVE_UNION,
+	DIRECTIVE_UNIQUE,
+	DIRECTIVE_UNIVERSAL,
+	DIRECTIVE_UTCTime,
+	DIRECTIVE_UTF8String,
+	DIRECTIVE_UniversalString,
+	DIRECTIVE_VideotexString,
+	DIRECTIVE_VisibleString,
+	DIRECTIVE_WITH,
+	NR__DIRECTIVES,
+	TOKEN_ASSIGNMENT = NR__DIRECTIVES,
+	TOKEN_OPEN_CURLY,
+	TOKEN_CLOSE_CURLY,
+	TOKEN_OPEN_SQUARE,
+	TOKEN_CLOSE_SQUARE,
+	TOKEN_OPEN_ACTION,
+	TOKEN_CLOSE_ACTION,
+	TOKEN_COMMA,
+	TOKEN_NUMBER,
+	TOKEN_TYPE_NAME,
+	TOKEN_ELEMENT_NAME,
+	NR__TOKENS
+};
+
+static const unsigned char token_to_tag[NR__TOKENS] = {
+	/* EOC goes first */
+	[DIRECTIVE_BOOLEAN]		= ASN1_BOOL,
+	[DIRECTIVE_INTEGER]		= ASN1_INT,
+	[DIRECTIVE_BIT]			= ASN1_BTS,
+	[DIRECTIVE_OCTET]		= ASN1_OTS,
+	[DIRECTIVE_NULL]		= ASN1_NULL,
+	[DIRECTIVE_OBJECT]		= ASN1_OID,
+	[DIRECTIVE_ObjectDescriptor]	= ASN1_ODE,
+	[DIRECTIVE_EXTERNAL]		= ASN1_EXT,
+	[DIRECTIVE_REAL]		= ASN1_REAL,
+	[DIRECTIVE_ENUMERATED]		= ASN1_ENUM,
+	[DIRECTIVE_EMBEDDED]		= 0,
+	[DIRECTIVE_UTF8String]		= ASN1_UTF8STR,
+	[DIRECTIVE_RELATIVE_OID]	= ASN1_RELOID,
+	/* 14 */
+	/* 15 */
+	[DIRECTIVE_SEQUENCE]		= ASN1_SEQ,
+	[DIRECTIVE_SET]			= ASN1_SET,
+	[DIRECTIVE_NumericString]	= ASN1_NUMSTR,
+	[DIRECTIVE_PrintableString]	= ASN1_PRNSTR,
+	[DIRECTIVE_T61String]		= ASN1_TEXSTR,
+	[DIRECTIVE_TeletexString]	= ASN1_TEXSTR,
+	[DIRECTIVE_VideotexString]	= ASN1_VIDSTR,
+	[DIRECTIVE_IA5String]		= ASN1_IA5STR,
+	[DIRECTIVE_UTCTime]		= ASN1_UNITIM,
+	[DIRECTIVE_GeneralizedTime]	= ASN1_GENTIM,
+	[DIRECTIVE_GraphicString]	= ASN1_GRASTR,
+	[DIRECTIVE_VisibleString]	= ASN1_VISSTR,
+	[DIRECTIVE_GeneralString]	= ASN1_GENSTR,
+	[DIRECTIVE_UniversalString]	= ASN1_UNITIM,
+	[DIRECTIVE_CHARACTER]		= ASN1_CHRSTR,
+	[DIRECTIVE_BMPString]		= ASN1_BMPSTR,
+};
+
+static const char asn1_classes[4][5] = {
+	[ASN1_UNIV]	= "UNIV",
+	[ASN1_APPL]	= "APPL",
+	[ASN1_CONT]	= "CONT",
+	[ASN1_PRIV]	= "PRIV"
+};
+
+static const char asn1_methods[2][5] = {
+	[ASN1_UNIV]	= "PRIM",
+	[ASN1_APPL]	= "CONS"
+};
+
+static const char *const asn1_universal_tags[32] = {
+	"EOC",
+	"BOOL",
+	"INT",
+	"BTS",
+	"OTS",
+	"NULL",
+	"OID",
+	"ODE",
+	"EXT",
+	"REAL",
+	"ENUM",
+	"EPDV",
+	"UTF8STR",
+	"RELOID",
+	NULL,		/* 14 */
+	NULL,		/* 15 */
+	"SEQ",
+	"SET",
+	"NUMSTR",
+	"PRNSTR",
+	"TEXSTR",
+	"VIDSTR",
+	"IA5STR",
+	"UNITIM",
+	"GENTIM",
+	"GRASTR",
+	"VISSTR",
+	"GENSTR",
+	"UNISTR",
+	"CHRSTR",
+	"BMPSTR",
+	NULL		/* 31 */
+};
+
+static const char *filename;
+static const char *grammar_name;
+static const char *outputname;
+static const char *headername;
+
+static const char *const directives[NR__DIRECTIVES] = {
+#define _(X) [DIRECTIVE_##X] = #X
+	_(ABSENT),
+	_(ALL),
+	_(ANY),
+	_(APPLICATION),
+	_(AUTOMATIC),
+	_(BEGIN),
+	_(BIT),
+	_(BMPString),
+	_(BOOLEAN),
+	_(BY),
+	_(CHARACTER),
+	_(CHOICE),
+	_(CLASS),
+	_(COMPONENT),
+	_(COMPONENTS),
+	_(CONSTRAINED),
+	_(CONTAINING),
+	_(DEFAULT),
+	_(DEFINED),
+	_(DEFINITIONS),
+	_(EMBEDDED),
+	_(ENCODED),
+	[DIRECTIVE_ENCODING_CONTROL] = "ENCODING-CONTROL",
+	_(END),
+	_(ENUMERATED),
+	_(EXCEPT),
+	_(EXPLICIT),
+	_(EXPORTS),
+	_(EXTENSIBILITY),
+	_(EXTERNAL),
+	_(FALSE),
+	_(FROM),
+	_(GeneralString),
+	_(GeneralizedTime),
+	_(GraphicString),
+	_(IA5String),
+	_(IDENTIFIER),
+	_(IMPLICIT),
+	_(IMPLIED),
+	_(IMPORTS),
+	_(INCLUDES),
+	_(INSTANCE),
+	_(INSTRUCTIONS),
+	_(INTEGER),
+	_(INTERSECTION),
+	_(ISO646String),
+	_(MAX),
+	_(MIN),
+	[DIRECTIVE_MINUS_INFINITY] = "MINUS-INFINITY",
+	[DIRECTIVE_NULL] = "NULL",
+	_(NumericString),
+	_(OBJECT),
+	_(OCTET),
+	_(OF),
+	_(OPTIONAL),
+	_(ObjectDescriptor),
+	_(PATTERN),
+	_(PDV),
+	[DIRECTIVE_PLUS_INFINITY] = "PLUS-INFINITY",
+	_(PRESENT),
+	_(PRIVATE),
+	_(PrintableString),
+	_(REAL),
+	[DIRECTIVE_RELATIVE_OID] = "RELATIVE-OID",
+	_(SEQUENCE),
+	_(SET),
+	_(SIZE),
+	_(STRING),
+	_(SYNTAX),
+	_(T61String),
+	_(TAGS),
+	_(TRUE),
+	_(TeletexString),
+	_(UNION),
+	_(UNIQUE),
+	_(UNIVERSAL),
+	_(UTCTime),
+	_(UTF8String),
+	_(UniversalString),
+	_(VideotexString),
+	_(VisibleString),
+	_(WITH)
+};
+
+struct action {
+	struct action	*next;
+	char		*name;
+	unsigned char	index;
+};
+
+static struct action *action_list;
+static unsigned nr_actions;
+
+struct token {
+	unsigned short	line;
+	enum token_type	token_type : 8;
+	unsigned char	size;
+	struct action	*action;
+	char		*content;
+	struct type	*type;
+};
+
+static struct token *token_list;
+static unsigned nr_tokens;
+static bool verbose_opt;
+static bool debug_opt;
+
+#define verbose(fmt, ...) do { if (verbose_opt) printf(fmt, ## __VA_ARGS__); } while (0)
+#define debug(fmt, ...) do { if (debug_opt) printf(fmt, ## __VA_ARGS__); } while (0)
+
+static int directive_compare(const void *_key, const void *_pdir)
+{
+	const struct token *token = _key;
+	const char *const *pdir = _pdir, *dir = *pdir;
+	size_t dlen, clen;
+	int val;
+
+	dlen = strlen(dir);
+	clen = (dlen < token->size) ? dlen : token->size;
+
+	//debug("cmp(%s,%s) = ", token->content, dir);
+
+	val = memcmp(token->content, dir, clen);
+	if (val != 0) {
+		//debug("%d [cmp]\n", val);
+		return val;
+	}
+
+	if (dlen == token->size) {
+		//debug("0\n");
+		return 0;
+	}
+	//debug("%d\n", (int)dlen - (int)token->size);
+	return dlen - token->size; /* shorter -> negative */
+}
+
+/*
+ * Tokenise an ASN.1 grammar
+ */
+static void tokenise(char *buffer, char *end)
+{
+	struct token *tokens;
+	char *line, *nl, *start, *p, *q;
+	unsigned tix, lineno;
+
+	/* Assume we're going to have half as many tokens as we have
+	 * characters
+	 */
+	token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token));
+	if (!tokens) {
+		perror(NULL);
+		exit(1);
+	}
+	tix = 0;
+
+	lineno = 0;
+	while (buffer < end) {
+		/* First of all, break out a line */
+		lineno++;
+		line = buffer;
+		nl = memchr(line, '\n', end - buffer);
+		if (!nl) {
+			buffer = nl = end;
+		} else {
+			buffer = nl + 1;
+			*nl = '\0';
+		}
+
+		/* Remove "--" comments */
+		p = line;
+	next_comment:
+		while ((p = memchr(p, '-', nl - p))) {
+			if (p[1] == '-') {
+				/* Found a comment; see if there's a terminator */
+				q = p + 2;
+				while ((q = memchr(q, '-', nl - q))) {
+					if (q[1] == '-') {
+						/* There is - excise the comment */
+						q += 2;
+						memmove(p, q, nl - q);
+						goto next_comment;
+					}
+					q++;
+				}
+				*p = '\0';
+				nl = p;
+				break;
+			} else {
+				p++;
+			}
+		}
+
+		p = line;
+		while (p < nl) {
+			/* Skip white space */
+			while (p < nl && isspace(*p))
+				*(p++) = 0;
+			if (p >= nl)
+				break;
+
+			tokens[tix].line = lineno;
+			start = p;
+
+			/* Handle string tokens */
+			if (isalpha(*p)) {
+				const char **dir;
+
+				/* Can be a directive, type name or element
+				 * name.  Find the end of the name.
+				 */
+				q = p + 1;
+				while (q < nl && (isalnum(*q) || *q == '-' || *q == '_'))
+					q++;
+				tokens[tix].size = q - p;
+				p = q;
+
+				tokens[tix].content = malloc(tokens[tix].size + 1);
+				if (!tokens[tix].content) {
+					perror(NULL);
+					exit(1);
+				}
+				memcpy(tokens[tix].content, start, tokens[tix].size);
+				tokens[tix].content[tokens[tix].size] = 0;
+				
+				/* If it begins with a lowercase letter then
+				 * it's an element name
+				 */
+				if (islower(tokens[tix].content[0])) {
+					tokens[tix++].token_type = TOKEN_ELEMENT_NAME;
+					continue;
+				}
+
+				/* Otherwise we need to search the directive
+				 * table
+				 */
+				dir = bsearch(&tokens[tix], directives,
+					      sizeof(directives) / sizeof(directives[1]),
+					      sizeof(directives[1]),
+					      directive_compare);
+				if (dir) {
+					tokens[tix++].token_type = dir - directives;
+					continue;
+				}
+
+				tokens[tix++].token_type = TOKEN_TYPE_NAME;
+				continue;
+			}
+
+			/* Handle numbers */
+			if (isdigit(*p)) {
+				/* Find the end of the number */
+				q = p + 1;
+				while (q < nl && (isdigit(*q)))
+					q++;
+				tokens[tix].size = q - p;
+				p = q;
+				tokens[tix].content = malloc(tokens[tix].size + 1);
+				if (!tokens[tix].content) {
+					perror(NULL);
+					exit(1);
+				}
+				memcpy(tokens[tix].content, start, tokens[tix].size);
+				tokens[tix].content[tokens[tix].size] = 0;
+				tokens[tix++].token_type = TOKEN_NUMBER;
+				continue;
+			}
+
+			if (nl - p >= 3) {
+				if (memcmp(p, "::=", 3) == 0) {
+					p += 3;
+					tokens[tix].size = 3;
+					tokens[tix].content = "::=";
+					tokens[tix++].token_type = TOKEN_ASSIGNMENT;
+					continue;
+				}
+			}
+
+			if (nl - p >= 2) {
+				if (memcmp(p, "({", 2) == 0) {
+					p += 2;
+					tokens[tix].size = 2;
+					tokens[tix].content = "({";
+					tokens[tix++].token_type = TOKEN_OPEN_ACTION;
+					continue;
+				}
+				if (memcmp(p, "})", 2) == 0) {
+					p += 2;
+					tokens[tix].size = 2;
+					tokens[tix].content = "})";
+					tokens[tix++].token_type = TOKEN_CLOSE_ACTION;
+					continue;
+				}
+			}
+
+			if (nl - p >= 1) {
+				tokens[tix].size = 1;
+				switch (*p) {
+				case '{':
+					p += 1;
+					tokens[tix].content = "{";
+					tokens[tix++].token_type = TOKEN_OPEN_CURLY;
+					continue;
+				case '}':
+					p += 1;
+					tokens[tix].content = "}";
+					tokens[tix++].token_type = TOKEN_CLOSE_CURLY;
+					continue;
+				case '[':
+					p += 1;
+					tokens[tix].content = "[";
+					tokens[tix++].token_type = TOKEN_OPEN_SQUARE;
+					continue;
+				case ']':
+					p += 1;
+					tokens[tix].content = "]";
+					tokens[tix++].token_type = TOKEN_CLOSE_SQUARE;
+					continue;
+				case ',':
+					p += 1;
+					tokens[tix].content = ",";
+					tokens[tix++].token_type = TOKEN_COMMA;
+					continue;
+				default:
+					break;
+				}
+			}
+
+			fprintf(stderr, "%s:%u: Unknown character in grammar: '%c'\n",
+				filename, lineno, *p);
+			exit(1);
+		}
+	}
+
+	nr_tokens = tix;
+	verbose("Extracted %u tokens\n", nr_tokens);
+
+#if 0
+	{
+		int n;
+		for (n = 0; n < nr_tokens; n++)
+			debug("Token %3u: '%s'\n", n, token_list[n].content);
+	}
+#endif
+}
+
+static void build_type_list(void);
+static void parse(void);
+static void dump_elements(void);
+static void render(FILE *out, FILE *hdr);
+
+/*
+ *
+ */
+int main(int argc, char **argv)
+{
+	struct stat st;
+	ssize_t readlen;
+	FILE *out, *hdr;
+	char *buffer, *p;
+	char *kbuild_verbose;
+	int fd;
+
+	kbuild_verbose = getenv("KBUILD_VERBOSE");
+	if (kbuild_verbose)
+		verbose_opt = atoi(kbuild_verbose);
+
+	while (argc > 4) {
+		if (strcmp(argv[1], "-v") == 0)
+			verbose_opt = true;
+		else if (strcmp(argv[1], "-d") == 0)
+			debug_opt = true;
+		else
+			break;
+		memmove(&argv[1], &argv[2], (argc - 2) * sizeof(char *));
+		argc--;
+	}
+
+	if (argc != 4) {
+		fprintf(stderr, "Format: %s [-v] [-d] <grammar-file> <c-file> <hdr-file>\n",
+			argv[0]);
+		exit(2);
+	}
+
+	filename = argv[1];
+	outputname = argv[2];
+	headername = argv[3];
+
+	fd = open(filename, O_RDONLY);
+	if (fd < 0) {
+		perror(filename);
+		exit(1);
+	}
+
+	if (fstat(fd, &st) < 0) {
+		perror(filename);
+		exit(1);
+	}
+
+	if (!(buffer = malloc(st.st_size + 1))) {
+		perror(NULL);
+		exit(1);
+	}
+
+	if ((readlen = read(fd, buffer, st.st_size)) < 0) {
+		perror(filename);
+		exit(1);
+	}
+
+	if (close(fd) < 0) {
+		perror(filename);
+		exit(1);
+	}
+
+	if (readlen != st.st_size) {
+		fprintf(stderr, "%s: Short read\n", filename);
+		exit(1);
+	}
+
+	p = strrchr(argv[1], '/');
+	p = p ? p + 1 : argv[1];
+	grammar_name = strdup(p);
+	if (!p) {
+		perror(NULL);
+		exit(1);
+	}
+	p = strchr(grammar_name, '.');
+	if (p)
+		*p = '\0';
+
+	buffer[readlen] = 0;
+	tokenise(buffer, buffer + readlen);
+	build_type_list();
+	parse();
+	dump_elements();
+
+	out = fopen(outputname, "w");
+	if (!out) {
+		perror(outputname);
+		exit(1);
+	}
+
+	hdr = fopen(headername, "w");
+	if (!hdr) {
+		perror(headername);
+		exit(1);
+	}
+
+	render(out, hdr);
+
+	if (fclose(out) < 0) {
+		perror(outputname);
+		exit(1);
+	}
+
+	if (fclose(hdr) < 0) {
+		perror(headername);
+		exit(1);
+	}
+
+	return 0;
+}
+
+enum compound {
+	NOT_COMPOUND,
+	SET,
+	SET_OF,
+	SEQUENCE,
+	SEQUENCE_OF,
+	CHOICE,
+	ANY,
+	TYPE_REF,
+	TAG_OVERRIDE
+};
+
+struct element {
+	struct type	*type_def;
+	struct token	*name;
+	struct token	*type;
+	struct action	*action;
+	struct element	*children;
+	struct element	*next;
+	struct element	*render_next;
+	struct element	*list_next;
+	uint8_t		n_elements;
+	enum compound	compound : 8;
+	enum asn1_class	class : 8;
+	enum asn1_method method : 8;
+	uint8_t		tag;
+	unsigned	entry_index;
+	unsigned	flags;
+#define ELEMENT_IMPLICIT	0x0001
+#define ELEMENT_EXPLICIT	0x0002
+#define ELEMENT_TAG_SPECIFIED	0x0004
+#define ELEMENT_RENDERED	0x0008
+#define ELEMENT_SKIPPABLE	0x0010
+#define ELEMENT_CONDITIONAL	0x0020
+};
+
+struct type {
+	struct token	*name;
+	struct token	*def;
+	struct element	*element;
+	unsigned	ref_count;
+	unsigned	flags;
+#define TYPE_STOP_MARKER	0x0001
+#define TYPE_BEGIN		0x0002
+};
+
+static struct type *type_list;
+static struct type **type_index;
+static unsigned nr_types;
+
+static int type_index_compare(const void *_a, const void *_b)
+{
+	const struct type *const *a = _a, *const *b = _b;
+
+	if ((*a)->name->size != (*b)->name->size)
+		return (*a)->name->size - (*b)->name->size;
+	else
+		return memcmp((*a)->name->content, (*b)->name->content,
+			      (*a)->name->size);
+}
+
+static int type_finder(const void *_key, const void *_ti)
+{
+	const struct token *token = _key;
+	const struct type *const *ti = _ti;
+	const struct type *type = *ti;
+
+	if (token->size != type->name->size)
+		return token->size - type->name->size;
+	else
+		return memcmp(token->content, type->name->content,
+			      token->size);
+}
+
+/*
+ * Build up a list of types and a sorted index to that list.
+ */
+static void build_type_list(void)
+{
+	struct type *types;
+	unsigned nr, t, n;
+
+	nr = 0;
+	for (n = 0; n < nr_tokens - 1; n++)
+		if (token_list[n + 0].token_type == TOKEN_TYPE_NAME &&
+		    token_list[n + 1].token_type == TOKEN_ASSIGNMENT)
+			nr++;
+
+	if (nr == 0) {
+		fprintf(stderr, "%s: No defined types\n", filename);
+		exit(1);
+	}
+
+	nr_types = nr;
+	types = type_list = calloc(nr + 1, sizeof(type_list[0]));
+	if (!type_list) {
+		perror(NULL);
+		exit(1);
+	}
+	type_index = calloc(nr, sizeof(type_index[0]));
+	if (!type_index) {
+		perror(NULL);
+		exit(1);
+	}
+
+	t = 0;
+	types[t].flags |= TYPE_BEGIN;
+	for (n = 0; n < nr_tokens - 1; n++) {
+		if (token_list[n + 0].token_type == TOKEN_TYPE_NAME &&
+		    token_list[n + 1].token_type == TOKEN_ASSIGNMENT) {
+			types[t].name = &token_list[n];
+			type_index[t] = &types[t];
+			t++;
+		}
+	}
+	types[t].name = &token_list[n + 1];
+	types[t].flags |= TYPE_STOP_MARKER;
+
+	qsort(type_index, nr, sizeof(type_index[0]), type_index_compare);
+
+	verbose("Extracted %u types\n", nr_types);
+#if 0
+	for (n = 0; n < nr_types; n++) {
+		struct type *type = type_index[n];
+		debug("- %*.*s\n", type->name->content);
+	}
+#endif
+}
+
+static struct element *parse_type(struct token **_cursor, struct token *stop,
+				  struct token *name);
+
+/*
+ * Parse the token stream
+ */
+static void parse(void)
+{
+	struct token *cursor;
+	struct type *type;
+
+	/* Parse one type definition statement at a time */
+	type = type_list;
+	do {
+		cursor = type->name;
+
+		if (cursor[0].token_type != TOKEN_TYPE_NAME ||
+		    cursor[1].token_type != TOKEN_ASSIGNMENT)
+			abort();
+		cursor += 2;
+
+		type->element = parse_type(&cursor, type[1].name, NULL);
+		type->element->type_def = type;
+
+		if (cursor != type[1].name) {
+			fprintf(stderr, "%s:%d: Parse error at token '%s'\n",
+				filename, cursor->line, cursor->content);
+			exit(1);
+		}
+
+	} while (type++, !(type->flags & TYPE_STOP_MARKER));
+
+	verbose("Extracted %u actions\n", nr_actions);
+}
+
+static struct element *element_list;
+
+static struct element *alloc_elem(struct token *type)
+{
+	struct element *e = calloc(1, sizeof(*e));
+	if (!e) {
+		perror(NULL);
+		exit(1);
+	}
+	e->list_next = element_list;
+	element_list = e;
+	return e;
+}
+
+static struct element *parse_compound(struct token **_cursor, struct token *end,
+				      int alternates);
+
+/*
+ * Parse one type definition statement
+ */
+static struct element *parse_type(struct token **_cursor, struct token *end,
+				  struct token *name)
+{
+	struct element *top, *element;
+	struct action *action, **ppaction;
+	struct token *cursor = *_cursor;
+	struct type **ref;
+	char *p;
+	int labelled = 0, implicit = 0;
+
+	top = element = alloc_elem(cursor);
+	element->class = ASN1_UNIV;
+	element->method = ASN1_PRIM;
+	element->tag = token_to_tag[cursor->token_type];
+	element->name = name;
+
+	/* Extract the tag value if one given */
+	if (cursor->token_type == TOKEN_OPEN_SQUARE) {
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+		switch (cursor->token_type) {
+		case DIRECTIVE_UNIVERSAL:
+			element->class = ASN1_UNIV;
+			cursor++;
+			break;
+		case DIRECTIVE_APPLICATION:
+			element->class = ASN1_APPL;
+			cursor++;
+			break;
+		case TOKEN_NUMBER:
+			element->class = ASN1_CONT;
+			break;
+		case DIRECTIVE_PRIVATE:
+			element->class = ASN1_PRIV;
+			cursor++;
+			break;
+		default:
+			fprintf(stderr, "%s:%d: Unrecognised tag class token '%s'\n",
+				filename, cursor->line, cursor->content);
+			exit(1);
+		}
+
+		if (cursor >= end)
+			goto overrun_error;
+		if (cursor->token_type != TOKEN_NUMBER) {
+			fprintf(stderr, "%s:%d: Missing tag number '%s'\n",
+				filename, cursor->line, cursor->content);
+			exit(1);
+		}
+
+		element->tag &= ~0x1f;
+		element->tag |= strtoul(cursor->content, &p, 10);
+		element->flags |= ELEMENT_TAG_SPECIFIED;
+		if (p - cursor->content != cursor->size)
+			abort();
+		cursor++;
+
+		if (cursor >= end)
+			goto overrun_error;
+		if (cursor->token_type != TOKEN_CLOSE_SQUARE) {
+			fprintf(stderr, "%s:%d: Missing closing square bracket '%s'\n",
+				filename, cursor->line, cursor->content);
+			exit(1);
+		}
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+		labelled = 1;
+	}
+
+	/* Handle implicit and explicit markers */
+	if (cursor->token_type == DIRECTIVE_IMPLICIT) {
+		element->flags |= ELEMENT_IMPLICIT;
+		implicit = 1;
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+	} else if (cursor->token_type == DIRECTIVE_EXPLICIT) {
+		element->flags |= ELEMENT_EXPLICIT;
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+	}
+
+	if (labelled) {
+		if (!implicit)
+			element->method |= ASN1_CONS;
+		element->compound = implicit ? TAG_OVERRIDE : SEQUENCE;
+		element->children = alloc_elem(cursor);
+		element = element->children;
+		element->class = ASN1_UNIV;
+		element->method = ASN1_PRIM;
+		element->tag = token_to_tag[cursor->token_type];
+		element->name = name;
+	}
+
+	/* Extract the type we're expecting here */
+	element->type = cursor;
+	switch (cursor->token_type) {
+	case DIRECTIVE_ANY:
+		element->compound = ANY;
+		cursor++;
+		break;
+
+	case DIRECTIVE_NULL:
+	case DIRECTIVE_BOOLEAN:
+	case DIRECTIVE_ENUMERATED:
+	case DIRECTIVE_INTEGER:
+		element->compound = NOT_COMPOUND;
+		cursor++;
+		break;
+
+	case DIRECTIVE_EXTERNAL:
+		element->method = ASN1_CONS;
+
+	case DIRECTIVE_BMPString:
+	case DIRECTIVE_GeneralString:
+	case DIRECTIVE_GraphicString:
+	case DIRECTIVE_IA5String:
+	case DIRECTIVE_ISO646String:
+	case DIRECTIVE_NumericString:
+	case DIRECTIVE_PrintableString:
+	case DIRECTIVE_T61String:
+	case DIRECTIVE_TeletexString:
+	case DIRECTIVE_UniversalString:
+	case DIRECTIVE_UTF8String:
+	case DIRECTIVE_VideotexString:
+	case DIRECTIVE_VisibleString:
+	case DIRECTIVE_ObjectDescriptor:
+	case DIRECTIVE_GeneralizedTime:
+	case DIRECTIVE_UTCTime:
+		element->compound = NOT_COMPOUND;
+		cursor++;
+		break;
+
+	case DIRECTIVE_BIT:
+	case DIRECTIVE_OCTET:
+		element->compound = NOT_COMPOUND;
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+		if (cursor->token_type != DIRECTIVE_STRING)
+			goto parse_error;
+		cursor++;
+		break;
+
+	case DIRECTIVE_OBJECT:
+		element->compound = NOT_COMPOUND;
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+		if (cursor->token_type != DIRECTIVE_IDENTIFIER)
+			goto parse_error;
+		cursor++;
+		break;
+
+	case TOKEN_TYPE_NAME:
+		element->compound = TYPE_REF;
+		ref = bsearch(cursor, type_index, nr_types, sizeof(type_index[0]),
+			      type_finder);
+		if (!ref) {
+			fprintf(stderr, "%s:%d: Type '%s' undefined\n",
+				filename, cursor->line, cursor->content);
+			exit(1);
+		}
+		cursor->type = *ref;
+		(*ref)->ref_count++;
+		cursor++;
+		break;
+
+	case DIRECTIVE_CHOICE:
+		element->compound = CHOICE;
+		cursor++;
+		element->children = parse_compound(&cursor, end, 1);
+		break;
+
+	case DIRECTIVE_SEQUENCE:
+		element->compound = SEQUENCE;
+		element->method = ASN1_CONS;
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+		if (cursor->token_type == DIRECTIVE_OF) {
+			element->compound = SEQUENCE_OF;
+			cursor++;
+			if (cursor >= end)
+				goto overrun_error;
+			element->children = parse_type(&cursor, end, NULL);
+		} else {
+			element->children = parse_compound(&cursor, end, 0);
+		}
+		break;
+
+	case DIRECTIVE_SET:
+		element->compound = SET;
+		element->method = ASN1_CONS;
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+		if (cursor->token_type == DIRECTIVE_OF) {
+			element->compound = SET_OF;
+			cursor++;
+			if (cursor >= end)
+				goto parse_error;
+			element->children = parse_type(&cursor, end, NULL);
+		} else {
+			element->children = parse_compound(&cursor, end, 1);
+		}
+		break;
+
+	default:
+		fprintf(stderr, "%s:%d: Token '%s' does not introduce a type\n",
+			filename, cursor->line, cursor->content);
+		exit(1);
+	}
+
+	/* Handle elements that are optional */
+	if (cursor < end && (cursor->token_type == DIRECTIVE_OPTIONAL ||
+			     cursor->token_type == DIRECTIVE_DEFAULT)
+	    ) {
+		cursor++;
+		top->flags |= ELEMENT_SKIPPABLE;
+	}
+
+	if (cursor < end && cursor->token_type == TOKEN_OPEN_ACTION) {
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+		if (cursor->token_type != TOKEN_ELEMENT_NAME) {
+			fprintf(stderr, "%s:%d: Token '%s' is not an action function name\n",
+				filename, cursor->line, cursor->content);
+			exit(1);
+		}
+
+		action = malloc(sizeof(struct action));
+		if (!action) {
+			perror(NULL);
+			exit(1);
+		}
+		action->index = 0;
+		action->name = cursor->content;
+
+		for (ppaction = &action_list;
+		     *ppaction;
+		     ppaction = &(*ppaction)->next
+		     ) {
+			int cmp = strcmp(action->name, (*ppaction)->name);
+			if (cmp == 0) {
+				free(action);
+				action = *ppaction;
+				goto found;
+			}
+			if (cmp < 0) {
+				action->next = *ppaction;
+				*ppaction = action;
+				nr_actions++;
+				goto found;
+			}
+		}
+		action->next = NULL;
+		*ppaction = action;
+		nr_actions++;
+	found:
+
+		element->action = action;
+		cursor->action = action;
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+		if (cursor->token_type != TOKEN_CLOSE_ACTION) {
+			fprintf(stderr, "%s:%d: Missing close action, got '%s'\n",
+				filename, cursor->line, cursor->content);
+			exit(1);
+		}
+		cursor++;
+	}
+
+	*_cursor = cursor;
+	return top;
+
+parse_error:
+	fprintf(stderr, "%s:%d: Unexpected token '%s'\n",
+		filename, cursor->line, cursor->content);
+	exit(1);
+
+overrun_error:
+	fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename);
+	exit(1);
+}
+
+/*
+ * Parse a compound type list
+ */
+static struct element *parse_compound(struct token **_cursor, struct token *end,
+				      int alternates)
+{
+	struct element *children, **child_p = &children, *element;
+	struct token *cursor = *_cursor, *name;
+
+	if (cursor->token_type != TOKEN_OPEN_CURLY) {
+		fprintf(stderr, "%s:%d: Expected compound to start with brace not '%s'\n",
+			filename, cursor->line, cursor->content);
+		exit(1);
+	}
+	cursor++;
+	if (cursor >= end)
+		goto overrun_error;
+
+	if (cursor->token_type == TOKEN_OPEN_CURLY) {
+		fprintf(stderr, "%s:%d: Empty compound\n",
+			filename, cursor->line);
+		exit(1);
+	}
+
+	for (;;) {
+		name = NULL;
+		if (cursor->token_type == TOKEN_ELEMENT_NAME) {
+			name = cursor;
+			cursor++;
+			if (cursor >= end)
+				goto overrun_error;
+		}
+
+		element = parse_type(&cursor, end, name);
+		if (alternates)
+			element->flags |= ELEMENT_SKIPPABLE | ELEMENT_CONDITIONAL;
+
+		*child_p = element;
+		child_p = &element->next;
+
+		if (cursor >= end)
+			goto overrun_error;
+		if (cursor->token_type != TOKEN_COMMA)
+			break;
+		cursor++;
+		if (cursor >= end)
+			goto overrun_error;
+	}
+
+	children->flags &= ~ELEMENT_CONDITIONAL;
+
+	if (cursor->token_type != TOKEN_CLOSE_CURLY) {
+		fprintf(stderr, "%s:%d: Expected compound closure, got '%s'\n",
+			filename, cursor->line, cursor->content);
+		exit(1);
+	}
+	cursor++;
+
+	*_cursor = cursor;
+	return children;
+
+overrun_error:
+	fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename);
+	exit(1);
+}
+
+static void dump_element(const struct element *e, int level)
+{
+	const struct element *c;
+	const struct type *t = e->type_def;
+	const char *name = e->name ? e->name->content : ".";
+	const char *tname = t && t->name ? t->name->content : ".";
+	char tag[32];
+
+	if (e->class == 0 && e->method == 0 && e->tag == 0)
+		strcpy(tag, "<...>");
+	else if (e->class == ASN1_UNIV)
+		sprintf(tag, "%s %s %s",
+			asn1_classes[e->class],
+			asn1_methods[e->method],
+			asn1_universal_tags[e->tag]);
+	else
+		sprintf(tag, "%s %s %u",
+			asn1_classes[e->class],
+			asn1_methods[e->method],
+			e->tag);
+
+	printf("%c%c%c%c%c %c %*s[*] \e[33m%s\e[m %s %s \e[35m%s\e[m\n",
+	       e->flags & ELEMENT_IMPLICIT ? 'I' : '-',
+	       e->flags & ELEMENT_EXPLICIT ? 'E' : '-',
+	       e->flags & ELEMENT_TAG_SPECIFIED ? 'T' : '-',
+	       e->flags & ELEMENT_SKIPPABLE ? 'S' : '-',
+	       e->flags & ELEMENT_CONDITIONAL ? 'C' : '-',
+	       "-tTqQcaro"[e->compound],
+	       level, "",
+	       tag,
+	       tname,
+	       name,
+	       e->action ? e->action->name : "");
+	if (e->compound == TYPE_REF)
+		dump_element(e->type->type->element, level + 3);
+	else
+		for (c = e->children; c; c = c->next)
+			dump_element(c, level + 3);
+}
+
+static void dump_elements(void)
+{
+	if (debug_opt)
+		dump_element(type_list[0].element, 0);
+}
+
+static void render_element(FILE *out, struct element *e, struct element *tag);
+static void render_out_of_line_list(FILE *out);
+
+static int nr_entries;
+static int render_depth = 1;
+static struct element *render_list, **render_list_p = &render_list;
+
+__attribute__((format(printf, 2, 3)))
+static void render_opcode(FILE *out, const char *fmt, ...)
+{
+	va_list va;
+
+	if (out) {
+		fprintf(out, "\t[%4d] =%*s", nr_entries, render_depth, "");
+		va_start(va, fmt);
+		vfprintf(out, fmt, va);
+		va_end(va);
+	}
+	nr_entries++;
+}
+
+__attribute__((format(printf, 2, 3)))
+static void render_more(FILE *out, const char *fmt, ...)
+{
+	va_list va;
+
+	if (out) {
+		va_start(va, fmt);
+		vfprintf(out, fmt, va);
+		va_end(va);
+	}
+}
+
+/*
+ * Render the grammar into a state machine definition.
+ */
+static void render(FILE *out, FILE *hdr)
+{
+	struct element *e;
+	struct action *action;
+	struct type *root;
+	int index;
+
+	fprintf(hdr, "/*\n");
+	fprintf(hdr, " * Automatically generated by asn1_compiler.  Do not edit\n");
+	fprintf(hdr, " *\n");
+	fprintf(hdr, " * ASN.1 parser for %s\n", grammar_name);
+	fprintf(hdr, " */\n");
+	fprintf(hdr, "#include <linux/asn1_decoder.h>\n");
+	fprintf(hdr, "\n");
+	fprintf(hdr, "extern const struct asn1_decoder %s_decoder;\n", grammar_name);
+	if (ferror(hdr)) {
+		perror(headername);
+		exit(1);
+	}
+
+	fprintf(out, "/*\n");
+	fprintf(out, " * Automatically generated by asn1_compiler.  Do not edit\n");
+	fprintf(out, " *\n");
+	fprintf(out, " * ASN.1 parser for %s\n", grammar_name);
+	fprintf(out, " */\n");
+	fprintf(out, "#include <linux/asn1_ber_bytecode.h>\n");
+	fprintf(out, "#include \"%s.asn1.h\"\n", grammar_name);
+	fprintf(out, "\n");
+	if (ferror(out)) {
+		perror(outputname);
+		exit(1);
+	}
+
+	/* Tabulate the action functions we might have to call */
+	fprintf(hdr, "\n");
+	index = 0;
+	for (action = action_list; action; action = action->next) {
+		action->index = index++;
+		fprintf(hdr,
+			"extern int %s(void *, size_t, unsigned char,"
+			" const void *, size_t);\n",
+			action->name);
+	}
+	fprintf(hdr, "\n");
+
+	fprintf(out, "enum %s_actions {\n", grammar_name);
+	for (action = action_list; action; action = action->next)
+		fprintf(out, "\tACT_%s = %u,\n",
+			action->name, action->index);
+	fprintf(out, "\tNR__%s_actions = %u\n", grammar_name, nr_actions);
+	fprintf(out, "};\n");
+
+	fprintf(out, "\n");
+	fprintf(out, "static const asn1_action_t %s_action_table[NR__%s_actions] = {\n",
+		grammar_name, grammar_name);
+	for (action = action_list; action; action = action->next)
+		fprintf(out, "\t[%4u] = %s,\n", action->index, action->name);
+	fprintf(out, "};\n");
+
+	if (ferror(out)) {
+		perror(outputname);
+		exit(1);
+	}
+
+	/* We do two passes - the first one calculates all the offsets */
+	verbose("Pass 1\n");
+	nr_entries = 0;
+	root = &type_list[0];
+	render_element(NULL, root->element, NULL);
+	render_opcode(NULL, "ASN1_OP_COMPLETE,\n");
+	render_out_of_line_list(NULL);
+
+	for (e = element_list; e; e = e->list_next)
+		e->flags &= ~ELEMENT_RENDERED;
+
+	/* And then we actually render */
+	verbose("Pass 2\n");
+	fprintf(out, "\n");
+	fprintf(out, "static const unsigned char %s_machine[] = {\n",
+		grammar_name);
+
+	nr_entries = 0;
+	root = &type_list[0];
+	render_element(out, root->element, NULL);
+	render_opcode(out, "ASN1_OP_COMPLETE,\n");
+	render_out_of_line_list(out);
+
+	fprintf(out, "};\n");
+
+	fprintf(out, "\n");
+	fprintf(out, "const struct asn1_decoder %s_decoder = {\n", grammar_name);
+	fprintf(out, "\t.machine = %s_machine,\n", grammar_name);
+	fprintf(out, "\t.machlen = sizeof(%s_machine),\n", grammar_name);
+	fprintf(out, "\t.actions = %s_action_table,\n", grammar_name);
+	fprintf(out, "};\n");
+}
+
+/*
+ * Render the out-of-line elements
+ */
+static void render_out_of_line_list(FILE *out)
+{
+	struct element *e, *ce;
+	const char *act;
+	int entry;
+
+	while ((e = render_list)) {
+		render_list = e->render_next;
+		if (!render_list)
+			render_list_p = &render_list;
+
+		render_more(out, "\n");
+		e->entry_index = entry = nr_entries;
+		render_depth++;
+		for (ce = e->children; ce; ce = ce->next)
+			render_element(out, ce, NULL);
+		render_depth--;
+
+		act = e->action ? "_ACT" : "";
+		switch (e->compound) {
+		case SEQUENCE:
+			render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act);
+			break;
+		case SEQUENCE_OF:
+			render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act);
+			render_opcode(out, "_jump_target(%u),\n", entry);
+			break;
+		case SET:
+			render_opcode(out, "ASN1_OP_END_SET%s,\n", act);
+			break;
+		case SET_OF:
+			render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act);
+			render_opcode(out, "_jump_target(%u),\n", entry);
+			break;
+		default:
+			break;
+		}
+		if (e->action)
+			render_opcode(out, "_action(ACT_%s),\n",
+				      e->action->name);
+		render_opcode(out, "ASN1_OP_RETURN,\n");
+	}
+}
+
+/*
+ * Render an element.
+ */
+static void render_element(FILE *out, struct element *e, struct element *tag)
+{
+	struct element *ec, *x;
+	const char *cond, *act;
+	int entry, skippable = 0, outofline = 0;
+
+	if (e->flags & ELEMENT_SKIPPABLE ||
+	    (tag && tag->flags & ELEMENT_SKIPPABLE))
+		skippable = 1;
+
+	if ((e->type_def && e->type_def->ref_count > 1) ||
+	    skippable)
+		outofline = 1;
+
+	if (e->type_def && out) {
+		render_more(out, "\t// %s\n", e->type_def->name->content);
+	}
+
+	/* Render the operation */
+	cond = (e->flags & ELEMENT_CONDITIONAL ||
+		(tag && tag->flags & ELEMENT_CONDITIONAL)) ? "COND_" : "";
+	act = e->action ? "_ACT" : "";
+	switch (e->compound) {
+	case ANY:
+		render_opcode(out, "ASN1_OP_%sMATCH_ANY%s%s,",
+			      cond, act, skippable ? "_OR_SKIP" : "");
+		if (e->name)
+			render_more(out, "\t\t// %s", e->name->content);
+		render_more(out, "\n");
+		goto dont_render_tag;
+
+	case TAG_OVERRIDE:
+		render_element(out, e->children, e);
+		return;
+
+	case SEQUENCE:
+	case SEQUENCE_OF:
+	case SET:
+	case SET_OF:
+		render_opcode(out, "ASN1_OP_%sMATCH%s%s,",
+			      cond,
+			      outofline ? "_JUMP" : "",
+			      skippable ? "_OR_SKIP" : "");
+		break;
+
+	case CHOICE:
+		goto dont_render_tag;
+
+	case TYPE_REF:
+		if (e->class == ASN1_UNIV && e->method == ASN1_PRIM && e->tag == 0)
+			goto dont_render_tag;
+	default:
+		render_opcode(out, "ASN1_OP_%sMATCH%s%s,",
+			      cond, act,
+			      skippable ? "_OR_SKIP" : "");
+		break;
+	}
+
+	x = tag ?: e;
+	if (x->name)
+		render_more(out, "\t\t// %s", x->name->content);
+	render_more(out, "\n");
+
+	/* Render the tag */
+	if (!tag || !(tag->flags & ELEMENT_TAG_SPECIFIED))
+		tag = e;
+
+	if (tag->class == ASN1_UNIV &&
+	    tag->tag != 14 &&
+	    tag->tag != 15 &&
+	    tag->tag != 31)
+		render_opcode(out, "_tag(%s, %s, %s),\n",
+			      asn1_classes[tag->class],
+			      asn1_methods[tag->method | e->method],
+			      asn1_universal_tags[tag->tag]);
+	else
+		render_opcode(out, "_tagn(%s, %s, %2u),\n",
+			      asn1_classes[tag->class],
+			      asn1_methods[tag->method | e->method],
+			      tag->tag);
+	tag = NULL;
+dont_render_tag:
+
+	/* Deal with compound types */
+	switch (e->compound) {
+	case TYPE_REF:
+		render_element(out, e->type->type->element, tag);
+		if (e->action)
+			render_opcode(out, "ASN1_OP_%sACT,\n",
+				      skippable ? "MAYBE_" : "");
+		break;
+
+	case SEQUENCE:
+		if (outofline) {
+			/* Render out-of-line for multiple use or
+			 * skipability */
+			render_opcode(out, "_jump_target(%u),", e->entry_index);
+			if (e->type_def && e->type_def->name)
+				render_more(out, "\t\t// --> %s",
+					    e->type_def->name->content);
+			render_more(out, "\n");
+			if (!(e->flags & ELEMENT_RENDERED)) {
+				e->flags |= ELEMENT_RENDERED;
+				*render_list_p = e;
+				render_list_p = &e->render_next;
+			}
+			return;
+		} else {
+			/* Render inline for single use */
+			render_depth++;
+			for (ec = e->children; ec; ec = ec->next)
+				render_element(out, ec, NULL);
+			render_depth--;
+			render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act);
+		}
+		break;
+
+	case SEQUENCE_OF:
+	case SET_OF:
+		if (outofline) {
+			/* Render out-of-line for multiple use or
+			 * skipability */
+			render_opcode(out, "_jump_target(%u),", e->entry_index);
+			if (e->type_def && e->type_def->name)
+				render_more(out, "\t\t// --> %s",
+					    e->type_def->name->content);
+			render_more(out, "\n");
+			if (!(e->flags & ELEMENT_RENDERED)) {
+				e->flags |= ELEMENT_RENDERED;
+				*render_list_p = e;
+				render_list_p = &e->render_next;
+			}
+			return;
+		} else {
+			/* Render inline for single use */
+			entry = nr_entries;
+			render_depth++;
+			render_element(out, e->children, NULL);
+			render_depth--;
+			if (e->compound == SEQUENCE_OF)
+				render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act);
+			else
+				render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act);
+			render_opcode(out, "_jump_target(%u),\n", entry);
+		}
+		break;
+
+	case SET:
+		/* I can't think of a nice way to do SET support without having
+		 * a stack of bitmasks to make sure no element is repeated.
+		 * The bitmask has also to be checked that no non-optional
+		 * elements are left out whilst not preventing optional
+		 * elements from being left out.
+		 */
+		fprintf(stderr, "The ASN.1 SET type is not currently supported.\n");
+		exit(1);
+
+	case CHOICE:
+		for (ec = e->children; ec; ec = ec->next)
+			render_element(out, ec, ec);
+		if (!skippable)
+			render_opcode(out, "ASN1_OP_COND_FAIL,\n");
+		if (e->action)
+			render_opcode(out, "ASN1_OP_ACT,\n");
+		break;
+
+	default:
+		break;
+	}
+
+	if (e->action)
+		render_opcode(out, "_action(ACT_%s),\n", e->action->name);
+}