Use a compiler to marshall/unmarshall the sessions
authorSimo Sorce <simo@redhat.com>
Tue, 9 Jun 2015 17:30:57 +0000 (13:30 -0400)
committerSimo Sorce <simo@redhat.com>
Tue, 9 Jun 2015 21:53:34 +0000 (17:53 -0400)
This way changes are easier, all is needed is to change the session.asn1
file to add or remove elements, and different session types can also be
supported at the same time.

55 files changed:
.gitignore
Makefile.am
configure.ac
src/Makefile.am
src/asn1c/BIT_STRING.c [new file with mode: 0644]
src/asn1c/BIT_STRING.h [new file with mode: 0644]
src/asn1c/GSSSessionData.c [new file with mode: 0644]
src/asn1c/GSSSessionData.h [new file with mode: 0644]
src/asn1c/INTEGER.c [new file with mode: 0644]
src/asn1c/INTEGER.h [new file with mode: 0644]
src/asn1c/Makefile.am [new file with mode: 0644]
src/asn1c/NativeEnumerated.c [new file with mode: 0644]
src/asn1c/NativeEnumerated.h [new file with mode: 0644]
src/asn1c/NativeInteger.c [new file with mode: 0644]
src/asn1c/NativeInteger.h [new file with mode: 0644]
src/asn1c/OCTET_STRING.c [new file with mode: 0644]
src/asn1c/OCTET_STRING.h [new file with mode: 0644]
src/asn1c/Uint32.c [new file with mode: 0644]
src/asn1c/Uint32.h [new file with mode: 0644]
src/asn1c/asn_application.h [new file with mode: 0644]
src/asn1c/asn_codecs.h [new file with mode: 0644]
src/asn1c/asn_codecs_prim.c [new file with mode: 0644]
src/asn1c/asn_codecs_prim.h [new file with mode: 0644]
src/asn1c/asn_internal.h [new file with mode: 0644]
src/asn1c/asn_system.h [new file with mode: 0644]
src/asn1c/ber_decoder.c [new file with mode: 0644]
src/asn1c/ber_decoder.h [new file with mode: 0644]
src/asn1c/ber_tlv_length.c [new file with mode: 0644]
src/asn1c/ber_tlv_length.h [new file with mode: 0644]
src/asn1c/ber_tlv_tag.c [new file with mode: 0644]
src/asn1c/ber_tlv_tag.h [new file with mode: 0644]
src/asn1c/constr_SEQUENCE.c [new file with mode: 0644]
src/asn1c/constr_SEQUENCE.h [new file with mode: 0644]
src/asn1c/constr_TYPE.c [new file with mode: 0644]
src/asn1c/constr_TYPE.h [new file with mode: 0644]
src/asn1c/constraints.c [new file with mode: 0644]
src/asn1c/constraints.h [new file with mode: 0644]
src/asn1c/der_encoder.c [new file with mode: 0644]
src/asn1c/der_encoder.h [new file with mode: 0644]
src/asn1c/per_decoder.c [new file with mode: 0644]
src/asn1c/per_decoder.h [new file with mode: 0644]
src/asn1c/per_encoder.c [new file with mode: 0644]
src/asn1c/per_encoder.h [new file with mode: 0644]
src/asn1c/per_opentype.c [new file with mode: 0644]
src/asn1c/per_opentype.h [new file with mode: 0644]
src/asn1c/per_support.c [new file with mode: 0644]
src/asn1c/per_support.h [new file with mode: 0644]
src/asn1c/session.asn1 [new file with mode: 0644]
src/asn1c/xer_decoder.c [new file with mode: 0644]
src/asn1c/xer_decoder.h [new file with mode: 0644]
src/asn1c/xer_encoder.c [new file with mode: 0644]
src/asn1c/xer_encoder.h [new file with mode: 0644]
src/asn1c/xer_support.c [new file with mode: 0644]
src/asn1c/xer_support.h [new file with mode: 0644]
src/sessions.c

index 27a8cf3..c7b7689 100644 (file)
@@ -1,24 +1,25 @@
-/Makefile
-/Makefile.in
-/aclocal.m4
-/ar-lib
-/autom4te.cache
-/compile
-/config.guess
-/config.log
-/config.status
-/config.sub
-/configure
-/depcomp
-/install-sh
-/libtool
-/ltmain.sh
-/m4/
-/missing
-/src/.deps
-/src/.libs
-/src/Makefile
-/src/Makefile.in
-/src/config.h
-/src/config.h.in
-/src/stamp-h1
+Makefile
+Makefile.in
+aclocal.m4
+ar-lib
+autom4te.cache
+compile
+config.guess
+config.log
+config.status
+config.sub
+configure
+depcomp
+install-sh
+libtool
+ltmain.sh
+m4/
+missing
+.deps
+.libs
+config.h
+config.h.in*
+stamp-h1
+*.o
+*.lo
+*.la
index f8238b2..71b4abd 100644 (file)
@@ -1,3 +1,3 @@
 ACLOCAL_AMFLAGS = -I m4
 
-SUBDIRS = src
+SUBDIRS = src/asn1c src
index b1e13d0..9013e8c 100644 (file)
@@ -82,6 +82,6 @@ AC_SUBST([MAG_LIBS])
 AC_SUBST([LIBTOOL])
 AC_SUBST([MAG_LIBDIR])
 
-AC_CONFIG_FILES([Makefile src/Makefile])
+AC_CONFIG_FILES([Makefile src/Makefile src/asn1c/Makefile])
 
 AC_OUTPUT
index e2b0148..34bb442 100644 (file)
@@ -1,3 +1,5 @@
+AM_CPPFLAGS = -Iasn1c
+
 magdir = $(MAG_LIBDIR)
 mag_LTLIBRARIES = \
     mod_auth_gssapi.la
@@ -9,6 +11,8 @@ mod_auth_gssapi_la_SOURCES = \
     mod_auth_gssapi.c crypto.c sessions.c
 mod_auth_gssapi_la_CFLAGS = \
     $(MAG_CFLAGS)
+mod_auth_gssapi_la_LIBADD = \
+    asn1c/libmagasn1.la
 mod_auth_gssapi_la_LDFLAGS = \
     $(MAG_LIBS) \
     -avoid-version \
