On Sat, Oct 12, 2019 at 01:22:15PM +0200, Heinrich Schuchardt wrote:

On 10/11/19 9:41 AM, AKASHI Takahiro wrote:

...

Adding kmemdup() will help improve portability from linux kernel code (in my case, lib/crypto/x509_cert_parser.c and pkcs7_parser.c).

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

include/linux/compat.h | 4 ++-- lib/linux_compat.c | 11 +++++++++++ 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/include/linux/compat.h b/include/linux/compat.h index d0f51baab407..d23ef50454ce 100644 --- a/include/linux/compat.h +++ b/include/linux/compat.h @@ -117,6 +117,8 @@ static inline void kmem_cache_destroy(struct kmem_cache *cachep) free(cachep); }

+void *kmemdup(const void *src, size_t size, int flags);

kememdup() is already implemented in fs/ubifs/ubifs.c and used both in drivers/mtd/ and in fs/ubifs/.

Good catch, I haven't noticed that. ubifs.c is a very bad place for that function. # drivers/mtd/mtd*.c doesn't use it as relevant code is guarded by "#ifndef __UBOOT__" though.

Why would you want to use a different signature than both the Linux kernel and current U-Boot?

...

#define DECLARE_WAITQUEUE(...) do { } while (0) #define add_wait_queue(...) do { } while (0) #define remove_wait_queue(...) do { } while (0) @@ -346,8 +348,6 @@ struct writeback_control { unsigned for_sync:1; /* sync(2) WB_SYNC_ALL writeback */ };

-void *kmemdup(const void *src, size_t len, gfp_t gfp);

typedef int irqreturn_t;

struct timer_list {}; diff --git a/lib/linux_compat.c b/lib/linux_compat.c index 6373b4451eb3..dd1e5b3c2087 100644 --- a/lib/linux_compat.c +++ b/lib/linux_compat.c @@ -40,3 +40,14 @@ void *kmem_cache_alloc(struct kmem_cache *obj, int flag) { return malloc_cache_aligned(obj->sz); }

+void *kmemdup(const void *src, size_t size, int flags) +{

You should not duplicate the implementation in the UBI filesystem. Instead move the existing implementation to a place that can be linked in your future work.

Okay, I'll remove it from ubifs.c.

Thanks, -Takahiro Akashi

Best regards

Heinrich

...

• void *p;
• p = kmalloc(size, flags);
• if (p)

• memcpy(p, src, size);
  

• return p;

+}

On 10/11/19 9:41 AM, AKASHI Takahiro wrote:

Adding time64_t definition will help improve portability of linux kernel code (in my case, lib/crypto/x509_cert_parser.c).

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

include/linux/time.h | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)

diff --git a/include/linux/time.h b/include/linux/time.h index b8d298eb4d68..6186985856d7 100644 --- a/include/linux/time.h +++ b/include/linux/time.h @@ -150,4 +150,28 @@ _DEFUN (ctime_r, (tim_p, result), return asctime_r (localtime_r (tim_p, &tm), result); }

+/* from <linux>/kernel/time/time.c */ +typedef __s64 time64_t;

Wouldn't we want to put these definitions into a file include/linux/time64.h?

+inline time64_t mktime64(const unsigned int year0, const unsigned int mon0,

• 	 const unsigned int day, const unsigned int hour,
  

• 	 const unsigned int min, const unsigned int sec)
  

Where is the function description?

The Linux kernel does not make this function an inline function. Why should we inline it in U-Boot?

+{

• unsigned int mon = mon0, year = year0;
• /* 1..12 -> 11,12,1..10 */
• mon -= 2;
• if (0 >= (int)mon) {

• mon += 12;	/* Puts Feb last since it has leap day */
  

• year -= 1;
  

• }
• return ((((time64_t)

•   (year / 4 - year / 100 + year / 400 + 367 * mon / 12 + day) +
  

•   year * 365 - 719499
  

•  ) * 24 + hour /* now have hours - midnight tomorrow handled here */
  

•  ) * 60 + min /* now have minutes */
  

• ) * 60 + sec; /* finally seconds */

This code is duplicate to rtc_mktime().

Duplication could be avoided by letting rtc_mktime() call mktime64().

Best regards

Heinrich

+}

• #endif

On 10/17/19 7:39 AM, AKASHI Takahiro wrote:

On Sat, Oct 12, 2019 at 01:40:32PM +0200, Heinrich Schuchardt wrote:

...

On 10/11/19 9:41 AM, AKASHI Takahiro wrote:

...

Adding time64_t definition will help improve portability of linux kernel code (in my case, lib/crypto/x509_cert_parser.c).

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

include/linux/time.h | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)

diff --git a/include/linux/time.h b/include/linux/time.h index b8d298eb4d68..6186985856d7 100644 --- a/include/linux/time.h +++ b/include/linux/time.h @@ -150,4 +150,28 @@ _DEFUN (ctime_r, (tim_p, result), return asctime_r (localtime_r (tim_p, &tm), result); }

+/* from <linux>/kernel/time/time.c */ +typedef __s64 time64_t;

Wouldn't we want to put these definitions into a file include/linux/time64.h?

Obviously, there is no problem at following your suggestion, but I hesitate to do so as it adds only one line header file. Moreover, mktime64(), which is the only reason for this patch, is also declared in "linux/time.h" even in linux code. # Please note that "linux/time64.h" is mainly for timespec64 helper functions, which are never used in U-Boot.

So I'd like to leave as it is. I think that we can re-visit this issue in the future when other definitions in time64.h are required.

...

...

+inline time64_t mktime64(const unsigned int year0, const unsigned int mon0,

• 	 const unsigned int day, const unsigned int hour,
  

• 	 const unsigned int min, const unsigned int sec)
  

Where is the function description?

The Linux kernel does not make this function an inline function. Why should we inline it in U-Boot?

...

+{

• unsigned int mon = mon0, year = year0;
• /* 1..12 -> 11,12,1..10 */
• mon -= 2;
• if (0 >= (int)mon) {

• mon += 12;	/* Puts Feb last since it has leap day */
  

• year -= 1;
  

• }
• return ((((time64_t)

•   (year / 4 - year / 100 + year / 400 + 367 * mon / 12 + day) +
  

•   year * 365 - 719499
  

•  ) * 24 + hour /* now have hours - midnight tomorrow handled here */
  

•  ) * 60 + min /* now have minutes */
  

• ) * 60 + sec; /* finally seconds */

This code is duplicate to rtc_mktime().

Duplication could be avoided by letting rtc_mktime() call mktime64().

Okay, but as an inline function in this case.

Inline use in two places adds more bytes to the binary. U-Boot should stay as small as possible.

Best regards

Heinrich

In addition, drivers/rtc/date.c will be moved to lib/ for general use with CONFIG_LIB_DATE.

Thanks, -Takahiro Akashi

...

Best regards

Heinrich

...

+}

• #endif

On 10/11/19 9:41 AM, AKASHI Takahiro wrote:

Adding "printk.h" will help improve portability from linux kernel code (in my case, lib/asn1_decoder.c).

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

include/linux/kernel.h | 2 ++ 1 file changed, 2 insertions(+)

diff --git a/include/linux/kernel.h b/include/linux/kernel.h index a85c15d8dc28..919d12bdf89c 100644 --- a/include/linux/kernel.h +++ b/include/linux/kernel.h @@ -2,7 +2,9 @@ #define _LINUX_KERNEL_H

+#include <vsprintf.h> /* for printf utilities */

Kernel code has no vsprintf.h. Linux's lib/asn1_decoder.c has not a single print statement. So why are you inserting vsprintf.h here?

#include <linux/types.h> +#include <linux/printk.h>

Linux include/linux/kernel.h also includes printk.h. OK.

Best regards

Heinrich

#define USHRT_MAX ((u16)(~0U)) #define SHRT_MAX ((s16)(USHRT_MAX>>1))

On Thu, Oct 17, 2019 at 02:58:45PM +0900, AKASHI Takahiro wrote:

On Sat, Oct 12, 2019 at 01:47:06PM +0200, Heinrich Schuchardt wrote:

...

On 10/11/19 9:41 AM, AKASHI Takahiro wrote:

...

Adding "printk.h" will help improve portability from linux kernel code (in my case, lib/asn1_decoder.c).

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

include/linux/kernel.h | 2 ++ 1 file changed, 2 insertions(+)

diff --git a/include/linux/kernel.h b/include/linux/kernel.h index a85c15d8dc28..919d12bdf89c 100644 --- a/include/linux/kernel.h +++ b/include/linux/kernel.h @@ -2,7 +2,9 @@ #define _LINUX_KERNEL_H

+#include <vsprintf.h> /* for printf utilities */

Kernel code has no vsprintf.h. Linux's lib/asn1_decoder.c has not a single print statement. So why are you inserting vsprintf.h here?

I don't remember why I mentioned to asn1_decoder.c here, but

For the record, asn1_parser.c uses pr_debug/pr_devel and others in many places.

-Takahiro Akashi

When this statement is removed from kernel.h, some files cannot be compiled. The fact is that sprintf() is used in time.h without including any related headers. (There are still bunch of *missing headers* issues in U-Boot.)

I will add one more patch against time.h here.

Thanks, -Takahiro Akashi

...

...

#include <linux/types.h> +#include <linux/printk.h>

Linux include/linux/kernel.h also includes printk.h. OK.

Best regards

Heinrich

...

#define USHRT_MAX ((u16)(~0U)) #define SHRT_MAX ((s16)(USHRT_MAX>>1))

On 10/11/19 9:41 AM, AKASHI Takahiro wrote:

Imported from linux kernel v5.3.

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

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

cmd/Kconfig | 3 + include/linux/asn1.h | 65 ++ include/linux/asn1_ber_bytecode.h | 89 ++ include/linux/asn1_decoder.h | 20 + scripts/Makefile | 3 + scripts/asn1_compiler.c | 1611 +++++++++++++++++++++++++++++

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

6 files changed, 1791 insertions(+) create mode 100644 include/linux/asn1.h create mode 100644 include/linux/asn1_ber_bytecode.h create mode 100644 include/linux/asn1_decoder.h create mode 100644 scripts/asn1_compiler.c

diff --git a/cmd/Kconfig b/cmd/Kconfig index 4e61565aab16..605dcfdf4282 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -184,6 +184,9 @@ endmenu config BUILD_BIN2C bool

+config BUILD_ASN1

• bool

• comment "Commands"

  menu "Info commands"

diff --git a/include/linux/asn1.h b/include/linux/asn1.h new file mode 100644 index 000000000000..a4d0bdd10711 --- /dev/null +++ b/include/linux/asn1.h @@ -0,0 +1,65 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* ASN.1 BER/DER/CER encoding definitions

• • Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
• • Written by David Howells (dhowells@redhat.com)
• */

+#ifndef _LINUX_ASN1_H +#define _LINUX_ASN1_H

+/* Class */ +enum asn1_class {

• ASN1_UNIV = 0, /* Universal */
• ASN1_APPL = 1, /* Application */
• ASN1_CONT = 2, /* Context */
• ASN1_PRIV = 3 /* Private */

+}; +#define ASN1_CLASS_BITS 0xc0

+enum asn1_method {

• ASN1_PRIM = 0, /* Primitive */
• ASN1_CONS = 1 /* Constructed */

+}; +#define ASN1_CONS_BIT 0x20

