| 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 |
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); > +} >
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 --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); +}
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