diff --git a/src/asn1c/BIT_STRING.c b/src/asn1c/BIT_STRING.c
new file mode 100644 (file)
index 0000000..9b98271
--- /dev/null
@@ -0,0 +1,189 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <BIT_STRING.h>
+#include <asn_internal.h>
+
+/*
+ * BIT STRING basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
+       (ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = {
+       sizeof(BIT_STRING_t),
+       offsetof(BIT_STRING_t, _asn_ctx),
+       ASN_OSUBV_BIT
+};
+asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
+       "BIT STRING",
+       "BIT_STRING",
+       OCTET_STRING_free,         /* Implemented in terms of OCTET STRING */
+       BIT_STRING_print,
+       BIT_STRING_constraint,
+       OCTET_STRING_decode_ber,   /* Implemented in terms of OCTET STRING */
+       OCTET_STRING_encode_der,   /* Implemented in terms of OCTET STRING */
+       OCTET_STRING_decode_xer_binary,
+       BIT_STRING_encode_xer,
+       OCTET_STRING_decode_uper,       /* Unaligned PER decoder */
+       OCTET_STRING_encode_uper,       /* Unaligned PER encoder */
+       0, /* Use generic outmost tag fetcher */
+       asn_DEF_BIT_STRING_tags,
+       sizeof(asn_DEF_BIT_STRING_tags)
+         / sizeof(asn_DEF_BIT_STRING_tags[0]),
+       asn_DEF_BIT_STRING_tags,        /* Same as above */
+       sizeof(asn_DEF_BIT_STRING_tags)
+         / sizeof(asn_DEF_BIT_STRING_tags[0]),
+       0,      /* No PER visible constraints */
+       0, 0,   /* No members */
+       &asn_DEF_BIT_STRING_specs
+};
+
+/*
+ * BIT STRING generic constraint.
+ */
+int
+BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+               asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+       const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+
+       if(st && st->buf) {
+               if((st->size == 0 && st->bits_unused)
+               || st->bits_unused < 0 || st->bits_unused > 7) {
+                       _ASN_CTFAIL(app_key, td, sptr,
+                               "%s: invalid padding byte (%s:%d)",
+                               td->name, __FILE__, __LINE__);
+                       return -1;
+               }
+       } else {
+               _ASN_CTFAIL(app_key, td, sptr,
+                       "%s: value not given (%s:%d)",
+                       td->name, __FILE__, __LINE__);
+               return -1;
+       }
+
+       return 0;
+}
+
+static char *_bit_pattern[16] = {
+       "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
+       "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
+};
+
+asn_enc_rval_t
+BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+       int ilevel, enum xer_encoder_flags_e flags,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       asn_enc_rval_t er;
+       char scratch[128];
+       char *p = scratch;
+       char *scend = scratch + (sizeof(scratch) - 10);
+       const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+       int xcan = (flags & XER_F_CANONICAL);
+       uint8_t *buf;
+       uint8_t *end;
+
+       if(!st || !st->buf)
+               _ASN_ENCODE_FAILED;
+
+       er.encoded = 0;
+
+       buf = st->buf;
+       end = buf + st->size - 1;       /* Last byte is special */
+
+       /*
+        * Binary dump
+        */
+       for(; buf < end; buf++) {
+               int v = *buf;
+               int nline = xcan?0:(((buf - st->buf) % 8) == 0);
+               if(p >= scend || nline) {
+                       er.encoded += p - scratch;
+                       _ASN_CALLBACK(scratch, p - scratch);
+                       p = scratch;
+                       if(nline) _i_ASN_TEXT_INDENT(1, ilevel);
+               }
+               memcpy(p + 0, _bit_pattern[v >> 4], 4);
+               memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
+               p += 8;
+       }
+
+       if(!xcan && ((buf - st->buf) % 8) == 0)
+               _i_ASN_TEXT_INDENT(1, ilevel);
+       er.encoded += p - scratch;
+       _ASN_CALLBACK(scratch, p - scratch);
+       p = scratch;
+
+       if(buf == end) {
+               int v = *buf;
+               int ubits = st->bits_unused;
+               int i;
+               for(i = 7; i >= ubits; i--)
+                       *p++ = (v & (1 << i)) ? 0x31 : 0x30;
+               er.encoded += p - scratch;
+               _ASN_CALLBACK(scratch, p - scratch);
+       }
+
+       if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1);
+
+       _ASN_ENCODED_OK(er);
+cb_failed:
+       _ASN_ENCODE_FAILED;
+}
+
+
+/*
+ * BIT STRING specific contents printer.
+ */
+int
+BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       static const char *h2c = "0123456789ABCDEF";
+       char scratch[64];
+       const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+       uint8_t *buf;
+       uint8_t *end;
+       char *p = scratch;
+
+       (void)td;       /* Unused argument */
+
+       if(!st || !st->buf)
+               return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+
+       ilevel++;
+       buf = st->buf;
+       end = buf + st->size;
+
+       /*
+        * Hexadecimal dump.
+        */
+       for(; buf < end; buf++) {
+               if((buf - st->buf) % 16 == 0 && (st->size > 16)
+                               && buf != st->buf) {
+                       _i_INDENT(1);
+                       /* Dump the string */
+                       if(cb(scratch, p - scratch, app_key) < 0) return -1;
+                       p = scratch;
+               }
+               *p++ = h2c[*buf >> 4];
+               *p++ = h2c[*buf & 0x0F];
+               *p++ = 0x20;
+       }
+
+       if(p > scratch) {
+               p--;    /* Eat the tailing space */
+
+               if((st->size > 16)) {
+                       _i_INDENT(1);
+               }
+
+               /* Dump the incomplete 16-bytes row */
+               if(cb(scratch, p - scratch, app_key) < 0)
+                       return -1;
+       }
+
+       return 0;
+}
+
diff --git a/src/asn1c/BIT_STRING.h b/src/asn1c/BIT_STRING.h
new file mode 100644 (file)
index 0000000..732e878
--- /dev/null
@@ -0,0 +1,33 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        _BIT_STRING_H_
+#define        _BIT_STRING_H_
+
+#include <OCTET_STRING.h>      /* Some help from OCTET STRING */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct BIT_STRING_s {
+       uint8_t *buf;   /* BIT STRING body */
+       int size;       /* Size of the above buffer */
+
+       int bits_unused;/* Unused trailing bits in the last octet (0..7) */
+
+       asn_struct_ctx_t _asn_ctx;      /* Parsing across buffer boundaries */
+} BIT_STRING_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
+
+asn_struct_print_f BIT_STRING_print;   /* Human-readable output */
+asn_constr_check_f BIT_STRING_constraint;
+xer_type_encoder_f BIT_STRING_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _BIT_STRING_H_ */
diff --git a/src/asn1c/GSSSessionData.c b/src/asn1c/GSSSessionData.c
new file mode 100644 (file)
index 0000000..5c8ec17
--- /dev/null
@@ -0,0 +1,79 @@
+/*
+ * Generated by asn1c-0.9.27 (http://lionet.info/asn1c)
+ * From ASN.1 module "GssapiSessionModule"
+ *     found in "session.asn1"
+ *     `asn1c -fskeletons-copy`
+ */
+
+#include "GSSSessionData.h"
+
+static asn_TYPE_member_t asn_MBR_GSSSessionData_1[] = {
+       { ATF_NOFLAGS, 0, offsetof(struct GSSSessionData, expiration),
+               (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+               +1,     /* EXPLICIT tag at current level */
+               &asn_DEF_Uint32,
+               0,      /* Defer constraints checking to the member type */
+               0,      /* PER is not compiled, use -gen-PER */
+               0,
+               "expiration"
+               },
+       { ATF_NOFLAGS, 0, offsetof(struct GSSSessionData, username),
+               (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+               +1,     /* EXPLICIT tag at current level */
+               &asn_DEF_OCTET_STRING,
+               0,      /* Defer constraints checking to the member type */
+               0,      /* PER is not compiled, use -gen-PER */
+               0,
+               "username"
+               },
+       { ATF_NOFLAGS, 0, offsetof(struct GSSSessionData, gssname),
+               (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+               +1,     /* EXPLICIT tag at current level */
+               &asn_DEF_OCTET_STRING,
+               0,      /* Defer constraints checking to the member type */
+               0,      /* PER is not compiled, use -gen-PER */
+               0,
+               "gssname"
+               },
+};
+static ber_tlv_tag_t asn_DEF_GSSSessionData_tags_1[] = {
+       (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_GSSSessionData_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* expiration */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* username */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* gssname */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_GSSSessionData_specs_1 = {
+       sizeof(struct GSSSessionData),
+       offsetof(struct GSSSessionData, _asn_ctx),
+       asn_MAP_GSSSessionData_tag2el_1,
+       3,      /* Count of tags in the map */
+       0, 0, 0,        /* Optional elements (not needed) */
+       -1,     /* Start extensions */
+       -1      /* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_GSSSessionData = {
+       "GSSSessionData",
+       "GSSSessionData",
+       SEQUENCE_free,
+       SEQUENCE_print,
+       SEQUENCE_constraint,
+       SEQUENCE_decode_ber,
+       SEQUENCE_encode_der,
+       SEQUENCE_decode_xer,
+       SEQUENCE_encode_xer,
+       0, 0,   /* No PER support, use "-gen-PER" to enable */
+       0,      /* Use generic outmost tag fetcher */
+       asn_DEF_GSSSessionData_tags_1,
+       sizeof(asn_DEF_GSSSessionData_tags_1)
+               /sizeof(asn_DEF_GSSSessionData_tags_1[0]), /* 1 */
+       asn_DEF_GSSSessionData_tags_1,  /* Same as above */
+       sizeof(asn_DEF_GSSSessionData_tags_1)
+               /sizeof(asn_DEF_GSSSessionData_tags_1[0]), /* 1 */
+       0,      /* No PER visible constraints */
+       asn_MBR_GSSSessionData_1,
+       3,      /* Elements count */
+       &asn_SPC_GSSSessionData_specs_1 /* Additional specs */
+};
+
diff --git a/src/asn1c/GSSSessionData.h b/src/asn1c/GSSSessionData.h
new file mode 100644 (file)
index 0000000..b4e2e45
--- /dev/null
@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.27 (http://lionet.info/asn1c)
+ * From ASN.1 module "GssapiSessionModule"
+ *     found in "session.asn1"
+ *     `asn1c -fskeletons-copy`
+ */
+
+#ifndef        _GSSSessionData_H_
+#define        _GSSSessionData_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "Uint32.h"
+#include <OCTET_STRING.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* GSSSessionData */
+typedef struct GSSSessionData {
+       Uint32_t         expiration;
+       OCTET_STRING_t   username;
+       OCTET_STRING_t   gssname;
+       
+       /* Context for parsing across buffer boundaries */
+       asn_struct_ctx_t _asn_ctx;
+} GSSSessionData_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_GSSSessionData;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _GSSSessionData_H_ */
+#include <asn_internal.h>
diff --git a/src/asn1c/INTEGER.c b/src/asn1c/INTEGER.c
new file mode 100644 (file)
index 0000000..38ddb60
--- /dev/null
@@ -0,0 +1,1023 @@
+/*-
+ * Copyright (c) 2003-2014 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <INTEGER.h>
+#include <asn_codecs_prim.h>   /* Encoder and decoder of a primitive type */
+#include <errno.h>
+
+/*
+ * INTEGER basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_INTEGER_tags[] = {
+       (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_INTEGER = {
+       "INTEGER",
+       "INTEGER",
+       ASN__PRIMITIVE_TYPE_free,
+       INTEGER_print,
+       asn_generic_no_constraint,
+       ber_decode_primitive,
+       INTEGER_encode_der,
+       INTEGER_decode_xer,
+       INTEGER_encode_xer,
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
+       INTEGER_decode_uper,    /* Unaligned PER decoder */
+       INTEGER_encode_uper,    /* Unaligned PER encoder */
+#endif /* ASN_DISABLE_PER_SUPPORT */
+       0, /* Use generic outmost tag fetcher */
+       asn_DEF_INTEGER_tags,
+       sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
+       asn_DEF_INTEGER_tags,   /* Same as above */
+       sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
+       0,      /* No PER visible constraints */
+       0, 0,   /* No members */
+       0       /* No specifics */
+};
+
+/*
+ * Encode INTEGER type using DER.
+ */
+asn_enc_rval_t
+INTEGER_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
+       int tag_mode, ber_tlv_tag_t tag,
+       asn_app_consume_bytes_f *cb, void *app_key) {
+       INTEGER_t *st = (INTEGER_t *)sptr;
+
+       ASN_DEBUG("%s %s as INTEGER (tm=%d)",
+               cb?"Encoding":"Estimating", td->name, tag_mode);
+
+       /*
+        * Canonicalize integer in the buffer.
+        * (Remove too long sign extension, remove some first 0x00 bytes)
+        */
+       if(st->buf) {
+               uint8_t *buf = st->buf;
+               uint8_t *end1 = buf + st->size - 1;
+               int shift;
+
+               /* Compute the number of superfluous leading bytes */
+               for(; buf < end1; buf++) {
+                       /*
+                        * If the contents octets of an integer value encoding
+                        * consist of more than one octet, then the bits of the
+                        * first octet and bit 8 of the second octet:
+                        * a) shall not all be ones; and
+                        * b) shall not all be zero.
+                        */
+                       switch(*buf) {
+                       case 0x00: if((buf[1] & 0x80) == 0)
+                                       continue;
+                               break;
+                       case 0xff: if((buf[1] & 0x80))
+                                       continue;
+                               break;
+                       }
+                       break;
+               }
+
+               /* Remove leading superfluous bytes from the integer */
+               shift = buf - st->buf;
+               if(shift) {
+                       uint8_t *nb = st->buf;
+                       uint8_t *end;
+
+                       st->size -= shift;      /* New size, minus bad bytes */
+                       end = nb + st->size;
+
+                       for(; nb < end; nb++, buf++)
+                               *nb = *buf;
+               }
+
+       } /* if(1) */
+
+       return der_encode_primitive(td, sptr, tag_mode, tag, cb, app_key);
+}
+
+static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value(asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop);
+
+/*
+ * INTEGER specific human-readable output.
+ */
+static ssize_t
+INTEGER__dump(asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_consume_bytes_f *cb, void *app_key, int plainOrXER) {
+       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+       char scratch[32];       /* Enough for 64-bit integer */
+       uint8_t *buf = st->buf;
+       uint8_t *buf_end = st->buf + st->size;
+       signed long value;
+       ssize_t wrote = 0;
+       char *p;
+       int ret;
+
+       if(specs && specs->field_unsigned)
+               ret = asn_INTEGER2ulong(st, (unsigned long *)&value);
+       else
+               ret = asn_INTEGER2long(st, &value);
+
+       /* Simple case: the integer size is small */
+       if(ret == 0) {
+               const asn_INTEGER_enum_map_t *el;
+               size_t scrsize;
+               char *scr;
+
+               el = (value >= 0 || !specs || !specs->field_unsigned)
+                       ? INTEGER_map_value2enum(specs, value) : 0;
+               if(el) {
+                       scrsize = el->enum_len + 32;
+                       scr = (char *)alloca(scrsize);
+                       if(plainOrXER == 0)
+                               ret = snprintf(scr, scrsize,
+                                       "%ld (%s)", value, el->enum_name);
+                       else
+                               ret = snprintf(scr, scrsize,
+                                       "<%s/>", el->enum_name);
+               } else if(plainOrXER && specs && specs->strict_enumeration) {
+                       ASN_DEBUG("ASN.1 forbids dealing with "
+                               "unknown value of ENUMERATED type");
+                       errno = EPERM;
+                       return -1;
+               } else {
+                       scrsize = sizeof(scratch);
+                       scr = scratch;
+                       ret = snprintf(scr, scrsize,
+                               (specs && specs->field_unsigned)
+                               ?"%lu":"%ld", value);
+               }
+               assert(ret > 0 && (size_t)ret < scrsize);
+               return (cb(scr, ret, app_key) < 0) ? -1 : ret;
+       } else if(plainOrXER && specs && specs->strict_enumeration) {
+               /*
+                * Here and earlier, we cannot encode the ENUMERATED values
+                * if there is no corresponding identifier.
+                */
+               ASN_DEBUG("ASN.1 forbids dealing with "
+                       "unknown value of ENUMERATED type");
+               errno = EPERM;
+               return -1;
+       }
+
+       /* Output in the long xx:yy:zz... format */
+       /* TODO: replace with generic algorithm (Knuth TAOCP Vol 2, 4.3.1) */
+       for(p = scratch; buf < buf_end; buf++) {
+               static const char *h2c = "0123456789ABCDEF";
+               if((p - scratch) >= (ssize_t)(sizeof(scratch) - 4)) {
+                       /* Flush buffer */
+                       if(cb(scratch, p - scratch, app_key) < 0)
+                               return -1;
+                       wrote += p - scratch;
+                       p = scratch;
+               }
+               *p++ = h2c[*buf >> 4];
+               *p++ = h2c[*buf & 0x0F];
+               *p++ = 0x3a;    /* ":" */
+       }
+       if(p != scratch)
+               p--;    /* Remove the last ":" */
+
+       wrote += p - scratch;
+       return (cb(scratch, p - scratch, app_key) < 0) ? -1 : wrote;
+}
+
+/*
+ * INTEGER specific human-readable output.
+ */
+int
+INTEGER_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+       asn_app_consume_bytes_f *cb, void *app_key) {
+       const INTEGER_t *st = (const INTEGER_t *)sptr;
+       ssize_t ret;
+
+       (void)td;
+       (void)ilevel;
+
+       if(!st || !st->buf)
+               ret = cb("<absent>", 8, app_key);
+       else
+               ret = INTEGER__dump(td, st, cb, app_key, 0);
+
+       return (ret < 0) ? -1 : 0;
+}
+
+struct e2v_key {
+       const char *start;
+       const char *stop;
+       asn_INTEGER_enum_map_t *vemap;
+       unsigned int *evmap;
+};
+static int
+INTEGER__compar_enum2value(const void *kp, const void *am) {
+       const struct e2v_key *key = (const struct e2v_key *)kp;
+       const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
+       const char *ptr, *end, *name;
+
+       /* Remap the element (sort by different criterion) */
+       el = key->vemap + key->evmap[el - key->vemap];
+
+       /* Compare strings */
+       for(ptr = key->start, end = key->stop, name = el->enum_name;
+                       ptr < end; ptr++, name++) {
+               if(*ptr != *name)
+                       return *(const unsigned char *)ptr
+                               - *(const unsigned char *)name;
+       }
+       return name[0] ? -1 : 0;
+}
+
+static const asn_INTEGER_enum_map_t *
+INTEGER_map_enum2value(asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop) {
+       asn_INTEGER_enum_map_t *el_found;
+       int count = specs ? specs->map_count : 0;
+       struct e2v_key key;
+       const char *lp;
+
+       if(!count) return NULL;
+
+       /* Guaranteed: assert(lstart < lstop); */
+       /* Figure out the tag name */
+       for(lstart++, lp = lstart; lp < lstop; lp++) {
+               switch(*lp) {
+               case 9: case 10: case 11: case 12: case 13: case 32: /* WSP */
+               case 0x2f: /* '/' */ case 0x3e: /* '>' */
+                       break;
+               default:
+                       continue;
+               }
+               break;
+       }
+       if(lp == lstop) return NULL;    /* No tag found */
+       lstop = lp;
+
+       key.start = lstart;
+       key.stop = lstop;
+       key.vemap = specs->value2enum;
+       key.evmap = specs->enum2value;
+       el_found = (asn_INTEGER_enum_map_t *)bsearch(&key,
+               specs->value2enum, count, sizeof(specs->value2enum[0]),
+               INTEGER__compar_enum2value);
+       if(el_found) {
+               /* Remap enum2value into value2enum */
+               el_found = key.vemap + key.evmap[el_found - key.vemap];
+       }
+       return el_found;
+}
+
+static int
+INTEGER__compar_value2enum(const void *kp, const void *am) {
+       long a = *(const long *)kp;
+       const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
+       long b = el->nat_value;
+       if(a < b) return -1;
+       else if(a == b) return 0;
+       else return 1;
+}
+
+const asn_INTEGER_enum_map_t *
+INTEGER_map_value2enum(asn_INTEGER_specifics_t *specs, long value) {
+       int count = specs ? specs->map_count : 0;
+       if(!count) return 0;
+       return (asn_INTEGER_enum_map_t *)bsearch(&value, specs->value2enum,
+               count, sizeof(specs->value2enum[0]),
+               INTEGER__compar_value2enum);
+}
+
+static int
+INTEGER_st_prealloc(INTEGER_t *st, int min_size) {
+       void *p = MALLOC(min_size + 1);
+       if(p) {
+               void *b = st->buf;
+               st->size = 0;
+               st->buf = p;
+               FREEMEM(b);
+               return 0;
+       } else {
+               return -1;
+       }
+}
+
+/*
+ * Decode the chunk of XML text encoding INTEGER.
+ */
+static enum xer_pbd_rval
+INTEGER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
+       INTEGER_t *st = (INTEGER_t *)sptr;
+       long dec_value;
+       long hex_value = 0;
+       const char *lp;
+       const char *lstart = (const char *)chunk_buf;
+       const char *lstop = lstart + chunk_size;
+       enum {
+               ST_LEADSPACE,
+               ST_SKIPSPHEX,
+               ST_WAITDIGITS,
+               ST_DIGITS,
+               ST_DIGITS_TRAILSPACE,
+               ST_HEXDIGIT1,
+               ST_HEXDIGIT2,
+               ST_HEXDIGITS_TRAILSPACE,
+               ST_HEXCOLON,
+               ST_END_ENUM,
+               ST_UNEXPECTED
+       } state = ST_LEADSPACE;
+       const char *dec_value_start = 0; /* INVARIANT: always !0 in ST_DIGITS */
+       const char *dec_value_end = 0;
+
+       if(chunk_size)
+               ASN_DEBUG("INTEGER body %ld 0x%2x..0x%2x",
+                       (long)chunk_size, *lstart, lstop[-1]);
+
+       if(INTEGER_st_prealloc(st, (chunk_size/3) + 1))
+               return XPBD_SYSTEM_FAILURE;
+
+       /*
+        * We may have received a tag here. It will be processed inline.
+        * Use strtoul()-like code and serialize the result.
+        */
+       for(lp = lstart; lp < lstop; lp++) {
+               int lv = *lp;
+               switch(lv) {
+               case 0x09: case 0x0a: case 0x0d: case 0x20:
+                       switch(state) {
+                       case ST_LEADSPACE:
+                       case ST_DIGITS_TRAILSPACE:
+                       case ST_HEXDIGITS_TRAILSPACE:
+                       case ST_SKIPSPHEX:
+                               continue;
+                       case ST_DIGITS:
+                               dec_value_end = lp;
+                               state = ST_DIGITS_TRAILSPACE;
+                               continue;
+                       case ST_HEXCOLON:
+                               state = ST_HEXDIGITS_TRAILSPACE;
+                               continue;
+                       default:
+                               break;
+                       }
+                       break;
+               case 0x2d:      /* '-' */
+                       if(state == ST_LEADSPACE) {
+                               dec_value = 0;
+                               dec_value_start = lp;
+                               state = ST_WAITDIGITS;
+                               continue;
+                       }
+                       break;
+               case 0x2b:      /* '+' */
+                       if(state == ST_LEADSPACE) {
+                               dec_value = 0;
+                               dec_value_start = lp;
+                               state = ST_WAITDIGITS;
+                               continue;
+                       }
+                       break;
+               case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
+               case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
+                       switch(state) {
+                       case ST_DIGITS: continue;
+                       case ST_SKIPSPHEX:      /* Fall through */
+                       case ST_HEXDIGIT1:
+                               hex_value = (lv - 0x30) << 4;
+                               state = ST_HEXDIGIT2;
+                               continue;
+                       case ST_HEXDIGIT2:
+                               hex_value += (lv - 0x30);
+                               state = ST_HEXCOLON;
+                               st->buf[st->size++] = (uint8_t)hex_value;
+                               continue;
+                       case ST_HEXCOLON:
+                               return XPBD_BROKEN_ENCODING;
+                       case ST_LEADSPACE:
+                               dec_value = 0;
+                               dec_value_start = lp;
+                               /* FALL THROUGH */
+                       case ST_WAITDIGITS:
+                               state = ST_DIGITS;
+                               continue;
+                       default:
+                               break;
+                       }
+                       break;
+               case 0x3c:      /* '<', start of XML encoded enumeration */
+                       if(state == ST_LEADSPACE) {
+                               const asn_INTEGER_enum_map_t *el;
+                               el = INTEGER_map_enum2value(
+                                       (asn_INTEGER_specifics_t *)
+                                       td->specifics, lstart, lstop);
+                               if(el) {
+                                       ASN_DEBUG("Found \"%s\" => %ld",
+                                               el->enum_name, el->nat_value);
+                                       dec_value = el->nat_value;
+                                       state = ST_END_ENUM;
+                                       lp = lstop - 1;
+                                       continue;
+                               }
+                               ASN_DEBUG("Unknown identifier for INTEGER");
+                       }
+                       return XPBD_BROKEN_ENCODING;
+               case 0x3a:      /* ':' */
+                       if(state == ST_HEXCOLON) {
+                               /* This colon is expected */
+                               state = ST_HEXDIGIT1;
+                               continue;
+                       } else if(state == ST_DIGITS) {
+                               /* The colon here means that we have
+                                * decoded the first two hexadecimal
+                                * places as a decimal value.
+                                * Switch decoding mode. */
+                               ASN_DEBUG("INTEGER re-evaluate as hex form");
+                               state = ST_SKIPSPHEX;
+                               dec_value_start = 0;
+                               lp = lstart - 1;
+                               continue;
+                       } else {
+                               ASN_DEBUG("state %d at %ld", state, (long)(lp - lstart));
+                               break;
+                       }
+               /* [A-Fa-f] */
+               case 0x41:case 0x42:case 0x43:case 0x44:case 0x45:case 0x46:
+               case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:case 0x66:
+                       switch(state) {
+                       case ST_SKIPSPHEX:
+                       case ST_LEADSPACE: /* Fall through */
+                       case ST_HEXDIGIT1:
+                               hex_value = lv - ((lv < 0x61) ? 0x41 : 0x61);
+                               hex_value += 10;
+                               hex_value <<= 4;
+                               state = ST_HEXDIGIT2;
+                               continue;
+                       case ST_HEXDIGIT2:
+                               hex_value += lv - ((lv < 0x61) ? 0x41 : 0x61);
+                               hex_value += 10;
+                               st->buf[st->size++] = (uint8_t)hex_value;
+                               state = ST_HEXCOLON;
+                               continue;
+                       case ST_DIGITS:
+                               ASN_DEBUG("INTEGER re-evaluate as hex form");
+                               state = ST_SKIPSPHEX;
+                               dec_value_start = 0;
+                               lp = lstart - 1;
+                               continue;
+                       default:
+                               break;
+                       }
+                       break;
+               }
+
+               /* Found extra non-numeric stuff */
+               ASN_DEBUG("INTEGER :: Found non-numeric 0x%2x at %ld",
+                       lv, (long)(lp - lstart));
+               state = ST_UNEXPECTED;
+               break;
+       }
+
+       switch(state) {
+       case ST_END_ENUM:
+               /* Got a complete and valid enumeration encoded as a tag. */
+               break;
+       case ST_DIGITS:
+               dec_value_end = lstop;
+               /* FALL THROUGH */
+       case ST_DIGITS_TRAILSPACE:
+               /* The last symbol encountered was a digit. */
+               switch(asn_strtol_lim(dec_value_start, &dec_value_end, &dec_value)) {
+               case ASN_STRTOL_OK:
+                       break;
+               case ASN_STRTOL_ERROR_RANGE:
+                       return XPBD_DECODER_LIMIT;
+               case ASN_STRTOL_ERROR_INVAL:
+               case ASN_STRTOL_EXPECT_MORE:
+               case ASN_STRTOL_EXTRA_DATA:
+                       return XPBD_BROKEN_ENCODING;
+               }
+               break;
+       case ST_HEXCOLON:
+       case ST_HEXDIGITS_TRAILSPACE:
+               st->buf[st->size] = 0;  /* Just in case termination */
+               return XPBD_BODY_CONSUMED;
+       case ST_HEXDIGIT1:
+       case ST_HEXDIGIT2:
+       case ST_SKIPSPHEX:
+               return XPBD_BROKEN_ENCODING;
+       case ST_LEADSPACE:
+               /* Content not found */
+               return XPBD_NOT_BODY_IGNORE;
+       case ST_WAITDIGITS:
+       case ST_UNEXPECTED:
+               ASN_DEBUG("INTEGER: No useful digits (state %d)", state);
+               return XPBD_BROKEN_ENCODING;    /* No digits */
+       }
+
+       /*
+        * Convert the result of parsing of enumeration or a straight
+        * decimal value into a BER representation.
+        */
+       if(asn_long2INTEGER(st, dec_value))
+               return XPBD_SYSTEM_FAILURE;
+
+       return XPBD_BODY_CONSUMED;
+}
+
+asn_dec_rval_t
+INTEGER_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
+               const void *buf_ptr, size_t size) {
+
+       return xer_decode_primitive(opt_codec_ctx, td,
+               sptr, sizeof(INTEGER_t), opt_mname,
+               buf_ptr, size, INTEGER__xer_body_decode);
+}
+
+asn_enc_rval_t
+INTEGER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+       int ilevel, enum xer_encoder_flags_e flags,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       const INTEGER_t *st = (const INTEGER_t *)sptr;
+       asn_enc_rval_t er;
+
+       (void)ilevel;
+       (void)flags;
+       
+       if(!st || !st->buf)
+               _ASN_ENCODE_FAILED;
+
+       er.encoded = INTEGER__dump(td, st, cb, app_key, 1);
+       if(er.encoded < 0) _ASN_ENCODE_FAILED;
+
+       _ASN_ENCODED_OK(er);
+}
+
+#ifndef        ASN_DISABLE_PER_SUPPORT
+
+asn_dec_rval_t
+INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+       asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+       asn_dec_rval_t rval = { RC_OK, 0 };
+       INTEGER_t *st = (INTEGER_t *)*sptr;
+       asn_per_constraint_t *ct;
+       int repeat;
+
+       (void)opt_codec_ctx;
+
+       if(!st) {
+               st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st)));
+               if(!st) _ASN_DECODE_FAILED;
+       }
+
+       if(!constraints) constraints = td->per_constraints;
+       ct = constraints ? &constraints->value : 0;
+
+       if(ct && ct->flags & APC_EXTENSIBLE) {
+               int inext = per_get_few_bits(pd, 1);
+               if(inext < 0) _ASN_DECODE_STARVED;
+               if(inext) ct = 0;
+       }
+
+       FREEMEM(st->buf);
+       st->buf = 0;
+       st->size = 0;
+       if(ct) {
+               if(ct->flags & APC_SEMI_CONSTRAINED) {
+                       st->buf = (uint8_t *)CALLOC(1, 2);
+                       if(!st->buf) _ASN_DECODE_FAILED;
+                       st->size = 1;
+               } else if(ct->flags & APC_CONSTRAINED && ct->range_bits >= 0) {
+                       size_t size = (ct->range_bits + 7) >> 3;
+                       st->buf = (uint8_t *)MALLOC(1 + size + 1);
+                       if(!st->buf) _ASN_DECODE_FAILED;
+                       st->size = size;
+               }
+       }
+
+       /* X.691-2008/11, #13.2.2, constrained whole number */
+       if(ct && ct->flags != APC_UNCONSTRAINED) {
+               /* #11.5.6 */
+               ASN_DEBUG("Integer with range %d bits", ct->range_bits);
+               if(ct->range_bits >= 0) {
+                       if((size_t)ct->range_bits > 8 * sizeof(unsigned long))
+                               _ASN_DECODE_FAILED;
+
+                       if(specs && specs->field_unsigned) {
+                               unsigned long uvalue;
+                               if(uper_get_constrained_whole_number(pd,
+                                       &uvalue, ct->range_bits))
+                                       _ASN_DECODE_STARVED;
+                               ASN_DEBUG("Got value %lu + low %ld",
+                                       uvalue, ct->lower_bound);
+                               uvalue += ct->lower_bound;
+                               if(asn_ulong2INTEGER(st, uvalue))
+                                       _ASN_DECODE_FAILED;
+                       } else {
+                               unsigned long svalue;
+                               if(uper_get_constrained_whole_number(pd,
+                                       &svalue, ct->range_bits))
+                                       _ASN_DECODE_STARVED;
+                               ASN_DEBUG("Got value %ld + low %ld",
+                                       svalue, ct->lower_bound);
+                               svalue += ct->lower_bound;
+                               if(asn_long2INTEGER(st, svalue))
+                                       _ASN_DECODE_FAILED;
+                       }
+                       return rval;
+               }
+       } else {
+               ASN_DEBUG("Decoding unconstrained integer %s", td->name);
+       }
+
+       /* X.691, #12.2.3, #12.2.4 */
+       do {
+               ssize_t len;
+               void *p;
+               int ret;
+
+               /* Get the PER length */
+               len = uper_get_length(pd, -1, &repeat);
+               if(len < 0) _ASN_DECODE_STARVED;
+
+               p = REALLOC(st->buf, st->size + len + 1);
+               if(!p) _ASN_DECODE_FAILED;
+               st->buf = (uint8_t *)p;
+
+               ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len);
+               if(ret < 0) _ASN_DECODE_STARVED;
+               st->size += len;
+       } while(repeat);
+       st->buf[st->size] = 0;  /* JIC */
+
+       /* #12.2.3 */
+       if(ct && ct->lower_bound) {
+               /*
+                * TODO: replace by in-place arithmetics.
+                */
+               long value;
+               if(asn_INTEGER2long(st, &value))
+                       _ASN_DECODE_FAILED;
+               if(asn_long2INTEGER(st, value + ct->lower_bound))
+                       _ASN_DECODE_FAILED;
+       }
+
+       return rval;
+}
+
+asn_enc_rval_t
+INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
+       asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+       asn_enc_rval_t er;
+       INTEGER_t *st = (INTEGER_t *)sptr;
+       const uint8_t *buf;
+       const uint8_t *end;
+       asn_per_constraint_t *ct;
+       long value = 0;
+
+       if(!st || st->size == 0) _ASN_ENCODE_FAILED;
+
+       if(!constraints) constraints = td->per_constraints;
+       ct = constraints ? &constraints->value : 0;
+
+       er.encoded = 0;
+
+       if(ct) {
+               int inext = 0;
+               if(specs && specs->field_unsigned) {
+                       unsigned long uval;
+                       if(asn_INTEGER2ulong(st, &uval))
+                               _ASN_ENCODE_FAILED;
+                       /* Check proper range */
+                       if(ct->flags & APC_SEMI_CONSTRAINED) {
+                               if(uval < (unsigned long)ct->lower_bound)
+                                       inext = 1;
+                       } else if(ct->range_bits >= 0) {
+                               if(uval < (unsigned long)ct->lower_bound
+                               || uval > (unsigned long)ct->upper_bound)
+                                       inext = 1;
+                       }
+                       ASN_DEBUG("Value %lu (%02x/%d) lb %lu ub %lu %s",
+                               uval, st->buf[0], st->size,
+                               ct->lower_bound, ct->upper_bound,
+                               inext ? "ext" : "fix");
+                       value = uval;
+               } else {
+                       if(asn_INTEGER2long(st, &value))
+                               _ASN_ENCODE_FAILED;
+                       /* Check proper range */
+                       if(ct->flags & APC_SEMI_CONSTRAINED) {
+                               if(value < ct->lower_bound)
+                                       inext = 1;
+                       } else if(ct->range_bits >= 0) {
+                               if(value < ct->lower_bound
+                               || value > ct->upper_bound)
+                                       inext = 1;
+                       }
+                       ASN_DEBUG("Value %ld (%02x/%d) lb %ld ub %ld %s",
+                               value, st->buf[0], st->size,
+                               ct->lower_bound, ct->upper_bound,
+                               inext ? "ext" : "fix");
+               }
+               if(ct->flags & APC_EXTENSIBLE) {
+                       if(per_put_few_bits(po, inext, 1))
+                               _ASN_ENCODE_FAILED;
+                       if(inext) ct = 0;
+               } else if(inext) {
+                       _ASN_ENCODE_FAILED;
+               }
+       }
+
+
+       /* X.691-11/2008, #13.2.2, test if constrained whole number */
+       if(ct && ct->range_bits >= 0) {
+               /* #11.5.6 -> #11.3 */
+               ASN_DEBUG("Encoding integer %ld (%lu) with range %d bits",
+                       value, value - ct->lower_bound, ct->range_bits);
+               unsigned long v = value - ct->lower_bound;
+               if(uper_put_constrained_whole_number_u(po, v, ct->range_bits))
+                       _ASN_ENCODE_FAILED;
+               _ASN_ENCODED_OK(er);
+       }
+
+       if(ct && ct->lower_bound) {
+               ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound);
+               /* TODO: adjust lower bound */
+               _ASN_ENCODE_FAILED;
+       }
+
+       for(buf = st->buf, end = st->buf + st->size; buf < end;) {
+               ssize_t mayEncode = uper_put_length(po, end - buf);
+               if(mayEncode < 0)
+                       _ASN_ENCODE_FAILED;
+               if(per_put_many_bits(po, buf, 8 * mayEncode))
+                       _ASN_ENCODE_FAILED;
+               buf += mayEncode;
+       }
+
+       _ASN_ENCODED_OK(er);
+}
+
+#endif /* ASN_DISABLE_PER_SUPPORT */
+
+int
+asn_INTEGER2long(const INTEGER_t *iptr, long *lptr) {
+       uint8_t *b, *end;
+       size_t size;
+       long l;
+
+       /* Sanity checking */
+       if(!iptr || !iptr->buf || !lptr) {
+               errno = EINVAL;
+               return -1;
+       }
+
+       /* Cache the begin/end of the buffer */
+       b = iptr->buf;  /* Start of the INTEGER buffer */
+       size = iptr->size;
+       end = b + size; /* Where to stop */
+
+       if(size > sizeof(long)) {
+               uint8_t *end1 = end - 1;
+               /*
+                * Slightly more advanced processing,
+                * able to >sizeof(long) bytes,
+                * when the actual value is small
+                * (0x0000000000abcdef would yield a fine 0x00abcdef)
+                */
+               /* Skip out the insignificant leading bytes */
+               for(; b < end1; b++) {
+                       switch(*b) {
+                       case 0x00: if((b[1] & 0x80) == 0) continue; break;
+                       case 0xff: if((b[1] & 0x80) != 0) continue; break;
+                       }
+                       break;
+               }
+
+               size = end - b;
+               if(size > sizeof(long)) {
+                       /* Still cannot fit the long */
+                       errno = ERANGE;
+                       return -1;
+               }
+       }
+
+       /* Shortcut processing of a corner case */
+       if(end == b) {
+               *lptr = 0;
+               return 0;
+       }
+
+       /* Perform the sign initialization */
+       /* Actually l = -(*b >> 7); gains nothing, yet unreadable! */
+       if((*b >> 7)) l = -1; else l = 0;
+
+       /* Conversion engine */
+       for(; b < end; b++)
+               l = (l << 8) | *b;
+
+       *lptr = l;
+       return 0;
+}
+
+int
+asn_INTEGER2ulong(const INTEGER_t *iptr, unsigned long *lptr) {
+       uint8_t *b, *end;
+       unsigned long l;
+       size_t size;
+
+       if(!iptr || !iptr->buf || !lptr) {
+               errno = EINVAL;
+               return -1;
+       }
+
+       b = iptr->buf;
+       size = iptr->size;
+       end = b + size;
+
+       /* If all extra leading bytes are zeroes, ignore them */
+       for(; size > sizeof(unsigned long); b++, size--) {
+               if(*b) {
+                       /* Value won't fit unsigned long */
+                       errno = ERANGE;
+                       return -1;
+               }
+       }
+
+       /* Conversion engine */
+       for(l = 0; b < end; b++)
+               l = (l << 8) | *b;
+
+       *lptr = l;
+       return 0;
+}
+
+int
+asn_ulong2INTEGER(INTEGER_t *st, unsigned long value) {
+       uint8_t *buf;
+       uint8_t *end;
+       uint8_t *b;
+       int shr;
+
+       if(value <= LONG_MAX)
+               return asn_long2INTEGER(st, value);
+
+       buf = (uint8_t *)MALLOC(1 + sizeof(value));
+       if(!buf) return -1;
+
+       end = buf + (sizeof(value) + 1);
+       buf[0] = 0;
+       for(b = buf + 1, shr = (sizeof(long)-1)*8; b < end; shr -= 8, b++)
+               *b = (uint8_t)(value >> shr);
+
+       if(st->buf) FREEMEM(st->buf);
+       st->buf = buf;
+       st->size = 1 + sizeof(value);
+
+       return 0;
+}
+
+int
+asn_long2INTEGER(INTEGER_t *st, long value) {
+       uint8_t *buf, *bp;
+       uint8_t *p;
+       uint8_t *pstart;
+       uint8_t *pend1;
+       int littleEndian = 1;   /* Run-time detection */
+       int add;
+
+       if(!st) {
+               errno = EINVAL;
+               return -1;
+       }
+
+       buf = (uint8_t *)MALLOC(sizeof(value));
+       if(!buf) return -1;
+
+       if(*(char *)&littleEndian) {
+               pstart = (uint8_t *)&value + sizeof(value) - 1;
+               pend1 = (uint8_t *)&value;
+               add = -1;
+       } else {
+               pstart = (uint8_t *)&value;
+               pend1 = pstart + sizeof(value) - 1;
+               add = 1;
+       }
+
+       /*
+        * If the contents octet consists of more than one octet,
+        * then bits of the first octet and bit 8 of the second octet:
+        * a) shall not all be ones; and
+        * b) shall not all be zero.
+        */
+       for(p = pstart; p != pend1; p += add) {
+               switch(*p) {
+               case 0x00: if((*(p+add) & 0x80) == 0)
+                               continue;
+                       break;
+               case 0xff: if((*(p+add) & 0x80))
+                               continue;
+                       break;
+               }
+               break;
+       }
+       /* Copy the integer body */
+       for(pstart = p, bp = buf, pend1 += add; p != pend1; p += add)
+               *bp++ = *p;
+
+       if(st->buf) FREEMEM(st->buf);
+       st->buf = buf;
+       st->size = bp - buf;
+
+       return 0;
+}
+
+/*
+ * This function is going to be DEPRECATED soon.
+ */
+enum asn_strtol_result_e
+asn_strtol(const char *str, const char *end, long *lp) {
+    const char *endp = end;
+
+    switch(asn_strtol_lim(str, &endp, lp)) {
+    case ASN_STRTOL_ERROR_RANGE:
+        return ASN_STRTOL_ERROR_RANGE;
+    case ASN_STRTOL_ERROR_INVAL:
+        return ASN_STRTOL_ERROR_INVAL;
+    case ASN_STRTOL_EXPECT_MORE:
+        return ASN_STRTOL_ERROR_INVAL;  /* Retain old behavior */
+    case ASN_STRTOL_OK:
+        return ASN_STRTOL_OK;
+    case ASN_STRTOL_EXTRA_DATA:
+        return ASN_STRTOL_ERROR_INVAL;  /* Retain old behavior */
+    }
+
+    return ASN_STRTOL_ERROR_INVAL;  /* Retain old behavior */
+}
+
+/*
+ * Parse the number in the given string until the given *end position,
+ * returning the position after the last parsed character back using the
+ * same (*end) pointer.
+ * WARNING: This behavior is different from the standard strtol(3).
+ */
+enum asn_strtol_result_e
+asn_strtol_lim(const char *str, const char **end, long *lp) {
+       int sign = 1;
+       long l;
+
+       const long upper_boundary = LONG_MAX / 10;
+       long last_digit_max = LONG_MAX % 10;
+
+       if(str >= *end) return ASN_STRTOL_ERROR_INVAL;
+
+       switch(*str) {
+       case '-':
+               last_digit_max++;
+               sign = -1;
+       case '+':
+               str++;
+               if(str >= *end) {
+                       *end = str;
+                       return ASN_STRTOL_EXPECT_MORE;
+               }
+       }
+
+       for(l = 0; str < (*end); str++) {
+               switch(*str) {
+               case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
+               case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: {
+                       int d = *str - '0';
+                       if(l < upper_boundary) {
+                               l = l * 10 + d;
+                       } else if(l == upper_boundary) {
+                               if(d <= last_digit_max) {
+                                       if(sign > 0) {
+                                               l = l * 10 + d;
+                                       } else {
+                                               sign = 1;
+                                               l = -l * 10 - d;
+                                       }
+                               } else {
+                                       *end = str;
+                                       return ASN_STRTOL_ERROR_RANGE;
+                               }
+                       } else {
+                               *end = str;
+                               return ASN_STRTOL_ERROR_RANGE;
+                       }
+                   }
+                   continue;
+               default:
+                   *end = str;
+                   *lp = sign * l;
+                   return ASN_STRTOL_EXTRA_DATA;
+               }
+       }
+
+       *end = str;
+       *lp = sign * l;
+       return ASN_STRTOL_OK;
+}
+
diff --git a/src/asn1c/INTEGER.h b/src/asn1c/INTEGER.h
new file mode 100644 (file)
index 0000000..fe08b03
--- /dev/null
@@ -0,0 +1,82 @@
+/*-
+ * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        _INTEGER_H_
+#define        _INTEGER_H_
+
+#include <asn_application.h>
+#include <asn_codecs_prim.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef ASN__PRIMITIVE_TYPE_t INTEGER_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_INTEGER;
+
+/* Map with <tag> to integer value association */
+typedef struct asn_INTEGER_enum_map_s {
+       long             nat_value;     /* associated native integer value */
+       size_t           enum_len;      /* strlen("tag") */
+       const char      *enum_name;     /* "tag" */
+} asn_INTEGER_enum_map_t;
+
+/* This type describes an enumeration for INTEGER and ENUMERATED types */
+typedef struct asn_INTEGER_specifics_s {
+       asn_INTEGER_enum_map_t *value2enum;     /* N -> "tag"; sorted by N */
+       unsigned int *enum2value;               /* "tag" => N; sorted by tag */
+       int map_count;                          /* Elements in either map */
+       int extension;                          /* This map is extensible */
+       int strict_enumeration;                 /* Enumeration set is fixed */
+       int field_width;                        /* Size of native integer */
+       int field_unsigned;                     /* Signed=0, unsigned=1 */
+} asn_INTEGER_specifics_t;
+
+asn_struct_print_f INTEGER_print;
+ber_type_decoder_f INTEGER_decode_ber;
+der_type_encoder_f INTEGER_encode_der;
+xer_type_decoder_f INTEGER_decode_xer;
+xer_type_encoder_f INTEGER_encode_xer;
+per_type_decoder_f INTEGER_decode_uper;
+per_type_encoder_f INTEGER_encode_uper;
+
+/***********************************
+ * Some handy conversion routines. *
+ ***********************************/
+
+/*
+ * Returns 0 if it was possible to convert, -1 otherwise.
+ * -1/EINVAL: Mandatory argument missing
+ * -1/ERANGE: Value encoded is out of range for long representation
+ * -1/ENOMEM: Memory allocation failed (in asn_long2INTEGER()).
+ */
+int asn_INTEGER2long(const INTEGER_t *i, long *l);
+int asn_INTEGER2ulong(const INTEGER_t *i, unsigned long *l);
+int asn_long2INTEGER(INTEGER_t *i, long l);
+int asn_ulong2INTEGER(INTEGER_t *i, unsigned long l);
+
+/* A a reified version of strtol(3) with nicer error reporting. */
+enum asn_strtol_result_e {
+    ASN_STRTOL_ERROR_RANGE = -3,  /* Input outside of numeric range for long type */
+    ASN_STRTOL_ERROR_INVAL = -2,  /* Invalid data encountered (e.g., "+-") */
+    ASN_STRTOL_EXPECT_MORE = -1,  /* More data expected (e.g. "+") */
+    ASN_STRTOL_OK          =  0,  /* Conversion succeded, number ends at (*end) */
+    ASN_STRTOL_EXTRA_DATA  =  1,  /* Conversion succeded, but the string has extra stuff */
+};
+enum asn_strtol_result_e asn_strtol_lim(const char *str, const char **end, long *l);
+
+/* The asn_strtol is going to be DEPRECATED soon */
+enum asn_strtol_result_e asn_strtol(const char *str, const char *end, long *l);
+
+/*
+ * Convert the integer value into the corresponding enumeration map entry.
+ */
+const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(asn_INTEGER_specifics_t *specs, long value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _INTEGER_H_ */
diff --git a/src/asn1c/Makefile.am b/src/asn1c/Makefile.am
new file mode 100644 (file)
index 0000000..8d6c81d
--- /dev/null
@@ -0,0 +1,66 @@
+NULL =
+
+ASN1C_SOURCES =                        \
+       asn_codecs_prim.c       \
+       ber_decoder.c           \
+       ber_tlv_length.c        \
+       ber_tlv_tag.c           \
+       BIT_STRING.c            \
+       constraints.c           \
+       constr_SEQUENCE.c       \
+       constr_TYPE.c           \
+       der_encoder.c           \
+       INTEGER.c               \
+       NativeEnumerated.c      \
+       NativeInteger.c         \
+       OCTET_STRING.c          \
+       per_decoder.c           \
+       per_encoder.c           \
+       per_opentype.c          \
+       per_support.c           \
+       xer_decoder.c           \
+       xer_encoder.c           \
+       xer_support.c           \
+       asn_application.h       \
+       asn_codecs.h            \
+       asn_codecs_prim.h       \
+       asn_internal.h          \
+       asn_system.h            \
+       ber_decoder.h           \
+       ber_tlv_length.h        \
+       ber_tlv_tag.h           \
+       BIT_STRING.h            \
+       constraints.h           \
+       constr_SEQUENCE.h       \
+       constr_TYPE.h           \
+       der_encoder.h           \
+       INTEGER.h               \
+       NativeEnumerated.h      \
+       NativeInteger.h         \
+       OCTET_STRING.h          \
+       per_decoder.h           \
+       per_encoder.h           \
+       per_opentype.h          \
+       per_support.h           \
+       xer_decoder.h           \
+       xer_encoder.h           \
+       xer_support.h           \
+       $(NULL)
+
+ASN1Cdir = .
+
+MAGASN1_SOURCES =              \
+       GSSSessionData.c        \
+       Uint32.c                \
+       GSSSessionData.h        \
+       Uint32.h                \
+       $(NULL)
+
+MAGASN1dir = .
+
+noinst_LTLIBRARIES = libmagasn1.la
+libmagasn1_la_SOURCES = $(ASN1C_SOURCES) $(MAGASN1_SOURCES)
+
+regenerate:
+       asn1c -fskeletons-copy -fnative-types session.asn1
+       rm -f converter-sample.c Makefile.am.sample
diff --git a/src/asn1c/NativeEnumerated.c b/src/asn1c/NativeEnumerated.c
new file mode 100644 (file)
index 0000000..1554220
--- /dev/null
@@ -0,0 +1,207 @@
+/*-
+ * Copyright (c) 2004, 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * Read the NativeInteger.h for the explanation wrt. differences between
+ * INTEGER and NativeInteger.
+ * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this
+ * implementation deals with the standard (machine-specific) representation
+ * of them instead of using the platform-independent buffer.
+ */
+#include <asn_internal.h>
+#include <NativeEnumerated.h>
+
+/*
+ * NativeEnumerated basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_NativeEnumerated_tags[] = {
+       (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NativeEnumerated = {
+       "ENUMERATED",                   /* The ASN.1 type is still ENUMERATED */
+       "ENUMERATED",
+       NativeInteger_free,
+       NativeInteger_print,
+       asn_generic_no_constraint,
+       NativeInteger_decode_ber,
+       NativeInteger_encode_der,
+       NativeInteger_decode_xer,
+       NativeEnumerated_encode_xer,
+       NativeEnumerated_decode_uper,
+       NativeEnumerated_encode_uper,
+       0, /* Use generic outmost tag fetcher */
+       asn_DEF_NativeEnumerated_tags,
+       sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]),
+       asn_DEF_NativeEnumerated_tags,  /* Same as above */
+       sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]),
+       0,      /* No PER visible constraints */
+       0, 0,   /* No members */
+       0       /* No specifics */
+};
+
+asn_enc_rval_t
+NativeEnumerated_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+        int ilevel, enum xer_encoder_flags_e flags,
+                asn_app_consume_bytes_f *cb, void *app_key) {
+       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+        asn_enc_rval_t er;
+        const long *native = (const long *)sptr;
+       const asn_INTEGER_enum_map_t *el;
+
+        (void)ilevel;
+        (void)flags;
+
+        if(!native) _ASN_ENCODE_FAILED;
+
+       el = INTEGER_map_value2enum(specs, *native);
+       if(el) {
+               size_t srcsize = el->enum_len + 5;
+               char *src = (char *)alloca(srcsize);
+
+               er.encoded = snprintf(src, srcsize, "<%s/>", el->enum_name);
+               assert(er.encoded > 0 && (size_t)er.encoded < srcsize);
+               if(cb(src, er.encoded, app_key) < 0) _ASN_ENCODE_FAILED;
+               _ASN_ENCODED_OK(er);
+       } else {
+               ASN_DEBUG("ASN.1 forbids dealing with "
+                       "unknown value of ENUMERATED type");
+               _ASN_ENCODE_FAILED;
+       }
+}
+
+asn_dec_rval_t
+NativeEnumerated_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
+       void **sptr, asn_per_data_t *pd) {
+       asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
+       asn_dec_rval_t rval = { RC_OK, 0 };
+       long *native = (long *)*sptr;
+       asn_per_constraint_t *ct;
+       long value;
+
+       (void)opt_codec_ctx;
+
+       if(constraints) ct = &constraints->value;
+       else if(td->per_constraints) ct = &td->per_constraints->value;
+       else _ASN_DECODE_FAILED;        /* Mandatory! */
+       if(!specs) _ASN_DECODE_FAILED;
+
+       if(!native) {
+               native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+               if(!native) _ASN_DECODE_FAILED;
+       }
+
+       ASN_DEBUG("Decoding %s as NativeEnumerated", td->name);
+
+       if(ct->flags & APC_EXTENSIBLE) {
+               int inext = per_get_few_bits(pd, 1);
+               if(inext < 0) _ASN_DECODE_STARVED;
+               if(inext) ct = 0;
+       }
+
+       if(ct && ct->range_bits >= 0) {
+               value = per_get_few_bits(pd, ct->range_bits);
+               if(value < 0) _ASN_DECODE_STARVED;
+               if(value >= (specs->extension
+                       ? specs->extension - 1 : specs->map_count))
+                       _ASN_DECODE_FAILED;
+       } else {
+               if(!specs->extension)
+                       _ASN_DECODE_FAILED;
+               /*
+                * X.691, #10.6: normally small non-negative whole number;
+                */
+               value = uper_get_nsnnwn(pd);
+               if(value < 0) _ASN_DECODE_STARVED;
+               value += specs->extension - 1;
+               if(value >= specs->map_count)
+                       _ASN_DECODE_FAILED;
+       }
+
+       *native = specs->value2enum[value].nat_value;
+       ASN_DEBUG("Decoded %s = %ld", td->name, *native);
+
+       return rval;
+}
+
+static int
+NativeEnumerated__compar_value2enum(const void *ap, const void *bp) {
+       const asn_INTEGER_enum_map_t *a = ap;
+       const asn_INTEGER_enum_map_t *b = bp;
+       if(a->nat_value == b->nat_value)
+               return 0;
+       if(a->nat_value < b->nat_value)
+               return -1;
+       return 1;
+}
+
+asn_enc_rval_t
+NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td,
+       asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+       asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
+       asn_enc_rval_t er;
+       long native, value;
+       asn_per_constraint_t *ct;
+       int inext = 0;
+       asn_INTEGER_enum_map_t key;
+       asn_INTEGER_enum_map_t *kf;
+
+       if(!sptr) _ASN_ENCODE_FAILED;
+       if(!specs) _ASN_ENCODE_FAILED;
+
+       if(constraints) ct = &constraints->value;
+       else if(td->per_constraints) ct = &td->per_constraints->value;
+       else _ASN_ENCODE_FAILED;        /* Mandatory! */
+
+       ASN_DEBUG("Encoding %s as NativeEnumerated", td->name);
+
+       er.encoded = 0;
+
+       native = *(long *)sptr;
+       if(native < 0) _ASN_ENCODE_FAILED;
+
+       key.nat_value = native;
+       kf = bsearch(&key, specs->value2enum, specs->map_count,
+               sizeof(key), NativeEnumerated__compar_value2enum);
+       if(!kf) {
+               ASN_DEBUG("No element corresponds to %ld", native);
+               _ASN_ENCODE_FAILED;
+       }
+       value = kf - specs->value2enum;
+
+       if(ct->range_bits >= 0) {
+               int cmpWith = specs->extension
+                               ? specs->extension - 1 : specs->map_count;
+               if(value >= cmpWith)
+                       inext = 1;
+       }
+       if(ct->flags & APC_EXTENSIBLE) {
+               if(per_put_few_bits(po, inext, 1))
+                       _ASN_ENCODE_FAILED;
+               if(inext) ct = 0;
+       } else if(inext) {
+               _ASN_ENCODE_FAILED;
+       }
+
+       if(ct && ct->range_bits >= 0) {
+               if(per_put_few_bits(po, value, ct->range_bits))
+                       _ASN_ENCODE_FAILED;
+               _ASN_ENCODED_OK(er);
+       }
+
+       if(!specs->extension)
+               _ASN_ENCODE_FAILED;
+
+       /*
+        * X.691, #10.6: normally small non-negative whole number;
+        */
+       ASN_DEBUG("value = %ld, ext = %d, inext = %d, res = %ld",
+               value, specs->extension, inext,
+               value - (inext ? (specs->extension - 1) : 0));
+       if(uper_put_nsnnwn(po, value - (inext ? (specs->extension - 1) : 0)))
+               _ASN_ENCODE_FAILED;
+
+       _ASN_ENCODED_OK(er);
+}
+
diff --git a/src/asn1c/NativeEnumerated.h b/src/asn1c/NativeEnumerated.h
new file mode 100644 (file)
index 0000000..c59bb1b
--- /dev/null
@@ -0,0 +1,32 @@
+/*-
+ * Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * This type differs from the standard ENUMERATED in that it is modelled using
+ * the fixed machine type (long, int, short), so it can hold only values of
+ * limited length. There is no type (i.e., NativeEnumerated_t, any integer type
+ * will do).
+ * This type may be used when integer range is limited by subtype constraints.
+ */
+#ifndef        _NativeEnumerated_H_
+#define        _NativeEnumerated_H_
+
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern asn_TYPE_descriptor_t asn_DEF_NativeEnumerated;
+
+xer_type_encoder_f NativeEnumerated_encode_xer;
+per_type_decoder_f NativeEnumerated_decode_uper;
+per_type_encoder_f NativeEnumerated_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _NativeEnumerated_H_ */
diff --git a/src/asn1c/NativeInteger.c b/src/asn1c/NativeInteger.c
new file mode 100644 (file)
index 0000000..cffd0be
--- /dev/null
@@ -0,0 +1,332 @@
+/*-
+ * Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * Read the NativeInteger.h for the explanation wrt. differences between
+ * INTEGER and NativeInteger.
+ * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this
+ * implementation deals with the standard (machine-specific) representation
+ * of them instead of using the platform-independent buffer.
+ */
+#include <asn_internal.h>
+#include <NativeInteger.h>
+
+/*
+ * NativeInteger basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = {
+       (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NativeInteger = {
+       "INTEGER",                      /* The ASN.1 type is still INTEGER */
+       "INTEGER",
+       NativeInteger_free,
+       NativeInteger_print,
+       asn_generic_no_constraint,
+       NativeInteger_decode_ber,
+       NativeInteger_encode_der,
+       NativeInteger_decode_xer,
+       NativeInteger_encode_xer,
+       NativeInteger_decode_uper,      /* Unaligned PER decoder */
+       NativeInteger_encode_uper,      /* Unaligned PER encoder */
+       0, /* Use generic outmost tag fetcher */
+       asn_DEF_NativeInteger_tags,
+       sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
+       asn_DEF_NativeInteger_tags,     /* Same as above */
+       sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
+       0,      /* No PER visible constraints */
+       0, 0,   /* No members */
+       0       /* No specifics */
+};
+
+/*
+ * Decode INTEGER type.
+ */
+asn_dec_rval_t
+NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td,
+       void **nint_ptr, const void *buf_ptr, size_t size, int tag_mode) {
+       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+       long *native = (long *)*nint_ptr;
+       asn_dec_rval_t rval;
+       ber_tlv_len_t length;
+
+       /*
+        * If the structure is not there, allocate it.
+        */
+       if(native == NULL) {
+               native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native)));
+               if(native == NULL) {
+                       rval.code = RC_FAIL;
+                       rval.consumed = 0;
+                       return rval;
+               }
+       }
+
+       ASN_DEBUG("Decoding %s as INTEGER (tm=%d)",
+               td->name, tag_mode);
+
+       /*
+        * Check tags.
+        */
+       rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
+                       tag_mode, 0, &length, 0);
+       if(rval.code != RC_OK)
+               return rval;
+
+       ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
+
+       /*
+        * Make sure we have this length.
+        */
+       buf_ptr = ((const char *)buf_ptr) + rval.consumed;
+       size -= rval.consumed;
+       if(length > (ber_tlv_len_t)size) {
+               rval.code = RC_WMORE;
+               rval.consumed = 0;
+               return rval;
+       }
+
+       /*
+        * ASN.1 encoded INTEGER: buf_ptr, length
+        * Fill the native, at the same time checking for overflow.
+        * If overflow occured, return with RC_FAIL.
+        */
+       {
+               INTEGER_t tmp;
+               union {
+                       const void *constbuf;
+                       void *nonconstbuf;
+               } unconst_buf;
+               long l;
+
+               unconst_buf.constbuf = buf_ptr;
+               tmp.buf = (uint8_t *)unconst_buf.nonconstbuf;
+               tmp.size = length;
+
+               if((specs&&specs->field_unsigned)
+                       ? asn_INTEGER2ulong(&tmp, (unsigned long *)&l) /* sic */
+                       : asn_INTEGER2long(&tmp, &l)) {
+                       rval.code = RC_FAIL;
+                       rval.consumed = 0;
+                       return rval;
+               }
+
+               *native = l;
+       }
+
+       rval.code = RC_OK;
+       rval.consumed += length;
+
+       ASN_DEBUG("Took %ld/%ld bytes to encode %s (%ld)",
+               (long)rval.consumed, (long)length, td->name, (long)*native);
+
+       return rval;
+}
+
+/*
+ * Encode the NativeInteger using the standard INTEGER type DER encoder.
+ */
+asn_enc_rval_t
+NativeInteger_encode_der(asn_TYPE_descriptor_t *sd, void *ptr,
+       int tag_mode, ber_tlv_tag_t tag,
+       asn_app_consume_bytes_f *cb, void *app_key) {
+       unsigned long native = *(unsigned long *)ptr;   /* Disable sign ext. */
+       asn_enc_rval_t erval;
+       INTEGER_t tmp;
+
+#ifdef WORDS_BIGENDIAN         /* Opportunistic optimization */
+
+       tmp.buf = (uint8_t *)&native;
+       tmp.size = sizeof(native);
+
+#else  /* Works even if WORDS_BIGENDIAN is not set where should've been */
+       uint8_t buf[sizeof(native)];
+       uint8_t *p;
+
+       /* Prepare a fake INTEGER */
+       for(p = buf + sizeof(buf) - 1; p >= buf; p--, native >>= 8)
+               *p = (uint8_t)native;
+
+       tmp.buf = buf;
+       tmp.size = sizeof(buf);
+#endif /* WORDS_BIGENDIAN */
+       
+       /* Encode fake INTEGER */
+       erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key);
+       if(erval.encoded == -1) {
+               assert(erval.structure_ptr == &tmp);
+               erval.structure_ptr = ptr;
+       }
+       return erval;
+}
+
+/*
+ * Decode the chunk of XML text encoding INTEGER.
+ */
+asn_dec_rval_t
+NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
+               const void *buf_ptr, size_t size) {
+       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+       asn_dec_rval_t rval;
+       INTEGER_t st;
+       void *st_ptr = (void *)&st;
+       long *native = (long *)*sptr;
+
+       if(!native) {
+               native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+               if(!native) _ASN_DECODE_FAILED;
+       }
+
+       memset(&st, 0, sizeof(st));
+       rval = INTEGER_decode_xer(opt_codec_ctx, td, &st_ptr, 
+               opt_mname, buf_ptr, size);
+       if(rval.code == RC_OK) {
+               long l;
+               if((specs&&specs->field_unsigned)
+                       ? asn_INTEGER2ulong(&st, (unsigned long *)&l) /* sic */
+                       : asn_INTEGER2long(&st, &l)) {
+                       rval.code = RC_FAIL;
+                       rval.consumed = 0;
+               } else {
+                       *native = l;
+               }
+       } else {
+               /*
+                * Cannot restart from the middle;
+                * there is no place to save state in the native type.
+                * Request a continuation from the very beginning.
+                */
+               rval.consumed = 0;
+       }
+       ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &st);
+       return rval;
+}
+
+
+asn_enc_rval_t
+NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+       int ilevel, enum xer_encoder_flags_e flags,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+       char scratch[32];       /* Enough for 64-bit int */
+       asn_enc_rval_t er;
+       const long *native = (const long *)sptr;
+
+       (void)ilevel;
+       (void)flags;
+
+       if(!native) _ASN_ENCODE_FAILED;
+
+       er.encoded = snprintf(scratch, sizeof(scratch),
+                       (specs && specs->field_unsigned)
+                       ? "%lu" : "%ld", *native);
+       if(er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch)
+               || cb(scratch, er.encoded, app_key) < 0)
+               _ASN_ENCODE_FAILED;
+
+       _ASN_ENCODED_OK(er);
+}
+
+asn_dec_rval_t
+NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td,
+       asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+
+       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+       asn_dec_rval_t rval;
+       long *native = (long *)*sptr;
+       INTEGER_t tmpint;
+       void *tmpintptr = &tmpint;
+
+       (void)opt_codec_ctx;
+       ASN_DEBUG("Decoding NativeInteger %s (UPER)", td->name);
+
+       if(!native) {
+               native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+               if(!native) _ASN_DECODE_FAILED;
+       }
+
+       memset(&tmpint, 0, sizeof tmpint);
+       rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints,
+                                  &tmpintptr, pd);
+       if(rval.code == RC_OK) {
+               if((specs&&specs->field_unsigned)
+                       ? asn_INTEGER2ulong(&tmpint, (unsigned long *)native)
+                       : asn_INTEGER2long(&tmpint, native))
+                       rval.code = RC_FAIL;
+               else
+                       ASN_DEBUG("NativeInteger %s got value %ld",
+                               td->name, *native);
+       }
+       ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+
+       return rval;
+}
+
+asn_enc_rval_t
+NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
+       asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+       asn_enc_rval_t er;
+       long native;
+       INTEGER_t tmpint;
+
+       if(!sptr) _ASN_ENCODE_FAILED;
+
+       native = *(long *)sptr;
+
+       ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);
+
+       memset(&tmpint, 0, sizeof(tmpint));
+       if((specs&&specs->field_unsigned)
+               ? asn_ulong2INTEGER(&tmpint, native)
+               : asn_long2INTEGER(&tmpint, native))
+               _ASN_ENCODE_FAILED;
+       er = INTEGER_encode_uper(td, constraints, &tmpint, po);
+       ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+       return er;
+}
+
+/*
+ * INTEGER specific human-readable output.
+ */
+int
+NativeInteger_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+       asn_app_consume_bytes_f *cb, void *app_key) {
+       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+       const long *native = (const long *)sptr;
+       char scratch[32];       /* Enough for 64-bit int */
+       int ret;
+
+       (void)td;       /* Unused argument */
+       (void)ilevel;   /* Unused argument */
+
+       if(native) {
+               ret = snprintf(scratch, sizeof(scratch),
+                       (specs && specs->field_unsigned)
+                       ? "%lu" : "%ld", *native);
+               assert(ret > 0 && (size_t)ret < sizeof(scratch));
+               return (cb(scratch, ret, app_key) < 0) ? -1 : 0;
+       } else {
+               return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+       }
+}
+
+void
+NativeInteger_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+
+       if(!td || !ptr)
+               return;
+
+       ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",
+               td->name, contents_only, ptr);
+
+       if(!contents_only) {
+               FREEMEM(ptr);
+       }
+}
+
diff --git a/src/asn1c/NativeInteger.h b/src/asn1c/NativeInteger.h
new file mode 100644 (file)
index 0000000..4e63a83
--- /dev/null
@@ -0,0 +1,37 @@
+/*-
+ * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * This type differs from the standard INTEGER in that it is modelled using
+ * the fixed machine type (long, int, short), so it can hold only values of
+ * limited length. There is no type (i.e., NativeInteger_t, any integer type
+ * will do).
+ * This type may be used when integer range is limited by subtype constraints.
+ */
+#ifndef        _NativeInteger_H_
+#define        _NativeInteger_H_
+
+#include <asn_application.h>
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern asn_TYPE_descriptor_t asn_DEF_NativeInteger;
+
+asn_struct_free_f  NativeInteger_free;
+asn_struct_print_f NativeInteger_print;
+ber_type_decoder_f NativeInteger_decode_ber;
+der_type_encoder_f NativeInteger_encode_der;
+xer_type_decoder_f NativeInteger_decode_xer;
+xer_type_encoder_f NativeInteger_encode_xer;
+per_type_decoder_f NativeInteger_decode_uper;
+per_type_encoder_f NativeInteger_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _NativeInteger_H_ */
diff --git a/src/asn1c/OCTET_STRING.c b/src/asn1c/OCTET_STRING.c
new file mode 100644 (file)
index 0000000..f2eec13
--- /dev/null
@@ -0,0 +1,1805 @@
+/*-
+ * Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <OCTET_STRING.h>
+#include <BIT_STRING.h>        /* for .bits_unused member */
+#include <errno.h>
+
+/*
+ * OCTET STRING basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_OCTET_STRING_tags[] = {
+       (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+static asn_OCTET_STRING_specifics_t asn_DEF_OCTET_STRING_specs = {
+       sizeof(OCTET_STRING_t),
+       offsetof(OCTET_STRING_t, _asn_ctx),
+       ASN_OSUBV_STR
+};
+static asn_per_constraints_t asn_DEF_OCTET_STRING_constraints = {
+       { APC_CONSTRAINED, 8, 8, 0, 255 },
+       { APC_SEMI_CONSTRAINED, -1, -1, 0, 0 },
+       0, 0
+};
+asn_TYPE_descriptor_t asn_DEF_OCTET_STRING = {
+       "OCTET STRING",         /* Canonical name */
+       "OCTET_STRING",         /* XML tag name */
+       OCTET_STRING_free,
+       OCTET_STRING_print,     /* non-ascii stuff, generally */
+       asn_generic_no_constraint,
+       OCTET_STRING_decode_ber,
+       OCTET_STRING_encode_der,
+       OCTET_STRING_decode_xer_hex,
+       OCTET_STRING_encode_xer,
+       OCTET_STRING_decode_uper,       /* Unaligned PER decoder */
+       OCTET_STRING_encode_uper,       /* Unaligned PER encoder */
+       0, /* Use generic outmost tag fetcher */
+       asn_DEF_OCTET_STRING_tags,
+       sizeof(asn_DEF_OCTET_STRING_tags)
+         / sizeof(asn_DEF_OCTET_STRING_tags[0]),
+       asn_DEF_OCTET_STRING_tags,      /* Same as above */
+       sizeof(asn_DEF_OCTET_STRING_tags)
+         / sizeof(asn_DEF_OCTET_STRING_tags[0]),
+       0,      /* No PER visible constraints */
+       0, 0,   /* No members */
+       &asn_DEF_OCTET_STRING_specs
+};
+
+#undef _CH_PHASE
+#undef NEXT_PHASE
+#undef PREV_PHASE
+#define        _CH_PHASE(ctx, inc) do {                                        \
+               if(ctx->phase == 0)                                     \
+                       ctx->context = 0;                               \
+               ctx->phase += inc;                                      \
+       } while(0)
+#define        NEXT_PHASE(ctx) _CH_PHASE(ctx, +1)
+#define        PREV_PHASE(ctx) _CH_PHASE(ctx, -1)
+
+#undef ADVANCE
+#define        ADVANCE(num_bytes)      do {                                    \
+               size_t num = (num_bytes);                               \
+               buf_ptr = ((const char *)buf_ptr) + num;                \
+               size -= num;                                            \
+               consumed_myself += num;                                 \
+       } while(0)
+
+#undef RETURN
+#define        RETURN(_code)   do {                                            \
+               asn_dec_rval_t tmprval;                                 \
+               tmprval.code = _code;                                   \
+               tmprval.consumed = consumed_myself;                     \
+               return tmprval;                                         \
+       } while(0)
+
+#undef APPEND
+#define        APPEND(bufptr, bufsize) do {                                    \
+               size_t _bs = (bufsize);         /* Append size */       \
+               size_t _ns = ctx->context;      /* Allocated now */     \
+               size_t _es = st->size + _bs;    /* Expected size */     \
+               /* int is really a typeof(st->size): */                 \
+               if((int)_es < 0) RETURN(RC_FAIL);                       \
+               if(_ns <= _es) {                                        \
+                       void *ptr;                                      \
+                       /* Be nice and round to the memory allocator */ \
+                       do { _ns = _ns ? _ns << 1 : 16; }               \
+                           while(_ns <= _es);                          \
+                       /* int is really a typeof(st->size): */         \
+                       if((int)_ns < 0) RETURN(RC_FAIL);               \
+                       ptr = REALLOC(st->buf, _ns);                    \
+                       if(ptr) {                                       \
+                               st->buf = (uint8_t *)ptr;               \
+                               ctx->context = _ns;                     \
+                       } else {                                        \
+                               RETURN(RC_FAIL);                        \
+                       }                                               \
+                       ASN_DEBUG("Reallocating into %ld", (long)_ns);  \
+               }                                                       \
+               memcpy(st->buf + st->size, bufptr, _bs);                \
+               /* Convenient nul-termination */                        \
+               st->buf[_es] = '\0';                                    \
+               st->size = _es;                                         \
+       } while(0)
+
+/*
+ * The main reason why ASN.1 is still alive is that too much time and effort
+ * is necessary for learning it more or less adequately, thus creating a gut
+ * necessity to demonstrate that aquired skill everywhere afterwards.
+ * No, I am not going to explain what the following stuff is.
+ */
+struct _stack_el {
+       ber_tlv_len_t   left;   /* What's left to read (or -1) */
+       ber_tlv_len_t   got;    /* What was actually processed */
+       int     cont_level;     /* Depth of subcontainment */
+       int     want_nulls;     /* Want null "end of content" octets? */
+       int     bits_chopped;   /* Flag in BIT STRING mode */
+       ber_tlv_tag_t   tag;    /* For debugging purposes */
+       struct _stack_el *prev;
+       struct _stack_el *next;
+};
+struct _stack {
+       struct _stack_el *tail;
+       struct _stack_el *cur_ptr;
+};
+
+static struct _stack_el *
+OS__add_stack_el(struct _stack *st) {
+       struct _stack_el *nel;
+
+       /*
+        * Reuse the old stack frame or allocate a new one.
+        */
+       if(st->cur_ptr && st->cur_ptr->next) {
+               nel = st->cur_ptr->next;
+               nel->bits_chopped = 0;
+               nel->got = 0;
+               /* Retain the nel->cont_level, it's correct. */
+       } else {
+               nel = (struct _stack_el *)CALLOC(1, sizeof(struct _stack_el));
+               if(nel == NULL)
+                       return NULL;
+       
+               if(st->tail) {
+                       /* Increase a subcontainment depth */
+                       nel->cont_level = st->tail->cont_level + 1;
+                       st->tail->next = nel;
+               }
+               nel->prev = st->tail;
+               st->tail = nel;
+       }
+
+       st->cur_ptr = nel;
+
+       return nel;
+}
+
+static struct _stack *
+_new_stack() {
+       return (struct _stack *)CALLOC(1, sizeof(struct _stack));
+}
+
+/*
+ * Decode OCTET STRING type.
+ */
+asn_dec_rval_t
+OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td,
+       void **sptr, const void *buf_ptr, size_t size, int tag_mode) {
+       asn_OCTET_STRING_specifics_t *specs = td->specifics
+                               ? (asn_OCTET_STRING_specifics_t *)td->specifics
+                               : &asn_DEF_OCTET_STRING_specs;
+       BIT_STRING_t *st = (BIT_STRING_t *)*sptr;
+       asn_dec_rval_t rval;
+       asn_struct_ctx_t *ctx;
+       ssize_t consumed_myself = 0;
+       struct _stack *stck;            /* Expectations stack structure */
+       struct _stack_el *sel = 0;      /* Stack element */
+       int tlv_constr;
+       enum asn_OS_Subvariant type_variant = specs->subvariant;
+
+       ASN_DEBUG("Decoding %s as %s (frame %ld)",
+               td->name,
+               (type_variant == ASN_OSUBV_STR) ?
+                       "OCTET STRING" : "OS-SpecialCase",
+               (long)size);
+
+       /*
+        * Create the string if does not exist.
+        */
+       if(st == NULL) {
+               st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
+               if(st == NULL) RETURN(RC_FAIL);
+       }
+
+       /* Restore parsing context */
+       ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
+
+       switch(ctx->phase) {
+       case 0:
+               /*
+                * Check tags.
+                */
+               rval = ber_check_tags(opt_codec_ctx, td, ctx,
+                       buf_ptr, size, tag_mode, -1,
+                       &ctx->left, &tlv_constr);
+               if(rval.code != RC_OK)
+                       return rval;
+
+               if(tlv_constr) {
+                       /*
+                        * Complex operation, requires stack of expectations.
+                        */
+                       ctx->ptr = _new_stack();
+                       if(ctx->ptr) {
+                               stck = (struct _stack *)ctx->ptr;
+                       } else {
+                               RETURN(RC_FAIL);
+                       }
+               } else {
+                       /*
+                        * Jump into stackless primitive decoding.
+                        */
+                       _CH_PHASE(ctx, 3);
+                       if(type_variant == ASN_OSUBV_ANY && tag_mode != 1)
+                               APPEND(buf_ptr, rval.consumed);
+                       ADVANCE(rval.consumed);
+                       goto phase3;
+               }
+
+               NEXT_PHASE(ctx);
+               /* Fall through */
+       case 1:
+       phase1:
+               /*
+                * Fill the stack with expectations.
+                */
+               stck = (struct _stack *)ctx->ptr;
+               sel = stck->cur_ptr;
+         do {
+               ber_tlv_tag_t tlv_tag;
+               ber_tlv_len_t tlv_len;
+               ber_tlv_tag_t expected_tag;
+               ssize_t tl, ll, tlvl;
+                               /* This one works even if (sel->left == -1) */
+               ssize_t Left = ((!sel||(size_t)sel->left >= size)
+                                       ?(ssize_t)size:sel->left);
+
+
+               ASN_DEBUG("%p, s->l=%ld, s->wn=%ld, s->g=%ld\n", sel,
+                       (long)(sel?sel->left:0),
+                       (long)(sel?sel->want_nulls:0),
+                       (long)(sel?sel->got:0)
+               );
+               if(sel && sel->left <= 0 && sel->want_nulls == 0) {
+                       if(sel->prev) {
+                               struct _stack_el *prev = sel->prev;
+                               if(prev->left != -1) {
+                                       if(prev->left < sel->got)
+                                               RETURN(RC_FAIL);
+                                       prev->left -= sel->got;
+                               }
+                               prev->got += sel->got;
+                               sel = stck->cur_ptr = prev;
+                               if(!sel) break;
+                               tlv_constr = 1;
+                               continue;
+                       } else {
+                               sel = stck->cur_ptr = 0;
+                               break;  /* Nothing to wait */
+                       }
+               }
+
+               tl = ber_fetch_tag(buf_ptr, Left, &tlv_tag);
+               ASN_DEBUG("fetch tag(size=%ld,L=%ld), %sstack, left=%ld, wn=%ld, tl=%ld",
+                       (long)size, (long)Left, sel?"":"!",
+                       (long)(sel?sel->left:0),
+                       (long)(sel?sel->want_nulls:0),
+                       (long)tl);
+               switch(tl) {
+               case -1: RETURN(RC_FAIL);
+               case 0: RETURN(RC_WMORE);
+               }
+
+               tlv_constr = BER_TLV_CONSTRUCTED(buf_ptr);
+
+               ll = ber_fetch_length(tlv_constr,
+                               (const char *)buf_ptr + tl,Left - tl,&tlv_len);
+               ASN_DEBUG("Got tag=%s, tc=%d, left=%ld, tl=%ld, len=%ld, ll=%ld",
+                       ber_tlv_tag_string(tlv_tag), tlv_constr,
+                               (long)Left, (long)tl, (long)tlv_len, (long)ll);
+               switch(ll) {
+               case -1: RETURN(RC_FAIL);
+               case 0: RETURN(RC_WMORE);
+               }
+
+               if(sel && sel->want_nulls
+                       && ((const uint8_t *)buf_ptr)[0] == 0
+                       && ((const uint8_t *)buf_ptr)[1] == 0)
+               {
+
+                       ASN_DEBUG("Eat EOC; wn=%d--", sel->want_nulls);
+
+                       if(type_variant == ASN_OSUBV_ANY
+                       && (tag_mode != 1 || sel->cont_level))
+                               APPEND("\0\0", 2);
+
+                       ADVANCE(2);
+                       sel->got += 2;
+                       if(sel->left != -1) {
+                               sel->left -= 2; /* assert(sel->left >= 2) */
+                       }
+
+                       sel->want_nulls--;
+                       if(sel->want_nulls == 0) {
+                               /* Move to the next expectation */
+                               sel->left = 0;
+                               tlv_constr = 1;
+                       }
+
+                       continue;
+               }
+
+               /*
+                * Set up expected tags,
+                * depending on ASN.1 type being decoded.
+                */
+               switch(type_variant) {
+               case ASN_OSUBV_BIT:
+                       /* X.690: 8.6.4.1, NOTE 2 */
+                       /* Fall through */
+               case ASN_OSUBV_STR:
+               default:
+                       if(sel) {
+                               int level = sel->cont_level;
+                               if(level < td->all_tags_count) {
+                                       expected_tag = td->all_tags[level];
+                                       break;
+                               } else if(td->all_tags_count) {
+                                       expected_tag = td->all_tags
+                                               [td->all_tags_count - 1];
+                                       break;
+                               }
+                               /* else, Fall through */
+                       }
+                       /* Fall through */
+               case ASN_OSUBV_ANY:
+                       expected_tag = tlv_tag;
+                       break;
+               }
+
+
+               if(tlv_tag != expected_tag) {
+                       char buf[2][32];
+                       ber_tlv_tag_snprint(tlv_tag,
+                               buf[0], sizeof(buf[0]));
+                       ber_tlv_tag_snprint(td->tags[td->tags_count-1],
+                               buf[1], sizeof(buf[1]));
+                       ASN_DEBUG("Tag does not match expectation: %s != %s",
+                               buf[0], buf[1]);
+                       RETURN(RC_FAIL);
+               }
+
+               tlvl = tl + ll; /* Combined length of T and L encoding */
+               if((tlv_len + tlvl) < 0) {
+                       /* tlv_len value is too big */
+                       ASN_DEBUG("TLV encoding + length (%ld) is too big",
+                               (long)tlv_len);
+                       RETURN(RC_FAIL);
+               }
+
+               /*
+                * Append a new expectation.
+                */
+               sel = OS__add_stack_el(stck);
+               if(!sel) RETURN(RC_FAIL);
+
+               sel->tag = tlv_tag;
+
+               sel->want_nulls = (tlv_len==-1);
+               if(sel->prev && sel->prev->left != -1) {
+                       /* Check that the parent frame is big enough */
+                       if(sel->prev->left < tlvl + (tlv_len==-1?0:tlv_len))
+                               RETURN(RC_FAIL);
+                       if(tlv_len == -1)
+                               sel->left = sel->prev->left - tlvl;
+                       else
+                               sel->left = tlv_len;
+               } else {
+                       sel->left = tlv_len;
+               }
+               if(type_variant == ASN_OSUBV_ANY
+               && (tag_mode != 1 || sel->cont_level))
+                       APPEND(buf_ptr, tlvl);
+               sel->got += tlvl;
+               ADVANCE(tlvl);
+
+               ASN_DEBUG("+EXPECT2 got=%ld left=%ld, wn=%d, clvl=%d",
+                       (long)sel->got, (long)sel->left,
+                       sel->want_nulls, sel->cont_level);
+
+         } while(tlv_constr);
+               if(sel == NULL) {
+                       /* Finished operation, "phase out" */
+                       ASN_DEBUG("Phase out");
+                       _CH_PHASE(ctx, +3);
+                       break;
+               }
+
+               NEXT_PHASE(ctx);
+               /* Fall through */
+       case 2:
+               stck = (struct _stack *)ctx->ptr;
+               sel = stck->cur_ptr;
+               ASN_DEBUG("Phase 2: Need %ld bytes, size=%ld, alrg=%ld, wn=%d",
+                       (long)sel->left, (long)size, (long)sel->got,
+                               sel->want_nulls);
+           {
+               ber_tlv_len_t len;
+
+               assert(sel->left >= 0);
+
+               len = ((ber_tlv_len_t)size < sel->left)
+                               ? (ber_tlv_len_t)size : sel->left;
+               if(len > 0) {
+                       if(type_variant == ASN_OSUBV_BIT
+                       && sel->bits_chopped == 0) {
+                               /* Put the unused-bits-octet away */
+                               st->bits_unused = *(const uint8_t *)buf_ptr;
+                               APPEND(((const char *)buf_ptr+1), (len - 1));
+                               sel->bits_chopped = 1;
+                       } else {
+                               APPEND(buf_ptr, len);
+                       }
+                       ADVANCE(len);
+                       sel->left -= len;
+                       sel->got += len;
+               }
+
+               if(sel->left) {
+                       ASN_DEBUG("OS left %ld, size = %ld, wn=%d\n",
+                               (long)sel->left, (long)size, sel->want_nulls);
+                       RETURN(RC_WMORE);
+               }
+
+               PREV_PHASE(ctx);
+               goto phase1;
+           }
+               break;
+       case 3:
+       phase3:
+               /*
+                * Primitive form, no stack required.
+                */
+               assert(ctx->left >= 0);
+
+               if(size < (size_t)ctx->left) {
+                       if(!size) RETURN(RC_WMORE);
+                       if(type_variant == ASN_OSUBV_BIT && !ctx->context) {
+                               st->bits_unused = *(const uint8_t *)buf_ptr;
+                               ctx->left--;
+                               ADVANCE(1);
+                       }
+                       APPEND(buf_ptr, size);
+                       assert(ctx->context > 0);
+                       ctx->left -= size;
+                       ADVANCE(size);
+                       RETURN(RC_WMORE);
+               } else {
+                       if(type_variant == ASN_OSUBV_BIT
+                       && !ctx->context && ctx->left) {
+                               st->bits_unused = *(const uint8_t *)buf_ptr;
+                               ctx->left--;
+                               ADVANCE(1);
+                       }
+                       APPEND(buf_ptr, ctx->left);
+                       ADVANCE(ctx->left);
+                       ctx->left = 0;
+
+                       NEXT_PHASE(ctx);
+               }
+               break;
+       }
+
+       if(sel) {
+               ASN_DEBUG("3sel p=%p, wn=%d, l=%ld, g=%ld, size=%ld",
+                       sel->prev, sel->want_nulls,
+                       (long)sel->left, (long)sel->got, (long)size);
+               if(sel->prev || sel->want_nulls > 1 || sel->left > 0) {
+                       RETURN(RC_WMORE);
+               }
+       }
+
+       /*
+        * BIT STRING-specific processing.
+        */
+       if(type_variant == ASN_OSUBV_BIT && st->size) {
+               /* Finalize BIT STRING: zero out unused bits. */
+               st->buf[st->size-1] &= 0xff << st->bits_unused;
+       }
+
+       ASN_DEBUG("Took %ld bytes to encode %s: [%s]:%ld",
+               (long)consumed_myself, td->name,
+               (type_variant == ASN_OSUBV_STR) ? (char *)st->buf : "<data>",
+               (long)st->size);
+
+
+       RETURN(RC_OK);
+}
+
+/*
+ * Encode OCTET STRING type using DER.
+ */
+asn_enc_rval_t
+OCTET_STRING_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
+       int tag_mode, ber_tlv_tag_t tag,
+       asn_app_consume_bytes_f *cb, void *app_key) {
+       asn_enc_rval_t er;
+       asn_OCTET_STRING_specifics_t *specs = td->specifics
+                               ? (asn_OCTET_STRING_specifics_t *)td->specifics
+                               : &asn_DEF_OCTET_STRING_specs;
+       BIT_STRING_t *st = (BIT_STRING_t *)sptr;
+       enum asn_OS_Subvariant type_variant = specs->subvariant;
+       int fix_last_byte = 0;
+
+       ASN_DEBUG("%s %s as OCTET STRING",
+               cb?"Estimating":"Encoding", td->name);
+
+       /*
+        * Write tags.
+        */
+       if(type_variant != ASN_OSUBV_ANY || tag_mode == 1) {
+               er.encoded = der_write_tags(td,
+                               (type_variant == ASN_OSUBV_BIT) + st->size,
+                       tag_mode, type_variant == ASN_OSUBV_ANY, tag,
+                       cb, app_key);
+               if(er.encoded == -1) {
+                       er.failed_type = td;
+                       er.structure_ptr = sptr;
+                       return er;
+               }
+       } else {
+               /* Disallow: [<tag>] IMPLICIT ANY */
+               assert(type_variant != ASN_OSUBV_ANY || tag_mode != -1);
+               er.encoded = 0;
+       }
+
+       if(!cb) {
+               er.encoded += (type_variant == ASN_OSUBV_BIT) + st->size;
+               _ASN_ENCODED_OK(er);
+       }
+
+       /*
+        * Prepare to deal with the last octet of BIT STRING.
+        */
+       if(type_variant == ASN_OSUBV_BIT) {
+               uint8_t b = st->bits_unused & 0x07;
+               if(b && st->size) fix_last_byte = 1;
+               _ASN_CALLBACK(&b, 1);
+               er.encoded++;
+       }
+
+       /* Invoke callback for the main part of the buffer */
+       _ASN_CALLBACK(st->buf, st->size - fix_last_byte);
+
+       /* The last octet should be stripped off the unused bits */
+       if(fix_last_byte) {
+               uint8_t b = st->buf[st->size-1] & (0xff << st->bits_unused);
+               _ASN_CALLBACK(&b, 1);
+       }
+
+       er.encoded += st->size;
+       _ASN_ENCODED_OK(er);
+cb_failed:
+       _ASN_ENCODE_FAILED;
+}
+
+asn_enc_rval_t
+OCTET_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+       int ilevel, enum xer_encoder_flags_e flags,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       static const char *h2c = "0123456789ABCDEF";
+       const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+       asn_enc_rval_t er;
+       char scratch[16 * 3 + 4];
+       char *p = scratch;
+       uint8_t *buf;
+       uint8_t *end;
+       size_t i;
+
+       if(!st || (!st->buf && st->size))
+               _ASN_ENCODE_FAILED;
+
+       er.encoded = 0;
+
+       /*
+        * Dump the contents of the buffer in hexadecimal.
+        */
+       buf = st->buf;
+       end = buf + st->size;
+       if(flags & XER_F_CANONICAL) {
+               char *scend = scratch + (sizeof(scratch) - 2);
+               for(; buf < end; buf++) {
+                       if(p >= scend) {
+                               _ASN_CALLBACK(scratch, p - scratch);
+                               er.encoded += p - scratch;
+                               p = scratch;
+                       }
+                       *p++ = h2c[(*buf >> 4) & 0x0F];
+                       *p++ = h2c[*buf & 0x0F];
+               }
+
+               _ASN_CALLBACK(scratch, p-scratch);      /* Dump the rest */
+               er.encoded += p - scratch;
+       } else {
+               for(i = 0; buf < end; buf++, i++) {
+                       if(!(i % 16) && (i || st->size > 16)) {
+                               _ASN_CALLBACK(scratch, p-scratch);
+                               er.encoded += (p-scratch);
+                               p = scratch;
+                               _i_ASN_TEXT_INDENT(1, ilevel);
+                       }
+                       *p++ = h2c[(*buf >> 4) & 0x0F];
+                       *p++ = h2c[*buf & 0x0F];
+                       *p++ = 0x20;
+               }
+               if(p - scratch) {
+                       p--;    /* Remove the tail space */
+                       _ASN_CALLBACK(scratch, p-scratch); /* Dump the rest */
+                       er.encoded += p - scratch;
+                       if(st->size > 16)
+                               _i_ASN_TEXT_INDENT(1, ilevel-1);
+               }
+       }
+
+       _ASN_ENCODED_OK(er);
+cb_failed:
+       _ASN_ENCODE_FAILED;
+}
+
+static struct OCTET_STRING__xer_escape_table_s {
+       char *string;
+       int size;
+} OCTET_STRING__xer_escape_table[] = {
+#define        OSXET(s)        { s, sizeof(s) - 1 }
+       OSXET("\074\156\165\154\057\076"),      /* <nul/> */
+       OSXET("\074\163\157\150\057\076"),      /* <soh/> */
+       OSXET("\074\163\164\170\057\076"),      /* <stx/> */
+       OSXET("\074\145\164\170\057\076"),      /* <etx/> */
+       OSXET("\074\145\157\164\057\076"),      /* <eot/> */
+       OSXET("\074\145\156\161\057\076"),      /* <enq/> */
+       OSXET("\074\141\143\153\057\076"),      /* <ack/> */
+       OSXET("\074\142\145\154\057\076"),      /* <bel/> */
+       OSXET("\074\142\163\057\076"),          /* <bs/> */
+       OSXET("\011"),                          /* \t */
+       OSXET("\012"),                          /* \n */
+       OSXET("\074\166\164\057\076"),          /* <vt/> */
+       OSXET("\074\146\146\057\076"),          /* <ff/> */
+       OSXET("\015"),                          /* \r */
+       OSXET("\074\163\157\057\076"),          /* <so/> */
+       OSXET("\074\163\151\057\076"),          /* <si/> */
+       OSXET("\074\144\154\145\057\076"),      /* <dle/> */
+       OSXET("\074\144\143\061\057\076"),      /* <de1/> */
+       OSXET("\074\144\143\062\057\076"),      /* <de2/> */
+       OSXET("\074\144\143\063\057\076"),      /* <de3/> */
+       OSXET("\074\144\143\064\057\076"),      /* <de4/> */
+       OSXET("\074\156\141\153\057\076"),      /* <nak/> */
+       OSXET("\074\163\171\156\057\076"),      /* <syn/> */
+       OSXET("\074\145\164\142\057\076"),      /* <etb/> */
+       OSXET("\074\143\141\156\057\076"),      /* <can/> */
+       OSXET("\074\145\155\057\076"),          /* <em/> */
+       OSXET("\074\163\165\142\057\076"),      /* <sub/> */
+       OSXET("\074\145\163\143\057\076"),      /* <esc/> */
+       OSXET("\074\151\163\064\057\076"),      /* <is4/> */
+       OSXET("\074\151\163\063\057\076"),      /* <is3/> */
+       OSXET("\074\151\163\062\057\076"),      /* <is2/> */
+       OSXET("\074\151\163\061\057\076"),      /* <is1/> */
+       { 0, 0 },       /* " " */
+       { 0, 0 },       /* ! */
+       { 0, 0 },       /* \" */
+       { 0, 0 },       /* # */
+       { 0, 0 },       /* $ */
+       { 0, 0 },       /* % */
+       OSXET("\046\141\155\160\073"),  /* &amp; */
+       { 0, 0 },       /* ' */
+       {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, /* ()*+,-./ */
+       {0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, /* 01234567 */
+       {0,0},{0,0},{0,0},{0,0},                         /* 89:; */
+       OSXET("\046\154\164\073"),      /* &lt; */
+       { 0, 0 },       /* = */
+       OSXET("\046\147\164\073"),      /* &gt; */
+};
+
+static int
+OS__check_escaped_control_char(const void *buf, int size) {
+       size_t i;
+       /*
+        * Inefficient algorithm which translates the escape sequences
+        * defined above into characters. Returns -1 if not found.
+        * TODO: replace by a faster algorithm (bsearch(), hash or
+        * nested table lookups).
+        */
+       for(i = 0; i < 32 /* Don't spend time on the bottom half */; i++) {
+               struct OCTET_STRING__xer_escape_table_s *el;
+               el = &OCTET_STRING__xer_escape_table[i];
+               if(el->size == size && memcmp(buf, el->string, size) == 0)
+                       return i;
+       }
+       return -1;
+}
+
+static int
+OCTET_STRING__handle_control_chars(void *struct_ptr, const void *chunk_buf, size_t chunk_size) {
+       /*
+        * This might be one of the escape sequences
+        * for control characters. Check it out.
+        * #11.15.5
+        */
+       int control_char = OS__check_escaped_control_char(chunk_buf,chunk_size);
+       if(control_char >= 0) {
+               OCTET_STRING_t *st = (OCTET_STRING_t *)struct_ptr;
+               void *p = REALLOC(st->buf, st->size + 2);
+               if(p) {
+                       st->buf = (uint8_t *)p;
+                       st->buf[st->size++] = control_char;
+                       st->buf[st->size] = '\0';       /* nul-termination */
+                       return 0;
+               }
+       }
+       
+       return -1;      /* No, it's not */
+}
+
+asn_enc_rval_t
+OCTET_STRING_encode_xer_utf8(asn_TYPE_descriptor_t *td, void *sptr,
+       int ilevel, enum xer_encoder_flags_e flags,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+       asn_enc_rval_t er;
+       uint8_t *buf, *end;
+       uint8_t *ss;    /* Sequence start */
+       ssize_t encoded_len = 0;
+
+       (void)ilevel;   /* Unused argument */
+       (void)flags;    /* Unused argument */
+
+       if(!st || (!st->buf && st->size))
+               _ASN_ENCODE_FAILED;
+
+       buf = st->buf;
+       end = buf + st->size;
+       for(ss = buf; buf < end; buf++) {
+               unsigned int ch = *buf;
+               int s_len;      /* Special encoding sequence length */
+
+               /*
+                * Escape certain characters: X.680/11.15
+                */
+               if(ch < sizeof(OCTET_STRING__xer_escape_table)
+                       /sizeof(OCTET_STRING__xer_escape_table[0])
+               && (s_len = OCTET_STRING__xer_escape_table[ch].size)) {
+                       if(((buf - ss) && cb(ss, buf - ss, app_key) < 0)
+                       || cb(OCTET_STRING__xer_escape_table[ch].string, s_len,
+                                       app_key) < 0)
+                               _ASN_ENCODE_FAILED;
+                       encoded_len += (buf - ss) + s_len;
+                       ss = buf + 1;
+               }
+       }
+
+       encoded_len += (buf - ss);
+       if((buf - ss) && cb(ss, buf - ss, app_key) < 0)
+               _ASN_ENCODE_FAILED;
+
+       er.encoded = encoded_len;
+       _ASN_ENCODED_OK(er);
+}
+
+/*
+ * Convert from hexadecimal format (cstring): "AB CD EF"
+ */
+static ssize_t OCTET_STRING__convert_hexadecimal(void *sptr, const void *chunk_buf, size_t chunk_size, int have_more) {
+       OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
+       const char *chunk_stop = (const char *)chunk_buf;
+       const char *p = chunk_stop;
+       const char *pend = p + chunk_size;
+       unsigned int clv = 0;
+       int half = 0;   /* Half bit */
+       uint8_t *buf;
+
+       /* Reallocate buffer according to high cap estimation */
+       ssize_t _ns = st->size + (chunk_size + 1) / 2;
+       void *nptr = REALLOC(st->buf, _ns + 1);
+       if(!nptr) return -1;
+       st->buf = (uint8_t *)nptr;
+       buf = st->buf + st->size;
+
+       /*
+        * If something like " a b c " appears here, the " a b":3 will be
+        * converted, and the rest skipped. That is, unless buf_size is greater
+        * than chunk_size, then it'll be equivalent to "ABC0".
+        */
+       for(; p < pend; p++) {
+               int ch = *(const unsigned char *)p;
+               switch(ch) {
+               case 0x09: case 0x0a: case 0x0c: case 0x0d:
+               case 0x20:
+                       /* Ignore whitespace */
+                       continue;
+               case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: /*01234*/
+               case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: /*56789*/
+                       clv = (clv << 4) + (ch - 0x30);
+                       break;
+               case 0x41: case 0x42: case 0x43:        /* ABC */
+               case 0x44: case 0x45: case 0x46:        /* DEF */
+                       clv = (clv << 4) + (ch - 0x41 + 10);
+                       break;
+               case 0x61: case 0x62: case 0x63:        /* abc */
+               case 0x64: case 0x65: case 0x66:        /* def */
+                       clv = (clv << 4) + (ch - 0x61 + 10);
+                       break;
+               default:
+                       *buf = 0;       /* JIC */
+                       return -1;
+               }
+               if(half++) {
+                       half = 0;
+                       *buf++ = clv;
+                       chunk_stop = p + 1;
+               }
+       }
+
+       /*
+        * Check partial decoding.
+        */
+       if(half) {
+               if(have_more) {
+                       /*
+                        * Partial specification is fine,
+                        * because no more more PXER_TEXT data is available.
+                        */
+                       *buf++ = clv << 4;
+                       chunk_stop = p;
+               }
+       } else {
+               chunk_stop = p;
+       }
+
+       st->size = buf - st->buf;       /* Adjust the buffer size */
+       assert(st->size <= _ns);
+       st->buf[st->size] = 0;          /* Courtesy termination */
+
+       return (chunk_stop - (const char *)chunk_buf);  /* Converted size */
+}
+
+/*
+ * Convert from binary format: "00101011101"
+ */
+static ssize_t OCTET_STRING__convert_binary(void *sptr, const void *chunk_buf, size_t chunk_size, int have_more) {
+       BIT_STRING_t *st = (BIT_STRING_t *)sptr;
+       const char *p = (const char *)chunk_buf;
+       const char *pend = p + chunk_size;
+       int bits_unused = st->bits_unused & 0x7;
+       uint8_t *buf;
+
+       /* Reallocate buffer according to high cap estimation */
+       ssize_t _ns = st->size + (chunk_size + 7) / 8;
+       void *nptr = REALLOC(st->buf, _ns + 1);
+       if(!nptr) return -1;
+       st->buf = (uint8_t *)nptr;
+       buf = st->buf + st->size;
+
+       (void)have_more;
+
+       if(bits_unused == 0)
+               bits_unused = 8;
+       else if(st->size)
+               buf--;
+
+       /*
+        * Convert series of 0 and 1 into the octet string.
+        */
+       for(; p < pend; p++) {
+               int ch = *(const unsigned char *)p;
+               switch(ch) {
+               case 0x09: case 0x0a: case 0x0c: case 0x0d:
+               case 0x20:
+                       /* Ignore whitespace */
+                       break;
+               case 0x30:
+               case 0x31:
+                       if(bits_unused-- <= 0) {
+                               *++buf = 0;     /* Clean the cell */
+                               bits_unused = 7;
+                       }
+                       *buf |= (ch&1) << bits_unused;
+                       break;
+               default:
+                       st->bits_unused = bits_unused;
+                       return -1;
+               }
+       }
+
+       if(bits_unused == 8) {
+               st->size = buf - st->buf;
+               st->bits_unused = 0;
+       } else {
+               st->size = buf - st->buf + 1;
+               st->bits_unused = bits_unused;
+       }
+
+       assert(st->size <= _ns);
+       st->buf[st->size] = 0;          /* Courtesy termination */
+
+       return chunk_size;      /* Converted in full */
+}
+
+/*
+ * Something like strtod(), but with stricter rules.
+ */
+static int
+OS__strtoent(int base, const char *buf, const char *end, int32_t *ret_value) {
+       int32_t val = 0;
+       const char *p;
+
+       for(p = buf; p < end; p++) {
+               int ch = *p;
+
+               /* Strange huge value */
+               if((val * base + base) < 0)
+                       return -1;
+
+               switch(ch) {
+               case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: /*01234*/
+               case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: /*56789*/
+                       val = val * base + (ch - 0x30);
+                       break;
+               case 0x41: case 0x42: case 0x43:        /* ABC */
+               case 0x44: case 0x45: case 0x46:        /* DEF */
+                       val = val * base + (ch - 0x41 + 10);
+                       break;
+               case 0x61: case 0x62: case 0x63:        /* abc */
+               case 0x64: case 0x65: case 0x66:        /* def */
+                       val = val * base + (ch - 0x61 + 10);
+                       break;
+               case 0x3b:      /* ';' */
+                       *ret_value = val;
+                       return (p - buf) + 1;
+               default:
+                       return -1;      /* Character set error */
+               }
+       }
+
+       *ret_value = -1;
+       return (p - buf);
+}
+
+/*
+ * Convert from the plain UTF-8 format, expanding entity references: "2 &lt; 3"
+ */
+static ssize_t OCTET_STRING__convert_entrefs(void *sptr, const void *chunk_buf, size_t chunk_size, int have_more) {
+       OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
+       const char *p = (const char *)chunk_buf;
+       const char *pend = p + chunk_size;
+       uint8_t *buf;
+
+       /* Reallocate buffer */
+       ssize_t _ns = st->size + chunk_size;
+       void *nptr = REALLOC(st->buf, _ns + 1);
+       if(!nptr) return -1;
+       st->buf = (uint8_t *)nptr;
+       buf = st->buf + st->size;
+
+       /*
+        * Convert series of 0 and 1 into the octet string.
+        */
+       for(; p < pend; p++) {
+               int ch = *(const unsigned char *)p;
+               int len;        /* Length of the rest of the chunk */
+
+               if(ch != 0x26 /* '&' */) {
+                       *buf++ = ch;
+                       continue;       /* That was easy... */
+               }
+
+               /*
+                * Process entity reference.
+                */
+               len = chunk_size - (p - (const char *)chunk_buf);
+               if(len == 1 /* "&" */) goto want_more;
+               if(p[1] == 0x23 /* '#' */) {
+                       const char *pval;       /* Pointer to start of digits */
+                       int32_t val = 0;        /* Entity reference value */
+                       int base;
+
+                       if(len == 2 /* "&#" */) goto want_more;
+                       if(p[2] == 0x78 /* 'x' */)
+                               pval = p + 3, base = 16;
+                       else
+                               pval = p + 2, base = 10;
+                       len = OS__strtoent(base, pval, p + len, &val);
+                       if(len == -1) {
+                               /* Invalid charset. Just copy verbatim. */
+                               *buf++ = ch;
+                               continue;
+                       }
+                       if(!len || pval[len-1] != 0x3b) goto want_more;
+                       assert(val > 0);
+                       p += (pval - p) + len - 1; /* Advance past entref */
+
+                       if(val < 0x80) {
+                               *buf++ = (char)val;
+                       } else if(val < 0x800) {
+                               *buf++ = 0xc0 | ((val >> 6));
+                               *buf++ = 0x80 | ((val & 0x3f));
+                       } else if(val < 0x10000) {
+                               *buf++ = 0xe0 | ((val >> 12));
+                               *buf++ = 0x80 | ((val >> 6) & 0x3f);
+                               *buf++ = 0x80 | ((val & 0x3f));
+                       } else if(val < 0x200000) {
+                               *buf++ = 0xf0 | ((val >> 18));
+                               *buf++ = 0x80 | ((val >> 12) & 0x3f);
+                               *buf++ = 0x80 | ((val >> 6) & 0x3f);
+                               *buf++ = 0x80 | ((val & 0x3f));
+                       } else if(val < 0x4000000) {
+                               *buf++ = 0xf8 | ((val >> 24));
+                               *buf++ = 0x80 | ((val >> 18) & 0x3f);
+                               *buf++ = 0x80 | ((val >> 12) & 0x3f);
+                               *buf++ = 0x80 | ((val >> 6) & 0x3f);
+                               *buf++ = 0x80 | ((val & 0x3f));
+                       } else {
+                               *buf++ = 0xfc | ((val >> 30) & 0x1);
+                               *buf++ = 0x80 | ((val >> 24) & 0x3f);
+                               *buf++ = 0x80 | ((val >> 18) & 0x3f);
+                               *buf++ = 0x80 | ((val >> 12) & 0x3f);
+                               *buf++ = 0x80 | ((val >> 6) & 0x3f);
+                               *buf++ = 0x80 | ((val & 0x3f));
+                       }
+               } else {
+                       /*
+                        * Ugly, limited parsing of &amp; &gt; &lt;
+                        */
+                       char *sc = (char *)memchr(p, 0x3b, len > 5 ? 5 : len);
+                       if(!sc) goto want_more;
+                       if((sc - p) == 4
+                               && p[1] == 0x61 /* 'a' */
+                               && p[2] == 0x6d /* 'm' */
+                               && p[3] == 0x70 /* 'p' */) {
+                               *buf++ = 0x26;
+                               p = sc;
+                               continue;
+                       }
+                       if((sc - p) == 3) {
+                               if(p[1] == 0x6c) {
+                                       *buf = 0x3c;    /* '<' */
+                               } else if(p[1] == 0x67) {
+                                       *buf = 0x3e;    /* '>' */
+                               } else {
+                                       /* Unsupported entity reference */
+                                       *buf++ = ch;
+                                       continue;
+                               }
+                               if(p[2] != 0x74) {
+                                       /* Unsupported entity reference */
+                                       *buf++ = ch;
+                                       continue;
+                               }
+                               buf++;
+                               p = sc;
+                               continue;
+                       }
+                       /* Unsupported entity reference */
+                       *buf++ = ch;
+               }
+
+               continue;
+       want_more:
+               if(have_more) {
+                       /*
+                        * We know that no more data (of the same type)
+                        * is coming. Copy the rest verbatim.
+                        */
+                       *buf++ = ch;
+                       continue;
+               }
+               chunk_size = (p - (const char *)chunk_buf);
+               /* Processing stalled: need more data */
+               break;
+       }
+
+       st->size = buf - st->buf;
+       assert(st->size <= _ns);
+       st->buf[st->size] = 0;          /* Courtesy termination */
+
+       return chunk_size;      /* Converted in full */
+}
+
+/*
+ * Decode OCTET STRING from the XML element's body.
+ */
+static asn_dec_rval_t
+OCTET_STRING__decode_xer(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td, void **sptr,
+       const char *opt_mname, const void *buf_ptr, size_t size,
+       int (*opt_unexpected_tag_decoder)
+               (void *struct_ptr, const void *chunk_buf, size_t chunk_size),
+       ssize_t (*body_receiver)
+               (void *struct_ptr, const void *chunk_buf, size_t chunk_size,
+                       int have_more)
+) {
+       OCTET_STRING_t *st = (OCTET_STRING_t *)*sptr;
+       asn_OCTET_STRING_specifics_t *specs = td->specifics
+                               ? (asn_OCTET_STRING_specifics_t *)td->specifics
+                               : &asn_DEF_OCTET_STRING_specs;
+       const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
+       asn_struct_ctx_t *ctx;          /* Per-structure parser context */
+       asn_dec_rval_t rval;            /* Return value from the decoder */
+       int st_allocated;
+
+       /*
+        * Create the string if does not exist.
+        */
+       if(!st) {
+               st = (OCTET_STRING_t *)CALLOC(1, specs->struct_size);
+               *sptr = (void *)st;
+               if(!st) goto sta_failed;
+               st_allocated = 1;
+       } else {
+               st_allocated = 0;
+       }
+       if(!st->buf) {
+               /* This is separate from above section */
+               st->buf = (uint8_t *)CALLOC(1, 1);
+               if(!st->buf) {
+                       if(st_allocated) {
+                               *sptr = 0;
+                               goto stb_failed;
+                       } else {
+                               goto sta_failed;
+                       }
+               }
+       }
+
+       /* Restore parsing context */
+       ctx = (asn_struct_ctx_t *)(((char *)*sptr) + specs->ctx_offset);
+
+       return xer_decode_general(opt_codec_ctx, ctx, *sptr, xml_tag,
+               buf_ptr, size, opt_unexpected_tag_decoder, body_receiver);
+
+stb_failed:
+       FREEMEM(st);
+sta_failed:
+       rval.code = RC_FAIL;
+       rval.consumed = 0;
+       return rval;
+}
+
+/*
+ * Decode OCTET STRING from the hexadecimal data.
+ */
+asn_dec_rval_t
+OCTET_STRING_decode_xer_hex(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td, void **sptr,
+               const char *opt_mname, const void *buf_ptr, size_t size) {
+       return OCTET_STRING__decode_xer(opt_codec_ctx, td, sptr, opt_mname,
+               buf_ptr, size, 0, OCTET_STRING__convert_hexadecimal);
+}
+
+/*
+ * Decode OCTET STRING from the binary (0/1) data.
+ */
+asn_dec_rval_t
+OCTET_STRING_decode_xer_binary(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td, void **sptr,
+               const char *opt_mname, const void *buf_ptr, size_t size) {
+       return OCTET_STRING__decode_xer(opt_codec_ctx, td, sptr, opt_mname,
+               buf_ptr, size, 0, OCTET_STRING__convert_binary);
+}
+
+/*
+ * Decode OCTET STRING from the string (ASCII/UTF-8) data.
+ */
+asn_dec_rval_t
+OCTET_STRING_decode_xer_utf8(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td, void **sptr,
+               const char *opt_mname, const void *buf_ptr, size_t size) {
+       return OCTET_STRING__decode_xer(opt_codec_ctx, td, sptr, opt_mname,
+               buf_ptr, size,
+               OCTET_STRING__handle_control_chars,
+               OCTET_STRING__convert_entrefs);
+}
+
+static int
+OCTET_STRING_per_get_characters(asn_per_data_t *po, uint8_t *buf,
+               size_t units, unsigned int bpc, unsigned int unit_bits,
+               long lb, long ub, asn_per_constraints_t *pc) {
+       uint8_t *end = buf + units * bpc;
+
+       ASN_DEBUG("Expanding %d characters into (%ld..%ld):%d",
+               (int)units, lb, ub, unit_bits);
+
+       /* X.691: 27.5.4 */
+       if((unsigned long)ub <= ((unsigned long)2 << (unit_bits - 1))) {
+               /* Decode without translation */
+               lb = 0;
+       } else if(pc && pc->code2value) {
+               if(unit_bits > 16)
+                       return 1;       /* FATAL: can't have constrained
+                                        * UniversalString with more than
+                                        * 16 million code points */
+               for(; buf < end; buf += bpc) {
+                       int value;
+                       int code = per_get_few_bits(po, unit_bits);
+                       if(code < 0) return -1; /* WMORE */
+                       value = pc->code2value(code);
+                       if(value < 0) {
+                               ASN_DEBUG("Code %d (0x%02x) is"
+                                       " not in map (%ld..%ld)",
+                                       code, code, lb, ub);
+                               return 1;       /* FATAL */
+                       }
+                       switch(bpc) {
+                       case 1: *buf = value; break;
+                       case 2: buf[0] = value >> 8; buf[1] = value; break;
+                       case 4: buf[0] = value >> 24; buf[1] = value >> 16;
+                               buf[2] = value >> 8; buf[3] = value; break;
+                       }
+               }
+               return 0;
+       }
+
+       /* Shortcut the no-op copying to the aligned structure */
+       if(lb == 0 && (unit_bits == 8 * bpc)) {
+               return per_get_many_bits(po, buf, 0, unit_bits * units);
+       }
+
+       for(; buf < end; buf += bpc) {
+               int code = per_get_few_bits(po, unit_bits);
+               int ch = code + lb;
+               if(code < 0) return -1; /* WMORE */
+               if(ch > ub) {
+                       ASN_DEBUG("Code %d is out of range (%ld..%ld)",
+                               ch, lb, ub);
+                       return 1;       /* FATAL */
+               }
+               switch(bpc) {
+               case 1: *buf = ch; break;
+               case 2: buf[0] = ch >> 8; buf[1] = ch; break;
+               case 4: buf[0] = ch >> 24; buf[1] = ch >> 16;
+                       buf[2] = ch >> 8; buf[3] = ch; break;
+               }
+       }
+
+       return 0;
+}
+
+static int
+OCTET_STRING_per_put_characters(asn_per_outp_t *po, const uint8_t *buf,
+               size_t units, unsigned int bpc, unsigned int unit_bits,
+               long lb, long ub, asn_per_constraints_t *pc) {
+       const uint8_t *end = buf + units * bpc;
+
+       ASN_DEBUG("Squeezing %d characters into (%ld..%ld):%d (%d bpc)",
+               (int)units, lb, ub, unit_bits, bpc);
+
+       /* X.691: 27.5.4 */
+       if((unsigned long)ub <= ((unsigned long)2 << (unit_bits - 1))) {
+               /* Encode as is */
+               lb = 0;
+       } else if(pc && pc->value2code) {
+               for(; buf < end; buf += bpc) {
+                       int code;
+                       uint32_t value;
+                       switch(bpc) {
+                       case 1: value = *(const uint8_t *)buf; break;
+                       case 2: value = (buf[0] << 8) | buf[1]; break;
+                       case 4: value = (buf[0] << 24) | (buf[1] << 16)
+                                       | (buf[2] << 8) | buf[3]; break;
+                       default: return -1;
+                       }
+                       code = pc->value2code(value);
+                       if(code < 0) {
+                               ASN_DEBUG("Character %d (0x%02x) is"
+                                       " not in map (%ld..%ld)",
+                                       *buf, *buf, lb, ub);
+                               return -1;
+                       }
+                       if(per_put_few_bits(po, code, unit_bits))
+                               return -1;
+               }
+       }
+
+       /* Shortcut the no-op copying to the aligned structure */
+       if(lb == 0 && (unit_bits == 8 * bpc)) {
+               return per_put_many_bits(po, buf, unit_bits * units);
+       }
+
+       for(ub -= lb; buf < end; buf += bpc) {
+               int ch;
+               uint32_t value;
+               switch(bpc) {
+               case 1: value = *(const uint8_t *)buf; break;
+               case 2: value = (buf[0] << 8) | buf[1]; break;
+               case 4: value = (buf[0] << 24) | (buf[1] << 16)
+                               | (buf[2] << 8) | buf[3]; break;
+               default: return -1;
+               }
+               ch = value - lb;
+               if(ch < 0 || ch > ub) {
+                       ASN_DEBUG("Character %d (0x%02x)"
+                       " is out of range (%ld..%ld)",
+                               *buf, *buf, lb, ub + lb);
+                       return -1;
+               }
+               if(per_put_few_bits(po, ch, unit_bits))
+                       return -1;
+       }
+
+       return 0;
+}
+
+asn_dec_rval_t
+OCTET_STRING_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
+       void **sptr, asn_per_data_t *pd) {
+
+       asn_OCTET_STRING_specifics_t *specs = td->specifics
+               ? (asn_OCTET_STRING_specifics_t *)td->specifics
+               : &asn_DEF_OCTET_STRING_specs;
+       asn_per_constraints_t *pc = constraints ? constraints
+                               : td->per_constraints;
+       asn_per_constraint_t *cval;
+       asn_per_constraint_t *csiz;
+       asn_dec_rval_t rval = { RC_OK, 0 };
+       BIT_STRING_t *st = (BIT_STRING_t *)*sptr;
+       ssize_t consumed_myself = 0;
+       int repeat;
+       enum {
+               OS__BPC_BIT     = 0,
+               OS__BPC_CHAR    = 1,
+               OS__BPC_U16     = 2,
+               OS__BPC_U32     = 4
+       } bpc;  /* Bytes per character */
+       unsigned int unit_bits;
+       unsigned int canonical_unit_bits;
+
+       (void)opt_codec_ctx;
+
+       if(pc) {
+               cval = &pc->value;
+               csiz = &pc->size;
+       } else {
+               cval = &asn_DEF_OCTET_STRING_constraints.value;
+               csiz = &asn_DEF_OCTET_STRING_constraints.size;
+       }
+
+       switch(specs->subvariant) {
+       default:
+       case ASN_OSUBV_ANY:
+               ASN_DEBUG("Unrecognized subvariant %d", specs->subvariant);
+               RETURN(RC_FAIL);
+       case ASN_OSUBV_BIT:
+               canonical_unit_bits = unit_bits = 1;
+               bpc = OS__BPC_BIT;
+               break;
+       case ASN_OSUBV_STR:
+               canonical_unit_bits = unit_bits = 8;
+               if(cval->flags & APC_CONSTRAINED)
+                       unit_bits = cval->range_bits;
+               bpc = OS__BPC_CHAR;
+               break;
+       case ASN_OSUBV_U16:
+               canonical_unit_bits = unit_bits = 16;
+               if(cval->flags & APC_CONSTRAINED)
+                       unit_bits = cval->range_bits;
+               bpc = OS__BPC_U16;
+               break;
+       case ASN_OSUBV_U32:
+               canonical_unit_bits = unit_bits = 32;
+               if(cval->flags & APC_CONSTRAINED)
+                       unit_bits = cval->range_bits;
+               bpc = OS__BPC_U32;
+               break;
+       }
+
+       /*
+        * Allocate the string.
+        */
+       if(!st) {
+               st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
+               if(!st) RETURN(RC_FAIL);
+       }
+
+       ASN_DEBUG("PER Decoding %s size %ld .. %ld bits %d",
+               csiz->flags & APC_EXTENSIBLE ? "extensible" : "non-extensible",
+               csiz->lower_bound, csiz->upper_bound, csiz->effective_bits);
+
+       if(csiz->flags & APC_EXTENSIBLE) {
+               int inext = per_get_few_bits(pd, 1);
+               if(inext < 0) RETURN(RC_WMORE);
+               if(inext) {
+                       csiz = &asn_DEF_OCTET_STRING_constraints.size;
+                       cval = &asn_DEF_OCTET_STRING_constraints.value;
+                       unit_bits = canonical_unit_bits;
+               }
+       }
+
+       if(csiz->effective_bits >= 0) {
+               FREEMEM(st->buf);
+               if(bpc) {
+                       st->size = csiz->upper_bound * bpc;
+               } else {
+                       st->size = (csiz->upper_bound + 7) >> 3;
+               }
+               st->buf = (uint8_t *)MALLOC(st->size + 1);
+               if(!st->buf) { st->size = 0; RETURN(RC_FAIL); }
+       }
+
+       /* X.691, #16.5: zero-length encoding */
+       /* X.691, #16.6: short fixed length encoding (up to 2 octets) */
+       /* X.691, #16.7: long fixed length encoding (up to 64K octets) */
+       if(csiz->effective_bits == 0) {
+               int ret;
+               if(bpc) {
+                       ASN_DEBUG("Encoding OCTET STRING size %ld",
+                               csiz->upper_bound);
+                       ret = OCTET_STRING_per_get_characters(pd, st->buf,
+                               csiz->upper_bound, bpc, unit_bits,
+                               cval->lower_bound, cval->upper_bound, pc);
+                       if(ret > 0) RETURN(RC_FAIL);
+               } else {
+                       ASN_DEBUG("Encoding BIT STRING size %ld",
+                               csiz->upper_bound);
+                       ret = per_get_many_bits(pd, st->buf, 0,
+                                           unit_bits * csiz->upper_bound);
+               }
+               if(ret < 0) RETURN(RC_WMORE);
+               consumed_myself += unit_bits * csiz->upper_bound;
+               st->buf[st->size] = 0;
+               if(bpc == 0) {
+                       int ubs = (csiz->upper_bound & 0x7);
+                       st->bits_unused = ubs ? 8 - ubs : 0;
+               }
+               RETURN(RC_OK);
+       }
+
+       st->size = 0;
+       do {
+               ssize_t raw_len;
+               ssize_t len_bytes;
+               ssize_t len_bits;
+               void *p;
+               int ret;
+
+               /* Get the PER length */
+               raw_len = uper_get_length(pd, csiz->effective_bits, &repeat);
+               if(raw_len < 0) RETURN(RC_WMORE);
+               raw_len += csiz->lower_bound;
+
+               ASN_DEBUG("Got PER length eb %ld, len %ld, %s (%s)",
+                       (long)csiz->effective_bits, (long)raw_len,
+                       repeat ? "repeat" : "once", td->name);
+               if(bpc) {
+                       len_bytes = raw_len * bpc;
+                       len_bits = len_bytes * unit_bits;
+               } else {
+                       len_bits = raw_len;
+                       len_bytes = (len_bits + 7) >> 3;
+                       if(len_bits & 0x7)
+                               st->bits_unused = 8 - (len_bits & 0x7);
+                       /* len_bits be multiple of 16K if repeat is set */
+               }
+               p = REALLOC(st->buf, st->size + len_bytes + 1);
+               if(!p) RETURN(RC_FAIL);
+               st->buf = (uint8_t *)p;
+
+               if(bpc) {
+                       ret = OCTET_STRING_per_get_characters(pd,
+                               &st->buf[st->size], raw_len, bpc, unit_bits,
+                               cval->lower_bound, cval->upper_bound, pc);
+                       if(ret > 0) RETURN(RC_FAIL);
+               } else {
+                       ret = per_get_many_bits(pd, &st->buf[st->size],
+                               0, len_bits);
+               }
+               if(ret < 0) RETURN(RC_WMORE);
+               st->size += len_bytes;
+       } while(repeat);
+       st->buf[st->size] = 0;  /* nul-terminate */
+
+       return rval;
+}
+
+asn_enc_rval_t
+OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
+        asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+
+       asn_OCTET_STRING_specifics_t *specs = td->specifics
+               ? (asn_OCTET_STRING_specifics_t *)td->specifics
+               : &asn_DEF_OCTET_STRING_specs;
+       asn_per_constraints_t *pc = constraints ? constraints
+                               : td->per_constraints;
+       asn_per_constraint_t *cval;
+       asn_per_constraint_t *csiz;
+       const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+       asn_enc_rval_t er = { 0, 0, 0 };
+       int inext = 0;          /* Lies not within extension root */
+       unsigned int unit_bits;
+       unsigned int canonical_unit_bits;
+       unsigned int sizeinunits;
+       const uint8_t *buf;
+       int ret;
+       enum {
+               OS__BPC_BIT     = 0,
+               OS__BPC_CHAR    = 1,
+               OS__BPC_U16     = 2,
+               OS__BPC_U32     = 4
+       } bpc;  /* Bytes per character */
+       int ct_extensible;
+
+       if(!st || (!st->buf && st->size))
+               _ASN_ENCODE_FAILED;
+
+       if(pc) {
+               cval = &pc->value;
+               csiz = &pc->size;
+       } else {
+               cval = &asn_DEF_OCTET_STRING_constraints.value;
+               csiz = &asn_DEF_OCTET_STRING_constraints.size;
+       }
+       ct_extensible = csiz->flags & APC_EXTENSIBLE;
+
+       switch(specs->subvariant) {
+       default:
+       case ASN_OSUBV_ANY:
+               _ASN_ENCODE_FAILED;
+       case ASN_OSUBV_BIT:
+               canonical_unit_bits = unit_bits = 1;
+               bpc = OS__BPC_BIT;
+               sizeinunits = st->size * 8 - (st->bits_unused & 0x07);
+               ASN_DEBUG("BIT STRING of %d bytes, %d bits unused",
+                               sizeinunits, st->bits_unused);
+               break;
+       case ASN_OSUBV_STR:
+               canonical_unit_bits = unit_bits = 8;
+               if(cval->flags & APC_CONSTRAINED)
+                       unit_bits = cval->range_bits;
+               bpc = OS__BPC_CHAR;
+               sizeinunits = st->size;
+               break;
+       case ASN_OSUBV_U16:
+               canonical_unit_bits = unit_bits = 16;
+               if(cval->flags & APC_CONSTRAINED)
+                       unit_bits = cval->range_bits;
+               bpc = OS__BPC_U16;
+               sizeinunits = st->size / 2;
+               break;
+       case ASN_OSUBV_U32:
+               canonical_unit_bits = unit_bits = 32;
+               if(cval->flags & APC_CONSTRAINED)
+                       unit_bits = cval->range_bits;
+               bpc = OS__BPC_U32;
+               sizeinunits = st->size / 4;
+               break;
+       }
+
+       ASN_DEBUG("Encoding %s into %d units of %d bits"
+               " (%ld..%ld, effective %d)%s",
+               td->name, sizeinunits, unit_bits,
+               csiz->lower_bound, csiz->upper_bound,
+               csiz->effective_bits, ct_extensible ? " EXT" : "");
+
+       /* Figure out whether size lies within PER visible constraint */
+
+       if(csiz->effective_bits >= 0) {
+               if((int)sizeinunits < csiz->lower_bound
+               || (int)sizeinunits > csiz->upper_bound) {
+                       if(ct_extensible) {
+                               cval = &asn_DEF_OCTET_STRING_constraints.value;
+                               csiz = &asn_DEF_OCTET_STRING_constraints.size;
+                               unit_bits = canonical_unit_bits;
+                               inext = 1;
+                       } else
+                               _ASN_ENCODE_FAILED;
+               }
+       } else {
+               inext = 0;
+       }
+
+       if(ct_extensible) {
+               /* Declare whether length is [not] within extension root */
+               if(per_put_few_bits(po, inext, 1))
+                       _ASN_ENCODE_FAILED;
+       }
+
+       /* X.691, #16.5: zero-length encoding */
+       /* X.691, #16.6: short fixed length encoding (up to 2 octets) */
+       /* X.691, #16.7: long fixed length encoding (up to 64K octets) */
+       if(csiz->effective_bits >= 0) {
+               ASN_DEBUG("Encoding %d bytes (%ld), length in %d bits",
+                               st->size, sizeinunits - csiz->lower_bound,
+                               csiz->effective_bits);
+               ret = per_put_few_bits(po, sizeinunits - csiz->lower_bound,
+                               csiz->effective_bits);
+               if(ret) _ASN_ENCODE_FAILED;
+               if(bpc) {
+                       ret = OCTET_STRING_per_put_characters(po, st->buf,
+                               sizeinunits, bpc, unit_bits,
+                               cval->lower_bound, cval->upper_bound, pc);
+               } else {
+                       ret = per_put_many_bits(po, st->buf,
+                               sizeinunits * unit_bits);
+               }
+               if(ret) _ASN_ENCODE_FAILED;
+               _ASN_ENCODED_OK(er);
+       }
+
+       ASN_DEBUG("Encoding %d bytes", st->size);
+
+       if(sizeinunits == 0) {
+               if(uper_put_length(po, 0))
+                       _ASN_ENCODE_FAILED;
+               _ASN_ENCODED_OK(er);
+       }
+
+       buf = st->buf;
+       while(sizeinunits) {
+               ssize_t maySave = uper_put_length(po, sizeinunits);
+               if(maySave < 0) _ASN_ENCODE_FAILED;
+
+               ASN_DEBUG("Encoding %ld of %ld",
+                       (long)maySave, (long)sizeinunits);
+
+               if(bpc) {
+                       ret = OCTET_STRING_per_put_characters(po, buf,
+                               maySave, bpc, unit_bits,
+                               cval->lower_bound, cval->upper_bound, pc);
+               } else {
+                       ret = per_put_many_bits(po, buf, maySave * unit_bits);
+               }
+               if(ret) _ASN_ENCODE_FAILED;
+
+               if(bpc)
+                       buf += maySave * bpc;
+               else
+                       buf += maySave >> 3;
+               sizeinunits -= maySave;
+               assert(!(maySave & 0x07) || !sizeinunits);
+       }
+
+       _ASN_ENCODED_OK(er);
+}
+
+int
+OCTET_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+       asn_app_consume_bytes_f *cb, void *app_key) {
+       static const char *h2c = "0123456789ABCDEF";
+       const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+       char scratch[16 * 3 + 4];
+       char *p = scratch;
+       uint8_t *buf;
+       uint8_t *end;
+       size_t i;
+
+       (void)td;       /* Unused argument */
+
+       if(!st || (!st->buf && st->size))
+               return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+
+       /*
+        * Dump the contents of the buffer in hexadecimal.
+        */
+       buf = st->buf;
+       end = buf + st->size;
+       for(i = 0; buf < end; buf++, i++) {
+               if(!(i % 16) && (i || st->size > 16)) {
+                       if(cb(scratch, p - scratch, app_key) < 0)
+                               return -1;
+                       _i_INDENT(1);
+                       p = scratch;
+               }
+               *p++ = h2c[(*buf >> 4) & 0x0F];
+               *p++ = h2c[*buf & 0x0F];
+               *p++ = 0x20;
+       }
+
+       if(p > scratch) {
+               p--;    /* Remove the tail space */
+               if(cb(scratch, p - scratch, app_key) < 0)
+                       return -1;
+       }
+
+       return 0;
+}
+
+int
+OCTET_STRING_print_utf8(asn_TYPE_descriptor_t *td, const void *sptr,
+               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+       const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+
+       (void)td;       /* Unused argument */
+       (void)ilevel;   /* Unused argument */
+
+       if(st && (st->buf || !st->size)) {
+               return (cb(st->buf, st->size, app_key) < 0) ? -1 : 0;
+       } else {
+               return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+       }
+}
+
+void
+OCTET_STRING_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
+       OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
+       asn_OCTET_STRING_specifics_t *specs = td->specifics
+                               ? (asn_OCTET_STRING_specifics_t *)td->specifics
+                               : &asn_DEF_OCTET_STRING_specs;
+       asn_struct_ctx_t *ctx = (asn_struct_ctx_t *)
+                                       ((char *)st + specs->ctx_offset);
+       struct _stack *stck;
+
+       if(!td || !st)
+               return;
+
+       ASN_DEBUG("Freeing %s as OCTET STRING", td->name);
+
+       if(st->buf) {
+               FREEMEM(st->buf);
+               st->buf = 0;
+       }
+
+       /*
+        * Remove decode-time stack.
+        */
+       stck = (struct _stack *)ctx->ptr;
+       if(stck) {
+               while(stck->tail) {
+                       struct _stack_el *sel = stck->tail;
+                       stck->tail = sel->prev;
+                       FREEMEM(sel);
+               }
+               FREEMEM(stck);
+       }
+
+       if(!contents_only) {
+               FREEMEM(st);
+       }
+}
+
+/*
+ * Conversion routines.
+ */
+int
+OCTET_STRING_fromBuf(OCTET_STRING_t *st, const char *str, int len) {
+       void *buf;
+
+       if(st == 0 || (str == 0 && len)) {
+               errno = EINVAL;
+               return -1;
+       }
+
+       /*
+        * Clear the OCTET STRING.
+        */
+       if(str == NULL) {
+               FREEMEM(st->buf);
+               st->buf = 0;
+               st->size = 0;
+               return 0;
+       }
+
+       /* Determine the original string size, if not explicitly given */
+       if(len < 0)
+               len = strlen(str);
+
+       /* Allocate and fill the memory */
+       buf = MALLOC(len + 1);
+       if(buf == NULL)
+               return -1;
+
+       memcpy(buf, str, len);
+       ((uint8_t *)buf)[len] = '\0';   /* Couldn't use memcpy(len+1)! */
+       FREEMEM(st->buf);
+       st->buf = (uint8_t *)buf;
+       st->size = len;
+
+       return 0;
+}
+
+OCTET_STRING_t *
+OCTET_STRING_new_fromBuf(asn_TYPE_descriptor_t *td, const char *str, int len) {
+       asn_OCTET_STRING_specifics_t *specs = td->specifics
+                               ? (asn_OCTET_STRING_specifics_t *)td->specifics
+                               : &asn_DEF_OCTET_STRING_specs;
+       OCTET_STRING_t *st;
+
+       st = (OCTET_STRING_t *)CALLOC(1, specs->struct_size);
+       if(st && str && OCTET_STRING_fromBuf(st, str, len)) {
+               FREEMEM(st);
+               st = NULL;
+       }
+
+       return st;
+}
+
diff --git a/src/asn1c/OCTET_STRING.h b/src/asn1c/OCTET_STRING.h
new file mode 100644 (file)
index 0000000..8df9a18
--- /dev/null
@@ -0,0 +1,86 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        _OCTET_STRING_H_
+#define        _OCTET_STRING_H_
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OCTET_STRING {
+       uint8_t *buf;   /* Buffer with consecutive OCTET_STRING bits */
+       int size;       /* Size of the buffer */
+
+       asn_struct_ctx_t _asn_ctx;      /* Parsing across buffer boundaries */
+} OCTET_STRING_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_OCTET_STRING;
+
+asn_struct_free_f OCTET_STRING_free;
+asn_struct_print_f OCTET_STRING_print;
+asn_struct_print_f OCTET_STRING_print_utf8;
+ber_type_decoder_f OCTET_STRING_decode_ber;
+der_type_encoder_f OCTET_STRING_encode_der;
+xer_type_decoder_f OCTET_STRING_decode_xer_hex;                /* Hexadecimal */
+xer_type_decoder_f OCTET_STRING_decode_xer_binary;     /* 01010111010 */
+xer_type_decoder_f OCTET_STRING_decode_xer_utf8;       /* ASCII/UTF-8 */
+xer_type_encoder_f OCTET_STRING_encode_xer;
+xer_type_encoder_f OCTET_STRING_encode_xer_utf8;
+per_type_decoder_f OCTET_STRING_decode_uper;
+per_type_encoder_f OCTET_STRING_encode_uper;
+
+/******************************
+ * Handy conversion routines. *
+ ******************************/
+
+/*
+ * This function clears the previous value of the OCTET STRING (if any)
+ * and then allocates a new memory with the specified content (str/size).
+ * If size = -1, the size of the original string will be determined
+ * using strlen(str).
+ * If str equals to NULL, the function will silently clear the
+ * current contents of the OCTET STRING.
+ * Returns 0 if it was possible to perform operation, -1 otherwise.
+ */
+int OCTET_STRING_fromBuf(OCTET_STRING_t *s, const char *str, int size);
+
+/* Handy conversion from the C string into the OCTET STRING. */
+#define        OCTET_STRING_fromString(s, str) OCTET_STRING_fromBuf(s, str, -1)
+
+/*
+ * Allocate and fill the new OCTET STRING and return a pointer to the newly
+ * allocated object. NULL is permitted in str: the function will just allocate
+ * empty OCTET STRING.
+ */
+OCTET_STRING_t *OCTET_STRING_new_fromBuf(asn_TYPE_descriptor_t *td,
+       const char *str, int size);
+
+/****************************
+ * Internally useful stuff. *
+ ****************************/
+
+typedef struct asn_OCTET_STRING_specifics_s {
+       /*
+        * Target structure description.
+        */
+       int struct_size;        /* Size of the structure */
+       int ctx_offset;         /* Offset of the asn_struct_ctx_t member */
+
+       enum asn_OS_Subvariant {
+               ASN_OSUBV_ANY,  /* The open type (ANY) */
+               ASN_OSUBV_BIT,  /* BIT STRING */
+               ASN_OSUBV_STR,  /* String types, not {BMP,Universal}String  */
+               ASN_OSUBV_U16,  /* 16-bit character (BMPString) */
+               ASN_OSUBV_U32   /* 32-bit character (UniversalString) */
+       } subvariant;
+} asn_OCTET_STRING_specifics_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _OCTET_STRING_H_ */
diff --git a/src/asn1c/Uint32.c b/src/asn1c/Uint32.c
new file mode 100644 (file)
index 0000000..794f98b
--- /dev/null
@@ -0,0 +1,122 @@
+/*
+ * Generated by asn1c-0.9.27 (http://lionet.info/asn1c)
+ * From ASN.1 module "GssapiSessionModule"
+ *     found in "session.asn1"
+ *     `asn1c -fskeletons-copy`
+ */
+
+#include "Uint32.h"
+
+int
+Uint32_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+       
+       if(!sptr) {
+               _ASN_CTFAIL(app_key, td, sptr,
+                       "%s: value not given (%s:%d)",
+                       td->name, __FILE__, __LINE__);
+               return -1;
+       }
+       
+       
+       /* Constraint check succeeded */
+       return 0;
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Uint32_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+       td->free_struct    = asn_DEF_NativeInteger.free_struct;
+       td->print_struct   = asn_DEF_NativeInteger.print_struct;
+       td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+       td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+       td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+       td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+       td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+       td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+       td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+       if(!td->per_constraints)
+               td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+       td->elements       = asn_DEF_NativeInteger.elements;
+       td->elements_count = asn_DEF_NativeInteger.elements_count;
+     /* td->specifics      = asn_DEF_NativeInteger.specifics;  // Defined explicitly */
+}
+
+void
+Uint32_free(asn_TYPE_descriptor_t *td,
+               void *struct_ptr, int contents_only) {
+       Uint32_1_inherit_TYPE_descriptor(td);
+       td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Uint32_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+       Uint32_1_inherit_TYPE_descriptor(td);
+       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Uint32_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+               void **structure, const void *bufptr, size_t size, int tag_mode) {
+       Uint32_1_inherit_TYPE_descriptor(td);
+       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Uint32_encode_der(asn_TYPE_descriptor_t *td,
+               void *structure, int tag_mode, ber_tlv_tag_t tag,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       Uint32_1_inherit_TYPE_descriptor(td);
+       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Uint32_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+               void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+       Uint32_1_inherit_TYPE_descriptor(td);
+       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Uint32_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+               int ilevel, enum xer_encoder_flags_e flags,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       Uint32_1_inherit_TYPE_descriptor(td);
+       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static asn_INTEGER_specifics_t asn_SPC_Uint32_specs_1 = {
+       0,      0,      0,      0,      0,
+       0,      /* Native long size */
+       1       /* Unsigned representation */
+};
+static ber_tlv_tag_t asn_DEF_Uint32_tags_1[] = {
+       (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Uint32 = {
+       "Uint32",
+       "Uint32",
+       Uint32_free,
+       Uint32_print,
+       Uint32_constraint,
+       Uint32_decode_ber,
+       Uint32_encode_der,
+       Uint32_decode_xer,
+       Uint32_encode_xer,
+       0, 0,   /* No PER support, use "-gen-PER" to enable */
+       0,      /* Use generic outmost tag fetcher */
+       asn_DEF_Uint32_tags_1,
+       sizeof(asn_DEF_Uint32_tags_1)
+               /sizeof(asn_DEF_Uint32_tags_1[0]), /* 1 */
+       asn_DEF_Uint32_tags_1,  /* Same as above */
+       sizeof(asn_DEF_Uint32_tags_1)
+               /sizeof(asn_DEF_Uint32_tags_1[0]), /* 1 */
+       0,      /* No PER visible constraints */
+       0, 0,   /* No members */
+       &asn_SPC_Uint32_specs_1 /* Additional specs */
+};
+
diff --git a/src/asn1c/Uint32.h b/src/asn1c/Uint32.h
new file mode 100644 (file)
index 0000000..a0ed876
--- /dev/null
@@ -0,0 +1,39 @@
+/*
+ * Generated by asn1c-0.9.27 (http://lionet.info/asn1c)
+ * From ASN.1 module "GssapiSessionModule"
+ *     found in "session.asn1"
+ *     `asn1c -fskeletons-copy`
+ */
+
+#ifndef        _Uint32_H_
+#define        _Uint32_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Uint32 */
+typedef unsigned long   Uint32_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Uint32;
+asn_struct_free_f Uint32_free;
+asn_struct_print_f Uint32_print;
+asn_constr_check_f Uint32_constraint;
+ber_type_decoder_f Uint32_decode_ber;
+der_type_encoder_f Uint32_encode_der;
+xer_type_decoder_f Uint32_decode_xer;
+xer_type_encoder_f Uint32_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _Uint32_H_ */
+#include <asn_internal.h>
diff --git a/src/asn1c/asn_application.h b/src/asn1c/asn_application.h
new file mode 100644 (file)
index 0000000..f40cd86
--- /dev/null
@@ -0,0 +1,47 @@
+/*-
+ * Copyright (c) 2004, 2006 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * Application-level ASN.1 callbacks.
+ */
+#ifndef        _ASN_APPLICATION_H_
+#define        _ASN_APPLICATION_H_
+
+#include "asn_system.h"                /* for platform-dependent types */
+#include "asn_codecs.h"                /* for ASN.1 codecs specifics */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Generic type of an application-defined callback to return various
+ * types of data to the application.
+ * EXPECTED RETURN VALUES:
+ *  -1: Failed to consume bytes. Abort the mission.
+ * Non-negative return values indicate success, and ignored.
+ */
+typedef int (asn_app_consume_bytes_f)(const void *buffer, size_t size,
+       void *application_specific_key);
+
+/*
+ * A callback of this type is called whenever constraint validation fails
+ * on some ASN.1 type. See "constraints.h" for more details on constraint
+ * validation.
+ * This callback specifies a descriptor of the ASN.1 type which failed
+ * the constraint check, as well as human readable message on what
+ * particular constraint has failed.
+ */
+typedef void (asn_app_constraint_failed_f)(void *application_specific_key,
+       struct asn_TYPE_descriptor_s *type_descriptor_which_failed,
+       const void *structure_which_failed_ptr,
+       const char *error_message_format, ...) GCC_PRINTFLIKE(4, 5);
+
+#ifdef __cplusplus
+}
+#endif
+
+#include "constr_TYPE.h"       /* for asn_TYPE_descriptor_t */
+
+#endif /* _ASN_APPLICATION_H_ */
diff --git a/src/asn1c/asn_codecs.h b/src/asn1c/asn_codecs.h
new file mode 100644 (file)
index 0000000..e560014
--- /dev/null
@@ -0,0 +1,109 @@
+/*-
+ * Copyright (c) 2003, 2004, 2005 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        _ASN_CODECS_H_
+#define        _ASN_CODECS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct asn_TYPE_descriptor_s;  /* Forward declaration */
+
+/*
+ * This structure defines a set of parameters that may be passed
+ * to every ASN.1 encoder or decoder function.
+ * WARNING: if max_stack_size member is set, and you are calling the
+ *   function pointers of the asn_TYPE_descriptor_t directly,
+ *   this structure must be ALLOCATED ON THE STACK!
+ *   If you can't always satisfy this requirement, use ber_decode(),
+ *   xer_decode() and uper_decode() functions instead.
+ */
+typedef struct asn_codec_ctx_s {
+       /*
+        * Limit the decoder routines to use no (much) more stack than a given
+        * number of bytes. Most of decoders are stack-based, and this
+        * would protect against stack overflows if the number of nested
+        * encodings is high.
+        * The OCTET STRING, BIT STRING and ANY BER decoders are heap-based,
+        * and are safe from this kind of overflow.
+        * A value from getrlimit(RLIMIT_STACK) may be used to initialize
+        * this variable. Be careful in multithreaded environments, as the
+        * stack size is rather limited.
+        */
+       size_t  max_stack_size; /* 0 disables stack bounds checking */
+} asn_codec_ctx_t;
+
+/*
+ * Type of the return value of the encoding functions (der_encode, xer_encode).
+ */
+typedef struct asn_enc_rval_s {
+       /*
+        * Number of bytes encoded.
+        * -1 indicates failure to encode the structure.
+        * In this case, the members below this one are meaningful.
+        */
+       ssize_t encoded;
+
+       /*
+        * Members meaningful when (encoded == -1), for post mortem analysis.
+        */
+
+       /* Type which cannot be encoded */
+       struct asn_TYPE_descriptor_s *failed_type;
+
+       /* Pointer to the structure of that type */
+       void *structure_ptr;
+} asn_enc_rval_t;
+#define        _ASN_ENCODE_FAILED do {                                 \
+       asn_enc_rval_t tmp_error;                               \
+       tmp_error.encoded = -1;                                 \
+       tmp_error.failed_type = td;                             \
+       tmp_error.structure_ptr = sptr;                         \
+       ASN_DEBUG("Failed to encode element %s", td ? td->name : "");   \
+       return tmp_error;                                       \
+} while(0)
+#define        _ASN_ENCODED_OK(rval) do {                              \
+       rval.structure_ptr = 0;                                 \
+       rval.failed_type = 0;                                   \
+       return rval;                                            \
+} while(0)
+
+/*
+ * Type of the return value of the decoding functions (ber_decode, xer_decode)
+ * 
+ * Please note that the number of consumed bytes is ALWAYS meaningful,
+ * even if code==RC_FAIL. This is to indicate the number of successfully
+ * decoded bytes, hence providing a possibility to fail with more diagnostics
+ * (i.e., print the offending remainder of the buffer).
+ */
+enum asn_dec_rval_code_e {
+       RC_OK,          /* Decoded successfully */
+       RC_WMORE,       /* More data expected, call again */
+       RC_FAIL         /* Failure to decode data */
+};
+typedef struct asn_dec_rval_s {
+       enum asn_dec_rval_code_e code;  /* Result code */
+       size_t consumed;                /* Number of bytes consumed */
+} asn_dec_rval_t;
+#define        _ASN_DECODE_FAILED do {                                 \
+       asn_dec_rval_t tmp_error;                               \
+       tmp_error.code = RC_FAIL;                               \
+       tmp_error.consumed = 0;                                 \
+       ASN_DEBUG("Failed to decode element %s", td ? td->name : "");   \
+       return tmp_error;                                       \
+} while(0)
+#define        _ASN_DECODE_STARVED do {                                \
+       asn_dec_rval_t tmp_error;                               \
+       tmp_error.code = RC_WMORE;                              \
+       tmp_error.consumed = 0;                                 \
+       return tmp_error;                                       \
+} while(0)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ASN_CODECS_H_ */
diff --git a/src/asn1c/asn_codecs_prim.c b/src/asn1c/asn_codecs_prim.c
new file mode 100644 (file)
index 0000000..8e604a4
--- /dev/null
@@ -0,0 +1,312 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_codecs_prim.h>
+#include <errno.h>
+
+/*
+ * Decode an always-primitive type.
+ */
+asn_dec_rval_t
+ber_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td,
+       void **sptr, const void *buf_ptr, size_t size, int tag_mode) {
+       ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)*sptr;
+       asn_dec_rval_t rval;
+       ber_tlv_len_t length = 0; // =0 to avoid [incorrect] warning.
+
+       /*
+        * If the structure is not there, allocate it.
+        */
+       if(st == NULL) {
+               st = (ASN__PRIMITIVE_TYPE_t *)CALLOC(1, sizeof(*st));
+               if(st == NULL) _ASN_DECODE_FAILED;
+               *sptr = (void *)st;
+       }
+
+       ASN_DEBUG("Decoding %s as plain primitive (tm=%d)",
+               td->name, tag_mode);
+
+       /*
+        * Check tags and extract value length.
+        */
+       rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
+                       tag_mode, 0, &length, 0);
+       if(rval.code != RC_OK)
+               return rval;
+
+       ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
+
+       /*
+        * Make sure we have this length.
+        */
+       buf_ptr = ((const char *)buf_ptr) + rval.consumed;
+       size -= rval.consumed;
+       if(length > (ber_tlv_len_t)size) {
+               rval.code = RC_WMORE;
+               rval.consumed = 0;
+               return rval;
+       }
+
+       st->size = (int)length;
+       /* The following better be optimized away. */
+       if(sizeof(st->size) != sizeof(length)
+                       && (ber_tlv_len_t)st->size != length) {
+               st->size = 0;
+               _ASN_DECODE_FAILED;
+       }
+
+       st->buf = (uint8_t *)MALLOC(length + 1);
+       if(!st->buf) {
+               st->size = 0;
+               _ASN_DECODE_FAILED;
+       }
+
+       memcpy(st->buf, buf_ptr, length);
+       st->buf[length] = '\0';         /* Just in case */
+
+       rval.code = RC_OK;
+       rval.consumed += length;
+
+       ASN_DEBUG("Took %ld/%ld bytes to encode %s",
+               (long)rval.consumed,
+               (long)length, td->name);
+
+       return rval;
+}
+
+/*
+ * Encode an always-primitive type using DER.
+ */
+asn_enc_rval_t
+der_encode_primitive(asn_TYPE_descriptor_t *td, void *sptr,
+       int tag_mode, ber_tlv_tag_t tag,
+       asn_app_consume_bytes_f *cb, void *app_key) {
+       asn_enc_rval_t erval;
+       ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
+
+       ASN_DEBUG("%s %s as a primitive type (tm=%d)",
+               cb?"Encoding":"Estimating", td->name, tag_mode);
+
+       erval.encoded = der_write_tags(td, st->size, tag_mode, 0, tag,
+               cb, app_key);
+       ASN_DEBUG("%s wrote tags %d", td->name, (int)erval.encoded);
+       if(erval.encoded == -1) {
+               erval.failed_type = td;
+               erval.structure_ptr = sptr;
+               return erval;
+       }
+
+       if(cb && st->buf) {
+               if(cb(st->buf, st->size, app_key) < 0) {
+                       erval.encoded = -1;
+                       erval.failed_type = td;
+                       erval.structure_ptr = sptr;
+                       return erval;
+               }
+       } else {
+               assert(st->buf || st->size == 0);
+       }
+
+       erval.encoded += st->size;
+       _ASN_ENCODED_OK(erval);
+}
+
+void
+ASN__PRIMITIVE_TYPE_free(asn_TYPE_descriptor_t *td, void *sptr,
+               int contents_only) {
+       ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
+
+       if(!td || !sptr)
+               return;
+
+       ASN_DEBUG("Freeing %s as a primitive type", td->name);
+
+       if(st->buf)
+               FREEMEM(st->buf);
+
+       if(!contents_only)
+               FREEMEM(st);
+}
+
+
+/*
+ * Local internal type passed around as an argument.
+ */
+struct xdp_arg_s {
+       asn_TYPE_descriptor_t *type_descriptor;
+       void *struct_key;
+       xer_primitive_body_decoder_f *prim_body_decoder;
+       int decoded_something;
+       int want_more;
+};
+
+/*
+ * Since some kinds of primitive values can be encoded using value-specific
+ * tags (<MINUS-INFINITY>, <enum-element>, etc), the primitive decoder must
+ * be supplied with such tags to parse them as needed.
+ */
+static int
+xer_decode__unexpected_tag(void *key, const void *chunk_buf, size_t chunk_size) {
+       struct xdp_arg_s *arg = (struct xdp_arg_s *)key;
+       enum xer_pbd_rval bret;
+
+       /*
+        * The chunk_buf is guaranteed to start at '<'.
+        */
+       assert(chunk_size && ((const char *)chunk_buf)[0] == 0x3c);
+
+       /*
+        * Decoding was performed once already. Prohibit doing it again.
+        */
+       if(arg->decoded_something)
+               return -1;
+
+       bret = arg->prim_body_decoder(arg->type_descriptor,
+               arg->struct_key, chunk_buf, chunk_size);
+       switch(bret) {
+       case XPBD_SYSTEM_FAILURE:
+       case XPBD_DECODER_LIMIT:
+       case XPBD_BROKEN_ENCODING:
+               break;
+       case XPBD_BODY_CONSUMED:
+               /* Tag decoded successfully */
+               arg->decoded_something = 1;
+               /* Fall through */
+       case XPBD_NOT_BODY_IGNORE:      /* Safe to proceed further */
+               return 0;
+       }
+
+       return -1;
+}
+
+static ssize_t
+xer_decode__primitive_body(void *key, const void *chunk_buf, size_t chunk_size, int have_more) {
+       struct xdp_arg_s *arg = (struct xdp_arg_s *)key;
+       enum xer_pbd_rval bret;
+       size_t lead_wsp_size;
+
+       if(arg->decoded_something) {
+               if(xer_whitespace_span(chunk_buf, chunk_size) == chunk_size) {
+                       /*
+                        * Example:
+                        * "<INTEGER>123<!--/--> </INTEGER>"
+                        *                      ^- chunk_buf position.
+                        */
+                       return chunk_size;
+               }
+               /*
+                * Decoding was done once already. Prohibit doing it again.
+                */
+               return -1;
+       }
+
+       if(!have_more) {
+               /*
+                * If we've received something like "1", we can't really
+                * tell whether it is really `1` or `123`, until we know
+                * that there is no more data coming.
+                * The have_more argument will be set to 1 once something
+                * like this is available to the caller of this callback:
+                * "1<tag_start..."
+                */
+               arg->want_more = 1;
+               return -1;
+       }
+
+       lead_wsp_size = xer_whitespace_span(chunk_buf, chunk_size);
+       chunk_buf = (const char *)chunk_buf + lead_wsp_size;
+       chunk_size -= lead_wsp_size;
+
+       bret = arg->prim_body_decoder(arg->type_descriptor,
+               arg->struct_key, chunk_buf, chunk_size);
+       switch(bret) {
+       case XPBD_SYSTEM_FAILURE:
+       case XPBD_DECODER_LIMIT:
+       case XPBD_BROKEN_ENCODING:
+               break;
+       case XPBD_BODY_CONSUMED:
+               /* Tag decoded successfully */
+               arg->decoded_something = 1;
+               /* Fall through */
+       case XPBD_NOT_BODY_IGNORE:      /* Safe to proceed further */
+               return lead_wsp_size + chunk_size;
+       }
+
+       return -1;
+}
+
+
+asn_dec_rval_t
+xer_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *td,
+       void **sptr,
+       size_t struct_size,
+       const char *opt_mname,
+       const void *buf_ptr, size_t size,
+       xer_primitive_body_decoder_f *prim_body_decoder
+) {
+       const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
+       asn_struct_ctx_t s_ctx;
+       struct xdp_arg_s s_arg;
+       asn_dec_rval_t rc;
+
+       /*
+        * Create the structure if does not exist.
+        */
+       if(!*sptr) {
+               *sptr = CALLOC(1, struct_size);
+               if(!*sptr) _ASN_DECODE_FAILED;
+       }
+
+       memset(&s_ctx, 0, sizeof(s_ctx));
+       s_arg.type_descriptor = td;
+       s_arg.struct_key = *sptr;
+       s_arg.prim_body_decoder = prim_body_decoder;
+       s_arg.decoded_something = 0;
+       s_arg.want_more = 0;
+
+       rc = xer_decode_general(opt_codec_ctx, &s_ctx, &s_arg,
+               xml_tag, buf_ptr, size,
+               xer_decode__unexpected_tag, xer_decode__primitive_body);
+       switch(rc.code) {
+       case RC_OK:
+               if(!s_arg.decoded_something) {
+                       char ch;
+                       ASN_DEBUG("Primitive body is not recognized, "
+                               "supplying empty one");
+                       /*
+                        * Decoding opportunity has come and gone.
+                        * Where's the result?
+                        * Try to feed with empty body, see if it eats it.
+                        */
+                       if(prim_body_decoder(s_arg.type_descriptor,
+                               s_arg.struct_key, &ch, 0)
+                                       != XPBD_BODY_CONSUMED) {
+                               /*
+                                * This decoder does not like empty stuff.
+                                */
+                               _ASN_DECODE_FAILED;
+                       }
+               }
+               break;
+       case RC_WMORE:
+               /*
+                * Redo the whole thing later.
+                * We don't have a context to save intermediate parsing state.
+                */
+               rc.consumed = 0;
+               break;
+       case RC_FAIL:
+               rc.consumed = 0;
+               if(s_arg.want_more)
+                       rc.code = RC_WMORE;
+               else
+                       _ASN_DECODE_FAILED;
+               break;
+       }
+       return rc;
+}
+
diff --git a/src/asn1c/asn_codecs_prim.h b/src/asn1c/asn_codecs_prim.h
new file mode 100644 (file)
index 0000000..0f683fd
--- /dev/null
@@ -0,0 +1,53 @@
+/*-
+ * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        ASN_CODECS_PRIM_H
+#define        ASN_CODECS_PRIM_H
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ASN__PRIMITIVE_TYPE_s {
+       uint8_t *buf;   /* Buffer with consecutive primitive encoding bytes */
+       int size;       /* Size of the buffer */
+} ASN__PRIMITIVE_TYPE_t;       /* Do not use this type directly! */
+
+asn_struct_free_f ASN__PRIMITIVE_TYPE_free;
+ber_type_decoder_f ber_decode_primitive;
+der_type_encoder_f der_encode_primitive;
+
+/*
+ * A callback specification for the xer_decode_primitive() function below.
+ */
+enum xer_pbd_rval {
+       XPBD_SYSTEM_FAILURE,    /* System failure (memory shortage, etc) */
+       XPBD_DECODER_LIMIT,     /* Hit some decoder limitation or deficiency */
+       XPBD_BROKEN_ENCODING,   /* Encoding of a primitive body is broken */
+       XPBD_NOT_BODY_IGNORE,   /* Not a body format, but safe to ignore */
+       XPBD_BODY_CONSUMED      /* Body is recognized and consumed */
+};
+typedef enum xer_pbd_rval (xer_primitive_body_decoder_f)
+       (asn_TYPE_descriptor_t *td, void *struct_ptr,
+               const void *chunk_buf, size_t chunk_size);
+
+/*
+ * Specific function to decode simple primitive types.
+ * Also see xer_decode_general() in xer_decoder.h
+ */
+asn_dec_rval_t xer_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *type_descriptor,
+       void **struct_ptr, size_t struct_size,
+       const char *opt_mname,
+       const void *buf_ptr, size_t size,
+       xer_primitive_body_decoder_f *prim_body_decoder
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ASN_CODECS_PRIM_H */
diff --git a/src/asn1c/asn_internal.h b/src/asn1c/asn_internal.h
new file mode 100644 (file)
index 0000000..7e0f71b
--- /dev/null
@@ -0,0 +1,126 @@
+/*-
+ * Copyright (c) 2003, 2004, 2005, 2007 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * Declarations internally useful for the ASN.1 support code.
+ */
+#ifndef        _ASN_INTERNAL_H_
+#define        _ASN_INTERNAL_H_
+
+#include "asn_application.h"   /* Application-visible API */
+
+#ifndef        __NO_ASSERT_H__         /* Include assert.h only for internal use. */
+#include <assert.h>            /* for assert() macro */
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Environment version might be used to avoid running with the old library */
+#define        ASN1C_ENVIRONMENT_VERSION       923     /* Compile-time version */
+int get_asn1c_environment_version(void);       /* Run-time version */
+
+#define        CALLOC(nmemb, size)     calloc(nmemb, size)
+#define        MALLOC(size)            malloc(size)
+#define        REALLOC(oldptr, size)   realloc(oldptr, size)
+#define        FREEMEM(ptr)            free(ptr)
+
+#define        asn_debug_indent        0
+#define ASN_DEBUG_INDENT_ADD(i) do{}while(0)
+
+/*
+ * A macro for debugging the ASN.1 internals.
+ * You may enable or override it.
+ */
+#ifndef        ASN_DEBUG       /* If debugging code is not defined elsewhere... */
+#if    EMIT_ASN_DEBUG == 1     /* And it was asked to emit this code... */
+#ifdef __GNUC__
+#ifdef ASN_THREAD_SAFE
+/* Thread safety requires sacrifice in output indentation:
+ * Retain empty definition of ASN_DEBUG_INDENT_ADD. */
+#else  /* !ASN_THREAD_SAFE */
+#undef  ASN_DEBUG_INDENT_ADD
+#undef  asn_debug_indent
+int asn_debug_indent;
+#define ASN_DEBUG_INDENT_ADD(i) do { asn_debug_indent += i; } while(0)
+#endif /* ASN_THREAD_SAFE */
+#define        ASN_DEBUG(fmt, args...) do {                    \
+               int adi = asn_debug_indent;             \
+               while(adi--) fprintf(stderr, " ");      \
+               fprintf(stderr, fmt, ##args);           \
+               fprintf(stderr, " (%s:%d)\n",           \
+                       __FILE__, __LINE__);            \
+       } while(0)
+#else  /* !__GNUC__ */
+void ASN_DEBUG_f(const char *fmt, ...);
+#define        ASN_DEBUG       ASN_DEBUG_f
+#endif /* __GNUC__ */
+#else  /* EMIT_ASN_DEBUG != 1 */
+static inline void ASN_DEBUG(const char *fmt, ...) { (void)fmt; }
+#endif /* EMIT_ASN_DEBUG */
+#endif /* ASN_DEBUG */
+
+/*
+ * Invoke the application-supplied callback and fail, if something is wrong.
+ */
+#define        __ASN_E_cbc(buf, size)  (cb((buf), (size), app_key) < 0)
+#define        _ASN_E_CALLBACK(foo)    do {                                    \
+               if(foo) goto cb_failed;                                 \
+       } while(0)
+#define        _ASN_CALLBACK(buf, size)                                        \
+       _ASN_E_CALLBACK(__ASN_E_cbc(buf, size))
+#define        _ASN_CALLBACK2(buf1, size1, buf2, size2)                        \
+       _ASN_E_CALLBACK(__ASN_E_cbc(buf1, size1) || __ASN_E_cbc(buf2, size2))
+#define        _ASN_CALLBACK3(buf1, size1, buf2, size2, buf3, size3)           \
+       _ASN_E_CALLBACK(__ASN_E_cbc(buf1, size1)                        \
+               || __ASN_E_cbc(buf2, size2)                             \
+               || __ASN_E_cbc(buf3, size3))
+
+#define        _i_ASN_TEXT_INDENT(nl, level) do {                              \
+       int __level = (level);                                          \
+       int __nl = ((nl) != 0);                                         \
+       int __i;                                                        \
+       if(__nl) _ASN_CALLBACK("\n", 1);                                \
+       if(__level < 0) __level = 0;                                    \
+       for(__i = 0; __i < __level; __i++)                              \
+               _ASN_CALLBACK("    ", 4);                               \
+       er.encoded += __nl + 4 * __level;                               \
+} while(0)
+
+#define        _i_INDENT(nl)   do {                                            \
+       int __i;                                                        \
+       if((nl) && cb("\n", 1, app_key) < 0) return -1;                 \
+       for(__i = 0; __i < ilevel; __i++)                               \
+               if(cb("    ", 4, app_key) < 0) return -1;               \
+} while(0)
+
+/*
+ * Check stack against overflow, if limit is set.
+ */
+#define        _ASN_DEFAULT_STACK_MAX  (30000)
+static inline int
+_ASN_STACK_OVERFLOW_CHECK(asn_codec_ctx_t *ctx) {
+       if(ctx && ctx->max_stack_size) {
+
+               /* ctx MUST be allocated on the stack */
+               ptrdiff_t usedstack = ((char *)ctx - (char *)&ctx);
+               if(usedstack > 0) usedstack = -usedstack; /* grows up! */
+
+               /* double negative required to avoid int wrap-around */
+               if(usedstack < -(ptrdiff_t)ctx->max_stack_size) {
+                       ASN_DEBUG("Stack limit %ld reached",
+                               (long)ctx->max_stack_size);
+                       return -1;
+               }
+       }
+       return 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ASN_INTERNAL_H_ */
diff --git a/src/asn1c/asn_system.h b/src/asn1c/asn_system.h
new file mode 100644 (file)
index 0000000..e420ad2
--- /dev/null
@@ -0,0 +1,129 @@
+/*-
+ * Copyright (c) 2003, 2004, 2007 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * Miscellaneous system-dependent types.
+ */
+#ifndef        _ASN_SYSTEM_H_
+#define        _ASN_SYSTEM_H_
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>     /* For snprintf(3) */
+#include <stdlib.h>    /* For *alloc(3) */
+#include <string.h>    /* For memcpy(3) */
+#include <sys/types.h> /* For size_t */
+#include <limits.h>    /* For LONG_MAX */
+#include <stdarg.h>    /* For va_start */
+#include <stddef.h>    /* for offsetof and ptrdiff_t */
+
+#ifdef _WIN32
+
+#include <malloc.h>
+#define         snprintf       _snprintf
+#define         vsnprintf      _vsnprintf
+
+/* To avoid linking with ws2_32.lib, here's the definition of ntohl() */
+#define sys_ntohl(l)   ((((l) << 24)  & 0xff000000)    \
+                       | (((l) << 8) & 0xff0000)       \
+                       | (((l) >> 8)  & 0xff00)        \
+                       | ((l >> 24) & 0xff))
+
+#ifdef _MSC_VER                        /* MSVS.Net */
+#ifndef __cplusplus
+#define inline __inline
+#endif
+#ifndef        ASSUMESTDTYPES  /* Standard types have been defined elsewhere */
+#define        ssize_t         SSIZE_T
+typedef        char            int8_t;
+typedef        short           int16_t;
+typedef        int             int32_t;
+typedef        unsigned char   uint8_t;
+typedef        unsigned short  uint16_t;
+typedef        unsigned int    uint32_t;
+#endif /* ASSUMESTDTYPES */
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <float.h>
+#define isnan _isnan
+#define finite _finite
+#define copysign _copysign
+#define        ilogb   _logb
+#else  /* !_MSC_VER */
+#include <stdint.h>
+#endif /* _MSC_VER */
+
+#else  /* !_WIN32 */
+
+#if defined(__vxworks)
+#include <types/vxTypes.h>
+#else  /* !defined(__vxworks) */
+
+#include <inttypes.h>  /* C99 specifies this file */
+/*
+ * 1. Earlier FreeBSD version didn't have <stdint.h>,
+ * but <inttypes.h> was present.
+ * 2. Sun Solaris requires <alloca.h> for alloca(3),
+ * but does not have <stdint.h>.
+ */
+#if    (!defined(__FreeBSD__) || !defined(_SYS_INTTYPES_H_))
+#if    defined(sun)
+#include <alloca.h>    /* For alloca(3) */
+#include <ieeefp.h>    /* for finite(3) */
+#elif  defined(__hpux)
+#ifdef __GNUC__
+#include <alloca.h>    /* For alloca(3) */
+#else  /* !__GNUC__ */
+#define inline
+#endif /* __GNUC__ */
+#else
+#include <stdint.h>    /* SUSv2+ and C99 specify this file, for uintXX_t */
+#endif /* defined(sun) */
+#endif
+
+#include <netinet/in.h> /* for ntohl() */
+#define        sys_ntohl(foo)  ntohl(foo)
+
+#endif /* defined(__vxworks) */
+
+#endif /* _WIN32 */
+
+#if    __GNUC__ >= 3
+#ifndef        GCC_PRINTFLIKE
+#define        GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
+#endif
+#ifndef        GCC_NOTUSED
+#define        GCC_NOTUSED             __attribute__((unused))
+#endif
+#else
+#ifndef        GCC_PRINTFLIKE
+#define        GCC_PRINTFLIKE(fmt,var) /* nothing */
+#endif
+#ifndef        GCC_NOTUSED
+#define        GCC_NOTUSED
+#endif
+#endif
+
+/* Figure out if thread safety is requested */
+#if !defined(ASN_THREAD_SAFE) && (defined(THREAD_SAFE) || defined(_REENTRANT))
+#define        ASN_THREAD_SAFE
+#endif /* Thread safety */
+
+#ifndef        offsetof        /* If not defined by <stddef.h> */
+#define        offsetof(s, m)  ((ptrdiff_t)&(((s *)0)->m) - (ptrdiff_t)((s *)0))
+#endif /* offsetof */
+
+#ifndef        MIN             /* Suitable for comparing primitive types (integers) */
+#if defined(__GNUC__)
+#define        MIN(a,b)        ({ __typeof a _a = a; __typeof b _b = b;        \
+       ((_a)<(_b)?(_a):(_b)); })
+#else  /* !__GNUC__ */
+#define        MIN(a,b)        ((a)<(b)?(a):(b))       /* Unsafe variant */
+#endif /* __GNUC__ */
+#endif /* MIN */
+
+#endif /* _ASN_SYSTEM_H_ */
diff --git a/src/asn1c/ber_decoder.c b/src/asn1c/ber_decoder.c
new file mode 100644 (file)
index 0000000..0f99400
--- /dev/null
@@ -0,0 +1,283 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+
+#undef ADVANCE
+#define        ADVANCE(num_bytes)      do {                                    \
+               size_t num = num_bytes;                                 \
+               ptr = ((const char *)ptr) + num;                        \
+               size -= num;                                            \
+               consumed_myself += num;                                 \
+       } while(0)
+#undef RETURN
+#define        RETURN(_code)   do {                                            \
+               asn_dec_rval_t rval;                                    \
+               rval.code = _code;                                      \
+               if(opt_ctx) opt_ctx->step = step; /* Save context */    \
+               if(_code == RC_OK || opt_ctx)                           \
+                       rval.consumed = consumed_myself;                \
+               else                                                    \
+                       rval.consumed = 0;      /* Context-free */      \
+               return rval;                                            \
+       } while(0)
+
+/*
+ * The BER decoder of any type.
+ */
+asn_dec_rval_t
+ber_decode(asn_codec_ctx_t *opt_codec_ctx,
+       asn_TYPE_descriptor_t *type_descriptor,
+       void **struct_ptr, const void *ptr, size_t size) {
+       asn_codec_ctx_t s_codec_ctx;
+
+       /*
+        * Stack checker requires that the codec context
+        * must be allocated on the stack.
+        */
+       if(opt_codec_ctx) {
+               if(opt_codec_ctx->max_stack_size) {
+                       s_codec_ctx = *opt_codec_ctx;
+                       opt_codec_ctx = &s_codec_ctx;
+               }
+       } else {
+               /* If context is not given, be security-conscious anyway */
+               memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
+               s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
+               opt_codec_ctx = &s_codec_ctx;
+       }
+
+       /*
+        * Invoke type-specific decoder.
+        */
+       return type_descriptor->ber_decoder(opt_codec_ctx, type_descriptor,
+               struct_ptr,     /* Pointer to the destination structure */
+               ptr, size,      /* Buffer and its size */
+               0               /* Default tag mode is 0 */
+               );
+}
+
+/*
+ * Check the set of <TL<TL<TL...>>> tags matches the definition.
+ */
+asn_dec_rval_t
+ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
+               asn_TYPE_descriptor_t *td, asn_struct_ctx_t *opt_ctx,
+               const void *ptr, size_t size, int tag_mode, int last_tag_form,
+               ber_tlv_len_t *last_length, int *opt_tlv_form) {
+       ssize_t consumed_myself = 0;
+       ssize_t tag_len;
+       ssize_t len_len;
+       ber_tlv_tag_t tlv_tag;
+       ber_tlv_len_t tlv_len;
+       ber_tlv_len_t limit_len = -1;
+       int expect_00_terminators = 0;
+       int tlv_constr = -1;    /* If CHOICE, opt_tlv_form is not given */
+       int step = opt_ctx ? opt_ctx->step : 0; /* Where we left previously */
+       int tagno;
+
+       /*
+        * Make sure we didn't exceed the maximum stack size.
+        */
+       if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
+               RETURN(RC_FAIL);
+
+       /*
+        * So what does all this implicit skip stuff mean?
+        * Imagine two types,
+        *      A ::= [5] IMPLICIT      T
+        *      B ::= [2] EXPLICIT      T
+        * Where T is defined as
+        *      T ::= [4] IMPLICIT SEQUENCE { ... }
+        * 
+        * Let's say, we are starting to decode type A, given the
+        * following TLV stream: <5> <0>. What does this mean?
+        * It means that the type A contains type T which is,
+        * in turn, empty.
+        * Remember though, that we are still in A. We cannot
+        * just pass control to the type T decoder. Why? Because
+        * the type T decoder expects <4> <0>, not <5> <0>.
+        * So, we must make sure we are going to receive <5> while
+        * still in A, then pass control to the T decoder, indicating
+        * that the tag <4> was implicitly skipped. The decoder of T
+        * hence will be prepared to treat <4> as valid tag, and decode
+        * it appropriately.
+        */
+
+       tagno = step    /* Continuing where left previously */
+               + (tag_mode==1?-1:0)
+               ;
+       ASN_DEBUG("ber_check_tags(%s, size=%ld, tm=%d, step=%d, tagno=%d)",
+               td->name, (long)size, tag_mode, step, tagno);
+       /* assert(td->tags_count >= 1) May not be the case for CHOICE or ANY */
+
+       if(tag_mode == 0 && tagno == td->tags_count) {
+               /*
+                * This must be the _untagged_ ANY type,
+                * which outermost tag isn't known in advance.
+                * Fetch the tag and length separately.
+                */
+               tag_len = ber_fetch_tag(ptr, size, &tlv_tag);
+               switch(tag_len) {
+               case -1: RETURN(RC_FAIL);
+               case 0: RETURN(RC_WMORE);
+               }
+               tlv_constr = BER_TLV_CONSTRUCTED(ptr);
+               len_len = ber_fetch_length(tlv_constr,
+                       (const char *)ptr + tag_len, size - tag_len, &tlv_len);
+               switch(len_len) {
+               case -1: RETURN(RC_FAIL);
+               case 0: RETURN(RC_WMORE);
+               }
+               ASN_DEBUG("Advancing %ld in ANY case",
+                       (long)(tag_len + len_len));
+               ADVANCE(tag_len + len_len);
+       } else {
+               assert(tagno < td->tags_count); /* At least one loop */
+       }
+       for((void)tagno; tagno < td->tags_count; tagno++, step++) {
+
+               /*
+                * Fetch and process T from TLV.
+                */
+               tag_len = ber_fetch_tag(ptr, size, &tlv_tag);
+                       ASN_DEBUG("Fetching tag from {%p,%ld}: "
+                               "len %ld, step %d, tagno %d got %s",
+                               ptr, (long)size,
+                               (long)tag_len, step, tagno,
+                               ber_tlv_tag_string(tlv_tag));
+               switch(tag_len) {
+               case -1: RETURN(RC_FAIL);
+               case 0: RETURN(RC_WMORE);
+               }
+
+               tlv_constr = BER_TLV_CONSTRUCTED(ptr);
+
+               /*
+                * If {I}, don't check anything.
+                * If {I,B,C}, check B and C unless we're at I.
+                */
+               if(tag_mode != 0 && step == 0) {
+                       /*
+                        * We don't expect tag to match here.
+                        * It's just because we don't know how the tag
+                        * is supposed to look like.
+                        */
+               } else {
+                   assert(tagno >= 0); /* Guaranteed by the code above */
+                   if(tlv_tag != td->tags[tagno]) {
+                       /*
+                        * Unexpected tag. Too bad.
+                        */
+                       ASN_DEBUG("Expected: %s, "
+                               "expectation failed (tn=%d, tm=%d)",
+                               ber_tlv_tag_string(td->tags[tagno]),
+                               tagno, tag_mode
+                       );
+                       RETURN(RC_FAIL);
+                   }
+               }
+
+               /*
+                * Attention: if there are more tags expected,
+                * ensure that the current tag is presented
+                * in constructed form (it contains other tags!).
+                * If this one is the last one, check that the tag form
+                * matches the one given in descriptor.
+                */
+               if(tagno < (td->tags_count - 1)) {
+                       if(tlv_constr == 0) {
+                               ASN_DEBUG("tlv_constr = %d, expfail",
+                                       tlv_constr);
+                               RETURN(RC_FAIL);
+                       }
+               } else {
+                       if(last_tag_form != tlv_constr
+                       && last_tag_form != -1) {
+                               ASN_DEBUG("last_tag_form %d != %d",
+                                       last_tag_form, tlv_constr);
+                               RETURN(RC_FAIL);
+                       }
+               }
+
+               /*
+                * Fetch and process L from TLV.
+                */
+               len_len = ber_fetch_length(tlv_constr,
+                       (const char *)ptr + tag_len, size - tag_len, &tlv_len);
+               ASN_DEBUG("Fetching len = %ld", (long)len_len);
+               switch(len_len) {
+               case -1: RETURN(RC_FAIL);
+               case 0: RETURN(RC_WMORE);
+               }
+
+               /*
+                * FIXME
+                * As of today, the chain of tags
+                * must either contain several indefinite length TLVs,
+                * or several definite length ones.
+                * No mixing is allowed.
+                */
+               if(tlv_len == -1) {
+                       /*
+                        * Indefinite length.
+                        */
+                       if(limit_len == -1) {
+                               expect_00_terminators++;
+                       } else {
+                               ASN_DEBUG("Unexpected indefinite length "
+                                       "in a chain of definite lengths");
+                               RETURN(RC_FAIL);
+                       }
+                       ADVANCE(tag_len + len_len);
+                       continue;
+               } else {
+                       if(expect_00_terminators) {
+                               ASN_DEBUG("Unexpected definite length "
+                                       "in a chain of indefinite lengths");
+                               RETURN(RC_FAIL);
+                       }
+               }
+
+               /*
+                * Check that multiple TLVs specify ever decreasing length,
+                * which is consistent.
+                */
+               if(limit_len == -1) {
+                       limit_len    = tlv_len + tag_len + len_len;
+                       if(limit_len < 0) {
+                               /* Too great tlv_len value? */
+                               RETURN(RC_FAIL);
+                       }
+               } else if(limit_len != tlv_len + tag_len + len_len) {
+                       /*
+                        * Inner TLV specifies length which is inconsistent
+                        * with the outer TLV's length value.
+                        */
+                       ASN_DEBUG("Outer TLV is %ld and inner is %ld",
+                               (long)limit_len, (long)tlv_len);
+                       RETURN(RC_FAIL);
+               }
+
+               ADVANCE(tag_len + len_len);
+
+               limit_len -= (tag_len + len_len);
+               if((ssize_t)size > limit_len) {
+                       /*
+                        * Make sure that we won't consume more bytes
+                        * from the parent frame than the inferred limit.
+                        */
+                       size = limit_len;
+               }
+       }
+
+       if(opt_tlv_form)
+               *opt_tlv_form = tlv_constr;
+       if(expect_00_terminators)
+               *last_length = -expect_00_terminators;
+       else
+               *last_length = tlv_len;
+
+       RETURN(RC_OK);
+}
diff --git a/src/asn1c/ber_decoder.h b/src/asn1c/ber_decoder.h
new file mode 100644 (file)
index 0000000..9fe2e89
--- /dev/null
@@ -0,0 +1,64 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        _BER_DECODER_H_
+#define        _BER_DECODER_H_
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct asn_TYPE_descriptor_s;  /* Forward declaration */
+struct asn_codec_ctx_s;                /* Forward declaration */
+
+/*
+ * The BER decoder of any type.
+ * This function may be invoked directly from the application.
+ * The der_encode() function (der_encoder.h) is an opposite to ber_decode().
+ */
+asn_dec_rval_t ber_decode(struct asn_codec_ctx_s *opt_codec_ctx,
+       struct asn_TYPE_descriptor_s *type_descriptor,
+       void **struct_ptr,      /* Pointer to a target structure's pointer */
+       const void *buffer,     /* Data to be decoded */
+       size_t size             /* Size of that buffer */
+       );
+
+/*
+ * Type of generic function which decodes the byte stream into the structure.
+ */
+typedef asn_dec_rval_t (ber_type_decoder_f)(
+               struct asn_codec_ctx_s *opt_codec_ctx,
+               struct asn_TYPE_descriptor_s *type_descriptor,
+               void **struct_ptr, const void *buf_ptr, size_t size,
+               int tag_mode);
+
+/*******************************
+ * INTERNALLY USEFUL FUNCTIONS *
+ *******************************/
+
+/*
+ * Check that all tags correspond to the type definition (as given in head).
+ * On return, last_length would contain either a non-negative length of the
+ * value part of the last TLV, or the negative number of expected
+ * "end of content" sequences. The number may only be negative if the
+ * head->last_tag_form is non-zero.
+ */
+asn_dec_rval_t ber_check_tags(
+               struct asn_codec_ctx_s *opt_codec_ctx,  /* codec options */
+               struct asn_TYPE_descriptor_s *type_descriptor,
+               asn_struct_ctx_t *opt_ctx,      /* saved decoding context */
+               const void *ptr, size_t size,
+               int tag_mode,           /* {-1,0,1}: IMPLICIT, no, EXPLICIT */
+               int last_tag_form,      /* {-1,0:1}: any, primitive, constr */
+               ber_tlv_len_t *last_length,
+               int *opt_tlv_form       /* optional tag form */
+       );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _BER_DECODER_H_ */
diff --git a/src/asn1c/ber_tlv_length.c b/src/asn1c/ber_tlv_length.c
new file mode 100644 (file)
index 0000000..b87e75e
--- /dev/null
@@ -0,0 +1,178 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <ber_tlv_length.h>
+#include <ber_tlv_tag.h>
+
+ssize_t
+ber_fetch_length(int _is_constructed, const void *bufptr, size_t size,
+               ber_tlv_len_t *len_r) {
+       const uint8_t *buf = (const uint8_t *)bufptr;
+       unsigned oct;
+
+       if(size == 0)
+               return 0;       /* Want more */
+
+       oct = *(const uint8_t *)buf;
+       if((oct & 0x80) == 0) {
+               /*
+                * Short definite length.
+                */
+               *len_r = oct;   /* & 0x7F */
+               return 1;
+       } else {
+               ber_tlv_len_t len;
+               size_t skipped;
+
+               if(_is_constructed && oct == 0x80) {
+                       *len_r = -1;    /* Indefinite length */
+                       return 1;
+               }
+
+               if(oct == 0xff) {
+                       /* Reserved in standard for future use. */
+                       return -1;
+               }
+
+               oct &= 0x7F;    /* Leave only the 7 LS bits */
+               for(len = 0, buf++, skipped = 1;
+                       oct && (++skipped <= size); buf++, oct--) {
+
+                       len = (len << 8) | *buf;
+                       if(len < 0
+                       || (len >> ((8 * sizeof(len)) - 8) && oct > 1)) {
+                               /*
+                                * Too large length value.
+                                */
+                               return -1;
+                       }
+               }
+
+               if(oct == 0) {
+                       ber_tlv_len_t lenplusepsilon = (size_t)len + 1024;
+                       /*
+                        * Here length may be very close or equal to 2G.
+                        * However, the arithmetics used in some decoders
+                        * may add some (small) quantities to the length,
+                        * to check the resulting value against some limits.
+                        * This may result in integer wrap-around, which
+                        * we try to avoid by checking it earlier here.
+                        */
+                       if(lenplusepsilon < 0) {
+                               /* Too large length value */
+                               return -1;
+                       }
+
+                       *len_r = len;
+                       return skipped;
+               }
+
+               return 0;       /* Want more */
+       }
+
+}
+
+ssize_t
+ber_skip_length(asn_codec_ctx_t *opt_codec_ctx,
+               int _is_constructed, const void *ptr, size_t size) {
+       ber_tlv_len_t vlen;     /* Length of V in TLV */
+       ssize_t tl;             /* Length of L in TLV */
+       ssize_t ll;             /* Length of L in TLV */
+       size_t skip;
+
+       /*
+        * Make sure we didn't exceed the maximum stack size.
+        */
+       if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
+               return -1;
+
+       /*
+        * Determine the size of L in TLV.
+        */
+       ll = ber_fetch_length(_is_constructed, ptr, size, &vlen);
+       if(ll <= 0) return ll;
+
+       /*
+        * Definite length.
+        */
+       if(vlen >= 0) {
+               skip = ll + vlen;
+               if(skip > size)
+                       return 0;       /* Want more */
+               return skip;
+       }
+
+       /*
+        * Indefinite length!
+        */
+       ASN_DEBUG("Skipping indefinite length");
+       for(skip = ll, ptr = ((const char *)ptr) + ll, size -= ll;;) {
+               ber_tlv_tag_t tag;
+
+               /* Fetch the tag */
+               tl = ber_fetch_tag(ptr, size, &tag);
+               if(tl <= 0) return tl;
+
+               ll = ber_skip_length(opt_codec_ctx,
+                       BER_TLV_CONSTRUCTED(ptr),
+                       ((const char *)ptr) + tl, size - tl);
+               if(ll <= 0) return ll;
+
+               skip += tl + ll;
+
+               /*
+                * This may be the end of the indefinite length structure,
+                * two consecutive 0 octets.
+                * Check if it is true.
+                */
+               if(((const uint8_t *)ptr)[0] == 0
+               && ((const uint8_t *)ptr)[1] == 0)
+                       return skip;
+
+               ptr = ((const char *)ptr) + tl + ll;
+               size -= tl + ll;
+       }
+
+       /* UNREACHABLE */
+}
+
+size_t
+der_tlv_length_serialize(ber_tlv_len_t len, void *bufp, size_t size) {
+       size_t required_size;   /* Size of len encoding */
+       uint8_t *buf = (uint8_t *)bufp;
+       uint8_t *end;
+       size_t i;
+
+       if(len <= 127) {
+               /* Encoded in 1 octet */
+               if(size) *buf = (uint8_t)len;
+               return 1;
+       }
+
+       /*
+        * Compute the size of the subsequent bytes.
+        */
+       for(required_size = 1, i = 8; i < 8 * sizeof(len); i += 8) {
+               if(len >> i)
+                       required_size++;
+               else
+                       break;
+       }
+
+       if(size <= required_size)
+               return required_size + 1;
+
+       *buf++ = (uint8_t)(0x80 | required_size);  /* Length of the encoding */
+
+       /*
+        * Produce the len encoding, space permitting.
+        */
+       end = buf + required_size;
+       for(i -= 8; buf < end; i -= 8, buf++)
+               *buf = (uint8_t)(len >> i);
+
+       return required_size + 1;
+}
+
diff --git a/src/asn1c/ber_tlv_length.h b/src/asn1c/ber_tlv_length.h
new file mode 100644 (file)
index 0000000..3496802
--- /dev/null
@@ -0,0 +1,50 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        _BER_TLV_LENGTH_H_
+#define        _BER_TLV_LENGTH_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef ssize_t ber_tlv_len_t;
+
+/*
+ * This function tries to fetch the length of the BER TLV value and place it
+ * in *len_r.
+ * RETURN VALUES:
+ *      0:     More data expected than bufptr contains.
+ *     -1:     Fatal error deciphering length.
+ *     >0:     Number of bytes used from bufptr.
+ * On return with >0, len_r is constrained as -1..MAX, where -1 mean
+ * that the value is of indefinite length.
+ */
+ssize_t ber_fetch_length(int _is_constructed, const void *bufptr, size_t size,
+       ber_tlv_len_t *len_r);
+
+/*
+ * This function expects bufptr to be positioned over L in TLV.
+ * It returns number of bytes occupied by L and V together, suitable
+ * for skipping. The function properly handles indefinite length.
+ * RETURN VALUES:
+ *     Standard {-1,0,>0} convention.
+ */
+ssize_t ber_skip_length(
+       struct asn_codec_ctx_s *opt_codec_ctx,  /* optional context */
+       int _is_constructed, const void *bufptr, size_t size);
+
+/*
+ * This function serializes the length (L from TLV) in DER format.
+ * It always returns number of bytes necessary to represent the length,
+ * it is a caller's responsibility to check the return value
+ * against the supplied buffer's size.
+ */
+size_t der_tlv_length_serialize(ber_tlv_len_t len, void *bufptr, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _BER_TLV_LENGTH_H_ */
diff --git a/src/asn1c/ber_tlv_tag.c b/src/asn1c/ber_tlv_tag.c
new file mode 100644 (file)
index 0000000..4270876
--- /dev/null
@@ -0,0 +1,144 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <ber_tlv_tag.h>
+#include <errno.h>
+
+ssize_t
+ber_fetch_tag(const void *ptr, size_t size, ber_tlv_tag_t *tag_r) {
+       ber_tlv_tag_t val;
+       ber_tlv_tag_t tclass;
+       size_t skipped;
+
+       if(size == 0)
+               return 0;
+
+       val = *(const uint8_t *)ptr;
+       tclass = (val >> 6);
+       if((val &= 0x1F) != 0x1F) {
+               /*
+                * Simple form: everything encoded in a single octet.
+                * Tag Class is encoded using two least significant bits.
+                */
+               *tag_r = (val << 2) | tclass;
+               return 1;
+       }
+
+       /*
+        * Each octet contains 7 bits of useful information.
+        * The MSB is 0 if it is the last octet of the tag.
+        */
+       for(val = 0, ptr = ((const char *)ptr) + 1, skipped = 2;
+                       skipped <= size;
+                               ptr = ((const char *)ptr) + 1, skipped++) {
+               unsigned int oct = *(const uint8_t *)ptr;
+               if(oct & 0x80) {
+                       val = (val << 7) | (oct & 0x7F);
+                       /*
+                        * Make sure there are at least 9 bits spare
+                        * at the MS side of a value.
+                        */
+                       if(val >> ((8 * sizeof(val)) - 9)) {
+                               /*
+                                * We would not be able to accomodate
+                                * any more tag bits.
+                                */
+                               return -1;
+                       }
+               } else {
+                       val = (val << 7) | oct;
+                       *tag_r = (val << 2) | tclass;
+                       return skipped;
+               }
+       }
+
+       return 0;       /* Want more */
+}
+
+
+ssize_t
+ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *f) {
+       char buf[sizeof("[APPLICATION ]") + 32];
+       ssize_t ret;
+
+       ret = ber_tlv_tag_snprint(tag, buf, sizeof(buf));
+       if(ret >= (ssize_t)sizeof(buf) || ret < 2) {
+               errno = EPERM;
+               return -1;
+       }
+
+       return fwrite(buf, 1, ret, f);
+}
+
+ssize_t
+ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t size) {
+       char *type = 0;
+       int ret;
+
+       switch(tag & 0x3) {
+       case ASN_TAG_CLASS_UNIVERSAL:   type = "UNIVERSAL ";    break;
+       case ASN_TAG_CLASS_APPLICATION: type = "APPLICATION ";  break;
+       case ASN_TAG_CLASS_CONTEXT:     type = "";              break;
+       case ASN_TAG_CLASS_PRIVATE:     type = "PRIVATE ";      break;
+       }
+
+       ret = snprintf(buf, size, "[%s%u]", type, ((unsigned)tag) >> 2);
+       if(ret <= 0 && size) buf[0] = '\0';     /* against broken libc's */
+
+       return ret;
+}
+
+char *
+ber_tlv_tag_string(ber_tlv_tag_t tag) {
+       static char buf[sizeof("[APPLICATION ]") + 32];
+
+       (void)ber_tlv_tag_snprint(tag, buf, sizeof(buf));
+
+       return buf;
+}
+
+
+size_t
+ber_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufp, size_t size) {
+       int tclass = BER_TAG_CLASS(tag);
+       ber_tlv_tag_t tval = BER_TAG_VALUE(tag);
+       uint8_t *buf = (uint8_t *)bufp;
+       uint8_t *end;
+       size_t required_size;
+       size_t i;
+
+       if(tval <= 30) {
+               /* Encoded in 1 octet */
+               if(size) buf[0] = (tclass << 6) | tval;
+               return 1;
+       } else if(size) {
+               *buf++ = (tclass << 6) | 0x1F;
+               size--;
+       }
+
+       /*
+        * Compute the size of the subsequent bytes.
+        */
+       for(required_size = 1, i = 7; i < 8 * sizeof(tval); i += 7) {
+               if(tval >> i)
+                       required_size++;
+               else
+                       break;
+       }
+
+       if(size < required_size)
+               return required_size + 1;
+
+       /*
+        * Fill in the buffer, space permitting.
+        */
+       end = buf + required_size - 1;
+       for(i -= 7; buf < end; i -= 7, buf++)
+               *buf = 0x80 | ((tval >> i) & 0x7F);
+       *buf = (tval & 0x7F);   /* Last octet without high bit */
+
+       return required_size + 1;
+}
+
diff --git a/src/asn1c/ber_tlv_tag.h b/src/asn1c/ber_tlv_tag.h
new file mode 100644 (file)
index 0000000..60e8668
--- /dev/null
@@ -0,0 +1,60 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        _BER_TLV_TAG_H_
+#define        _BER_TLV_TAG_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum asn_tag_class {
+       ASN_TAG_CLASS_UNIVERSAL         = 0,    /* 0b00 */
+       ASN_TAG_CLASS_APPLICATION       = 1,    /* 0b01 */
+       ASN_TAG_CLASS_CONTEXT           = 2,    /* 0b10 */
+       ASN_TAG_CLASS_PRIVATE           = 3     /* 0b11 */
+};
+typedef unsigned ber_tlv_tag_t;        /* BER TAG from Tag-Length-Value */
+
+/*
+ * Tag class is encoded together with tag value for optimization purposes.
+ */
+#define        BER_TAG_CLASS(tag)      ((tag) & 0x3)
+#define        BER_TAG_VALUE(tag)      ((tag) >> 2)
+#define        BER_TLV_CONSTRUCTED(tagptr)     (((*(const uint8_t *)tagptr)&0x20)?1:0)
+
+#define        BER_TAGS_EQUAL(tag1, tag2)      ((tag1) == (tag2))
+
+/*
+ * Several functions for printing the TAG in the canonical form
+ * (i.e. "[PRIVATE 0]").
+ * Return values correspond to their libc counterparts (if any).
+ */
+ssize_t ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t buflen);
+ssize_t ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *);
+char *ber_tlv_tag_string(ber_tlv_tag_t tag);
+
+
+/*
+ * This function tries to fetch the tag from the input stream.
+ * RETURN VALUES:
+ *      0:     More data expected than bufptr contains.
+ *     -1:     Fatal error deciphering tag.
+ *     >0:     Number of bytes used from bufptr. tag_r will contain the tag.
+ */
+ssize_t ber_fetch_tag(const void *bufptr, size_t size, ber_tlv_tag_t *tag_r);
+
+/*
+ * This function serializes the tag (T from TLV) in BER format.
+ * It always returns number of bytes necessary to represent the tag,
+ * it is a caller's responsibility to check the return value
+ * against the supplied buffer's size.
+ */
+size_t ber_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufptr, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _BER_TLV_TAG_H_ */
diff --git a/src/asn1c/constr_SEQUENCE.c b/src/asn1c/constr_SEQUENCE.c
new file mode 100644 (file)
index 0000000..c405a18
--- /dev/null
@@ -0,0 +1,1422 @@
+/*-
+ * Copyright (c) 2003, 2004, 2005, 2006, 2007 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <constr_SEQUENCE.h>
+#include <per_opentype.h>
+
+/*
+ * Number of bytes left for this structure.
+ * (ctx->left) indicates the number of bytes _transferred_ for the structure.
+ * (size) contains the number of bytes in the buffer passed.
+ */
+#define        LEFT    ((size<(size_t)ctx->left)?size:(size_t)ctx->left)
+
+/*
+ * If the subprocessor function returns with an indication that it wants
+ * more data, it may well be a fatal decoding problem, because the
+ * size is constrained by the <TLV>'s L, even if the buffer size allows
+ * reading more data.
+ * For example, consider the buffer containing the following TLVs:
+ * <T:5><L:1><V> <T:6>...
+ * The TLV length clearly indicates that one byte is expected in V, but
+ * if the V processor returns with "want more data" even if the buffer
+ * contains way more data than the V processor have seen.
+ */
+#define        SIZE_VIOLATION  (ctx->left >= 0 && (size_t)ctx->left <= size)
+
+/*
+ * This macro "eats" the part of the buffer which is definitely "consumed",
+ * i.e. was correctly converted into local representation or rightfully skipped.
+ */
+#undef ADVANCE
+#define        ADVANCE(num_bytes)      do {            \
+               size_t num = num_bytes;         \
+               ptr = ((const char *)ptr) + num; \
+               size -= num;                    \
+               if(ctx->left >= 0)              \
+                       ctx->left -= num;       \
+               consumed_myself += num;         \
+       } while(0)
+
+/*
+ * Switch to the next phase of parsing.
+ */
+#undef NEXT_PHASE
+#undef PHASE_OUT
+#define        NEXT_PHASE(ctx) do {                    \
+               ctx->phase++;                   \
+               ctx->step = 0;                  \
+       } while(0)
+#define        PHASE_OUT(ctx)  do { ctx->phase = 10; } while(0)
+
+/*
+ * Return a standardized complex structure.
+ */
+#undef RETURN
+#define        RETURN(_code)   do {                    \
+               rval.code = _code;              \
+               rval.consumed = consumed_myself;\
+               return rval;                    \
+       } while(0)
+
+/*
+ * Check whether we are inside the extensions group.
+ */
+#define        IN_EXTENSION_GROUP(specs, memb_idx)     \
+       ( ((memb_idx) > (specs)->ext_after)     \
+       &&((memb_idx) < (specs)->ext_before))
+
+
+/*
+ * Tags are canonically sorted in the tag2element map.
+ */
+static int
+_t2e_cmp(const void *ap, const void *bp) {
+       const asn_TYPE_tag2member_t *a = (const asn_TYPE_tag2member_t *)ap;
+       const asn_TYPE_tag2member_t *b = (const asn_TYPE_tag2member_t *)bp;
+
+       int a_class = BER_TAG_CLASS(a->el_tag);
+       int b_class = BER_TAG_CLASS(b->el_tag);
+
+       if(a_class == b_class) {
+               ber_tlv_tag_t a_value = BER_TAG_VALUE(a->el_tag);
+               ber_tlv_tag_t b_value = BER_TAG_VALUE(b->el_tag);
+
+               if(a_value == b_value) {
+                       if(a->el_no > b->el_no)
+                               return 1;
+                       /*
+                        * Important: we do not check
+                        * for a->el_no <= b->el_no!
+                        */
+                       return 0;
+               } else if(a_value < b_value)
+                       return -1;
+               else
+                       return 1;
+       } else if(a_class < b_class) {
+               return -1;
+       } else {
+               return 1;
+       }
+}
+
+
+/*
+ * The decoder of the SEQUENCE type.
+ */
+asn_dec_rval_t
+SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+       void **struct_ptr, const void *ptr, size_t size, int tag_mode) {
+       /*
+        * Bring closer parts of structure description.
+        */
+       asn_SEQUENCE_specifics_t *specs = (asn_SEQUENCE_specifics_t *)td->specifics;
+       asn_TYPE_member_t *elements = td->elements;
+
+       /*
+        * Parts of the structure being constructed.
+        */
+       void *st = *struct_ptr; /* Target structure. */
+       asn_struct_ctx_t *ctx;  /* Decoder context */
+
+       ber_tlv_tag_t tlv_tag;  /* T from TLV */
+       asn_dec_rval_t rval;    /* Return code from subparsers */
+
+       ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
+       int edx;                        /* SEQUENCE element's index */
+
+       ASN_DEBUG("Decoding %s as SEQUENCE", td->name);
+       
+       /*
+        * Create the target structure if it is not present already.
+        */
+       if(st == 0) {
+               st = *struct_ptr = CALLOC(1, specs->struct_size);
+               if(st == 0) {
+                       RETURN(RC_FAIL);
+               }
+       }
+
+       /*
+        * Restore parsing context.
+        */
+       ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
+       
+       /*
+        * Start to parse where left previously
+        */
+       switch(ctx->phase) {
+       case 0:
+               /*
+                * PHASE 0.
+                * Check that the set of tags associated with given structure
+                * perfectly fits our expectations.
+                */
+
+               rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size,
+                       tag_mode, 1, &ctx->left, 0);
+               if(rval.code != RC_OK) {
+                       ASN_DEBUG("%s tagging check failed: %d",
+                               td->name, rval.code);
+                       return rval;
+               }
+
+               if(ctx->left >= 0)
+                       ctx->left += rval.consumed; /* ?Substracted below! */
+               ADVANCE(rval.consumed);
+
+               NEXT_PHASE(ctx);
+
+               ASN_DEBUG("Structure consumes %ld bytes, buffer %ld",
+                       (long)ctx->left, (long)size);
+
+               /* Fall through */
+       case 1:
+               /*
+                * PHASE 1.
+                * From the place where we've left it previously,
+                * try to decode the next member from the list of
+                * this structure's elements.
+                * (ctx->step) stores the member being processed
+                * between invocations and the microphase {0,1} of parsing
+                * that member:
+                *      step = (<member_number> * 2 + <microphase>).
+                */
+         for(edx = (ctx->step >> 1); edx < td->elements_count;
+                       edx++, ctx->step = (ctx->step & ~1) + 2) {
+               void *memb_ptr;         /* Pointer to the member */
+               void **memb_ptr2;       /* Pointer to that pointer */
+               ssize_t tag_len;        /* Length of TLV's T */
+               int opt_edx_end;        /* Next non-optional element */
+               int use_bsearch;
+               int n;
+
+               if(ctx->step & 1)
+                       goto microphase2;
+
+               /*
+                * MICROPHASE 1: Synchronize decoding.
+                */
+               ASN_DEBUG("In %s SEQUENCE left %d, edx=%d flags=%d"
+                               " opt=%d ec=%d",
+                       td->name, (int)ctx->left, edx,
+                       elements[edx].flags, elements[edx].optional,
+                       td->elements_count);
+
+               if(ctx->left == 0       /* No more stuff is expected */
+               && (
+                       /* Explicit OPTIONAL specification reaches the end */
+                       (edx + elements[edx].optional
+                                       == td->elements_count)
+                       ||
+                       /* All extensions are optional */
+                       (IN_EXTENSION_GROUP(specs, edx)
+                               && specs->ext_before > td->elements_count)
+                  )
+               ) {
+                       ASN_DEBUG("End of SEQUENCE %s", td->name);
+                       /*
+                        * Found the legitimate end of the structure.
+                        */
+                       PHASE_OUT(ctx);
+                       RETURN(RC_OK);
+               }
+
+               /*
+                * Fetch the T from TLV.
+                */
+               tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag);
+               ASN_DEBUG("Current tag in %s SEQUENCE for element %d "
+                       "(%s) is %s encoded in %d bytes, of frame %ld",
+                       td->name, edx, elements[edx].name,
+                       ber_tlv_tag_string(tlv_tag), (int)tag_len, (long)LEFT);
+               switch(tag_len) {
+               case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
+                       /* Fall through */
+               case -1: RETURN(RC_FAIL);
+               }
+
+               if(ctx->left < 0 && ((const uint8_t *)ptr)[0] == 0) {
+                       if(LEFT < 2) {
+                               if(SIZE_VIOLATION)
+                                       RETURN(RC_FAIL);
+                               else
+                                       RETURN(RC_WMORE);
+                       } else if(((const uint8_t *)ptr)[1] == 0) {
+                       ASN_DEBUG("edx = %d, opt = %d, ec=%d",
+                               edx, elements[edx].optional,
+                               td->elements_count);
+                               if((edx + elements[edx].optional
+                                       == td->elements_count)
+                               || (IN_EXTENSION_GROUP(specs, edx)
+                                       && specs->ext_before
+                                               > td->elements_count)) {
+                                       /*
+                                        * Yeah, baby! Found the terminator
+                                        * of the indefinite length structure.
+                                        */
+                                       /*
+                                        * Proceed to the canonical
+                                        * finalization function.
+                                        * No advancing is necessary.
+                                        */
+                                       goto phase3;
+                               }
+                       }
+               }
+
+               /*
+                * Find the next available type with this tag.
+                */
+               use_bsearch = 0;
+               opt_edx_end = edx + elements[edx].optional + 1;
+               if(opt_edx_end > td->elements_count)
+                       opt_edx_end = td->elements_count;       /* Cap */
+               else if(opt_edx_end - edx > 8) {
+                       /* Limit the scope of linear search... */
+                       opt_edx_end = edx + 8;
+                       use_bsearch = 1;
+                       /* ... and resort to bsearch() */
+               }
+               for(n = edx; n < opt_edx_end; n++) {
+                       if(BER_TAGS_EQUAL(tlv_tag, elements[n].tag)) {
+                               /*
+                                * Found element corresponding to the tag
+                                * being looked at.
+                                * Reposition over the right element.
+                                */
+                               edx = n;
+                               ctx->step = 1 + 2 * edx;        /* Remember! */
+                               goto microphase2;
+                       } else if(elements[n].flags & ATF_OPEN_TYPE) {
+                               /*
+                                * This is the ANY type, which may bear
+                                * any flag whatsoever.
+                                */
+                               edx = n;
+                               ctx->step = 1 + 2 * edx;        /* Remember! */
+                               goto microphase2;
+                       } else if(elements[n].tag == (ber_tlv_tag_t)-1) {
+                               use_bsearch = 1;
+                               break;
+                       }
+               }
+               if(use_bsearch) {
+                       /*
+                        * Resort to a binary search over
+                        * sorted array of tags.
+                        */
+                       asn_TYPE_tag2member_t *t2m;
+                       asn_TYPE_tag2member_t key;
+                       key.el_tag = tlv_tag;
+                       key.el_no = edx;
+                       t2m = (asn_TYPE_tag2member_t *)bsearch(&key,
+                               specs->tag2el, specs->tag2el_count,
+                               sizeof(specs->tag2el[0]), _t2e_cmp);
+                       if(t2m) {
+                               asn_TYPE_tag2member_t *best = 0;
+                               asn_TYPE_tag2member_t *t2m_f, *t2m_l;
+                               int edx_max = edx + elements[edx].optional;
+                               /*
+                                * Rewind to the first element with that tag,
+                                * `cause bsearch() does not guarantee order.
+                                */
+                               t2m_f = t2m + t2m->toff_first;
+                               t2m_l = t2m + t2m->toff_last;
+                               for(t2m = t2m_f; t2m <= t2m_l; t2m++) {
+                                       if(t2m->el_no > edx_max) break;
+                                       if(t2m->el_no < edx) continue;
+                                       best = t2m;
+                               }
+                               if(best) {
+                                       edx = best->el_no;
+                                       ctx->step = 1 + 2 * edx;
+                                       goto microphase2;
+                               }
+                       }
+                       n = opt_edx_end;
+               }
+               if(n == opt_edx_end) {
+                       /*
+                        * If tag is unknown, it may be either
+                        * an unknown (thus, incorrect) tag,
+                        * or an extension (...),
+                        * or an end of the indefinite-length structure.
+                        */
+                       if(!IN_EXTENSION_GROUP(specs,
+                               edx + elements[edx].optional)) {
+                               ASN_DEBUG("Unexpected tag %s (at %d)",
+                                       ber_tlv_tag_string(tlv_tag), edx);
+                               ASN_DEBUG("Expected tag %s (%s)%s",
+                                       ber_tlv_tag_string(elements[edx].tag),
+                                       elements[edx].name,
+                                       elements[edx].optional
+                                               ?" or alternatives":"");
+                               RETURN(RC_FAIL);
+                       } else {
+                               /* Skip this tag */
+                               ssize_t skip;
+                               edx += elements[edx].optional;
+
+                               ASN_DEBUG("Skipping unexpected %s (at %d)",
+                                       ber_tlv_tag_string(tlv_tag), edx);
+                               skip = ber_skip_length(opt_codec_ctx,
+                                       BER_TLV_CONSTRUCTED(ptr),
+                                       (const char *)ptr + tag_len,
+                                       LEFT - tag_len);
+                               ASN_DEBUG("Skip length %d in %s",
+                                       (int)skip, td->name);
+                               switch(skip) {
+                               case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
+                                       /* Fall through */
+                               case -1: RETURN(RC_FAIL);
+                               }
+
+                               ADVANCE(skip + tag_len);
+                               ctx->step -= 2;
+                               edx--;
+                               continue;  /* Try again with the next tag */
+                       }
+               }
+
+               /*
+                * MICROPHASE 2: Invoke the member-specific decoder.
+                */
+               ctx->step |= 1;         /* Confirm entering next microphase */
+       microphase2:
+               ASN_DEBUG("Inside SEQUENCE %s MF2", td->name);
+               
+               /*
+                * Compute the position of the member inside a structure,
+                * and also a type of containment (it may be contained
+                * as pointer or using inline inclusion).
+                */
+               if(elements[edx].flags & ATF_POINTER) {
+                       /* Member is a pointer to another structure */
+                       memb_ptr2 = (void **)((char *)st + elements[edx].memb_offset);
+               } else {
+                       /*
+                        * A pointer to a pointer
+                        * holding the start of the structure
+                        */
+                       memb_ptr = (char *)st + elements[edx].memb_offset;
+                       memb_ptr2 = &memb_ptr;
+               }
+               /*
+                * Invoke the member fetch routine according to member's type
+                */
+               rval = elements[edx].type->ber_decoder(opt_codec_ctx,
+                               elements[edx].type,
+                               memb_ptr2, ptr, LEFT,
+                               elements[edx].tag_mode);
+               ASN_DEBUG("In %s SEQUENCE decoded %d %s of %d "
+                       "in %d bytes rval.code %d, size=%d",
+                       td->name, edx, elements[edx].type->name,
+                       (int)LEFT, (int)rval.consumed, rval.code, (int)size);
+               switch(rval.code) {
+               case RC_OK:
+                       break;
+               case RC_WMORE: /* More data expected */
+                       if(!SIZE_VIOLATION) {
+                               ADVANCE(rval.consumed);
+                               RETURN(RC_WMORE);
+                       }
+                       ASN_DEBUG("Size violation (c->l=%ld <= s=%ld)",
+                               (long)ctx->left, (long)size);
+                       /* Fall through */
+               case RC_FAIL: /* Fatal error */
+                       RETURN(RC_FAIL);
+               } /* switch(rval) */
+               
+               ADVANCE(rval.consumed);
+         }     /* for(all structure members) */
+
+       phase3:
+               ctx->phase = 3;
+       case 3: /* 00 and other tags expected */
+       case 4: /* only 00's expected */
+
+               ASN_DEBUG("SEQUENCE %s Leftover: %ld, size = %ld",
+                       td->name, (long)ctx->left, (long)size);
+
+               /*
+                * Skip everything until the end of the SEQUENCE.
+                */
+               while(ctx->left) {
+                       ssize_t tl, ll;
+
+                       tl = ber_fetch_tag(ptr, LEFT, &tlv_tag);
+                       switch(tl) {
+                       case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
+                               /* Fall through */
+                       case -1: RETURN(RC_FAIL);
+                       }
+
+                       /*
+                        * If expected <0><0>...
+                        */
+                       if(ctx->left < 0
+                               && ((const uint8_t *)ptr)[0] == 0) {
+                               if(LEFT < 2) {
+                                       if(SIZE_VIOLATION)
+                                               RETURN(RC_FAIL);
+                                       else
+                                               RETURN(RC_WMORE);
+                               } else if(((const uint8_t *)ptr)[1] == 0) {
+                                       /*
+                                        * Correctly finished with <0><0>.
+                                        */
+                                       ADVANCE(2);
+                                       ctx->left++;
+                                       ctx->phase = 4;
+                                       continue;
+                               }
+                       }
+
+                       if(!IN_EXTENSION_GROUP(specs, td->elements_count)
+                       || ctx->phase == 4) {
+                               ASN_DEBUG("Unexpected continuation "
+                                       "of a non-extensible type "
+                                       "%s (SEQUENCE): %s",
+                                       td->name,
+                                       ber_tlv_tag_string(tlv_tag));
+                               RETURN(RC_FAIL);
+                       }
+
+                       ll = ber_skip_length(opt_codec_ctx,
+                               BER_TLV_CONSTRUCTED(ptr),
+                               (const char *)ptr + tl, LEFT - tl);
+                       switch(ll) {
+                       case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
+                               /* Fall through */
+                       case -1: RETURN(RC_FAIL);
+                       }
+
+                       ADVANCE(tl + ll);
+               }
+
+               PHASE_OUT(ctx);
+       }
+       
+       RETURN(RC_OK);
+}
+
+
+/*
+ * The DER encoder of the SEQUENCE type.
+ */
+asn_enc_rval_t
+SEQUENCE_encode_der(asn_TYPE_descriptor_t *td,
+       void *sptr, int tag_mode, ber_tlv_tag_t tag,
+       asn_app_consume_bytes_f *cb, void *app_key) {
+       size_t computed_size = 0;
+       asn_enc_rval_t erval;
+       ssize_t ret;
+       int edx;
+
+       ASN_DEBUG("%s %s as SEQUENCE",
+               cb?"Encoding":"Estimating", td->name);
+
+       /*
+        * Gather the length of the underlying members sequence.
+        */
+       for(edx = 0; edx < td->elements_count; edx++) {
+               asn_TYPE_member_t *elm = &td->elements[edx];
+               void *memb_ptr;
+               if(elm->flags & ATF_POINTER) {
+                       memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
+                       if(!memb_ptr) {
+                               if(elm->optional) continue;
+                               /* Mandatory element is missing */
+                               _ASN_ENCODE_FAILED;
+                       }
+               } else {
+                       memb_ptr = (void *)((char *)sptr + elm->memb_offset);
+               }
+               erval = elm->type->der_encoder(elm->type, memb_ptr,
+                       elm->tag_mode, elm->tag,
+                       0, 0);
+               if(erval.encoded == -1)
+                       return erval;
+               computed_size += erval.encoded;
+               ASN_DEBUG("Member %d %s estimated %ld bytes",
+                       edx, elm->name, (long)erval.encoded);
+       }
+
+       /*
+        * Encode the TLV for the sequence itself.
+        */
+       ret = der_write_tags(td, computed_size, tag_mode, 1, tag, cb, app_key);
+       ASN_DEBUG("Wrote tags: %ld (+%ld)", (long)ret, (long)computed_size);
+       if(ret == -1)
+               _ASN_ENCODE_FAILED;
+       erval.encoded = computed_size + ret;
+
+       if(!cb) _ASN_ENCODED_OK(erval);
+
+       /*
+        * Encode all members.
+        */
+       for(edx = 0; edx < td->elements_count; edx++) {
+               asn_TYPE_member_t *elm = &td->elements[edx];
+               asn_enc_rval_t tmperval;
+               void *memb_ptr;
+
+               if(elm->flags & ATF_POINTER) {
+                       memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
+                       if(!memb_ptr) continue;
+               } else {
+                       memb_ptr = (void *)((char *)sptr + elm->memb_offset);
+               }
+               tmperval = elm->type->der_encoder(elm->type, memb_ptr,
+                       elm->tag_mode, elm->tag,
+                       cb, app_key);
+               if(tmperval.encoded == -1)
+                       return tmperval;
+               computed_size -= tmperval.encoded;
+               ASN_DEBUG("Member %d %s of SEQUENCE %s encoded in %ld bytes",
+                       edx, elm->name, td->name, (long)tmperval.encoded);
+       }
+
+       if(computed_size != 0)
+               /*
+                * Encoded size is not equal to the computed size.
+                */
+               _ASN_ENCODE_FAILED;
+
+       _ASN_ENCODED_OK(erval);
+}
+
+
+#undef XER_ADVANCE
+#define        XER_ADVANCE(num_bytes)  do {                    \
+               size_t num = num_bytes;                 \
+               buf_ptr = ((const char *)buf_ptr) + num;\
+               size -= num;                            \
+               consumed_myself += num;                 \
+       } while(0)
+
+/*
+ * Decode the XER (XML) data.
+ */
+asn_dec_rval_t
+SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+       void **struct_ptr, const char *opt_mname,
+               const void *buf_ptr, size_t size) {
+       /*
+        * Bring closer parts of structure description.
+        */
+       asn_SEQUENCE_specifics_t *specs
+               = (asn_SEQUENCE_specifics_t *)td->specifics;
+       asn_TYPE_member_t *elements = td->elements;
+       const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
+
+       /*
+        * ... and parts of the structure being constructed.
+        */
+       void *st = *struct_ptr; /* Target structure. */
+       asn_struct_ctx_t *ctx;  /* Decoder context */
+
+       asn_dec_rval_t rval;            /* Return value from a decoder */
+       ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
+       int edx;                        /* Element index */
+       int edx_end;
+
+       /*
+        * Create the target structure if it is not present already.
+        */
+       if(st == 0) {
+               st = *struct_ptr = CALLOC(1, specs->struct_size);
+               if(st == 0) RETURN(RC_FAIL);
+       }
+
+       /*
+        * Restore parsing context.
+        */
+       ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
+
+
+       /*
+        * Phases of XER/XML processing:
+        * Phase 0: Check that the opening tag matches our expectations.
+        * Phase 1: Processing body and reacting on closing tag.
+        * Phase 2: Processing inner type.
+        * Phase 3: Skipping unknown extensions.
+        * Phase 4: PHASED OUT
+        */
+       for(edx = ctx->step; ctx->phase <= 3;) {
+               pxer_chunk_type_e ch_type;      /* XER chunk type */
+               ssize_t ch_size;                /* Chunk size */
+               xer_check_tag_e tcv;            /* Tag check value */
+               asn_TYPE_member_t *elm;
+               int n;
+
+               /*
+                * Go inside the inner member of a sequence.
+                */
+               if(ctx->phase == 2) {
+                       asn_dec_rval_t tmprval;
+                       void *memb_ptr;         /* Pointer to the member */
+                       void **memb_ptr2;       /* Pointer to that pointer */
+
+                       elm = &td->elements[edx];
+
+                       if(elm->flags & ATF_POINTER) {
+                               /* Member is a pointer to another structure */
+                               memb_ptr2 = (void **)((char *)st + elm->memb_offset);
+                       } else {
+                               memb_ptr = (char *)st + elm->memb_offset;
+                               memb_ptr2 = &memb_ptr;
+                       }
+
+                       /* Invoke the inner type decoder, m.b. multiple times */
+                       tmprval = elm->type->xer_decoder(opt_codec_ctx,
+                                       elm->type, memb_ptr2, elm->name,
+                                       buf_ptr, size);
+                       XER_ADVANCE(tmprval.consumed);
+                       if(tmprval.code != RC_OK)
+                               RETURN(tmprval.code);
+                       ctx->phase = 1; /* Back to body processing */
+                       ctx->step = ++edx;
+                       ASN_DEBUG("XER/SEQUENCE phase => %d, step => %d",
+                               ctx->phase, ctx->step);
+                       /* Fall through */
+               }
+
+               /*
+                * Get the next part of the XML stream.
+                */
+               ch_size = xer_next_token(&ctx->context, buf_ptr, size,
+                       &ch_type);
+               switch(ch_size) {
+               case -1: RETURN(RC_FAIL);
+               case 0:  RETURN(RC_WMORE);
+               default:
+                       switch(ch_type) {
+                       case PXER_COMMENT:      /* Got XML comment */
+                       case PXER_TEXT:         /* Ignore free-standing text */
+                               XER_ADVANCE(ch_size);   /* Skip silently */
+                               continue;
+                       case PXER_TAG:
+                               break;  /* Check the rest down there */
+                       }
+               }
+
+               tcv = xer_check_tag(buf_ptr, ch_size, xml_tag);
+               ASN_DEBUG("XER/SEQUENCE: tcv = %d, ph=%d [%s]",
+                       tcv, ctx->phase, xml_tag);
+
+               /* Skip the extensions section */
+               if(ctx->phase == 3) {
+                       switch(xer_skip_unknown(tcv, &ctx->left)) {
+                       case -1:
+                               ctx->phase = 4;
+                               RETURN(RC_FAIL);
+                       case 0:
+                               XER_ADVANCE(ch_size);
+                               continue;
+                       case 1:
+                               XER_ADVANCE(ch_size);
+                               ctx->phase = 1;
+                               continue;
+                       case 2:
+                               ctx->phase = 1;
+                               break;
+                       }
+               }
+
+               switch(tcv) {
+               case XCT_CLOSING:
+                       if(ctx->phase == 0) break;
+                       ctx->phase = 0;
+                       /* Fall through */
+               case XCT_BOTH:
+                       if(ctx->phase == 0) {
+                               if(edx >= td->elements_count
+                                  ||
+                                  /* Explicit OPTIONAL specs reaches the end */
+                                   (edx + elements[edx].optional
+                                       == td->elements_count)
+                                  ||
+                                  /* All extensions are optional */
+                                  (IN_EXTENSION_GROUP(specs, edx)
+                                       && specs->ext_before
+                                               > td->elements_count)
+                               ) {
+                                       XER_ADVANCE(ch_size);
+                                       ctx->phase = 4; /* Phase out */
+                                       RETURN(RC_OK);
+                               } else {
+                                       ASN_DEBUG("Premature end of XER SEQUENCE");
+                                       RETURN(RC_FAIL);
+                               }
+                       }
+                       /* Fall through */
+               case XCT_OPENING:
+                       if(ctx->phase == 0) {
+                               XER_ADVANCE(ch_size);
+                               ctx->phase = 1; /* Processing body phase */
+                               continue;
+                       }
+                       /* Fall through */
+               case XCT_UNKNOWN_OP:
+               case XCT_UNKNOWN_BO:
+
+                       ASN_DEBUG("XER/SEQUENCE: tcv=%d, ph=%d, edx=%d",
+                               tcv, ctx->phase, edx);
+                       if(ctx->phase != 1) {
+                               break;  /* Really unexpected */
+                       }
+
+                       if(edx < td->elements_count) {
+                               /*
+                                * Search which member corresponds to this tag.
+                                */
+                               edx_end = edx + elements[edx].optional + 1;
+                               if(edx_end > td->elements_count)
+                                       edx_end = td->elements_count;
+                               for(n = edx; n < edx_end; n++) {
+                                       elm = &td->elements[n];
+                                       tcv = xer_check_tag(buf_ptr,
+                                               ch_size, elm->name);
+                                       switch(tcv) {
+                                       case XCT_BOTH:
+                                       case XCT_OPENING:
+                                               /*
+                                                * Process this member.
+                                                */
+                                               ctx->step = edx = n;
+                                               ctx->phase = 2;
+                                               break;
+                                       case XCT_UNKNOWN_OP:
+                                       case XCT_UNKNOWN_BO:
+                                               continue;
+                                       default:
+                                               n = edx_end;
+                                               break;  /* Phase out */
+                                       }
+                                       break;
+                               }
+                               if(n != edx_end)
+                                       continue;
+                       } else {
+                               ASN_DEBUG("Out of defined members: %d/%d",
+                                       edx, td->elements_count);
+                       }
+
+                       /* It is expected extension */
+                       if(IN_EXTENSION_GROUP(specs,
+                               edx + (edx < td->elements_count
+                                       ? elements[edx].optional : 0))) {
+                               ASN_DEBUG("Got anticipated extension at %d",
+                                       edx);
+                               /*
+                                * Check for (XCT_BOTH or XCT_UNKNOWN_BO)
+                                * By using a mask. Only record a pure
+                                * <opening> tags.
+                                */
+                               if(tcv & XCT_CLOSING) {
+                                       /* Found </extension> without body */
+                               } else {
+                                       ctx->left = 1;
+                                       ctx->phase = 3; /* Skip ...'s */
+                               }
+                               XER_ADVANCE(ch_size);
+                               continue;
+                       }
+
+                       /* Fall through */
+               default:
+                       break;
+               }
+
+               ASN_DEBUG("Unexpected XML tag in SEQUENCE [%c%c%c%c%c%c]",
+                       size>0?((const char *)buf_ptr)[0]:'.',
+                       size>1?((const char *)buf_ptr)[1]:'.',
+                       size>2?((const char *)buf_ptr)[2]:'.',
+                       size>3?((const char *)buf_ptr)[3]:'.',
+                       size>4?((const char *)buf_ptr)[4]:'.',
+                       size>5?((const char *)buf_ptr)[5]:'.');
+               break;
+       }
+
+       ctx->phase = 4; /* "Phase out" on hard failure */
+       RETURN(RC_FAIL);
+}
+
+asn_enc_rval_t
+SEQUENCE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+       int ilevel, enum xer_encoder_flags_e flags,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       asn_enc_rval_t er;
+       int xcan = (flags & XER_F_CANONICAL);
+       int edx;
+
+       if(!sptr)
+               _ASN_ENCODE_FAILED;
+
+       er.encoded = 0;
+
+       for(edx = 0; edx < td->elements_count; edx++) {
+               asn_enc_rval_t tmper;
+               asn_TYPE_member_t *elm = &td->elements[edx];
+               void *memb_ptr;
+               const char *mname = elm->name;
+               unsigned int mlen = strlen(mname);
+
+               if(elm->flags & ATF_POINTER) {
+                       memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
+                       if(!memb_ptr) {
+                               if(elm->optional)
+                                       continue;
+                               /* Mandatory element is missing */
+                               _ASN_ENCODE_FAILED;
+                       }
+               } else {
+                       memb_ptr = (void *)((char *)sptr + elm->memb_offset);
+               }
+
+               if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel);
+               _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
+
+               /* Print the member itself */
+               tmper = elm->type->xer_encoder(elm->type, memb_ptr,
+                       ilevel + 1, flags, cb, app_key);
+               if(tmper.encoded == -1) return tmper;
+
+               _ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
+               er.encoded += 5 + (2 * mlen) + tmper.encoded;
+       }
+
+       if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1);
+
+       _ASN_ENCODED_OK(er);
+cb_failed:
+       _ASN_ENCODE_FAILED;
+}
+
+int
+SEQUENCE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       int edx;
+       int ret;
+
+       if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+
+       /* Dump preamble */
+       if(cb(td->name, strlen(td->name), app_key) < 0
+       || cb(" ::= {", 6, app_key) < 0)
+               return -1;
+
+       for(edx = 0; edx < td->elements_count; edx++) {
+               asn_TYPE_member_t *elm = &td->elements[edx];
+               const void *memb_ptr;
+
+               if(elm->flags & ATF_POINTER) {
+                       memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset);
+                       if(!memb_ptr) {
+                               if(elm->optional) continue;
+                               /* Print <absent> line */
+                               /* Fall through */
+                       }
+               } else {
+                       memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+               }
+
+               /* Indentation */
+               _i_INDENT(1);
+
+               /* Print the member's name and stuff */
+               if(cb(elm->name, strlen(elm->name), app_key) < 0
+               || cb(": ", 2, app_key) < 0)
+                       return -1;
+
+               /* Print the member itself */
+               ret = elm->type->print_struct(elm->type, memb_ptr, ilevel + 1,
+                       cb, app_key);
+               if(ret) return ret;
+       }
+
+       ilevel--;
+       _i_INDENT(1);
+
+       return (cb("}", 1, app_key) < 0) ? -1 : 0;
+}
+
+void
+SEQUENCE_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
+       int edx;
+
+       if(!td || !sptr)
+               return;
+
+       ASN_DEBUG("Freeing %s as SEQUENCE", td->name);
+
+       for(edx = 0; edx < td->elements_count; edx++) {
+               asn_TYPE_member_t *elm = &td->elements[edx];
+               void *memb_ptr;
+               if(elm->flags & ATF_POINTER) {
+                       memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
+                       if(memb_ptr)
+                               ASN_STRUCT_FREE(*elm->type, memb_ptr);
+               } else {
+                       memb_ptr = (void *)((char *)sptr + elm->memb_offset);
+                       ASN_STRUCT_FREE_CONTENTS_ONLY(*elm->type, memb_ptr);
+               }
+       }
+
+       if(!contents_only) {
+               FREEMEM(sptr);
+       }
+}
+
+int
+SEQUENCE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+               asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+       int edx;
+
+       if(!sptr) {
+               _ASN_CTFAIL(app_key, td, sptr,
+                       "%s: value not given (%s:%d)",
+                       td->name, __FILE__, __LINE__);
+               return -1;
+       }
+
+       /*
+        * Iterate over structure members and check their validity.
+        */
+       for(edx = 0; edx < td->elements_count; edx++) {
+               asn_TYPE_member_t *elm = &td->elements[edx];
+               const void *memb_ptr;
+
+               if(elm->flags & ATF_POINTER) {
+                       memb_ptr = *(const void * const *)((const char *)sptr + elm->memb_offset);
+                       if(!memb_ptr) {
+                               if(elm->optional)
+                                       continue;
+                               _ASN_CTFAIL(app_key, td, sptr,
+                               "%s: mandatory element %s absent (%s:%d)",
+                               td->name, elm->name, __FILE__, __LINE__);
+                               return -1;
+                       }
+               } else {
+                       memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+               }
+
+               if(elm->memb_constraints) {
+                       int ret = elm->memb_constraints(elm->type, memb_ptr,
+                               ctfailcb, app_key);
+                       if(ret) return ret;
+               } else {
+                       int ret = elm->type->check_constraints(elm->type,
+                               memb_ptr, ctfailcb, app_key);
+                       if(ret) return ret;
+                       /*
+                        * Cannot inherit it earlier:
+                        * need to make sure we get the updated version.
+                        */
+                       elm->memb_constraints = elm->type->check_constraints;
+               }
+       }
+
+       return 0;
+}
+
+asn_dec_rval_t
+SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+       asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+       asn_SEQUENCE_specifics_t *specs = (asn_SEQUENCE_specifics_t *)td->specifics;
+       void *st = *sptr;       /* Target structure. */
+       int extpresent;         /* Extension additions are present */
+       uint8_t *opres;         /* Presence of optional root members */
+       asn_per_data_t opmd;
+       asn_dec_rval_t rv;
+       int edx;
+
+       (void)constraints;
+
+       if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
+               _ASN_DECODE_FAILED;
+
+       if(!st) {
+               st = *sptr = CALLOC(1, specs->struct_size);
+               if(!st) _ASN_DECODE_FAILED;
+       }
+
+       ASN_DEBUG("Decoding %s as SEQUENCE (UPER)", td->name);
+
+       /* Handle extensions */
+       if(specs->ext_before >= 0) {
+               extpresent = per_get_few_bits(pd, 1);
+               if(extpresent < 0) _ASN_DECODE_STARVED;
+       } else {
+               extpresent = 0;
+       }
+
+       /* Prepare a place and read-in the presence bitmap */
+       memset(&opmd, 0, sizeof(opmd));
+       if(specs->roms_count) {
+               opres = (uint8_t *)MALLOC(((specs->roms_count + 7) >> 3) + 1);
+               if(!opres) _ASN_DECODE_FAILED;
+               /* Get the presence map */
+               if(per_get_many_bits(pd, opres, 0, specs->roms_count)) {
+                       FREEMEM(opres);
+                       _ASN_DECODE_STARVED;
+               }
+               opmd.buffer = opres;
+               opmd.nbits = specs->roms_count;
+               ASN_DEBUG("Read in presence bitmap for %s of %d bits (%x..)",
+                       td->name, specs->roms_count, *opres);
+       } else {
+               opres = 0;
+       }
+
+       /*
+        * Get the sequence ROOT elements.
+        */
+       for(edx = 0; edx < td->elements_count; edx++) {
+               asn_TYPE_member_t *elm = &td->elements[edx];
+               void *memb_ptr;         /* Pointer to the member */
+               void **memb_ptr2;       /* Pointer to that pointer */
+
+               if(IN_EXTENSION_GROUP(specs, edx))
+                       continue;
+
+               /* Fetch the pointer to this member */
+               if(elm->flags & ATF_POINTER) {
+                       memb_ptr2 = (void **)((char *)st + elm->memb_offset);
+               } else {
+                       memb_ptr = (char *)st + elm->memb_offset;
+                       memb_ptr2 = &memb_ptr;
+               }
+
+               /* Deal with optionality */
+               if(elm->optional) {
+                       int present = per_get_few_bits(&opmd, 1);
+                       ASN_DEBUG("Member %s->%s is optional, p=%d (%d->%d)",
+                               td->name, elm->name, present,
+                               (int)opmd.nboff, (int)opmd.nbits);
+                       if(present == 0) {
+                               /* This element is not present */
+                               if(elm->default_value) {
+                                       /* Fill-in DEFAULT */
+                                       if(elm->default_value(1, memb_ptr2)) {
+                                               FREEMEM(opres);
+                                               _ASN_DECODE_FAILED;
+                                       }
+                                       ASN_DEBUG("Filled-in default");
+                               }
+                               /* The member is just not present */
+                               continue;
+                       }
+                       /* Fall through */
+               }
+
+               /* Fetch the member from the stream */
+               ASN_DEBUG("Decoding member %s in %s", elm->name, td->name);
+               rv = elm->type->uper_decoder(opt_codec_ctx, elm->type,
+                       elm->per_constraints, memb_ptr2, pd);
+               if(rv.code != RC_OK) {
+                       ASN_DEBUG("Failed decode %s in %s",
+                               elm->name, td->name);
+                       FREEMEM(opres);
+                       return rv;
+               }
+       }
+
+       /* Optionality map is not needed anymore */
+       FREEMEM(opres);
+
+       /*
+        * Deal with extensions.
+        */
+       if(extpresent) {
+               ssize_t bmlength;
+               uint8_t *epres;         /* Presence of extension members */
+               asn_per_data_t epmd;
+
+               bmlength = uper_get_nslength(pd);
+               if(bmlength < 0) _ASN_DECODE_STARVED;
+
+          &n