+/* Tag */ +enum asn1_tag {

• ASN1_EOC = 0, /* End Of Contents or N/A */
• ASN1_BOOL = 1, /* Boolean */
• ASN1_INT = 2, /* Integer */
• ASN1_BTS = 3, /* Bit String */
• ASN1_OTS = 4, /* Octet String */
• ASN1_NULL = 5, /* Null */
• ASN1_OID = 6, /* Object Identifier */
• ASN1_ODE = 7, /* Object Description */
• ASN1_EXT = 8, /* External */
• ASN1_REAL = 9, /* Real float */
• ASN1_ENUM = 10, /* Enumerated */
• ASN1_EPDV = 11, /* Embedded PDV */
• ASN1_UTF8STR = 12, /* UTF8 String */
• ASN1_RELOID = 13, /* Relative OID */
• /* 14 - Reserved */
• /* 15 - Reserved */
• ASN1_SEQ = 16, /* Sequence and Sequence of */
• ASN1_SET = 17, /* Set and Set of */
• ASN1_NUMSTR = 18, /* Numerical String */
• ASN1_PRNSTR = 19, /* Printable String */
• ASN1_TEXSTR = 20, /* T61 String / Teletext String */
• ASN1_VIDSTR = 21, /* Videotex String */
• ASN1_IA5STR = 22, /* IA5 String */
• ASN1_UNITIM = 23, /* Universal Time */
• ASN1_GENTIM = 24, /* General Time */
• ASN1_GRASTR = 25, /* Graphic String */
• ASN1_VISSTR = 26, /* Visible String */
• ASN1_GENSTR = 27, /* General String */
• ASN1_UNISTR = 28, /* Universal String */
• ASN1_CHRSTR = 29, /* Character String */
• ASN1_BMPSTR = 30, /* BMP String */
• ASN1_LONG_TAG = 31 /* Long form tag */

+};

+#define ASN1_INDEFINITE_LENGTH 0x80

+#endif /* _LINUX_ASN1_H */ diff --git a/include/linux/asn1_ber_bytecode.h b/include/linux/asn1_ber_bytecode.h new file mode 100644 index 000000000000..b38361953a48 --- /dev/null +++ b/include/linux/asn1_ber_bytecode.h @@ -0,0 +1,89 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* ASN.1 BER/DER/CER parsing state machine internal definitions

• • Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
• • Written by David Howells (dhowells@redhat.com)
• */

+#ifndef _LINUX_ASN1_BER_BYTECODE_H +#define _LINUX_ASN1_BER_BYTECODE_H

+#ifdef __KERNEL__ +#include <linux/types.h> +#endif +#include <linux/asn1.h>

+typedef int (*asn1_action_t)(void *context,

• 	     size_t hdrlen, /* In case of ANY type */
  

• 	     unsigned char tag, /* In case of ANY type */
  

• 	     const void *value, size_t vlen);
  

+struct asn1_decoder {

• const unsigned char *machine;
• size_t machlen;
• const asn1_action_t *actions;

+};

+enum asn1_opcode {

• /* The tag-matching ops come first and the odd-numbered slots

• * are for OR_SKIP ops.
  

• */
  

+#define ASN1_OP_MATCH__SKIP 0x01 +#define ASN1_OP_MATCH__ACT 0x02 +#define ASN1_OP_MATCH__JUMP 0x04 +#define ASN1_OP_MATCH__ANY 0x08 +#define ASN1_OP_MATCH__COND 0x10

• ASN1_OP_MATCH = 0x00,
• ASN1_OP_MATCH_OR_SKIP = 0x01,
• ASN1_OP_MATCH_ACT = 0x02,
• ASN1_OP_MATCH_ACT_OR_SKIP = 0x03,
• ASN1_OP_MATCH_JUMP = 0x04,
• ASN1_OP_MATCH_JUMP_OR_SKIP = 0x05,
• ASN1_OP_MATCH_ANY = 0x08,
• ASN1_OP_MATCH_ANY_OR_SKIP = 0x09,
• ASN1_OP_MATCH_ANY_ACT = 0x0a,
• ASN1_OP_MATCH_ANY_ACT_OR_SKIP = 0x0b,
• /* Everything before here matches unconditionally */
• ASN1_OP_COND_MATCH_OR_SKIP = 0x11,
• ASN1_OP_COND_MATCH_ACT_OR_SKIP = 0x13,
• ASN1_OP_COND_MATCH_JUMP_OR_SKIP = 0x15,
• ASN1_OP_COND_MATCH_ANY = 0x18,
• ASN1_OP_COND_MATCH_ANY_OR_SKIP = 0x19,
• ASN1_OP_COND_MATCH_ANY_ACT = 0x1a,
• ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP = 0x1b,
• /* Everything before here will want a tag from the data */

+#define ASN1_OP__MATCHES_TAG ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP

• /* These are here to help fill up space */
• ASN1_OP_COND_FAIL = 0x1c,
• ASN1_OP_COMPLETE = 0x1d,
• ASN1_OP_ACT = 0x1e,
• ASN1_OP_MAYBE_ACT = 0x1f,
• /* The following eight have bit 0 -> SET, 1 -> OF, 2 -> ACT */
• ASN1_OP_END_SEQ = 0x20,
• ASN1_OP_END_SET = 0x21,
• ASN1_OP_END_SEQ_OF = 0x22,
• ASN1_OP_END_SET_OF = 0x23,
• ASN1_OP_END_SEQ_ACT = 0x24,
• ASN1_OP_END_SET_ACT = 0x25,
• ASN1_OP_END_SEQ_OF_ACT = 0x26,
• ASN1_OP_END_SET_OF_ACT = 0x27,

+#define ASN1_OP_END__SET 0x01 +#define ASN1_OP_END__OF 0x02 +#define ASN1_OP_END__ACT 0x04

• ASN1_OP_RETURN = 0x28,
• ASN1_OP__NR

+};

+#define _tag(CLASS, CP, TAG) ((ASN1_##CLASS << 6) | (ASN1_##CP << 5) | ASN1_##TAG) +#define _tagn(CLASS, CP, TAG) ((ASN1_##CLASS << 6) | (ASN1_##CP << 5) | TAG) +#define _jump_target(N) (N) +#define _action(N) (N)

+#endif /* _LINUX_ASN1_BER_BYTECODE_H */ diff --git a/include/linux/asn1_decoder.h b/include/linux/asn1_decoder.h new file mode 100644 index 000000000000..83f9c6e1e5e9 --- /dev/null +++ b/include/linux/asn1_decoder.h @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* ASN.1 decoder

• • Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
• • Written by David Howells (dhowells@redhat.com)
• */

+#ifndef _LINUX_ASN1_DECODER_H +#define _LINUX_ASN1_DECODER_H

+#include <linux/asn1.h>

+struct asn1_decoder;

+extern int asn1_ber_decoder(const struct asn1_decoder *decoder,

• 	    void *context,
  

• 	    const unsigned char *data,
  

• 	    size_t datalen);
  

+#endif /* _LINUX_ASN1_DECODER_H */ diff --git a/scripts/Makefile b/scripts/Makefile index e7b353f77f43..c4e2ae5db2ea 100644 --- a/scripts/Makefile +++ b/scripts/Makefile @@ -5,6 +5,9 @@ # ---------------------------------------------------------------------------

hostprogs-$(CONFIG_BUILD_BIN2C) += bin2c +hostprogs-$(CONFIG_BUILD_ASN1) += asn1_compiler

+HOSTCFLAGS_asn1_compiler.o = -idirafter $(srctree)/include

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

Otherwise

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

always := $(hostprogs-y)

diff --git a/scripts/asn1_compiler.c b/scripts/asn1_compiler.c new file mode 100644 index 000000000000..adabd4145264 --- /dev/null +++ b/scripts/asn1_compiler.c @@ -0,0 +1,1611 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* Simplified ASN.1 notation parser

• • Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
• • Written by David Howells (dhowells@redhat.com)
• */

+#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <stdbool.h> +#include <string.h> +#include <ctype.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <linux/asn1_ber_bytecode.h>

+enum token_type {

• DIRECTIVE_ABSENT,
• DIRECTIVE_ALL,
• DIRECTIVE_ANY,
• DIRECTIVE_APPLICATION,
• DIRECTIVE_AUTOMATIC,
• DIRECTIVE_BEGIN,
• DIRECTIVE_BIT,
• DIRECTIVE_BMPString,
• DIRECTIVE_BOOLEAN,
• DIRECTIVE_BY,
• DIRECTIVE_CHARACTER,
• DIRECTIVE_CHOICE,
• DIRECTIVE_CLASS,
• DIRECTIVE_COMPONENT,
• DIRECTIVE_COMPONENTS,
• DIRECTIVE_CONSTRAINED,
• DIRECTIVE_CONTAINING,
• DIRECTIVE_DEFAULT,
• DIRECTIVE_DEFINED,
• DIRECTIVE_DEFINITIONS,
• DIRECTIVE_EMBEDDED,
• DIRECTIVE_ENCODED,
• DIRECTIVE_ENCODING_CONTROL,
• DIRECTIVE_END,
• DIRECTIVE_ENUMERATED,
• DIRECTIVE_EXCEPT,
• DIRECTIVE_EXPLICIT,
• DIRECTIVE_EXPORTS,
• DIRECTIVE_EXTENSIBILITY,
• DIRECTIVE_EXTERNAL,
• DIRECTIVE_FALSE,
• DIRECTIVE_FROM,
• DIRECTIVE_GeneralString,
• DIRECTIVE_GeneralizedTime,
• DIRECTIVE_GraphicString,
• DIRECTIVE_IA5String,
• DIRECTIVE_IDENTIFIER,
• DIRECTIVE_IMPLICIT,
• DIRECTIVE_IMPLIED,
• DIRECTIVE_IMPORTS,
• DIRECTIVE_INCLUDES,
• DIRECTIVE_INSTANCE,
• DIRECTIVE_INSTRUCTIONS,
• DIRECTIVE_INTEGER,
• DIRECTIVE_INTERSECTION,
• DIRECTIVE_ISO646String,
• DIRECTIVE_MAX,
• DIRECTIVE_MIN,
• DIRECTIVE_MINUS_INFINITY,
• DIRECTIVE_NULL,
• DIRECTIVE_NumericString,
• DIRECTIVE_OBJECT,
• DIRECTIVE_OCTET,
• DIRECTIVE_OF,
• DIRECTIVE_OPTIONAL,
• DIRECTIVE_ObjectDescriptor,
• DIRECTIVE_PATTERN,
• DIRECTIVE_PDV,
• DIRECTIVE_PLUS_INFINITY,
• DIRECTIVE_PRESENT,
• DIRECTIVE_PRIVATE,
• DIRECTIVE_PrintableString,
• DIRECTIVE_REAL,
• DIRECTIVE_RELATIVE_OID,
• DIRECTIVE_SEQUENCE,
• DIRECTIVE_SET,
• DIRECTIVE_SIZE,
• DIRECTIVE_STRING,
• DIRECTIVE_SYNTAX,
• DIRECTIVE_T61String,
• DIRECTIVE_TAGS,
• DIRECTIVE_TRUE,
• DIRECTIVE_TeletexString,
• DIRECTIVE_UNION,
• DIRECTIVE_UNIQUE,
• DIRECTIVE_UNIVERSAL,
• DIRECTIVE_UTCTime,
• DIRECTIVE_UTF8String,
• DIRECTIVE_UniversalString,
• DIRECTIVE_VideotexString,
• DIRECTIVE_VisibleString,
• DIRECTIVE_WITH,
• NR__DIRECTIVES,
• TOKEN_ASSIGNMENT = NR__DIRECTIVES,
• TOKEN_OPEN_CURLY,
• TOKEN_CLOSE_CURLY,
• TOKEN_OPEN_SQUARE,
• TOKEN_CLOSE_SQUARE,
• TOKEN_OPEN_ACTION,
• TOKEN_CLOSE_ACTION,
• TOKEN_COMMA,
• TOKEN_NUMBER,
• TOKEN_TYPE_NAME,
• TOKEN_ELEMENT_NAME,
• NR__TOKENS

+};

+static const unsigned char token_to_tag[NR__TOKENS] = {

• /* EOC goes first */
• [DIRECTIVE_BOOLEAN] = ASN1_BOOL,
• [DIRECTIVE_INTEGER] = ASN1_INT,
• [DIRECTIVE_BIT] = ASN1_BTS,
• [DIRECTIVE_OCTET] = ASN1_OTS,
• [DIRECTIVE_NULL] = ASN1_NULL,
• [DIRECTIVE_OBJECT] = ASN1_OID,
• [DIRECTIVE_ObjectDescriptor] = ASN1_ODE,
• [DIRECTIVE_EXTERNAL] = ASN1_EXT,
• [DIRECTIVE_REAL] = ASN1_REAL,
• [DIRECTIVE_ENUMERATED] = ASN1_ENUM,
• [DIRECTIVE_EMBEDDED] = 0,
• [DIRECTIVE_UTF8String] = ASN1_UTF8STR,
• [DIRECTIVE_RELATIVE_OID] = ASN1_RELOID,
• /* 14 */
• /* 15 */
• [DIRECTIVE_SEQUENCE] = ASN1_SEQ,
• [DIRECTIVE_SET] = ASN1_SET,
• [DIRECTIVE_NumericString] = ASN1_NUMSTR,
• [DIRECTIVE_PrintableString] = ASN1_PRNSTR,
• [DIRECTIVE_T61String] = ASN1_TEXSTR,
• [DIRECTIVE_TeletexString] = ASN1_TEXSTR,
• [DIRECTIVE_VideotexString] = ASN1_VIDSTR,
• [DIRECTIVE_IA5String] = ASN1_IA5STR,
• [DIRECTIVE_UTCTime] = ASN1_UNITIM,
• [DIRECTIVE_GeneralizedTime] = ASN1_GENTIM,
• [DIRECTIVE_GraphicString] = ASN1_GRASTR,
• [DIRECTIVE_VisibleString] = ASN1_VISSTR,
• [DIRECTIVE_GeneralString] = ASN1_GENSTR,
• [DIRECTIVE_UniversalString] = ASN1_UNITIM,
• [DIRECTIVE_CHARACTER] = ASN1_CHRSTR,
• [DIRECTIVE_BMPString] = ASN1_BMPSTR,

+};

+static const char asn1_classes[4][5] = {

• [ASN1_UNIV] = "UNIV",
• [ASN1_APPL] = "APPL",
• [ASN1_CONT] = "CONT",
• [ASN1_PRIV] = "PRIV"

+};

+static const char asn1_methods[2][5] = {

• [ASN1_UNIV] = "PRIM",
• [ASN1_APPL] = "CONS"

+};

+static const char *const asn1_universal_tags[32] = {

• "EOC",
• "BOOL",
• "INT",
• "BTS",
• "OTS",
• "NULL",
• "OID",
• "ODE",
• "EXT",
• "REAL",
• "ENUM",
• "EPDV",
• "UTF8STR",
• "RELOID",
• NULL, /* 14 */
• NULL, /* 15 */
• "SEQ",
• "SET",
• "NUMSTR",
• "PRNSTR",
• "TEXSTR",
• "VIDSTR",
• "IA5STR",
• "UNITIM",
• "GENTIM",
• "GRASTR",
• "VISSTR",
• "GENSTR",
• "UNISTR",
• "CHRSTR",
• "BMPSTR",
• NULL /* 31 */

+};

+static const char *filename; +static const char *grammar_name; +static const char *outputname; +static const char *headername;

+static const char *const directives[NR__DIRECTIVES] = { +#define _(X) [DIRECTIVE_##X] = #X

• _(ABSENT),
• _(ALL),
• _(ANY),
• _(APPLICATION),
• _(AUTOMATIC),
• _(BEGIN),
• _(BIT),
• _(BMPString),
• _(BOOLEAN),
• _(BY),
• _(CHARACTER),
• _(CHOICE),
• _(CLASS),
• _(COMPONENT),
• _(COMPONENTS),
• _(CONSTRAINED),
• _(CONTAINING),
• _(DEFAULT),
• _(DEFINED),
• _(DEFINITIONS),
• _(EMBEDDED),
• _(ENCODED),
• [DIRECTIVE_ENCODING_CONTROL] = "ENCODING-CONTROL",
• _(END),
• _(ENUMERATED),
• _(EXCEPT),
• _(EXPLICIT),
• _(EXPORTS),
• _(EXTENSIBILITY),
• _(EXTERNAL),
• _(FALSE),
• _(FROM),
• _(GeneralString),
• _(GeneralizedTime),
• _(GraphicString),
• _(IA5String),
• _(IDENTIFIER),
• _(IMPLICIT),
• _(IMPLIED),
• _(IMPORTS),
• _(INCLUDES),
• _(INSTANCE),
• _(INSTRUCTIONS),
• _(INTEGER),
• _(INTERSECTION),
• _(ISO646String),
• _(MAX),
• _(MIN),
• [DIRECTIVE_MINUS_INFINITY] = "MINUS-INFINITY",
• [DIRECTIVE_NULL] = "NULL",
• _(NumericString),
• _(OBJECT),
• _(OCTET),
• _(OF),
• _(OPTIONAL),
• _(ObjectDescriptor),
• _(PATTERN),
• _(PDV),
• [DIRECTIVE_PLUS_INFINITY] = "PLUS-INFINITY",
• _(PRESENT),
• _(PRIVATE),
• _(PrintableString),
• _(REAL),
• [DIRECTIVE_RELATIVE_OID] = "RELATIVE-OID",
• _(SEQUENCE),
• _(SET),
• _(SIZE),
• _(STRING),
• _(SYNTAX),
• _(T61String),
• _(TAGS),
• _(TRUE),
• _(TeletexString),
• _(UNION),
• _(UNIQUE),
• _(UNIVERSAL),
• _(UTCTime),
• _(UTF8String),
• _(UniversalString),
• _(VideotexString),
• _(VisibleString),
• _(WITH)

+};

+struct action {

• struct action *next;
• char *name;
• unsigned char index;

+};

+static struct action *action_list; +static unsigned nr_actions;

+struct token {

• unsigned short line;
• enum token_type token_type : 8;
• unsigned char size;
• struct action *action;
• char *content;
• struct type *type;

+};

+static struct token *token_list; +static unsigned nr_tokens; +static bool verbose_opt; +static bool debug_opt;

+#define verbose(fmt, ...) do { if (verbose_opt) printf(fmt, ## __VA_ARGS__); } while (0) +#define debug(fmt, ...) do { if (debug_opt) printf(fmt, ## __VA_ARGS__); } while (0)

+static int directive_compare(const void *_key, const void *_pdir) +{

• const struct token *token = _key;
• const char *const *pdir = _pdir, *dir = *pdir;
• size_t dlen, clen;
• int val;
• dlen = strlen(dir);
• clen = (dlen < token->size) ? dlen : token->size;
• //debug("cmp(%s,%s) = ", token->content, dir);
• val = memcmp(token->content, dir, clen);
• if (val != 0) {

• //debug("%d [cmp]\n", val);
  

• return val;
  

• }
• if (dlen == token->size) {

• //debug("0\n");
  

• return 0;
  

• }
• //debug("%d\n", (int)dlen - (int)token->size);
• return dlen - token->size; /* shorter -> negative */

+}

+/*

• • Tokenise an ASN.1 grammar
• */

+static void tokenise(char *buffer, char *end) +{

• struct token *tokens;
• char *line, *nl, *start, *p, *q;
• unsigned tix, lineno;
• /* Assume we're going to have half as many tokens as we have

• * characters
  

• */
  

• token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token));
• if (!tokens) {

• perror(NULL);
  

• exit(1);
  

• }
• tix = 0;
• lineno = 0;
• while (buffer < end) {

• /* First of all, break out a line */
  

• lineno++;
  

• line = buffer;
  

• nl = memchr(line, '\n', end - buffer);
  

• if (!nl) {
  

• 	buffer = nl = end;
  

• } else {
  

• 	buffer = nl + 1;
  

• 	*nl = '\0';
  

• }
  

• /* Remove "--" comments */
  

• p = line;
  

• next_comment:

• while ((p = memchr(p, '-', nl - p))) {
  

• 	if (p[1] == '-') {
  

• 		/* Found a comment; see if there's a terminator */
  

• 		q = p + 2;
  

• 		while ((q = memchr(q, '-', nl - q))) {
  

• 			if (q[1] == '-') {
  

• 				/* There is - excise the comment */
  

• 				q += 2;
  

• 				memmove(p, q, nl - q);
  

• 				goto next_comment;
  

• 			}
  

• 			q++;
  

• 		}
  

• 		*p = '\0';
  

• 		nl = p;
  

• 		break;
  

• 	} else {
  

• 		p++;
  

• 	}
  

• }
  

• p = line;
  

• while (p < nl) {
  

• 	/* Skip white space */
  

• 	while (p < nl && isspace(*p))
  

• 		*(p++) = 0;
  

• 	if (p >= nl)
  

• 		break;
  

• 	tokens[tix].line = lineno;
  

• 	start = p;
  

• 	/* Handle string tokens */
  

• 	if (isalpha(*p)) {
  

• 		const char **dir;
  

• 		/* Can be a directive, type name or element
  

• 		 * name.  Find the end of the name.
  

• 		 */
  

• 		q = p + 1;
  

• 		while (q < nl && (isalnum(*q) || *q == '-' || *q == '_'))
  

• 			q++;
  

• 		tokens[tix].size = q - p;
  

• 		p = q;
  

• 		tokens[tix].content = malloc(tokens[tix].size + 1);
  

• 		if (!tokens[tix].content) {
  

• 			perror(NULL);
  

• 			exit(1);
  

• 		}
  

• 		memcpy(tokens[tix].content, start, tokens[tix].size);
  

• 		tokens[tix].content[tokens[tix].size] = 0;
  

• 		/* If it begins with a lowercase letter then
  

• 		 * it's an element name
  

• 		 */
  

• 		if (islower(tokens[tix].content[0])) {
  

• 			tokens[tix++].token_type = TOKEN_ELEMENT_NAME;
  

• 			continue;
  

• 		}
  

• 		/* Otherwise we need to search the directive
  

• 		 * table
  

• 		 */
  

• 		dir = bsearch(&tokens[tix], directives,
  

• 			      sizeof(directives) / sizeof(directives[1]),
  

• 			      sizeof(directives[1]),
  

• 			      directive_compare);
  

• 		if (dir) {
  

• 			tokens[tix++].token_type = dir - directives;
  

• 			continue;
  

• 		}
  

• 		tokens[tix++].token_type = TOKEN_TYPE_NAME;
  

• 		continue;
  

• 	}
  

• 	/* Handle numbers */
  

• 	if (isdigit(*p)) {
  

• 		/* Find the end of the number */
  

• 		q = p + 1;
  

• 		while (q < nl && (isdigit(*q)))
  

• 			q++;
  

• 		tokens[tix].size = q - p;
  

• 		p = q;
  

• 		tokens[tix].content = malloc(tokens[tix].size + 1);
  

• 		if (!tokens[tix].content) {
  

• 			perror(NULL);
  

• 			exit(1);
  

• 		}
  

• 		memcpy(tokens[tix].content, start, tokens[tix].size);
  

• 		tokens[tix].content[tokens[tix].size] = 0;
  

• 		tokens[tix++].token_type = TOKEN_NUMBER;
  

• 		continue;
  

• 	}
  

• 	if (nl - p >= 3) {
  

• 		if (memcmp(p, "::=", 3) == 0) {
  

• 			p += 3;
  

• 			tokens[tix].size = 3;
  

• 			tokens[tix].content = "::=";
  

• 			tokens[tix++].token_type = TOKEN_ASSIGNMENT;
  

• 			continue;
  

• 		}
  

• 	}
  

• 	if (nl - p >= 2) {
  

• 		if (memcmp(p, "({", 2) == 0) {
  

• 			p += 2;
  

• 			tokens[tix].size = 2;
  

• 			tokens[tix].content = "({";
  

• 			tokens[tix++].token_type = TOKEN_OPEN_ACTION;
  

• 			continue;
  

• 		}
  

• 		if (memcmp(p, "})", 2) == 0) {
  

• 			p += 2;
  

• 			tokens[tix].size = 2;
  

• 			tokens[tix].content = "})";
  

• 			tokens[tix++].token_type = TOKEN_CLOSE_ACTION;
  

• 			continue;
  

• 		}
  

• 	}
  

• 	if (nl - p >= 1) {
  

• 		tokens[tix].size = 1;
  

• 		switch (*p) {
  

• 		case '{':
  

• 			p += 1;
  

• 			tokens[tix].content = "{";
  

• 			tokens[tix++].token_type = TOKEN_OPEN_CURLY;
  

• 			continue;
  

• 		case '}':
  

• 			p += 1;
  

• 			tokens[tix].content = "}";
  

• 			tokens[tix++].token_type = TOKEN_CLOSE_CURLY;
  

• 			continue;
  

• 		case '[':
  

• 			p += 1;
  

• 			tokens[tix].content = "[";
  

• 			tokens[tix++].token_type = TOKEN_OPEN_SQUARE;
  

• 			continue;
  

• 		case ']':
  

• 			p += 1;
  

• 			tokens[tix].content = "]";
  

• 			tokens[tix++].token_type = TOKEN_CLOSE_SQUARE;
  

• 			continue;
  

• 		case ',':
  

• 			p += 1;
  

• 			tokens[tix].content = ",";
  

• 			tokens[tix++].token_type = TOKEN_COMMA;
  

• 			continue;
  

• 		default:
  

• 			break;
  

• 		}
  

• 	}
  

• 	fprintf(stderr, "%s:%u: Unknown character in grammar: '%c'\n",
  

• 		filename, lineno, *p);
  

• 	exit(1);
  

• }
  

• }
• nr_tokens = tix;
• verbose("Extracted %u tokens\n", nr_tokens);

+#if 0

• {

• int n;
  

• for (n = 0; n < nr_tokens; n++)
  

• 	debug("Token %3u: '%s'\n", n, token_list[n].content);
  

• }

+#endif +}

+static void build_type_list(void); +static void parse(void); +static void dump_elements(void); +static void render(FILE *out, FILE *hdr);

+/*

• */

+int main(int argc, char **argv) +{

• struct stat st;
• ssize_t readlen;
• FILE *out, *hdr;
• char *buffer, *p;
• char *kbuild_verbose;
• int fd;
• kbuild_verbose = getenv("KBUILD_VERBOSE");
• if (kbuild_verbose)

• verbose_opt = atoi(kbuild_verbose);
  

• while (argc > 4) {

• if (strcmp(argv[1], "-v") == 0)
  

• 	verbose_opt = true;
  

• else if (strcmp(argv[1], "-d") == 0)
  

• 	debug_opt = true;
  

• else
  

• 	break;
  

• memmove(&argv[1], &argv[2], (argc - 2) * sizeof(char *));
  

• argc--;
  

• }
• if (argc != 4) {

• fprintf(stderr, "Format: %s [-v] [-d] <grammar-file> <c-file> <hdr-file>\n",
  

• 	argv[0]);
  

• exit(2);
  

• }
• filename = argv[1];
• outputname = argv[2];
• headername = argv[3];
• fd = open(filename, O_RDONLY);
• if (fd < 0) {

• perror(filename);
  

• exit(1);
  

• }
• if (fstat(fd, &st) < 0) {

• perror(filename);
  

• exit(1);
  

• }
• if (!(buffer = malloc(st.st_size + 1))) {

• perror(NULL);
  

• exit(1);
  

• }
• if ((readlen = read(fd, buffer, st.st_size)) < 0) {

• perror(filename);
  

• exit(1);
  

• }
• if (close(fd) < 0) {

• perror(filename);
  

• exit(1);
  

• }
• if (readlen != st.st_size) {

• fprintf(stderr, "%s: Short read\n", filename);
  

• exit(1);
  

• }
• p = strrchr(argv[1], '/');
• p = p ? p + 1 : argv[1];
• grammar_name = strdup(p);
• if (!p) {

• perror(NULL);
  

• exit(1);
  

• }
• p = strchr(grammar_name, '.');
• if (p)

• *p = '\0';
  

• buffer[readlen] = 0;
• tokenise(buffer, buffer + readlen);
• build_type_list();
• parse();
• dump_elements();
• out = fopen(outputname, "w");
• if (!out) {

• perror(outputname);
  

• exit(1);
  

• }
• hdr = fopen(headername, "w");
• if (!hdr) {

• perror(headername);
  

• exit(1);
  

• }
• render(out, hdr);
• if (fclose(out) < 0) {

• perror(outputname);
  

• exit(1);
  

• }
• if (fclose(hdr) < 0) {

• perror(headername);
  

• exit(1);
  

• }
• return 0;

+}

+enum compound {

• NOT_COMPOUND,
• SET,
• SET_OF,
• SEQUENCE,
• SEQUENCE_OF,
• CHOICE,
• ANY,
• TYPE_REF,
• TAG_OVERRIDE

+};

+struct element {

• struct type *type_def;
• struct token *name;
• struct token *type;
• struct action *action;
• struct element *children;
• struct element *next;
• struct element *render_next;
• struct element *list_next;
• uint8_t n_elements;
• enum compound compound : 8;
• enum asn1_class class : 8;
• enum asn1_method method : 8;
• uint8_t tag;
• unsigned entry_index;
• unsigned flags;

+#define ELEMENT_IMPLICIT 0x0001 +#define ELEMENT_EXPLICIT 0x0002 +#define ELEMENT_TAG_SPECIFIED 0x0004 +#define ELEMENT_RENDERED 0x0008 +#define ELEMENT_SKIPPABLE 0x0010 +#define ELEMENT_CONDITIONAL 0x0020 +};

+struct type {

• struct token *name;
• struct token *def;
• struct element *element;
• unsigned ref_count;
• unsigned flags;

+#define TYPE_STOP_MARKER 0x0001 +#define TYPE_BEGIN 0x0002 +};

+static struct type *type_list; +static struct type **type_index; +static unsigned nr_types;

+static int type_index_compare(const void *_a, const void *_b) +{

• const struct type *const *a = _a, *const *b = _b;
• if ((*a)->name->size != (*b)->name->size)

• return (*a)->name->size - (*b)->name->size;
  

• else

• return memcmp((*a)->name->content, (*b)->name->content,
  

• 	      (*a)->name->size);
  

+}

+static int type_finder(const void *_key, const void *_ti) +{

• const struct token *token = _key;
• const struct type *const *ti = _ti;
• const struct type *type = *ti;
• if (token->size != type->name->size)

• return token->size - type->name->size;
  

• else

• return memcmp(token->content, type->name->content,
  

• 	      token->size);
  

+}

+/*

• • Build up a list of types and a sorted index to that list.
• */

+static void build_type_list(void) +{

• struct type *types;
• unsigned nr, t, n;
• nr = 0;
• for (n = 0; n < nr_tokens - 1; n++)

• if (token_list[n + 0].token_type == TOKEN_TYPE_NAME &&
  

•     token_list[n + 1].token_type == TOKEN_ASSIGNMENT)
  

• 	nr++;
  

• if (nr == 0) {

• fprintf(stderr, "%s: No defined types\n", filename);
  

• exit(1);
  

• }
• nr_types = nr;
• types = type_list = calloc(nr + 1, sizeof(type_list[0]));
• if (!type_list) {

• perror(NULL);
  

• exit(1);
  

• }
• type_index = calloc(nr, sizeof(type_index[0]));
• if (!type_index) {

• perror(NULL);
  

• exit(1);
  

• }
• t = 0;
• types[t].flags |= TYPE_BEGIN;
• for (n = 0; n < nr_tokens - 1; n++) {

• if (token_list[n + 0].token_type == TOKEN_TYPE_NAME &&
  

•     token_list[n + 1].token_type == TOKEN_ASSIGNMENT) {
  

• 	types[t].name = &token_list[n];
  

• 	type_index[t] = &types[t];
  

• 	t++;
  

• }
  

• }
• types[t].name = &token_list[n + 1];
• types[t].flags |= TYPE_STOP_MARKER;
• qsort(type_index, nr, sizeof(type_index[0]), type_index_compare);
• verbose("Extracted %u types\n", nr_types);

+#if 0

• for (n = 0; n < nr_types; n++) {

• struct type *type = type_index[n];
  

• debug("- %*.*s\n", type->name->content);
  

• }

+#endif +}

+static struct element *parse_type(struct token **_cursor, struct token *stop,

• 		  struct token *name);
  

+/*

• • Parse the token stream
• */

+static void parse(void) +{

• struct token *cursor;
• struct type *type;
• /* Parse one type definition statement at a time */
• type = type_list;
• do {

• cursor = type->name;
  

• if (cursor[0].token_type != TOKEN_TYPE_NAME ||
  

•     cursor[1].token_type != TOKEN_ASSIGNMENT)
  

• 	abort();
  

• cursor += 2;
  

• type->element = parse_type(&cursor, type[1].name, NULL);
  

• type->element->type_def = type;
  

• if (cursor != type[1].name) {
  

• 	fprintf(stderr, "%s:%d: Parse error at token '%s'\n",
  

• 		filename, cursor->line, cursor->content);
  

• 	exit(1);
  

• }
  

• } while (type++, !(type->flags & TYPE_STOP_MARKER));
• verbose("Extracted %u actions\n", nr_actions);

+}

+static struct element *element_list;

+static struct element *alloc_elem(struct token *type) +{

• struct element *e = calloc(1, sizeof(*e));
• if (!e) {

• perror(NULL);
  

• exit(1);
  

• }
• e->list_next = element_list;
• element_list = e;
• return e;

+}

+static struct element *parse_compound(struct token **_cursor, struct token *end,

• 		      int alternates);
  

+/*

• • Parse one type definition statement
• */

+static struct element *parse_type(struct token **_cursor, struct token *end,

• 		  struct token *name)
  

+{

• struct element *top, *element;
• struct action *action, **ppaction;
• struct token *cursor = *_cursor;
• struct type **ref;
• char *p;
• int labelled = 0, implicit = 0;
• top = element = alloc_elem(cursor);
• element->class = ASN1_UNIV;
• element->method = ASN1_PRIM;
• element->tag = token_to_tag[cursor->token_type];
• element->name = name;
• /* Extract the tag value if one given */
• if (cursor->token_type == TOKEN_OPEN_SQUARE) {

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• switch (cursor->token_type) {
  

• case DIRECTIVE_UNIVERSAL:
  

• 	element->class = ASN1_UNIV;
  

• 	cursor++;
  

• 	break;
  

• case DIRECTIVE_APPLICATION:
  

• 	element->class = ASN1_APPL;
  

• 	cursor++;
  

• 	break;
  

• case TOKEN_NUMBER:
  

• 	element->class = ASN1_CONT;
  

• 	break;
  

• case DIRECTIVE_PRIVATE:
  

• 	element->class = ASN1_PRIV;
  

• 	cursor++;
  

• 	break;
  

• default:
  

• 	fprintf(stderr, "%s:%d: Unrecognised tag class token '%s'\n",
  

• 		filename, cursor->line, cursor->content);
  

• 	exit(1);
  

• }
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• if (cursor->token_type != TOKEN_NUMBER) {
  

• 	fprintf(stderr, "%s:%d: Missing tag number '%s'\n",
  

• 		filename, cursor->line, cursor->content);
  

• 	exit(1);
  

• }
  

• element->tag &= ~0x1f;
  

• element->tag |= strtoul(cursor->content, &p, 10);
  

• element->flags |= ELEMENT_TAG_SPECIFIED;
  

• if (p - cursor->content != cursor->size)
  

• 	abort();
  

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• if (cursor->token_type != TOKEN_CLOSE_SQUARE) {
  

• 	fprintf(stderr, "%s:%d: Missing closing square bracket '%s'\n",
  

• 		filename, cursor->line, cursor->content);
  

• 	exit(1);
  

• }
  

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• labelled = 1;
  

• }
• /* Handle implicit and explicit markers */
• if (cursor->token_type == DIRECTIVE_IMPLICIT) {

• element->flags |= ELEMENT_IMPLICIT;
  

• implicit = 1;
  

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• } else if (cursor->token_type == DIRECTIVE_EXPLICIT) {

• element->flags |= ELEMENT_EXPLICIT;
  

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• }
• if (labelled) {

• if (!implicit)
  

• 	element->method |= ASN1_CONS;
  

• element->compound = implicit ? TAG_OVERRIDE : SEQUENCE;
  

• element->children = alloc_elem(cursor);
  

• element = element->children;
  

• element->class = ASN1_UNIV;
  

• element->method = ASN1_PRIM;
  

• element->tag = token_to_tag[cursor->token_type];
  

• element->name = name;
  

• }
• /* Extract the type we're expecting here */
• element->type = cursor;
• switch (cursor->token_type) {
• case DIRECTIVE_ANY:

• element->compound = ANY;
  

• cursor++;
  

• break;
  

• case DIRECTIVE_NULL:
• case DIRECTIVE_BOOLEAN:
• case DIRECTIVE_ENUMERATED:
• case DIRECTIVE_INTEGER:

• element->compound = NOT_COMPOUND;
  

• cursor++;
  

• break;
  

• case DIRECTIVE_EXTERNAL:

• element->method = ASN1_CONS;
  

• case DIRECTIVE_BMPString:
• case DIRECTIVE_GeneralString:
• case DIRECTIVE_GraphicString:
• case DIRECTIVE_IA5String:
• case DIRECTIVE_ISO646String:
• case DIRECTIVE_NumericString:
• case DIRECTIVE_PrintableString:
• case DIRECTIVE_T61String:
• case DIRECTIVE_TeletexString:
• case DIRECTIVE_UniversalString:
• case DIRECTIVE_UTF8String:
• case DIRECTIVE_VideotexString:
• case DIRECTIVE_VisibleString:
• case DIRECTIVE_ObjectDescriptor:
• case DIRECTIVE_GeneralizedTime:
• case DIRECTIVE_UTCTime:

• element->compound = NOT_COMPOUND;
  

• cursor++;
  

• break;
  

• case DIRECTIVE_BIT:
• case DIRECTIVE_OCTET:

• element->compound = NOT_COMPOUND;
  

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• if (cursor->token_type != DIRECTIVE_STRING)
  

• 	goto parse_error;
  

• cursor++;
  

• break;
  

• case DIRECTIVE_OBJECT:

• element->compound = NOT_COMPOUND;
  

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• if (cursor->token_type != DIRECTIVE_IDENTIFIER)
  

• 	goto parse_error;
  

• cursor++;
  

• break;
  

• case TOKEN_TYPE_NAME:

• element->compound = TYPE_REF;
  

• ref = bsearch(cursor, type_index, nr_types, sizeof(type_index[0]),
  

• 	      type_finder);
  

• if (!ref) {
  

• 	fprintf(stderr, "%s:%d: Type '%s' undefined\n",
  

• 		filename, cursor->line, cursor->content);
  

• 	exit(1);
  

• }
  

• cursor->type = *ref;
  

• (*ref)->ref_count++;
  

• cursor++;
  

• break;
  

• case DIRECTIVE_CHOICE:

• element->compound = CHOICE;
  

• cursor++;
  

• element->children = parse_compound(&cursor, end, 1);
  

• break;
  

• case DIRECTIVE_SEQUENCE:

• element->compound = SEQUENCE;
  

• element->method = ASN1_CONS;
  

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• if (cursor->token_type == DIRECTIVE_OF) {
  

• 	element->compound = SEQUENCE_OF;
  

• 	cursor++;
  

• 	if (cursor >= end)
  

• 		goto overrun_error;
  

• 	element->children = parse_type(&cursor, end, NULL);
  

• } else {
  

• 	element->children = parse_compound(&cursor, end, 0);
  

• }
  

• break;
  

• case DIRECTIVE_SET:

• element->compound = SET;
  

• element->method = ASN1_CONS;
  

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• if (cursor->token_type == DIRECTIVE_OF) {
  

• 	element->compound = SET_OF;
  

• 	cursor++;
  

• 	if (cursor >= end)
  

• 		goto parse_error;
  

• 	element->children = parse_type(&cursor, end, NULL);
  

• } else {
  

• 	element->children = parse_compound(&cursor, end, 1);
  

• }
  

• break;
  

• default:

• fprintf(stderr, "%s:%d: Token '%s' does not introduce a type\n",
  

• 	filename, cursor->line, cursor->content);
  

• exit(1);
  

• }
• /* Handle elements that are optional */
• if (cursor < end && (cursor->token_type == DIRECTIVE_OPTIONAL ||

• 	     cursor->token_type == DIRECTIVE_DEFAULT)
  

•    ) {
  

• cursor++;
  

• top->flags |= ELEMENT_SKIPPABLE;
  

• }
• if (cursor < end && cursor->token_type == TOKEN_OPEN_ACTION) {

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• if (cursor->token_type != TOKEN_ELEMENT_NAME) {
  

• 	fprintf(stderr, "%s:%d: Token '%s' is not an action function name\n",
  

• 		filename, cursor->line, cursor->content);
  

• 	exit(1);
  

• }
  

• action = malloc(sizeof(struct action));
  

• if (!action) {
  

• 	perror(NULL);
  

• 	exit(1);
  

• }
  

• action->index = 0;
  

• action->name = cursor->content;
  

• for (ppaction = &action_list;
  

•      *ppaction;
  

•      ppaction = &(*ppaction)->next
  

•      ) {
  

• 	int cmp = strcmp(action->name, (*ppaction)->name);
  

• 	if (cmp == 0) {
  

• 		free(action);
  

• 		action = *ppaction;
  

• 		goto found;
  

• 	}
  

• 	if (cmp < 0) {
  

• 		action->next = *ppaction;
  

• 		*ppaction = action;
  

• 		nr_actions++;
  

• 		goto found;
  

• 	}
  

• }
  

• action->next = NULL;
  

• *ppaction = action;
  

• nr_actions++;
  

• found:

• element->action = action;
  

• cursor->action = action;
  

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• if (cursor->token_type != TOKEN_CLOSE_ACTION) {
  

• 	fprintf(stderr, "%s:%d: Missing close action, got '%s'\n",
  

• 		filename, cursor->line, cursor->content);
  

• 	exit(1);
  

• }
  

• cursor++;
  

• }
• *_cursor = cursor;
• return top;

+parse_error:

• fprintf(stderr, "%s:%d: Unexpected token '%s'\n",

• filename, cursor->line, cursor->content);
  

• exit(1);

+overrun_error:

• fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename);
• exit(1);

+}

+/*

• • Parse a compound type list
• */

+static struct element *parse_compound(struct token **_cursor, struct token *end,

• 		      int alternates)
  

+{

• struct element *children, **child_p = &children, *element;
• struct token *cursor = *_cursor, *name;
• if (cursor->token_type != TOKEN_OPEN_CURLY) {

• fprintf(stderr, "%s:%d: Expected compound to start with brace not '%s'\n",
  

• 	filename, cursor->line, cursor->content);
  

• exit(1);
  

• }
• cursor++;
• if (cursor >= end)

• goto overrun_error;
  

• if (cursor->token_type == TOKEN_OPEN_CURLY) {

• fprintf(stderr, "%s:%d: Empty compound\n",
  

• 	filename, cursor->line);
  

• exit(1);
  

• }
• for (;;) {

• name = NULL;
  

• if (cursor->token_type == TOKEN_ELEMENT_NAME) {
  

• 	name = cursor;
  

• 	cursor++;
  

• 	if (cursor >= end)
  

• 		goto overrun_error;
  

• }
  

• element = parse_type(&cursor, end, name);
  

• if (alternates)
  

• 	element->flags |= ELEMENT_SKIPPABLE | ELEMENT_CONDITIONAL;
  

• *child_p = element;
  

• child_p = &element->next;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• if (cursor->token_type != TOKEN_COMMA)
  

• 	break;
  

• cursor++;
  

• if (cursor >= end)
  

• 	goto overrun_error;
  

• }
• children->flags &= ~ELEMENT_CONDITIONAL;
• if (cursor->token_type != TOKEN_CLOSE_CURLY) {

• fprintf(stderr, "%s:%d: Expected compound closure, got '%s'\n",
  

• 	filename, cursor->line, cursor->content);
  

• exit(1);
  

• }
• cursor++;
• *_cursor = cursor;
• return children;

+overrun_error:

• fprintf(stderr, "%s: Unexpectedly hit EOF\n", filename);
• exit(1);

+}

+static void dump_element(const struct element *e, int level) +{

• const struct element *c;
• const struct type *t = e->type_def;
• const char *name = e->name ? e->name->content : ".";
• const char *tname = t && t->name ? t->name->content : ".";
• char tag[32];
• if (e->class == 0 && e->method == 0 && e->tag == 0)

• strcpy(tag, "<...>");
  

• else if (e->class == ASN1_UNIV)

• sprintf(tag, "%s %s %s",
  

• 	asn1_classes[e->class],
  

• 	asn1_methods[e->method],
  

• 	asn1_universal_tags[e->tag]);
  

• else

• sprintf(tag, "%s %s %u",
  

• 	asn1_classes[e->class],
  

• 	asn1_methods[e->method],
  

• 	e->tag);
  

• printf("%c%c%c%c%c %c %*s[*] \e[33m%s\e[m %s %s \e[35m%s\e[m\n",

•       e->flags & ELEMENT_IMPLICIT ? 'I' : '-',
  

•       e->flags & ELEMENT_EXPLICIT ? 'E' : '-',
  

•       e->flags & ELEMENT_TAG_SPECIFIED ? 'T' : '-',
  

•       e->flags & ELEMENT_SKIPPABLE ? 'S' : '-',
  

•       e->flags & ELEMENT_CONDITIONAL ? 'C' : '-',
  

•       "-tTqQcaro"[e->compound],
  

•       level, "",
  

•       tag,
  

•       tname,
  

•       name,
  

•       e->action ? e->action->name : "");
  

• if (e->compound == TYPE_REF)

• dump_element(e->type->type->element, level + 3);
  

• else

• for (c = e->children; c; c = c->next)
  

• 	dump_element(c, level + 3);
  

+}

+static void dump_elements(void) +{

• if (debug_opt)

• dump_element(type_list[0].element, 0);
  

+}

+static void render_element(FILE *out, struct element *e, struct element *tag); +static void render_out_of_line_list(FILE *out);

+static int nr_entries; +static int render_depth = 1; +static struct element *render_list, **render_list_p = &render_list;

+__attribute__((format(printf, 2, 3))) +static void render_opcode(FILE *out, const char *fmt, ...) +{

• va_list va;
• if (out) {

• fprintf(out, "\t[%4d] =%*s", nr_entries, render_depth, "");
  

• va_start(va, fmt);
  

• vfprintf(out, fmt, va);
  

• va_end(va);
  

• }
• nr_entries++;

+}

+__attribute__((format(printf, 2, 3))) +static void render_more(FILE *out, const char *fmt, ...) +{

• va_list va;
• if (out) {

• va_start(va, fmt);
  

• vfprintf(out, fmt, va);
  

• va_end(va);
  

• }

+}

+/*

• • Render the grammar into a state machine definition.
• */

+static void render(FILE *out, FILE *hdr) +{

• struct element *e;
• struct action *action;
• struct type *root;
• int index;
• fprintf(hdr, "/*\n");
• fprintf(hdr, " * Automatically generated by asn1_compiler. Do not edit\n");
• fprintf(hdr, " *\n");
• fprintf(hdr, " * ASN.1 parser for %s\n", grammar_name);
• fprintf(hdr, " */\n");
• fprintf(hdr, "#include <linux/asn1_decoder.h>\n");
• fprintf(hdr, "\n");
• fprintf(hdr, "extern const struct asn1_decoder %s_decoder;\n", grammar_name);
• if (ferror(hdr)) {

• perror(headername);
  

• exit(1);
  

• }
• fprintf(out, "/*\n");
• fprintf(out, " * Automatically generated by asn1_compiler. Do not edit\n");
• fprintf(out, " *\n");
• fprintf(out, " * ASN.1 parser for %s\n", grammar_name);
• fprintf(out, " */\n");
• fprintf(out, "#include <linux/asn1_ber_bytecode.h>\n");
• fprintf(out, "#include "%s.asn1.h"\n", grammar_name);
• fprintf(out, "\n");
• if (ferror(out)) {

• perror(outputname);
  

• exit(1);
  

• }
• /* Tabulate the action functions we might have to call */
• fprintf(hdr, "\n");
• index = 0;
• for (action = action_list; action; action = action->next) {

• action->index = index++;
  

• fprintf(hdr,
  

• 	"extern int %s(void *, size_t, unsigned char,"
  

• 	" const void *, size_t);\n",
  

• 	action->name);
  

• }
• fprintf(hdr, "\n");
• fprintf(out, "enum %s_actions {\n", grammar_name);
• for (action = action_list; action; action = action->next)

• fprintf(out, "\tACT_%s = %u,\n",
  

• 	action->name, action->index);
  

• fprintf(out, "\tNR__%s_actions = %u\n", grammar_name, nr_actions);
• fprintf(out, "};\n");
• fprintf(out, "\n");
• fprintf(out, "static const asn1_action_t %s_action_table[NR__%s_actions] = {\n",

• grammar_name, grammar_name);
  

• for (action = action_list; action; action = action->next)

• fprintf(out, "\t[%4u] = %s,\n", action->index, action->name);
  

• fprintf(out, "};\n");
• if (ferror(out)) {

• perror(outputname);
  

• exit(1);
  

• }
• /* We do two passes - the first one calculates all the offsets */
• verbose("Pass 1\n");
• nr_entries = 0;
• root = &type_list[0];
• render_element(NULL, root->element, NULL);
• render_opcode(NULL, "ASN1_OP_COMPLETE,\n");
• render_out_of_line_list(NULL);
• for (e = element_list; e; e = e->list_next)

• e->flags &= ~ELEMENT_RENDERED;
  

• /* And then we actually render */
• verbose("Pass 2\n");
• fprintf(out, "\n");
• fprintf(out, "static const unsigned char %s_machine[] = {\n",

• grammar_name);
  

• nr_entries = 0;
• root = &type_list[0];
• render_element(out, root->element, NULL);
• render_opcode(out, "ASN1_OP_COMPLETE,\n");
• render_out_of_line_list(out);
• fprintf(out, "};\n");
• fprintf(out, "\n");
• fprintf(out, "const struct asn1_decoder %s_decoder = {\n", grammar_name);
• fprintf(out, "\t.machine = %s_machine,\n", grammar_name);
• fprintf(out, "\t.machlen = sizeof(%s_machine),\n", grammar_name);
• fprintf(out, "\t.actions = %s_action_table,\n", grammar_name);
• fprintf(out, "};\n");

+}

+/*

• • Render the out-of-line elements
• */

+static void render_out_of_line_list(FILE *out) +{

• struct element *e, *ce;
• const char *act;
• int entry;
• while ((e = render_list)) {

• render_list = e->render_next;
  

• if (!render_list)
  

• 	render_list_p = &render_list;
  

• render_more(out, "\n");
  

• e->entry_index = entry = nr_entries;
  

• render_depth++;
  

• for (ce = e->children; ce; ce = ce->next)
  

• 	render_element(out, ce, NULL);
  

• render_depth--;
  

• act = e->action ? "_ACT" : "";
  

• switch (e->compound) {
  

• case SEQUENCE:
  

• 	render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act);
  

• 	break;
  

• case SEQUENCE_OF:
  

• 	render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act);
  

• 	render_opcode(out, "_jump_target(%u),\n", entry);
  

• 	break;
  

• case SET:
  

• 	render_opcode(out, "ASN1_OP_END_SET%s,\n", act);
  

• 	break;
  

• case SET_OF:
  

• 	render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act);
  

• 	render_opcode(out, "_jump_target(%u),\n", entry);
  

• 	break;
  

• default:
  

• 	break;
  

• }
  

• if (e->action)
  

• 	render_opcode(out, "_action(ACT_%s),\n",
  

• 		      e->action->name);
  

• render_opcode(out, "ASN1_OP_RETURN,\n");
  

• }

+}

+/*

• • Render an element.
• */

+static void render_element(FILE *out, struct element *e, struct element *tag) +{

• struct element *ec, *x;
• const char *cond, *act;
• int entry, skippable = 0, outofline = 0;
• if (e->flags & ELEMENT_SKIPPABLE ||

•    (tag && tag->flags & ELEMENT_SKIPPABLE))
  

• skippable = 1;
  

• if ((e->type_def && e->type_def->ref_count > 1) ||

•    skippable)
  

• outofline = 1;
  

• if (e->type_def && out) {

• render_more(out, "\t// %s\n", e->type_def->name->content);
  

• }
• /* Render the operation */
• cond = (e->flags & ELEMENT_CONDITIONAL ||

• (tag && tag->flags & ELEMENT_CONDITIONAL)) ? "COND_" : "";
  

• act = e->action ? "_ACT" : "";
• switch (e->compound) {
• case ANY:

• render_opcode(out, "ASN1_OP_%sMATCH_ANY%s%s,",
  

• 	      cond, act, skippable ? "_OR_SKIP" : "");
  

• if (e->name)
  

• 	render_more(out, "\t\t// %s", e->name->content);
  

• render_more(out, "\n");
  

• goto dont_render_tag;
  

• case TAG_OVERRIDE:

• render_element(out, e->children, e);
  

• return;
  

• case SEQUENCE:
• case SEQUENCE_OF:
• case SET:
• case SET_OF:

• render_opcode(out, "ASN1_OP_%sMATCH%s%s,",
  

• 	      cond,
  

• 	      outofline ? "_JUMP" : "",
  

• 	      skippable ? "_OR_SKIP" : "");
  

• break;
  

• case CHOICE:

• goto dont_render_tag;
  

• case TYPE_REF:

• if (e->class == ASN1_UNIV && e->method == ASN1_PRIM && e->tag == 0)
  

• 	goto dont_render_tag;
  

• default:

• render_opcode(out, "ASN1_OP_%sMATCH%s%s,",
  

• 	      cond, act,
  

• 	      skippable ? "_OR_SKIP" : "");
  

• break;
  

• }
• x = tag ?: e;
• if (x->name)

• render_more(out, "\t\t// %s", x->name->content);
  

• render_more(out, "\n");
• /* Render the tag */
• if (!tag || !(tag->flags & ELEMENT_TAG_SPECIFIED))

• tag = e;
  

• if (tag->class == ASN1_UNIV &&

•    tag->tag != 14 &&
  

•    tag->tag != 15 &&
  

•    tag->tag != 31)
  

• render_opcode(out, "_tag(%s, %s, %s),\n",
  

• 	      asn1_classes[tag->class],
  

• 	      asn1_methods[tag->method | e->method],
  

• 	      asn1_universal_tags[tag->tag]);
  

• else

• render_opcode(out, "_tagn(%s, %s, %2u),\n",
  

• 	      asn1_classes[tag->class],
  

• 	      asn1_methods[tag->method | e->method],
  

• 	      tag->tag);
  

• tag = NULL;

+dont_render_tag:

• /* Deal with compound types */
• switch (e->compound) {
• case TYPE_REF:

• render_element(out, e->type->type->element, tag);
  

• if (e->action)
  

• 	render_opcode(out, "ASN1_OP_%sACT,\n",
  

• 		      skippable ? "MAYBE_" : "");
  

• break;
  

• case SEQUENCE:

• if (outofline) {
  

• 	/* Render out-of-line for multiple use or
  

• 	 * skipability */
  

• 	render_opcode(out, "_jump_target(%u),", e->entry_index);
  

• 	if (e->type_def && e->type_def->name)
  

• 		render_more(out, "\t\t// --> %s",
  

• 			    e->type_def->name->content);
  

• 	render_more(out, "\n");
  

• 	if (!(e->flags & ELEMENT_RENDERED)) {
  

• 		e->flags |= ELEMENT_RENDERED;
  

• 		*render_list_p = e;
  

• 		render_list_p = &e->render_next;
  

• 	}
  

• 	return;
  

• } else {
  

• 	/* Render inline for single use */
  

• 	render_depth++;
  

• 	for (ec = e->children; ec; ec = ec->next)
  

• 		render_element(out, ec, NULL);
  

• 	render_depth--;
  

• 	render_opcode(out, "ASN1_OP_END_SEQ%s,\n", act);
  

• }
  

• break;
  

• case SEQUENCE_OF:
• case SET_OF:

• if (outofline) {
  

• 	/* Render out-of-line for multiple use or
  

• 	 * skipability */
  

• 	render_opcode(out, "_jump_target(%u),", e->entry_index);
  

• 	if (e->type_def && e->type_def->name)
  

• 		render_more(out, "\t\t// --> %s",
  

• 			    e->type_def->name->content);
  

• 	render_more(out, "\n");
  

• 	if (!(e->flags & ELEMENT_RENDERED)) {
  

• 		e->flags |= ELEMENT_RENDERED;
  

• 		*render_list_p = e;
  

• 		render_list_p = &e->render_next;
  

• 	}
  

• 	return;
  

• } else {
  

• 	/* Render inline for single use */
  

• 	entry = nr_entries;
  

• 	render_depth++;
  

• 	render_element(out, e->children, NULL);
  

• 	render_depth--;
  

• 	if (e->compound == SEQUENCE_OF)
  

• 		render_opcode(out, "ASN1_OP_END_SEQ_OF%s,\n", act);
  

• 	else
  

• 		render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act);
  

• 	render_opcode(out, "_jump_target(%u),\n", entry);
  

• }
  

• break;
  

• case SET:

• /* I can't think of a nice way to do SET support without having
  

•  * a stack of bitmasks to make sure no element is repeated.
  

•  * The bitmask has also to be checked that no non-optional
  

•  * elements are left out whilst not preventing optional
  

•  * elements from being left out.
  

•  */
  

• fprintf(stderr, "The ASN.1 SET type is not currently supported.\n");
  

• exit(1);
  

• case CHOICE:

• for (ec = e->children; ec; ec = ec->next)
  

• 	render_element(out, ec, ec);
  

• if (!skippable)
  

• 	render_opcode(out, "ASN1_OP_COND_FAIL,\n");
  

• if (e->action)
  

• 	render_opcode(out, "ASN1_OP_ACT,\n");
  

• break;
  

• default:

• break;
  

• }
• if (e->action)

• render_opcode(out, "_action(ACT_%s),\n", e->action->name);
  

+}

On Sat, Oct 12, 2019 at 02:36:48PM +0200, Heinrich Schuchardt wrote:

On 10/11/19 9:41 AM, AKASHI Takahiro wrote:

...

This rule will be used to build x509 and pkcs7 parsers.

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

The ASN1 compiler is generating both *.asn.h and *.asn.c files.

Then I would expect that these files are deleted by `make mrproper'.

Please, adjust the clean: target in /Makefile accordingly.

Good catch, thank you.

-Takahiro Akashi

Best regards

Heinrich

...

---

scripts/Makefile.build | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/scripts/Makefile.build b/scripts/Makefile.build index f7a041296d3d..9357d310e50b 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -331,7 +331,7 @@ quiet_cmd_asn1_compiler = ASN.1 $@ cmd_asn1_compiler = $(objtree)/scripts/asn1_compiler $< \ $(subst .h,.c,$@) $(subst .c,.h,$@)

-$(obj)/%-asn1.c $(obj)/%-asn1.h: $(src)/%.asn1 $(objtree)/scripts/asn1_compiler +$(obj)/%.asn1.c $(obj)/%.asn1.h: $(src)/%.asn1 $(objtree)/scripts/asn1_compiler $(call cmd,asn1_compiler)

# Build the compiled-in targets @@ -419,9 +419,11 @@ targets += $(multi-used-y) $(multi-used-m) intermediate_targets = $(foreach sfx, $(2), \ $(patsubst %$(strip $(1)),%$(sfx), \ $(filter %$(strip $(1)), $(targets)))) +# %.asn1.o <- %.asn1.[ch] <- %.asn1 # %.lex.o <- %.lex.c <- %.l # %.tab.o <- %.tab.[ch] <- %.y -targets += $(call intermediate_targets, .lex.o, .lex.c) \ +targets += $(call intermediate_targets, .asn1.o, .asn1.c .asn1.h) \

•   $(call intermediate_targets, .lex.o, .lex.c) \
  $(call intermediate_targets, .tab.o, .tab.c .tab.h)
  
  

# Descending

On 10/11/19 9:41 AM, AKASHI Takahiro wrote:

Imported from linux kernel v5.3.

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org

lib/Kconfig | 6 + lib/Makefile | 1 + lib/asn1_decoder.c | 527 +++++++++++++++++++++++++++++++++++++++++++++

Except for adjustments of include files lib/asn1_decoder.c is a verbatime copy of the Linux kernel file. OK.

3 files changed, 534 insertions(+) create mode 100644 lib/asn1_decoder.c

diff --git a/lib/Kconfig b/lib/Kconfig index 3da45a5ec322..26c94f49ecd2 100644 --- a/lib/Kconfig +++ b/lib/Kconfig @@ -521,6 +521,12 @@ config SMBIOS_PRODUCT_NAME

endmenu

+config ASN1

• bool
• select BUILD_ASN1

BUILD_ASN1 does not really fit into cmd/Kconfig.

Should we move it here?

Why do we need two separate flags ASN1 and BUILD_ASN1?

Best regards

Heinrich

• help

•  Enable asn1 decoder library.
  

• source lib/efi/Kconfig source lib/efi_loader/Kconfig source lib/optee/Kconfig

diff --git a/lib/Makefile b/lib/Makefile index 2fffd68f943c..eb3a675fb8c2 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -17,6 +17,7 @@ obj-$(CONFIG_OF_LIVE) += of_live.o obj-$(CONFIG_CMD_DHRYSTONE) += dhry/ obj-$(CONFIG_ARCH_AT91) += at91/ obj-$(CONFIG_OPTEE) += optee/ +obj-$(CONFIG_BUILD_ASN1) += asn1_decoder.o

obj-$(CONFIG_AES) += aes.o

diff --git a/lib/asn1_decoder.c b/lib/asn1_decoder.c new file mode 100644 index 000000000000..db222625dd0f --- /dev/null +++ b/lib/asn1_decoder.c @@ -0,0 +1,527 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* Decoder for ASN.1 BER/DER/CER encoded bytestream

• • Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
• • Written by David Howells (dhowells@redhat.com)
• */

+#ifdef __UBOOT__ +#include <linux/compat.h> +#else +#include <linux/export.h> +#endif +#include <linux/kernel.h> +#include <linux/errno.h> +#ifndef __UBOOT__ +#include <linux/module.h> +#endif +#include <linux/asn1_decoder.h> +#include <linux/asn1_ber_bytecode.h>

+static const unsigned char asn1_op_lengths[ASN1_OP__NR] = {

• /* OPC TAG JMP ACT */
• [ASN1_OP_MATCH] = 1 + 1,
• [ASN1_OP_MATCH_OR_SKIP] = 1 + 1,
• [ASN1_OP_MATCH_ACT] = 1 + 1 + 1,
• [ASN1_OP_MATCH_ACT_OR_SKIP] = 1 + 1 + 1,
• [ASN1_OP_MATCH_JUMP] = 1 + 1 + 1,
• [ASN1_OP_MATCH_JUMP_OR_SKIP] = 1 + 1 + 1,
• [ASN1_OP_MATCH_ANY] = 1,
• [ASN1_OP_MATCH_ANY_OR_SKIP] = 1,
• [ASN1_OP_MATCH_ANY_ACT] = 1 + 1,
• [ASN1_OP_MATCH_ANY_ACT_OR_SKIP] = 1 + 1,
• [ASN1_OP_COND_MATCH_OR_SKIP] = 1 + 1,
• [ASN1_OP_COND_MATCH_ACT_OR_SKIP] = 1 + 1 + 1,
• [ASN1_OP_COND_MATCH_JUMP_OR_SKIP] = 1 + 1 + 1,
• [ASN1_OP_COND_MATCH_ANY] = 1,
• [ASN1_OP_COND_MATCH_ANY_OR_SKIP] = 1,
• [ASN1_OP_COND_MATCH_ANY_ACT] = 1 + 1,
• [ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP] = 1 + 1,
• [ASN1_OP_COND_FAIL] = 1,
• [ASN1_OP_COMPLETE] = 1,
• [ASN1_OP_ACT] = 1 + 1,
• [ASN1_OP_MAYBE_ACT] = 1 + 1,
• [ASN1_OP_RETURN] = 1,
• [ASN1_OP_END_SEQ] = 1,
• [ASN1_OP_END_SEQ_OF] = 1 + 1,
• [ASN1_OP_END_SET] = 1,
• [ASN1_OP_END_SET_OF] = 1 + 1,
• [ASN1_OP_END_SEQ_ACT] = 1 + 1,
• [ASN1_OP_END_SEQ_OF_ACT] = 1 + 1 + 1,
• [ASN1_OP_END_SET_ACT] = 1 + 1,
• [ASN1_OP_END_SET_OF_ACT] = 1 + 1 + 1,

+};

+/*

• • Find the length of an indefinite length object
• • @data: The data buffer
• • @datalen: The end of the innermost containing element in the buffer
• • @_dp: The data parse cursor (updated before returning)
• • @_len: Where to return the size of the element.
• • @_errmsg: Where to return a pointer to an error message on error
• */

+static int asn1_find_indefinite_length(const unsigned char *data, size_t datalen,

• 		       size_t *_dp, size_t *_len,
  

• 		       const char **_errmsg)
  

+{

• unsigned char tag, tmp;
• size_t dp = *_dp, len, n;
• int indef_level = 1;

+next_tag:

• if (unlikely(datalen - dp < 2)) {

• if (datalen == dp)
  

• 	goto missing_eoc;
  

• goto data_overrun_error;
  

• }
• /* Extract a tag from the data */
• tag = data[dp++];
• if (tag == ASN1_EOC) {

• /* It appears to be an EOC. */
  

• if (data[dp++] != 0)
  

• 	goto invalid_eoc;
  

• if (--indef_level <= 0) {
  

• 	*_len = dp - *_dp;
  

• 	*_dp = dp;
  

• 	return 0;
  

• }
  

• goto next_tag;
  

• }
• if (unlikely((tag & 0x1f) == ASN1_LONG_TAG)) {

• do {
  

• 	if (unlikely(datalen - dp < 2))
  

• 		goto data_overrun_error;
  

• 	tmp = data[dp++];
  

• } while (tmp & 0x80);
  

• }
• /* Extract the length */
• len = data[dp++];
• if (len <= 0x7f)

• goto check_length;
  

• if (unlikely(len == ASN1_INDEFINITE_LENGTH)) {

• /* Indefinite length */
  

• if (unlikely((tag & ASN1_CONS_BIT) == ASN1_PRIM << 5))
  

• 	goto indefinite_len_primitive;
  

• indef_level++;
  

• goto next_tag;
  

• }
• n = len - 0x80;
• if (unlikely(n > sizeof(len) - 1))

• goto length_too_long;
  

• if (unlikely(n > datalen - dp))

• goto data_overrun_error;
  

• len = 0;
• for (; n > 0; n--) {

• len <<= 8;
  

• len |= data[dp++];
  

• }

+check_length:

• if (len > datalen - dp)

• goto data_overrun_error;
  

• dp += len;
• goto next_tag;

+length_too_long:

• *_errmsg = "Unsupported length";
• goto error;

+indefinite_len_primitive:

• *_errmsg = "Indefinite len primitive not permitted";
• goto error;

+invalid_eoc:

• *_errmsg = "Invalid length EOC";
• goto error;

+data_overrun_error:

• *_errmsg = "Data overrun error";
• goto error;

+missing_eoc:

• *_errmsg = "Missing EOC in indefinite len cons";

+error:

• *_dp = dp;
• return -1;

+}

+/**

• • asn1_ber_decoder - Decoder BER/DER/CER ASN.1 according to pattern
• • @decoder: The decoder definition (produced by asn1_compiler)
• • @context: The caller's context (to be passed to the action functions)
• • @data: The encoded data
• • @datalen: The size of the encoded data
• • Decode BER/DER/CER encoded ASN.1 data according to a bytecode pattern
• • produced by asn1_compiler. Action functions are called on marked tags to
• • allow the caller to retrieve significant data.
• • LIMITATIONS:
• • To keep down the amount of stack used by this function, the following limits
• • have been imposed:
• • (1) This won't handle datalen > 65535 without increasing the size of the
• • cons stack elements and length_too_long checking.
• • (2) The stack of constructed types is 10 deep. If the depth of non-leaf
• • constructed types exceeds this, the decode will fail.
• • (3) The SET type (not the SET OF type) isn't really supported as tracking
• • what members of the set have been seen is a pain.
• */

+int asn1_ber_decoder(const struct asn1_decoder *decoder,

•      void *context,
  

•      const unsigned char *data,
  

•      size_t datalen)
  

+{

• const unsigned char *machine = decoder->machine;
• const asn1_action_t *actions = decoder->actions;
• size_t machlen = decoder->machlen;
• enum asn1_opcode op;
• unsigned char tag = 0, csp = 0, jsp = 0, optag = 0, hdr = 0;
• const char *errmsg;
• size_t pc = 0, dp = 0, tdp = 0, len = 0;
• int ret;
• unsigned char flags = 0;

+#define FLAG_INDEFINITE_LENGTH 0x01 +#define FLAG_MATCHED 0x02 +#define FLAG_LAST_MATCHED 0x04 /* Last tag matched */ +#define FLAG_CONS 0x20 /* Corresponds to CONS bit in the opcode tag

• 		      * - ie. whether or not we are going to parse
  

• 		      *   a compound type.
  

• 		      */
  

+#define NR_CONS_STACK 10

• unsigned short cons_dp_stack[NR_CONS_STACK];
• unsigned short cons_datalen_stack[NR_CONS_STACK];
• unsigned char cons_hdrlen_stack[NR_CONS_STACK];

+#define NR_JUMP_STACK 10

• unsigned char jump_stack[NR_JUMP_STACK];
• if (datalen > 65535)

• return -EMSGSIZE;
  

+next_op:

• pr_debug("next_op: pc=\e[32m%zu\e[m/%zu dp=\e[33m%zu\e[m/%zu C=%d J=%d\n",

•  pc, machlen, dp, datalen, csp, jsp);
  

• if (unlikely(pc >= machlen))

• goto machine_overrun_error;
  

• op = machine[pc];
• if (unlikely(pc + asn1_op_lengths[op] > machlen))

• goto machine_overrun_error;
  

• /* If this command is meant to match a tag, then do that before

• * evaluating the command.
  

• */
  

• if (op <= ASN1_OP__MATCHES_TAG) {

• unsigned char tmp;
  

• /* Skip conditional matches if possible */
  

• if ((op & ASN1_OP_MATCH__COND && flags & FLAG_MATCHED) ||
  

•     (op & ASN1_OP_MATCH__SKIP && dp == datalen)) {
  

• 	flags &= ~FLAG_LAST_MATCHED;
  

• 	pc += asn1_op_lengths[op];
  

• 	goto next_op;
  

• }
  

• flags = 0;
  

• hdr = 2;
  

• /* Extract a tag from the data */
  

• if (unlikely(datalen - dp < 2))
  

• 	goto data_overrun_error;
  

• tag = data[dp++];
  

• if (unlikely((tag & 0x1f) == ASN1_LONG_TAG))
  

• 	goto long_tag_not_supported;
  

• if (op & ASN1_OP_MATCH__ANY) {
  

• 	pr_debug("- any %02x\n", tag);
  

• } else {
  

• 	/* Extract the tag from the machine
  

• 	 * - Either CONS or PRIM are permitted in the data if
  

• 	 *   CONS is not set in the op stream, otherwise CONS
  

• 	 *   is mandatory.
  

• 	 */
  

• 	optag = machine[pc + 1];
  

• 	flags |= optag & FLAG_CONS;
  

• 	/* Determine whether the tag matched */
  

• 	tmp = optag ^ tag;
  

• 	tmp &= ~(optag & ASN1_CONS_BIT);
  

• 	pr_debug("- match? %02x %02x %02x\n", tag, optag, tmp);
  

• 	if (tmp != 0) {
  

• 		/* All odd-numbered tags are MATCH_OR_SKIP. */
  

• 		if (op & ASN1_OP_MATCH__SKIP) {
  

• 			pc += asn1_op_lengths[op];
  

• 			dp--;
  

• 			goto next_op;
  

• 		}
  

• 		goto tag_mismatch;
  

• 	}
  

• }
  

• flags |= FLAG_MATCHED;
  

• len = data[dp++];
  

• if (len > 0x7f) {
  

• 	if (unlikely(len == ASN1_INDEFINITE_LENGTH)) {
  

• 		/* Indefinite length */
  

• 		if (unlikely(!(tag & ASN1_CONS_BIT)))
  

• 			goto indefinite_len_primitive;
  

• 		flags |= FLAG_INDEFINITE_LENGTH;
  

• 		if (unlikely(2 > datalen - dp))
  

• 			goto data_overrun_error;
  

• 	} else {
  

• 		int n = len - 0x80;
  

• 		if (unlikely(n > 2))
  

• 			goto length_too_long;
  

• 		if (unlikely(n > datalen - dp))
  

• 			goto data_overrun_error;
  

• 		hdr += n;
  

• 		for (len = 0; n > 0; n--) {
  

• 			len <<= 8;
  

• 			len |= data[dp++];
  

• 		}
  

• 		if (unlikely(len > datalen - dp))
  

• 			goto data_overrun_error;
  

• 	}
  

• } else {
  

• 	if (unlikely(len > datalen - dp))
  

• 		goto data_overrun_error;
  

• }
  

• if (flags & FLAG_CONS) {
  

• 	/* For expected compound forms, we stack the positions
  

• 	 * of the start and end of the data.
  

• 	 */
  

• 	if (unlikely(csp >= NR_CONS_STACK))
  

• 		goto cons_stack_overflow;
  

• 	cons_dp_stack[csp] = dp;
  

• 	cons_hdrlen_stack[csp] = hdr;
  

• 	if (!(flags & FLAG_INDEFINITE_LENGTH)) {
  

• 		cons_datalen_stack[csp] = datalen;
  

• 		datalen = dp + len;
  

• 	} else {
  

• 		cons_datalen_stack[csp] = 0;
  

• 	}
  

• 	csp++;
  

• }
  

• pr_debug("- TAG: %02x %zu%s\n",
  

• 	 tag, len, flags & FLAG_CONS ? " CONS" : "");
  

• tdp = dp;
  

• }
• /* Decide how to handle the operation */
• switch (op) {
• case ASN1_OP_MATCH:
• case ASN1_OP_MATCH_OR_SKIP:
• case ASN1_OP_MATCH_ACT:
• case ASN1_OP_MATCH_ACT_OR_SKIP:
• case ASN1_OP_MATCH_ANY:
• case ASN1_OP_MATCH_ANY_OR_SKIP:
• case ASN1_OP_MATCH_ANY_ACT:
• case ASN1_OP_MATCH_ANY_ACT_OR_SKIP:
• case ASN1_OP_COND_MATCH_OR_SKIP:
• case ASN1_OP_COND_MATCH_ACT_OR_SKIP:
• case ASN1_OP_COND_MATCH_ANY:
• case ASN1_OP_COND_MATCH_ANY_OR_SKIP:
• case ASN1_OP_COND_MATCH_ANY_ACT:
• case ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP:

• if (!(flags & FLAG_CONS)) {
  

• 	if (flags & FLAG_INDEFINITE_LENGTH) {
  

• 		size_t tmp = dp;
  

• 		ret = asn1_find_indefinite_length(
  

• 			data, datalen, &tmp, &len, &errmsg);
  

• 		if (ret < 0)
  

• 			goto error;
  

• 	}
  

• 	pr_debug("- LEAF: %zu\n", len);
  

• }
  

• if (op & ASN1_OP_MATCH__ACT) {
  

• 	unsigned char act;
  

• 	if (op & ASN1_OP_MATCH__ANY)
  

• 		act = machine[pc + 1];
  

• 	else
  

• 		act = machine[pc + 2];
  

• 	ret = actions[act](context, hdr, tag, data + dp, len);
  

• 	if (ret < 0)
  

• 		return ret;
  

• }
  

• if (!(flags & FLAG_CONS))
  

• 	dp += len;
  

• pc += asn1_op_lengths[op];
  

• goto next_op;
  

• case ASN1_OP_MATCH_JUMP:
• case ASN1_OP_MATCH_JUMP_OR_SKIP:
• case ASN1_OP_COND_MATCH_JUMP_OR_SKIP:

• pr_debug("- MATCH_JUMP\n");
  

• if (unlikely(jsp == NR_JUMP_STACK))
  

• 	goto jump_stack_overflow;
  

• jump_stack[jsp++] = pc + asn1_op_lengths[op];
  

• pc = machine[pc + 2];
  

• goto next_op;
  

• case ASN1_OP_COND_FAIL:

• if (unlikely(!(flags & FLAG_MATCHED)))
  

• 	goto tag_mismatch;
  

• pc += asn1_op_lengths[op];
  

• goto next_op;
  

• case ASN1_OP_COMPLETE:

• if (unlikely(jsp != 0 || csp != 0)) {
  

• 	pr_err("ASN.1 decoder error: Stacks not empty at completion (%u, %u)\n",
  

• 	       jsp, csp);
  

• 	return -EBADMSG;
  

• }
  

• return 0;
  

• case ASN1_OP_END_SET:
• case ASN1_OP_END_SET_ACT:

• if (unlikely(!(flags & FLAG_MATCHED)))
  

• 	goto tag_mismatch;
  

• /* fall through */
  

• case ASN1_OP_END_SEQ:
• case ASN1_OP_END_SET_OF:
• case ASN1_OP_END_SEQ_OF:
• case ASN1_OP_END_SEQ_ACT:
• case ASN1_OP_END_SET_OF_ACT:
• case ASN1_OP_END_SEQ_OF_ACT:

• if (unlikely(csp <= 0))
  

• 	goto cons_stack_underflow;
  

• csp--;
  

• tdp = cons_dp_stack[csp];
  

• hdr = cons_hdrlen_stack[csp];
  

• len = datalen;
  

• datalen = cons_datalen_stack[csp];
  

• pr_debug("- end cons t=%zu dp=%zu l=%zu/%zu\n",
  

• 	 tdp, dp, len, datalen);
  

• if (datalen == 0) {
  

• 	/* Indefinite length - check for the EOC. */
  

• 	datalen = len;
  

• 	if (unlikely(datalen - dp < 2))
  

• 		goto data_overrun_error;
  

• 	if (data[dp++] != 0) {
  

• 		if (op & ASN1_OP_END__OF) {
  

• 			dp--;
  

• 			csp++;
  

• 			pc = machine[pc + 1];
  

• 			pr_debug("- continue\n");
  

• 			goto next_op;
  

• 		}
  

• 		goto missing_eoc;
  

• 	}
  

• 	if (data[dp++] != 0)
  

• 		goto invalid_eoc;
  

• 	len = dp - tdp - 2;
  

• } else {
  

• 	if (dp < len && (op & ASN1_OP_END__OF)) {
  

• 		datalen = len;
  

• 		csp++;
  

• 		pc = machine[pc + 1];
  

• 		pr_debug("- continue\n");
  

• 		goto next_op;
  

• 	}
  

• 	if (dp != len)
  

• 		goto cons_length_error;
  

• 	len -= tdp;
  

• 	pr_debug("- cons len l=%zu d=%zu\n", len, dp - tdp);
  

• }
  

• if (op & ASN1_OP_END__ACT) {
  

• 	unsigned char act;
  

• 	if (op & ASN1_OP_END__OF)
  

• 		act = machine[pc + 2];
  

• 	else
  

• 		act = machine[pc + 1];
  

• 	ret = actions[act](context, hdr, 0, data + tdp, len);
  

• 	if (ret < 0)
  

• 		return ret;
  

• }
  

• pc += asn1_op_lengths[op];
  

• goto next_op;
  

• case ASN1_OP_MAYBE_ACT:

• if (!(flags & FLAG_LAST_MATCHED)) {
  

• 	pc += asn1_op_lengths[op];
  

• 	goto next_op;
  

• }
  

• /* fall through */
  

• case ASN1_OP_ACT:

• ret = actions[machine[pc + 1]](context, hdr, tag, data + tdp, len);
  

• if (ret < 0)
  

• 	return ret;
  

• pc += asn1_op_lengths[op];
  

• goto next_op;
  

• case ASN1_OP_RETURN:

• if (unlikely(jsp <= 0))
  

• 	goto jump_stack_underflow;
  

• pc = jump_stack[--jsp];
  

• flags |= FLAG_MATCHED | FLAG_LAST_MATCHED;
  

• goto next_op;
  

• default:

• break;
  

• }
• /* Shouldn't reach here */
• pr_err("ASN.1 decoder error: Found reserved opcode (%u) pc=%zu\n",

•       op, pc);
  

• return -EBADMSG;

+data_overrun_error:

• errmsg = "Data overrun error";
• goto error;

+machine_overrun_error:

• errmsg = "Machine overrun error";
• goto error;

+jump_stack_underflow:

• errmsg = "Jump stack underflow";
• goto error;

+jump_stack_overflow:

• errmsg = "Jump stack overflow";
• goto error;

+cons_stack_underflow:

• errmsg = "Cons stack underflow";
• goto error;

+cons_stack_overflow:

• errmsg = "Cons stack overflow";
• goto error;

+cons_length_error:

• errmsg = "Cons length error";
• goto error;

+missing_eoc:

• errmsg = "Missing EOC in indefinite len cons";
• goto error;

+invalid_eoc:

• errmsg = "Invalid length EOC";
• goto error;

+length_too_long:

• errmsg = "Unsupported length";
• goto error;

+indefinite_len_primitive:

• errmsg = "Indefinite len primitive not permitted";
• goto error;

+tag_mismatch:

• errmsg = "Unexpected tag";
• goto error;

+long_tag_not_supported:

• errmsg = "Long tag not supported";

+error:

• pr_debug("\nASN1: %s [m=%zu d=%zu ot=%02x t=%02x l=%zu]\n",

•  errmsg, pc, dp, optag, tag, len);
  

• return -EBADMSG;

+} +EXPORT_SYMBOL_GPL(asn1_ber_decoder);

+MODULE_LICENSE("GPL");