]> git.stg.codes - stg.git/commitdiff
Regen SMUX support library with more recent ASN1 compiler.
authorMaksym Mamontov <madf@madf.info>
Sun, 28 Aug 2022 15:02:04 +0000 (18:02 +0300)
committerMaksym Mamontov <madf@madf.info>
Sun, 28 Aug 2022 15:02:04 +0000 (18:02 +0300)
161 files changed:
libs/smux/ANY.c
libs/smux/ApplicationSyntax.c
libs/smux/AtEntry.c
libs/smux/BIT_STRING.c
libs/smux/BIT_STRING_oer.c [new file with mode: 0644]
libs/smux/BOOLEAN.c [deleted file]
libs/smux/ClosePDU.c
libs/smux/Counter.c
libs/smux/DisplayString.c
libs/smux/EgpNeighEntry.c
libs/smux/Gauge.c
libs/smux/GetNextRequest-PDU.c
libs/smux/GetRequest-PDU.c
libs/smux/GetResponse-PDU.c
libs/smux/INTEGER.c
libs/smux/INTEGER_oer.c [new file with mode: 0644]
libs/smux/IfEntry.c
libs/smux/IpAddrEntry.c
libs/smux/IpAddress.c
libs/smux/IpNetToMediaEntry.c
libs/smux/IpRouteEntry.c
libs/smux/Message.c
libs/smux/NULL.c
libs/smux/NativeEnumerated.c [deleted file]
libs/smux/NativeInteger.c
libs/smux/NativeInteger_oer.c [new file with mode: 0644]
libs/smux/NetworkAddress.c
libs/smux/OBJECT_IDENTIFIER.c
libs/smux/OCTET_STRING.c
libs/smux/OCTET_STRING_oer.c [new file with mode: 0644]
libs/smux/OPEN_TYPE.c [new file with mode: 0644]
libs/smux/OPEN_TYPE_oer.c [new file with mode: 0644]
libs/smux/ObjectName.c
libs/smux/ObjectSyntax.c
libs/smux/Opaque.c
libs/smux/OpenPDU.c
libs/smux/PDU.c
libs/smux/PDUs.c
libs/smux/PhysAddress.c
libs/smux/RReqPDU.c
libs/smux/RRspPDU.c
libs/smux/SMUX-PDUs.c
libs/smux/SOutPDU.c
libs/smux/SetRequest-PDU.c
libs/smux/SimpleOpen.c
libs/smux/SimpleSyntax.c
libs/smux/TcpConnEntry.c
libs/smux/TimeTicks.c
libs/smux/Trap-PDU.c
libs/smux/UdpEntry.c
libs/smux/VarBind.c
libs/smux/VarBindList.c
libs/smux/asn_application.c [new file with mode: 0644]
libs/smux/asn_bit_data.c [new file with mode: 0644]
libs/smux/asn_codecs_prim.c
libs/smux/asn_internal.c [new file with mode: 0644]
libs/smux/asn_random_fill.c [new file with mode: 0644]
libs/smux/ber_decoder.c
libs/smux/ber_tlv_length.c
libs/smux/ber_tlv_tag.c
libs/smux/constr_CHOICE.c
libs/smux/constr_CHOICE_oer.c [new file with mode: 0644]
libs/smux/constr_SEQUENCE.c
libs/smux/constr_SEQUENCE_OF.c
libs/smux/constr_SEQUENCE_oer.c [new file with mode: 0644]
libs/smux/constr_SET_OF.c
libs/smux/constr_SET_OF_oer.c [new file with mode: 0644]
libs/smux/constr_TYPE.c
libs/smux/constraints.c
libs/smux/der_encoder.c
libs/smux/include/stg/ANY.h
libs/smux/include/stg/ApplicationSyntax.h
libs/smux/include/stg/AtEntry.h
libs/smux/include/stg/BIT_STRING.h
libs/smux/include/stg/BOOLEAN.h [deleted file]
libs/smux/include/stg/ClosePDU.h
libs/smux/include/stg/Counter.h
libs/smux/include/stg/DisplayString.h
libs/smux/include/stg/EgpNeighEntry.h
libs/smux/include/stg/Gauge.h
libs/smux/include/stg/GetNextRequest-PDU.h
libs/smux/include/stg/GetRequest-PDU.h
libs/smux/include/stg/GetResponse-PDU.h
libs/smux/include/stg/INTEGER.h
libs/smux/include/stg/IfEntry.h
libs/smux/include/stg/IpAddrEntry.h
libs/smux/include/stg/IpAddress.h
libs/smux/include/stg/IpNetToMediaEntry.h
libs/smux/include/stg/IpRouteEntry.h
libs/smux/include/stg/Message.h
libs/smux/include/stg/NULL.h
libs/smux/include/stg/NativeEnumerated.h [deleted file]
libs/smux/include/stg/NativeInteger.h
libs/smux/include/stg/NetworkAddress.h
libs/smux/include/stg/OBJECT_IDENTIFIER.h
libs/smux/include/stg/OCTET_STRING.h
libs/smux/include/stg/OPEN_TYPE.h [new file with mode: 0644]
libs/smux/include/stg/ObjectName.h
libs/smux/include/stg/ObjectSyntax.h
libs/smux/include/stg/Opaque.h
libs/smux/include/stg/OpenPDU.h
libs/smux/include/stg/PDU.h
libs/smux/include/stg/PDUs.h
libs/smux/include/stg/PhysAddress.h
libs/smux/include/stg/RReqPDU.h
libs/smux/include/stg/RRspPDU.h
libs/smux/include/stg/SMUX-PDUs.h
libs/smux/include/stg/SOutPDU.h
libs/smux/include/stg/SetRequest-PDU.h
libs/smux/include/stg/SimpleOpen.h
libs/smux/include/stg/SimpleSyntax.h
libs/smux/include/stg/TcpConnEntry.h
libs/smux/include/stg/TimeTicks.h
libs/smux/include/stg/Trap-PDU.h
libs/smux/include/stg/UdpEntry.h
libs/smux/include/stg/VarBind.h
libs/smux/include/stg/VarBindList.h
libs/smux/include/stg/asn_SEQUENCE_OF.h
libs/smux/include/stg/asn_SET_OF.h
libs/smux/include/stg/asn_application.h
libs/smux/include/stg/asn_bit_data.h [new file with mode: 0644]
libs/smux/include/stg/asn_codecs.h
libs/smux/include/stg/asn_codecs_prim.h
libs/smux/include/stg/asn_internal.h
libs/smux/include/stg/asn_ioc.h [new file with mode: 0644]
libs/smux/include/stg/asn_random_fill.h [new file with mode: 0644]
libs/smux/include/stg/asn_system.h
libs/smux/include/stg/ber_decoder.h
libs/smux/include/stg/ber_tlv_length.h
libs/smux/include/stg/ber_tlv_tag.h
libs/smux/include/stg/constr_CHOICE.h
libs/smux/include/stg/constr_SEQUENCE.h
libs/smux/include/stg/constr_SEQUENCE_OF.h
libs/smux/include/stg/constr_SET_OF.h
libs/smux/include/stg/constr_TYPE.h
libs/smux/include/stg/constraints.h
libs/smux/include/stg/der_encoder.h
libs/smux/include/stg/oer_decoder.h [new file with mode: 0644]
libs/smux/include/stg/oer_encoder.h [new file with mode: 0644]
libs/smux/include/stg/oer_support.h [new file with mode: 0644]
libs/smux/include/stg/per_decoder.h
libs/smux/include/stg/per_encoder.h
libs/smux/include/stg/per_opentype.h
libs/smux/include/stg/per_support.h
libs/smux/include/stg/xer_decoder.h
libs/smux/include/stg/xer_encoder.h
libs/smux/include/stg/xer_support.h
libs/smux/oer_decoder.c [new file with mode: 0644]
libs/smux/oer_encoder.c [new file with mode: 0644]
libs/smux/oer_support.c [new file with mode: 0644]
libs/smux/pdu_collection.c [new file with mode: 0644]
libs/smux/per_decoder.c
libs/smux/per_encoder.c
libs/smux/per_opentype.c
libs/smux/per_support.c
libs/smux/regen.sh
libs/smux/xer_decoder.c
libs/smux/xer_encoder.c
projects/stargazer/plugins/other/smux/types.cpp
projects/stargazer/plugins/other/smux/types.h
projects/stargazer/plugins/other/smux/utils.cpp

index 77024bdcf3c9229fa4cc94428fc0042ef4c59989..6bd5e67a586b3e728c8d1a2c68c1e8f24bd206f9 100644 (file)
@@ -1,41 +1,64 @@
-/*-
- * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+/*
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_internal.h>
 #include <ANY.h>
 #include <errno.h>
 
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_internal.h>
 #include <ANY.h>
 #include <errno.h>
 
-static asn_OCTET_STRING_specifics_t asn_DEF_ANY_specs = {
+asn_OCTET_STRING_specifics_t asn_SPC_ANY_specs = {
        sizeof(ANY_t),
        offsetof(ANY_t, _asn_ctx),
        ASN_OSUBV_ANY
 };
        sizeof(ANY_t),
        offsetof(ANY_t, _asn_ctx),
        ASN_OSUBV_ANY
 };
-asn_TYPE_descriptor_t asn_DEF_ANY = {
-       "ANY",
-       "ANY",
+asn_TYPE_operation_t asn_OP_ANY = {
        OCTET_STRING_free,
        OCTET_STRING_print,
        OCTET_STRING_free,
        OCTET_STRING_print,
-       asn_generic_no_constraint,
+       OCTET_STRING_compare,
        OCTET_STRING_decode_ber,
        OCTET_STRING_encode_der,
        OCTET_STRING_decode_xer_hex,
        ANY_encode_xer,
        OCTET_STRING_decode_ber,
        OCTET_STRING_encode_der,
        OCTET_STRING_decode_xer_hex,
        ANY_encode_xer,
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       0,
+       0,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
        0, 0,
        0, 0,
-       0, /* Use generic outmost tag fetcher */
+#else
+       ANY_decode_uper,
+       ANY_encode_uper,
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+       0,      /* Random fill is not defined for ANY type */
+       0       /* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_ANY = {
+       "ANY",
+       "ANY",
+       &asn_OP_ANY,
        0, 0, 0, 0,
        0, 0, 0, 0,
-       0,      /* No PER visible constraints */
+       { 0, 0, asn_generic_no_constraint },    /* No constraints */
        0, 0,   /* No members */
        0, 0,   /* No members */
-       &asn_DEF_ANY_specs,
+       &asn_SPC_ANY_specs,
 };
 
 };
 
+#undef RETURN
+#define RETURN(_code)                       \
+    do {                                    \
+        asn_dec_rval_t tmprval;             \
+        tmprval.code = _code;               \
+        tmprval.consumed = consumed_myself; \
+        return tmprval;                     \
+    } while(0)
 
 asn_enc_rval_t
 
 asn_enc_rval_t
-ANY_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) {
-
-       if(flags & XER_F_CANONICAL) {
+ANY_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+               enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
+               void *app_key) {
+    if(flags & XER_F_CANONICAL) {
                /*
                 * Canonical XER-encoding of ANY type is not supported.
                 */
                /*
                 * Canonical XER-encoding of ANY type is not supported.
                 */
@@ -156,3 +179,99 @@ static int ANY__consume_bytes(const void *buffer, size_t size, void *key) {
        return 0;
 }
 
        return 0;
 }
 
+#ifndef ASN_DISABLE_PER_SUPPORT
+
+asn_dec_rval_t
+ANY_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                const asn_TYPE_descriptor_t *td,
+                const asn_per_constraints_t *constraints, void **sptr,
+                asn_per_data_t *pd) {
+    const asn_OCTET_STRING_specifics_t *specs =
+        td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                      : &asn_SPC_ANY_specs;
+    size_t consumed_myself = 0;
+    int repeat;
+    ANY_t *st = (ANY_t *)*sptr;
+
+    (void)opt_codec_ctx;
+    (void)constraints;
+
+    /*
+     * Allocate the structure.
+     */
+    if(!st) {
+        st = (ANY_t *)(*sptr = CALLOC(1, specs->struct_size));
+        if(!st) RETURN(RC_FAIL);
+    }
+
+    ASN_DEBUG("PER Decoding ANY type");
+
+
+    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, -1, 0, &repeat);
+        if(raw_len < 0) RETURN(RC_WMORE);
+        if(raw_len == 0 && st->buf) break;
+
+        ASN_DEBUG("Got PER length len %" ASN_PRI_SIZE ", %s (%s)", raw_len,
+                  repeat ? "repeat" : "once", td->name);
+        len_bytes = raw_len;
+        len_bits = len_bytes * 8;
+
+        p = REALLOC(st->buf, st->size + len_bytes + 1);
+        if(!p) RETURN(RC_FAIL);
+        st->buf = (uint8_t *)p;
+
+        ret = per_get_many_bits(pd, &st->buf[st->size], 0, len_bits);
+        if(ret < 0) RETURN(RC_WMORE);
+        consumed_myself += len_bits;
+        st->size += len_bytes;
+    } while(repeat);
+    st->buf[st->size] = 0; /* nul-terminate */
+
+    RETURN(RC_OK);
+}
+
+asn_enc_rval_t
+ANY_encode_uper(const asn_TYPE_descriptor_t *td,
+                const asn_per_constraints_t *constraints, const void *sptr,
+                asn_per_outp_t *po) {
+    const ANY_t *st = (const ANY_t *)sptr;
+    asn_enc_rval_t er = {0, 0, 0};
+    const uint8_t *buf;
+    size_t size;
+    int ret;
+
+    (void)constraints;
+
+    if(!st || (!st->buf && st->size)) ASN__ENCODE_FAILED;
+
+    buf = st->buf;
+    size = st->size;
+    do {
+        int need_eom = 0;
+        ssize_t may_save = uper_put_length(po, size, &need_eom);
+        if(may_save < 0) ASN__ENCODE_FAILED;
+
+        ret = per_put_many_bits(po, buf, may_save * 8);
+        if(ret) ASN__ENCODE_FAILED;
+
+        buf += may_save;
+        size -= may_save;
+        assert(!(may_save & 0x07) || !size);
+        if(need_eom && uper_put_length(po, 0, 0))
+            ASN__ENCODE_FAILED; /* End of Message length */
+    } while(size);
+
+    ASN__ENCODED_OK(er);
+}
+
+#endif /* ASN_DISABLE_PER_SUPPORT */
+
index 163bae33ca3ea60d18e29598e874897293ae5a16..a9a9637ea767e81d903b9fd543325f5b808ce7c0 100644 (file)
@@ -1,56 +1,64 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "ApplicationSyntax.h"
 
  */
 
 #include "ApplicationSyntax.h"
 
-static asn_TYPE_member_t asn_MBR_ApplicationSyntax_1[] = {
+static asn_oer_constraints_t asn_OER_type_ApplicationSyntax_constr_1 CC_NOTUSED = {
+       { 0, 0 },
+       -1};
+asn_per_constraints_t asn_PER_type_ApplicationSyntax_constr_1 CC_NOTUSED = {
+       { APC_CONSTRAINED,       3,  3,  0,  4 }        /* (0..4) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_ApplicationSyntax_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.address),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_NetworkAddress,
        { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.address),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_NetworkAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "address"
                },
        { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.counter),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "address"
                },
        { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.counter),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "counter"
                },
        { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.gauge),
                (ASN_TAG_CLASS_APPLICATION | (2 << 2)),
                0,
                &asn_DEF_Gauge,
                "counter"
                },
        { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.gauge),
                (ASN_TAG_CLASS_APPLICATION | (2 << 2)),
                0,
                &asn_DEF_Gauge,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "gauge"
                },
        { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.ticks),
                (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
                0,
                &asn_DEF_TimeTicks,
                "gauge"
                },
        { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.ticks),
                (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
                0,
                &asn_DEF_TimeTicks,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ticks"
                },
        { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.arbitrary),
                (ASN_TAG_CLASS_APPLICATION | (4 << 2)),
                0,
                &asn_DEF_Opaque,
                "ticks"
                },
        { ATF_NOFLAGS, 0, offsetof(struct ApplicationSyntax, choice.arbitrary),
                (ASN_TAG_CLASS_APPLICATION | (4 << 2)),
                0,
                &asn_DEF_Opaque,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "arbitrary"
                },
 };
                "arbitrary"
                },
 };
@@ -61,33 +69,25 @@ static const asn_TYPE_tag2member_t asn_MAP_ApplicationSyntax_tag2el_1[] = {
     { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 3, 0, 0 }, /* ticks */
     { (ASN_TAG_CLASS_APPLICATION | (4 << 2)), 4, 0, 0 } /* arbitrary */
 };
     { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 3, 0, 0 }, /* ticks */
     { (ASN_TAG_CLASS_APPLICATION | (4 << 2)), 4, 0, 0 } /* arbitrary */
 };
-static asn_CHOICE_specifics_t asn_SPC_ApplicationSyntax_specs_1 = {
+asn_CHOICE_specifics_t asn_SPC_ApplicationSyntax_specs_1 = {
        sizeof(struct ApplicationSyntax),
        offsetof(struct ApplicationSyntax, _asn_ctx),
        offsetof(struct ApplicationSyntax, present),
        sizeof(((struct ApplicationSyntax *)0)->present),
        asn_MAP_ApplicationSyntax_tag2el_1,
        5,      /* Count of tags in the map */
        sizeof(struct ApplicationSyntax),
        offsetof(struct ApplicationSyntax, _asn_ctx),
        offsetof(struct ApplicationSyntax, present),
        sizeof(((struct ApplicationSyntax *)0)->present),
        asn_MAP_ApplicationSyntax_tag2el_1,
        5,      /* Count of tags in the map */
-       0,
+       0, 0,
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_ApplicationSyntax = {
        "ApplicationSyntax",
        "ApplicationSyntax",
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_ApplicationSyntax = {
        "ApplicationSyntax",
        "ApplicationSyntax",
-       CHOICE_free,
-       CHOICE_print,
-       CHOICE_constraint,
-       CHOICE_decode_ber,
-       CHOICE_encode_der,
-       CHOICE_decode_xer,
-       CHOICE_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       CHOICE_outmost_tag,
+       &asn_OP_CHOICE,
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_ApplicationSyntax_constr_1, &asn_PER_type_ApplicationSyntax_constr_1, CHOICE_constraint },
        asn_MBR_ApplicationSyntax_1,
        5,      /* Elements count */
        &asn_SPC_ApplicationSyntax_specs_1      /* Additional specs */
        asn_MBR_ApplicationSyntax_1,
        5,      /* Elements count */
        &asn_SPC_ApplicationSyntax_specs_1      /* Additional specs */
index 035ea40a7b625f6bd1a92a6be5d276c5a285aa59..0e815d39a7e72c9770ec85fec87aa25a9072538d 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "AtEntry.h"
  */
 
 #include "AtEntry.h"
@@ -12,27 +12,27 @@ static asn_TYPE_member_t asn_MBR_AtEntry_1[] = {
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "atIfIndex"
                },
        { ATF_NOFLAGS, 0, offsetof(struct AtEntry, atPhysAddress),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_PhysAddress,
                "atIfIndex"
                },
        { ATF_NOFLAGS, 0, offsetof(struct AtEntry, atPhysAddress),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_PhysAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "atPhysAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct AtEntry, atNetAddress),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_NetworkAddress,
                "atPhysAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct AtEntry, atNetAddress),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_NetworkAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "atNetAddress"
                },
 };
                "atNetAddress"
                },
 };
@@ -50,28 +50,19 @@ static asn_SEQUENCE_specifics_t asn_SPC_AtEntry_specs_1 = {
        asn_MAP_AtEntry_tag2el_1,
        3,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        asn_MAP_AtEntry_tag2el_1,
        3,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_AtEntry = {
        "AtEntry",
        "AtEntry",
 };
 asn_TYPE_descriptor_t asn_DEF_AtEntry = {
        "AtEntry",
        "AtEntry",
-       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_OP_SEQUENCE,
        asn_DEF_AtEntry_tags_1,
        sizeof(asn_DEF_AtEntry_tags_1)
                /sizeof(asn_DEF_AtEntry_tags_1[0]), /* 1 */
        asn_DEF_AtEntry_tags_1, /* Same as above */
        sizeof(asn_DEF_AtEntry_tags_1)
                /sizeof(asn_DEF_AtEntry_tags_1[0]), /* 1 */
        asn_DEF_AtEntry_tags_1,
        sizeof(asn_DEF_AtEntry_tags_1)
                /sizeof(asn_DEF_AtEntry_tags_1[0]), /* 1 */
        asn_DEF_AtEntry_tags_1, /* Same as above */
        sizeof(asn_DEF_AtEntry_tags_1)
                /sizeof(asn_DEF_AtEntry_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_AtEntry_1,
        3,      /* Elements count */
        &asn_SPC_AtEntry_specs_1        /* Additional specs */
        asn_MBR_AtEntry_1,
        3,      /* Elements count */
        &asn_SPC_AtEntry_specs_1        /* Additional specs */
index 997ff41619e35b6632bcbd27a44ae50684bc433c..0cff7706fae77685701ace324df8e68445195da8 100644 (file)
 static const ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
 };
 static const 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 = {
+asn_OCTET_STRING_specifics_t asn_SPC_BIT_STRING_specs = {
        sizeof(BIT_STRING_t),
        offsetof(BIT_STRING_t, _asn_ctx),
        ASN_OSUBV_BIT
 };
        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",
+asn_TYPE_operation_t asn_OP_BIT_STRING = {
        OCTET_STRING_free,         /* Implemented in terms of OCTET STRING */
        BIT_STRING_print,
        OCTET_STRING_free,         /* Implemented in terms of OCTET STRING */
        BIT_STRING_print,
-       BIT_STRING_constraint,
+       BIT_STRING_compare,
        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_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 */
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       BIT_STRING_decode_oer,
+       BIT_STRING_encode_oer,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
+       BIT_STRING_decode_uper, /* Unaligned PER decoder */
+       BIT_STRING_encode_uper, /* Unaligned PER encoder */
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+       BIT_STRING_random_fill,
+       0       /* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
+       "BIT STRING",
+       "BIT_STRING",
+       &asn_OP_BIT_STRING,
        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]),
        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, BIT_STRING_constraint },
        0, 0,   /* No members */
        0, 0,   /* No members */
-       &asn_DEF_BIT_STRING_specs
+       &asn_SPC_BIT_STRING_specs
 };
 
 /*
  * BIT STRING generic constraint.
  */
 int
 };
 
 /*
  * 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;
+BIT_STRING_constraint(const 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)
 
        if(st && st->buf) {
                if((st->size == 0 && st->bits_unused)
@@ -67,16 +83,16 @@ BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
        return 0;
 }
 
        return 0;
 }
 
-static char *_bit_pattern[16] = {
+static const char *_bit_pattern[16] = {
        "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
        "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
 };
 
 asn_enc_rval_t
        "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;
+BIT_STRING_encode_xer(const asn_TYPE_descriptor_t *td, const 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);
        char scratch[128];
        char *p = scratch;
        char *scend = scratch + (sizeof(scratch) - 10);
@@ -100,7 +116,6 @@ BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
                int v = *buf;
                int nline = xcan?0:(((buf - st->buf) % 8) == 0);
                if(p >= scend || nline) {
                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) ASN__TEXT_INDENT(1, ilevel);
                        ASN__CALLBACK(scratch, p - scratch);
                        p = scratch;
                        if(nline) ASN__TEXT_INDENT(1, ilevel);
@@ -112,7 +127,6 @@ BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 
        if(!xcan && ((buf - st->buf) % 8) == 0)
                ASN__TEXT_INDENT(1, ilevel);
 
        if(!xcan && ((buf - st->buf) % 8) == 0)
                ASN__TEXT_INDENT(1, ilevel);
-       er.encoded += p - scratch;
        ASN__CALLBACK(scratch, p - scratch);
        p = scratch;
 
        ASN__CALLBACK(scratch, p - scratch);
        p = scratch;
 
@@ -122,7 +136,6 @@ BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
                int i;
                for(i = 7; i >= ubits; i--)
                        *p++ = (v & (1 << i)) ? 0x31 : 0x30;
                int i;
                for(i = 7; i >= ubits; i--)
                        *p++ = (v & (1 << i)) ? 0x31 : 0x30;
-               er.encoded += p - scratch;
                ASN__CALLBACK(scratch, p - scratch);
        }
 
                ASN__CALLBACK(scratch, p - scratch);
        }
 
@@ -138,9 +151,9 @@ cb_failed:
  * BIT STRING specific contents printer.
  */
 int
  * 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) {
-       const char * const h2c = "0123456789ABCDEF";
+BIT_STRING_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+                 asn_app_consume_bytes_f *cb, void *app_key) {
+    const char * const h2c = "0123456789ABCDEF";
        char scratch[64];
        const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
        uint8_t *buf;
        char scratch[64];
        const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
        uint8_t *buf;
@@ -184,6 +197,456 @@ BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
                        return -1;
        }
 
                        return -1;
        }
 
+    if(st->bits_unused) {
+        int ret = snprintf(scratch, sizeof(scratch), " (%d bit%s unused)",
+                           st->bits_unused, st->bits_unused == 1 ? "" : "s");
+        assert(ret > 0 && ret < (ssize_t)sizeof(scratch));
+        if(ret > 0 && ret < (ssize_t)sizeof(scratch)
+           && cb(scratch, ret, app_key) < 0)
+            return -1;
+    }
+
        return 0;
 }
 
        return 0;
 }
 
+/*
+ * Non-destructively remove the trailing 0-bits from the given bit string.
+ */
+static const BIT_STRING_t *
+BIT_STRING__compactify(const BIT_STRING_t *st, BIT_STRING_t *tmp) {
+    const uint8_t *b;
+    union {
+        const uint8_t *c_buf;
+        uint8_t *nc_buf;
+    } unconst;
+
+    if(st->size == 0) {
+        assert(st->bits_unused == 0);
+        return st;
+    } else {
+        for(b = &st->buf[st->size - 1]; b > st->buf && *b == 0; b--) {
+            ;
+        }
+        /* b points to the last byte which may contain data */
+        if(*b) {
+            int unused = 7;
+            uint8_t v = *b;
+            v &= -(int8_t)v;
+            if(v & 0x0F) unused -= 4;
+            if(v & 0x33) unused -= 2;
+            if(v & 0x55) unused -= 1;
+            tmp->size = b-st->buf + 1;
+            tmp->bits_unused = unused;
+        } else {
+            tmp->size = b-st->buf;
+            tmp->bits_unused = 0;
+        }
+
+        assert(b >= st->buf);
+    }
+
+    unconst.c_buf = st->buf;
+    tmp->buf = unconst.nc_buf;
+    return tmp;
+}
+
+/*
+ * Lexicographically compare the common prefix of both strings,
+ * and if it is the same return -1 for the smallest string.
+ */
+int
+BIT_STRING_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
+                   const void *bptr) {
+    /*
+     * Remove information about trailing bits, since
+     * X.680 (08/2015) #22.7 "ensure that different semantics are not"
+     * "associated with [values that differ only in] the trailing 0 bits."
+     */
+    BIT_STRING_t compact_a, compact_b;
+    const BIT_STRING_t *a = BIT_STRING__compactify(aptr, &compact_a);
+    const BIT_STRING_t *b = BIT_STRING__compactify(bptr, &compact_b);
+    const asn_OCTET_STRING_specifics_t *specs = td->specifics;
+
+    assert(specs && specs->subvariant == ASN_OSUBV_BIT);
+
+    if(a && b) {
+        size_t common_prefix_size = a->size <= b->size ? a->size : b->size;
+        int ret = memcmp(a->buf, b->buf, common_prefix_size);
+        if(ret == 0) {
+            /* Figure out which string with equal prefixes is longer. */
+            if(a->size < b->size) {
+                return -1;
+            } else if(a->size > b->size) {
+                return 1;
+            } else {
+                /* Figure out how many unused bits */
+                if(a->bits_unused > b->bits_unused) {
+                    return -1;
+                } else if(a->bits_unused < b->bits_unused) {
+                    return 1;
+                } else {
+                    return 0;
+                }
+            }
+        } else {
+            return ret;
+        }
+    } else if(!a && !b) {
+        return 0;
+    } else if(!a) {
+        return -1;
+    } else {
+        return 1;
+    }
+}
+
+#ifndef  ASN_DISABLE_PER_SUPPORT
+
+#undef  RETURN
+#define RETURN(_code)                       \
+    do {                                    \
+        asn_dec_rval_t tmprval;             \
+        tmprval.code = _code;               \
+        tmprval.consumed = consumed_myself; \
+        return tmprval;                     \
+    } while(0)
+
+static asn_per_constraint_t asn_DEF_BIT_STRING_constraint_size = {
+    APC_SEMI_CONSTRAINED, -1, -1, 0, 0};
+
+asn_dec_rval_t
+BIT_STRING_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                       const asn_TYPE_descriptor_t *td,
+                       const asn_per_constraints_t *constraints, void **sptr,
+                       asn_per_data_t *pd) {
+    const asn_OCTET_STRING_specifics_t *specs = td->specifics
+               ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+               : &asn_SPC_BIT_STRING_specs;
+    const asn_per_constraints_t *pc =
+        constraints ? constraints : td->encoding_constraints.per_constraints;
+       const 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;
+
+       (void)opt_codec_ctx;
+
+       if(pc) {
+               csiz = &pc->size;
+       } else {
+               csiz = &asn_DEF_BIT_STRING_constraint_size;
+       }
+
+       if(specs->subvariant != ASN_OSUBV_BIT) {
+               ASN_DEBUG("Subvariant %d is not BIT OSUBV_BIT", specs->subvariant);
+               RETURN(RC_FAIL);
+    }
+
+       /*
+        * 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_BIT_STRING_constraint_size;
+               }
+       }
+
+       if(csiz->effective_bits >= 0) {
+               FREEMEM(st->buf);
+        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;
+        ASN_DEBUG("Encoding BIT STRING size %ld", csiz->upper_bound);
+        ret = per_get_many_bits(pd, st->buf, 0, csiz->upper_bound);
+               if(ret < 0) RETURN(RC_WMORE);
+               consumed_myself += csiz->upper_bound;
+               st->buf[st->size] = 0;
+        st->bits_unused = (8 - (csiz->upper_bound & 0x7)) & 0x7;
+        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, csiz->lower_bound,
+                                         &repeat);
+               if(raw_len < 0) RETURN(RC_WMORE);
+        if(raw_len == 0 && st->buf) break;
+
+               ASN_DEBUG("Got PER length eb %ld, len %ld, %s (%s)",
+                       (long)csiz->effective_bits, (long)raw_len,
+                       repeat ? "repeat" : "once", td->name);
+        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;
+
+        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
+BIT_STRING_encode_uper(const asn_TYPE_descriptor_t *td,
+                       const asn_per_constraints_t *constraints,
+                       const void *sptr, asn_per_outp_t *po) {
+    const asn_OCTET_STRING_specifics_t *specs =
+        td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                      : &asn_SPC_BIT_STRING_specs;
+    const asn_per_constraints_t *pc =
+        constraints ? constraints : td->encoding_constraints.per_constraints;
+       const asn_per_constraint_t *csiz;
+       const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+       BIT_STRING_t compact_bstr;  /* Do not modify this directly! */
+       asn_enc_rval_t er = { 0, 0, 0 };
+       int inext = 0;          /* Lies not within extension root */
+       size_t size_in_bits;
+       const uint8_t *buf;
+       int ret;
+       int ct_extensible;
+
+       if(!st || (!st->buf && st->size))
+               ASN__ENCODE_FAILED;
+
+       if(specs->subvariant == ASN_OSUBV_BIT) {
+        if((st->size == 0 && st->bits_unused) || (st->bits_unused & ~7))
+            ASN__ENCODE_FAILED;
+    } else {
+               ASN__ENCODE_FAILED;
+    }
+
+       if(pc) {
+        csiz = &pc->size;
+    } else {
+               csiz = &asn_DEF_BIT_STRING_constraint_size;
+       }
+       ct_extensible = csiz->flags & APC_EXTENSIBLE;
+
+    /* Figure out the size without the trailing bits */
+    st = BIT_STRING__compactify(st, &compact_bstr);
+    size_in_bits = 8 * st->size - st->bits_unused;
+
+    ASN_DEBUG(
+        "Encoding %s into %" ASN_PRI_SIZE " bits"
+        " (%ld..%ld, effective %d)%s",
+        td->name, size_in_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((ssize_t)size_in_bits > csiz->upper_bound) {
+            if(ct_extensible) {
+                csiz = &asn_DEF_BIT_STRING_constraint_size;
+                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;
+       }
+
+    if(csiz->effective_bits >= 0 && !inext) {
+        int add_trailer = (ssize_t)size_in_bits < csiz->lower_bound;
+        ASN_DEBUG(
+            "Encoding %" ASN_PRI_SIZE " bytes (%ld), length (in %d bits) trailer %d; actual "
+            "value %" ASN_PRI_SSIZE "",
+            st->size, size_in_bits - csiz->lower_bound, csiz->effective_bits,
+            add_trailer,
+            add_trailer ? 0 : (ssize_t)size_in_bits - csiz->lower_bound);
+        ret = per_put_few_bits(
+            po, add_trailer ? 0 : (ssize_t)size_in_bits - csiz->lower_bound,
+            csiz->effective_bits);
+        if(ret) ASN__ENCODE_FAILED;
+        ret = per_put_many_bits(po, st->buf, size_in_bits);
+        if(ret) ASN__ENCODE_FAILED;
+        if(add_trailer) {
+            static const uint8_t zeros[16];
+            size_t trailing_zero_bits = csiz->lower_bound - size_in_bits;
+            while(trailing_zero_bits > 0) {
+                if(trailing_zero_bits > 8 * sizeof(zeros)) {
+                    ret = per_put_many_bits(po, zeros, 8 * sizeof(zeros));
+                    trailing_zero_bits -= 8 * sizeof(zeros);
+                } else {
+                    ret = per_put_many_bits(po, zeros, trailing_zero_bits);
+                    trailing_zero_bits = 0;
+                }
+                if(ret) ASN__ENCODE_FAILED;
+            }
+        }
+        ASN__ENCODED_OK(er);
+    }
+
+    ASN_DEBUG("Encoding %" ASN_PRI_SIZE " bytes", st->size);
+
+    buf = st->buf;
+    do {
+        int need_eom = 0;
+        ssize_t maySave = uper_put_length(po, size_in_bits, &need_eom);
+        if(maySave < 0) ASN__ENCODE_FAILED;
+
+        ASN_DEBUG("Encoding %" ASN_PRI_SSIZE " of %" ASN_PRI_SIZE "", maySave, size_in_bits);
+
+        ret = per_put_many_bits(po, buf, maySave);
+        if(ret) ASN__ENCODE_FAILED;
+
+        buf += maySave >> 3;
+        size_in_bits -= maySave;
+        assert(!(maySave & 0x07) || !size_in_bits);
+        if(need_eom && uper_put_length(po, 0, 0))
+            ASN__ENCODE_FAILED; /* End of Message length */
+    } while(size_in_bits);
+
+    ASN__ENCODED_OK(er);
+}
+
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
+asn_random_fill_result_t
+BIT_STRING_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                       const asn_encoding_constraints_t *constraints,
+                       size_t max_length) {
+    const asn_OCTET_STRING_specifics_t *specs =
+        td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                      : &asn_SPC_BIT_STRING_specs;
+    asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    static unsigned lengths[] = {0,     1,     2,     3,     4,     8,
+                                 126,   127,   128,   16383, 16384, 16385,
+                                 65534, 65535, 65536, 65537};
+    uint8_t *buf;
+    uint8_t *bend;
+    uint8_t *b;
+    size_t rnd_bits, rnd_len;
+    BIT_STRING_t *st;
+
+    if(max_length == 0) return result_skipped;
+
+    switch(specs->subvariant) {
+    case ASN_OSUBV_ANY:
+        return result_failed;
+    case ASN_OSUBV_BIT:
+        break;
+    default:
+        break;
+    }
+
+    /* Figure out how far we should go */
+    rnd_bits = lengths[asn_random_between(
+        0, sizeof(lengths) / sizeof(lengths[0]) - 1)];
+    if(!constraints || !constraints->per_constraints)
+        constraints = &td->encoding_constraints;
+    if(constraints->per_constraints) {
+        const asn_per_constraint_t *pc = &constraints->per_constraints->size;
+        if(pc->flags & APC_CONSTRAINED) {
+            long suggested_upper_bound = pc->upper_bound < (ssize_t)max_length
+                                             ? pc->upper_bound
+                                             : (ssize_t)max_length;
+            if(max_length < (size_t)pc->lower_bound) {
+                return result_skipped;
+            }
+            if(pc->flags & APC_EXTENSIBLE) {
+                switch(asn_random_between(0, 5)) {
+                case 0:
+                    if(pc->lower_bound > 0) {
+                        rnd_bits = pc->lower_bound - 1;
+                        break;
+                    }
+                    /* Fall through */
+                case 1:
+                    rnd_bits = pc->upper_bound + 1;
+                    break;
+                case 2:
+                    /* Keep rnd_bits from the table */
+                    if(rnd_bits < max_length) {
+                        break;
+                    }
+                    /* Fall through */
+                default:
+                    rnd_bits = asn_random_between(pc->lower_bound,
+                                                  suggested_upper_bound);
+                }
+            } else {
+                rnd_bits =
+                    asn_random_between(pc->lower_bound, suggested_upper_bound);
+            }
+        } else {
+            rnd_bits = asn_random_between(0, max_length - 1);
+        }
+    } else if(rnd_bits >= max_length) {
+        rnd_bits = asn_random_between(0, max_length - 1);
+    }
+
+    rnd_len = (rnd_bits + 7) / 8;
+    buf = CALLOC(1, rnd_len + 1);
+    if(!buf) return result_failed;
+
+    bend = &buf[rnd_len];
+
+    for(b = buf; b < bend; b++) {
+        *(uint8_t *)b = asn_random_between(0, 255);
+    }
+    *b = 0; /* Zero-terminate just in case. */
+
+    if(*sptr) {
+        st = *sptr;
+        FREEMEM(st->buf);
+    } else {
+        st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
+        if(!st) {
+            FREEMEM(buf);
+            return result_failed;
+        }
+    }
+
+    st->buf = buf;
+    st->size = rnd_len;
+    st->bits_unused = (8 - (rnd_bits & 0x7)) & 0x7;
+    if(st->bits_unused) {
+        assert(st->size > 0);
+        st->buf[st->size-1] &= 0xff << st->bits_unused;
+    }
+
+    result_ok.length = st->size;
+    return result_ok;
+}
diff --git a/libs/smux/BIT_STRING_oer.c b/libs/smux/BIT_STRING_oer.c
new file mode 100644 (file)
index 0000000..aff5075
--- /dev/null
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_DISABLE_OER_SUPPORT
+
+#include <asn_internal.h>
+#include <BIT_STRING.h>
+#include <errno.h>
+
+asn_dec_rval_t
+BIT_STRING_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
+                      const asn_TYPE_descriptor_t *td,
+                      const asn_oer_constraints_t *constraints, void **sptr,
+                      const void *ptr, size_t size) {
+    BIT_STRING_t *st = (BIT_STRING_t *)*sptr;
+    const asn_oer_constraints_t *cts =
+        constraints ? constraints : td->encoding_constraints.oer_constraints;
+    ssize_t ct_size = cts ? cts->size : -1;
+    asn_dec_rval_t rval = {RC_OK, 0};
+    size_t expected_length = 0;
+
+    (void)opt_codec_ctx;
+
+    if(!st) {
+        st = (BIT_STRING_t *)(*sptr = CALLOC(1, sizeof(*st)));
+        if(!st) ASN__DECODE_FAILED;
+    }
+
+    if(ct_size >= 0) {
+        expected_length = (ct_size + 7) >> 3;
+        st->bits_unused = (8 - (ct_size & 7)) & 7;
+    } else {
+        /*
+         * X.696 (08/2015) #13.3.1
+         * Encode length determinant as _number of octets_, but only
+         * if upper bound is not equal to lower bound.
+         */
+        ssize_t len_len = oer_fetch_length(ptr, size, &expected_length);
+        if(len_len > 0) {
+            ptr = (const char *)ptr + len_len;
+            size -= len_len;
+        } else if(len_len == 0) {
+            ASN__DECODE_STARVED;
+        } else if(len_len < 0) {
+            ASN__DECODE_FAILED;
+        }
+
+        if(expected_length < 1) {
+            ASN__DECODE_FAILED;
+        } else if(expected_length > size) {
+            ASN__DECODE_STARVED;
+        }
+
+        st->bits_unused = ((const uint8_t *)ptr)[0];
+        if(st->bits_unused & ~7) {
+            ASN_DEBUG("%s: unused bits outside of 0..7 range", td->name);
+            ASN__DECODE_FAILED;
+        }
+        ptr = (const char *)ptr + 1;
+        size--;
+        expected_length--;
+        rval.consumed = len_len + 1;
+    }
+
+    if(size < expected_length) {
+        ASN__DECODE_STARVED;
+    } else {
+        uint8_t *buf = MALLOC(expected_length + 1);
+        if(buf == NULL) {
+            ASN__DECODE_FAILED;
+        } else {
+            memcpy(buf, ptr, expected_length);
+            buf[expected_length] = '\0';
+        }
+        FREEMEM(st->buf);
+        st->buf = buf;
+        st->size = expected_length;
+        if(expected_length > 0) {
+            buf[expected_length - 1] &= (0xff << st->bits_unused);
+        }
+
+        rval.consumed += expected_length;
+        return rval;
+    }
+}
+
+/*
+ * Encode as Canonical OER.
+ */
+asn_enc_rval_t
+BIT_STRING_encode_oer(const asn_TYPE_descriptor_t *td,
+                      const asn_oer_constraints_t *constraints,
+                      const void *sptr, asn_app_consume_bytes_f *cb,
+                      void *app_key) {
+    const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+    asn_enc_rval_t erval = {0, 0, 0};
+    const asn_oer_constraints_t *cts =
+        constraints ? constraints : td->encoding_constraints.oer_constraints;
+    ssize_t ct_size = cts ? cts->size : -1;
+    size_t trailing_zeros = 0;
+    int fix_last_byte = 0;
+
+    if(!st) ASN__ENCODE_FAILED;
+
+    if(st->bits_unused & ~7) {
+        ASN_DEBUG("BIT STRING unused bits %d out of 0..7 range",
+                  st->bits_unused);
+        ASN__ENCODE_FAILED;
+    }
+    if(st->bits_unused && !(st->size && st->buf)) {
+        ASN_DEBUG("BIT STRING %s size 0 can't support unused bits %d", td->name,
+                  st->bits_unused);
+        ASN__ENCODE_FAILED;
+    }
+
+    if(ct_size >= 0) {
+        size_t ct_bytes = (ct_size + 7) >> 3;
+        if(st->size > ct_bytes) {
+            ASN_DEBUG("More bits in BIT STRING %s (%" ASN_PRI_SSIZE ") than constrained %" ASN_PRI_SSIZE "",
+                      td->name, 8 * st->size - st->bits_unused, ct_size);
+            ASN__ENCODE_FAILED;
+        }
+        trailing_zeros = ct_bytes - st->size;   /* Allow larger constraint */
+    } else {
+        uint8_t ub = st->bits_unused & 7;
+        ssize_t len_len = oer_serialize_length(1 + st->size, cb, app_key);
+        if(len_len < 0) ASN__ENCODE_FAILED;
+        if(cb(&ub, 1, app_key) < 0) {
+            ASN__ENCODE_FAILED;
+        }
+        erval.encoded += len_len + 1;
+    }
+
+    if(st->bits_unused) {
+        if(st->buf[st->size - 1] & (0xff << st->bits_unused)) {
+            fix_last_byte = 1;
+        }
+    }
+
+    if(cb(st->buf, st->size - fix_last_byte, app_key) < 0) {
+        ASN__ENCODE_FAILED;
+    }
+
+    if(fix_last_byte) {
+        uint8_t b = st->buf[st->size - 1] & (0xff << st->bits_unused);
+        if(cb(&b, 1, app_key) < 0) {
+            ASN__ENCODE_FAILED;
+        }
+    }
+
+    erval.encoded += st->size;
+
+    if(trailing_zeros) {
+        static uint8_t zeros[16];
+        while(trailing_zeros > 0) {
+            int ret;
+            if(trailing_zeros < sizeof(zeros)) {
+                ret = cb(zeros, trailing_zeros, app_key);
+                erval.encoded += trailing_zeros;
+            } else {
+                ret = cb(zeros, sizeof(zeros), app_key);
+                erval.encoded += sizeof(zeros);
+            }
+            if(ret < 0) ASN__ENCODE_FAILED;
+        }
+    }
+
+    return erval;
+}
+
+
+#endif  /* ASN_DISABLE_OER_SUPPORT */
diff --git a/libs/smux/BOOLEAN.c b/libs/smux/BOOLEAN.c
deleted file mode 100644 (file)
index 6e55b3e..0000000
+++ /dev/null
@@ -1,282 +0,0 @@
-/*-
- * Copyright (c) 2003, 2005 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 <BOOLEAN.h>
-
-/*
- * BOOLEAN basic type description.
- */
-static const ber_tlv_tag_t asn_DEF_BOOLEAN_tags[] = {
-       (ASN_TAG_CLASS_UNIVERSAL | (1 << 2))
-};
-asn_TYPE_descriptor_t asn_DEF_BOOLEAN = {
-       "BOOLEAN",
-       "BOOLEAN",
-       BOOLEAN_free,
-       BOOLEAN_print,
-       asn_generic_no_constraint,
-       BOOLEAN_decode_ber,
-       BOOLEAN_encode_der,
-       BOOLEAN_decode_xer,
-       BOOLEAN_encode_xer,
-       BOOLEAN_decode_uper,    /* Unaligned PER decoder */
-       BOOLEAN_encode_uper,    /* Unaligned PER encoder */
-       0, /* Use generic outmost tag fetcher */
-       asn_DEF_BOOLEAN_tags,
-       sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
-       asn_DEF_BOOLEAN_tags,   /* Same as above */
-       sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
-       0,      /* No PER visible constraints */
-       0, 0,   /* No members */
-       0       /* No specifics */
-};
-
-/*
- * Decode BOOLEAN type.
- */
-asn_dec_rval_t
-BOOLEAN_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
-               asn_TYPE_descriptor_t *td,
-               void **bool_value, const void *buf_ptr, size_t size,
-               int tag_mode) {
-       BOOLEAN_t *st = (BOOLEAN_t *)*bool_value;
-       asn_dec_rval_t rval;
-       ber_tlv_len_t length;
-       ber_tlv_len_t lidx;
-
-       if(st == NULL) {
-               st = (BOOLEAN_t *)(*bool_value = CALLOC(1, sizeof(*st)));
-               if(st == NULL) {
-                       rval.code = RC_FAIL;
-                       rval.consumed = 0;
-                       return rval;
-               }
-       }
-
-       ASN_DEBUG("Decoding %s as BOOLEAN (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("Boolean length is %d bytes", (int)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;
-       }
-
-       /*
-        * Compute boolean value.
-        */
-       for(*st = 0, lidx = 0;
-               (lidx < length) && *st == 0; lidx++) {
-               /*
-                * Very simple approach: read bytes until the end or
-                * value is already TRUE.
-                * BOOLEAN is not supposed to contain meaningful data anyway.
-                */
-               *st |= ((const uint8_t *)buf_ptr)[lidx];
-       }
-
-       rval.code = RC_OK;
-       rval.consumed += length;
-
-       ASN_DEBUG("Took %ld/%ld bytes to encode %s, value=%d",
-               (long)rval.consumed, (long)length,
-               td->name, *st);
-       
-       return rval;
-}
-
-asn_enc_rval_t
-BOOLEAN_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 erval;
-       BOOLEAN_t *st = (BOOLEAN_t *)sptr;
-
-       erval.encoded = der_write_tags(td, 1, tag_mode, 0, tag, cb, app_key);
-       if(erval.encoded == -1) {
-               erval.failed_type = td;
-               erval.structure_ptr = sptr;
-               return erval;
-       }
-
-       if(cb) {
-               uint8_t bool_value;
-
-               bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */
-
-               if(cb(&bool_value, 1, app_key) < 0) {
-                       erval.encoded = -1;
-                       erval.failed_type = td;
-                       erval.structure_ptr = sptr;
-                       return erval;
-               }
-       }
-
-       erval.encoded += 1;
-
-       ASN__ENCODED_OK(erval);
-}
-
-
-/*
- * Decode the chunk of XML text encoding INTEGER.
- */
-static enum xer_pbd_rval
-BOOLEAN__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
-       BOOLEAN_t *st = (BOOLEAN_t *)sptr;
-       const char *p = (const char *)chunk_buf;
-
-       (void)td;
-
-       if(chunk_size && p[0] == 0x3c /* '<' */) {
-               switch(xer_check_tag(chunk_buf, chunk_size, "false")) {
-               case XCT_BOTH:
-                       /* "<false/>" */
-                       *st = 0;
-                       break;
-               case XCT_UNKNOWN_BO:
-                       if(xer_check_tag(chunk_buf, chunk_size, "true")
-                                       != XCT_BOTH)
-                               return XPBD_BROKEN_ENCODING;
-                       /* "<true/>" */
-                       *st = 1;        /* Or 0xff as in DER?.. */
-                       break;
-               default:
-                       return XPBD_BROKEN_ENCODING;
-               }
-               return XPBD_BODY_CONSUMED;
-       } else {
-               return XPBD_BROKEN_ENCODING;
-       }
-}
-
-
-asn_dec_rval_t
-BOOLEAN_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(BOOLEAN_t), opt_mname, buf_ptr, size,
-               BOOLEAN__xer_body_decode);
-}
-
-asn_enc_rval_t
-BOOLEAN_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 BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
-       asn_enc_rval_t er;
-
-       (void)ilevel;
-       (void)flags;
-
-       if(!st) ASN__ENCODE_FAILED;
-
-       if(*st) {
-               ASN__CALLBACK("<true/>", 7);
-               er.encoded = 7;
-       } else {
-               ASN__CALLBACK("<false/>", 8);
-               er.encoded = 8;
-       }
-
-       ASN__ENCODED_OK(er);
-cb_failed:
-       ASN__ENCODE_FAILED;
-}
-
-int
-BOOLEAN_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
-       asn_app_consume_bytes_f *cb, void *app_key) {
-       const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
-       const char *buf;
-       size_t buflen;
-
-       (void)td;       /* Unused argument */
-       (void)ilevel;   /* Unused argument */
-
-       if(st) {
-               if(*st) {
-                       buf = "TRUE";
-                       buflen = 4;
-               } else {
-                       buf = "FALSE";
-                       buflen = 5;
-               }
-       } else {
-               buf = "<absent>";
-               buflen = 8;
-       }
-
-       return (cb(buf, buflen, app_key) < 0) ? -1 : 0;
-}
-
-void
-BOOLEAN_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
-       if(td && ptr && !contents_only) {
-               FREEMEM(ptr);
-       }
-}
-
-asn_dec_rval_t
-BOOLEAN_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_dec_rval_t rv;
-       BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
-
-       (void)opt_codec_ctx;
-       (void)constraints;
-
-       if(!st) {
-               st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
-               if(!st) ASN__DECODE_FAILED;
-       }
-
-       /*
-        * Extract a single bit
-        */
-       switch(per_get_few_bits(pd, 1)) {
-       case 1: *st = 1; break;
-       case 0: *st = 0; break;
-       case -1: default: ASN__DECODE_STARVED;
-       }
-
-       ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
-
-       rv.code = RC_OK;
-       rv.consumed = 1;
-       return rv;
-}
-
-
-asn_enc_rval_t
-BOOLEAN_encode_uper(asn_TYPE_descriptor_t *td,
-       asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-       const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
-       asn_enc_rval_t er = { 0, 0, 0 };
-
-       (void)constraints;
-
-       if(!st) ASN__ENCODE_FAILED;
-
-       if(per_put_few_bits(po, *st ? 1 : 0, 1))
-               ASN__ENCODE_FAILED;
-
-       ASN__ENCODED_OK(er);
-}
index ce9745d7dba232ceeec7f0bd09730f0825a372d2..b58b0253b516fe79a5fc590cf66aaaffea2a1d31 100644 (file)
@@ -1,86 +1,16 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "ClosePDU.h"
 
  */
 
 #include "ClosePDU.h"
 
-int
-ClosePDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_INTEGER.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using INTEGER,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using INTEGER,
  * so here we adjust the DEF accordingly.
  */
-static void
-ClosePDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_INTEGER.free_struct;
-       td->print_struct   = asn_DEF_INTEGER.print_struct;
-       td->check_constraints = asn_DEF_INTEGER.check_constraints;
-       td->ber_decoder    = asn_DEF_INTEGER.ber_decoder;
-       td->der_encoder    = asn_DEF_INTEGER.der_encoder;
-       td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
-       td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
-       td->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
-       td->uper_encoder   = asn_DEF_INTEGER.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_INTEGER.per_constraints;
-       td->elements       = asn_DEF_INTEGER.elements;
-       td->elements_count = asn_DEF_INTEGER.elements_count;
-       td->specifics      = asn_DEF_INTEGER.specifics;
-}
-
-void
-ClosePDU_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       ClosePDU_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-ClosePDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       ClosePDU_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-ClosePDU_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) {
-       ClosePDU_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-ClosePDU_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) {
-       ClosePDU_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-ClosePDU_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) {
-       ClosePDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-ClosePDU_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) {
-       ClosePDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_ClosePDU_tags_1[] = {
        (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 static const ber_tlv_tag_t asn_DEF_ClosePDU_tags_1[] = {
        (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
@@ -88,22 +18,14 @@ static const ber_tlv_tag_t asn_DEF_ClosePDU_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_ClosePDU = {
        "ClosePDU",
        "ClosePDU",
 asn_TYPE_descriptor_t asn_DEF_ClosePDU = {
        "ClosePDU",
        "ClosePDU",
-       ClosePDU_free,
-       ClosePDU_print,
-       ClosePDU_constraint,
-       ClosePDU_decode_ber,
-       ClosePDU_encode_der,
-       ClosePDU_decode_xer,
-       ClosePDU_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_INTEGER,
        asn_DEF_ClosePDU_tags_1,
        sizeof(asn_DEF_ClosePDU_tags_1)
                /sizeof(asn_DEF_ClosePDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_ClosePDU_tags_1,        /* Same as above */
        sizeof(asn_DEF_ClosePDU_tags_1)
                /sizeof(asn_DEF_ClosePDU_tags_1[0]), /* 2 */
        asn_DEF_ClosePDU_tags_1,
        sizeof(asn_DEF_ClosePDU_tags_1)
                /sizeof(asn_DEF_ClosePDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_ClosePDU_tags_1,        /* Same as above */
        sizeof(asn_DEF_ClosePDU_tags_1)
                /sizeof(asn_DEF_ClosePDU_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { 0, 0, INTEGER_constraint },
        0, 0,   /* Defined elsewhere */
        0       /* No specifics */
 };
        0, 0,   /* Defined elsewhere */
        0       /* No specifics */
 };
index a083ee8f155e9a86b537979fc1c724c6a2919214..e858b205f92c614470aa2d0362ace57b9844e1af 100644 (file)
@@ -1,14 +1,14 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "Counter.h"
 
 int
  */
 
 #include "Counter.h"
 
 int
-Counter_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+Counter_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        
        if(!sptr) {
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        
        if(!sptr) {
@@ -27,69 +27,15 @@ Counter_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * This type is implemented using NativeInteger,
  * so here we adjust the DEF accordingly.
  */
  * This type is implemented using NativeInteger,
  * so here we adjust the DEF accordingly.
  */
-static void
-Counter_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
-Counter_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       Counter_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-Counter_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       Counter_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-Counter_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) {
-       Counter_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-Counter_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) {
-       Counter_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-Counter_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) {
-       Counter_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-Counter_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) {
-       Counter_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
-static const asn_INTEGER_specifics_t asn_SPC_Counter_specs_1 = {
+static asn_oer_constraints_t asn_OER_type_Counter_constr_1 CC_NOTUSED = {
+       { 4, 1 }        /* (0..4294967295) */,
+       -1};
+asn_per_constraints_t asn_PER_type_Counter_constr_1 CC_NOTUSED = {
+       { APC_CONSTRAINED,       32, -1,  0,  4294967295 }      /* (0..4294967295) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+const asn_INTEGER_specifics_t asn_SPC_Counter_specs_1 = {
        0,      0,      0,      0,      0,
        0,      /* Native long size */
        1       /* Unsigned representation */
        0,      0,      0,      0,      0,
        0,      /* Native long size */
        1       /* Unsigned representation */
@@ -101,22 +47,14 @@ static const ber_tlv_tag_t asn_DEF_Counter_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_Counter = {
        "Counter",
        "Counter",
 asn_TYPE_descriptor_t asn_DEF_Counter = {
        "Counter",
        "Counter",
-       Counter_free,
-       Counter_print,
-       Counter_constraint,
-       Counter_decode_ber,
-       Counter_encode_der,
-       Counter_decode_xer,
-       Counter_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_NativeInteger,
        asn_DEF_Counter_tags_1,
        sizeof(asn_DEF_Counter_tags_1)
                /sizeof(asn_DEF_Counter_tags_1[0]) - 1, /* 1 */
        asn_DEF_Counter_tags_1, /* Same as above */
        sizeof(asn_DEF_Counter_tags_1)
                /sizeof(asn_DEF_Counter_tags_1[0]), /* 2 */
        asn_DEF_Counter_tags_1,
        sizeof(asn_DEF_Counter_tags_1)
                /sizeof(asn_DEF_Counter_tags_1[0]) - 1, /* 1 */
        asn_DEF_Counter_tags_1, /* Same as above */
        sizeof(asn_DEF_Counter_tags_1)
                /sizeof(asn_DEF_Counter_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_Counter_constr_1, &asn_PER_type_Counter_constr_1, Counter_constraint },
        0, 0,   /* No members */
        &asn_SPC_Counter_specs_1        /* Additional specs */
 };
        0, 0,   /* No members */
        &asn_SPC_Counter_specs_1        /* Additional specs */
 };
index a567799f3e372f35abd62cd786d91bc744c76d6b..a868a67202d71a6c58181caa8f3177a411124003 100644 (file)
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "DisplayString.h"
 
  */
 
 #include "DisplayString.h"
 
-int
-DisplayString_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using OCTET_STRING,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using OCTET_STRING,
  * so here we adjust the DEF accordingly.
  */
-static void
-DisplayString_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
-       td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
-       td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
-       td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
-       td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
-       td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
-       td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
-       td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
-       td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
-       td->elements       = asn_DEF_OCTET_STRING.elements;
-       td->elements_count = asn_DEF_OCTET_STRING.elements_count;
-       td->specifics      = asn_DEF_OCTET_STRING.specifics;
-}
-
-void
-DisplayString_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       DisplayString_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-DisplayString_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       DisplayString_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-DisplayString_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) {
-       DisplayString_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-DisplayString_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) {
-       DisplayString_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-DisplayString_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) {
-       DisplayString_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-DisplayString_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) {
-       DisplayString_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_DisplayString_tags_1[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_DisplayString = {
        "DisplayString",
        "DisplayString",
 static const ber_tlv_tag_t asn_DEF_DisplayString_tags_1[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_DisplayString = {
        "DisplayString",
        "DisplayString",
-       DisplayString_free,
-       DisplayString_print,
-       DisplayString_constraint,
-       DisplayString_decode_ber,
-       DisplayString_encode_der,
-       DisplayString_decode_xer,
-       DisplayString_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_OCTET_STRING,
        asn_DEF_DisplayString_tags_1,
        sizeof(asn_DEF_DisplayString_tags_1)
                /sizeof(asn_DEF_DisplayString_tags_1[0]), /* 1 */
        asn_DEF_DisplayString_tags_1,   /* Same as above */
        sizeof(asn_DEF_DisplayString_tags_1)
                /sizeof(asn_DEF_DisplayString_tags_1[0]), /* 1 */
        asn_DEF_DisplayString_tags_1,
        sizeof(asn_DEF_DisplayString_tags_1)
                /sizeof(asn_DEF_DisplayString_tags_1[0]), /* 1 */
        asn_DEF_DisplayString_tags_1,   /* Same as above */
        sizeof(asn_DEF_DisplayString_tags_1)
                /sizeof(asn_DEF_DisplayString_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, OCTET_STRING_constraint },
        0, 0,   /* No members */
        0, 0,   /* No members */
-       0       /* No specifics */
+       &asn_SPC_OCTET_STRING_specs     /* Additional specs */
 };
 
 };
 
index b12c489fd522d966f68995fadef2a2ea31082af6..2c2268a0c2715a37319c83d69cff2b8ed445bc64 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "EgpNeighEntry.h"
  */
 
 #include "EgpNeighEntry.h"
@@ -12,135 +12,135 @@ static asn_TYPE_member_t asn_MBR_EgpNeighEntry_1[] = {
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighState"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighAddr),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
                "egpNeighState"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighAddr),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighAddr"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighAs),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "egpNeighAddr"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighAs),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighAs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighInMsgs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "egpNeighAs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighInMsgs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighInMsgs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighInErrs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "egpNeighInMsgs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighInErrs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighInErrs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighOutMsgs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "egpNeighInErrs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighOutMsgs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighOutMsgs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighOutErrs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "egpNeighOutMsgs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighOutErrs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighOutErrs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighInErrMsgs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "egpNeighOutErrs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighInErrMsgs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighInErrMsgs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighOutErrMsgs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "egpNeighInErrMsgs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighOutErrMsgs),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighOutErrMsgs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighStateUps),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "egpNeighOutErrMsgs"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighStateUps),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighStateUps"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighStateDowns),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "egpNeighStateUps"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighStateDowns),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighStateDowns"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighIntervalHello),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "egpNeighStateDowns"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighIntervalHello),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighIntervalHello"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighIntervalPoll),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "egpNeighIntervalHello"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighIntervalPoll),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighIntervalPoll"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighMode),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "egpNeighIntervalPoll"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighMode),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighMode"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighEventTrigger),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "egpNeighMode"
                },
        { ATF_NOFLAGS, 0, offsetof(struct EgpNeighEntry, egpNeighEventTrigger),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "egpNeighEventTrigger"
                },
 };
                "egpNeighEventTrigger"
                },
 };
@@ -170,28 +170,19 @@ static asn_SEQUENCE_specifics_t asn_SPC_EgpNeighEntry_specs_1 = {
        asn_MAP_EgpNeighEntry_tag2el_1,
        15,     /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        asn_MAP_EgpNeighEntry_tag2el_1,
        15,     /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_EgpNeighEntry = {
        "EgpNeighEntry",
        "EgpNeighEntry",
 };
 asn_TYPE_descriptor_t asn_DEF_EgpNeighEntry = {
        "EgpNeighEntry",
        "EgpNeighEntry",
-       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_OP_SEQUENCE,
        asn_DEF_EgpNeighEntry_tags_1,
        sizeof(asn_DEF_EgpNeighEntry_tags_1)
                /sizeof(asn_DEF_EgpNeighEntry_tags_1[0]), /* 1 */
        asn_DEF_EgpNeighEntry_tags_1,   /* Same as above */
        sizeof(asn_DEF_EgpNeighEntry_tags_1)
                /sizeof(asn_DEF_EgpNeighEntry_tags_1[0]), /* 1 */
        asn_DEF_EgpNeighEntry_tags_1,
        sizeof(asn_DEF_EgpNeighEntry_tags_1)
                /sizeof(asn_DEF_EgpNeighEntry_tags_1[0]), /* 1 */
        asn_DEF_EgpNeighEntry_tags_1,   /* Same as above */
        sizeof(asn_DEF_EgpNeighEntry_tags_1)
                /sizeof(asn_DEF_EgpNeighEntry_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_EgpNeighEntry_1,
        15,     /* Elements count */
        &asn_SPC_EgpNeighEntry_specs_1  /* Additional specs */
        asn_MBR_EgpNeighEntry_1,
        15,     /* Elements count */
        &asn_SPC_EgpNeighEntry_specs_1  /* Additional specs */
index 2007be44d34245eb0c4cce32bea229e41c737b58..52b737f8de885e709aa73d3f11776ec365c1c6a8 100644 (file)
@@ -1,14 +1,14 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "Gauge.h"
 
 int
  */
 
 #include "Gauge.h"
 
 int
-Gauge_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+Gauge_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        
        if(!sptr) {
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        
        if(!sptr) {
@@ -27,69 +27,15 @@ Gauge_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * This type is implemented using NativeInteger,
  * so here we adjust the DEF accordingly.
  */
  * This type is implemented using NativeInteger,
  * so here we adjust the DEF accordingly.
  */
-static void
-Gauge_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
-Gauge_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       Gauge_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-Gauge_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       Gauge_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-Gauge_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) {
-       Gauge_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-Gauge_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) {
-       Gauge_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-Gauge_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) {
-       Gauge_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-Gauge_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) {
-       Gauge_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
-static const asn_INTEGER_specifics_t asn_SPC_Gauge_specs_1 = {
+static asn_oer_constraints_t asn_OER_type_Gauge_constr_1 CC_NOTUSED = {
+       { 4, 1 }        /* (0..4294967295) */,
+       -1};
+asn_per_constraints_t asn_PER_type_Gauge_constr_1 CC_NOTUSED = {
+       { APC_CONSTRAINED,       32, -1,  0,  4294967295 }      /* (0..4294967295) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+const asn_INTEGER_specifics_t asn_SPC_Gauge_specs_1 = {
        0,      0,      0,      0,      0,
        0,      /* Native long size */
        1       /* Unsigned representation */
        0,      0,      0,      0,      0,
        0,      /* Native long size */
        1       /* Unsigned representation */
@@ -101,22 +47,14 @@ static const ber_tlv_tag_t asn_DEF_Gauge_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_Gauge = {
        "Gauge",
        "Gauge",
 asn_TYPE_descriptor_t asn_DEF_Gauge = {
        "Gauge",
        "Gauge",
-       Gauge_free,
-       Gauge_print,
-       Gauge_constraint,
-       Gauge_decode_ber,
-       Gauge_encode_der,
-       Gauge_decode_xer,
-       Gauge_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_NativeInteger,
        asn_DEF_Gauge_tags_1,
        sizeof(asn_DEF_Gauge_tags_1)
                /sizeof(asn_DEF_Gauge_tags_1[0]) - 1, /* 1 */
        asn_DEF_Gauge_tags_1,   /* Same as above */
        sizeof(asn_DEF_Gauge_tags_1)
                /sizeof(asn_DEF_Gauge_tags_1[0]), /* 2 */
        asn_DEF_Gauge_tags_1,
        sizeof(asn_DEF_Gauge_tags_1)
                /sizeof(asn_DEF_Gauge_tags_1[0]) - 1, /* 1 */
        asn_DEF_Gauge_tags_1,   /* Same as above */
        sizeof(asn_DEF_Gauge_tags_1)
                /sizeof(asn_DEF_Gauge_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_Gauge_constr_1, &asn_PER_type_Gauge_constr_1, Gauge_constraint },
        0, 0,   /* No members */
        &asn_SPC_Gauge_specs_1  /* Additional specs */
 };
        0, 0,   /* No members */
        &asn_SPC_Gauge_specs_1  /* Additional specs */
 };
index ef88e805f931a2f5e3dd0f294490f6390606519f..323ba4eb96f115e505601b7be0725e2e6b2656f5 100644 (file)
@@ -1,86 +1,16 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "GetNextRequest-PDU.h"
 
  */
 
 #include "GetNextRequest-PDU.h"
 
-int
-GetNextRequest_PDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_PDU.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using PDU,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using PDU,
  * so here we adjust the DEF accordingly.
  */
-static void
-GetNextRequest_PDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_PDU.free_struct;
-       td->print_struct   = asn_DEF_PDU.print_struct;
-       td->check_constraints = asn_DEF_PDU.check_constraints;
-       td->ber_decoder    = asn_DEF_PDU.ber_decoder;
-       td->der_encoder    = asn_DEF_PDU.der_encoder;
-       td->xer_decoder    = asn_DEF_PDU.xer_decoder;
-       td->xer_encoder    = asn_DEF_PDU.xer_encoder;
-       td->uper_decoder   = asn_DEF_PDU.uper_decoder;
-       td->uper_encoder   = asn_DEF_PDU.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_PDU.per_constraints;
-       td->elements       = asn_DEF_PDU.elements;
-       td->elements_count = asn_DEF_PDU.elements_count;
-       td->specifics      = asn_DEF_PDU.specifics;
-}
-
-void
-GetNextRequest_PDU_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       GetNextRequest_PDU_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-GetNextRequest_PDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       GetNextRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-GetNextRequest_PDU_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) {
-       GetNextRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-GetNextRequest_PDU_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) {
-       GetNextRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-GetNextRequest_PDU_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) {
-       GetNextRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-GetNextRequest_PDU_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) {
-       GetNextRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_GetNextRequest_PDU_tags_1[] = {
        (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 static const ber_tlv_tag_t asn_DEF_GetNextRequest_PDU_tags_1[] = {
        (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
@@ -88,23 +18,16 @@ static const ber_tlv_tag_t asn_DEF_GetNextRequest_PDU_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_GetNextRequest_PDU = {
        "GetNextRequest-PDU",
        "GetNextRequest-PDU",
 asn_TYPE_descriptor_t asn_DEF_GetNextRequest_PDU = {
        "GetNextRequest-PDU",
        "GetNextRequest-PDU",
-       GetNextRequest_PDU_free,
-       GetNextRequest_PDU_print,
-       GetNextRequest_PDU_constraint,
-       GetNextRequest_PDU_decode_ber,
-       GetNextRequest_PDU_encode_der,
-       GetNextRequest_PDU_decode_xer,
-       GetNextRequest_PDU_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_SEQUENCE,
        asn_DEF_GetNextRequest_PDU_tags_1,
        sizeof(asn_DEF_GetNextRequest_PDU_tags_1)
                /sizeof(asn_DEF_GetNextRequest_PDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_GetNextRequest_PDU_tags_1,      /* Same as above */
        sizeof(asn_DEF_GetNextRequest_PDU_tags_1)
                /sizeof(asn_DEF_GetNextRequest_PDU_tags_1[0]), /* 2 */
        asn_DEF_GetNextRequest_PDU_tags_1,
        sizeof(asn_DEF_GetNextRequest_PDU_tags_1)
                /sizeof(asn_DEF_GetNextRequest_PDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_GetNextRequest_PDU_tags_1,      /* Same as above */
        sizeof(asn_DEF_GetNextRequest_PDU_tags_1)
                /sizeof(asn_DEF_GetNextRequest_PDU_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
-       0, 0,   /* Defined elsewhere */
-       0       /* No specifics */
+       { 0, 0, SEQUENCE_constraint },
+       asn_MBR_PDU_1,
+       4,      /* Elements count */
+       &asn_SPC_PDU_specs_1    /* Additional specs */
 };
 
 };
 
index 953999cec41fa0364bd3a720eff3378de0979e64..bed361c500d5c963c7008608e9db7b2c4aed5449 100644 (file)
@@ -1,86 +1,16 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "GetRequest-PDU.h"
 
  */
 
 #include "GetRequest-PDU.h"
 
-int
-GetRequest_PDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_PDU.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using PDU,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using PDU,
  * so here we adjust the DEF accordingly.
  */
-static void
-GetRequest_PDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_PDU.free_struct;
-       td->print_struct   = asn_DEF_PDU.print_struct;
-       td->check_constraints = asn_DEF_PDU.check_constraints;
-       td->ber_decoder    = asn_DEF_PDU.ber_decoder;
-       td->der_encoder    = asn_DEF_PDU.der_encoder;
-       td->xer_decoder    = asn_DEF_PDU.xer_decoder;
-       td->xer_encoder    = asn_DEF_PDU.xer_encoder;
-       td->uper_decoder   = asn_DEF_PDU.uper_decoder;
-       td->uper_encoder   = asn_DEF_PDU.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_PDU.per_constraints;
-       td->elements       = asn_DEF_PDU.elements;
-       td->elements_count = asn_DEF_PDU.elements_count;
-       td->specifics      = asn_DEF_PDU.specifics;
-}
-
-void
-GetRequest_PDU_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       GetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-GetRequest_PDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       GetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-GetRequest_PDU_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) {
-       GetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-GetRequest_PDU_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) {
-       GetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-GetRequest_PDU_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) {
-       GetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-GetRequest_PDU_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) {
-       GetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_GetRequest_PDU_tags_1[] = {
        (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 static const ber_tlv_tag_t asn_DEF_GetRequest_PDU_tags_1[] = {
        (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
@@ -88,23 +18,16 @@ static const ber_tlv_tag_t asn_DEF_GetRequest_PDU_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_GetRequest_PDU = {
        "GetRequest-PDU",
        "GetRequest-PDU",
 asn_TYPE_descriptor_t asn_DEF_GetRequest_PDU = {
        "GetRequest-PDU",
        "GetRequest-PDU",
-       GetRequest_PDU_free,
-       GetRequest_PDU_print,
-       GetRequest_PDU_constraint,
-       GetRequest_PDU_decode_ber,
-       GetRequest_PDU_encode_der,
-       GetRequest_PDU_decode_xer,
-       GetRequest_PDU_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_SEQUENCE,
        asn_DEF_GetRequest_PDU_tags_1,
        sizeof(asn_DEF_GetRequest_PDU_tags_1)
                /sizeof(asn_DEF_GetRequest_PDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_GetRequest_PDU_tags_1,  /* Same as above */
        sizeof(asn_DEF_GetRequest_PDU_tags_1)
                /sizeof(asn_DEF_GetRequest_PDU_tags_1[0]), /* 2 */
        asn_DEF_GetRequest_PDU_tags_1,
        sizeof(asn_DEF_GetRequest_PDU_tags_1)
                /sizeof(asn_DEF_GetRequest_PDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_GetRequest_PDU_tags_1,  /* Same as above */
        sizeof(asn_DEF_GetRequest_PDU_tags_1)
                /sizeof(asn_DEF_GetRequest_PDU_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
-       0, 0,   /* Defined elsewhere */
-       0       /* No specifics */
+       { 0, 0, SEQUENCE_constraint },
+       asn_MBR_PDU_1,
+       4,      /* Elements count */
+       &asn_SPC_PDU_specs_1    /* Additional specs */
 };
 
 };
 
index 37019105d01b5cc8f8dc0e0b14fd40481cd44224..529beeeb5f60ac746a3e1cbea9b159913ec0ac33 100644 (file)
@@ -1,86 +1,16 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "GetResponse-PDU.h"
 
  */
 
 #include "GetResponse-PDU.h"
 
-int
-GetResponse_PDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_PDU.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using PDU,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using PDU,
  * so here we adjust the DEF accordingly.
  */
-static void
-GetResponse_PDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_PDU.free_struct;
-       td->print_struct   = asn_DEF_PDU.print_struct;
-       td->check_constraints = asn_DEF_PDU.check_constraints;
-       td->ber_decoder    = asn_DEF_PDU.ber_decoder;
-       td->der_encoder    = asn_DEF_PDU.der_encoder;
-       td->xer_decoder    = asn_DEF_PDU.xer_decoder;
-       td->xer_encoder    = asn_DEF_PDU.xer_encoder;
-       td->uper_decoder   = asn_DEF_PDU.uper_decoder;
-       td->uper_encoder   = asn_DEF_PDU.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_PDU.per_constraints;
-       td->elements       = asn_DEF_PDU.elements;
-       td->elements_count = asn_DEF_PDU.elements_count;
-       td->specifics      = asn_DEF_PDU.specifics;
-}
-
-void
-GetResponse_PDU_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       GetResponse_PDU_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-GetResponse_PDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       GetResponse_PDU_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-GetResponse_PDU_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) {
-       GetResponse_PDU_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-GetResponse_PDU_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) {
-       GetResponse_PDU_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-GetResponse_PDU_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) {
-       GetResponse_PDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-GetResponse_PDU_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) {
-       GetResponse_PDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_GetResponse_PDU_tags_1[] = {
        (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 static const ber_tlv_tag_t asn_DEF_GetResponse_PDU_tags_1[] = {
        (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
@@ -88,23 +18,16 @@ static const ber_tlv_tag_t asn_DEF_GetResponse_PDU_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_GetResponse_PDU = {
        "GetResponse-PDU",
        "GetResponse-PDU",
 asn_TYPE_descriptor_t asn_DEF_GetResponse_PDU = {
        "GetResponse-PDU",
        "GetResponse-PDU",
-       GetResponse_PDU_free,
-       GetResponse_PDU_print,
-       GetResponse_PDU_constraint,
-       GetResponse_PDU_decode_ber,
-       GetResponse_PDU_encode_der,
-       GetResponse_PDU_decode_xer,
-       GetResponse_PDU_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_SEQUENCE,
        asn_DEF_GetResponse_PDU_tags_1,
        sizeof(asn_DEF_GetResponse_PDU_tags_1)
                /sizeof(asn_DEF_GetResponse_PDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_GetResponse_PDU_tags_1, /* Same as above */
        sizeof(asn_DEF_GetResponse_PDU_tags_1)
                /sizeof(asn_DEF_GetResponse_PDU_tags_1[0]), /* 2 */
        asn_DEF_GetResponse_PDU_tags_1,
        sizeof(asn_DEF_GetResponse_PDU_tags_1)
                /sizeof(asn_DEF_GetResponse_PDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_GetResponse_PDU_tags_1, /* Same as above */
        sizeof(asn_DEF_GetResponse_PDU_tags_1)
                /sizeof(asn_DEF_GetResponse_PDU_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
-       0, 0,   /* Defined elsewhere */
-       0       /* No specifics */
+       { 0, 0, SEQUENCE_constraint },
+       asn_MBR_PDU_1,
+       4,      /* Elements count */
+       &asn_SPC_PDU_specs_1    /* Additional specs */
 };
 
 };
 
index eed82176b509a49668f6fbef629ce980e17228f4..2b43cdf7c9193cecdd11e71fa8cb9022f5c4c38e 100644 (file)
@@ -1,5 +1,5 @@
-/*-
- * Copyright (c) 2003-2014 Lev Walkin <vlm@lionet.info>.
+/*
+ * Copyright (c) 2003-2019 Lev Walkin <vlm@lionet.info>.
  * All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
  * All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 static const ber_tlv_tag_t asn_DEF_INTEGER_tags[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 static const 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,
+asn_TYPE_operation_t asn_OP_INTEGER = {
+       INTEGER_free,
        INTEGER_print,
        INTEGER_print,
-       asn_generic_no_constraint,
+       INTEGER_compare,
        ber_decode_primitive,
        INTEGER_encode_der,
        INTEGER_decode_xer,
        INTEGER_encode_xer,
        ber_decode_primitive,
        INTEGER_encode_der,
        INTEGER_decode_xer,
        INTEGER_encode_xer,
+#ifdef  ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       INTEGER_decode_oer,     /* OER decoder */
+       INTEGER_encode_oer,     /* Canonical OER encoder */
+#endif  /* ASN_DISABLE_OER_SUPPORT */
 #ifdef ASN_DISABLE_PER_SUPPORT
        0,
        0,
 #ifdef ASN_DISABLE_PER_SUPPORT
        0,
        0,
@@ -31,12 +36,18 @@ asn_TYPE_descriptor_t asn_DEF_INTEGER = {
        INTEGER_decode_uper,    /* Unaligned PER decoder */
        INTEGER_encode_uper,    /* Unaligned PER encoder */
 #endif /* ASN_DISABLE_PER_SUPPORT */
        INTEGER_decode_uper,    /* Unaligned PER decoder */
        INTEGER_encode_uper,    /* Unaligned PER encoder */
 #endif /* ASN_DISABLE_PER_SUPPORT */
-       0, /* Use generic outmost tag fetcher */
+       INTEGER_random_fill,
+       0       /* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_INTEGER = {
+       "INTEGER",
+       "INTEGER",
+       &asn_OP_INTEGER,
        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]),
        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, asn_generic_no_constraint },
        0, 0,   /* No members */
        0       /* No specifics */
 };
        0, 0,   /* No members */
        0       /* No specifics */
 };
@@ -45,10 +56,12 @@ asn_TYPE_descriptor_t asn_DEF_INTEGER = {
  * Encode INTEGER type using DER.
  */
 asn_enc_rval_t
  * 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;
+INTEGER_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,
+                   int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,
+                   void *app_key) {
+    const INTEGER_t *st = (const INTEGER_t *)sptr;
+    asn_enc_rval_t rval;
+    INTEGER_t effective_integer;
 
        ASN_DEBUG("%s %s as INTEGER (tm=%d)",
                cb?"Encoding":"Estimating", td->name, tag_mode);
 
        ASN_DEBUG("%s %s as INTEGER (tm=%d)",
                cb?"Encoding":"Estimating", td->name, tag_mode);
@@ -85,58 +98,60 @@ INTEGER_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
                /* Remove leading superfluous bytes from the integer */
                shift = buf - st->buf;
                if(shift) {
                /* 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) */
+            union {
+                const uint8_t *c_buf;
+                uint8_t *nc_buf;
+            } unconst;
+            unconst.c_buf = st->buf;
+            effective_integer.buf = unconst.nc_buf + shift;
+            effective_integer.size = st->size - shift;
+
+            st = &effective_integer;
+        }
+    }
 
 
-       return der_encode_primitive(td, sptr, tag_mode, tag, cb, app_key);
+    rval = der_encode_primitive(td, st, tag_mode, tag, cb, app_key);
+    if(rval.structure_ptr == &effective_integer) {
+        rval.structure_ptr = sptr;
+    }
+    return rval;
 }
 
 }
 
-static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value(asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop);
+static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value(
+    const asn_INTEGER_specifics_t *specs, const char *lstart,
+    const char *lstop);
 
 /*
  * INTEGER specific human-readable output.
  */
 static ssize_t
 INTEGER__dump(const asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_consume_bytes_f *cb, void *app_key, int plainOrXER) {
 
 /*
  * INTEGER specific human-readable output.
  */
 static ssize_t
 INTEGER__dump(const 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 */
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+       char scratch[32];
        uint8_t *buf = st->buf;
        uint8_t *buf_end = st->buf + st->size;
        uint8_t *buf = st->buf;
        uint8_t *buf_end = st->buf + st->size;
-       signed long value;
+       intmax_t value;
        ssize_t wrote = 0;
        char *p;
        int ret;
 
        if(specs && specs->field_unsigned)
        ssize_t wrote = 0;
        char *p;
        int ret;
 
        if(specs && specs->field_unsigned)
-               ret = asn_INTEGER2ulong(st, (unsigned long *)&value);
+               ret = asn_INTEGER2umax(st, (uintmax_t *)&value);
        else
        else
-               ret = asn_INTEGER2long(st, &value);
+               ret = asn_INTEGER2imax(st, &value);
 
        /* Simple case: the integer size is small */
        if(ret == 0) {
                const asn_INTEGER_enum_map_t *el;
 
        /* 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) {
                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)
                        if(plainOrXER == 0)
-                               ret = snprintf(scr, scrsize,
-                                       "%ld (%s)", value, el->enum_name);
+                               return asn__format_to_callback(cb, app_key,
+                                       "%" ASN_PRIdMAX " (%s)", value, el->enum_name);
                        else
                        else
-                               ret = snprintf(scr, scrsize,
+                               return asn__format_to_callback(cb, app_key,
                                        "<%s/>", el->enum_name);
                } else if(plainOrXER && specs && specs->strict_enumeration) {
                        ASN_DEBUG("ASN.1 forbids dealing with "
                                        "<%s/>", el->enum_name);
                } else if(plainOrXER && specs && specs->strict_enumeration) {
                        ASN_DEBUG("ASN.1 forbids dealing with "
@@ -144,14 +159,12 @@ INTEGER__dump(const asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_cons
                        errno = EPERM;
                        return -1;
                } else {
                        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;
+            return asn__format_to_callback(cb, app_key,
+                                           (specs && specs->field_unsigned)
+                                               ? "%" ASN_PRIuMAX
+                                               : "%" ASN_PRIdMAX,
+                                           value);
+        }
        } else if(plainOrXER && specs && specs->strict_enumeration) {
                /*
                 * Here and earlier, we cannot encode the ENUMERATED values
        } else if(plainOrXER && specs && specs->strict_enumeration) {
                /*
                 * Here and earlier, we cannot encode the ENUMERATED values
@@ -189,12 +202,11 @@ INTEGER__dump(const asn_TYPE_descriptor_t *td, const INTEGER_t *st, asn_app_cons
  * INTEGER specific human-readable output.
  */
 int
  * 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;
+INTEGER_print(const 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;
 
        ssize_t ret;
 
-       (void)td;
        (void)ilevel;
 
        if(!st || !st->buf)
        (void)ilevel;
 
        if(!st || !st->buf)
@@ -223,7 +235,7 @@ INTEGER__compar_enum2value(const void *kp, const void *am) {
        /* Compare strings */
        for(ptr = key->start, end = key->stop, name = el->enum_name;
                        ptr < end; ptr++, name++) {
        /* Compare strings */
        for(ptr = key->start, end = key->stop, name = el->enum_name;
                        ptr < end; ptr++, name++) {
-               if(*ptr != *name)
+               if(*ptr != *name || !*name)
                        return *(const unsigned char *)ptr
                                - *(const unsigned char *)name;
        }
                        return *(const unsigned char *)ptr
                                - *(const unsigned char *)name;
        }
@@ -231,8 +243,9 @@ INTEGER__compar_enum2value(const void *kp, const void *am) {
 }
 
 static const asn_INTEGER_enum_map_t *
 }
 
 static const asn_INTEGER_enum_map_t *
-INTEGER_map_enum2value(asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop) {
-       const asn_INTEGER_enum_map_t *el_found;
+INTEGER_map_enum2value(const asn_INTEGER_specifics_t *specs, const char *lstart,
+                       const char *lstop) {
+    const asn_INTEGER_enum_map_t *el_found;
        int count = specs ? specs->map_count : 0;
        struct e2v_key key;
        const char *lp;
        int count = specs ? specs->map_count : 0;
        struct e2v_key key;
        const char *lp;
@@ -279,7 +292,7 @@ INTEGER__compar_value2enum(const void *kp, const void *am) {
 }
 
 const asn_INTEGER_enum_map_t *
 }
 
 const asn_INTEGER_enum_map_t *
-INTEGER_map_value2enum(asn_INTEGER_specifics_t *specs, long value) {
+INTEGER_map_value2enum(const 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,
        int count = specs ? specs->map_count : 0;
        if(!count) return 0;
        return (asn_INTEGER_enum_map_t *)bsearch(&value, specs->value2enum,
@@ -305,10 +318,11 @@ INTEGER_st_prealloc(INTEGER_t *st, int min_size) {
  * Decode the chunk of XML text encoding INTEGER.
  */
 static enum xer_pbd_rval
  * 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;
+INTEGER__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
+                         const void *chunk_buf, size_t chunk_size) {
+    INTEGER_t *st = (INTEGER_t *)sptr;
+       intmax_t dec_value;
+       intmax_t hex_value = 0;
        const char *lp;
        const char *lstart = (const char *)chunk_buf;
        const char *lstop = lstart + chunk_size;
        const char *lp;
        const char *lstart = (const char *)chunk_buf;
        const char *lstop = lstart + chunk_size;
@@ -407,7 +421,7 @@ INTEGER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chun
                        if(state == ST_LEADSPACE) {
                                const asn_INTEGER_enum_map_t *el;
                                el = INTEGER_map_enum2value(
                        if(state == ST_LEADSPACE) {
                                const asn_INTEGER_enum_map_t *el;
                                el = INTEGER_map_enum2value(
-                                       (asn_INTEGER_specifics_t *)
+                                       (const asn_INTEGER_specifics_t *)
                                        td->specifics, lstart, lstop);
                                if(el) {
                                        ASN_DEBUG("Found \"%s\" => %ld",
                                        td->specifics, lstart, lstop);
                                if(el) {
                                        ASN_DEBUG("Found \"%s\" => %ld",
@@ -485,14 +499,24 @@ INTEGER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chun
                /* FALL THROUGH */
        case ST_DIGITS_TRAILSPACE:
                /* The last symbol encountered was a digit. */
                /* 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:
+        switch(asn_strtoimax_lim(dec_value_start, &dec_value_end, &dec_value)) {
+        case ASN_STRTOX_OK:
+            if(dec_value >= LONG_MIN && dec_value <= LONG_MAX) {
+                break;
+            } else {
+                /*
+                 * We model INTEGER on long for XER,
+                 * to avoid rewriting all the tests at once.
+                 */
+                ASN_DEBUG("INTEGER exceeds long range");
+            }
+            /* Fall through */
+        case ASN_STRTOX_ERROR_RANGE:
+            ASN_DEBUG("INTEGER decode %s hit range limit", td->name);
+            return XPBD_DECODER_LIMIT;
+               case ASN_STRTOX_ERROR_INVAL:
+               case ASN_STRTOX_EXPECT_MORE:
+               case ASN_STRTOX_EXTRA_DATA:
                        return XPBD_BROKEN_ENCODING;
                }
                break;
                        return XPBD_BROKEN_ENCODING;
                }
                break;
@@ -517,27 +541,28 @@ INTEGER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chun
         * Convert the result of parsing of enumeration or a straight
         * decimal value into a BER representation.
         */
         * Convert the result of parsing of enumeration or a straight
         * decimal value into a BER representation.
         */
-       if(asn_long2INTEGER(st, dec_value))
+       if(asn_imax2INTEGER(st, dec_value)) {
+                ASN_DEBUG("INTEGER decode %s conversion failed", td->name);
                return XPBD_SYSTEM_FAILURE;
                return XPBD_SYSTEM_FAILURE;
+        }
 
        return XPBD_BODY_CONSUMED;
 }
 
 asn_dec_rval_t
 
        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,
+INTEGER_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
+                   const 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
                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;
+INTEGER_encode_xer(const asn_TYPE_descriptor_t *td, const 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;
        asn_enc_rval_t er;
 
        (void)ilevel;
@@ -555,12 +580,15 @@ INTEGER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 #ifndef        ASN_DISABLE_PER_SUPPORT
 
 asn_dec_rval_t
 #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_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                    const asn_TYPE_descriptor_t *td,
+                    const asn_per_constraints_t *constraints, void **sptr,
+                    asn_per_data_t *pd) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_dec_rval_t rval = { RC_OK, 0 };
        INTEGER_t *st = (INTEGER_t *)*sptr;
        INTEGER_t *st = (INTEGER_t *)*sptr;
-       asn_per_constraint_t *ct;
+       const asn_per_constraint_t *ct;
        int repeat;
 
        (void)opt_codec_ctx;
        int repeat;
 
        (void)opt_codec_ctx;
@@ -570,7 +598,7 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                if(!st) ASN__DECODE_FAILED;
        }
 
                if(!st) ASN__DECODE_FAILED;
        }
 
-       if(!constraints) constraints = td->per_constraints;
+       if(!constraints) constraints = td->encoding_constraints.per_constraints;
        ct = constraints ? &constraints->value : 0;
 
        if(ct && ct->flags & APC_EXTENSIBLE) {
        ct = constraints ? &constraints->value : 0;
 
        if(ct && ct->flags & APC_EXTENSIBLE) {
@@ -604,7 +632,7 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                                ASN__DECODE_FAILED;
 
                        if(specs && specs->field_unsigned) {
                                ASN__DECODE_FAILED;
 
                        if(specs && specs->field_unsigned) {
-                               unsigned long uvalue;
+                               unsigned long uvalue = 0;
                                if(uper_get_constrained_whole_number(pd,
                                        &uvalue, ct->range_bits))
                                        ASN__DECODE_STARVED;
                                if(uper_get_constrained_whole_number(pd,
                                        &uvalue, ct->range_bits))
                                        ASN__DECODE_STARVED;
@@ -614,15 +642,18 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                                if(asn_ulong2INTEGER(st, uvalue))
                                        ASN__DECODE_FAILED;
                        } else {
                                if(asn_ulong2INTEGER(st, uvalue))
                                        ASN__DECODE_FAILED;
                        } else {
-                               unsigned long svalue;
+                               unsigned long uvalue = 0;
+                               long svalue;
                                if(uper_get_constrained_whole_number(pd,
                                if(uper_get_constrained_whole_number(pd,
-                                       &svalue, ct->range_bits))
+                                       &uvalue, ct->range_bits))
                                        ASN__DECODE_STARVED;
                                        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;
+                               ASN_DEBUG("Got value %lu + low %ld",
+                                       uvalue, ct->lower_bound);
+                if(per_long_range_unrebase(uvalue, ct->lower_bound,
+                                           ct->upper_bound, &svalue)
+                   || asn_long2INTEGER(st, svalue)) {
+                    ASN__DECODE_FAILED;
+                }
                        }
                        return rval;
                }
                        }
                        return rval;
                }
@@ -632,12 +663,12 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 
        /* X.691, #12.2.3, #12.2.4 */
        do {
 
        /* X.691, #12.2.3, #12.2.4 */
        do {
-               ssize_t len;
-               void *p;
-               int ret;
+               ssize_t len = 0;
+               void *p = NULL;
+               int ret = 0;
 
                /* Get the PER length */
 
                /* Get the PER length */
-               len = uper_get_length(pd, -1, &repeat);
+               len = uper_get_length(pd, -1, 0, &repeat);
                if(len < 0) ASN__DECODE_STARVED;
 
                p = REALLOC(st->buf, st->size + len + 1);
                if(len < 0) ASN__DECODE_STARVED;
 
                p = REALLOC(st->buf, st->size + len + 1);
@@ -655,10 +686,10 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                /*
                 * TODO: replace by in-place arithmetics.
                 */
                /*
                 * TODO: replace by in-place arithmetics.
                 */
-               long value;
+               long value = 0;
                if(asn_INTEGER2long(st, &value))
                        ASN__DECODE_FAILED;
                if(asn_INTEGER2long(st, &value))
                        ASN__DECODE_FAILED;
-               if(asn_long2INTEGER(st, value + ct->lower_bound))
+               if(asn_imax2INTEGER(st, value + ct->lower_bound))
                        ASN__DECODE_FAILED;
        }
 
                        ASN__DECODE_FAILED;
        }
 
@@ -666,20 +697,21 @@ INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 }
 
 asn_enc_rval_t
 }
 
 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;
+INTEGER_encode_uper(const asn_TYPE_descriptor_t *td,
+                    const asn_per_constraints_t *constraints, const void *sptr,
+                    asn_per_outp_t *po) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_enc_rval_t er;
+       const INTEGER_t *st = (const INTEGER_t *)sptr;
        const uint8_t *buf;
        const uint8_t *end;
        const uint8_t *buf;
        const uint8_t *end;
-       asn_per_constraint_t *ct;
+       const asn_per_constraint_t *ct;
        long value = 0;
        long value = 0;
-       unsigned long v = 0;
 
        if(!st || st->size == 0) ASN__ENCODE_FAILED;
 
 
        if(!st || st->size == 0) ASN__ENCODE_FAILED;
 
-       if(!constraints) constraints = td->per_constraints;
+       if(!constraints) constraints = td->encoding_constraints.per_constraints;
        ct = constraints ? &constraints->value : 0;
 
        er.encoded = 0;
        ct = constraints ? &constraints->value : 0;
 
        er.encoded = 0;
@@ -699,7 +731,7 @@ INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
                                || uval > (unsigned long)ct->upper_bound)
                                        inext = 1;
                        }
                                || uval > (unsigned long)ct->upper_bound)
                                        inext = 1;
                        }
-                       ASN_DEBUG("Value %lu (%02x/%d) lb %lu ub %lu %s",
+                       ASN_DEBUG("Value %lu (%02x/%" ASN_PRI_SIZE ") lb %lu ub %lu %s",
                                uval, st->buf[0], st->size,
                                ct->lower_bound, ct->upper_bound,
                                inext ? "ext" : "fix");
                                uval, st->buf[0], st->size,
                                ct->lower_bound, ct->upper_bound,
                                inext ? "ext" : "fix");
@@ -716,7 +748,7 @@ INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
                                || value > ct->upper_bound)
                                        inext = 1;
                        }
                                || value > ct->upper_bound)
                                        inext = 1;
                        }
-                       ASN_DEBUG("Value %ld (%02x/%d) lb %ld ub %ld %s",
+                       ASN_DEBUG("Value %ld (%02x/%" ASN_PRI_SIZE ") lb %ld ub %ld %s",
                                value, st->buf[0], st->size,
                                ct->lower_bound, ct->upper_bound,
                                inext ? "ext" : "fix");
                                value, st->buf[0], st->size,
                                ct->lower_bound, ct->upper_bound,
                                inext ? "ext" : "fix");
@@ -733,12 +765,15 @@ INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
 
        /* X.691-11/2008, #13.2.2, test if constrained whole number */
        if(ct && ct->range_bits >= 0) {
 
        /* X.691-11/2008, #13.2.2, test if constrained whole number */
        if(ct && ct->range_bits >= 0) {
+        unsigned long v;
                /* #11.5.6 -> #11.3 */
                ASN_DEBUG("Encoding integer %ld (%lu) with range %d bits",
                        value, value - ct->lower_bound, ct->range_bits);
                /* #11.5.6 -> #11.3 */
                ASN_DEBUG("Encoding integer %ld (%lu) with range %d bits",
                        value, value - ct->lower_bound, ct->range_bits);
-               v = value - ct->lower_bound;
-               if(uper_put_constrained_whole_number_u(po, v, ct->range_bits))
-                       ASN__ENCODE_FAILED;
+        if(per_long_range_rebase(value, ct->lower_bound, ct->upper_bound, &v)) {
+            ASN__ENCODE_FAILED;
+        }
+        if(uper_put_constrained_whole_number_u(po, v, ct->range_bits))
+            ASN__ENCODE_FAILED;
                ASN__ENCODED_OK(er);
        }
 
                ASN__ENCODED_OK(er);
        }
 
@@ -749,24 +784,45 @@ INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
        }
 
        for(buf = st->buf, end = st->buf + st->size; buf < end;) {
        }
 
        for(buf = st->buf, end = st->buf + st->size; buf < end;) {
-               ssize_t mayEncode = uper_put_length(po, end - buf);
-               if(mayEncode < 0)
+        int need_eom = 0;
+        ssize_t mayEncode = uper_put_length(po, end - buf, &need_eom);
+        if(mayEncode < 0)
                        ASN__ENCODE_FAILED;
                if(per_put_many_bits(po, buf, 8 * mayEncode))
                        ASN__ENCODE_FAILED;
                buf += mayEncode;
                        ASN__ENCODE_FAILED;
                if(per_put_many_bits(po, buf, 8 * mayEncode))
                        ASN__ENCODE_FAILED;
                buf += mayEncode;
-       }
+        if(need_eom && uper_put_length(po, 0, 0)) ASN__ENCODE_FAILED;
+    }
 
        ASN__ENCODED_OK(er);
 }
 
 #endif /* ASN_DISABLE_PER_SUPPORT */
 
 
        ASN__ENCODED_OK(er);
 }
 
 #endif /* ASN_DISABLE_PER_SUPPORT */
 
+static intmax_t
+asn__integer_convert(const uint8_t *b, const uint8_t *end) {
+    uintmax_t value;
+
+    /* Perform the sign initialization */
+    /* Actually value = -(*b >> 7); gains nothing, yet unreadable! */
+    if((*b >> 7)) {
+        value = (uintmax_t)(-1);
+    } else {
+        value = 0;
+    }
+
+    /* Conversion engine */
+    for(; b < end; b++) {
+        value = (value << 8) | *b;
+    }
+
+    return value;
+}
+
 int
 int
-asn_INTEGER2long(const INTEGER_t *iptr, long *lptr) {
+asn_INTEGER2imax(const INTEGER_t *iptr, intmax_t *lptr) {
        uint8_t *b, *end;
        size_t size;
        uint8_t *b, *end;
        size_t size;
-       long l;
 
        /* Sanity checking */
        if(!iptr || !iptr->buf || !lptr) {
 
        /* Sanity checking */
        if(!iptr || !iptr->buf || !lptr) {
@@ -779,26 +835,26 @@ asn_INTEGER2long(const INTEGER_t *iptr, long *lptr) {
        size = iptr->size;
        end = b + size; /* Where to stop */
 
        size = iptr->size;
        end = b + size; /* Where to stop */
 
-       if(size > sizeof(long)) {
+       if(size > sizeof(intmax_t)) {
                uint8_t *end1 = end - 1;
                /*
                 * Slightly more advanced processing,
                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)
+                * able to process INTEGERs with >sizeof(intmax_t) bytes
+                * when the actual value is small, e.g. for intmax_t == int32_t
+                * (0x0000000000abcdef INTEGER would yield a fine 0x00abcdef int32_t)
                 */
                /* Skip out the insignificant leading bytes */
                for(; b < end1; b++) {
                        switch(*b) {
                 */
                /* 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;
+                               case 0x00: if((b[1] & 0x80) == 0) continue; break;
+                               case 0xff: if((b[1] & 0x80) != 0) continue; break;
                        }
                        break;
                }
 
                size = end - b;
                        }
                        break;
                }
 
                size = end - b;
-               if(size > sizeof(long)) {
-                       /* Still cannot fit the long */
+               if(size > sizeof(intmax_t)) {
+                       /* Still cannot fit the sizeof(intmax_t) */
                        errno = ERANGE;
                        return -1;
                }
                        errno = ERANGE;
                        return -1;
                }
@@ -810,22 +866,15 @@ asn_INTEGER2long(const INTEGER_t *iptr, long *lptr) {
                return 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;
+       *lptr = asn__integer_convert(b, end);
        return 0;
 }
 
        return 0;
 }
 
+/* FIXME: negative INTEGER values are silently interpreted as large unsigned ones. */
 int
 int
-asn_INTEGER2ulong(const INTEGER_t *iptr, unsigned long *lptr) {
+asn_INTEGER2umax(const INTEGER_t *iptr, uintmax_t *lptr) {
        uint8_t *b, *end;
        uint8_t *b, *end;
-       unsigned long l;
+       uintmax_t value;
        size_t size;
 
        if(!iptr || !iptr->buf || !lptr) {
        size_t size;
 
        if(!iptr || !iptr->buf || !lptr) {
@@ -838,49 +887,50 @@ asn_INTEGER2ulong(const INTEGER_t *iptr, unsigned long *lptr) {
        end = b + size;
 
        /* If all extra leading bytes are zeroes, ignore them */
        end = b + size;
 
        /* If all extra leading bytes are zeroes, ignore them */
-       for(; size > sizeof(unsigned long); b++, size--) {
+       for(; size > sizeof(value); b++, size--) {
                if(*b) {
                if(*b) {
-                       /* Value won't fit unsigned long */
+                       /* Value won't fit into uintmax_t */
                        errno = ERANGE;
                        return -1;
                }
        }
 
        /* Conversion engine */
                        errno = ERANGE;
                        return -1;
                }
        }
 
        /* Conversion engine */
-       for(l = 0; b < end; b++)
-               l = (l << 8) | *b;
+       for(value = 0; b < end; b++)
+               value = (value << 8) | *b;
 
 
-       *lptr = l;
+       *lptr = value;
        return 0;
 }
 
 int
        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);
+asn_umax2INTEGER(INTEGER_t *st, uintmax_t value) {
+    uint8_t *buf;
+    uint8_t *end;
+    uint8_t *b;
+    int shr;
+
+    if(value <= ((~(uintmax_t)0) >> 1)) {
+        return asn_imax2INTEGER(st, value);
+    }
 
 
-       buf = (uint8_t *)MALLOC(1 + sizeof(value));
-       if(!buf) return -1;
+    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);
+    end = buf + (sizeof(value) + 1);
+    buf[0] = 0; /* INTEGERs are signed. 0-byte indicates positive. */
+    for(b = buf + 1, shr = (sizeof(value) - 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);
+    if(st->buf) FREEMEM(st->buf);
+    st->buf = buf;
+    st->size = 1 + sizeof(value);
 
        return 0;
 }
 
 int
 
        return 0;
 }
 
 int
-asn_long2INTEGER(INTEGER_t *st, long value) {
+asn_imax2INTEGER(INTEGER_t *st, intmax_t value) {
        uint8_t *buf, *bp;
        uint8_t *p;
        uint8_t *pstart;
        uint8_t *buf, *bp;
        uint8_t *p;
        uint8_t *pstart;
@@ -893,7 +943,7 @@ asn_long2INTEGER(INTEGER_t *st, long value) {
                return -1;
        }
 
                return -1;
        }
 
-       buf = (uint8_t *)MALLOC(sizeof(value));
+       buf = (uint8_t *)(long *)MALLOC(sizeof(value));
        if(!buf) return -1;
 
        if(*(char *)&littleEndian) {
        if(!buf) return -1;
 
        if(*(char *)&littleEndian) {
@@ -924,7 +974,7 @@ asn_long2INTEGER(INTEGER_t *st, long value) {
                break;
        }
        /* Copy the integer body */
                break;
        }
        /* Copy the integer body */
-       for(pstart = p, bp = buf, pend1 += add; p != pend1; p += add)
+       for(bp = buf, pend1 += add; p != pend1; p += add)
                *bp++ = *p;
 
        if(st->buf) FREEMEM(st->buf);
                *bp++ = *p;
 
        if(st->buf) FREEMEM(st->buf);
@@ -934,92 +984,370 @@ asn_long2INTEGER(INTEGER_t *st, long value) {
        return 0;
 }
 
        return 0;
 }
 
+int
+asn_INTEGER2long(const INTEGER_t *iptr, long *l) {
+    intmax_t v;
+    if(asn_INTEGER2imax(iptr, &v) == 0) {
+        if(v < LONG_MIN || v > LONG_MAX) {
+            errno = ERANGE;
+            return -1;
+        }
+        *l = v;
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+int
+asn_INTEGER2ulong(const INTEGER_t *iptr, unsigned long *l) {
+    uintmax_t v;
+    if(asn_INTEGER2umax(iptr, &v) == 0) {
+        if(v > ULONG_MAX) {
+            errno = ERANGE;
+            return -1;
+        }
+        *l = v;
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+int
+asn_long2INTEGER(INTEGER_t *st, long value) {
+    return asn_imax2INTEGER(st, value);
+}
+
+int
+asn_ulong2INTEGER(INTEGER_t *st, unsigned long value) {
+    return asn_imax2INTEGER(st, value);
+}
+
 /*
 /*
- * This function is going to be DEPRECATED soon.
+ * 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/strtoimax(3).
  */
  */
-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 */
+enum asn_strtox_result_e
+asn_strtoimax_lim(const char *str, const char **end, intmax_t *intp) {
+    int sign = 1;
+    intmax_t value;
+
+    const intmax_t asn1_intmax_max = ((~(uintmax_t)0) >> 1);
+    const intmax_t upper_boundary = asn1_intmax_max / 10;
+    intmax_t last_digit_max = asn1_intmax_max % 10;
+
+    if(str >= *end) return ASN_STRTOX_ERROR_INVAL;
+
+    switch(*str) {
+    case '-':
+        last_digit_max++;
+        sign = -1;
+        /* FALL THROUGH */
+    case '+':
+        str++;
+        if(str >= *end) {
+            *end = str;
+            return ASN_STRTOX_EXPECT_MORE;
+        }
+    }
+
+    for(value = 0; str < (*end); str++) {
+        if(*str >= 0x30 && *str <= 0x39) {
+            int d = *str - '0';
+            if(value < upper_boundary) {
+                value = value * 10 + d;
+            } else if(value == upper_boundary) {
+                if(d <= last_digit_max) {
+                    if(sign > 0) {
+                        value = value * 10 + d;
+                    } else {
+                        sign = 1;
+                        value = -value * 10 - d;
+                    }
+                    str += 1;
+                    if(str < *end) {
+                        // If digits continue, we're guaranteed out of range.
+                        *end = str;
+                        if(*str >= 0x30 && *str <= 0x39) {
+                            return ASN_STRTOX_ERROR_RANGE;
+                        } else {
+                            *intp = sign * value;
+                            return ASN_STRTOX_EXTRA_DATA;
+                        }
+                    }
+                    break;
+                } else {
+                    *end = str;
+                    return ASN_STRTOX_ERROR_RANGE;
+                }
+            } else {
+                *end = str;
+                return ASN_STRTOX_ERROR_RANGE;
+            }
+        } else {
+            *end = str;
+            *intp = sign * value;
+            return ASN_STRTOX_EXTRA_DATA;
+        }
     }
 
     }
 
-    return ASN_STRTOL_ERROR_INVAL;  /* Retain old behavior */
+    *end = str;
+    *intp = sign * value;
+    return ASN_STRTOX_OK;
 }
 
 /*
  * 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.
 }
 
 /*
  * 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).
+ * WARNING: This behavior is different from the standard strtoul/strtoumax(3).
  */
  */
-enum asn_strtol_result_e
+enum asn_strtox_result_e
+asn_strtoumax_lim(const char *str, const char **end, uintmax_t *uintp) {
+    uintmax_t value;
+
+    const uintmax_t asn1_uintmax_max = ((~(uintmax_t)0));
+    const uintmax_t upper_boundary = asn1_uintmax_max / 10;
+    uintmax_t last_digit_max = asn1_uintmax_max % 10;
+
+    if(str >= *end) return ASN_STRTOX_ERROR_INVAL;
+
+    switch(*str) {
+    case '-':
+        return ASN_STRTOX_ERROR_INVAL;
+    case '+':
+        str++;
+        if(str >= *end) {
+            *end = str;
+            return ASN_STRTOX_EXPECT_MORE;
+        }
+    }
+
+    for(value = 0; str < (*end); str++) {
+        if(*str >= 0x30 && *str <= 0x39) {
+            unsigned int d = *str - '0';
+            if(value < upper_boundary) {
+                value = value * 10 + d;
+            } else if(value == upper_boundary) {
+                if(d <= last_digit_max) {
+                    value = value * 10 + d;
+                    str += 1;
+                    if(str < *end) {
+                        // If digits continue, we're guaranteed out of range.
+                        *end = str;
+                        if(*str >= 0x30 && *str <= 0x39) {
+                            return ASN_STRTOX_ERROR_RANGE;
+                        } else {
+                            *uintp = value;
+                            return ASN_STRTOX_EXTRA_DATA;
+                        }
+                    }
+                    break;
+                } else {
+                    *end = str;
+                    return ASN_STRTOX_ERROR_RANGE;
+                }
+            } else {
+                *end = str;
+                return ASN_STRTOX_ERROR_RANGE;
+            }
+        } else {
+            *end = str;
+            *uintp = value;
+            return ASN_STRTOX_EXTRA_DATA;
+        }
+    }
+
+    *end = str;
+    *uintp = value;
+    return ASN_STRTOX_OK;
+}
+
+enum asn_strtox_result_e
 asn_strtol_lim(const char *str, const char **end, long *lp) {
 asn_strtol_lim(const char *str, const char **end, long *lp) {
-       int sign = 1;
-       long l;
+    intmax_t value;
+    switch(asn_strtoimax_lim(str, end, &value)) {
+    case ASN_STRTOX_ERROR_RANGE:
+        return ASN_STRTOX_ERROR_RANGE;
+    case ASN_STRTOX_ERROR_INVAL:
+        return ASN_STRTOX_ERROR_INVAL;
+    case ASN_STRTOX_EXPECT_MORE:
+        return ASN_STRTOX_EXPECT_MORE;
+    case ASN_STRTOX_OK:
+        if(value >= LONG_MIN && value <= LONG_MAX) {
+            *lp = value;
+            return ASN_STRTOX_OK;
+        } else {
+            return ASN_STRTOX_ERROR_RANGE;
+        }
+    case ASN_STRTOX_EXTRA_DATA:
+        if(value >= LONG_MIN && value <= LONG_MAX) {
+            *lp = value;
+            return ASN_STRTOX_EXTRA_DATA;
+        } else {
+            return ASN_STRTOX_ERROR_RANGE;
+        }
+    }
 
 
-       const long upper_boundary = LONG_MAX / 10;
-       long last_digit_max = LONG_MAX % 10;
+    assert(!"Unreachable");
+    return ASN_STRTOX_ERROR_INVAL;
+}
 
 
-       if(str >= *end) return ASN_STRTOL_ERROR_INVAL;
+enum asn_strtox_result_e
+asn_strtoul_lim(const char *str, const char **end, unsigned long *ulp) {
+    uintmax_t value;
+    switch(asn_strtoumax_lim(str, end, &value)) {
+    case ASN_STRTOX_ERROR_RANGE:
+        return ASN_STRTOX_ERROR_RANGE;
+    case ASN_STRTOX_ERROR_INVAL:
+        return ASN_STRTOX_ERROR_INVAL;
+    case ASN_STRTOX_EXPECT_MORE:
+        return ASN_STRTOX_EXPECT_MORE;
+    case ASN_STRTOX_OK:
+        if(value <= ULONG_MAX) {
+            *ulp = value;
+            return ASN_STRTOX_OK;
+        } else {
+            return ASN_STRTOX_ERROR_RANGE;
+        }
+    case ASN_STRTOX_EXTRA_DATA:
+        if(value <= ULONG_MAX) {
+            *ulp = value;
+            return ASN_STRTOX_EXTRA_DATA;
+        } else {
+            return ASN_STRTOX_ERROR_RANGE;
+        }
+    }
 
 
-       switch(*str) {
-       case '-':
-               last_digit_max++;
-               sign = -1;
-               /* FALL THROUGH */
-       case '+':
-               str++;
-               if(str >= *end) {
-                       *end = str;
-                       return ASN_STRTOL_EXPECT_MORE;
-               }
-       }
+    assert(!"Unreachable");
+    return ASN_STRTOX_ERROR_INVAL;
+}
 
 
-       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;
-               }
-       }
+int
+INTEGER_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
+                     const void *bptr) {
+    const INTEGER_t *a = aptr;
+    const INTEGER_t *b = bptr;
+
+    (void)td;
+
+    if(a && b) {
+        if(a->size && b->size) {
+            int sign_a = (a->buf[0] & 0x80) ? -1 : 1;
+            int sign_b = (b->buf[0] & 0x80) ? -1 : 1;
+
+            if(sign_a < sign_b) return -1;
+            if(sign_a > sign_b) return 1;
+
+            /* The shortest integer wins, unless comparing negatives */
+            if(a->size < b->size) {
+                return -1 * sign_a;
+            } else if(a->size > b->size) {
+                return 1 * sign_b;
+            }
+
+            return sign_a * memcmp(a->buf, b->buf, a->size);
+        } else if(a->size) {
+            int sign = (a->buf[0] & 0x80) ? -1 : 1;
+            return (1) * sign;
+        } else if(b->size) {
+            int sign = (a->buf[0] & 0x80) ? -1 : 1;
+            return (-1) * sign;
+        } else {
+            return 0;
+        }
+    } else if(!a && !b) {
+        return 0;
+    } else if(!a) {
+        return -1;
+    } else {
+        return 1;
+    }
 
 
-       *end = str;
-       *lp = sign * l;
-       return ASN_STRTOL_OK;
 }
 
 }
 
+asn_random_fill_result_t
+INTEGER_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                    const asn_encoding_constraints_t *constraints,
+                    size_t max_length) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    INTEGER_t *st = *sptr;
+    const asn_INTEGER_enum_map_t *emap;
+    size_t emap_len;
+    intmax_t value;
+    int find_inside_map;
+
+    if(max_length == 0) return result_skipped;
+
+    if(st == NULL) {
+        st = (INTEGER_t *)CALLOC(1, sizeof(*st));
+        if(st == NULL) {
+            return result_failed;
+        }
+    }
+
+    if(specs) {
+        emap = specs->value2enum;
+        emap_len = specs->map_count;
+        if(specs->strict_enumeration) {
+            find_inside_map = emap_len > 0;
+        } else {
+            find_inside_map = emap_len ? asn_random_between(0, 1) : 0;
+        }
+    } else {
+        emap = 0;
+        emap_len = 0;
+        find_inside_map = 0;
+    }
+
+    if(find_inside_map) {
+        assert(emap_len > 0);
+        value = emap[asn_random_between(0, emap_len - 1)].nat_value;
+    } else {
+        const asn_per_constraints_t *ct;
+
+        static const long variants[] = {
+            -65536, -65535, -65534, -32769, -32768, -32767, -16385, -16384,
+            -16383, -257,   -256,   -255,   -254,   -129,   -128,   -127,
+            -126,   -1,     0,      1,      126,    127,    128,    129,
+            254,    255,    256,    257,    16383,  16384,  16385,  32767,
+            32768,  32769,  65534,  65535,  65536,  65537};
+        if(specs && specs->field_unsigned) {
+            assert(variants[18] == 0);
+            value = variants[asn_random_between(
+                18, sizeof(variants) / sizeof(variants[0]) - 1)];
+        } else {
+            value = variants[asn_random_between(
+                0, sizeof(variants) / sizeof(variants[0]) - 1)];
+        }
+
+        if(!constraints) constraints = &td->encoding_constraints;
+        ct = constraints ? constraints->per_constraints : 0;
+        if(ct && (ct->value.flags & APC_CONSTRAINED)) {
+            if(value < ct->value.lower_bound || value > ct->value.upper_bound) {
+                value = asn_random_between(ct->value.lower_bound,
+                                           ct->value.upper_bound);
+            }
+        }
+    }
+
+    if(asn_imax2INTEGER(st, value)) {
+        if(st == *sptr) {
+            ASN_STRUCT_RESET(*td, st);
+        } else {
+            ASN_STRUCT_FREE(*td, st);
+        }
+        return result_failed;
+    } else {
+        *sptr = st;
+        result_ok.length = st->size;
+        return result_ok;
+    }
+}
diff --git a/libs/smux/INTEGER_oer.c b/libs/smux/INTEGER_oer.c
new file mode 100644 (file)
index 0000000..5c98d3e
--- /dev/null
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_DISABLE_OER_SUPPORT
+
+#include <asn_internal.h>
+#include <INTEGER.h>
+#include <errno.h>
+
+asn_dec_rval_t
+INTEGER_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
+                   const asn_TYPE_descriptor_t *td,
+                   const asn_oer_constraints_t *constraints, void **sptr,
+                   const void *ptr, size_t size) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_dec_rval_t rval = {RC_OK, 0};
+    INTEGER_t *st = (INTEGER_t *)*sptr;
+    struct asn_oer_constraint_number_s ct = {0, 0};
+    size_t req_bytes;
+
+    (void)opt_codec_ctx;
+    (void)specs;
+
+    if(!st) {
+        st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st)));
+        if(!st) ASN__DECODE_FAILED;
+    }
+
+    FREEMEM(st->buf);
+    st->buf = 0;
+    st->size = 0;
+
+    if(!constraints) constraints = td->encoding_constraints.oer_constraints;
+    if(constraints) ct = constraints->value;
+
+    if(ct.width) {
+        req_bytes = ct.width;
+    } else {
+        /* No lower bound and no upper bound, effectively */
+
+        ssize_t consumed = oer_fetch_length(ptr, size, &req_bytes);
+        if(consumed == 0) {
+            ASN__DECODE_STARVED;
+        } else if(consumed == -1) {
+            ASN__DECODE_FAILED;
+        }
+        rval.consumed += consumed;
+        ptr = (const char *)ptr + consumed;
+        size -= consumed;
+    }
+
+    if(req_bytes > size) {
+        ASN__DECODE_STARVED;
+    }
+
+    if(ct.positive) {
+        /* X.969 08/2015 10.2(a) */
+        unsigned msb;   /* Most significant bit */
+        size_t useful_size;
+
+        /* Check most significant bit */
+        msb = *(const uint8_t *)ptr >> 7; /* yields 0 or 1 */
+        useful_size = msb + req_bytes;
+        st->buf = (uint8_t *)MALLOC(useful_size + 1);
+        if(!st->buf) {
+            ASN__DECODE_FAILED;
+        }
+
+        /*
+         * Record a large unsigned in a way not to confuse it
+         * with signed value.
+         */
+        st->buf[0] = '\0';
+        memcpy(st->buf + msb, ptr, req_bytes);
+        st->buf[useful_size] = '\0';    /* Just in case, 0-terminate */
+        st->size = useful_size;
+
+        rval.consumed += req_bytes;
+        return rval;
+    } else {
+        /* X.969 08/2015 10.2(b) */
+        st->buf = (uint8_t *)MALLOC(req_bytes + 1);
+        if(!st->buf) {
+            ASN__DECODE_FAILED;
+        }
+
+        memcpy(st->buf, ptr, req_bytes);
+        st->buf[req_bytes] = '\0'; /* Just in case, 0-terminate */
+        st->size = req_bytes;
+
+        rval.consumed += req_bytes;
+        return rval;
+    }
+}
+
+/*
+ * Encode as Canonical OER.
+ */
+asn_enc_rval_t
+INTEGER_encode_oer(const asn_TYPE_descriptor_t *td,
+                   const asn_oer_constraints_t *constraints, const void *sptr,
+                   asn_app_consume_bytes_f *cb, void *app_key) {
+    const INTEGER_t *st = sptr;
+    asn_enc_rval_t er;
+    struct asn_oer_constraint_number_s ct = {0, 0};
+    const uint8_t *buf;
+    const uint8_t *end;
+    size_t useful_bytes;
+    size_t req_bytes = 0;
+    int sign = 0;
+
+    if(!st || st->size == 0) ASN__ENCODE_FAILED;
+
+    if(!constraints) constraints = td->encoding_constraints.oer_constraints;
+    if(constraints) ct = constraints->value;
+
+    er.encoded = 0;
+
+    buf = st->buf;
+    end = buf + st->size;
+
+    sign = (buf && buf < end) ? buf[0] & 0x80 : 0;
+
+    /* Ignore 9 leading zeroes or ones */
+    if(ct.positive) {
+        if(sign) {
+            /* The value given is a signed value. Can't proceed. */
+            ASN__ENCODE_FAILED;
+        }
+        /* Remove leading zeros. */
+        for(; buf + 1 < end; buf++) {
+            if(buf[0] != 0x0) break;
+        }
+    } else {
+        for(; buf + 1 < end; buf++) {
+            if(buf[0] == 0x0 && (buf[1] & 0x80) == 0) {
+                continue;
+            } else if(buf[0] == 0xff && (buf[1] & 0x80) != 0) {
+                continue;
+            }
+            break;
+        }
+    }
+
+    useful_bytes = end - buf;
+    if(ct.width) {
+        req_bytes = ct.width;
+    } else {
+        ssize_t r = oer_serialize_length(useful_bytes, cb, app_key);
+        if(r < 0) {
+            ASN__ENCODE_FAILED;
+        }
+        er.encoded += r;
+        req_bytes = useful_bytes;
+    }
+
+    if(req_bytes < useful_bytes) {
+        ASN__ENCODE_FAILED;
+    }
+
+    er.encoded += req_bytes;
+
+    for(; req_bytes > useful_bytes; req_bytes--) {
+        if(cb(sign?"\xff":"\0", 1, app_key) < 0) {
+            ASN__ENCODE_FAILED;
+        }
+    }
+
+    if(cb(buf, useful_bytes, app_key) < 0) {
+        ASN__ENCODE_FAILED;
+    }
+
+    ASN__ENCODED_OK(er);
+}
+
+#endif  /* ASN_DISABLE_OER_SUPPORT */
index ad2e29d9c2b786d6409e32889dcdb2a135e8a833..85806373019a462590b42aba92395e944e1362b9 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "IfEntry.h"
  */
 
 #include "IfEntry.h"
@@ -12,198 +12,198 @@ static asn_TYPE_member_t asn_MBR_IfEntry_1[] = {
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifIndex"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifDescr),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_DisplayString,
                "ifIndex"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifDescr),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_DisplayString,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifDescr"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifType),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ifDescr"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifType),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifType"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifMtu),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ifType"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifMtu),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifMtu"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifSpeed),
                (ASN_TAG_CLASS_APPLICATION | (2 << 2)),
                0,
                &asn_DEF_Gauge,
                "ifMtu"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifSpeed),
                (ASN_TAG_CLASS_APPLICATION | (2 << 2)),
                0,
                &asn_DEF_Gauge,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifSpeed"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifPhysAddress),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_PhysAddress,
                "ifSpeed"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifPhysAddress),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_PhysAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifPhysAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifAdminStatus),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ifPhysAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifAdminStatus),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifAdminStatus"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOperStatus),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ifAdminStatus"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOperStatus),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifOperStatus"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifLastChange),
                (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
                0,
                &asn_DEF_TimeTicks,
                "ifOperStatus"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifLastChange),
                (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
                0,
                &asn_DEF_TimeTicks,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifLastChange"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInOctets),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifLastChange"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInOctets),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifInOctets"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInUcastPkts),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifInOctets"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInUcastPkts),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifInUcastPkts"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInNUcastPkts),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifInUcastPkts"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInNUcastPkts),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifInNUcastPkts"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInDiscards),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifInNUcastPkts"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInDiscards),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifInDiscards"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInErrors),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifInDiscards"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInErrors),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifInErrors"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInUnknownProtos),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifInErrors"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifInUnknownProtos),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifInUnknownProtos"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutOctets),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifInUnknownProtos"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutOctets),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifOutOctets"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutUcastPkts),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifOutOctets"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutUcastPkts),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifOutUcastPkts"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutNUcastPkts),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifOutUcastPkts"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutNUcastPkts),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifOutNUcastPkts"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutDiscards),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifOutNUcastPkts"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutDiscards),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifOutDiscards"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutErrors),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
                "ifOutDiscards"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutErrors),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_Counter,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifOutErrors"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutQLen),
                (ASN_TAG_CLASS_APPLICATION | (2 << 2)),
                0,
                &asn_DEF_Gauge,
                "ifOutErrors"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifOutQLen),
                (ASN_TAG_CLASS_APPLICATION | (2 << 2)),
                0,
                &asn_DEF_Gauge,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifOutQLen"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifSpecific),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_OBJECT_IDENTIFIER,
                "ifOutQLen"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IfEntry, ifSpecific),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_OBJECT_IDENTIFIER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ifSpecific"
                },
 };
                "ifSpecific"
                },
 };
@@ -240,28 +240,19 @@ static asn_SEQUENCE_specifics_t asn_SPC_IfEntry_specs_1 = {
        asn_MAP_IfEntry_tag2el_1,
        22,     /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        asn_MAP_IfEntry_tag2el_1,
        22,     /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_IfEntry = {
        "IfEntry",
        "IfEntry",
 };
 asn_TYPE_descriptor_t asn_DEF_IfEntry = {
        "IfEntry",
        "IfEntry",
-       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_OP_SEQUENCE,
        asn_DEF_IfEntry_tags_1,
        sizeof(asn_DEF_IfEntry_tags_1)
                /sizeof(asn_DEF_IfEntry_tags_1[0]), /* 1 */
        asn_DEF_IfEntry_tags_1, /* Same as above */
        sizeof(asn_DEF_IfEntry_tags_1)
                /sizeof(asn_DEF_IfEntry_tags_1[0]), /* 1 */
        asn_DEF_IfEntry_tags_1,
        sizeof(asn_DEF_IfEntry_tags_1)
                /sizeof(asn_DEF_IfEntry_tags_1[0]), /* 1 */
        asn_DEF_IfEntry_tags_1, /* Same as above */
        sizeof(asn_DEF_IfEntry_tags_1)
                /sizeof(asn_DEF_IfEntry_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_IfEntry_1,
        22,     /* Elements count */
        &asn_SPC_IfEntry_specs_1        /* Additional specs */
        asn_MBR_IfEntry_1,
        22,     /* Elements count */
        &asn_SPC_IfEntry_specs_1        /* Additional specs */
index bccd1550a647580485ff98178c9b368f107bbc07..22f8b8d5ae70765dfeb44f054c7faf671d4e3f71 100644 (file)
@@ -1,14 +1,14 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "IpAddrEntry.h"
 
 static int
  */
 
 #include "IpAddrEntry.h"
 
 static int
-memb_ipAdEntReasmMaxSize_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_ipAdEntReasmMaxSize_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        long value;
        
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        long value;
        
@@ -32,50 +32,58 @@ memb_ipAdEntReasmMaxSize_constraint_1(asn_TYPE_descriptor_t *td, const void *spt
        }
 }
 
        }
 }
 
+static asn_oer_constraints_t asn_OER_memb_ipAdEntReasmMaxSize_constr_6 CC_NOTUSED = {
+       { 2, 1 }        /* (0..65535) */,
+       -1};
+static asn_per_constraints_t asn_PER_memb_ipAdEntReasmMaxSize_constr_6 CC_NOTUSED = {
+       { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
 static asn_TYPE_member_t asn_MBR_IpAddrEntry_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntAddr),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
 static asn_TYPE_member_t asn_MBR_IpAddrEntry_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntAddr),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipAdEntAddr"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntIfIndex),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipAdEntAddr"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntIfIndex),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipAdEntIfIndex"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntNetMask),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
                "ipAdEntIfIndex"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntNetMask),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipAdEntNetMask"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntBcastAddr),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipAdEntNetMask"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntBcastAddr),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipAdEntBcastAddr"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntReasmMaxSize),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_NativeInteger,
                "ipAdEntBcastAddr"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpAddrEntry, ipAdEntReasmMaxSize),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_NativeInteger,
-               memb_ipAdEntReasmMaxSize_constraint_1,
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { &asn_OER_memb_ipAdEntReasmMaxSize_constr_6, &asn_PER_memb_ipAdEntReasmMaxSize_constr_6,  memb_ipAdEntReasmMaxSize_constraint_1 },
+               0, 0, /* No default value */
                "ipAdEntReasmMaxSize"
                },
 };
                "ipAdEntReasmMaxSize"
                },
 };
@@ -95,28 +103,19 @@ static asn_SEQUENCE_specifics_t asn_SPC_IpAddrEntry_specs_1 = {
        asn_MAP_IpAddrEntry_tag2el_1,
        5,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        asn_MAP_IpAddrEntry_tag2el_1,
        5,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_IpAddrEntry = {
        "IpAddrEntry",
        "IpAddrEntry",
 };
 asn_TYPE_descriptor_t asn_DEF_IpAddrEntry = {
        "IpAddrEntry",
        "IpAddrEntry",
-       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_OP_SEQUENCE,
        asn_DEF_IpAddrEntry_tags_1,
        sizeof(asn_DEF_IpAddrEntry_tags_1)
                /sizeof(asn_DEF_IpAddrEntry_tags_1[0]), /* 1 */
        asn_DEF_IpAddrEntry_tags_1,     /* Same as above */
        sizeof(asn_DEF_IpAddrEntry_tags_1)
                /sizeof(asn_DEF_IpAddrEntry_tags_1[0]), /* 1 */
        asn_DEF_IpAddrEntry_tags_1,
        sizeof(asn_DEF_IpAddrEntry_tags_1)
                /sizeof(asn_DEF_IpAddrEntry_tags_1[0]), /* 1 */
        asn_DEF_IpAddrEntry_tags_1,     /* Same as above */
        sizeof(asn_DEF_IpAddrEntry_tags_1)
                /sizeof(asn_DEF_IpAddrEntry_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_IpAddrEntry_1,
        5,      /* Elements count */
        &asn_SPC_IpAddrEntry_specs_1    /* Additional specs */
        asn_MBR_IpAddrEntry_1,
        5,      /* Elements count */
        &asn_SPC_IpAddrEntry_specs_1    /* Additional specs */
index 2eaebf9b2cf99e2952f17d54dbd2cad82e94a9e2..7eec1b5cdf3229345047c935281c485af34a5228 100644 (file)
@@ -1,14 +1,14 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "IpAddress.h"
 
 int
  */
 
 #include "IpAddress.h"
 
 int
-IpAddress_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+IpAddress_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
        size_t size;
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
        size_t size;
@@ -37,68 +37,14 @@ IpAddress_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * This type is implemented using OCTET_STRING,
  * so here we adjust the DEF accordingly.
  */
  * This type is implemented using OCTET_STRING,
  * so here we adjust the DEF accordingly.
  */
-static void
-IpAddress_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
-       td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
-       td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
-       td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
-       td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
-       td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
-       td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
-       td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
-       td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
-       td->elements       = asn_DEF_OCTET_STRING.elements;
-       td->elements_count = asn_DEF_OCTET_STRING.elements_count;
-       td->specifics      = asn_DEF_OCTET_STRING.specifics;
-}
-
-void
-IpAddress_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       IpAddress_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-IpAddress_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       IpAddress_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-IpAddress_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) {
-       IpAddress_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-IpAddress_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) {
-       IpAddress_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-IpAddress_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) {
-       IpAddress_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-IpAddress_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) {
-       IpAddress_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
+static asn_oer_constraints_t asn_OER_type_IpAddress_constr_1 CC_NOTUSED = {
+       { 0, 0 },
+       4       /* (SIZE(4..4)) */};
+asn_per_constraints_t asn_PER_type_IpAddress_constr_1 CC_NOTUSED = {
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       { APC_CONSTRAINED,       0,  0,  4,  4 }        /* (SIZE(4..4)) */,
+       0, 0    /* No PER value map */
+};
 static const ber_tlv_tag_t asn_DEF_IpAddress_tags_1[] = {
        (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
 static const ber_tlv_tag_t asn_DEF_IpAddress_tags_1[] = {
        (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
@@ -106,23 +52,15 @@ static const ber_tlv_tag_t asn_DEF_IpAddress_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_IpAddress = {
        "IpAddress",
        "IpAddress",
 asn_TYPE_descriptor_t asn_DEF_IpAddress = {
        "IpAddress",
        "IpAddress",
-       IpAddress_free,
-       IpAddress_print,
-       IpAddress_constraint,
-       IpAddress_decode_ber,
-       IpAddress_encode_der,
-       IpAddress_decode_xer,
-       IpAddress_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_OCTET_STRING,
        asn_DEF_IpAddress_tags_1,
        sizeof(asn_DEF_IpAddress_tags_1)
                /sizeof(asn_DEF_IpAddress_tags_1[0]) - 1, /* 1 */
        asn_DEF_IpAddress_tags_1,       /* Same as above */
        sizeof(asn_DEF_IpAddress_tags_1)
                /sizeof(asn_DEF_IpAddress_tags_1[0]), /* 2 */
        asn_DEF_IpAddress_tags_1,
        sizeof(asn_DEF_IpAddress_tags_1)
                /sizeof(asn_DEF_IpAddress_tags_1[0]) - 1, /* 1 */
        asn_DEF_IpAddress_tags_1,       /* Same as above */
        sizeof(asn_DEF_IpAddress_tags_1)
                /sizeof(asn_DEF_IpAddress_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_IpAddress_constr_1, &asn_PER_type_IpAddress_constr_1, IpAddress_constraint },
        0, 0,   /* No members */
        0, 0,   /* No members */
-       0       /* No specifics */
+       &asn_SPC_OCTET_STRING_specs     /* Additional specs */
 };
 
 };
 
index ce6aa6d29312299b9212afb22ec327467a29c0cb..6c19cde6534e802fddde8e7e943ab9301f3f4cf2 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "IpNetToMediaEntry.h"
  */
 
 #include "IpNetToMediaEntry.h"
@@ -12,36 +12,36 @@ static asn_TYPE_member_t asn_MBR_IpNetToMediaEntry_1[] = {
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipNetToMediaIfIndex"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpNetToMediaEntry, ipNetToMediaPhysAddress),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_PhysAddress,
                "ipNetToMediaIfIndex"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpNetToMediaEntry, ipNetToMediaPhysAddress),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_PhysAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipNetToMediaPhysAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpNetToMediaEntry, ipNetToMediaNetAddress),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
                "ipNetToMediaPhysAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpNetToMediaEntry, ipNetToMediaNetAddress),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipNetToMediaNetAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpNetToMediaEntry, ipNetToMediaType),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipNetToMediaNetAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpNetToMediaEntry, ipNetToMediaType),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipNetToMediaType"
                },
 };
                "ipNetToMediaType"
                },
 };
@@ -60,28 +60,19 @@ static asn_SEQUENCE_specifics_t asn_SPC_IpNetToMediaEntry_specs_1 = {
        asn_MAP_IpNetToMediaEntry_tag2el_1,
        4,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        asn_MAP_IpNetToMediaEntry_tag2el_1,
        4,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_IpNetToMediaEntry = {
        "IpNetToMediaEntry",
        "IpNetToMediaEntry",
 };
 asn_TYPE_descriptor_t asn_DEF_IpNetToMediaEntry = {
        "IpNetToMediaEntry",
        "IpNetToMediaEntry",
-       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_OP_SEQUENCE,
        asn_DEF_IpNetToMediaEntry_tags_1,
        sizeof(asn_DEF_IpNetToMediaEntry_tags_1)
                /sizeof(asn_DEF_IpNetToMediaEntry_tags_1[0]), /* 1 */
        asn_DEF_IpNetToMediaEntry_tags_1,       /* Same as above */
        sizeof(asn_DEF_IpNetToMediaEntry_tags_1)
                /sizeof(asn_DEF_IpNetToMediaEntry_tags_1[0]), /* 1 */
        asn_DEF_IpNetToMediaEntry_tags_1,
        sizeof(asn_DEF_IpNetToMediaEntry_tags_1)
                /sizeof(asn_DEF_IpNetToMediaEntry_tags_1[0]), /* 1 */
        asn_DEF_IpNetToMediaEntry_tags_1,       /* Same as above */
        sizeof(asn_DEF_IpNetToMediaEntry_tags_1)
                /sizeof(asn_DEF_IpNetToMediaEntry_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_IpNetToMediaEntry_1,
        4,      /* Elements count */
        &asn_SPC_IpNetToMediaEntry_specs_1      /* Additional specs */
        asn_MBR_IpNetToMediaEntry_1,
        4,      /* Elements count */
        &asn_SPC_IpNetToMediaEntry_specs_1      /* Additional specs */
index 5ee104ea97a978d4d00864818ea7235ae91f88a5..c0b54fe88f74ada6134872b9150c53452a3c8f5a 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "IpRouteEntry.h"
  */
 
 #include "IpRouteEntry.h"
@@ -12,117 +12,117 @@ static asn_TYPE_member_t asn_MBR_IpRouteEntry_1[] = {
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteDest"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteIfIndex),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipRouteDest"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteIfIndex),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteIfIndex"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric1),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipRouteIfIndex"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric1),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteMetric1"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric2),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipRouteMetric1"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric2),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteMetric2"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric3),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipRouteMetric2"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric3),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteMetric3"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric4),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipRouteMetric3"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric4),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteMetric4"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteNextHop),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
                "ipRouteMetric4"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteNextHop),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteNextHop"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteType),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipRouteNextHop"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteType),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteType"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteProto),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipRouteType"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteProto),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteProto"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteAge),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipRouteProto"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteAge),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteAge"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMask),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
                "ipRouteAge"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMask),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteMask"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric5),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "ipRouteMask"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteMetric5),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteMetric5"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteInfo),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_OBJECT_IDENTIFIER,
                "ipRouteMetric5"
                },
        { ATF_NOFLAGS, 0, offsetof(struct IpRouteEntry, ipRouteInfo),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_OBJECT_IDENTIFIER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "ipRouteInfo"
                },
 };
                "ipRouteInfo"
                },
 };
@@ -150,28 +150,19 @@ static asn_SEQUENCE_specifics_t asn_SPC_IpRouteEntry_specs_1 = {
        asn_MAP_IpRouteEntry_tag2el_1,
        13,     /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        asn_MAP_IpRouteEntry_tag2el_1,
        13,     /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_IpRouteEntry = {
        "IpRouteEntry",
        "IpRouteEntry",
 };
 asn_TYPE_descriptor_t asn_DEF_IpRouteEntry = {
        "IpRouteEntry",
        "IpRouteEntry",
-       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_OP_SEQUENCE,
        asn_DEF_IpRouteEntry_tags_1,
        sizeof(asn_DEF_IpRouteEntry_tags_1)
                /sizeof(asn_DEF_IpRouteEntry_tags_1[0]), /* 1 */
        asn_DEF_IpRouteEntry_tags_1,    /* Same as above */
        sizeof(asn_DEF_IpRouteEntry_tags_1)
                /sizeof(asn_DEF_IpRouteEntry_tags_1[0]), /* 1 */
        asn_DEF_IpRouteEntry_tags_1,
        sizeof(asn_DEF_IpRouteEntry_tags_1)
                /sizeof(asn_DEF_IpRouteEntry_tags_1[0]), /* 1 */
        asn_DEF_IpRouteEntry_tags_1,    /* Same as above */
        sizeof(asn_DEF_IpRouteEntry_tags_1)
                /sizeof(asn_DEF_IpRouteEntry_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_IpRouteEntry_1,
        13,     /* Elements count */
        &asn_SPC_IpRouteEntry_specs_1   /* Additional specs */
        asn_MBR_IpRouteEntry_1,
        13,     /* Elements count */
        &asn_SPC_IpRouteEntry_specs_1   /* Additional specs */
index 27ed3a2a36445a75dbd7276fcf1cf0f3d96ab49e..126eb1d90ccb5526a730439416b6083c0abe18b5 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "Message.h"
  */
 
 #include "Message.h"
@@ -12,27 +12,27 @@ static asn_TYPE_member_t asn_MBR_Message_1[] = {
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "version"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Message, community),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_OCTET_STRING,
                "version"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Message, community),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_OCTET_STRING,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "community"
                },
                "community"
                },
-       { ATF_OPEN_TYPE | ATF_NOFLAGS, 0, offsetof(struct Message, data),
+       { ATF_ANY_TYPE | ATF_NOFLAGS, 0, offsetof(struct Message, data),
                -1 /* Ambiguous tag (ANY?) */,
                0,
                &asn_DEF_ANY,
                -1 /* Ambiguous tag (ANY?) */,
                0,
                &asn_DEF_ANY,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "data"
                },
 };
                "data"
                },
 };
@@ -49,28 +49,19 @@ static asn_SEQUENCE_specifics_t asn_SPC_Message_specs_1 = {
        asn_MAP_Message_tag2el_1,
        2,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        asn_MAP_Message_tag2el_1,
        2,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_Message = {
        "Message",
        "Message",
 };
 asn_TYPE_descriptor_t asn_DEF_Message = {
        "Message",
        "Message",
-       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_OP_SEQUENCE,
        asn_DEF_Message_tags_1,
        sizeof(asn_DEF_Message_tags_1)
                /sizeof(asn_DEF_Message_tags_1[0]), /* 1 */
        asn_DEF_Message_tags_1, /* Same as above */
        sizeof(asn_DEF_Message_tags_1)
                /sizeof(asn_DEF_Message_tags_1[0]), /* 1 */
        asn_DEF_Message_tags_1,
        sizeof(asn_DEF_Message_tags_1)
                /sizeof(asn_DEF_Message_tags_1[0]), /* 1 */
        asn_DEF_Message_tags_1, /* Same as above */
        sizeof(asn_DEF_Message_tags_1)
                /sizeof(asn_DEF_Message_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_Message_1,
        3,      /* Elements count */
        &asn_SPC_Message_specs_1        /* Additional specs */
        asn_MBR_Message_1,
        3,      /* Elements count */
        &asn_SPC_Message_specs_1        /* Additional specs */
index 62bc91e05081c223d48d9713314ae95b79152715..076898e02b46e0a66e0ee8d1e32873a4d43c97e0 100644 (file)
@@ -5,7 +5,6 @@
 #include <asn_internal.h>
 #include <asn_codecs_prim.h>
 #include <NULL.h>
 #include <asn_internal.h>
 #include <asn_codecs_prim.h>
 #include <NULL.h>
-#include <BOOLEAN.h>   /* Implemented in terms of BOOLEAN type */
 
 /*
  * NULL basic type description.
 
 /*
  * NULL basic type description.
 static const ber_tlv_tag_t asn_DEF_NULL_tags[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (5 << 2))
 };
 static const ber_tlv_tag_t asn_DEF_NULL_tags[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (5 << 2))
 };
-asn_TYPE_descriptor_t asn_DEF_NULL = {
-       "NULL",
-       "NULL",
-       BOOLEAN_free,
+asn_TYPE_operation_t asn_OP_NULL = {
+       NULL_free,
        NULL_print,
        NULL_print,
-       asn_generic_no_constraint,
-       BOOLEAN_decode_ber,     /* Implemented in terms of BOOLEAN */
+       NULL_compare,
+       NULL_decode_ber,
        NULL_encode_der,        /* Special handling of DER encoding */
        NULL_decode_xer,
        NULL_encode_xer,
        NULL_encode_der,        /* Special handling of DER encoding */
        NULL_decode_xer,
        NULL_encode_xer,
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       NULL_decode_oer,
+       NULL_encode_oer,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
        NULL_decode_uper,       /* Unaligned PER decoder */
        NULL_encode_uper,       /* Unaligned PER encoder */
        NULL_decode_uper,       /* Unaligned PER decoder */
        NULL_encode_uper,       /* Unaligned PER encoder */
-       0, /* Use generic outmost tag fetcher */
+#endif /* ASN_DISABLE_PER_SUPPORT */
+       NULL_random_fill,
+       0       /* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_NULL = {
+       "NULL",
+       "NULL",
+       &asn_OP_NULL,
        asn_DEF_NULL_tags,
        sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
        asn_DEF_NULL_tags,      /* Same as above */
        sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
        asn_DEF_NULL_tags,
        sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
        asn_DEF_NULL_tags,      /* Same as above */
        sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
-       0,      /* No PER visible constraints */
+       { 0, 0, asn_generic_no_constraint },
        0, 0,   /* No members */
        0       /* No specifics */
 };
 
        0, 0,   /* No members */
        0       /* No specifics */
 };
 
+void
+NULL_free(const asn_TYPE_descriptor_t *td, void *ptr,
+          enum asn_struct_free_method method) {
+    if(td && ptr) {
+        switch(method) {
+        case ASFM_FREE_EVERYTHING:
+            FREEMEM(ptr);
+            break;
+        case ASFM_FREE_UNDERLYING:
+            break;
+        case ASFM_FREE_UNDERLYING_AND_RESET:
+            memset(ptr, 0, sizeof(NULL_t));
+            break;
+        }
+    }
+}
+
+/*
+ * Decode NULL type.
+ */
+asn_dec_rval_t
+NULL_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
+                const asn_TYPE_descriptor_t *td, void **bool_value,
+                const void *buf_ptr, size_t size, int tag_mode) {
+    NULL_t *st = (NULL_t *)*bool_value;
+    asn_dec_rval_t rval;
+    ber_tlv_len_t length;
+
+    if(st == NULL) {
+        st = (NULL_t *)(*bool_value = CALLOC(1, sizeof(*st)));
+        if(st == NULL) {
+            rval.code = RC_FAIL;
+            rval.consumed = 0;
+            return rval;
+        }
+    }
+
+    ASN_DEBUG("Decoding %s as NULL (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;
+    }
+
+    // X.690-201508, #8.8.2, length shall be zero.
+    if(length != 0) {
+        ASN_DEBUG("Decoding %s as NULL failed: too much data", td->name);
+        rval.code = RC_FAIL;
+        rval.consumed = 0;
+        return rval;
+    }
+
+    return rval;
+}
+
 asn_enc_rval_t
 asn_enc_rval_t
-NULL_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
-       int tag_mode, ber_tlv_tag_t tag,
-       asn_app_consume_bytes_f *cb, void *app_key) {
-       asn_enc_rval_t erval;
+NULL_encode_der(const asn_TYPE_descriptor_t *td, const void *ptr, int tag_mode,
+                ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_enc_rval_t erval;
 
        erval.encoded = der_write_tags(td, 0, tag_mode, 0, tag, cb, app_key);
        if(erval.encoded == -1) {
 
        erval.encoded = der_write_tags(td, 0, tag_mode, 0, tag, cb, app_key);
        if(erval.encoded == -1) {
@@ -51,10 +124,10 @@ NULL_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
 }
 
 asn_enc_rval_t
 }
 
 asn_enc_rval_t
-NULL_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;
+NULL_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+                enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
+                void *app_key) {
+    asn_enc_rval_t er;
 
        (void)td;
        (void)sptr;
 
        (void)td;
        (void)sptr;
@@ -70,8 +143,9 @@ NULL_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 
 
 static enum xer_pbd_rval
 
 
 static enum xer_pbd_rval
-NULL__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
-       (void)td;
+NULL__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
+                      const void *chunk_buf, size_t chunk_size) {
+    (void)td;
        (void)sptr;
        (void)chunk_buf;    /* Going to be empty according to the rules below. */
 
        (void)sptr;
        (void)chunk_buf;    /* Going to be empty according to the rules below. */
 
@@ -85,20 +159,26 @@ NULL__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_b
 }
 
 asn_dec_rval_t
 }
 
 asn_dec_rval_t
-NULL_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,
+NULL_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
+                const 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(NULL_t), opt_mname, buf_ptr, size,
                NULL__xer_body_decode);
 }
 
 int
                sptr, sizeof(NULL_t), opt_mname, buf_ptr, size,
                NULL__xer_body_decode);
 }
 
 int
-NULL_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
-       asn_app_consume_bytes_f *cb, void *app_key) {
+NULL_compare(const asn_TYPE_descriptor_t *td, const void *a, const void *b) {
+    (void)td;
+    (void)a;
+    (void)b;
+    return 0;
+}
 
 
-       (void)td;       /* Unused argument */
+int
+NULL_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+           asn_app_consume_bytes_f *cb, void *app_key) {
+    (void)td;  /* Unused argument */
        (void)ilevel;   /* Unused argument */
 
        if(sptr) {
        (void)ilevel;   /* Unused argument */
 
        if(sptr) {
@@ -108,10 +188,59 @@ NULL_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
        }
 }
 
        }
 }
 
+#ifndef ASN_DISABLE_OER_SUPPORT
+
+asn_dec_rval_t
+NULL_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
+                const asn_TYPE_descriptor_t *td,
+                const asn_oer_constraints_t *constraints, void **sptr,
+                const void *ptr, size_t size) {
+    asn_dec_rval_t rv = {RC_OK, 0};
+    (void)opt_codec_ctx;
+    (void)td;
+    (void)constraints;
+    (void)ptr;
+    (void)size;
+
+    if(!*sptr) {
+        *sptr = MALLOC(sizeof(NULL_t));
+        if(*sptr) {
+            *(NULL_t *)*sptr = 0;
+        } else {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    return rv;
+}
+
+asn_enc_rval_t
+NULL_encode_oer(const asn_TYPE_descriptor_t *td,
+                const asn_oer_constraints_t *constraints, const void *sptr,
+                asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_enc_rval_t er;
+
+    (void)td;
+    (void)sptr;
+    (void)constraints;
+    (void)cb;
+    (void)app_key;
+
+    er.encoded = 0; /* Encoding in 0 bytes. */
+
+    ASN__ENCODED_OK(er);
+}
+
+#endif /* ASN_DISABLE_OER_SUPPORT */
+
+#ifndef ASN_DISABLE_PER_SUPPORT
+
 asn_dec_rval_t
 asn_dec_rval_t
-NULL_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_dec_rval_t rv;
+NULL_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                 const asn_TYPE_descriptor_t *td,
+                 const asn_per_constraints_t *constraints, void **sptr,
+                 asn_per_data_t *pd) {
+    asn_dec_rval_t rv;
 
        (void)opt_codec_ctx;
        (void)td;
 
        (void)opt_codec_ctx;
        (void)td;
@@ -137,9 +266,10 @@ NULL_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 }
 
 asn_enc_rval_t
 }
 
 asn_enc_rval_t
-NULL_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
-               void *sptr, asn_per_outp_t *po) {
-       asn_enc_rval_t er;
+NULL_encode_uper(const asn_TYPE_descriptor_t *td,
+                 const asn_per_constraints_t *constraints, const void *sptr,
+                 asn_per_outp_t *po) {
+    asn_enc_rval_t er;
 
        (void)td;
        (void)constraints;
 
        (void)td;
        (void)constraints;
@@ -149,3 +279,30 @@ NULL_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
        er.encoded = 0;
        ASN__ENCODED_OK(er);
 }
        er.encoded = 0;
        ASN__ENCODED_OK(er);
 }
+
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
+asn_random_fill_result_t
+NULL_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                    const asn_encoding_constraints_t *constr,
+                    size_t max_length) {
+    asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    NULL_t *st = *sptr;
+
+    (void)td;
+    (void)constr;
+
+    if(max_length == 0) return result_skipped;
+
+    if(st == NULL) {
+        st = (NULL_t *)(*sptr = CALLOC(1, sizeof(*st)));
+        if(st == NULL) {
+            return result_failed;
+        }
+    }
+
+    return result_ok;
+}
+
diff --git a/libs/smux/NativeEnumerated.c b/libs/smux/NativeEnumerated.c
deleted file mode 100644 (file)
index 78366af..0000000
+++ /dev/null
@@ -1,207 +0,0 @@
-/*-
- * 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 const 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;
-       const 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);
-}
-
index e8ce6d2c33c1d8ad458fadf9499314a50d1979b6..d6b73940a9f4884a0e910d52ab2375961da0961f 100644 (file)
 static const ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 };
 static const 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",
+asn_TYPE_operation_t asn_OP_NativeInteger = {
        NativeInteger_free,
        NativeInteger_print,
        NativeInteger_free,
        NativeInteger_print,
-       asn_generic_no_constraint,
+       NativeInteger_compare,
        NativeInteger_decode_ber,
        NativeInteger_encode_der,
        NativeInteger_decode_xer,
        NativeInteger_encode_xer,
        NativeInteger_decode_ber,
        NativeInteger_encode_der,
        NativeInteger_decode_xer,
        NativeInteger_encode_xer,
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       NativeInteger_decode_oer,       /* OER decoder */
+       NativeInteger_encode_oer,       /* Canonical OER encoder */
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
        NativeInteger_decode_uper,      /* Unaligned PER decoder */
        NativeInteger_encode_uper,      /* Unaligned PER encoder */
        NativeInteger_decode_uper,      /* Unaligned PER decoder */
        NativeInteger_encode_uper,      /* Unaligned PER encoder */
-       0, /* Use generic outmost tag fetcher */
+#endif /* ASN_DISABLE_PER_SUPPORT */
+       NativeInteger_random_fill,
+       0       /* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_NativeInteger = {
+       "INTEGER",                      /* The ASN.1 type is still INTEGER */
+       "INTEGER",
+       &asn_OP_NativeInteger,
        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]),
        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, asn_generic_no_constraint },
        0, 0,   /* No members */
        0       /* No specifics */
 };
        0, 0,   /* No members */
        0       /* No specifics */
 };
@@ -45,11 +61,12 @@ asn_TYPE_descriptor_t asn_DEF_NativeInteger = {
  * Decode INTEGER type.
  */
 asn_dec_rval_t
  * 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;
+NativeInteger_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
+                         const asn_TYPE_descriptor_t *td, void **nint_ptr,
+                         const void *buf_ptr, size_t size, int tag_mode) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    long *native = (long *)*nint_ptr;
        asn_dec_rval_t rval;
        ber_tlv_len_t length;
 
        asn_dec_rval_t rval;
        ber_tlv_len_t length;
 
@@ -92,7 +109,7 @@ NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
        /*
         * ASN.1 encoded INTEGER: buf_ptr, length
         * Fill the native, at the same time checking for overflow.
        /*
         * ASN.1 encoded INTEGER: buf_ptr, length
         * Fill the native, at the same time checking for overflow.
-        * If overflow occured, return with RC_FAIL.
+        * If overflow occurred, return with RC_FAIL.
         */
        {
                INTEGER_t tmp;
         */
        {
                INTEGER_t tmp;
@@ -130,11 +147,11 @@ NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
  * Encode the NativeInteger using the standard INTEGER type DER encoder.
  */
 asn_enc_rval_t
  * 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;
+NativeInteger_encode_der(const asn_TYPE_descriptor_t *sd, const void *ptr,
+                         int tag_mode, ber_tlv_tag_t tag,
+                         asn_app_consume_bytes_f *cb, void *app_key) {
+    unsigned long native = *(const unsigned long *)ptr; /* Disable sign ext. */
+    asn_enc_rval_t erval;
        INTEGER_t tmp;
 
 #ifdef WORDS_BIGENDIAN         /* Opportunistic optimization */
        INTEGER_t tmp;
 
 #ifdef WORDS_BIGENDIAN         /* Opportunistic optimization */
@@ -156,10 +173,9 @@ NativeInteger_encode_der(asn_TYPE_descriptor_t *sd, void *ptr,
        
        /* Encode fake INTEGER */
        erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key);
        
        /* 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;
-       }
+    if(erval.structure_ptr == &tmp) {
+        erval.structure_ptr = ptr;
+    }
        return erval;
 }
 
        return erval;
 }
 
@@ -167,11 +183,13 @@ NativeInteger_encode_der(asn_TYPE_descriptor_t *sd, void *ptr,
  * Decode the chunk of XML text encoding INTEGER.
  */
 asn_dec_rval_t
  * 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;
+NativeInteger_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
+                         const asn_TYPE_descriptor_t *td, void **sptr,
+                         const char *opt_mname, const void *buf_ptr,
+                         size_t size) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_dec_rval_t rval;
        INTEGER_t st;
        void *st_ptr = (void *)&st;
        long *native = (long *)*sptr;
        INTEGER_t st;
        void *st_ptr = (void *)&st;
        long *native = (long *)*sptr;
@@ -208,11 +226,12 @@ NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
 
 
 asn_enc_rval_t
 
 
 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 */
+NativeInteger_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                         int ilevel, enum xer_encoder_flags_e flags,
+                         asn_app_consume_bytes_f *cb, void *app_key) {
+    const asn_INTEGER_specifics_t *specs =
+        (const 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;
 
        asn_enc_rval_t er;
        const long *native = (const long *)sptr;
 
@@ -231,13 +250,16 @@ NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
        ASN__ENCODED_OK(er);
 }
 
        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) {
+#ifndef  ASN_DISABLE_PER_SUPPORT
 
 
-       asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
-       asn_dec_rval_t rval;
+asn_dec_rval_t
+NativeInteger_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                          const asn_TYPE_descriptor_t *td,
+                          const asn_per_constraints_t *constraints, void **sptr,
+                          asn_per_data_t *pd) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_dec_rval_t rval;
        long *native = (long *)*sptr;
        INTEGER_t tmpint;
        void *tmpintptr = &tmpint;
        long *native = (long *)*sptr;
        INTEGER_t tmpint;
        void *tmpintptr = &tmpint;
@@ -268,18 +290,20 @@ NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
 }
 
 asn_enc_rval_t
 }
 
 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;
+NativeInteger_encode_uper(const asn_TYPE_descriptor_t *td,
+                          const asn_per_constraints_t *constraints,
+                          const void *sptr, asn_per_outp_t *po) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_enc_rval_t er;
        long native;
        INTEGER_t tmpint;
 
        if(!sptr) ASN__ENCODE_FAILED;
 
        long native;
        INTEGER_t tmpint;
 
        if(!sptr) ASN__ENCODE_FAILED;
 
-       native = *(long *)sptr;
+    native = *(const long *)sptr;
 
 
-       ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);
+    ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);
 
        memset(&tmpint, 0, sizeof(tmpint));
        if((specs&&specs->field_unsigned)
 
        memset(&tmpint, 0, sizeof(tmpint));
        if((specs&&specs->field_unsigned)
@@ -291,42 +315,170 @@ NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
        return er;
 }
 
        return er;
 }
 
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
 /*
  * INTEGER specific human-readable output.
  */
 int
 /*
  * 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;
+NativeInteger_print(const asn_TYPE_descriptor_t *td, const void *sptr,
+                    int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+    const asn_INTEGER_specifics_t *specs =
+        (const 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) {
+        long value = *native;
+        ret = snprintf(scratch, sizeof(scratch),
+                       (specs && specs->field_unsigned) ? "%lu" : "%ld", value);
+        assert(ret > 0 && (size_t)ret < sizeof(scratch));
+        if(cb(scratch, ret, app_key) < 0) return -1;
+        if(specs && (value >= 0 || !specs->field_unsigned)) {
+            const asn_INTEGER_enum_map_t *el =
+                INTEGER_map_value2enum(specs, value);
+            if(el) {
+                if(cb(" (", 2, app_key) < 0) return -1;
+                if(cb(el->enum_name, el->enum_len, app_key) < 0) return -1;
+                if(cb(")", 1, app_key) < 0) return -1;
+            }
+        }
+        return 0;
        } else {
                return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
        }
 }
 
 void
        } 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)
+NativeInteger_free(const asn_TYPE_descriptor_t *td, void *ptr,
+                   enum asn_struct_free_method method) {
+    if(!td || !ptr)
                return;
 
        ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",
                return;
 
        ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",
-               td->name, contents_only, ptr);
+               td->name, method, ptr);
+
+    switch(method) {
+    case ASFM_FREE_EVERYTHING:
+        FREEMEM(ptr);
+        break;
+    case ASFM_FREE_UNDERLYING:
+        break;
+    case ASFM_FREE_UNDERLYING_AND_RESET:
+        memset(ptr, 0, sizeof(long));
+        break;
+    }
+}
 
 
-       if(!contents_only) {
-               FREEMEM(ptr);
-       }
+int
+NativeInteger_compare(const asn_TYPE_descriptor_t *td, const void *aptr, const void *bptr) {
+    (void)td;
+
+    if(aptr && bptr) {
+        const asn_INTEGER_specifics_t *specs =
+            (const asn_INTEGER_specifics_t *)td->specifics;
+        if(specs && specs->field_unsigned) {
+            const unsigned long *a = aptr;
+            const unsigned long *b = bptr;
+            if(*a < *b) {
+                return -1;
+            } else if(*a > *b) {
+                return 1;
+            } else {
+                return 0;
+            }
+        } else {
+            const long *a = aptr;
+            const long *b = bptr;
+            if(*a < *b) {
+                return -1;
+            } else if(*a > *b) {
+                return 1;
+            } else {
+                return 0;
+            }
+        }
+    } else if(!aptr) {
+        return -1;
+    } else {
+        return 1;
+    }
 }
 
 }
 
+asn_random_fill_result_t
+NativeInteger_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                          const asn_encoding_constraints_t *constraints,
+                          size_t max_length) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    long *st = *sptr;
+    const asn_INTEGER_enum_map_t *emap;
+    size_t emap_len;
+    intmax_t value;
+    int find_inside_map;
+
+    if(max_length == 0) return result_skipped;
+
+    if(st == NULL) {
+        st = (long *)CALLOC(1, sizeof(*st));
+        if(st == NULL) {
+            return result_failed;
+        }
+    }
+
+    if(specs) {
+        emap = specs->value2enum;
+        emap_len = specs->map_count;
+        if(specs->strict_enumeration) {
+            find_inside_map = emap_len > 0;
+        } else {
+            find_inside_map = emap_len ? asn_random_between(0, 1) : 0;
+        }
+    } else {
+        emap = 0;
+        emap_len = 0;
+        find_inside_map = 0;
+    }
+
+    if(find_inside_map) {
+        assert(emap_len > 0);
+        value = emap[asn_random_between(0, emap_len - 1)].nat_value;
+    } else {
+        const asn_per_constraints_t *ct;
+
+        static const long variants[] = {
+            -65536, -65535, -65534, -32769, -32768, -32767, -16385, -16384,
+            -16383, -257,   -256,   -255,   -254,   -129,   -128,   -127,
+            -126,   -1,     0,      1,      126,    127,    128,    129,
+            254,    255,    256,    257,    16383,  16384,  16385,  32767,
+            32768,  32769,  65534,  65535,  65536,  65537};
+        if(specs && specs->field_unsigned) {
+            assert(variants[18] == 0);
+            value = variants[asn_random_between(
+                18, sizeof(variants) / sizeof(variants[0]) - 1)];
+        } else {
+            value = variants[asn_random_between(
+                0, sizeof(variants) / sizeof(variants[0]) - 1)];
+        }
+
+        if(!constraints) constraints = &td->encoding_constraints;
+        ct = constraints ? constraints->per_constraints : 0;
+        if(ct && (ct->value.flags & APC_CONSTRAINED)) {
+            if(value < ct->value.lower_bound || value > ct->value.upper_bound) {
+                value = asn_random_between(ct->value.lower_bound,
+                                           ct->value.upper_bound);
+            }
+        }
+    }
+
+    *sptr = st;
+    *st = value;
+    return result_ok;
+}
diff --git a/libs/smux/NativeInteger_oer.c b/libs/smux/NativeInteger_oer.c
new file mode 100644 (file)
index 0000000..411413a
--- /dev/null
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_DISABLE_OER_SUPPORT
+
+#include <asn_internal.h>
+#include <NativeInteger.h>
+#include <errno.h>
+
+asn_dec_rval_t
+NativeInteger_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
+                         const asn_TYPE_descriptor_t *td,
+                         const asn_oer_constraints_t *constraints,
+                         void **nint_ptr, const void *ptr, size_t size) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    asn_dec_rval_t rval = {RC_OK, 0};
+    long *native = (long *)*nint_ptr;
+    INTEGER_t tmpint;
+    INTEGER_t *tmpintptr = &tmpint;
+
+    memset(&tmpint, 0, sizeof(tmpint));
+
+    if(!native) {
+        native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native)));
+        if(!native) ASN__DECODE_FAILED;
+    }
+
+    /*
+     * OPTIMIZATION: Encode directly rather than passing through INTEGER.
+     * Saves a memory allocation.
+     */
+    rval = INTEGER_decode_oer(opt_codec_ctx, td, constraints,
+                              (void **)&tmpintptr, ptr, size);
+    if(rval.code != RC_OK) {
+        ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+        return rval;
+    }
+
+    if(specs && specs->field_unsigned) {
+        unsigned long ul;
+        int ok = asn_INTEGER2ulong(&tmpint, &ul) == 0;
+        ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+        if(ok) {
+            *native = ul;
+        } else {
+            rval.code = RC_FAIL;
+            return rval;
+        }
+    } else {
+        long l;
+        int ok = asn_INTEGER2long(&tmpint, &l) == 0;
+        ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+        if(ok) {
+            *native = l;
+        } else {
+            rval.code = RC_FAIL;
+            return rval;
+        }
+    }
+
+    return rval;
+}
+
+/*
+ * Encode as Canonical OER.
+ */
+asn_enc_rval_t
+NativeInteger_encode_oer(const asn_TYPE_descriptor_t *td,
+                         const asn_oer_constraints_t *constraints,
+                         const void *sptr, asn_app_consume_bytes_f *cb,
+                         void *app_key) {
+    const asn_INTEGER_specifics_t *specs =
+        (const asn_INTEGER_specifics_t *)td->specifics;
+    INTEGER_t tmpint;
+    long native;
+
+    if(!sptr) ASN__ENCODE_FAILED;
+
+    native = *(const long *)sptr;
+    memset(&tmpint, 0, sizeof(tmpint));
+
+    ASN_DEBUG("Encoding %s %ld as NativeInteger", td ? td->name : "", native);
+
+    if((specs && specs->field_unsigned) ? asn_ulong2INTEGER(&tmpint, native)
+                                        : asn_long2INTEGER(&tmpint, native)) {
+        ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+        ASN__ENCODE_FAILED;
+    } else {
+        asn_enc_rval_t er =
+            INTEGER_encode_oer(td, constraints, &tmpint, cb, app_key);
+        ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+        return er;
+    }
+}
+
+#endif  /* ASN_DISABLE_OER_SUPPORT */
index 3a65001d277f349fccd79bba00db5a2a7961824f..e56c9465eb1a0451cfdf42e447e7a1d5fdc93143 100644 (file)
@@ -1,53 +1,53 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "NetworkAddress.h"
 
  */
 
 #include "NetworkAddress.h"
 
-static asn_TYPE_member_t asn_MBR_NetworkAddress_1[] = {
+static asn_oer_constraints_t asn_OER_type_NetworkAddress_constr_1 CC_NOTUSED = {
+       { 0, 0 },
+       -1};
+asn_per_constraints_t asn_PER_type_NetworkAddress_constr_1 CC_NOTUSED = {
+       { APC_CONSTRAINED,       0,  0,  0,  0 }        /* (0..0) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_NetworkAddress_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct NetworkAddress, choice.internet),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
        { ATF_NOFLAGS, 0, offsetof(struct NetworkAddress, choice.internet),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "internet"
                },
 };
 static const asn_TYPE_tag2member_t asn_MAP_NetworkAddress_tag2el_1[] = {
     { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 } /* internet */
 };
                "internet"
                },
 };
 static const asn_TYPE_tag2member_t asn_MAP_NetworkAddress_tag2el_1[] = {
     { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 } /* internet */
 };
-static asn_CHOICE_specifics_t asn_SPC_NetworkAddress_specs_1 = {
+asn_CHOICE_specifics_t asn_SPC_NetworkAddress_specs_1 = {
        sizeof(struct NetworkAddress),
        offsetof(struct NetworkAddress, _asn_ctx),
        offsetof(struct NetworkAddress, present),
        sizeof(((struct NetworkAddress *)0)->present),
        asn_MAP_NetworkAddress_tag2el_1,
        1,      /* Count of tags in the map */
        sizeof(struct NetworkAddress),
        offsetof(struct NetworkAddress, _asn_ctx),
        offsetof(struct NetworkAddress, present),
        sizeof(((struct NetworkAddress *)0)->present),
        asn_MAP_NetworkAddress_tag2el_1,
        1,      /* Count of tags in the map */
-       0,
+       0, 0,
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_NetworkAddress = {
        "NetworkAddress",
        "NetworkAddress",
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_NetworkAddress = {
        "NetworkAddress",
        "NetworkAddress",
-       CHOICE_free,
-       CHOICE_print,
-       CHOICE_constraint,
-       CHOICE_decode_ber,
-       CHOICE_encode_der,
-       CHOICE_decode_xer,
-       CHOICE_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       CHOICE_outmost_tag,
+       &asn_OP_CHOICE,
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_NetworkAddress_constr_1, &asn_PER_type_NetworkAddress_constr_1, CHOICE_constraint },
        asn_MBR_NetworkAddress_1,
        1,      /* Elements count */
        &asn_SPC_NetworkAddress_specs_1 /* Additional specs */
        asn_MBR_NetworkAddress_1,
        1,      /* Elements count */
        &asn_SPC_NetworkAddress_specs_1 /* Additional specs */
index d0f8b31171213247e3551c608152c66ef4b39209..290545d1c2e76c60ce7b879095508909671eb6bd 100644 (file)
 static const ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
 };
 static const ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
 };
-asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {
-       "OBJECT IDENTIFIER",
-       "OBJECT_IDENTIFIER",
+asn_TYPE_operation_t asn_OP_OBJECT_IDENTIFIER = {
        ASN__PRIMITIVE_TYPE_free,
        OBJECT_IDENTIFIER_print,
        ASN__PRIMITIVE_TYPE_free,
        OBJECT_IDENTIFIER_print,
-       OBJECT_IDENTIFIER_constraint,
+       OCTET_STRING_compare,   /* Implemented in terms of a string comparison */
        ber_decode_primitive,
        der_encode_primitive,
        OBJECT_IDENTIFIER_decode_xer,
        OBJECT_IDENTIFIER_encode_xer,
        ber_decode_primitive,
        der_encode_primitive,
        OBJECT_IDENTIFIER_decode_xer,
        OBJECT_IDENTIFIER_encode_xer,
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       OBJECT_IDENTIFIER_decode_oer,
+       OBJECT_IDENTIFIER_encode_oer,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
        OCTET_STRING_decode_uper,
        OCTET_STRING_encode_uper,
        OCTET_STRING_decode_uper,
        OCTET_STRING_encode_uper,
-       0, /* Use generic outmost tag fetcher */
+#endif /* ASN_DISABLE_PER_SUPPORT */
+       OBJECT_IDENTIFIER_random_fill,
+       0       /* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {
+       "OBJECT IDENTIFIER",
+       "OBJECT_IDENTIFIER",
+       &asn_OP_OBJECT_IDENTIFIER,
        asn_DEF_OBJECT_IDENTIFIER_tags,
        sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
            / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
        asn_DEF_OBJECT_IDENTIFIER_tags, /* Same as above */
        sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
            / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
        asn_DEF_OBJECT_IDENTIFIER_tags,
        sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
            / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
        asn_DEF_OBJECT_IDENTIFIER_tags, /* Same as above */
        sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
            / sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
-       0,      /* No PER visible constraints */
+       { 0, 0, OBJECT_IDENTIFIER_constraint },
        0, 0,   /* No members */
        0       /* No specifics */
 };
 
        0, 0,   /* No members */
        0       /* No specifics */
 };
 
-
 int
 int
-OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-               asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+                             asn_app_constraint_failed_f *ctfailcb,
+                             void *app_key) {
+    const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
 
        if(st && st->buf) {
                if(st->size < 1) {
 
        if(st && st->buf) {
                if(st->size < 1) {
@@ -63,285 +79,186 @@ OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
        return 0;
 }
 
        return 0;
 }
 
-
-int
-OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, unsigned int arclen, signed int add, void *rvbufp, unsigned int rvsize) {
-       unsigned LE GCC_NOTUSED = 1; /* Little endian (x86) */
-       const uint8_t *arcend = arcbuf + arclen;        /* End of arc */
-       unsigned int cache = 0; /* No more than 14 significant bits */
-       unsigned char *rvbuf = (unsigned char *)rvbufp;
-       unsigned char *rvstart = rvbuf; /* Original start of the value buffer */
-       int inc;        /* Return value growth direction */
-
-       rvsize *= CHAR_BIT;     /* bytes to bits */
-       arclen *= 7;            /* bytes to bits */
-
-       /*
-        * The arc has the number of bits
-        * cannot be represented using supplied return value type.
-        */
-       if(arclen > rvsize) {
-               if(arclen > (rvsize + CHAR_BIT)) {
-                       errno = ERANGE; /* Overflow */
-                       return -1;
-               } else {
-                       /*
-                        * Even if the number of bits in the arc representation
-                        * is higher than the width of supplied * return value
-                        * type, there is still possible to fit it when there
-                        * are few unused high bits in the arc value
-                        * representaion.
-                        * 
-                        * Moreover, there is a possibility that the
-                        * number could actually fit the arc space, given
-                        * that add is negative, but we don't handle
-                        * such "temporary lack of precision" situation here.
-                        * May be considered as a bug.
-                        */
-                       uint8_t mask = (0xff << (7-(arclen - rvsize))) & 0x7f;
-                       if((*arcbuf & mask)) {
-                               errno = ERANGE; /* Overflow */
-                               return -1;
-                       }
-                       /* Fool the routine computing unused bits */
-                       arclen -= 7;
-                       cache = *arcbuf & 0x7f;
-                       arcbuf++;
-               }
-       }
-
-       /* Faster path for common size */
-       if(rvsize == (CHAR_BIT * sizeof(unsigned long))) {
-               unsigned long accum;
-               /* Gather all bits into the accumulator */
-               for(accum = cache; arcbuf < arcend; arcbuf++)
-                       accum = (accum << 7) | (*arcbuf & ~0x80);
-               if(accum < (unsigned)-add) {
-                       errno = ERANGE; /* Overflow */
-                       return -1;
-               }
-               *(unsigned long *)(void *)rvbuf = accum + add;  /* alignment OK! */
-               return 0;
-       }
-
-#ifndef        WORDS_BIGENDIAN
-       if(*(unsigned char *)&LE) {     /* Little endian (x86) */
-               /* "Convert" to big endian */
-               rvbuf += rvsize / CHAR_BIT - 1;
-               rvstart--;
-               inc = -1;       /* Descending */
-       } else
-#endif /* !WORDS_BIGENDIAN */
-               inc = +1;       /* Big endian is known [at compile time] */
-
-       {
-               int bits;       /* typically no more than 3-4 bits */
-
-               /* Clear the high unused bits */
-               for(bits = rvsize - arclen;
-                       bits > CHAR_BIT;
-                               rvbuf += inc, bits -= CHAR_BIT)
-                               *rvbuf = 0;
-
-               /* Fill the body of a value */
-               for(; arcbuf < arcend; arcbuf++) {
-                       cache = (cache << 7) | (*arcbuf & 0x7f);
-                       bits += 7;
-                       if(bits >= CHAR_BIT) {
-                               bits -= CHAR_BIT;
-                               *rvbuf = (cache >> bits);
-                               rvbuf += inc;
-                       }
-               }
-               if(bits) {
-                       *rvbuf = cache;
-                       rvbuf += inc;
-               }
-       }
-
-       if(add) {
-               for(rvbuf -= inc; rvbuf != rvstart; rvbuf -= inc) {
-                       int v = add + *rvbuf;
-                       if(v & ((unsigned)~0 << CHAR_BIT)) {
-                               *rvbuf = (unsigned char)(v + (1 << CHAR_BIT));
-                               add = -1;
-                       } else {
-                               *rvbuf = v;
-                               break;
-                       }
-               }
-               if(rvbuf == rvstart) {
-                       /* No space to carry over */
-                       errno = ERANGE; /* Overflow */
-                       return -1;
-               }
-       }
-
-       return 0;
+static ssize_t
+OBJECT_IDENTIFIER_get_first_arcs(const uint8_t *arcbuf, size_t arcbuf_len,
+                                 asn_oid_arc_t *arc0, asn_oid_arc_t *arc1) {
+    asn_oid_arc_t value;
+
+    ssize_t rd = OBJECT_IDENTIFIER_get_single_arc(arcbuf, arcbuf_len, &value);
+    if(rd <= 0) return rd;
+
+    if(value >= 80) {
+        *arc0 = 2;
+        *arc1 = value - 80;
+    } else if(value >= 40) {
+        *arc0 = 1;
+        *arc1 = value - 40;
+    } else {
+        *arc0 = 0;
+        *arc1 = value;
+    }
+
+    return rd;
 }
 
 ssize_t
 }
 
 ssize_t
-OBJECT_IDENTIFIER__dump_arc(const uint8_t *arcbuf, int arclen, int add,
-               asn_app_consume_bytes_f *cb, void *app_key) {
-       char scratch[64];       /* Conservative estimate */
-       unsigned long accum;    /* Bits accumulator */
-       char *p;                /* Position in the scratch buffer */
-
-       if(OBJECT_IDENTIFIER_get_single_arc(arcbuf, arclen, add,
-                       &accum, sizeof(accum)))
-               return -1;
+OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, size_t arcbuf_len,
+                                 asn_oid_arc_t *ret_value) {
+    const uint8_t *b = arcbuf;
+    const uint8_t *arcend = arcbuf + arcbuf_len; /* End of arc */
+
+    if(arcbuf == arcend) {
+        return 0;
+    } else {
+        asn_oid_arc_t accum;
+        /* Gather all bits into the accumulator */
+        for(accum = 0; b < arcend; b++) {
+            accum = (accum << 7) | (*b & ~0x80);
+            if((*b & 0x80) == 0) {
+                if(accum <= ASN_OID_ARC_MAX) {
+                    *ret_value = accum;
+                    return 1 + (b - arcbuf);
+                } else {
+                    errno = ERANGE; /* Overflow */
+                    return -1;
+                }
+            }
+        }
+        errno = EINVAL;
+        return -1;
+    }
 
 
-       if(accum) {
-               ssize_t len;
-
-               /* Fill the scratch buffer in reverse. */
-               p = scratch + sizeof(scratch);
-               for(; accum; accum /= 10)
-                       *(--p) = (char)(accum % 10) + 0x30; /* Put a digit */
-
-               len = sizeof(scratch) - (p - scratch);
-               if(cb(p, len, app_key) < 0)
-                       return -1;
-               return len;
-       } else {
-               *scratch = 0x30;
-               if(cb(scratch, 1, app_key) < 0)
-                       return -1;
-               return 1;
-       }
-}
-
-int
-OBJECT_IDENTIFIER_print_arc(const uint8_t *arcbuf, int arclen, int add,
-               asn_app_consume_bytes_f *cb, void *app_key) {
-
-       if(OBJECT_IDENTIFIER__dump_arc(arcbuf, arclen, add, cb, app_key) < 0)
-               return -1;
-
-       return 0;
 }
 
 static ssize_t
 }
 
 static ssize_t
-OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st, asn_app_consume_bytes_f *cb, void *app_key) {
-       ssize_t wrote_len = 0;
-       int startn;
-       int add = 0;
-       int i;
-
-       for(i = 0, startn = 0; i < st->size; i++) {
-               uint8_t b = st->buf[i];
-               if((b & 0x80))                  /* Continuation expected */
-                       continue;
-
-               if(startn == 0) {
-                       /*
-                        * First two arcs are encoded through the backdoor.
-                        */
-                       if(i) {
-                               add = -80;
-                               if(cb("2", 1, app_key) < 0) return -1;
-                       } else if(b <= 39) {
-                               add = 0;
-                               if(cb("0", 1, app_key) < 0) return -1;
-                       } else if(b < 79) {
-                               add = -40;
-                               if(cb("1", 1, app_key) < 0) return -1;
-                       } else {
-                               add = -80;
-                               if(cb("2", 1, app_key) < 0) return -1;
-                       }
-                       wrote_len += 1;
-               }
-
-               if(cb(".", 1, app_key) < 0)     /* Separate arcs */
-                       return -1;
-
-               add = OBJECT_IDENTIFIER__dump_arc(&st->buf[startn],
-                               i - startn + 1, add, cb, app_key);
-               if(add < 0) return -1;
-               wrote_len += 1 + add;
-               startn = i + 1;
-               add = 0;
-       }
-
-       return wrote_len;
+OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st,
+                             asn_app_consume_bytes_f *cb, void *app_key) {
+    char scratch[32];
+    asn_oid_arc_t arc0, arc1;
+    size_t produced = 0;
+    size_t off = 0;
+    ssize_t rd;
+    int ret;
+
+    rd = OBJECT_IDENTIFIER_get_first_arcs(st->buf, st->size, &arc0, &arc1);
+    if(rd <= 0) {
+        return -1;
+    }
+
+    ret = snprintf(scratch, sizeof(scratch), "%"PRIu32".%"PRIu32, arc0, arc1);
+    if(ret >= (ssize_t)sizeof(scratch)) {
+        return -1;
+    }
+    produced += ret;
+    if(cb(scratch, ret, app_key) < 0)
+        return -1;
+
+    for(off = rd; ; ) {
+        asn_oid_arc_t arc;
+        rd = OBJECT_IDENTIFIER_get_single_arc(st->buf + off, st->size - off,
+                                              &arc);
+        if(rd < 0) {
+            return -1;
+        } else if(rd == 0) {
+            /* No more arcs. */
+            break;
+        } else {
+            off += rd;
+            assert(off <= st->size);
+            ret = snprintf(scratch, sizeof(scratch), ".%" PRIu32, arc);
+            if(ret >= (ssize_t)sizeof(scratch)) {
+                return -1;
+            }
+            produced += ret;
+            if(cb(scratch, ret, app_key) < 0) return -1;
+        }
+    }
+
+    if(off != st->size) {
+        ASN_DEBUG("Could not scan to the end of Object Identifier");
+        return -1;
+    }
+
+       return produced;
 }
 
 static enum xer_pbd_rval
 }
 
 static enum xer_pbd_rval
-OBJECT_IDENTIFIER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
-       OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
+                                   const void *chunk_buf, size_t chunk_size) {
+    OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;
        const char *chunk_end = (const char *)chunk_buf + chunk_size;
        const char *endptr;
        const char *chunk_end = (const char *)chunk_buf + chunk_size;
        const char *endptr;
-       long s_arcs[10];
-       long *arcs = s_arcs;
-       int arcs_count;
-       int ret;
+       asn_oid_arc_t s_arcs[10];
+       asn_oid_arc_t *arcs = s_arcs;
+       ssize_t num_arcs;
+       ssize_t ret;
 
        (void)td;
 
 
        (void)td;
 
-       arcs_count = OBJECT_IDENTIFIER_parse_arcs(
-               (const char *)chunk_buf, chunk_size, arcs,
-                       sizeof(s_arcs)/sizeof(s_arcs[0]), &endptr);
-       if(arcs_count < 0) {
+    num_arcs = OBJECT_IDENTIFIER_parse_arcs(
+        (const char *)chunk_buf, chunk_size, arcs,
+        sizeof(s_arcs) / sizeof(s_arcs[0]), &endptr);
+    if(num_arcs < 0) {
                /* Expecting more than zero arcs */
                return XPBD_BROKEN_ENCODING;
                /* Expecting more than zero arcs */
                return XPBD_BROKEN_ENCODING;
-       } else if(arcs_count == 0) {
+       } else if(num_arcs == 0) {
                return XPBD_NOT_BODY_IGNORE;
        }
        assert(endptr == chunk_end);
 
                return XPBD_NOT_BODY_IGNORE;
        }
        assert(endptr == chunk_end);
 
-       if((size_t)arcs_count > sizeof(s_arcs)/sizeof(s_arcs[0])) {
-               arcs = (long *)MALLOC(arcs_count * sizeof(long));
+       if((size_t)num_arcs > sizeof(s_arcs)/sizeof(s_arcs[0])) {
+               arcs = (asn_oid_arc_t *)MALLOC(num_arcs * sizeof(asn_oid_arc_t));
                if(!arcs) return XPBD_SYSTEM_FAILURE;
                if(!arcs) return XPBD_SYSTEM_FAILURE;
-               ret = OBJECT_IDENTIFIER_parse_arcs(
-                       (const char *)chunk_buf, chunk_size,
-                       arcs, arcs_count, &endptr);
-               if(ret != arcs_count)
+        ret = OBJECT_IDENTIFIER_parse_arcs((const char *)chunk_buf, chunk_size,
+                                           arcs, num_arcs, &endptr);
+        if(ret != num_arcs)
                        return XPBD_SYSTEM_FAILURE;     /* assert?.. */
        }
 
        /*
         * Convert arcs into BER representation.
         */
                        return XPBD_SYSTEM_FAILURE;     /* assert?.. */
        }
 
        /*
         * Convert arcs into BER representation.
         */
-       ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, sizeof(*arcs), arcs_count);
+       ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, num_arcs);
        if(arcs != s_arcs) FREEMEM(arcs);
 
        return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
 }
 
 asn_dec_rval_t
        if(arcs != s_arcs) FREEMEM(arcs);
 
        return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
 }
 
 asn_dec_rval_t
-OBJECT_IDENTIFIER_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,
+OBJECT_IDENTIFIER_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
+                             const 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(OBJECT_IDENTIFIER_t), opt_mname,
                        buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode);
 }
 
 asn_enc_rval_t
                sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname,
                        buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode);
 }
 
 asn_enc_rval_t
-OBJECT_IDENTIFIER_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 OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                             int ilevel, enum xer_encoder_flags_e flags,
+                             asn_app_consume_bytes_f *cb, void *app_key) {
+    const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
        asn_enc_rval_t er;
 
        asn_enc_rval_t er;
 
-       (void)ilevel;
-       (void)flags;
+    (void)ilevel;
+    (void)flags;
 
 
-       if(!st || !st->buf)
-               ASN__ENCODE_FAILED;
+    if(!st || !st->buf) {
+        ASN__ENCODE_FAILED;
+    }
 
 
-       er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
-       if(er.encoded < 0) ASN__ENCODE_FAILED;
+    er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
+    if(er.encoded < 0) ASN__ENCODE_FAILED;
 
 
-       ASN__ENCODED_OK(er);
+    ASN__ENCODED_OK(er);
 }
 
 int
 }
 
 int
-OBJECT_IDENTIFIER_print(asn_TYPE_descriptor_t *td, const void *sptr,
-       int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
+OBJECT_IDENTIFIER_print(const asn_TYPE_descriptor_t *td, const void *sptr,
+                        int ilevel, asn_app_consume_bytes_f *cb,
+                        void *app_key) {
+    const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
 
        (void)td;       /* Unused argument */
        (void)ilevel;   /* Unused argument */
 
        (void)td;       /* Unused argument */
        (void)ilevel;   /* Unused argument */
@@ -353,301 +270,198 @@ OBJECT_IDENTIFIER_print(asn_TYPE_descriptor_t *td, const void *sptr,
        if(cb("{ ", 2, app_key) < 0)
                return -1;
 
        if(cb("{ ", 2, app_key) < 0)
                return -1;
 
-       if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0)
-               return -1;
+    if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0) {
+        return -1;
+    }
 
 
-       return (cb(" }", 2, app_key) < 0) ? -1 : 0;
+    return (cb(" }", 2, app_key) < 0) ? -1 : 0;
 }
 
 }
 
-int
-OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *oid, void *arcs,
-               unsigned int arc_type_size, unsigned int arc_slots) {
-       void *arcs_end = (char *)arcs + (arc_type_size * arc_slots);
-       int num_arcs = 0;
-       int startn = 0;
-       int add = 0;
-       int i;
-
-       if(!oid || !oid->buf || (arc_slots && arc_type_size <= 1)) {
-               errno = EINVAL;
-               return -1;
-       }
-
-       for(i = 0; i < oid->size; i++) {
-               uint8_t b = oid->buf[i];
-               if((b & 0x80))                  /* Continuation expected */
-                       continue;
-
-               if(num_arcs == 0) {
-                       /*
-                        * First two arcs are encoded through the backdoor.
-                        */
-                       unsigned LE = 1;        /* Little endian */
-                       int first_arc;
-                       num_arcs++;
-                       if(!arc_slots) { num_arcs++; continue; }
-
-                       if(i) first_arc = 2;
-                       else if(b <= 39) first_arc = 0;
-                       else if(b < 79) first_arc = 1;
-                       else first_arc = 2;
-
-                       add = -40 * first_arc;
-                       memset(arcs, 0, arc_type_size);
-                       *(unsigned char *)((char *)arcs
-                               + ((*(char *)&LE)?0:(arc_type_size - 1)))
-                                       = first_arc;
-                       arcs = ((char *)arcs) + arc_type_size;
-               }
-
-               /* Decode, if has space */
-               if(arcs < arcs_end) {
-                       if(OBJECT_IDENTIFIER_get_single_arc(&oid->buf[startn],
-                               i - startn + 1, add,
-                                       arcs, arc_type_size))
-                               return -1;
-                       startn = i + 1;
-                       arcs = ((char *)arcs) + arc_type_size;
-                       add = 0;
-               }
-               num_arcs++;
-       }
-
-       return num_arcs;
+ssize_t
+OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *st, asn_oid_arc_t *arcs,
+                           size_t arc_slots) {
+    asn_oid_arc_t arc0, arc1;
+    size_t num_arcs = 0;
+    size_t off;
+    ssize_t rd;
+
+    if(!st || !st->buf) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    rd = OBJECT_IDENTIFIER_get_first_arcs(st->buf, st->size, &arc0, &arc1);
+    if(rd <= 0) {
+        return -1;
+    }
+    num_arcs = 2;
+    switch(arc_slots) {
+    default:
+    case 2:
+        arcs[1] = arc1;
+        /* Fall through */
+    case 1:
+        arcs[0] = arc0;
+        /* Fall through */
+    case 0:
+        break;
+    }
+
+    for(off = rd; ; ) {
+        asn_oid_arc_t arc;
+        rd = OBJECT_IDENTIFIER_get_single_arc(st->buf + off, st->size - off,
+                                              &arc);
+        if(rd < 0) {
+            return -1;
+        } else if(rd == 0) {
+            /* No more arcs. */
+            break;
+        } else {
+            off += rd;
+            if(num_arcs < arc_slots) {
+                arcs[num_arcs] = arc;
+            }
+            num_arcs++;
+        }
+    }
+
+    if(off != st->size) {
+        return -1;
+    }
+
+    return num_arcs;
 }
 
 
 /*
  * Save the single value as an object identifier arc.
  */
 }
 
 
 /*
  * Save the single value as an object identifier arc.
  */
-int
-OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, const void *arcval, unsigned int arcval_size, int prepared_order) {
-       /*
+ssize_t
+OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, size_t arcbuf_len,
+                                 asn_oid_arc_t value) {
+    /*
         * The following conditions must hold:
         * The following conditions must hold:
-        * assert(arcval);
-        * assert(arcval_size > 0);
-        * assert(arcval_size <= 16);
         * assert(arcbuf);
         */
         * assert(arcbuf);
         */
-#ifdef WORDS_BIGENDIAN
-       const unsigned isLittleEndian = 0;
-#else
-       unsigned LE = 1;
-       unsigned isLittleEndian = *(char *)&LE;
-#endif
-       const uint8_t *tend, *tp;
-       unsigned int cache;
-       uint8_t *bp = arcbuf;
-       int bits;
-       uint8_t buffer[16];
-
-       if(isLittleEndian && !prepared_order) {
-               const uint8_t *a = (const unsigned char *)arcval + arcval_size - 1;
-               const uint8_t *aend = (const uint8_t *)arcval;
-               uint8_t *msb = buffer + arcval_size - 1;
-               uint8_t *tb;
-               for(tb = buffer; a >= aend; tb++, a--)
-                       if((*tb = *a) && (tb < msb))
-                               msb = tb;
-               tend = &buffer[arcval_size];
-               tp = msb;       /* Most significant non-zero byte */
-       } else {
-               /* Look for most significant non-zero byte */
-               tend = (const unsigned char *)arcval + arcval_size;
-               for(tp = (const uint8_t *)arcval; tp < tend - 1; tp++)
-                       if(*tp) break;
-       }
+    uint8_t scratch[((sizeof(value) * CHAR_BIT + 6) / 7)];
+    uint8_t *scratch_end = &scratch[sizeof(scratch)-1];
+    uint8_t *b;
+    size_t result_len;
+    uint8_t mask;
 
 
-       /*
-        * Split the value in 7-bits chunks.
-        */
-       bits = ((tend - tp) * CHAR_BIT) % 7;
-       if(bits) {
-               cache = *tp >> (CHAR_BIT - bits);
-               if(cache) {
-                       *bp++ = cache | 0x80;
-                       cache = *tp++;
-                       bits = CHAR_BIT - bits;
-               } else {
-                       bits = -bits;
-               }
-       } else {
-               cache = 0;
-       }
-       for(; tp < tend; tp++) {
-               cache = (cache << CHAR_BIT) + *tp;
-               bits += CHAR_BIT;
-               while(bits >= 7) {
-                       bits -= 7;
-                       *bp++ = 0x80 | (cache >> bits);
-               }
-       }
-       if(bits) *bp++ = cache;
-       bp[-1] &= 0x7f; /* Clear the last bit */
+    for(b = scratch_end, mask = 0; ; mask = 0x80, b--) {
+        *b = mask | (value & 0x7f);
+        value >>= 7;
+        if(!value) {
+            break;
+        }
+    }
+
+    result_len = (scratch_end - b) + 1;
 
 
-       return bp - arcbuf;
+    if(result_len > arcbuf_len) {
+        return -1;
+    }
+
+    memcpy(arcbuf, b, result_len);
+
+       return result_len;
 }
 
 int
 }
 
 int
-OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *oid, const void *arcs, unsigned int arc_type_size, unsigned int arc_slots) {
-       uint8_t *buf;
-       uint8_t *bp;
-       unsigned LE = 1;        /* Little endian (x86) */
-       unsigned isLittleEndian = *((char *)&LE);
-       unsigned int arc0;
-       unsigned int arc1;
-       unsigned size;
-       unsigned i;
-
-       if(!oid || !arcs || arc_type_size < 1
-       || arc_type_size > 16
-       || arc_slots < 2) {
-               errno = EINVAL;
+OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *st, const asn_oid_arc_t *arcs,
+                           size_t arc_slots) {
+    uint8_t *buf;
+    uint8_t *bp;
+    ssize_t wrote;
+    asn_oid_arc_t arc0;
+    asn_oid_arc_t arc1;
+    size_t size;
+    size_t i;
+
+    if(!st || !arcs || arc_slots < 2) {
+        errno = EINVAL;
                return -1;
        }
 
                return -1;
        }
 
-       switch(arc_type_size) {
-       case sizeof(char):
-               arc0 = ((const unsigned char *)arcs)[0];
-               arc1 = ((const unsigned char *)arcs)[1];
-               break;
-       case sizeof(short):
-               arc0 = ((const unsigned short *)arcs)[0];
-               arc1 = ((const unsigned short *)arcs)[1];
-               break;
-       case sizeof(int):
-               arc0 = ((const unsigned int *)arcs)[0];
-               arc1 = ((const unsigned int *)arcs)[1];
-               break;
-       default:
-               arc1 = arc0 = 0;
-               if(isLittleEndian) {    /* Little endian (x86) */
-                       const unsigned char *ps, *pe;
-                       /* If more significant bytes are present,
-                        * make them > 255 quick */
-                       for(ps = (const unsigned char *)arcs + 1, pe = ps+arc_type_size;
-                                       ps < pe; ps++)
-                               arc0 |= *ps, arc1 |= *(ps + arc_type_size);
-                       arc0 <<= CHAR_BIT, arc1 <<= CHAR_BIT;
-                       arc0 = *((const unsigned char *)arcs + 0);
-                       arc1 = *((const unsigned char *)arcs + arc_type_size);
-               } else {
-                       const unsigned char *ps, *pe;
-                       /* If more significant bytes are present,
-                        * make them > 255 quick */
-                       for(ps = (const unsigned char *)arcs, pe = ps+arc_type_size - 1; ps < pe; ps++)
-                               arc0 |= *ps, arc1 |= *(ps + arc_type_size);
-                       arc0 = *((const unsigned char *)arcs + arc_type_size - 1);
-                       arc1 = *((const unsigned char *)arcs +(arc_type_size<< 1)-1);
-               }
-       }
+    arc0 = arcs[0];
+    arc1 = arcs[1];
 
 
-       /*
-        * The previous chapter left us with the first and the second arcs.
-        * The values are not precise (that is, they are valid only if
-        * they're less than 255), but OK for the purposes of making
-        * the sanity test below.
-        */
        if(arc0 <= 1) {
        if(arc0 <= 1) {
-               if(arc1 >= 39) {
+               if(arc1 >= 40) {
                        /* 8.19.4: At most 39 subsequent values (including 0) */
                        errno = ERANGE;
                        return -1;
                }
                        /* 8.19.4: At most 39 subsequent values (including 0) */
                        errno = ERANGE;
                        return -1;
                }
-       } else if(arc0 > 2) {
-               /* 8.19.4: Only three values are allocated from the root node */
-               errno = ERANGE;
-               return -1;
-       }
-       /*
+    } else if(arc0 == 2) {
+        if(arc1 > ASN_OID_ARC_MAX - 80) {
+            errno = ERANGE;
+            return -1;
+        }
+    } else if(arc0 > 2) {
+        /* 8.19.4: Only three values are allocated from the root node */
+        errno = ERANGE;
+        return -1;
+    }
+
+    /*
         * After above tests it is known that the value of arc0 is completely
         * trustworthy (0..2). However, the arc1's value is still meaningless.
         */
 
         * After above tests it is known that the value of arc0 is completely
         * trustworthy (0..2). However, the arc1's value is still meaningless.
         */
 
-       /*
-        * Roughly estimate the maximum size necessary to encode these arcs.
-        * This estimation implicitly takes in account the following facts,
-        * that cancel each other:
-        *      * the first two arcs are encoded in a single value.
-        *      * the first value may require more space (+1 byte)
-        *      * the value of the first arc which is in range (0..2)
-        */
-       size = ((arc_type_size * CHAR_BIT + 6) / 7) * arc_slots;
-       bp = buf = (uint8_t *)MALLOC(size + 1);
-       if(!buf) {
-               /* ENOMEM */
-               return -1;
-       }
-
-       /*
-        * Encode the first two arcs.
-        * These require special treatment.
-        */
-       {
-               uint8_t *tp;
-               uint8_t first_value[1 + 16];    /* of two arcs */
-               uint8_t *fv = first_value;
-
-               /*
-                * Simulate first_value = arc0 * 40 + arc1;
-                */
-               /* Copy the second (1'st) arcs[1] into the first_value */
-               *fv++ = 0;
-               arcs = ((const char *)arcs) + arc_type_size;
-               if(isLittleEndian) {
-                       const uint8_t *aend = (const unsigned char *)arcs - 1;
-                       const uint8_t *a1 = (const unsigned char *)arcs + arc_type_size - 1;
-                       for(; a1 > aend; fv++, a1--) *fv = *a1;
-               } else {
-                       const uint8_t *a1 = (const uint8_t *)arcs;
-                       const uint8_t *aend = a1 + arc_type_size;
-                       for(; a1 < aend; fv++, a1++) *fv = *a1;
-               }
-               /* Increase the first_value by arc0 */
-               arc0 *= 40;     /* (0..80) */
-               for(tp = first_value + arc_type_size; tp >= first_value; tp--) {
-                       unsigned int v = *tp;
-                       v += arc0;
-                       *tp = v;
-                       if(v >= (1 << CHAR_BIT)) arc0 = v >> CHAR_BIT;
-                       else break;
-               }
-
-               assert(tp >= first_value);
-
-               bp += OBJECT_IDENTIFIER_set_single_arc(bp, first_value,
-                       fv - first_value, 1);
-       }
-
-       /*
-        * Save the rest of arcs.
-        */
-       for(arcs = ((const char *)arcs) + arc_type_size, i = 2;
-               i < arc_slots;
-                       i++, arcs = ((const char *)arcs) + arc_type_size) {
-               bp += OBJECT_IDENTIFIER_set_single_arc(bp,
-                       arcs, arc_type_size, 0);
-       }
-
-       assert((unsigned)(bp - buf) <= size);
-
-       /*
+    /*
+     * Roughly estimate the maximum size necessary to encode these arcs.
+     * This estimation implicitly takes in account the following facts,
+     * that cancel each other:
+     *         * the first two arcs are encoded in a single value.
+     *         * the first value may require more space (+1 byte)
+     *         * the value of the first arc which is in range (0..2)
+     */
+    size = ((sizeof(asn_oid_arc_t) * CHAR_BIT + 6) / 7) * arc_slots;
+    bp = buf = (uint8_t *)MALLOC(size + 1);
+    if(!buf) {
+        /* ENOMEM */
+        return -1;
+    }
+
+    wrote = OBJECT_IDENTIFIER_set_single_arc(bp, size, arc0 * 40 + arc1);
+    if(wrote <= 0) {
+        FREEMEM(buf);
+        return -1;
+    }
+    assert((size_t)wrote <= size);
+    bp += wrote;
+    size -= wrote;
+
+    for(i = 2; i < arc_slots; i++) {
+               wrote = OBJECT_IDENTIFIER_set_single_arc(bp, size, arcs[i]);
+        if(wrote <= 0) {
+            FREEMEM(buf);
+            return -1;
+        }
+        assert((size_t)wrote <= size);
+        bp += wrote;
+        size -= wrote;
+    }
+
+    /*
         * Replace buffer.
         */
         * Replace buffer.
         */
-       oid->size = bp - buf;
-       bp = oid->buf;
-       oid->buf = buf;
+       st->size = bp - buf;
+       bp = st->buf;
+       st->buf = buf;
+       st->buf[st->size] = '\0';
        if(bp) FREEMEM(bp);
 
        return 0;
 }
 
        if(bp) FREEMEM(bp);
 
        return 0;
 }
 
-
-int
+ssize_t
 OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
 OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
-       long *arcs, unsigned int arcs_slots, const char **opt_oid_text_end) {
-       unsigned int arcs_count = 0;
-       const char *oid_end;
+                             asn_oid_arc_t *arcs, size_t arcs_count,
+                             const char **opt_oid_text_end) {
+    size_t num_arcs = 0;
+    const char *oid_end;
        enum {
                ST_LEADSPACE,
                ST_TAILSPACE,
        enum {
                ST_LEADSPACE,
                ST_TAILSPACE,
@@ -655,7 +469,7 @@ OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
                ST_WAITDIGITS   /* Next character is expected to be a digit */
        } state = ST_LEADSPACE;
 
                ST_WAITDIGITS   /* Next character is expected to be a digit */
        } state = ST_LEADSPACE;
 
-       if(!oid_text || oid_txt_length < -1 || (arcs_slots && !arcs)) {
+       if(!oid_text || oid_txt_length < -1 || (arcs_count && !arcs)) {
                if(opt_oid_text_end) *opt_oid_text_end = oid_text;
                errno = EINVAL;
                return -1;
                if(opt_oid_text_end) *opt_oid_text_end = oid_text;
                errno = EINVAL;
                return -1;
@@ -664,32 +478,33 @@ OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
        if(oid_txt_length == -1)
                oid_txt_length = strlen(oid_text);
 
        if(oid_txt_length == -1)
                oid_txt_length = strlen(oid_text);
 
-#define        _OID_CAPTURE_ARC(oid_text, oid_end)             do {    \
-       const char *endp = oid_end;                             \
-       long value;                                             \
-       switch(asn_strtol_lim(oid_text, &endp, &value)) {       \
-       case ASN_STRTOL_EXTRA_DATA:                             \
-       case ASN_STRTOL_OK:                                     \
-               if(arcs_count < arcs_slots)                     \
-                       arcs[arcs_count] = value;               \
-               arcs_count++;                                   \
-               oid_text = endp - 1;                            \
-               break;                                          \
-       case ASN_STRTOL_ERROR_RANGE:                            \
-               if(opt_oid_text_end)                            \
-                       *opt_oid_text_end = oid_text;           \
-               errno = ERANGE;                                 \
-               return -1;                                      \
-       case ASN_STRTOL_ERROR_INVAL:                            \
-       case ASN_STRTOL_EXPECT_MORE:                            \
-               if(opt_oid_text_end)                            \
-                       *opt_oid_text_end = oid_text;           \
-               errno = EINVAL;                                 \
-               return -1;                                      \
-       }                                                       \
-  } while(0)
-
-       for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; oid_text++) {
+#define _OID_CAPTURE_ARC(oid_text, oid_end)                       \
+    do {                                                          \
+        const char *endp = oid_end;                               \
+        unsigned long value;                                      \
+        switch(asn_strtoul_lim(oid_text, &endp, &value)) {        \
+        case ASN_STRTOX_EXTRA_DATA:                               \
+        case ASN_STRTOX_OK:                                       \
+            if(value <= ASN_OID_ARC_MAX) {                        \
+                if(num_arcs < arcs_count) arcs[num_arcs] = value; \
+                num_arcs++;                                       \
+                oid_text = endp - 1;                              \
+                break;                                            \
+            }                                                     \
+            /* Fall through */                                    \
+        case ASN_STRTOX_ERROR_RANGE:                              \
+            if(opt_oid_text_end) *opt_oid_text_end = oid_text;    \
+            errno = ERANGE;                                       \
+            return -1;                                            \
+        case ASN_STRTOX_ERROR_INVAL:                              \
+        case ASN_STRTOX_EXPECT_MORE:                              \
+            if(opt_oid_text_end) *opt_oid_text_end = oid_text;    \
+            errno = EINVAL;                                       \
+            return -1;                                            \
+        }                                                         \
+    } while(0)
+
+    for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; oid_text++) {
            switch(*oid_text) {
            case 0x09: case 0x0a: case 0x0d: case 0x20: /* whitespace */
                switch(state) {
            switch(*oid_text) {
            case 0x09: case 0x0a: case 0x0d: case 0x20: /* whitespace */
                switch(state) {
@@ -754,11 +569,75 @@ OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
                return -1;
        case ST_AFTERVALUE:
        case ST_TAILSPACE:
                return -1;
        case ST_AFTERVALUE:
        case ST_TAILSPACE:
-               return arcs_count;
+               return num_arcs;
        }
 
        errno = EINVAL; /* Broken OID */
        return -1;
 }
 
        }
 
        errno = EINVAL; /* Broken OID */
        return -1;
 }
 
+/*
+ * Generate values from the list of interesting values, or just a random
+ * value up to the upper limit.
+ */
+static asn_oid_arc_t
+OBJECT_IDENTIFIER__biased_random_arc(asn_oid_arc_t upper_bound) {
+    const asn_oid_arc_t values[] = {0, 1, 127, 128, 129, 254, 255, 256};
+    size_t idx;
+
+    switch(asn_random_between(0, 2)) {
+    case 0:
+        idx = asn_random_between(0, sizeof(values) / sizeof(values[0]) - 1);
+        if(values[idx] < upper_bound) {
+            return values[idx];
+        }
+        /* Fall through */
+    case 1:
+        return asn_random_between(0, upper_bound);
+    case 2:
+    default:
+        return upper_bound;
+    }
+}
 
 
+asn_random_fill_result_t
+OBJECT_IDENTIFIER_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                              const asn_encoding_constraints_t *constraints,
+                              size_t max_length) {
+    asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    OBJECT_IDENTIFIER_t *st;
+    asn_oid_arc_t arcs[5];
+    size_t arcs_len = asn_random_between(2, 5);
+    size_t i;
+
+    (void)constraints;
+
+    if(max_length < arcs_len) return result_skipped;
+
+    if(*sptr) {
+        st = *sptr;
+    } else {
+        st = CALLOC(1, sizeof(*st));
+    }
+
+    arcs[0] = asn_random_between(0, 2);
+    arcs[1] = OBJECT_IDENTIFIER__biased_random_arc(
+        arcs[0] <= 1 ? 39 : (ASN_OID_ARC_MAX - 80));
+    for(i = 2; i < arcs_len; i++) {
+        arcs[i] = OBJECT_IDENTIFIER__biased_random_arc(ASN_OID_ARC_MAX);
+    }
+
+    if(OBJECT_IDENTIFIER_set_arcs(st, arcs, arcs_len)) {
+        if(st != *sptr) {
+            ASN_STRUCT_FREE(*td, st);
+        }
+        return result_failed;
+    }
+
+    *sptr = st;
+
+    result_ok.length = st->size;
+    return result_ok;
+}
index 5420dedecab20670a8c6a6c36c2ef3ae94b1b52e..a69285166c8d9e2cd94d3dba8fc1463ab501093c 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>.
  * All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
  * All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 static const ber_tlv_tag_t asn_DEF_OCTET_STRING_tags[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
 };
 static const ber_tlv_tag_t asn_DEF_OCTET_STRING_tags[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
 };
-static const asn_OCTET_STRING_specifics_t asn_DEF_OCTET_STRING_specs = {
+asn_OCTET_STRING_specifics_t asn_SPC_OCTET_STRING_specs = {
        sizeof(OCTET_STRING_t),
        offsetof(OCTET_STRING_t, _asn_ctx),
        ASN_OSUBV_STR
 };
        sizeof(OCTET_STRING_t),
        offsetof(OCTET_STRING_t, _asn_ctx),
        ASN_OSUBV_STR
 };
-static const 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 */
+
+asn_TYPE_operation_t asn_OP_OCTET_STRING = {
        OCTET_STRING_free,
        OCTET_STRING_free,
-       OCTET_STRING_print,     /* non-ascii stuff, generally */
-       asn_generic_no_constraint,
+       OCTET_STRING_print,     /* OCTET STRING generally means a non-ascii sequence */
+       OCTET_STRING_compare,
        OCTET_STRING_decode_ber,
        OCTET_STRING_encode_der,
        OCTET_STRING_decode_xer_hex,
        OCTET_STRING_encode_xer,
        OCTET_STRING_decode_ber,
        OCTET_STRING_encode_der,
        OCTET_STRING_decode_xer_hex,
        OCTET_STRING_encode_xer,
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       OCTET_STRING_decode_oer,
+       OCTET_STRING_encode_oer,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
        OCTET_STRING_decode_uper,       /* Unaligned PER decoder */
        OCTET_STRING_encode_uper,       /* Unaligned PER encoder */
        OCTET_STRING_decode_uper,       /* Unaligned PER decoder */
        OCTET_STRING_encode_uper,       /* Unaligned PER encoder */
-       0, /* Use generic outmost tag fetcher */
+#endif /* ASN_DISABLE_PER_SUPPORT */
+       OCTET_STRING_random_fill,
+       0       /* Use generic outmost tag fetcher */
+};
+asn_TYPE_descriptor_t asn_DEF_OCTET_STRING = {
+       "OCTET STRING",         /* Canonical name */
+       "OCTET_STRING",         /* XML tag name */
+       &asn_OP_OCTET_STRING,
        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]),
        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, asn_generic_no_constraint },
        0, 0,   /* No members */
        0, 0,   /* No members */
-       &asn_DEF_OCTET_STRING_specs
+       &asn_SPC_OCTET_STRING_specs
 };
 
 #undef _CH_PHASE
 };
 
 #undef _CH_PHASE
@@ -111,14 +123,14 @@ asn_TYPE_descriptor_t asn_DEF_OCTET_STRING = {
  * No, I am not going to explain what the following stuff is.
  */
 struct _stack_el {
  * 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;
+    ber_tlv_len_t left;     /* What's left to read (or -1) */
+    ber_tlv_len_t got;      /* What was actually processed */
+    unsigned 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 {
        struct _stack_el *tail;
@@ -157,7 +169,7 @@ OS__add_stack_el(struct _stack *st) {
 }
 
 static struct _stack *
 }
 
 static struct _stack *
-_new_stack() {
+_new_stack(void) {
        return (struct _stack *)CALLOC(1, sizeof(struct _stack));
 }
 
        return (struct _stack *)CALLOC(1, sizeof(struct _stack));
 }
 
@@ -165,12 +177,12 @@ _new_stack() {
  * Decode OCTET STRING type.
  */
 asn_dec_rval_t
  * 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;
+OCTET_STRING_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
+                        const asn_TYPE_descriptor_t *td, void **sptr,
+                        const void *buf_ptr, size_t size, int tag_mode) {
+    const asn_OCTET_STRING_specifics_t *specs = td->specifics
+                               ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                               : &asn_SPC_OCTET_STRING_specs;
        BIT_STRING_t *st = (BIT_STRING_t *)*sptr;
        asn_dec_rval_t rval;
        asn_struct_ctx_t *ctx;
        BIT_STRING_t *st = (BIT_STRING_t *)*sptr;
        asn_dec_rval_t rval;
        asn_struct_ctx_t *ctx;
@@ -213,9 +225,7 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
                         * Complex operation, requires stack of expectations.
                         */
                        ctx->ptr = _new_stack();
                         * Complex operation, requires stack of expectations.
                         */
                        ctx->ptr = _new_stack();
-                       if(ctx->ptr) {
-                               stck = (struct _stack *)ctx->ptr;
-                       } else {
+                       if(!ctx->ptr) {
                                RETURN(RC_FAIL);
                        }
                } else {
                                RETURN(RC_FAIL);
                        }
                } else {
@@ -244,11 +254,11 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
                ber_tlv_tag_t expected_tag;
                ssize_t tl, ll, tlvl;
                                /* This one works even if (sel->left == -1) */
                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);
+               size_t Left = ((!sel||(size_t)sel->left >= size)
+                                       ?size:(size_t)sel->left);
 
 
 
 
-               ASN_DEBUG("%p, s->l=%ld, s->wn=%ld, s->g=%ld\n", sel,
+               ASN_DEBUG("%p, s->l=%ld, s->wn=%ld, s->g=%ld\n", (void *)sel,
                        (long)(sel?sel->left:0),
                        (long)(sel?sel->want_nulls:0),
                        (long)(sel?sel->got:0)
                        (long)(sel?sel->left:0),
                        (long)(sel?sel->want_nulls:0),
                        (long)(sel?sel->got:0)
@@ -333,7 +343,7 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
                case ASN_OSUBV_STR:
                default:
                        if(sel) {
                case ASN_OSUBV_STR:
                default:
                        if(sel) {
-                               int level = sel->cont_level;
+                               unsigned level = sel->cont_level;
                                if(level < td->all_tags_count) {
                                        expected_tag = td->all_tags[level];
                                        break;
                                if(level < td->all_tags_count) {
                                        expected_tag = td->all_tags[level];
                                        break;
@@ -396,7 +406,7 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
                sel->got += tlvl;
                ADVANCE(tlvl);
 
                sel->got += tlvl;
                ADVANCE(tlvl);
 
-               ASN_DEBUG("+EXPECT2 got=%ld left=%ld, wn=%d, clvl=%d",
+               ASN_DEBUG("+EXPECT2 got=%ld left=%ld, wn=%d, clvl=%u",
                        (long)sel->got, (long)sel->left,
                        sel->want_nulls, sel->cont_level);
 
                        (long)sel->got, (long)sel->left,
                        sel->want_nulls, sel->cont_level);
 
@@ -485,7 +495,7 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
 
        if(sel) {
                ASN_DEBUG("3sel p=%p, wn=%d, l=%ld, g=%ld, size=%ld",
 
        if(sel) {
                ASN_DEBUG("3sel p=%p, wn=%d, l=%ld, g=%ld, size=%ld",
-                       sel->prev, sel->want_nulls,
+                       (void *)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);
                        (long)sel->left, (long)sel->got, (long)size);
                if(sel->prev || sel->want_nulls > 1 || sel->left > 0) {
                        RETURN(RC_WMORE);
@@ -495,9 +505,18 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
        /*
         * BIT STRING-specific processing.
         */
        /*
         * 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;
+       if(type_variant == ASN_OSUBV_BIT) {
+        if(st->size) {
+                       if(st->bits_unused < 0 || st->bits_unused > 7) {
+                               RETURN(RC_FAIL);
+                       }
+                       /* Finalize BIT STRING: zero out unused bits. */
+                       st->buf[st->size-1] &= 0xff << st->bits_unused;
+               } else {
+                       if(st->bits_unused) {
+                               RETURN(RC_FAIL);
+                       }
+               }
        }
 
        ASN_DEBUG("Took %ld bytes to encode %s: [%s]:%ld",
        }
 
        ASN_DEBUG("Took %ld bytes to encode %s: [%s]:%ld",
@@ -513,14 +532,14 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
  * Encode OCTET STRING type using DER.
  */
 asn_enc_rval_t
  * 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;
+OCTET_STRING_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,
+                        int tag_mode, ber_tlv_tag_t tag,
+                        asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_enc_rval_t er;
+       const asn_OCTET_STRING_specifics_t *specs = td->specifics
+                               ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                               : &asn_SPC_OCTET_STRING_specs;
+       const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
        enum asn_OS_Subvariant type_variant = specs->subvariant;
        int fix_last_byte = 0;
 
        enum asn_OS_Subvariant type_variant = specs->subvariant;
        int fix_last_byte = 0;
 
@@ -558,7 +577,6 @@ OCTET_STRING_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
                uint8_t b = st->bits_unused & 0x07;
                if(b && st->size) fix_last_byte = 1;
                ASN__CALLBACK(&b, 1);
                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 */
        }
 
        /* Invoke callback for the main part of the buffer */
@@ -570,17 +588,16 @@ OCTET_STRING_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
                ASN__CALLBACK(&b, 1);
        }
 
                ASN__CALLBACK(&b, 1);
        }
 
-       er.encoded += st->size;
        ASN__ENCODED_OK(er);
 cb_failed:
        ASN__ENCODE_FAILED;
 }
 
 asn_enc_rval_t
        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) {
-       const char * const h2c = "0123456789ABCDEF";
+OCTET_STRING_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                        int ilevel, enum xer_encoder_flags_e flags,
+                        asn_app_consume_bytes_f *cb, void *app_key) {
+    const char * const h2c = "0123456789ABCDEF";
        const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
        asn_enc_rval_t er;
        char scratch[16 * 3 + 4];
        const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
        asn_enc_rval_t er;
        char scratch[16 * 3 + 4];
@@ -604,7 +621,6 @@ OCTET_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
                for(; buf < end; buf++) {
                        if(p >= scend) {
                                ASN__CALLBACK(scratch, p - scratch);
                for(; buf < end; buf++) {
                        if(p >= scend) {
                                ASN__CALLBACK(scratch, p - scratch);
-                               er.encoded += p - scratch;
                                p = scratch;
                        }
                        *p++ = h2c[(*buf >> 4) & 0x0F];
                                p = scratch;
                        }
                        *p++ = h2c[(*buf >> 4) & 0x0F];
@@ -612,12 +628,10 @@ OCTET_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
                }
 
                ASN__CALLBACK(scratch, p-scratch);      /* Dump the rest */
                }
 
                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);
        } 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;
                                ASN__TEXT_INDENT(1, ilevel);
                        }
                                p = scratch;
                                ASN__TEXT_INDENT(1, ilevel);
                        }
@@ -628,7 +642,6 @@ OCTET_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
                if(p - scratch) {
                        p--;    /* Remove the tail space */
                        ASN__CALLBACK(scratch, p-scratch); /* Dump the rest */
                if(p - scratch) {
                        p--;    /* Remove the tail space */
                        ASN__CALLBACK(scratch, p-scratch); /* Dump the rest */
-                       er.encoded += p - scratch;
                        if(st->size > 16)
                                ASN__TEXT_INDENT(1, ilevel-1);
                }
                        if(st->size > 16)
                                ASN__TEXT_INDENT(1, ilevel-1);
                }
@@ -733,10 +746,10 @@ OCTET_STRING__handle_control_chars(void *struct_ptr, const void *chunk_buf, size
 }
 
 asn_enc_rval_t
 }
 
 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;
+OCTET_STRING_encode_xer_utf8(const asn_TYPE_descriptor_t *td, const 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 */
        asn_enc_rval_t er;
        uint8_t *buf, *end;
        uint8_t *ss;    /* Sequence start */
@@ -790,8 +803,8 @@ static ssize_t OCTET_STRING__convert_hexadecimal(void *sptr, const void *chunk_b
        uint8_t *buf;
 
        /* Reallocate buffer according to high cap estimation */
        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);
+       size_t new_size = st->size + (chunk_size + 1) / 2;
+       void *nptr = REALLOC(st->buf, new_size + 1);
        if(!nptr) return -1;
        st->buf = (uint8_t *)nptr;
        buf = st->buf + st->size;
        if(!nptr) return -1;
        st->buf = (uint8_t *)nptr;
        buf = st->buf + st->size;
@@ -848,7 +861,7 @@ static ssize_t OCTET_STRING__convert_hexadecimal(void *sptr, const void *chunk_b
        }
 
        st->size = buf - st->buf;       /* Adjust the buffer size */
        }
 
        st->size = buf - st->buf;       /* Adjust the buffer size */
-       assert(st->size <= _ns);
+       assert(st->size <= new_size);
        st->buf[st->size] = 0;          /* Courtesy termination */
 
        return (chunk_stop - (const char *)chunk_buf);  /* Converted size */
        st->buf[st->size] = 0;          /* Courtesy termination */
 
        return (chunk_stop - (const char *)chunk_buf);  /* Converted size */
@@ -865,8 +878,8 @@ static ssize_t OCTET_STRING__convert_binary(void *sptr, const void *chunk_buf, s
        uint8_t *buf;
 
        /* Reallocate buffer according to high cap estimation */
        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);
+       size_t new_size = st->size + (chunk_size + 7) / 8;
+       void *nptr = REALLOC(st->buf, new_size + 1);
        if(!nptr) return -1;
        st->buf = (uint8_t *)nptr;
        buf = st->buf + st->size;
        if(!nptr) return -1;
        st->buf = (uint8_t *)nptr;
        buf = st->buf + st->size;
@@ -910,7 +923,7 @@ static ssize_t OCTET_STRING__convert_binary(void *sptr, const void *chunk_buf, s
                st->bits_unused = bits_unused;
        }
 
                st->bits_unused = bits_unused;
        }
 
-       assert(st->size <= _ns);
+       assert(st->size <= new_size);
        st->buf[st->size] = 0;          /* Courtesy termination */
 
        return chunk_size;      /* Converted in full */
        st->buf[st->size] = 0;          /* Courtesy termination */
 
        return chunk_size;      /* Converted in full */
@@ -921,16 +934,13 @@ static ssize_t OCTET_STRING__convert_binary(void *sptr, const void *chunk_buf, s
  */
 static int
 OS__strtoent(int base, const char *buf, const char *end, int32_t *ret_value) {
  */
 static int
 OS__strtoent(int base, const char *buf, const char *end, int32_t *ret_value) {
+       const int32_t last_unicode_codepoint = 0x10ffff;
        int32_t val = 0;
        const char *p;
 
        for(p = buf; p < end; p++) {
                int ch = *p;
 
        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*/
                switch(ch) {
                case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: /*01234*/
                case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: /*56789*/
@@ -950,6 +960,11 @@ OS__strtoent(int base, const char *buf, const char *end, int32_t *ret_value) {
                default:
                        return -1;      /* Character set error */
                }
                default:
                        return -1;      /* Character set error */
                }
+
+               /* Value exceeds the Unicode range. */
+               if(val > last_unicode_codepoint) {
+                       return -1;
+               }
        }
 
        *ret_value = -1;
        }
 
        *ret_value = -1;
@@ -959,15 +974,17 @@ OS__strtoent(int base, const char *buf, const char *end, int32_t *ret_value) {
 /*
  * Convert from the plain UTF-8 format, expanding entity references: "2 &lt; 3"
  */
 /*
  * 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;
+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 */
        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);
+       size_t new_size = st->size + chunk_size;
+       void *nptr = REALLOC(st->buf, new_size + 1);
        if(!nptr) return -1;
        st->buf = (uint8_t *)nptr;
        buf = st->buf + st->size;
        if(!nptr) return -1;
        st->buf = (uint8_t *)nptr;
        buf = st->buf + st->size;
@@ -1090,7 +1107,7 @@ static ssize_t OCTET_STRING__convert_entrefs(void *sptr, const void *chunk_buf,
        }
 
        st->size = buf - st->buf;
        }
 
        st->size = buf - st->buf;
-       assert(st->size <= _ns);
+       assert(st->size <= new_size);
        st->buf[st->size] = 0;          /* Courtesy termination */
 
        return chunk_size;      /* Converted in full */
        st->buf[st->size] = 0;          /* Courtesy termination */
 
        return chunk_size;      /* Converted in full */
@@ -1100,19 +1117,17 @@ static ssize_t OCTET_STRING__convert_entrefs(void *sptr, const void *chunk_buf,
  * Decode OCTET STRING from the XML element's body.
  */
 static asn_dec_rval_t
  * 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;
+OCTET_STRING__decode_xer(
+    const asn_codec_ctx_t *opt_codec_ctx, const 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;
+       const asn_OCTET_STRING_specifics_t *specs = td->specifics
+                               ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                               : &asn_SPC_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 */
        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 */
@@ -1160,10 +1175,11 @@ sta_failed:
  * Decode OCTET STRING from the hexadecimal data.
  */
 asn_dec_rval_t
  * 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,
+OCTET_STRING_decode_xer_hex(const asn_codec_ctx_t *opt_codec_ctx,
+                            const 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);
 }
 
                buf_ptr, size, 0, OCTET_STRING__convert_hexadecimal);
 }
 
@@ -1171,10 +1187,11 @@ OCTET_STRING_decode_xer_hex(asn_codec_ctx_t *opt_codec_ctx,
  * Decode OCTET STRING from the binary (0/1) data.
  */
 asn_dec_rval_t
  * 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,
+OCTET_STRING_decode_xer_binary(const asn_codec_ctx_t *opt_codec_ctx,
+                               const 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);
 }
 
                buf_ptr, size, 0, OCTET_STRING__convert_binary);
 }
 
@@ -1182,19 +1199,22 @@ OCTET_STRING_decode_xer_binary(asn_codec_ctx_t *opt_codec_ctx,
  * Decode OCTET STRING from the string (ASCII/UTF-8) data.
  */
 asn_dec_rval_t
  * 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,
+OCTET_STRING_decode_xer_utf8(const asn_codec_ctx_t *opt_codec_ctx,
+                             const 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);
 }
 
                buf_ptr, size,
                OCTET_STRING__handle_control_chars,
                OCTET_STRING__convert_entrefs);
 }
 
+#ifndef  ASN_DISABLE_PER_SUPPORT
+
 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,
 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) {
+               long lb, long ub, const asn_per_constraints_t *pc) {
        uint8_t *end = buf + units * bpc;
 
        ASN_DEBUG("Expanding %d characters into (%ld..%ld):%d",
        uint8_t *end = buf + units * bpc;
 
        ASN_DEBUG("Expanding %d characters into (%ld..%ld):%d",
@@ -1236,8 +1256,8 @@ OCTET_STRING_per_get_characters(asn_per_data_t *po, uint8_t *buf,
        }
 
        for(; buf < end; buf += bpc) {
        }
 
        for(; buf < end; buf += bpc) {
-               int code = per_get_few_bits(po, unit_bits);
-               int ch = code + lb;
+               int32_t code = per_get_few_bits(po, unit_bits);
+               int32_t ch = code + lb;
                if(code < 0) return -1; /* WMORE */
                if(ch > ub) {
                        ASN_DEBUG("Code %d is out of range (%ld..%ld)",
                if(code < 0) return -1; /* WMORE */
                if(ch > ub) {
                        ASN_DEBUG("Code %d is out of range (%ld..%ld)",
@@ -1258,7 +1278,7 @@ OCTET_STRING_per_get_characters(asn_per_data_t *po, uint8_t *buf,
 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,
 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) {
+               long lb, long ub, const asn_per_constraints_t *pc) {
        const uint8_t *end = buf + units * bpc;
 
        ASN_DEBUG("Squeezing %d characters into (%ld..%ld):%d (%d bpc)",
        const uint8_t *end = buf + units * bpc;
 
        ASN_DEBUG("Squeezing %d characters into (%ld..%ld):%d (%d bpc)",
@@ -1296,48 +1316,57 @@ OCTET_STRING_per_put_characters(asn_per_outp_t *po, const uint8_t *buf,
                return per_put_many_bits(po, buf, unit_bits * units);
        }
 
                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;
+    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,
+                      value, lb, ub + lb);
+            return -1;
+        }
+        if(per_put_few_bits(po, ch, unit_bits)) return -1;
+    }
+
+    return 0;
 }
 
 }
 
+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_dec_rval_t
 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;
+OCTET_STRING_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                         const asn_TYPE_descriptor_t *td,
+                         const asn_per_constraints_t *constraints, void **sptr,
+                         asn_per_data_t *pd) {
+    const asn_OCTET_STRING_specifics_t *specs = td->specifics
+               ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+               : &asn_SPC_OCTET_STRING_specs;
+    const asn_per_constraints_t *pc =
+        constraints ? constraints : td->encoding_constraints.per_constraints;
+    const asn_per_constraint_t *cval;
+       const asn_per_constraint_t *csiz;
        asn_dec_rval_t rval = { RC_OK, 0 };
        asn_dec_rval_t rval = { RC_OK, 0 };
-       BIT_STRING_t *st = (BIT_STRING_t *)*sptr;
+       OCTET_STRING_t *st = (OCTET_STRING_t *)*sptr;
        ssize_t consumed_myself = 0;
        int repeat;
        enum {
        ssize_t consumed_myself = 0;
        int repeat;
        enum {
-               OS__BPC_BIT     = 0,
                OS__BPC_CHAR    = 1,
                OS__BPC_U16     = 2,
                OS__BPC_U32     = 4
                OS__BPC_CHAR    = 1,
                OS__BPC_U16     = 2,
                OS__BPC_U32     = 4
@@ -1358,11 +1387,9 @@ OCTET_STRING_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
        switch(specs->subvariant) {
        default:
        case ASN_OSUBV_ANY:
        switch(specs->subvariant) {
        default:
        case ASN_OSUBV_ANY:
+       case ASN_OSUBV_BIT:
                ASN_DEBUG("Unrecognized subvariant %d", specs->subvariant);
                RETURN(RC_FAIL);
                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;
                break;
        case ASN_OSUBV_STR:
                canonical_unit_bits = unit_bits = 8;
@@ -1388,7 +1415,7 @@ OCTET_STRING_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
         * Allocate the string.
         */
        if(!st) {
         * Allocate the string.
         */
        if(!st) {
-               st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
+               st = (OCTET_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
                if(!st) RETURN(RC_FAIL);
        }
 
                if(!st) RETURN(RC_FAIL);
        }
 
@@ -1401,7 +1428,6 @@ OCTET_STRING_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
                if(inext < 0) RETURN(RC_WMORE);
                if(inext) {
                        csiz = &asn_DEF_OCTET_STRING_constraints.size;
                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;
                }
        }
                        unit_bits = canonical_unit_bits;
                }
        }
@@ -1438,10 +1464,6 @@ OCTET_STRING_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
                if(ret < 0) RETURN(RC_WMORE);
                consumed_myself += unit_bits * csiz->upper_bound;
                st->buf[st->size] = 0;
                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);
        }
 
                RETURN(RC_OK);
        }
 
@@ -1449,41 +1471,27 @@ OCTET_STRING_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
        do {
                ssize_t raw_len;
                ssize_t len_bytes;
        do {
                ssize_t raw_len;
                ssize_t len_bytes;
-               ssize_t len_bits;
                void *p;
                int ret;
 
                /* Get the PER length */
                void *p;
                int ret;
 
                /* Get the PER length */
-               raw_len = uper_get_length(pd, csiz->effective_bits, &repeat);
+               raw_len = uper_get_length(pd, csiz->effective_bits, csiz->lower_bound,
+                                         &repeat);
                if(raw_len < 0) RETURN(RC_WMORE);
                if(raw_len < 0) RETURN(RC_WMORE);
-               raw_len += csiz->lower_bound;
+               if(raw_len == 0 && st->buf) break;
 
                ASN_DEBUG("Got PER length eb %ld, len %ld, %s (%s)",
                        (long)csiz->effective_bits, (long)raw_len,
                        repeat ? "repeat" : "once", td->name);
 
                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 */
-               }
+        len_bytes = raw_len * bpc;
                p = REALLOC(st->buf, st->size + len_bytes + 1);
                if(!p) RETURN(RC_FAIL);
                st->buf = (uint8_t *)p;
 
                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);
-               }
+        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);
                if(ret < 0) RETURN(RC_WMORE);
                st->size += len_bytes;
        } while(repeat);
                if(ret < 0) RETURN(RC_WMORE);
                st->size += len_bytes;
        } while(repeat);
@@ -1493,26 +1501,25 @@ OCTET_STRING_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
 }
 
 asn_enc_rval_t
 }
 
 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;
+OCTET_STRING_encode_uper(const asn_TYPE_descriptor_t *td,
+                         const asn_per_constraints_t *constraints,
+                         const void *sptr, asn_per_outp_t *po) {
+    const asn_OCTET_STRING_specifics_t *specs = td->specifics
+               ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+               : &asn_SPC_OCTET_STRING_specs;
+       const asn_per_constraints_t *pc = constraints ? constraints
+                               : td->encoding_constraints.per_constraints;
+       const asn_per_constraint_t *cval;
+       const asn_per_constraint_t *csiz;
+       const OCTET_STRING_t *st = (const OCTET_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;
        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;
+       size_t size_in_units;
        const uint8_t *buf;
        int ret;
        enum {
        const uint8_t *buf;
        int ret;
        enum {
-               OS__BPC_BIT     = 0,
                OS__BPC_CHAR    = 1,
                OS__BPC_U16     = 2,
                OS__BPC_U32     = 4
                OS__BPC_CHAR    = 1,
                OS__BPC_U16     = 2,
                OS__BPC_U32     = 4
@@ -1534,128 +1541,114 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
        switch(specs->subvariant) {
        default:
        case ASN_OSUBV_ANY:
        switch(specs->subvariant) {
        default:
        case ASN_OSUBV_ANY:
-               ASN__ENCODE_FAILED;
        case ASN_OSUBV_BIT:
        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;
+               ASN__ENCODE_FAILED;
        case ASN_OSUBV_STR:
                canonical_unit_bits = unit_bits = 8;
                if(cval->flags & APC_CONSTRAINED)
                        unit_bits = cval->range_bits;
                bpc = OS__BPC_CHAR;
        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;
+               size_in_units = 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;
                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;
+               size_in_units = st->size >> 1;
+               if(st->size & 1) {
+                       ASN_DEBUG("%s string size is not modulo 2", td->name);
+                       ASN__ENCODE_FAILED;
+               }
                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;
        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;
+               size_in_units = st->size >> 2;
+               if(st->size & 3) {
+                       ASN_DEBUG("%s string size is not modulo 4", td->name);
+                       ASN__ENCODE_FAILED;
+               }
                break;
        }
 
                break;
        }
 
-       ASN_DEBUG("Encoding %s into %d units of %d bits"
+       ASN_DEBUG("Encoding %s into %" ASN_PRI_SIZE " units of %d bits"
                " (%ld..%ld, effective %d)%s",
                " (%ld..%ld, effective %d)%s",
-               td->name, sizeinunits, unit_bits,
+               td->name, size_in_units, unit_bits,
                csiz->lower_bound, csiz->upper_bound,
                csiz->effective_bits, ct_extensible ? " EXT" : "");
 
        /* Figure out whether size lies within PER visible constraint */
 
                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) {
+    if(csiz->effective_bits >= 0) {
+        if((ssize_t)size_in_units < csiz->lower_bound
+           || (ssize_t)size_in_units > csiz->upper_bound) {
+            if(ct_extensible) {
+                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;
        }
 
                /* 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);
+    if(csiz->effective_bits >= 0 && !inext) {
+        ASN_DEBUG("Encoding %" ASN_PRI_SIZE " bytes (%ld), length in %d bits", st->size,
+                  size_in_units - csiz->lower_bound, csiz->effective_bits);
+        ret = per_put_few_bits(po, size_in_units - csiz->lower_bound,
+                               csiz->effective_bits);
+        if(ret) ASN__ENCODE_FAILED;
+        ret = OCTET_STRING_per_put_characters(po, st->buf, size_in_units, bpc,
+                                              unit_bits, cval->lower_bound,
+                                              cval->upper_bound, pc);
+        if(ret) ASN__ENCODE_FAILED;
+        ASN__ENCODED_OK(er);
+    }
+
+    ASN_DEBUG("Encoding %" ASN_PRI_SIZE " bytes", st->size);
+
+    buf = st->buf;
+    ASN_DEBUG("Encoding %" ASN_PRI_SIZE " in units", size_in_units);
+    do {
+        int need_eom = 0;
+        ssize_t may_save = uper_put_length(po, size_in_units, &need_eom);
+        if(may_save < 0) ASN__ENCODE_FAILED;
+
+        ASN_DEBUG("Encoding %" ASN_PRI_SSIZE " of %" ASN_PRI_SIZE "%s", may_save, size_in_units,
+                  need_eom ? ",+EOM" : "");
+
+        ret = OCTET_STRING_per_put_characters(po, buf, may_save, bpc, unit_bits,
+                                              cval->lower_bound,
+                                              cval->upper_bound, pc);
+        if(ret) ASN__ENCODE_FAILED;
+
+        buf += may_save * bpc;
+        size_in_units -= may_save;
+        assert(!(may_save & 0x07) || !size_in_units);
+        if(need_eom && uper_put_length(po, 0, 0))
+            ASN__ENCODE_FAILED; /* End of Message length */
+    } while(size_in_units);
+
+    ASN__ENCODED_OK(er);
 }
 
 }
 
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
 int
 int
-OCTET_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
-       asn_app_consume_bytes_f *cb, void *app_key) {
-       const char * const h2c = "0123456789ABCDEF";
+OCTET_STRING_print(const asn_TYPE_descriptor_t *td, const void *sptr,
+                   int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+    const char * const h2c = "0123456789ABCDEF";
        const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
        char scratch[16 * 3 + 4];
        char *p = scratch;
        const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
        char scratch[16 * 3 + 4];
        char *p = scratch;
@@ -1695,9 +1688,10 @@ OCTET_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 }
 
 int
 }
 
 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;
+OCTET_STRING_print_utf8(const 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 */
 
        (void)td;       /* Unused argument */
        (void)ilevel;   /* Unused argument */
@@ -1710,9 +1704,10 @@ OCTET_STRING_print_utf8(asn_TYPE_descriptor_t *td, const void *sptr,
 }
 
 void
 }
 
 void
-OCTET_STRING_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
+OCTET_STRING_free(const asn_TYPE_descriptor_t *td, void *sptr,
+                  enum asn_struct_free_method method) {
        OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
        OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
-       asn_OCTET_STRING_specifics_t *specs;
+       const asn_OCTET_STRING_specifics_t *specs;
        asn_struct_ctx_t *ctx;
        struct _stack *stck;
 
        asn_struct_ctx_t *ctx;
        struct _stack *stck;
 
@@ -1720,8 +1715,8 @@ OCTET_STRING_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
                return;
 
        specs = td->specifics
                return;
 
        specs = td->specifics
-                   ? (asn_OCTET_STRING_specifics_t *)td->specifics
-                   : &asn_DEF_OCTET_STRING_specs;
+                   ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                   : &asn_SPC_OCTET_STRING_specs;
        ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
 
        ASN_DEBUG("Freeing %s as OCTET STRING", td->name);
        ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
 
        ASN_DEBUG("Freeing %s as OCTET STRING", td->name);
@@ -1744,9 +1739,20 @@ OCTET_STRING_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
                FREEMEM(stck);
        }
 
                FREEMEM(stck);
        }
 
-       if(!contents_only) {
-               FREEMEM(st);
-       }
+    switch(method) {
+    case ASFM_FREE_EVERYTHING:
+        FREEMEM(sptr);
+        break;
+    case ASFM_FREE_UNDERLYING:
+        break;
+    case ASFM_FREE_UNDERLYING_AND_RESET:
+        memset(sptr, 0,
+               td->specifics
+                   ? ((const asn_OCTET_STRING_specifics_t *)(td->specifics))
+                         ->struct_size
+                   : sizeof(OCTET_STRING_t));
+        break;
+    }
 }
 
 /*
 }
 
 /*
@@ -1790,11 +1796,12 @@ OCTET_STRING_fromBuf(OCTET_STRING_t *st, const char *str, int len) {
 }
 
 OCTET_STRING_t *
 }
 
 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;
+OCTET_STRING_new_fromBuf(const asn_TYPE_descriptor_t *td, const char *str,
+                         int len) {
+    const asn_OCTET_STRING_specifics_t *specs =
+        td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                      : &asn_SPC_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)) {
 
        st = (OCTET_STRING_t *)CALLOC(1, specs->struct_size);
        if(st && str && OCTET_STRING_fromBuf(st, str, len)) {
@@ -1805,3 +1812,232 @@ OCTET_STRING_new_fromBuf(asn_TYPE_descriptor_t *td, const char *str, int len) {
        return st;
 }
 
        return st;
 }
 
+/*
+ * Lexicographically compare the common prefix of both strings,
+ * and if it is the same return -1 for the smallest string.
+ */
+int
+OCTET_STRING_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
+                     const void *bptr) {
+    const asn_OCTET_STRING_specifics_t *specs = td->specifics;
+    const OCTET_STRING_t *a = aptr;
+    const OCTET_STRING_t *b = bptr;
+
+    assert(!specs || specs->subvariant != ASN_OSUBV_BIT);
+
+    if(a && b) {
+        size_t common_prefix_size = a->size <= b->size ? a->size : b->size;
+        int ret = memcmp(a->buf, b->buf, common_prefix_size);
+        if(ret == 0) {
+            /* Figure out which string with equal prefixes is longer. */
+            if(a->size < b->size) {
+                return -1;
+            } else if(a->size > b->size) {
+                return 1;
+            } else {
+                return 0;
+            }
+        } else {
+            return ret < 0 ? -1 : 1;
+        }
+    } else if(!a && !b) {
+        return 0;
+    } else if(!a) {
+        return -1;
+    } else {
+        return 1;
+    }
+
+}
+
+/*
+ * Biased function for randomizing character values around their limits.
+ */
+static uint32_t
+OCTET_STRING__random_char(unsigned long lb, unsigned long ub) {
+    assert(lb <= ub);
+    switch(asn_random_between(0, 16)) {
+    case 0:
+        if(lb < ub) return lb + 1;
+        /* Fall through */
+    case 1:
+        return lb;
+    case 2:
+        if(lb < ub) return ub - 1;
+        /* Fall through */
+    case 3:
+        return ub;
+    default:
+        return asn_random_between(lb, ub);
+    }
+}
+
+
+size_t
+OCTET_STRING_random_length_constrained(
+    const asn_TYPE_descriptor_t *td,
+    const asn_encoding_constraints_t *constraints, size_t max_length) {
+    const unsigned lengths[] = {0,     1,     2,     3,     4,     8,
+                                126,   127,   128,   16383, 16384, 16385,
+                                65534, 65535, 65536, 65537};
+    size_t rnd_len;
+
+    /* Figure out how far we should go */
+    rnd_len = lengths[asn_random_between(
+        0, sizeof(lengths) / sizeof(lengths[0]) - 1)];
+
+    if(!constraints || !constraints->per_constraints)
+        constraints = &td->encoding_constraints;
+    if(constraints->per_constraints) {
+        const asn_per_constraint_t *pc = &constraints->per_constraints->size;
+        if(pc->flags & APC_CONSTRAINED) {
+            long suggested_upper_bound = pc->upper_bound < (ssize_t)max_length
+                                             ? pc->upper_bound
+                                             : (ssize_t)max_length;
+            if(max_length <= (size_t)pc->lower_bound) {
+                return pc->lower_bound;
+            }
+            if(pc->flags & APC_EXTENSIBLE) {
+                switch(asn_random_between(0, 5)) {
+                case 0:
+                    if(pc->lower_bound > 0) {
+                        rnd_len = pc->lower_bound - 1;
+                        break;
+                    }
+                    /* Fall through */
+                case 1:
+                    rnd_len = pc->upper_bound + 1;
+                    break;
+                case 2:
+                    /* Keep rnd_len from the table */
+                    if(rnd_len <= max_length) {
+                        break;
+                    }
+                    /* Fall through */
+                default:
+                    rnd_len = asn_random_between(pc->lower_bound,
+                                                 suggested_upper_bound);
+                }
+            } else {
+                rnd_len =
+                    asn_random_between(pc->lower_bound, suggested_upper_bound);
+            }
+        } else {
+            rnd_len = asn_random_between(0, max_length);
+        }
+    } else if(rnd_len > max_length) {
+        rnd_len = asn_random_between(0, max_length);
+    }
+
+    return rnd_len;
+}
+
+asn_random_fill_result_t
+OCTET_STRING_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                         const asn_encoding_constraints_t *constraints,
+                         size_t max_length) {
+       const asn_OCTET_STRING_specifics_t *specs = td->specifics
+                               ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                               : &asn_SPC_OCTET_STRING_specs;
+    asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    unsigned int unit_bytes = 1;
+    unsigned long clb = 0;  /* Lower bound on char */
+    unsigned long cub = 255;  /* Higher bound on char value */
+    uint8_t *buf;
+    uint8_t *bend;
+    uint8_t *b;
+    size_t rnd_len;
+    OCTET_STRING_t *st;
+
+    if(max_length == 0 && !*sptr) return result_skipped;
+
+    switch(specs->subvariant) {
+    default:
+    case ASN_OSUBV_ANY:
+        return result_failed;
+    case ASN_OSUBV_BIT:
+        /* Handled by BIT_STRING itself. */
+        return result_failed;
+    case ASN_OSUBV_STR:
+        unit_bytes = 1;
+        clb = 0;
+        cub = 255;
+        break;
+    case ASN_OSUBV_U16:
+        unit_bytes = 2;
+        clb = 0;
+        cub = 65535;
+        break;
+    case ASN_OSUBV_U32:
+        unit_bytes = 4;
+        clb = 0;
+        cub = 0x10FFFF;
+        break;
+    }
+
+    if(!constraints || !constraints->per_constraints)
+        constraints = &td->encoding_constraints;
+    if(constraints->per_constraints) {
+        const asn_per_constraint_t *pc = &constraints->per_constraints->value;
+        if(pc->flags & APC_SEMI_CONSTRAINED) {
+            clb = pc->lower_bound;
+        } else if(pc->flags & APC_CONSTRAINED) {
+            clb = pc->lower_bound;
+            cub = pc->upper_bound;
+        }
+    }
+
+    rnd_len =
+        OCTET_STRING_random_length_constrained(td, constraints, max_length);
+
+    buf = CALLOC(unit_bytes, rnd_len + 1);
+    if(!buf) return result_failed;
+
+    bend = &buf[unit_bytes * rnd_len];
+
+    switch(unit_bytes) {
+    case 1:
+        for(b = buf; b < bend; b += unit_bytes) {
+            *(uint8_t *)b = OCTET_STRING__random_char(clb, cub);
+        }
+        *(uint8_t *)b = 0;
+        break;
+    case 2:
+        for(b = buf; b < bend; b += unit_bytes) {
+            uint32_t code = OCTET_STRING__random_char(clb, cub);
+            b[0] = code >> 8;
+            b[1] = code;
+        }
+        *(uint16_t *)b = 0;
+        break;
+    case 4:
+        for(b = buf; b < bend; b += unit_bytes) {
+            uint32_t code = OCTET_STRING__random_char(clb, cub);
+            b[0] = code >> 24;
+            b[1] = code >> 16;
+            b[2] = code >> 8;
+            b[3] = code;
+        }
+        *(uint32_t *)b = 0;
+        break;
+    }
+
+    if(*sptr) {
+        st = *sptr;
+        FREEMEM(st->buf);
+    } else {
+        st = (OCTET_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
+        if(!st) {
+            FREEMEM(buf);
+            return result_failed;
+        }
+    }
+
+    st->buf = buf;
+    st->size = unit_bytes * rnd_len;
+
+    result_ok.length = st->size;
+    return result_ok;
+}
diff --git a/libs/smux/OCTET_STRING_oer.c b/libs/smux/OCTET_STRING_oer.c
new file mode 100644 (file)
index 0000000..c16faea
--- /dev/null
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_DISABLE_OER_SUPPORT
+
+#include <asn_internal.h>
+#include <OCTET_STRING.h>
+#include <errno.h>
+
+asn_dec_rval_t
+OCTET_STRING_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
+                        const asn_TYPE_descriptor_t *td,
+                        const asn_oer_constraints_t *constraints, void **sptr,
+                        const void *ptr, size_t size) {
+    const asn_OCTET_STRING_specifics_t *specs =
+        td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                      : &asn_SPC_OCTET_STRING_specs;
+    OCTET_STRING_t *st = (OCTET_STRING_t *)*sptr;
+    const asn_oer_constraints_t *cts =
+        constraints ? constraints : td->encoding_constraints.oer_constraints;
+    ssize_t ct_size = cts ? cts->size : -1;
+    asn_dec_rval_t rval = {RC_OK, 0};
+    size_t expected_length = 0;
+
+    size_t unit_bytes;
+    switch(specs->subvariant) {
+    default:
+    case ASN_OSUBV_BIT:
+        ASN_DEBUG("Invalid use of OCTET STRING to decode BIT STRING");
+        ASN__DECODE_FAILED;
+    case ASN_OSUBV_ANY:
+        /* Fall through */
+    case ASN_OSUBV_STR:
+        unit_bytes = 1;
+        break;
+    case ASN_OSUBV_U16:
+        unit_bytes = 2;
+        break;
+    case ASN_OSUBV_U32:
+        unit_bytes = 4;
+        break;
+    }
+
+    (void)opt_codec_ctx;
+
+    if(!st) {
+        st = (OCTET_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
+        if(!st) ASN__DECODE_FAILED;
+    }
+
+    if(ct_size >= 0) {
+        expected_length = unit_bytes * ct_size;
+    } else {
+        /*
+         * X.696 (08/2015) #27.2
+         * Encode length determinant as _number of octets_, but only
+         * if upper bound is not equal to lower bound.
+         */
+        ssize_t len_len = oer_fetch_length(ptr, size, &expected_length);
+        if(len_len > 0) {
+            rval.consumed = len_len;
+            ptr = (const char *)ptr + len_len;
+            size -= len_len;
+        } else if(len_len == 0) {
+            ASN__DECODE_STARVED;
+        } else if(len_len < 0) {
+            ASN__DECODE_FAILED;
+        }
+
+        if(expected_length % unit_bytes != 0) {
+            ASN_DEBUG(
+                "Data size %" ASN_PRI_SIZE " bytes is not consistent with multiplier %" ASN_PRI_SIZE "",
+                expected_length, unit_bytes);
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    if(size < expected_length) {
+        ASN__DECODE_STARVED;
+    } else {
+        uint8_t *buf = MALLOC(expected_length + 1);
+        if(buf == NULL) {
+            ASN__DECODE_FAILED;
+        } else {
+            memcpy(buf, ptr, expected_length);
+            buf[expected_length] = '\0';
+        }
+        FREEMEM(st->buf);
+        st->buf = buf;
+        st->size = expected_length;
+
+        rval.consumed += expected_length;
+        return rval;
+    }
+}
+
+/*
+ * Encode as Canonical OER.
+ */
+asn_enc_rval_t
+OCTET_STRING_encode_oer(const asn_TYPE_descriptor_t *td,
+                        const asn_oer_constraints_t *constraints,
+                        const void *sptr, asn_app_consume_bytes_f *cb,
+                        void *app_key) {
+    const asn_OCTET_STRING_specifics_t *specs =
+        td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
+                      : &asn_SPC_OCTET_STRING_specs;
+    const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+    const asn_oer_constraints_t *cts =
+        constraints ? constraints : td->encoding_constraints.oer_constraints;
+    ssize_t ct_size = cts ? cts->size : -1;
+    asn_enc_rval_t er = {0, 0, 0};
+
+    if(!st) ASN__ENCODE_FAILED;
+
+    ASN_DEBUG("Encoding %s %" ASN_PRI_SIZE " as OCTET STRING", td ? td->name : "", st->size);
+
+    if(ct_size >= 0) {
+        /*
+         * Check that available data matches the constraint
+         */
+        size_t unit_bytes;
+        switch(specs->subvariant) {
+        default:
+        case ASN_OSUBV_BIT:
+            ASN_DEBUG("Invalid use of OCTET STRING to encode BIT STRING");
+            ASN__ENCODE_FAILED;
+        case ASN_OSUBV_ANY:
+            /* Fall through */
+        case ASN_OSUBV_STR:
+            unit_bytes = 1;
+            break;
+        case ASN_OSUBV_U16:
+            unit_bytes = 2;
+            break;
+        case ASN_OSUBV_U32:
+            unit_bytes = 4;
+            break;
+        }
+
+        if(st->size != unit_bytes * (size_t)ct_size) {
+            ASN_DEBUG(
+                "Trying to encode %s (%" ASN_PRI_SIZE " bytes) which doesn't fit SIZE "
+                "constraint (%" ASN_PRI_SIZE ")",
+                td->name, st->size, ct_size);
+            ASN__ENCODE_FAILED;
+        }
+    } else {
+        /*
+         * X.696 (08/2015) #27.2
+         * Encode length determinant as _number of octets_, but only
+         * if upper bound is not equal to lower bound.
+         */
+        ssize_t ret = oer_serialize_length(st->size, cb, app_key);
+        if(ret < 0) {
+            ASN__ENCODE_FAILED;
+        }
+        er.encoded += ret;
+    }
+
+    er.encoded += st->size;
+    if(cb(st->buf, st->size, app_key) < 0) {
+        ASN__ENCODE_FAILED;
+    } else {
+        ASN__ENCODED_OK(er);
+    }
+}
+
+#endif  /* ASN_DISABLE_OER_SUPPORT */
diff --git a/libs/smux/OPEN_TYPE.c b/libs/smux/OPEN_TYPE.c
new file mode 100644 (file)
index 0000000..c672992
--- /dev/null
@@ -0,0 +1,402 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <OPEN_TYPE.h>
+#include <constr_CHOICE.h>
+#include <per_opentype.h>
+#include <errno.h>
+
+asn_TYPE_operation_t asn_OP_OPEN_TYPE = {
+       OPEN_TYPE_free,
+       OPEN_TYPE_print,
+       OPEN_TYPE_compare,
+       OPEN_TYPE_decode_ber,
+       OPEN_TYPE_encode_der,
+       OPEN_TYPE_decode_xer,
+       OPEN_TYPE_encode_xer,
+       0, 0,   /* No OER support, use "-gen-OER" to enable */
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0, 0,
+#else
+       OPEN_TYPE_decode_uper,
+       OPEN_TYPE_encode_uper,
+#endif
+       0,  /* Random fill is not supported for open type */
+       0,      /* Use generic outmost tag fetcher */
+};
+
+#undef  ADVANCE
+#define ADVANCE(num_bytes)               \
+    do {                                 \
+        size_t num = num_bytes;          \
+        ptr = ((const char *)ptr) + num; \
+        size -= num;                     \
+        consumed_myself += num;          \
+    } while(0)
+
+asn_dec_rval_t
+OPEN_TYPE_ber_get(const asn_codec_ctx_t *opt_codec_ctx,
+                  const asn_TYPE_descriptor_t *td, void *sptr,
+                  const asn_TYPE_member_t *elm, const void *ptr, size_t size) {
+    size_t consumed_myself = 0;
+    asn_type_selector_result_t selected;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *inner_value;
+    asn_dec_rval_t rv;
+
+    if(!(elm->flags & ATF_OPEN_TYPE)) {
+        ASN__DECODE_FAILED;
+    }
+
+    if(!elm->type_selector) {
+        ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
+                  td->name, elm->name, elm->type->name);
+        ASN__DECODE_FAILED;
+    }
+
+    selected = elm->type_selector(td, sptr);
+    if(!selected.presence_index) {
+        ASN__DECODE_FAILED;
+    }
+
+    /* Fetch the pointer to this member */
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+    } else {
+        memb_ptr = (char *)sptr + elm->memb_offset;
+        memb_ptr2 = &memb_ptr;
+    }
+    if(*memb_ptr2 != NULL) {
+        /* Make sure we reset the structure first before encoding */
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0) != 0) {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    inner_value =
+        (char *)*memb_ptr2
+        + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+    ASN_DEBUG("presence %d\n", selected.presence_index);
+
+    rv = selected.type_descriptor->op->ber_decoder(
+        opt_codec_ctx, selected.type_descriptor, &inner_value, ptr, size,
+        elm->tag_mode);
+    ADVANCE(rv.consumed);
+    rv.consumed = 0;
+    switch(rv.code) {
+    case RC_OK:
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+                                       selected.presence_index)
+           == 0) {
+            rv.code = RC_OK;
+            rv.consumed = consumed_myself;
+            return rv;
+        } else {
+            /* Oh, now a full-blown failure failure */
+        }
+        /* Fall through */
+    case RC_FAIL:
+        rv.consumed = consumed_myself;
+        /* Fall through */
+    case RC_WMORE:
+        break;
+    }
+
+    if(*memb_ptr2) {
+        const asn_CHOICE_specifics_t *specs =
+            selected.type_descriptor->specifics;
+        if(elm->flags & ATF_POINTER) {
+            ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+            *memb_ptr2 = NULL;
+        } else {
+            ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
+                                          inner_value);
+            memset(*memb_ptr2, 0, specs->struct_size);
+        }
+    }
+    return rv;
+}
+
+asn_dec_rval_t
+OPEN_TYPE_xer_get(const asn_codec_ctx_t *opt_codec_ctx,
+                  const asn_TYPE_descriptor_t *td, void *sptr,
+                  const asn_TYPE_member_t *elm, const void *ptr, size_t size) {
+    size_t consumed_myself = 0;
+    asn_type_selector_result_t selected;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *inner_value;
+    asn_dec_rval_t rv;
+
+    int xer_context = 0;
+    ssize_t ch_size;
+    pxer_chunk_type_e ch_type;
+
+    if(!(elm->flags & ATF_OPEN_TYPE)) {
+        ASN__DECODE_FAILED;
+    }
+
+    if(!elm->type_selector) {
+        ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
+                  td->name, elm->name, elm->type->name);
+        ASN__DECODE_FAILED;
+    }
+
+    selected = elm->type_selector(td, sptr);
+    if(!selected.presence_index) {
+        ASN__DECODE_FAILED;
+    }
+
+    /* Fetch the pointer to this member */
+    assert(elm->flags == ATF_OPEN_TYPE);
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+    } else {
+        memb_ptr = (char *)sptr + elm->memb_offset;
+        memb_ptr2 = &memb_ptr;
+    }
+    if(*memb_ptr2 != NULL) {
+        /* Make sure we reset the structure first before encoding */
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0)
+           != 0) {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    /*
+     * Confirm wrapper.
+     */
+    for(;;) {
+        ch_size = xer_next_token(&xer_context, ptr, size, &ch_type);
+        if(ch_size < 0) {
+            ASN__DECODE_FAILED;
+        } else {
+            switch(ch_type) {
+            case PXER_WMORE:
+                ASN__DECODE_STARVED;
+            case PXER_COMMENT:
+            case PXER_TEXT:
+                ADVANCE(ch_size);
+                continue;
+            case PXER_TAG:
+                break;
+            }
+            break;
+        }
+    }
+
+    /*
+     * Wrapper value confirmed.
+     */
+    switch(xer_check_tag(ptr, ch_size, elm->name)) {
+    case XCT_OPENING:
+        ADVANCE(ch_size);
+        break;
+    case XCT_BROKEN:
+    default:
+        ASN__DECODE_FAILED;
+    }
+
+    inner_value =
+        (char *)*memb_ptr2
+        + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+    rv = selected.type_descriptor->op->xer_decoder(
+        opt_codec_ctx, selected.type_descriptor, &inner_value, NULL, ptr, size);
+    ADVANCE(rv.consumed);
+    rv.consumed = 0;
+    switch(rv.code) {
+    case RC_OK:
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+                                       selected.presence_index)
+           == 0) {
+            break;
+        } else {
+            rv.code = RC_FAIL;
+        }
+        /* Fall through */
+    case RC_FAIL:
+        /* Point to a best position where failure occurred */
+        rv.consumed = consumed_myself;
+        /* Fall through */
+    case RC_WMORE:
+        /* Wrt. rv.consumed==0:
+         * In case a genuine RC_WMORE, the whole Open Type decoding
+         * will have to be restarted.
+         */
+        if(*memb_ptr2) {
+            const asn_CHOICE_specifics_t *specs =
+                selected.type_descriptor->specifics;
+            if(elm->flags & ATF_POINTER) {
+                ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+                *memb_ptr2 = NULL;
+            } else {
+                ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
+                                              inner_value);
+                memset(*memb_ptr2, 0, specs->struct_size);
+            }
+        }
+        return rv;
+    }
+
+    /*
+     * Finalize wrapper.
+     */
+    for(;;) {
+        ch_size = xer_next_token(&xer_context, ptr, size, &ch_type);
+        if(ch_size < 0) {
+            ASN__DECODE_FAILED;
+        } else {
+            switch(ch_type) {
+            case PXER_WMORE:
+                ASN__DECODE_STARVED;
+            case PXER_COMMENT:
+            case PXER_TEXT:
+                ADVANCE(ch_size);
+                continue;
+            case PXER_TAG:
+                break;
+            }
+            break;
+        }
+    }
+
+    /*
+     * Wrapper value confirmed.
+     */
+    switch(xer_check_tag(ptr, ch_size, elm->name)) {
+    case XCT_CLOSING:
+        ADVANCE(ch_size);
+        break;
+    case XCT_BROKEN:
+    default:
+        ASN__DECODE_FAILED;
+    }
+
+    rv.consumed += consumed_myself;
+
+    return rv;
+}
+
+
+#ifndef  ASN_DISABLE_PER_SUPPORT
+
+asn_dec_rval_t
+OPEN_TYPE_uper_get(const asn_codec_ctx_t *opt_codec_ctx,
+                   const asn_TYPE_descriptor_t *td, void *sptr,
+                   const asn_TYPE_member_t *elm, asn_per_data_t *pd) {
+    asn_type_selector_result_t selected;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *inner_value;
+    asn_dec_rval_t rv;
+
+    if(!(elm->flags & ATF_OPEN_TYPE)) {
+        ASN__DECODE_FAILED;
+    }
+
+    if(!elm->type_selector) {
+        ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
+                  td->name, elm->name, elm->type->name);
+        ASN__DECODE_FAILED;
+    }
+
+    selected = elm->type_selector(td, sptr);
+    if(!selected.presence_index) {
+        ASN__DECODE_FAILED;
+    }
+
+    /* Fetch the pointer to this member */
+    assert(elm->flags == ATF_OPEN_TYPE);
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+    } else {
+        memb_ptr = (char *)sptr + elm->memb_offset;
+        memb_ptr2 = &memb_ptr;
+    }
+    if(*memb_ptr2 != NULL) {
+        /* Make sure we reset the structure first before encoding */
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0)
+           != 0) {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    inner_value =
+        (char *)*memb_ptr2
+        + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+    rv = uper_open_type_get(opt_codec_ctx, selected.type_descriptor, NULL,
+                            &inner_value, pd);
+    switch(rv.code) {
+    case RC_OK:
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+                                       selected.presence_index)
+           == 0) {
+            break;
+        } else {
+            rv.code = RC_FAIL;
+        }
+        /* Fall through */
+    case RC_WMORE:
+    case RC_FAIL:
+        if(*memb_ptr2) {
+            const asn_CHOICE_specifics_t *specs =
+                selected.type_descriptor->specifics;
+            if(elm->flags & ATF_POINTER) {
+                ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+                *memb_ptr2 = NULL;
+            } else {
+                ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
+                                              inner_value);
+                memset(*memb_ptr2, 0, specs->struct_size);
+            }
+        }
+    }
+    return rv;
+}
+
+asn_enc_rval_t
+OPEN_TYPE_encode_uper(const asn_TYPE_descriptor_t *td,
+                      const asn_per_constraints_t *constraints,
+                      const void *sptr, asn_per_outp_t *po) {
+    const void *memb_ptr;   /* Pointer to the member */
+    asn_TYPE_member_t *elm; /* CHOICE's element */
+    asn_enc_rval_t er;
+    unsigned present;
+
+    (void)constraints;
+
+    present = CHOICE_variant_get_presence(td, sptr);
+    if(present == 0 || present > td->elements_count) {
+        ASN__ENCODE_FAILED;
+    } else {
+        present--;
+    }
+
+    ASN_DEBUG("Encoding %s OPEN TYPE element %d", td->name, present);
+
+    elm = &td->elements[present];
+    if(elm->flags & ATF_POINTER) {
+        /* Member is a pointer to another structure */
+        memb_ptr =
+            *(const void *const *)((const char *)sptr + elm->memb_offset);
+        if(!memb_ptr) ASN__ENCODE_FAILED;
+    } else {
+        memb_ptr = (const char *)sptr + elm->memb_offset;
+    }
+
+    if(uper_open_type_put(elm->type, NULL, memb_ptr, po) < 0) {
+        ASN__ENCODE_FAILED;
+    }
+
+    er.encoded = 0;
+    ASN__ENCODED_OK(er);
+}
+
+
+#endif  /* ASN_DISABLE_PER_SUPPORT */
diff --git a/libs/smux/OPEN_TYPE_oer.c b/libs/smux/OPEN_TYPE_oer.c
new file mode 100644 (file)
index 0000000..dd2f5c6
--- /dev/null
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <OPEN_TYPE.h>
+#include <constr_CHOICE.h>
+#include <errno.h>
+
+asn_dec_rval_t
+OPEN_TYPE_oer_get(const asn_codec_ctx_t *opt_codec_ctx,
+                  const asn_TYPE_descriptor_t *td, void *sptr,
+                  asn_TYPE_member_t *elm, const void *ptr, size_t size) {
+    asn_type_selector_result_t selected;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *inner_value;
+    asn_dec_rval_t rv;
+    size_t ot_ret;
+
+
+    if(!(elm->flags & ATF_OPEN_TYPE)) {
+        ASN__DECODE_FAILED;
+    }
+
+    if(!elm->type_selector) {
+        ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
+                  td->name, elm->name, elm->type->name);
+        ASN__DECODE_FAILED;
+    }
+
+    selected = elm->type_selector(td, sptr);
+    if(!selected.presence_index) {
+        ASN__DECODE_FAILED;
+    }
+
+    /* Fetch the pointer to this member */
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+    } else {
+        memb_ptr = (char *)sptr + elm->memb_offset;
+        memb_ptr2 = &memb_ptr;
+    }
+    if(*memb_ptr2 != NULL) {
+        /* Make sure we reset the structure first before encoding */
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0) != 0) {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    inner_value =
+        (char *)*memb_ptr2
+        + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+    ot_ret = oer_open_type_get(opt_codec_ctx, selected.type_descriptor, NULL,
+                               &inner_value, ptr, size);
+    switch(ot_ret) {
+    default:
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+                                       selected.presence_index)
+           == 0) {
+            rv.code = RC_OK;
+            rv.consumed = ot_ret;
+            return rv;
+        } else {
+            /* Oh, now a full-blown failure failure */
+        }
+        /* Fall through */
+    case -1:
+        rv.code = RC_FAIL;
+        rv.consumed = ot_ret;
+        break;
+    case 0:
+        rv.code = RC_WMORE;
+        rv.consumed = 0;
+        break;
+    }
+
+    if(*memb_ptr2) {
+        const asn_CHOICE_specifics_t *specs =
+            selected.type_descriptor->specifics;
+        if(elm->flags & ATF_POINTER) {
+            ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+            *memb_ptr2 = NULL;
+        } else {
+            ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
+                                          inner_value);
+            memset(*memb_ptr2, 0, specs->struct_size);
+        }
+    }
+    return rv;
+}
index 5b059007ac094612248331e513205c93734266b2..96917a87dc80309a0800999cafd44d32d0b67810 100644 (file)
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "ObjectName.h"
 
  */
 
 #include "ObjectName.h"
 
-int
-ObjectName_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_OBJECT_IDENTIFIER.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using OBJECT_IDENTIFIER,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using OBJECT_IDENTIFIER,
  * so here we adjust the DEF accordingly.
  */
-static void
-ObjectName_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_OBJECT_IDENTIFIER.free_struct;
-       td->print_struct   = asn_DEF_OBJECT_IDENTIFIER.print_struct;
-       td->check_constraints = asn_DEF_OBJECT_IDENTIFIER.check_constraints;
-       td->ber_decoder    = asn_DEF_OBJECT_IDENTIFIER.ber_decoder;
-       td->der_encoder    = asn_DEF_OBJECT_IDENTIFIER.der_encoder;
-       td->xer_decoder    = asn_DEF_OBJECT_IDENTIFIER.xer_decoder;
-       td->xer_encoder    = asn_DEF_OBJECT_IDENTIFIER.xer_encoder;
-       td->uper_decoder   = asn_DEF_OBJECT_IDENTIFIER.uper_decoder;
-       td->uper_encoder   = asn_DEF_OBJECT_IDENTIFIER.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_OBJECT_IDENTIFIER.per_constraints;
-       td->elements       = asn_DEF_OBJECT_IDENTIFIER.elements;
-       td->elements_count = asn_DEF_OBJECT_IDENTIFIER.elements_count;
-       td->specifics      = asn_DEF_OBJECT_IDENTIFIER.specifics;
-}
-
-void
-ObjectName_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       ObjectName_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-ObjectName_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       ObjectName_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-ObjectName_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) {
-       ObjectName_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-ObjectName_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) {
-       ObjectName_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-ObjectName_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) {
-       ObjectName_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-ObjectName_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) {
-       ObjectName_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_ObjectName_tags_1[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_ObjectName = {
        "ObjectName",
        "ObjectName",
 static const ber_tlv_tag_t asn_DEF_ObjectName_tags_1[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_ObjectName = {
        "ObjectName",
        "ObjectName",
-       ObjectName_free,
-       ObjectName_print,
-       ObjectName_constraint,
-       ObjectName_decode_ber,
-       ObjectName_encode_der,
-       ObjectName_decode_xer,
-       ObjectName_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_OBJECT_IDENTIFIER,
        asn_DEF_ObjectName_tags_1,
        sizeof(asn_DEF_ObjectName_tags_1)
                /sizeof(asn_DEF_ObjectName_tags_1[0]), /* 1 */
        asn_DEF_ObjectName_tags_1,      /* Same as above */
        sizeof(asn_DEF_ObjectName_tags_1)
                /sizeof(asn_DEF_ObjectName_tags_1[0]), /* 1 */
        asn_DEF_ObjectName_tags_1,
        sizeof(asn_DEF_ObjectName_tags_1)
                /sizeof(asn_DEF_ObjectName_tags_1[0]), /* 1 */
        asn_DEF_ObjectName_tags_1,      /* Same as above */
        sizeof(asn_DEF_ObjectName_tags_1)
                /sizeof(asn_DEF_ObjectName_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, OBJECT_IDENTIFIER_constraint },
        0, 0,   /* No members */
        0       /* No specifics */
 };
        0, 0,   /* No members */
        0       /* No specifics */
 };
index 1e5c63508e2c26cd9244cdcd05761c3e880002b0..6b0cd24f4f3028250e4b473a01d0a57f17e6d58c 100644 (file)
@@ -1,29 +1,37 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "ObjectSyntax.h"
 
  */
 
 #include "ObjectSyntax.h"
 
-static asn_TYPE_member_t asn_MBR_ObjectSyntax_1[] = {
+static asn_oer_constraints_t asn_OER_type_ObjectSyntax_constr_1 CC_NOTUSED = {
+       { 0, 0 },
+       -1};
+asn_per_constraints_t asn_PER_type_ObjectSyntax_constr_1 CC_NOTUSED = {
+       { APC_CONSTRAINED,       1,  1,  0,  1 }        /* (0..1) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_ObjectSyntax_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct ObjectSyntax, choice.simple),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_SimpleSyntax,
        { ATF_NOFLAGS, 0, offsetof(struct ObjectSyntax, choice.simple),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_SimpleSyntax,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "simple"
                },
        { ATF_NOFLAGS, 0, offsetof(struct ObjectSyntax, choice.application_wide),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_ApplicationSyntax,
                "simple"
                },
        { ATF_NOFLAGS, 0, offsetof(struct ObjectSyntax, choice.application_wide),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_ApplicationSyntax,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "application-wide"
                },
 };
                "application-wide"
                },
 };
@@ -38,33 +46,25 @@ static const asn_TYPE_tag2member_t asn_MAP_ObjectSyntax_tag2el_1[] = {
     { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 1, 0, 0 }, /* ticks */
     { (ASN_TAG_CLASS_APPLICATION | (4 << 2)), 1, 0, 0 } /* arbitrary */
 };
     { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 1, 0, 0 }, /* ticks */
     { (ASN_TAG_CLASS_APPLICATION | (4 << 2)), 1, 0, 0 } /* arbitrary */
 };
-static asn_CHOICE_specifics_t asn_SPC_ObjectSyntax_specs_1 = {
+asn_CHOICE_specifics_t asn_SPC_ObjectSyntax_specs_1 = {
        sizeof(struct ObjectSyntax),
        offsetof(struct ObjectSyntax, _asn_ctx),
        offsetof(struct ObjectSyntax, present),
        sizeof(((struct ObjectSyntax *)0)->present),
        asn_MAP_ObjectSyntax_tag2el_1,
        9,      /* Count of tags in the map */
        sizeof(struct ObjectSyntax),
        offsetof(struct ObjectSyntax, _asn_ctx),
        offsetof(struct ObjectSyntax, present),
        sizeof(((struct ObjectSyntax *)0)->present),
        asn_MAP_ObjectSyntax_tag2el_1,
        9,      /* Count of tags in the map */
-       0,
+       0, 0,
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_ObjectSyntax = {
        "ObjectSyntax",
        "ObjectSyntax",
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_ObjectSyntax = {
        "ObjectSyntax",
        "ObjectSyntax",
-       CHOICE_free,
-       CHOICE_print,
-       CHOICE_constraint,
-       CHOICE_decode_ber,
-       CHOICE_encode_der,
-       CHOICE_decode_xer,
-       CHOICE_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       CHOICE_outmost_tag,
+       &asn_OP_CHOICE,
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_ObjectSyntax_constr_1, &asn_PER_type_ObjectSyntax_constr_1, CHOICE_constraint },
        asn_MBR_ObjectSyntax_1,
        2,      /* Elements count */
        &asn_SPC_ObjectSyntax_specs_1   /* Additional specs */
        asn_MBR_ObjectSyntax_1,
        2,      /* Elements count */
        &asn_SPC_ObjectSyntax_specs_1   /* Additional specs */
index f9e6823c4c2498741fba25a8dd721ee0b362512a..07c608e8c8a2dbcf4ae385c420b2f3cf52f7f90c 100644 (file)
@@ -1,86 +1,16 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "Opaque.h"
 
  */
 
 #include "Opaque.h"
 
-int
-Opaque_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using OCTET_STRING,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using OCTET_STRING,
  * so here we adjust the DEF accordingly.
  */
-static void
-Opaque_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
-       td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
-       td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
-       td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
-       td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
-       td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
-       td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
-       td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
-       td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
-       td->elements       = asn_DEF_OCTET_STRING.elements;
-       td->elements_count = asn_DEF_OCTET_STRING.elements_count;
-       td->specifics      = asn_DEF_OCTET_STRING.specifics;
-}
-
-void
-Opaque_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       Opaque_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-Opaque_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       Opaque_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-Opaque_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) {
-       Opaque_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-Opaque_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) {
-       Opaque_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-Opaque_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) {
-       Opaque_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-Opaque_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) {
-       Opaque_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_Opaque_tags_1[] = {
        (ASN_TAG_CLASS_APPLICATION | (4 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
 static const ber_tlv_tag_t asn_DEF_Opaque_tags_1[] = {
        (ASN_TAG_CLASS_APPLICATION | (4 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
@@ -88,23 +18,15 @@ static const ber_tlv_tag_t asn_DEF_Opaque_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_Opaque = {
        "Opaque",
        "Opaque",
 asn_TYPE_descriptor_t asn_DEF_Opaque = {
        "Opaque",
        "Opaque",
-       Opaque_free,
-       Opaque_print,
-       Opaque_constraint,
-       Opaque_decode_ber,
-       Opaque_encode_der,
-       Opaque_decode_xer,
-       Opaque_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_OCTET_STRING,
        asn_DEF_Opaque_tags_1,
        sizeof(asn_DEF_Opaque_tags_1)
                /sizeof(asn_DEF_Opaque_tags_1[0]) - 1, /* 1 */
        asn_DEF_Opaque_tags_1,  /* Same as above */
        sizeof(asn_DEF_Opaque_tags_1)
                /sizeof(asn_DEF_Opaque_tags_1[0]), /* 2 */
        asn_DEF_Opaque_tags_1,
        sizeof(asn_DEF_Opaque_tags_1)
                /sizeof(asn_DEF_Opaque_tags_1[0]) - 1, /* 1 */
        asn_DEF_Opaque_tags_1,  /* Same as above */
        sizeof(asn_DEF_Opaque_tags_1)
                /sizeof(asn_DEF_Opaque_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { 0, 0, OCTET_STRING_constraint },
        0, 0,   /* No members */
        0, 0,   /* No members */
-       0       /* No specifics */
+       &asn_SPC_OCTET_STRING_specs     /* Additional specs */
 };
 
 };
 
index 337275e4320a626a57580410aae70fc95f24c748..d4036f855bf4d74e2f1250dafa646a0fb2ccf2fc 100644 (file)
@@ -1,53 +1,53 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "OpenPDU.h"
 
  */
 
 #include "OpenPDU.h"
 
-static asn_TYPE_member_t asn_MBR_OpenPDU_1[] = {
+static asn_oer_constraints_t asn_OER_type_OpenPDU_constr_1 CC_NOTUSED = {
+       { 0, 0 },
+       -1};
+asn_per_constraints_t asn_PER_type_OpenPDU_constr_1 CC_NOTUSED = {
+       { APC_CONSTRAINED,       0,  0,  0,  0 }        /* (0..0) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_OpenPDU_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct OpenPDU, choice.simple),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_SimpleOpen,
        { ATF_NOFLAGS, 0, offsetof(struct OpenPDU, choice.simple),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_SimpleOpen,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "simple"
                },
 };
 static const asn_TYPE_tag2member_t asn_MAP_OpenPDU_tag2el_1[] = {
     { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 } /* simple */
 };
                "simple"
                },
 };
 static const asn_TYPE_tag2member_t asn_MAP_OpenPDU_tag2el_1[] = {
     { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 } /* simple */
 };
-static asn_CHOICE_specifics_t asn_SPC_OpenPDU_specs_1 = {
+asn_CHOICE_specifics_t asn_SPC_OpenPDU_specs_1 = {
        sizeof(struct OpenPDU),
        offsetof(struct OpenPDU, _asn_ctx),
        offsetof(struct OpenPDU, present),
        sizeof(((struct OpenPDU *)0)->present),
        asn_MAP_OpenPDU_tag2el_1,
        1,      /* Count of tags in the map */
        sizeof(struct OpenPDU),
        offsetof(struct OpenPDU, _asn_ctx),
        offsetof(struct OpenPDU, present),
        sizeof(((struct OpenPDU *)0)->present),
        asn_MAP_OpenPDU_tag2el_1,
        1,      /* Count of tags in the map */
-       0,
+       0, 0,
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_OpenPDU = {
        "OpenPDU",
        "OpenPDU",
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_OpenPDU = {
        "OpenPDU",
        "OpenPDU",
-       CHOICE_free,
-       CHOICE_print,
-       CHOICE_constraint,
-       CHOICE_decode_ber,
-       CHOICE_encode_der,
-       CHOICE_decode_xer,
-       CHOICE_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       CHOICE_outmost_tag,
+       &asn_OP_CHOICE,
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_OpenPDU_constr_1, &asn_PER_type_OpenPDU_constr_1, CHOICE_constraint },
        asn_MBR_OpenPDU_1,
        1,      /* Elements count */
        &asn_SPC_OpenPDU_specs_1        /* Additional specs */
        asn_MBR_OpenPDU_1,
        1,      /* Elements count */
        &asn_SPC_OpenPDU_specs_1        /* Additional specs */
index af8528d5be9fd9278141ee4323062f7935975af1..73c0534eaa28091e1df80803c99d1df78dd55cf5 100644 (file)
@@ -1,47 +1,47 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "PDU.h"
 
  */
 
 #include "PDU.h"
 
-static asn_TYPE_member_t asn_MBR_PDU_1[] = {
+asn_TYPE_member_t asn_MBR_PDU_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct PDU, request_id),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
        { ATF_NOFLAGS, 0, offsetof(struct PDU, request_id),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "request-id"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDU, error_status),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "request-id"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDU, error_status),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "error-status"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDU, error_index),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "error-status"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDU, error_index),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "error-index"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDU, variable_bindings),
                (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
                0,
                &asn_DEF_VarBindList,
                "error-index"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDU, variable_bindings),
                (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
                0,
                &asn_DEF_VarBindList,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "variable-bindings"
                },
 };
                "variable-bindings"
                },
 };
@@ -54,34 +54,25 @@ static const asn_TYPE_tag2member_t asn_MAP_PDU_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -2, 0 }, /* error-index */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, 0, 0 } /* variable-bindings */
 };
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -2, 0 }, /* error-index */
     { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 3, 0, 0 } /* variable-bindings */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_PDU_specs_1 = {
+asn_SEQUENCE_specifics_t asn_SPC_PDU_specs_1 = {
        sizeof(struct PDU),
        offsetof(struct PDU, _asn_ctx),
        asn_MAP_PDU_tag2el_1,
        4,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        sizeof(struct PDU),
        offsetof(struct PDU, _asn_ctx),
        asn_MAP_PDU_tag2el_1,
        4,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_PDU = {
        "PDU",
        "PDU",
 };
 asn_TYPE_descriptor_t asn_DEF_PDU = {
        "PDU",
        "PDU",
-       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_OP_SEQUENCE,
        asn_DEF_PDU_tags_1,
        sizeof(asn_DEF_PDU_tags_1)
                /sizeof(asn_DEF_PDU_tags_1[0]), /* 1 */
        asn_DEF_PDU_tags_1,     /* Same as above */
        sizeof(asn_DEF_PDU_tags_1)
                /sizeof(asn_DEF_PDU_tags_1[0]), /* 1 */
        asn_DEF_PDU_tags_1,
        sizeof(asn_DEF_PDU_tags_1)
                /sizeof(asn_DEF_PDU_tags_1[0]), /* 1 */
        asn_DEF_PDU_tags_1,     /* Same as above */
        sizeof(asn_DEF_PDU_tags_1)
                /sizeof(asn_DEF_PDU_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_PDU_1,
        4,      /* Elements count */
        &asn_SPC_PDU_specs_1    /* Additional specs */
        asn_MBR_PDU_1,
        4,      /* Elements count */
        &asn_SPC_PDU_specs_1    /* Additional specs */
index 177d23d9aa198dfb8b4f2357b7bd6f5b5da2470c..a956ab4eac36712371be9982d4d1e2f2839bd7a5 100644 (file)
@@ -1,56 +1,64 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "PDUs.h"
 
  */
 
 #include "PDUs.h"
 
-static asn_TYPE_member_t asn_MBR_PDUs_1[] = {
+static asn_oer_constraints_t asn_OER_type_PDUs_constr_1 CC_NOTUSED = {
+       { 0, 0 },
+       -1};
+asn_per_constraints_t asn_PER_type_PDUs_constr_1 CC_NOTUSED = {
+       { APC_CONSTRAINED,       3,  3,  0,  4 }        /* (0..4) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_PDUs_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.get_request),
                (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
                0,
                &asn_DEF_GetRequest_PDU,
        { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.get_request),
                (ASN_TAG_CLASS_CONTEXT | (0 << 2)),
                0,
                &asn_DEF_GetRequest_PDU,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "get-request"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.get_next_request),
                (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
                0,
                &asn_DEF_GetNextRequest_PDU,
                "get-request"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.get_next_request),
                (ASN_TAG_CLASS_CONTEXT | (1 << 2)),
                0,
                &asn_DEF_GetNextRequest_PDU,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "get-next-request"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.get_response),
                (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
                0,
                &asn_DEF_GetResponse_PDU,
                "get-next-request"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.get_response),
                (ASN_TAG_CLASS_CONTEXT | (2 << 2)),
                0,
                &asn_DEF_GetResponse_PDU,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "get-response"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.set_request),
                (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
                0,
                &asn_DEF_SetRequest_PDU,
                "get-response"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.set_request),
                (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
                0,
                &asn_DEF_SetRequest_PDU,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "set-request"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.trap),
                (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
                0,
                &asn_DEF_Trap_PDU,
                "set-request"
                },
        { ATF_NOFLAGS, 0, offsetof(struct PDUs, choice.trap),
                (ASN_TAG_CLASS_CONTEXT | (4 << 2)),
                0,
                &asn_DEF_Trap_PDU,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "trap"
                },
 };
                "trap"
                },
 };
@@ -61,33 +69,25 @@ static const asn_TYPE_tag2member_t asn_MAP_PDUs_tag2el_1[] = {
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* set-request */
     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* trap */
 };
     { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* set-request */
     { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 } /* trap */
 };
-static asn_CHOICE_specifics_t asn_SPC_PDUs_specs_1 = {
+asn_CHOICE_specifics_t asn_SPC_PDUs_specs_1 = {
        sizeof(struct PDUs),
        offsetof(struct PDUs, _asn_ctx),
        offsetof(struct PDUs, present),
        sizeof(((struct PDUs *)0)->present),
        asn_MAP_PDUs_tag2el_1,
        5,      /* Count of tags in the map */
        sizeof(struct PDUs),
        offsetof(struct PDUs, _asn_ctx),
        offsetof(struct PDUs, present),
        sizeof(((struct PDUs *)0)->present),
        asn_MAP_PDUs_tag2el_1,
        5,      /* Count of tags in the map */
-       0,
+       0, 0,
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_PDUs = {
        "PDUs",
        "PDUs",
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_PDUs = {
        "PDUs",
        "PDUs",
-       CHOICE_free,
-       CHOICE_print,
-       CHOICE_constraint,
-       CHOICE_decode_ber,
-       CHOICE_encode_der,
-       CHOICE_decode_xer,
-       CHOICE_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       CHOICE_outmost_tag,
+       &asn_OP_CHOICE,
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_PDUs_constr_1, &asn_PER_type_PDUs_constr_1, CHOICE_constraint },
        asn_MBR_PDUs_1,
        5,      /* Elements count */
        &asn_SPC_PDUs_specs_1   /* Additional specs */
        asn_MBR_PDUs_1,
        5,      /* Elements count */
        &asn_SPC_PDUs_specs_1   /* Additional specs */
index 2ffd2c3de0e8883a3f260b54b810f2a658adc5cd..e751f555b791fca5aa705beec75ccc420e9dca15 100644 (file)
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "PhysAddress.h"
 
  */
 
 #include "PhysAddress.h"
 
-int
-PhysAddress_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using OCTET_STRING,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using OCTET_STRING,
  * so here we adjust the DEF accordingly.
  */
-static void
-PhysAddress_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
-       td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
-       td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
-       td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
-       td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
-       td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
-       td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
-       td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
-       td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
-       td->elements       = asn_DEF_OCTET_STRING.elements;
-       td->elements_count = asn_DEF_OCTET_STRING.elements_count;
-       td->specifics      = asn_DEF_OCTET_STRING.specifics;
-}
-
-void
-PhysAddress_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       PhysAddress_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-PhysAddress_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       PhysAddress_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-PhysAddress_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) {
-       PhysAddress_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-PhysAddress_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) {
-       PhysAddress_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-PhysAddress_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) {
-       PhysAddress_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-PhysAddress_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) {
-       PhysAddress_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_PhysAddress_tags_1[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_PhysAddress = {
        "PhysAddress",
        "PhysAddress",
 static const ber_tlv_tag_t asn_DEF_PhysAddress_tags_1[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
 };
 asn_TYPE_descriptor_t asn_DEF_PhysAddress = {
        "PhysAddress",
        "PhysAddress",
-       PhysAddress_free,
-       PhysAddress_print,
-       PhysAddress_constraint,
-       PhysAddress_decode_ber,
-       PhysAddress_encode_der,
-       PhysAddress_decode_xer,
-       PhysAddress_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_OCTET_STRING,
        asn_DEF_PhysAddress_tags_1,
        sizeof(asn_DEF_PhysAddress_tags_1)
                /sizeof(asn_DEF_PhysAddress_tags_1[0]), /* 1 */
        asn_DEF_PhysAddress_tags_1,     /* Same as above */
        sizeof(asn_DEF_PhysAddress_tags_1)
                /sizeof(asn_DEF_PhysAddress_tags_1[0]), /* 1 */
        asn_DEF_PhysAddress_tags_1,
        sizeof(asn_DEF_PhysAddress_tags_1)
                /sizeof(asn_DEF_PhysAddress_tags_1[0]), /* 1 */
        asn_DEF_PhysAddress_tags_1,     /* Same as above */
        sizeof(asn_DEF_PhysAddress_tags_1)
                /sizeof(asn_DEF_PhysAddress_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, OCTET_STRING_constraint },
        0, 0,   /* No members */
        0, 0,   /* No members */
-       0       /* No specifics */
+       &asn_SPC_OCTET_STRING_specs     /* Additional specs */
 };
 
 };
 
index ee4040dcd60ef2ead6f95ffb4a10df69e9c37548..43e78ae56061afe82dde46e6de827c2abdeee783 100644 (file)
@@ -1,14 +1,14 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "RReqPDU.h"
 
 static int
  */
 
 #include "RReqPDU.h"
 
 static int
-memb_priority_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_priority_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        long value;
        
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        long value;
        
@@ -32,32 +32,40 @@ memb_priority_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
        }
 }
 
        }
 }
 
-static asn_TYPE_member_t asn_MBR_RReqPDU_1[] = {
+static asn_oer_constraints_t asn_OER_memb_priority_constr_3 CC_NOTUSED = {
+       { 4, 0 }        /* (-1..2147483647) */,
+       -1};
+static asn_per_constraints_t asn_PER_memb_priority_constr_3 CC_NOTUSED = {
+       { APC_CONSTRAINED,       32, -1, -1,  2147483647 }      /* (-1..2147483647) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_RReqPDU_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct RReqPDU, subtree),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_ObjectName,
        { ATF_NOFLAGS, 0, offsetof(struct RReqPDU, subtree),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_ObjectName,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "subtree"
                },
        { ATF_NOFLAGS, 0, offsetof(struct RReqPDU, priority),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_NativeInteger,
                "subtree"
                },
        { ATF_NOFLAGS, 0, offsetof(struct RReqPDU, priority),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_NativeInteger,
-               memb_priority_constraint_1,
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { &asn_OER_memb_priority_constr_3, &asn_PER_memb_priority_constr_3,  memb_priority_constraint_1 },
+               0, 0, /* No default value */
                "priority"
                },
        { ATF_NOFLAGS, 0, offsetof(struct RReqPDU, operation),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "priority"
                },
        { ATF_NOFLAGS, 0, offsetof(struct RReqPDU, operation),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "operation"
                },
 };
                "operation"
                },
 };
@@ -70,34 +78,25 @@ static const asn_TYPE_tag2member_t asn_MAP_RReqPDU_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 0 }, /* operation */
     { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 0, 0, 0 } /* subtree */
 };
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 2, -1, 0 }, /* operation */
     { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 0, 0, 0 } /* subtree */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_RReqPDU_specs_1 = {
+asn_SEQUENCE_specifics_t asn_SPC_RReqPDU_specs_1 = {
        sizeof(struct RReqPDU),
        offsetof(struct RReqPDU, _asn_ctx),
        asn_MAP_RReqPDU_tag2el_1,
        3,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        sizeof(struct RReqPDU),
        offsetof(struct RReqPDU, _asn_ctx),
        asn_MAP_RReqPDU_tag2el_1,
        3,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_RReqPDU = {
        "RReqPDU",
        "RReqPDU",
 };
 asn_TYPE_descriptor_t asn_DEF_RReqPDU = {
        "RReqPDU",
        "RReqPDU",
-       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_OP_SEQUENCE,
        asn_DEF_RReqPDU_tags_1,
        sizeof(asn_DEF_RReqPDU_tags_1)
                /sizeof(asn_DEF_RReqPDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_RReqPDU_tags_1, /* Same as above */
        sizeof(asn_DEF_RReqPDU_tags_1)
                /sizeof(asn_DEF_RReqPDU_tags_1[0]), /* 2 */
        asn_DEF_RReqPDU_tags_1,
        sizeof(asn_DEF_RReqPDU_tags_1)
                /sizeof(asn_DEF_RReqPDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_RReqPDU_tags_1, /* Same as above */
        sizeof(asn_DEF_RReqPDU_tags_1)
                /sizeof(asn_DEF_RReqPDU_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_RReqPDU_1,
        3,      /* Elements count */
        &asn_SPC_RReqPDU_specs_1        /* Additional specs */
        asn_MBR_RReqPDU_1,
        3,      /* Elements count */
        &asn_SPC_RReqPDU_specs_1        /* Additional specs */
index b4d026f3cc21bdb08a67dc7d836ccbf2fd66a61a..c29401b4b4e1c2425ff6e4ba772ee6c0dd14953f 100644 (file)
@@ -1,86 +1,16 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "RRspPDU.h"
 
  */
 
 #include "RRspPDU.h"
 
-int
-RRspPDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_INTEGER.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using INTEGER,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using INTEGER,
  * so here we adjust the DEF accordingly.
  */
-static void
-RRspPDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_INTEGER.free_struct;
-       td->print_struct   = asn_DEF_INTEGER.print_struct;
-       td->check_constraints = asn_DEF_INTEGER.check_constraints;
-       td->ber_decoder    = asn_DEF_INTEGER.ber_decoder;
-       td->der_encoder    = asn_DEF_INTEGER.der_encoder;
-       td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
-       td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
-       td->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
-       td->uper_encoder   = asn_DEF_INTEGER.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_INTEGER.per_constraints;
-       td->elements       = asn_DEF_INTEGER.elements;
-       td->elements_count = asn_DEF_INTEGER.elements_count;
-       td->specifics      = asn_DEF_INTEGER.specifics;
-}
-
-void
-RRspPDU_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       RRspPDU_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-RRspPDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       RRspPDU_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-RRspPDU_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) {
-       RRspPDU_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-RRspPDU_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) {
-       RRspPDU_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-RRspPDU_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) {
-       RRspPDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-RRspPDU_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) {
-       RRspPDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_RRspPDU_tags_1[] = {
        (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 static const ber_tlv_tag_t asn_DEF_RRspPDU_tags_1[] = {
        (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
@@ -88,22 +18,14 @@ static const ber_tlv_tag_t asn_DEF_RRspPDU_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_RRspPDU = {
        "RRspPDU",
        "RRspPDU",
 asn_TYPE_descriptor_t asn_DEF_RRspPDU = {
        "RRspPDU",
        "RRspPDU",
-       RRspPDU_free,
-       RRspPDU_print,
-       RRspPDU_constraint,
-       RRspPDU_decode_ber,
-       RRspPDU_encode_der,
-       RRspPDU_decode_xer,
-       RRspPDU_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_INTEGER,
        asn_DEF_RRspPDU_tags_1,
        sizeof(asn_DEF_RRspPDU_tags_1)
                /sizeof(asn_DEF_RRspPDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_RRspPDU_tags_1, /* Same as above */
        sizeof(asn_DEF_RRspPDU_tags_1)
                /sizeof(asn_DEF_RRspPDU_tags_1[0]), /* 2 */
        asn_DEF_RRspPDU_tags_1,
        sizeof(asn_DEF_RRspPDU_tags_1)
                /sizeof(asn_DEF_RRspPDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_RRspPDU_tags_1, /* Same as above */
        sizeof(asn_DEF_RRspPDU_tags_1)
                /sizeof(asn_DEF_RRspPDU_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { 0, 0, INTEGER_constraint },
        0, 0,   /* Defined elsewhere */
        0       /* No specifics */
 };
        0, 0,   /* Defined elsewhere */
        0       /* No specifics */
 };
index adfdccdeba91f8b8b61644a0a3dc8fb46b184253..12516acdb14264fa20b5438c54640df1a406fc78 100644 (file)
@@ -1,68 +1,78 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "SMUX-PDUs.h"
 
  */
 
 #include "SMUX-PDUs.h"
 
+static asn_oer_constraints_t asn_OER_type_SMUX_PDUs_constr_1 CC_NOTUSED = {
+       { 0, 0 },
+       -1};
+static asn_per_constraints_t asn_PER_type_SMUX_PDUs_constr_1 CC_NOTUSED = {
+       { APC_CONSTRAINED,       3,  3,  0,  5 }        /* (0..5) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
 static asn_TYPE_member_t asn_MBR_SMUX_PDUs_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.open),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_OpenPDU,
 static asn_TYPE_member_t asn_MBR_SMUX_PDUs_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.open),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_OpenPDU,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "open"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.close),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_ClosePDU,
                "open"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.close),
                (ASN_TAG_CLASS_APPLICATION | (1 << 2)),
                0,
                &asn_DEF_ClosePDU,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "close"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.registerRequest),
                (ASN_TAG_CLASS_APPLICATION | (2 << 2)),
                0,
                &asn_DEF_RReqPDU,
                "close"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.registerRequest),
                (ASN_TAG_CLASS_APPLICATION | (2 << 2)),
                0,
                &asn_DEF_RReqPDU,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "registerRequest"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.registerResponse),
                (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
                0,
                &asn_DEF_RRspPDU,
                "registerRequest"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.registerResponse),
                (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
                0,
                &asn_DEF_RRspPDU,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "registerResponse"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.pdus),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_PDUs,
                "registerResponse"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.pdus),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_PDUs,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "pdus"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.commitOrRollback),
                (ASN_TAG_CLASS_APPLICATION | (4 << 2)),
                0,
                &asn_DEF_SOutPDU,
                "pdus"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SMUX_PDUs, choice.commitOrRollback),
                (ASN_TAG_CLASS_APPLICATION | (4 << 2)),
                0,
                &asn_DEF_SOutPDU,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "commitOrRollback"
                },
 };
                "commitOrRollback"
                },
 };
+static const unsigned asn_MAP_SMUX_PDUs_to_canonical_1[] = { 0, 1, 2, 3, 5, 4 };
+static const unsigned asn_MAP_SMUX_PDUs_from_canonical_1[] = { 0, 1, 2, 3, 5, 4 };
 static const asn_TYPE_tag2member_t asn_MAP_SMUX_PDUs_tag2el_1[] = {
     { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 }, /* simple */
     { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 1, 0, 0 }, /* close */
 static const asn_TYPE_tag2member_t asn_MAP_SMUX_PDUs_tag2el_1[] = {
     { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 0, 0, 0 }, /* simple */
     { (ASN_TAG_CLASS_APPLICATION | (1 << 2)), 1, 0, 0 }, /* close */
@@ -82,26 +92,19 @@ static asn_CHOICE_specifics_t asn_SPC_SMUX_PDUs_specs_1 = {
        sizeof(((struct SMUX_PDUs *)0)->present),
        asn_MAP_SMUX_PDUs_tag2el_1,
        10,     /* Count of tags in the map */
        sizeof(((struct SMUX_PDUs *)0)->present),
        asn_MAP_SMUX_PDUs_tag2el_1,
        10,     /* Count of tags in the map */
-       0,
+       asn_MAP_SMUX_PDUs_to_canonical_1,
+       asn_MAP_SMUX_PDUs_from_canonical_1,
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_SMUX_PDUs = {
        "SMUX-PDUs",
        "SMUX-PDUs",
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_SMUX_PDUs = {
        "SMUX-PDUs",
        "SMUX-PDUs",
-       CHOICE_free,
-       CHOICE_print,
-       CHOICE_constraint,
-       CHOICE_decode_ber,
-       CHOICE_encode_der,
-       CHOICE_decode_xer,
-       CHOICE_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       CHOICE_outmost_tag,
+       &asn_OP_CHOICE,
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_SMUX_PDUs_constr_1, &asn_PER_type_SMUX_PDUs_constr_1, CHOICE_constraint },
        asn_MBR_SMUX_PDUs_1,
        6,      /* Elements count */
        &asn_SPC_SMUX_PDUs_specs_1      /* Additional specs */
        asn_MBR_SMUX_PDUs_1,
        6,      /* Elements count */
        &asn_SPC_SMUX_PDUs_specs_1      /* Additional specs */
index 29d47786945dacc2504f8355e95cc44d74e74338..ef1547e67fa79b26c8a3e16508502e7a1455a9bb 100644 (file)
@@ -1,86 +1,16 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "SOutPDU.h"
 
  */
 
 #include "SOutPDU.h"
 
-int
-SOutPDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_INTEGER.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using INTEGER,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using INTEGER,
  * so here we adjust the DEF accordingly.
  */
-static void
-SOutPDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_INTEGER.free_struct;
-       td->print_struct   = asn_DEF_INTEGER.print_struct;
-       td->check_constraints = asn_DEF_INTEGER.check_constraints;
-       td->ber_decoder    = asn_DEF_INTEGER.ber_decoder;
-       td->der_encoder    = asn_DEF_INTEGER.der_encoder;
-       td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
-       td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
-       td->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
-       td->uper_encoder   = asn_DEF_INTEGER.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_INTEGER.per_constraints;
-       td->elements       = asn_DEF_INTEGER.elements;
-       td->elements_count = asn_DEF_INTEGER.elements_count;
-       td->specifics      = asn_DEF_INTEGER.specifics;
-}
-
-void
-SOutPDU_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       SOutPDU_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-SOutPDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       SOutPDU_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-SOutPDU_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) {
-       SOutPDU_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-SOutPDU_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) {
-       SOutPDU_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-SOutPDU_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) {
-       SOutPDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-SOutPDU_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) {
-       SOutPDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_SOutPDU_tags_1[] = {
        (ASN_TAG_CLASS_APPLICATION | (4 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
 static const ber_tlv_tag_t asn_DEF_SOutPDU_tags_1[] = {
        (ASN_TAG_CLASS_APPLICATION | (4 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
@@ -88,22 +18,14 @@ static const ber_tlv_tag_t asn_DEF_SOutPDU_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_SOutPDU = {
        "SOutPDU",
        "SOutPDU",
 asn_TYPE_descriptor_t asn_DEF_SOutPDU = {
        "SOutPDU",
        "SOutPDU",
-       SOutPDU_free,
-       SOutPDU_print,
-       SOutPDU_constraint,
-       SOutPDU_decode_ber,
-       SOutPDU_encode_der,
-       SOutPDU_decode_xer,
-       SOutPDU_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_INTEGER,
        asn_DEF_SOutPDU_tags_1,
        sizeof(asn_DEF_SOutPDU_tags_1)
                /sizeof(asn_DEF_SOutPDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_SOutPDU_tags_1, /* Same as above */
        sizeof(asn_DEF_SOutPDU_tags_1)
                /sizeof(asn_DEF_SOutPDU_tags_1[0]), /* 2 */
        asn_DEF_SOutPDU_tags_1,
        sizeof(asn_DEF_SOutPDU_tags_1)
                /sizeof(asn_DEF_SOutPDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_SOutPDU_tags_1, /* Same as above */
        sizeof(asn_DEF_SOutPDU_tags_1)
                /sizeof(asn_DEF_SOutPDU_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { 0, 0, INTEGER_constraint },
        0, 0,   /* Defined elsewhere */
        0       /* No specifics */
 };
        0, 0,   /* Defined elsewhere */
        0       /* No specifics */
 };
index 1bc9495dee5598aae059e0976cea0bc291c02564..7c339d03d290bd26a004d47361ad94048470b992 100644 (file)
@@ -1,86 +1,16 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "SetRequest-PDU.h"
 
  */
 
 #include "SetRequest-PDU.h"
 
-int
-SetRequest_PDU_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-                       asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       /* Replace with underlying type checker */
-       td->check_constraints = asn_DEF_PDU.check_constraints;
-       return td->check_constraints(td, sptr, ctfailcb, app_key);
-}
-
 /*
  * This type is implemented using PDU,
  * so here we adjust the DEF accordingly.
  */
 /*
  * This type is implemented using PDU,
  * so here we adjust the DEF accordingly.
  */
-static void
-SetRequest_PDU_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
-       td->free_struct    = asn_DEF_PDU.free_struct;
-       td->print_struct   = asn_DEF_PDU.print_struct;
-       td->check_constraints = asn_DEF_PDU.check_constraints;
-       td->ber_decoder    = asn_DEF_PDU.ber_decoder;
-       td->der_encoder    = asn_DEF_PDU.der_encoder;
-       td->xer_decoder    = asn_DEF_PDU.xer_decoder;
-       td->xer_encoder    = asn_DEF_PDU.xer_encoder;
-       td->uper_decoder   = asn_DEF_PDU.uper_decoder;
-       td->uper_encoder   = asn_DEF_PDU.uper_encoder;
-       if(!td->per_constraints)
-               td->per_constraints = asn_DEF_PDU.per_constraints;
-       td->elements       = asn_DEF_PDU.elements;
-       td->elements_count = asn_DEF_PDU.elements_count;
-       td->specifics      = asn_DEF_PDU.specifics;
-}
-
-void
-SetRequest_PDU_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       SetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-SetRequest_PDU_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       SetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-SetRequest_PDU_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) {
-       SetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-SetRequest_PDU_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) {
-       SetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-SetRequest_PDU_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) {
-       SetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-SetRequest_PDU_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) {
-       SetRequest_PDU_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
 static const ber_tlv_tag_t asn_DEF_SetRequest_PDU_tags_1[] = {
        (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 static const ber_tlv_tag_t asn_DEF_SetRequest_PDU_tags_1[] = {
        (ASN_TAG_CLASS_CONTEXT | (3 << 2)),
        (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
@@ -88,23 +18,16 @@ static const ber_tlv_tag_t asn_DEF_SetRequest_PDU_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_SetRequest_PDU = {
        "SetRequest-PDU",
        "SetRequest-PDU",
 asn_TYPE_descriptor_t asn_DEF_SetRequest_PDU = {
        "SetRequest-PDU",
        "SetRequest-PDU",
-       SetRequest_PDU_free,
-       SetRequest_PDU_print,
-       SetRequest_PDU_constraint,
-       SetRequest_PDU_decode_ber,
-       SetRequest_PDU_encode_der,
-       SetRequest_PDU_decode_xer,
-       SetRequest_PDU_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_SEQUENCE,
        asn_DEF_SetRequest_PDU_tags_1,
        sizeof(asn_DEF_SetRequest_PDU_tags_1)
                /sizeof(asn_DEF_SetRequest_PDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_SetRequest_PDU_tags_1,  /* Same as above */
        sizeof(asn_DEF_SetRequest_PDU_tags_1)
                /sizeof(asn_DEF_SetRequest_PDU_tags_1[0]), /* 2 */
        asn_DEF_SetRequest_PDU_tags_1,
        sizeof(asn_DEF_SetRequest_PDU_tags_1)
                /sizeof(asn_DEF_SetRequest_PDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_SetRequest_PDU_tags_1,  /* Same as above */
        sizeof(asn_DEF_SetRequest_PDU_tags_1)
                /sizeof(asn_DEF_SetRequest_PDU_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
-       0, 0,   /* Defined elsewhere */
-       0       /* No specifics */
+       { 0, 0, SEQUENCE_constraint },
+       asn_MBR_PDU_1,
+       4,      /* Elements count */
+       &asn_SPC_PDU_specs_1    /* Additional specs */
 };
 
 };
 
index 479430bf0691b1465990c37ff5e661ca04371c56..ff64f59d08a2de84bfef533230e8459dadb8011c 100644 (file)
@@ -1,47 +1,47 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "SimpleOpen.h"
 
  */
 
 #include "SimpleOpen.h"
 
-static asn_TYPE_member_t asn_MBR_SimpleOpen_1[] = {
+asn_TYPE_member_t asn_MBR_SimpleOpen_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, version),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
        { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, version),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "version"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, identity),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_OBJECT_IDENTIFIER,
                "version"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, identity),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_OBJECT_IDENTIFIER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "identity"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, description),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_DisplayString,
                "identity"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, description),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_DisplayString,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "description"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, password),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_OCTET_STRING,
                "description"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleOpen, password),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_OCTET_STRING,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "password"
                },
 };
                "password"
                },
 };
@@ -55,34 +55,25 @@ static const asn_TYPE_tag2member_t asn_MAP_SimpleOpen_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 3, -1, 0 }, /* password */
     { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 1, 0, 0 } /* identity */
 };
     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 3, -1, 0 }, /* password */
     { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 1, 0, 0 } /* identity */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_SimpleOpen_specs_1 = {
+asn_SEQUENCE_specifics_t asn_SPC_SimpleOpen_specs_1 = {
        sizeof(struct SimpleOpen),
        offsetof(struct SimpleOpen, _asn_ctx),
        asn_MAP_SimpleOpen_tag2el_1,
        4,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        sizeof(struct SimpleOpen),
        offsetof(struct SimpleOpen, _asn_ctx),
        asn_MAP_SimpleOpen_tag2el_1,
        4,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_SimpleOpen = {
        "SimpleOpen",
        "SimpleOpen",
 };
 asn_TYPE_descriptor_t asn_DEF_SimpleOpen = {
        "SimpleOpen",
        "SimpleOpen",
-       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_OP_SEQUENCE,
        asn_DEF_SimpleOpen_tags_1,
        sizeof(asn_DEF_SimpleOpen_tags_1)
                /sizeof(asn_DEF_SimpleOpen_tags_1[0]) - 1, /* 1 */
        asn_DEF_SimpleOpen_tags_1,      /* Same as above */
        sizeof(asn_DEF_SimpleOpen_tags_1)
                /sizeof(asn_DEF_SimpleOpen_tags_1[0]), /* 2 */
        asn_DEF_SimpleOpen_tags_1,
        sizeof(asn_DEF_SimpleOpen_tags_1)
                /sizeof(asn_DEF_SimpleOpen_tags_1[0]) - 1, /* 1 */
        asn_DEF_SimpleOpen_tags_1,      /* Same as above */
        sizeof(asn_DEF_SimpleOpen_tags_1)
                /sizeof(asn_DEF_SimpleOpen_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_SimpleOpen_1,
        4,      /* Elements count */
        &asn_SPC_SimpleOpen_specs_1     /* Additional specs */
        asn_MBR_SimpleOpen_1,
        4,      /* Elements count */
        &asn_SPC_SimpleOpen_specs_1     /* Additional specs */
index b2a385b485fafda462dcf0ce9a51566de816a176..6a3fc678a40bfce8558ce15830c3757741775cb2 100644 (file)
@@ -1,83 +1,86 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "SimpleSyntax.h"
 
  */
 
 #include "SimpleSyntax.h"
 
-static asn_TYPE_member_t asn_MBR_SimpleSyntax_1[] = {
+static asn_oer_constraints_t asn_OER_type_SimpleSyntax_constr_1 CC_NOTUSED = {
+       { 0, 0 },
+       -1};
+asn_per_constraints_t asn_PER_type_SimpleSyntax_constr_1 CC_NOTUSED = {
+       { APC_CONSTRAINED,       2,  2,  0,  3 }        /* (0..3) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+asn_TYPE_member_t asn_MBR_SimpleSyntax_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.number),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
        { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.number),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "number"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.string),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_OCTET_STRING,
                "number"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.string),
                (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)),
                0,
                &asn_DEF_OCTET_STRING,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "string"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.object),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_OBJECT_IDENTIFIER,
                "string"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.object),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_OBJECT_IDENTIFIER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "object"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.empty),
                (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
                0,
                &asn_DEF_NULL,
                "object"
                },
        { ATF_NOFLAGS, 0, offsetof(struct SimpleSyntax, choice.empty),
                (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)),
                0,
                &asn_DEF_NULL,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "empty"
                },
 };
                "empty"
                },
 };
+static const unsigned asn_MAP_SimpleSyntax_to_canonical_1[] = { 0, 1, 3, 2 };
+static const unsigned asn_MAP_SimpleSyntax_from_canonical_1[] = { 0, 1, 3, 2 };
 static const asn_TYPE_tag2member_t asn_MAP_SimpleSyntax_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* number */
     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 1, 0, 0 }, /* string */
     { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 3, 0, 0 }, /* empty */
     { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 2, 0, 0 } /* object */
 };
 static const asn_TYPE_tag2member_t asn_MAP_SimpleSyntax_tag2el_1[] = {
     { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 0 }, /* number */
     { (ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), 1, 0, 0 }, /* string */
     { (ASN_TAG_CLASS_UNIVERSAL | (5 << 2)), 3, 0, 0 }, /* empty */
     { (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)), 2, 0, 0 } /* object */
 };
-static asn_CHOICE_specifics_t asn_SPC_SimpleSyntax_specs_1 = {
+asn_CHOICE_specifics_t asn_SPC_SimpleSyntax_specs_1 = {
        sizeof(struct SimpleSyntax),
        offsetof(struct SimpleSyntax, _asn_ctx),
        offsetof(struct SimpleSyntax, present),
        sizeof(((struct SimpleSyntax *)0)->present),
        asn_MAP_SimpleSyntax_tag2el_1,
        4,      /* Count of tags in the map */
        sizeof(struct SimpleSyntax),
        offsetof(struct SimpleSyntax, _asn_ctx),
        offsetof(struct SimpleSyntax, present),
        sizeof(((struct SimpleSyntax *)0)->present),
        asn_MAP_SimpleSyntax_tag2el_1,
        4,      /* Count of tags in the map */
-       0,
+       asn_MAP_SimpleSyntax_to_canonical_1,
+       asn_MAP_SimpleSyntax_from_canonical_1,
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_SimpleSyntax = {
        "SimpleSyntax",
        "SimpleSyntax",
        -1      /* Extensions start */
 };
 asn_TYPE_descriptor_t asn_DEF_SimpleSyntax = {
        "SimpleSyntax",
        "SimpleSyntax",
-       CHOICE_free,
-       CHOICE_print,
-       CHOICE_constraint,
-       CHOICE_decode_ber,
-       CHOICE_encode_der,
-       CHOICE_decode_xer,
-       CHOICE_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       CHOICE_outmost_tag,
+       &asn_OP_CHOICE,
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
        0,      /* No effective tags (pointer) */
        0,      /* No effective tags (count) */
        0,      /* No tags (pointer) */
        0,      /* No tags (count) */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_SimpleSyntax_constr_1, &asn_PER_type_SimpleSyntax_constr_1, CHOICE_constraint },
        asn_MBR_SimpleSyntax_1,
        4,      /* Elements count */
        &asn_SPC_SimpleSyntax_specs_1   /* Additional specs */
        asn_MBR_SimpleSyntax_1,
        4,      /* Elements count */
        &asn_SPC_SimpleSyntax_specs_1   /* Additional specs */
index 994baa2932b351fb9b9d68b4d11ab0a40a18b28f..1f6e0d61119997aaa016d14480bbd0c2e562213e 100644 (file)
@@ -1,14 +1,14 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "TcpConnEntry.h"
 
 static int
  */
 
 #include "TcpConnEntry.h"
 
 static int
-memb_tcpConnLocalPort_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_tcpConnLocalPort_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        long value;
        
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        long value;
        
@@ -33,7 +33,7 @@ memb_tcpConnLocalPort_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
 }
 
 static int
 }
 
 static int
-memb_tcpConnRemPort_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_tcpConnRemPort_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        long value;
        
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        long value;
        
@@ -57,50 +57,66 @@ memb_tcpConnRemPort_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
        }
 }
 
        }
 }
 
+static asn_oer_constraints_t asn_OER_memb_tcpConnLocalPort_constr_4 CC_NOTUSED = {
+       { 2, 1 }        /* (0..65535) */,
+       -1};
+static asn_per_constraints_t asn_PER_memb_tcpConnLocalPort_constr_4 CC_NOTUSED = {
+       { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+static asn_oer_constraints_t asn_OER_memb_tcpConnRemPort_constr_6 CC_NOTUSED = {
+       { 2, 1 }        /* (0..65535) */,
+       -1};
+static asn_per_constraints_t asn_PER_memb_tcpConnRemPort_constr_6 CC_NOTUSED = {
+       { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
 static asn_TYPE_member_t asn_MBR_TcpConnEntry_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnState),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
 static asn_TYPE_member_t asn_MBR_TcpConnEntry_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnState),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "tcpConnState"
                },
        { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnLocalAddress),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
                "tcpConnState"
                },
        { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnLocalAddress),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "tcpConnLocalAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnLocalPort),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_NativeInteger,
                "tcpConnLocalAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnLocalPort),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_NativeInteger,
-               memb_tcpConnLocalPort_constraint_1,
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { &asn_OER_memb_tcpConnLocalPort_constr_4, &asn_PER_memb_tcpConnLocalPort_constr_4,  memb_tcpConnLocalPort_constraint_1 },
+               0, 0, /* No default value */
                "tcpConnLocalPort"
                },
        { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnRemAddress),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
                "tcpConnLocalPort"
                },
        { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnRemAddress),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "tcpConnRemAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnRemPort),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_NativeInteger,
                "tcpConnRemAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct TcpConnEntry, tcpConnRemPort),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_NativeInteger,
-               memb_tcpConnRemPort_constraint_1,
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { &asn_OER_memb_tcpConnRemPort_constr_6, &asn_PER_memb_tcpConnRemPort_constr_6,  memb_tcpConnRemPort_constraint_1 },
+               0, 0, /* No default value */
                "tcpConnRemPort"
                },
 };
                "tcpConnRemPort"
                },
 };
@@ -120,28 +136,19 @@ static asn_SEQUENCE_specifics_t asn_SPC_TcpConnEntry_specs_1 = {
        asn_MAP_TcpConnEntry_tag2el_1,
        5,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        asn_MAP_TcpConnEntry_tag2el_1,
        5,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_TcpConnEntry = {
        "TcpConnEntry",
        "TcpConnEntry",
 };
 asn_TYPE_descriptor_t asn_DEF_TcpConnEntry = {
        "TcpConnEntry",
        "TcpConnEntry",
-       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_OP_SEQUENCE,
        asn_DEF_TcpConnEntry_tags_1,
        sizeof(asn_DEF_TcpConnEntry_tags_1)
                /sizeof(asn_DEF_TcpConnEntry_tags_1[0]), /* 1 */
        asn_DEF_TcpConnEntry_tags_1,    /* Same as above */
        sizeof(asn_DEF_TcpConnEntry_tags_1)
                /sizeof(asn_DEF_TcpConnEntry_tags_1[0]), /* 1 */
        asn_DEF_TcpConnEntry_tags_1,
        sizeof(asn_DEF_TcpConnEntry_tags_1)
                /sizeof(asn_DEF_TcpConnEntry_tags_1[0]), /* 1 */
        asn_DEF_TcpConnEntry_tags_1,    /* Same as above */
        sizeof(asn_DEF_TcpConnEntry_tags_1)
                /sizeof(asn_DEF_TcpConnEntry_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_TcpConnEntry_1,
        5,      /* Elements count */
        &asn_SPC_TcpConnEntry_specs_1   /* Additional specs */
        asn_MBR_TcpConnEntry_1,
        5,      /* Elements count */
        &asn_SPC_TcpConnEntry_specs_1   /* Additional specs */
index b1aa11308791f60a6860d5b00e16e74adc2af9f8..74cac1ee92c33b3a21b8db49d08bae9940723786 100644 (file)
@@ -1,14 +1,14 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "TimeTicks.h"
 
 int
  */
 
 #include "TimeTicks.h"
 
 int
-TimeTicks_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+TimeTicks_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        
        if(!sptr) {
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        
        if(!sptr) {
@@ -27,69 +27,15 @@ TimeTicks_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * This type is implemented using NativeInteger,
  * so here we adjust the DEF accordingly.
  */
  * This type is implemented using NativeInteger,
  * so here we adjust the DEF accordingly.
  */
-static void
-TimeTicks_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
-TimeTicks_free(asn_TYPE_descriptor_t *td,
-               void *struct_ptr, int contents_only) {
-       TimeTicks_1_inherit_TYPE_descriptor(td);
-       td->free_struct(td, struct_ptr, contents_only);
-}
-
-int
-TimeTicks_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
-               int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
-       TimeTicks_1_inherit_TYPE_descriptor(td);
-       return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
-}
-
-asn_dec_rval_t
-TimeTicks_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) {
-       TimeTicks_1_inherit_TYPE_descriptor(td);
-       return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
-}
-
-asn_enc_rval_t
-TimeTicks_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) {
-       TimeTicks_1_inherit_TYPE_descriptor(td);
-       return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
-}
-
-asn_dec_rval_t
-TimeTicks_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) {
-       TimeTicks_1_inherit_TYPE_descriptor(td);
-       return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
-}
-
-asn_enc_rval_t
-TimeTicks_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) {
-       TimeTicks_1_inherit_TYPE_descriptor(td);
-       return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
-}
-
-static const asn_INTEGER_specifics_t asn_SPC_TimeTicks_specs_1 = {
+static asn_oer_constraints_t asn_OER_type_TimeTicks_constr_1 CC_NOTUSED = {
+       { 4, 1 }        /* (0..4294967295) */,
+       -1};
+asn_per_constraints_t asn_PER_type_TimeTicks_constr_1 CC_NOTUSED = {
+       { APC_CONSTRAINED,       32, -1,  0,  4294967295 }      /* (0..4294967295) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
+const asn_INTEGER_specifics_t asn_SPC_TimeTicks_specs_1 = {
        0,      0,      0,      0,      0,
        0,      /* Native long size */
        1       /* Unsigned representation */
        0,      0,      0,      0,      0,
        0,      /* Native long size */
        1       /* Unsigned representation */
@@ -101,22 +47,14 @@ static const ber_tlv_tag_t asn_DEF_TimeTicks_tags_1[] = {
 asn_TYPE_descriptor_t asn_DEF_TimeTicks = {
        "TimeTicks",
        "TimeTicks",
 asn_TYPE_descriptor_t asn_DEF_TimeTicks = {
        "TimeTicks",
        "TimeTicks",
-       TimeTicks_free,
-       TimeTicks_print,
-       TimeTicks_constraint,
-       TimeTicks_decode_ber,
-       TimeTicks_encode_der,
-       TimeTicks_decode_xer,
-       TimeTicks_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_NativeInteger,
        asn_DEF_TimeTicks_tags_1,
        sizeof(asn_DEF_TimeTicks_tags_1)
                /sizeof(asn_DEF_TimeTicks_tags_1[0]) - 1, /* 1 */
        asn_DEF_TimeTicks_tags_1,       /* Same as above */
        sizeof(asn_DEF_TimeTicks_tags_1)
                /sizeof(asn_DEF_TimeTicks_tags_1[0]), /* 2 */
        asn_DEF_TimeTicks_tags_1,
        sizeof(asn_DEF_TimeTicks_tags_1)
                /sizeof(asn_DEF_TimeTicks_tags_1[0]) - 1, /* 1 */
        asn_DEF_TimeTicks_tags_1,       /* Same as above */
        sizeof(asn_DEF_TimeTicks_tags_1)
                /sizeof(asn_DEF_TimeTicks_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { &asn_OER_type_TimeTicks_constr_1, &asn_PER_type_TimeTicks_constr_1, TimeTicks_constraint },
        0, 0,   /* No members */
        &asn_SPC_TimeTicks_specs_1      /* Additional specs */
 };
        0, 0,   /* No members */
        &asn_SPC_TimeTicks_specs_1      /* Additional specs */
 };
index 4c1b44dc227547c7f36203e01de3f3adde8acfb4..5ea27c19d93d5990473111924aba736a793546e8 100644 (file)
@@ -1,65 +1,65 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "Trap-PDU.h"
 
  */
 
 #include "Trap-PDU.h"
 
-static asn_TYPE_member_t asn_MBR_Trap_PDU_1[] = {
+asn_TYPE_member_t asn_MBR_Trap_PDU_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, enterprise),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_OBJECT_IDENTIFIER,
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, enterprise),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_OBJECT_IDENTIFIER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "enterprise"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, agent_addr),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_NetworkAddress,
                "enterprise"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, agent_addr),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_NetworkAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "agent-addr"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, generic_trap),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "agent-addr"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, generic_trap),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "generic-trap"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, specific_trap),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
                "generic-trap"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, specific_trap),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_INTEGER,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "specific-trap"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, time_stamp),
                (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
                0,
                &asn_DEF_TimeTicks,
                "specific-trap"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, time_stamp),
                (ASN_TAG_CLASS_APPLICATION | (3 << 2)),
                0,
                &asn_DEF_TimeTicks,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "time-stamp"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, variable_bindings),
                (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
                0,
                &asn_DEF_VarBindList,
                "time-stamp"
                },
        { ATF_NOFLAGS, 0, offsetof(struct Trap_PDU, variable_bindings),
                (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
                0,
                &asn_DEF_VarBindList,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "variable-bindings"
                },
 };
                "variable-bindings"
                },
 };
@@ -75,34 +75,25 @@ static const asn_TYPE_tag2member_t asn_MAP_Trap_PDU_tag2el_1[] = {
     { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 1, 0, 0 }, /* internet */
     { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 4, 0, 0 } /* time-stamp */
 };
     { (ASN_TAG_CLASS_APPLICATION | (0 << 2)), 1, 0, 0 }, /* internet */
     { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 4, 0, 0 } /* time-stamp */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_Trap_PDU_specs_1 = {
+asn_SEQUENCE_specifics_t asn_SPC_Trap_PDU_specs_1 = {
        sizeof(struct Trap_PDU),
        offsetof(struct Trap_PDU, _asn_ctx),
        asn_MAP_Trap_PDU_tag2el_1,
        6,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        sizeof(struct Trap_PDU),
        offsetof(struct Trap_PDU, _asn_ctx),
        asn_MAP_Trap_PDU_tag2el_1,
        6,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_Trap_PDU = {
        "Trap-PDU",
        "Trap-PDU",
 };
 asn_TYPE_descriptor_t asn_DEF_Trap_PDU = {
        "Trap-PDU",
        "Trap-PDU",
-       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_OP_SEQUENCE,
        asn_DEF_Trap_PDU_tags_1,
        sizeof(asn_DEF_Trap_PDU_tags_1)
                /sizeof(asn_DEF_Trap_PDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_Trap_PDU_tags_1,        /* Same as above */
        sizeof(asn_DEF_Trap_PDU_tags_1)
                /sizeof(asn_DEF_Trap_PDU_tags_1[0]), /* 2 */
        asn_DEF_Trap_PDU_tags_1,
        sizeof(asn_DEF_Trap_PDU_tags_1)
                /sizeof(asn_DEF_Trap_PDU_tags_1[0]) - 1, /* 1 */
        asn_DEF_Trap_PDU_tags_1,        /* Same as above */
        sizeof(asn_DEF_Trap_PDU_tags_1)
                /sizeof(asn_DEF_Trap_PDU_tags_1[0]), /* 2 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_Trap_PDU_1,
        6,      /* Elements count */
        &asn_SPC_Trap_PDU_specs_1       /* Additional specs */
        asn_MBR_Trap_PDU_1,
        6,      /* Elements count */
        &asn_SPC_Trap_PDU_specs_1       /* Additional specs */
index d4c85a385dfaa3ba5339f8b14962b23d6c93003b..ce2c10a7ce455516013dcdbf5b5097140f430fa3 100644 (file)
@@ -1,14 +1,14 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "UdpEntry.h"
 
 static int
  */
 
 #include "UdpEntry.h"
 
 static int
-memb_udpLocalPort_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+memb_udpLocalPort_constraint_1(const asn_TYPE_descriptor_t *td, const void *sptr,
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        long value;
        
                        asn_app_constraint_failed_f *ctfailcb, void *app_key) {
        long value;
        
@@ -32,23 +32,31 @@ memb_udpLocalPort_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
        }
 }
 
        }
 }
 
+static asn_oer_constraints_t asn_OER_memb_udpLocalPort_constr_3 CC_NOTUSED = {
+       { 2, 1 }        /* (0..65535) */,
+       -1};
+static asn_per_constraints_t asn_PER_memb_udpLocalPort_constr_3 CC_NOTUSED = {
+       { APC_CONSTRAINED,       16,  16,  0,  65535 }  /* (0..65535) */,
+       { APC_UNCONSTRAINED,    -1, -1,  0,  0 },
+       0, 0    /* No PER value map */
+};
 static asn_TYPE_member_t asn_MBR_UdpEntry_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct UdpEntry, udpLocalAddress),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
 static asn_TYPE_member_t asn_MBR_UdpEntry_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct UdpEntry, udpLocalAddress),
                (ASN_TAG_CLASS_APPLICATION | (0 << 2)),
                0,
                &asn_DEF_IpAddress,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "udpLocalAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct UdpEntry, udpLocalPort),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_NativeInteger,
                "udpLocalAddress"
                },
        { ATF_NOFLAGS, 0, offsetof(struct UdpEntry, udpLocalPort),
                (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
                0,
                &asn_DEF_NativeInteger,
-               memb_udpLocalPort_constraint_1,
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { &asn_OER_memb_udpLocalPort_constr_3, &asn_PER_memb_udpLocalPort_constr_3,  memb_udpLocalPort_constraint_1 },
+               0, 0, /* No default value */
                "udpLocalPort"
                },
 };
                "udpLocalPort"
                },
 };
@@ -65,28 +73,19 @@ static asn_SEQUENCE_specifics_t asn_SPC_UdpEntry_specs_1 = {
        asn_MAP_UdpEntry_tag2el_1,
        2,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        asn_MAP_UdpEntry_tag2el_1,
        2,      /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_UdpEntry = {
        "UdpEntry",
        "UdpEntry",
 };
 asn_TYPE_descriptor_t asn_DEF_UdpEntry = {
        "UdpEntry",
        "UdpEntry",
-       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_OP_SEQUENCE,
        asn_DEF_UdpEntry_tags_1,
        sizeof(asn_DEF_UdpEntry_tags_1)
                /sizeof(asn_DEF_UdpEntry_tags_1[0]), /* 1 */
        asn_DEF_UdpEntry_tags_1,        /* Same as above */
        sizeof(asn_DEF_UdpEntry_tags_1)
                /sizeof(asn_DEF_UdpEntry_tags_1[0]), /* 1 */
        asn_DEF_UdpEntry_tags_1,
        sizeof(asn_DEF_UdpEntry_tags_1)
                /sizeof(asn_DEF_UdpEntry_tags_1[0]), /* 1 */
        asn_DEF_UdpEntry_tags_1,        /* Same as above */
        sizeof(asn_DEF_UdpEntry_tags_1)
                /sizeof(asn_DEF_UdpEntry_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_UdpEntry_1,
        2,      /* Elements count */
        &asn_SPC_UdpEntry_specs_1       /* Additional specs */
        asn_MBR_UdpEntry_1,
        2,      /* Elements count */
        &asn_SPC_UdpEntry_specs_1       /* Additional specs */
index 047337f3569e002519b388a20c911c5c4f22ac52..49d3cfc57d5858b350a8cc50a3b923ebda8068f9 100644 (file)
@@ -1,29 +1,29 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "VarBind.h"
 
  */
 
 #include "VarBind.h"
 
-static asn_TYPE_member_t asn_MBR_VarBind_1[] = {
+asn_TYPE_member_t asn_MBR_VarBind_1[] = {
        { ATF_NOFLAGS, 0, offsetof(struct VarBind, name),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_ObjectName,
        { ATF_NOFLAGS, 0, offsetof(struct VarBind, name),
                (ASN_TAG_CLASS_UNIVERSAL | (6 << 2)),
                0,
                &asn_DEF_ObjectName,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "name"
                },
        { ATF_NOFLAGS, 0, offsetof(struct VarBind, value),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_ObjectSyntax,
                "name"
                },
        { ATF_NOFLAGS, 0, offsetof(struct VarBind, value),
                -1 /* Ambiguous tag (CHOICE?) */,
                0,
                &asn_DEF_ObjectSyntax,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                "value"
                },
 };
                "value"
                },
 };
@@ -42,34 +42,25 @@ static const asn_TYPE_tag2member_t asn_MAP_VarBind_tag2el_1[] = {
     { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 1, 0, 0 }, /* ticks */
     { (ASN_TAG_CLASS_APPLICATION | (4 << 2)), 1, 0, 0 } /* arbitrary */
 };
     { (ASN_TAG_CLASS_APPLICATION | (3 << 2)), 1, 0, 0 }, /* ticks */
     { (ASN_TAG_CLASS_APPLICATION | (4 << 2)), 1, 0, 0 } /* arbitrary */
 };
-static asn_SEQUENCE_specifics_t asn_SPC_VarBind_specs_1 = {
+asn_SEQUENCE_specifics_t asn_SPC_VarBind_specs_1 = {
        sizeof(struct VarBind),
        offsetof(struct VarBind, _asn_ctx),
        asn_MAP_VarBind_tag2el_1,
        10,     /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
        sizeof(struct VarBind),
        offsetof(struct VarBind, _asn_ctx),
        asn_MAP_VarBind_tag2el_1,
        10,     /* Count of tags in the map */
        0, 0, 0,        /* Optional elements (not needed) */
-       -1,     /* Start extensions */
-       -1      /* Stop extensions */
+       -1,     /* First extension addition */
 };
 asn_TYPE_descriptor_t asn_DEF_VarBind = {
        "VarBind",
        "VarBind",
 };
 asn_TYPE_descriptor_t asn_DEF_VarBind = {
        "VarBind",
        "VarBind",
-       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_OP_SEQUENCE,
        asn_DEF_VarBind_tags_1,
        sizeof(asn_DEF_VarBind_tags_1)
                /sizeof(asn_DEF_VarBind_tags_1[0]), /* 1 */
        asn_DEF_VarBind_tags_1, /* Same as above */
        sizeof(asn_DEF_VarBind_tags_1)
                /sizeof(asn_DEF_VarBind_tags_1[0]), /* 1 */
        asn_DEF_VarBind_tags_1,
        sizeof(asn_DEF_VarBind_tags_1)
                /sizeof(asn_DEF_VarBind_tags_1[0]), /* 1 */
        asn_DEF_VarBind_tags_1, /* Same as above */
        sizeof(asn_DEF_VarBind_tags_1)
                /sizeof(asn_DEF_VarBind_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_constraint },
        asn_MBR_VarBind_1,
        2,      /* Elements count */
        &asn_SPC_VarBind_specs_1        /* Additional specs */
        asn_MBR_VarBind_1,
        2,      /* Elements count */
        &asn_SPC_VarBind_specs_1        /* Additional specs */
index d84026e195576661680034f2201b99de484e8a73..2f970016c0489470ef442e9294344cf870c12756 100644 (file)
@@ -1,27 +1,27 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #include "VarBindList.h"
 
  */
 
 #include "VarBindList.h"
 
-static asn_TYPE_member_t asn_MBR_VarBindList_1[] = {
+asn_TYPE_member_t asn_MBR_VarBindList_1[] = {
        { ATF_POINTER, 0, 0,
                (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
                0,
                &asn_DEF_VarBind,
        { ATF_POINTER, 0, 0,
                (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
                0,
                &asn_DEF_VarBind,
-               0,      /* Defer constraints checking to the member type */
-               0,      /* PER is not compiled, use -gen-PER */
                0,
                0,
+               { 0, 0, 0 },
+               0, 0, /* No default value */
                ""
                },
 };
 static const ber_tlv_tag_t asn_DEF_VarBindList_tags_1[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
                ""
                },
 };
 static const ber_tlv_tag_t asn_DEF_VarBindList_tags_1[] = {
        (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
 };
-static asn_SET_OF_specifics_t asn_SPC_VarBindList_specs_1 = {
+asn_SET_OF_specifics_t asn_SPC_VarBindList_specs_1 = {
        sizeof(struct VarBindList),
        offsetof(struct VarBindList, _asn_ctx),
        0,      /* XER encoding is XMLDelimitedItemList */
        sizeof(struct VarBindList),
        offsetof(struct VarBindList, _asn_ctx),
        0,      /* XER encoding is XMLDelimitedItemList */
@@ -29,22 +29,14 @@ static asn_SET_OF_specifics_t asn_SPC_VarBindList_specs_1 = {
 asn_TYPE_descriptor_t asn_DEF_VarBindList = {
        "VarBindList",
        "VarBindList",
 asn_TYPE_descriptor_t asn_DEF_VarBindList = {
        "VarBindList",
        "VarBindList",
-       SEQUENCE_OF_free,
-       SEQUENCE_OF_print,
-       SEQUENCE_OF_constraint,
-       SEQUENCE_OF_decode_ber,
-       SEQUENCE_OF_encode_der,
-       SEQUENCE_OF_decode_xer,
-       SEQUENCE_OF_encode_xer,
-       0, 0,   /* No PER support, use "-gen-PER" to enable */
-       0,      /* Use generic outmost tag fetcher */
+       &asn_OP_SEQUENCE_OF,
        asn_DEF_VarBindList_tags_1,
        sizeof(asn_DEF_VarBindList_tags_1)
                /sizeof(asn_DEF_VarBindList_tags_1[0]), /* 1 */
        asn_DEF_VarBindList_tags_1,     /* Same as above */
        sizeof(asn_DEF_VarBindList_tags_1)
                /sizeof(asn_DEF_VarBindList_tags_1[0]), /* 1 */
        asn_DEF_VarBindList_tags_1,
        sizeof(asn_DEF_VarBindList_tags_1)
                /sizeof(asn_DEF_VarBindList_tags_1[0]), /* 1 */
        asn_DEF_VarBindList_tags_1,     /* Same as above */
        sizeof(asn_DEF_VarBindList_tags_1)
                /sizeof(asn_DEF_VarBindList_tags_1[0]), /* 1 */
-       0,      /* No PER visible constraints */
+       { 0, 0, SEQUENCE_OF_constraint },
        asn_MBR_VarBindList_1,
        1,      /* Single element */
        &asn_SPC_VarBindList_specs_1    /* Additional specs */
        asn_MBR_VarBindList_1,
        1,      /* Single element */
        &asn_SPC_VarBindList_specs_1    /* Additional specs */
diff --git a/libs/smux/asn_application.c b/libs/smux/asn_application.c
new file mode 100644 (file)
index 0000000..8ce0261
--- /dev/null
@@ -0,0 +1,440 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_application.h>
+#include <errno.h>
+
+static asn_enc_rval_t asn_encode_internal(const asn_codec_ctx_t *opt_codec_ctx,
+                                          enum asn_transfer_syntax syntax,
+                                          const asn_TYPE_descriptor_t *td,
+                                          const void *sptr,
+                                          asn_app_consume_bytes_f *callback,
+                                          void *callback_key);
+
+
+struct callback_count_bytes_key {
+    asn_app_consume_bytes_f *callback;
+    void *callback_key;
+    size_t computed_size;
+};
+
+/*
+ * Encoder which just counts bytes that come through it.
+ */
+static int
+callback_count_bytes_cb(const void *data, size_t size, void *keyp) {
+    struct callback_count_bytes_key *key = keyp;
+    int ret;
+
+    ret = key->callback(data, size, key->callback_key);
+    if(ret >= 0) {
+        key->computed_size += size;
+    }
+
+    return ret;
+}
+
+struct overrun_encoder_key {
+    void *buffer;
+    size_t buffer_size;
+    size_t computed_size;
+};
+
+struct dynamic_encoder_key {
+    void *buffer;
+    size_t buffer_size;
+    size_t computed_size;
+};
+
+struct callback_failure_catch_key {
+    asn_app_consume_bytes_f *callback;
+    void *callback_key;
+    int callback_failed;
+};
+
+/*
+ * Encoder which doesn't stop counting bytes
+ * even if it reaches the end of the buffer.
+ */
+static int
+overrun_encoder_cb(const void *data, size_t size, void *keyp) {
+    struct overrun_encoder_key *key = keyp;
+
+    if(key->computed_size + size > key->buffer_size) {
+        /*
+         * Avoid accident on the next call:
+         * stop adding bytes to the buffer.
+         */
+        key->buffer_size = 0;
+    } else {
+        memcpy((char *)key->buffer + key->computed_size, data, size);
+    }
+    key->computed_size += size;
+
+    return 0;
+}
+
+/*
+ * Encoder which dynamically allocates output, and continues
+ * to count even if allocation failed.
+ */
+static int
+dynamic_encoder_cb(const void *data, size_t size, void *keyp) {
+    struct dynamic_encoder_key *key = keyp;
+
+    if(key->buffer) {
+        if(key->computed_size + size >= key->buffer_size) {
+            void *p;
+            size_t new_size = key->buffer_size;
+
+            do {
+                new_size *= 2;
+            } while(new_size <= key->computed_size + size);
+
+            p = REALLOC(key->buffer, new_size);
+            if(p) {
+                key->buffer = p;
+                key->buffer_size = new_size;
+            } else {
+                FREEMEM(key->buffer);
+                key->buffer = 0;
+                key->buffer_size = 0;
+                key->computed_size += size;
+                return 0;
+            }
+        }
+        memcpy((char *)key->buffer + key->computed_size, data, size);
+    }
+
+    key->computed_size += size;
+
+    return 0;
+}
+
+/*
+ * Encoder which help convert the application level encoder failure into EIO.
+ */
+static int
+callback_failure_catch_cb(const void *data, size_t size, void *keyp) {
+    struct callback_failure_catch_key *key = keyp;
+    int ret;
+
+    ret = key->callback(data, size, key->callback_key);
+    if(ret < 0) {
+        key->callback_failed = 1;
+    }
+
+    return ret;
+}
+
+asn_enc_rval_t
+asn_encode(const asn_codec_ctx_t *opt_codec_ctx,
+           enum asn_transfer_syntax syntax, const asn_TYPE_descriptor_t *td,
+           const void *sptr, asn_app_consume_bytes_f *callback, void *callback_key) {
+    struct callback_failure_catch_key cb_key;
+    asn_enc_rval_t er;
+
+    if(!callback) {
+        errno = EINVAL;
+        ASN__ENCODE_FAILED;
+    }
+
+    cb_key.callback = callback;
+    cb_key.callback_key = callback_key;
+    cb_key.callback_failed = 0;
+
+    er = asn_encode_internal(opt_codec_ctx, syntax, td, sptr,
+                             callback_failure_catch_cb, &cb_key);
+    if(cb_key.callback_failed) {
+        assert(er.encoded == -1);
+        assert(errno == EBADF);
+        errno = EIO;
+    }
+
+    return er;
+}
+
+asn_enc_rval_t
+asn_encode_to_buffer(const asn_codec_ctx_t *opt_codec_ctx,
+                     enum asn_transfer_syntax syntax,
+                     const asn_TYPE_descriptor_t *td, const void *sptr,
+                     void *buffer, size_t buffer_size) {
+    struct overrun_encoder_key buf_key;
+    asn_enc_rval_t er;
+
+    if(buffer_size > 0 && !buffer) {
+        errno = EINVAL;
+        ASN__ENCODE_FAILED;
+    }
+
+    buf_key.buffer = buffer;
+    buf_key.buffer_size = buffer_size;
+    buf_key.computed_size = 0;
+
+    er = asn_encode_internal(opt_codec_ctx, syntax, td, sptr,
+                             overrun_encoder_cb, &buf_key);
+
+    if(er.encoded >= 0 && (size_t)er.encoded != buf_key.computed_size) {
+        ASN_DEBUG("asn_encode() returned %" ASN_PRI_SSIZE
+                  " yet produced %" ASN_PRI_SIZE " bytes",
+                  er.encoded, buf_key.computed_size);
+        assert(er.encoded < 0 || (size_t)er.encoded == buf_key.computed_size);
+    }
+
+    return er;
+}
+
+asn_encode_to_new_buffer_result_t
+asn_encode_to_new_buffer(const asn_codec_ctx_t *opt_codec_ctx,
+                         enum asn_transfer_syntax syntax,
+                         const asn_TYPE_descriptor_t *td, const void *sptr) {
+    struct dynamic_encoder_key buf_key;
+    asn_encode_to_new_buffer_result_t res;
+
+    buf_key.buffer_size = 16;
+    buf_key.buffer = MALLOC(buf_key.buffer_size);
+    buf_key.computed_size = 0;
+
+    res.result = asn_encode_internal(opt_codec_ctx, syntax, td, sptr,
+                                     dynamic_encoder_cb, &buf_key);
+
+    if(res.result.encoded >= 0
+       && (size_t)res.result.encoded != buf_key.computed_size) {
+        ASN_DEBUG("asn_encode() returned %" ASN_PRI_SSIZE
+                  " yet produced %" ASN_PRI_SIZE " bytes",
+                  res.result.encoded, buf_key.computed_size);
+        assert(res.result.encoded < 0
+               || (size_t)res.result.encoded == buf_key.computed_size);
+    }
+
+    res.buffer = buf_key.buffer;
+
+    /* 0-terminate just in case. */
+    if(res.buffer) {
+        assert(buf_key.computed_size < buf_key.buffer_size);
+        ((char *)res.buffer)[buf_key.computed_size] = '\0';
+    }
+
+    return res;
+}
+
+static asn_enc_rval_t
+asn_encode_internal(const asn_codec_ctx_t *opt_codec_ctx,
+                    enum asn_transfer_syntax syntax,
+                    const asn_TYPE_descriptor_t *td, const void *sptr,
+                    asn_app_consume_bytes_f *callback, void *callback_key) {
+    asn_enc_rval_t er;
+    enum xer_encoder_flags_e xer_flags = XER_F_CANONICAL;
+
+    (void)opt_codec_ctx; /* Parameters are not checked on encode yet. */
+
+    if(!td || !sptr) {
+        errno = EINVAL;
+        ASN__ENCODE_FAILED;
+    }
+
+    switch(syntax) {
+    case ATS_NONSTANDARD_PLAINTEXT:
+        if(td->op->print_struct) {
+            struct callback_count_bytes_key cb_key;
+            cb_key.callback = callback;
+            cb_key.callback_key = callback_key;
+            cb_key.computed_size = 0;
+            if(td->op->print_struct(td, sptr, 1, callback_count_bytes_cb,
+                                    &cb_key)
+                   < 0
+               || callback_count_bytes_cb("\n", 1, &cb_key) < 0) {
+                errno = EBADF; /* Structure has incorrect form. */
+                er.encoded = -1;
+                er.failed_type = td;
+                er.structure_ptr = sptr;
+            } else {
+                er.encoded = cb_key.computed_size;
+                er.failed_type = 0;
+                er.structure_ptr = 0;
+            }
+        } else {
+            errno = ENOENT; /* Transfer syntax is not defined for this type. */
+            ASN__ENCODE_FAILED;
+        }
+        break;
+
+    case ATS_RANDOM:
+        errno = ENOENT; /* Randomization doesn't make sense on output. */
+        ASN__ENCODE_FAILED;
+
+    case ATS_BER:
+        /* BER is a superset of DER. */
+        /* Fall through. */
+    case ATS_DER:
+        if(td->op->der_encoder) {
+            er = der_encode(td, sptr, callback, callback_key);
+            if(er.encoded == -1) {
+                if(er.failed_type && er.failed_type->op->der_encoder) {
+                    errno = EBADF;  /* Structure has incorrect form. */
+                } else {
+                    errno = ENOENT; /* DER is not defined for this type. */
+                }
+            }
+        } else {
+            errno = ENOENT; /* Transfer syntax is not defined for this type. */
+            ASN__ENCODE_FAILED;
+        }
+        break;
+    case ATS_CER:
+        errno = ENOENT; /* Transfer syntax is not defined for any type. */
+        ASN__ENCODE_FAILED;
+
+#ifdef  ASN_DISABLE_OER_SUPPORT
+    case ATS_BASIC_OER:
+    case ATS_CANONICAL_OER:
+        errno = ENOENT; /* PER is not defined. */
+        ASN__ENCODE_FAILED;
+        break;
+#else /* ASN_DISABLE_OER_SUPPORT */
+    case ATS_BASIC_OER:
+        /* CANONICAL-OER is a superset of BASIC-OER. */
+        /* Fall through. */
+    case ATS_CANONICAL_OER:
+        if(td->op->oer_encoder) {
+            er = oer_encode(td, sptr, callback, callback_key);
+            if(er.encoded == -1) {
+                if(er.failed_type && er.failed_type->op->oer_encoder) {
+                    errno = EBADF;  /* Structure has incorrect form. */
+                } else {
+                    errno = ENOENT; /* OER is not defined for this type. */
+                }
+            }
+        } else {
+            errno = ENOENT; /* Transfer syntax is not defined for this type. */
+            ASN__ENCODE_FAILED;
+        }
+        break;
+#endif /* ASN_DISABLE_OER_SUPPORT */
+
+#ifdef  ASN_DISABLE_PER_SUPPORT
+    case ATS_UNALIGNED_BASIC_PER:
+    case ATS_UNALIGNED_CANONICAL_PER:
+        errno = ENOENT; /* PER is not defined. */
+        ASN__ENCODE_FAILED;
+        break;
+#else /* ASN_DISABLE_PER_SUPPORT */
+    case ATS_UNALIGNED_BASIC_PER:
+        /* CANONICAL-UPER is a superset of BASIC-UPER. */
+        /* Fall through. */
+    case ATS_UNALIGNED_CANONICAL_PER:
+        if(td->op->uper_encoder) {
+            er = uper_encode(td, 0, sptr, callback, callback_key);
+            if(er.encoded == -1) {
+                if(er.failed_type && er.failed_type->op->uper_encoder) {
+                    errno = EBADF;  /* Structure has incorrect form. */
+                } else {
+                    errno = ENOENT; /* UPER is not defined for this type. */
+                }
+            } else {
+                ASN_DEBUG("Complete encoded in %ld bits", (long)er.encoded);
+                if(er.encoded == 0) {
+                    /* Enforce "Complete Encoding" of X.691 #11.1 */
+                    if(callback("\0", 1, callback_key) < 0) {
+                        errno = EBADF;
+                        ASN__ENCODE_FAILED;
+                    }
+                    er.encoded = 8; /* Exactly 8 zero bits is added. */
+                }
+                /* Convert bits into bytes */
+                er.encoded = (er.encoded + 7) >> 3;
+            }
+        } else {
+            errno = ENOENT; /* Transfer syntax is not defined for this type. */
+            ASN__ENCODE_FAILED;
+        }
+        break;
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
+    case ATS_BASIC_XER:
+        /* CANONICAL-XER is a superset of BASIC-XER. */
+        xer_flags &= ~XER_F_CANONICAL;
+        xer_flags |= XER_F_BASIC;
+        /* Fall through. */
+    case ATS_CANONICAL_XER:
+        if(td->op->xer_encoder) {
+            er = xer_encode(td, sptr, xer_flags, callback, callback_key);
+            if(er.encoded == -1) {
+                if(er.failed_type && er.failed_type->op->xer_encoder) {
+                    errno = EBADF;  /* Structure has incorrect form. */
+                } else {
+                    errno = ENOENT; /* XER is not defined for this type. */
+                }
+            }
+        } else {
+            errno = ENOENT; /* Transfer syntax is not defined for this type. */
+            ASN__ENCODE_FAILED;
+        }
+        break;
+
+    default:
+        errno = ENOENT;
+        ASN__ENCODE_FAILED;
+    }
+
+    return er;
+}
+
+asn_dec_rval_t
+asn_decode(const asn_codec_ctx_t *opt_codec_ctx,
+           enum asn_transfer_syntax syntax, const asn_TYPE_descriptor_t *td,
+           void **sptr, const void *buffer, size_t size) {
+    if(!td || !td->op || !sptr || (size && !buffer)) {
+        ASN__DECODE_FAILED;
+    }
+
+    switch(syntax) {
+    case ATS_CER:
+    case ATS_NONSTANDARD_PLAINTEXT:
+    default:
+        errno = ENOENT;
+        ASN__DECODE_FAILED;
+
+    case ATS_RANDOM:
+        if(!td->op->random_fill) {
+            ASN__DECODE_FAILED;
+        } else {
+            if(asn_random_fill(td, sptr, 16000) == 0) {
+                asn_dec_rval_t ret = {RC_OK, 0};
+                return ret;
+            } else {
+                ASN__DECODE_FAILED;
+            }
+        }
+        break;
+
+    case ATS_DER:
+    case ATS_BER:
+        return ber_decode(opt_codec_ctx, td, sptr, buffer, size);
+
+    case ATS_BASIC_OER:
+    case ATS_CANONICAL_OER:
+#ifdef  ASN_DISABLE_OER_SUPPORT
+        errno = ENOENT;
+        ASN__DECODE_FAILED;
+#else
+        return oer_decode(opt_codec_ctx, td, sptr, buffer, size);
+#endif
+
+    case ATS_UNALIGNED_BASIC_PER:
+    case ATS_UNALIGNED_CANONICAL_PER:
+#ifdef  ASN_DISABLE_PER_SUPPORT
+        errno = ENOENT;
+        ASN__DECODE_FAILED;
+#else
+        return uper_decode_complete(opt_codec_ctx, td, sptr, buffer, size);
+#endif
+
+    case ATS_BASIC_XER:
+    case ATS_CANONICAL_XER:
+        return xer_decode(opt_codec_ctx, td, sptr, buffer, size);
+    }
+}
+
diff --git a/libs/smux/asn_bit_data.c b/libs/smux/asn_bit_data.c
new file mode 100644 (file)
index 0000000..fe4b89b
--- /dev/null
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) 2005-2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_system.h>
+#include <asn_internal.h>
+#include <asn_bit_data.h>
+
+/*
+ * Create a contiguous non-refillable bit data structure.
+ * Can be freed by FREEMEM().
+ */
+asn_bit_data_t *
+asn_bit_data_new_contiguous(const void *data, size_t size_bits) {
+    size_t size_bytes = (size_bits + 7) / 8;
+    asn_bit_data_t *pd;
+    uint8_t *bytes;
+
+    /* Get the extensions map */
+    pd = CALLOC(1, sizeof(*pd) + size_bytes + 1);
+    if(!pd) {
+        return NULL;
+    }
+    bytes = (void *)(((char *)pd) + sizeof(*pd));
+    memcpy(bytes, data, size_bytes);
+    bytes[size_bytes] = 0;
+    pd->buffer = bytes;
+    pd->nboff = 0;
+    pd->nbits = size_bits;
+
+    return pd;
+}
+
+
+char *
+asn_bit_data_string(asn_bit_data_t *pd) {
+       static char buf[2][32];
+       static int n;
+       n = (n+1) % 2;
+    snprintf(buf[n], sizeof(buf[n]),
+             "{m=%" ASN_PRI_SIZE " span %" ASN_PRI_SIZE "[%" ASN_PRI_SIZE
+             "..%" ASN_PRI_SIZE "] (%" ASN_PRI_SIZE ")}",
+             pd->moved, ((uintptr_t)(pd->buffer) & 0xf), pd->nboff, pd->nbits,
+             pd->nbits - pd->nboff);
+    return buf[n];
+}
+
+void
+asn_get_undo(asn_bit_data_t *pd, int nbits) {
+       if((ssize_t)pd->nboff < nbits) {
+               assert((ssize_t)pd->nboff < nbits);
+       } else {
+               pd->nboff -= nbits;
+               pd->moved -= nbits;
+       }
+}
+
+/*
+ * Extract a small number of bits (<= 31) from the specified PER data pointer.
+ */
+int32_t
+asn_get_few_bits(asn_bit_data_t *pd, int nbits) {
+       size_t off;     /* Next after last bit offset */
+       ssize_t nleft;  /* Number of bits left in this stream */
+       uint32_t accum;
+       const uint8_t *buf;
+
+       if(nbits < 0)
+               return -1;
+
+       nleft = pd->nbits - pd->nboff;
+       if(nbits > nleft) {
+               int32_t tailv, vhead;
+               if(!pd->refill || nbits > 31) return -1;
+               /* Accumulate unused bytes before refill */
+               ASN_DEBUG("Obtain the rest %d bits (want %d)",
+                       (int)nleft, (int)nbits);
+               tailv = asn_get_few_bits(pd, nleft);
+               if(tailv < 0) return -1;
+               /* Refill (replace pd contents with new data) */
+               if(pd->refill(pd))
+                       return -1;
+               nbits -= nleft;
+               vhead = asn_get_few_bits(pd, nbits);
+               /* Combine the rest of previous pd with the head of new one */
+               tailv = (tailv << nbits) | vhead;  /* Could == -1 */
+               return tailv;
+       }
+
+       /*
+        * Normalize position indicator.
+        */
+       if(pd->nboff >= 8) {
+               pd->buffer += (pd->nboff >> 3);
+               pd->nbits  -= (pd->nboff & ~0x07);
+               pd->nboff  &= 0x07;
+       }
+       pd->moved += nbits;
+       pd->nboff += nbits;
+       off = pd->nboff;
+       buf = pd->buffer;
+
+       /*
+        * Extract specified number of bits.
+        */
+       if(off <= 8)
+               accum = nbits ? (buf[0]) >> (8 - off) : 0;
+       else if(off <= 16)
+               accum = ((buf[0] << 8) + buf[1]) >> (16 - off);
+       else if(off <= 24)
+               accum = ((buf[0] << 16) + (buf[1] << 8) + buf[2]) >> (24 - off);
+       else if(off <= 31)
+               accum = (((uint32_t)buf[0] << 24) + (buf[1] << 16)
+                       + (buf[2] << 8) + (buf[3])) >> (32 - off);
+       else if(nbits <= 31) {
+               asn_bit_data_t tpd = *pd;
+               /* Here are we with our 31-bits limit plus 1..7 bits offset. */
+               asn_get_undo(&tpd, nbits);
+               /* The number of available bits in the stream allow
+                * for the following operations to take place without
+                * invoking the ->refill() function */
+               accum  = asn_get_few_bits(&tpd, nbits - 24) << 24;
+               accum |= asn_get_few_bits(&tpd, 24);
+       } else {
+               asn_get_undo(pd, nbits);
+               return -1;
+       }
+
+       accum &= (((uint32_t)1 << nbits) - 1);
+
+       ASN_DEBUG("  [PER got %2d<=%2d bits => span %d %+ld[%d..%d]:%02x (%d) => 0x%x]",
+               (int)nbits, (int)nleft,
+               (int)pd->moved,
+               (((long)pd->buffer) & 0xf),
+               (int)pd->nboff, (int)pd->nbits,
+               ((pd->buffer != NULL)?pd->buffer[0]:0),
+               (int)(pd->nbits - pd->nboff),
+               (int)accum);
+
+       return accum;
+}
+
+/*
+ * Extract a large number of bits from the specified PER data pointer.
+ */
+int
+asn_get_many_bits(asn_bit_data_t *pd, uint8_t *dst, int alright, int nbits) {
+       int32_t value;
+
+       if(alright && (nbits & 7)) {
+               /* Perform right alignment of a first few bits */
+               value = asn_get_few_bits(pd, nbits & 0x07);
+               if(value < 0) return -1;
+               *dst++ = value; /* value is already right-aligned */
+               nbits &= ~7;
+       }
+
+       while(nbits) {
+               if(nbits >= 24) {
+                       value = asn_get_few_bits(pd, 24);
+                       if(value < 0) return -1;
+                       *(dst++) = value >> 16;
+                       *(dst++) = value >> 8;
+                       *(dst++) = value;
+                       nbits -= 24;
+               } else {
+                       value = asn_get_few_bits(pd, nbits);
+                       if(value < 0) return -1;
+                       if(nbits & 7) { /* implies left alignment */
+                               value <<= 8 - (nbits & 7),
+                               nbits += 8 - (nbits & 7);
+                               if(nbits > 24)
+                                       *dst++ = value >> 24;
+                       }
+                       if(nbits > 16)
+                               *dst++ = value >> 16;
+                       if(nbits > 8)
+                               *dst++ = value >> 8;
+                       *dst++ = value;
+                       break;
+               }
+       }
+
+       return 0;
+}
+
+/*
+ * Put a small number of bits (<= 31).
+ */
+int
+asn_put_few_bits(asn_bit_outp_t *po, uint32_t bits, int obits) {
+       size_t off;     /* Next after last bit offset */
+       size_t omsk;    /* Existing last byte meaningful bits mask */
+       uint8_t *buf;
+
+       if(obits <= 0 || obits >= 32) return obits ? -1 : 0;
+
+       ASN_DEBUG("[PER put %d bits %x to %p+%d bits]",
+                       obits, (int)bits, (void *)po->buffer, (int)po->nboff);
+
+       /*
+        * Normalize position indicator.
+        */
+       if(po->nboff >= 8) {
+               po->buffer += (po->nboff >> 3);
+               po->nbits  -= (po->nboff & ~0x07);
+               po->nboff  &= 0x07;
+       }
+
+       /*
+        * Flush whole-bytes output, if necessary.
+        */
+       if(po->nboff + obits > po->nbits) {
+               size_t complete_bytes;
+               if(!po->buffer) po->buffer = po->tmpspace;
+               complete_bytes = (po->buffer - po->tmpspace);
+               ASN_DEBUG("[PER output %ld complete + %ld]",
+                       (long)complete_bytes, (long)po->flushed_bytes);
+               if(po->output(po->tmpspace, complete_bytes, po->op_key) < 0)
+                       return -1;
+               if(po->nboff)
+                       po->tmpspace[0] = po->buffer[0];
+               po->buffer = po->tmpspace;
+               po->nbits = 8 * sizeof(po->tmpspace);
+               po->flushed_bytes += complete_bytes;
+       }
+
+       /*
+        * Now, due to sizeof(tmpspace), we are guaranteed large enough space.
+        */
+       buf = po->buffer;
+       omsk = ~((1 << (8 - po->nboff)) - 1);
+       off = (po->nboff + obits);
+
+       /* Clear data of debris before meaningful bits */
+       bits &= (((uint32_t)1 << obits) - 1);
+
+       ASN_DEBUG("[PER out %d %u/%x (t=%d,o=%d) %x&%x=%x]", obits,
+               (int)bits, (int)bits,
+               (int)po->nboff, (int)off,
+               buf[0], (int)(omsk&0xff),
+               (int)(buf[0] & omsk));
+
+       if(off <= 8)    /* Completely within 1 byte */
+               po->nboff = off,
+               bits <<= (8 - off),
+               buf[0] = (buf[0] & omsk) | bits;
+       else if(off <= 16)
+               po->nboff = off,
+               bits <<= (16 - off),
+               buf[0] = (buf[0] & omsk) | (bits >> 8),
+               buf[1] = bits;
+       else if(off <= 24)
+               po->nboff = off,
+               bits <<= (24 - off),
+               buf[0] = (buf[0] & omsk) | (bits >> 16),
+               buf[1] = bits >> 8,
+               buf[2] = bits;
+       else if(off <= 31)
+               po->nboff = off,
+               bits <<= (32 - off),
+               buf[0] = (buf[0] & omsk) | (bits >> 24),
+               buf[1] = bits >> 16,
+               buf[2] = bits >> 8,
+               buf[3] = bits;
+       else {
+               if(asn_put_few_bits(po, bits >> (obits - 24), 24)) return -1;
+               if(asn_put_few_bits(po, bits, obits - 24)) return -1;
+       }
+
+       ASN_DEBUG("[PER out %u/%x => %02x buf+%ld]",
+               (int)bits, (int)bits, buf[0],
+               (long)(po->buffer - po->tmpspace));
+
+       return 0;
+}
+
+
+/*
+ * Output a large number of bits.
+ */
+int
+asn_put_many_bits(asn_bit_outp_t *po, const uint8_t *src, int nbits) {
+
+       while(nbits) {
+               uint32_t value;
+
+               if(nbits >= 24) {
+                       value = (src[0] << 16) | (src[1] << 8) | src[2];
+                       src += 3;
+                       nbits -= 24;
+                       if(asn_put_few_bits(po, value, 24))
+                               return -1;
+               } else {
+                       value = src[0];
+                       if(nbits > 8)
+                               value = (value << 8) | src[1];
+                       if(nbits > 16)
+                               value = (value << 8) | src[2];
+                       if(nbits & 0x07)
+                               value >>= (8 - (nbits & 0x07));
+                       if(asn_put_few_bits(po, value, nbits))
+                               return -1;
+                       break;
+               }
+       }
+
+       return 0;
+}
+
+
+int
+asn_put_aligned_flush(asn_bit_outp_t *po) {
+    uint32_t unused_bits = (0x7 & (8 - (po->nboff & 0x07)));
+    size_t complete_bytes =
+        (po->buffer ? po->buffer - po->tmpspace : 0) + ((po->nboff + 7) >> 3);
+
+    if(unused_bits) {
+        po->buffer[po->nboff >> 3] &= ~0u << unused_bits;
+    }
+
+    if(po->output(po->tmpspace, complete_bytes, po->op_key) < 0) {
+        return -1;
+    } else {
+        po->buffer = po->tmpspace;
+        po->nboff = 0;
+        po->nbits = 8 * sizeof(po->tmpspace);
+        po->flushed_bytes += complete_bytes;
+        return 0;
+    }
+}
+
index 426339c94fa9789cac2e3a2c7342c04eba91ba34..78448a8ecb760a66f2405dac67bdf0c87aebe247 100644 (file)
  * Decode an always-primitive type.
  */
 asn_dec_rval_t
  * 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;
+ber_decode_primitive(const asn_codec_ctx_t *opt_codec_ctx,
+                     const 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. */
 
        asn_dec_rval_t rval;
        ber_tlv_len_t length = 0; /* =0 to avoid [incorrect] warning. */
 
@@ -81,11 +81,11 @@ ber_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
  * Encode an always-primitive type using DER.
  */
 asn_enc_rval_t
  * 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;
+der_encode_primitive(const asn_TYPE_descriptor_t *td, const void *sptr,
+                     int tag_mode, ber_tlv_tag_t tag,
+                     asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_enc_rval_t erval;
+       const ASN__PRIMITIVE_TYPE_t *st = (const ASN__PRIMITIVE_TYPE_t *)sptr;
 
        ASN_DEBUG("%s %s as a primitive type (tm=%d)",
                cb?"Encoding":"Estimating", td->name, tag_mode);
 
        ASN_DEBUG("%s %s as a primitive type (tm=%d)",
                cb?"Encoding":"Estimating", td->name, tag_mode);
@@ -115,9 +115,9 @@ der_encode_primitive(asn_TYPE_descriptor_t *td, void *sptr,
 }
 
 void
 }
 
 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;
+ASN__PRIMITIVE_TYPE_free(const asn_TYPE_descriptor_t *td, void *sptr,
+                         enum asn_struct_free_method method) {
+    ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
 
        if(!td || !sptr)
                return;
 
        if(!td || !sptr)
                return;
@@ -127,8 +127,16 @@ ASN__PRIMITIVE_TYPE_free(asn_TYPE_descriptor_t *td, void *sptr,
        if(st->buf)
                FREEMEM(st->buf);
 
        if(st->buf)
                FREEMEM(st->buf);
 
-       if(!contents_only)
-               FREEMEM(st);
+    switch(method) {
+    case ASFM_FREE_EVERYTHING:
+        FREEMEM(sptr);
+        break;
+    case ASFM_FREE_UNDERLYING:
+        break;
+    case ASFM_FREE_UNDERLYING_AND_RESET:
+        memset(sptr, 0, sizeof(ASN__PRIMITIVE_TYPE_t));
+        break;
+    }
 }
 
 
 }
 
 
@@ -136,8 +144,8 @@ ASN__PRIMITIVE_TYPE_free(asn_TYPE_descriptor_t *td, void *sptr,
  * Local internal type passed around as an argument.
  */
 struct xdp_arg_s {
  * Local internal type passed around as an argument.
  */
 struct xdp_arg_s {
-       asn_TYPE_descriptor_t *type_descriptor;
-       void *struct_key;
+    const asn_TYPE_descriptor_t *type_descriptor;
+    void *struct_key;
        xer_primitive_body_decoder_f *prim_body_decoder;
        int decoded_something;
        int want_more;
        xer_primitive_body_decoder_f *prim_body_decoder;
        int decoded_something;
        int want_more;
@@ -240,15 +248,12 @@ xer_decode__primitive_body(void *key, const void *chunk_buf, size_t chunk_size,
 
 
 asn_dec_rval_t
 
 
 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;
+xer_decode_primitive(const asn_codec_ctx_t *opt_codec_ctx,
+                     const 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;
        asn_struct_ctx_t s_ctx;
        struct xdp_arg_s s_arg;
        asn_dec_rval_t rc;
diff --git a/libs/smux/asn_internal.c b/libs/smux/asn_internal.c
new file mode 100644 (file)
index 0000000..91e537c
--- /dev/null
@@ -0,0 +1,47 @@
+#include <asn_internal.h>
+
+ssize_t
+asn__format_to_callback(int (*cb)(const void *, size_t, void *key), void *key,
+                        const char *fmt, ...) {
+    char scratch[64];
+    char *buf = scratch;
+    size_t buf_size = sizeof(scratch);
+    int wrote;
+    int cb_ret;
+
+    do {
+        va_list args;
+        va_start(args, fmt);
+
+        wrote = vsnprintf(buf, buf_size, fmt, args);
+        if(wrote < (ssize_t)buf_size) {
+            if(wrote < 0) {
+                if(buf != scratch) FREEMEM(buf);
+                return -1;
+            }
+            break;
+        }
+
+        buf_size <<= 1;
+        if(buf == scratch) {
+            buf = MALLOC(buf_size);
+            if(!buf) return -1;
+        } else {
+            void *p = REALLOC(buf, buf_size);
+            if(!p) {
+                FREEMEM(buf);
+                return -1;
+            }
+            buf = p;
+        }
+    } while(1);
+
+    cb_ret = cb(buf, wrote, key);
+    if(buf != scratch) FREEMEM(buf);
+    if(cb_ret < 0) {
+        return -1;
+    }
+
+    return wrote;
+}
+
diff --git a/libs/smux/asn_random_fill.c b/libs/smux/asn_random_fill.c
new file mode 100644 (file)
index 0000000..819cf70
--- /dev/null
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_random_fill.h>
+#include <constr_TYPE.h>
+
+int
+asn_random_fill(const struct asn_TYPE_descriptor_s *td, void **struct_ptr,
+                size_t length) {
+
+    if(td && td->op->random_fill) {
+        asn_random_fill_result_t res =
+            td->op->random_fill(td, struct_ptr, 0, length);
+        return (res.code == ARFILL_OK) ? 0 : -1;
+    } else {
+        return -1;
+    }
+}
+
+static uintmax_t
+asn__intmax_range(intmax_t lb, intmax_t ub) {
+    assert(lb <= ub);
+    if((ub < 0) == (lb < 0)) {
+        return ub - lb;
+    } else if(lb < 0) {
+        return 1 + ((uintmax_t)ub + (uintmax_t)-(lb + 1));
+    } else {
+        assert(!"Unreachable");
+        return 0;
+    }
+}
+
+intmax_t
+asn_random_between(intmax_t lb, intmax_t rb) {
+    if(lb == rb) {
+        return lb;
+    } else {
+        const uintmax_t intmax_max = ((~(uintmax_t)0) >> 1);
+        uintmax_t range = asn__intmax_range(lb, rb);
+        uintmax_t value = 0;
+        uintmax_t got_entropy = 0;
+
+        assert(RAND_MAX > 0xffffff);    /* Seen 7ffffffd! */
+        assert(range < intmax_max);
+
+        for(; got_entropy < range;) {
+            got_entropy = (got_entropy << 24) | 0xffffff;
+            value = (value << 24) | (random() % 0xffffff);
+        }
+
+        return lb + (intmax_t)(value % (range + 1));
+    }
+}
index b3a6329e063f67c9855ffaf3e6a48d2292ec637d..75d6016950f190507afdb5cb94ea90d10896a32f 100644 (file)
  * The BER decoder of any type.
  */
 asn_dec_rval_t
  * 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;
+ber_decode(const asn_codec_ctx_t *opt_codec_ctx,
+           const 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
 
        /*
         * Stack checker requires that the codec context
@@ -51,7 +51,7 @@ ber_decode(asn_codec_ctx_t *opt_codec_ctx,
        /*
         * Invoke type-specific decoder.
         */
        /*
         * Invoke type-specific decoder.
         */
-       return type_descriptor->ber_decoder(opt_codec_ctx, type_descriptor,
+       return type_descriptor->op->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 */
                struct_ptr,     /* Pointer to the destination structure */
                ptr, size,      /* Buffer and its size */
                0               /* Default tag mode is 0 */
@@ -62,11 +62,11 @@ ber_decode(asn_codec_ctx_t *opt_codec_ctx,
  * Check the set of <TL<TL<TL...>>> tags matches the definition.
  */
 asn_dec_rval_t
  * 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;
+ber_check_tags(const asn_codec_ctx_t *opt_codec_ctx,
+               const 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;
        ssize_t tag_len;
        ssize_t len_len;
        ber_tlv_tag_t tlv_tag;
@@ -112,7 +112,7 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
                td->name, (long)size, tag_mode, step, tagno);
        /* assert(td->tags_count >= 1) May not be the case for CHOICE or ANY */
 
                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) {
+       if(tag_mode == 0 && tagno == (int)td->tags_count) {
                /*
                 * This must be the _untagged_ ANY type,
                 * which outermost tag isn't known in advance.
                /*
                 * This must be the _untagged_ ANY type,
                 * which outermost tag isn't known in advance.
@@ -134,9 +134,9 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
                        (long)(tag_len + len_len));
                ADVANCE(tag_len + len_len);
        } else {
                        (long)(tag_len + len_len));
                ADVANCE(tag_len + len_len);
        } else {
-               assert(tagno < td->tags_count); /* At least one loop */
+               assert(tagno < (int)td->tags_count);    /* At least one loop */
        }
        }
-       for((void)tagno; tagno < td->tags_count; tagno++, step++) {
+       for((void)tagno; tagno < (int)td->tags_count; tagno++, step++) {
 
                /*
                 * Fetch and process T from TLV.
 
                /*
                 * Fetch and process T from TLV.
@@ -186,7 +186,7 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
                 * If this one is the last one, check that the tag form
                 * matches the one given in descriptor.
                 */
                 * 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(tagno < ((int)td->tags_count - 1)) {
                        if(tlv_constr == 0) {
                                ASN_DEBUG("tlv_constr = %d, expfail",
                                        tlv_constr);
                        if(tlv_constr == 0) {
                                ASN_DEBUG("tlv_constr = %d, expfail",
                                        tlv_constr);
index 4c2f1e5fd3ccdb17f0b3f76b9f27a052d9135b44..cfd467234bf00f4a91104f01b435e6cb7ff55c11 100644 (file)
@@ -40,28 +40,18 @@ ber_fetch_length(int _is_constructed, const void *bufptr, size_t size,
                for(len = 0, buf++, skipped = 1;
                        oct && (++skipped <= size); buf++, oct--) {
 
                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.
-                                */
+                       /* Verify that we won't overflow. */
+                       if(!(len >> ((8 * sizeof(len)) - (8+1)))) {
+                               len = (len << 8) | *buf;
+                       } else {
+                               /* Too large length value. */
                                return -1;
                        }
                }
 
                if(oct == 0) {
                                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 */
+                       if(len < 0 || len > RSSIZE_MAX) {
+                               /* Length value out of sane range. */
                                return -1;
                        }
 
                                return -1;
                        }
 
@@ -75,7 +65,7 @@ ber_fetch_length(int _is_constructed, const void *bufptr, size_t size,
 }
 
 ssize_t
 }
 
 ssize_t
-ber_skip_length(asn_codec_ctx_t *opt_codec_ctx,
+ber_skip_length(const 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 */
                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 */
@@ -143,7 +133,7 @@ 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 required_size;   /* Size of len encoding */
        uint8_t *buf = (uint8_t *)bufp;
        uint8_t *end;
-       size_t i;
+       int i;
 
        if(len <= 127) {
                /* Encoded in 1 octet */
 
        if(len <= 127) {
                /* Encoded in 1 octet */
@@ -154,7 +144,7 @@ der_tlv_length_serialize(ber_tlv_len_t len, void *bufp, size_t size) {
        /*
         * Compute the size of the subsequent bytes.
         */
        /*
         * Compute the size of the subsequent bytes.
         */
-       for(required_size = 1, i = 8; i < 8 * sizeof(len); i += 8) {
+       for(required_size = 1, i = 8; i < 8 * (int)sizeof(len); i += 8) {
                if(len >> i)
                        required_size++;
                else
                if(len >> i)
                        required_size++;
                else
index 42708760e089948b405743678efbc56ddd836c87..4a7d732f8b1de12ebc56ff2e5655868bb4f9bebb 100644 (file)
@@ -74,7 +74,7 @@ ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *f) {
 
 ssize_t
 ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t size) {
 
 ssize_t
 ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t size) {
-       char *type = 0;
+       const char *type = 0;
        int ret;
 
        switch(tag & 0x3) {
        int ret;
 
        switch(tag & 0x3) {
index 6116e6a6b0b47d989300d409c63a4241c0d10ff4..628979ec22b417f9c5570b4afc720eae944ac076 100644 (file)
@@ -1,6 +1,5 @@
 /*
 /*
- * Copyright (c) 2003, 2004, 2005, 2006, 2007 Lev Walkin <vlm@lionet.info>.
- * All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_internal.h>
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_internal.h>
 /*
  * See the definitions.
  */
 /*
  * See the definitions.
  */
-static int _fetch_present_idx(const void *struct_ptr, int off, int size);
-static void _set_present_idx(void *sptr, int offset, int size, int pres);
+static unsigned _fetch_present_idx(const void *struct_ptr, unsigned off,
+                                   unsigned size);
+static void _set_present_idx(void *sptr, unsigned offset, unsigned size,
+                             unsigned pres);
+static const void *_get_member_ptr(const asn_TYPE_descriptor_t *,
+                                   const void *sptr, asn_TYPE_member_t **elm,
+                                   unsigned *present);
 
 /*
  * Tags are canonically sorted in the tag to member table.
 
 /*
  * Tags are canonically sorted in the tag to member table.
@@ -98,12 +102,14 @@ _search4tag(const void *ap, const void *bp) {
  * The decoder of the CHOICE type.
  */
 asn_dec_rval_t
  * The decoder of the CHOICE type.
  */
 asn_dec_rval_t
-CHOICE_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) {
-       /*
+CHOICE_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
+                  const asn_TYPE_descriptor_t *td, void **struct_ptr,
+                  const void *ptr, size_t size, int tag_mode) {
+    /*
         * Bring closer parts of structure description.
         */
         * Bring closer parts of structure description.
         */
-       asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
+       const asn_CHOICE_specifics_t *specs =
+               (const asn_CHOICE_specifics_t *)td->specifics;
        asn_TYPE_member_t *elements = td->elements;
 
        /*
        asn_TYPE_member_t *elements = td->elements;
 
        /*
@@ -259,7 +265,7 @@ CHOICE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                /*
                 * Invoke the member fetch routine according to member's type
                 */
                /*
                 * Invoke the member fetch routine according to member's type
                 */
-               rval = elm->type->ber_decoder(opt_codec_ctx, elm->type,
+               rval = elm->type->op->ber_decoder(opt_codec_ctx, elm->type,
                                memb_ptr2, ptr, LEFT, elm->tag_mode);
                switch(rval.code) {
                case RC_OK:
                                memb_ptr2, ptr, LEFT, elm->tag_mode);
                switch(rval.code) {
                case RC_OK:
@@ -354,15 +360,15 @@ CHOICE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 }
 
 asn_enc_rval_t
 }
 
 asn_enc_rval_t
-CHOICE_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_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
+CHOICE_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,
+                  int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,
+                  void *app_key) {
+    const asn_CHOICE_specifics_t *specs = (const asn_CHOICE_specifics_t *)td->specifics;
        asn_TYPE_member_t *elm; /* CHOICE element */
        asn_enc_rval_t erval;
        asn_TYPE_member_t *elm; /* CHOICE element */
        asn_enc_rval_t erval;
-       void *memb_ptr;
+       const void *memb_ptr;
        size_t computed_size = 0;
        size_t computed_size = 0;
-       int present;
+       unsigned present;
 
        if(!sptr) ASN__ENCODE_FAILED;
 
 
        if(!sptr) ASN__ENCODE_FAILED;
 
@@ -376,7 +382,7 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
         * If the structure was not initialized, it cannot be encoded:
         * can't deduce what to encode in the choice type.
         */
         * If the structure was not initialized, it cannot be encoded:
         * can't deduce what to encode in the choice type.
         */
-       if(present <= 0 || present > td->elements_count) {
+       if(present == 0 || present > td->elements_count) {
                if(present == 0 && td->elements_count == 0) {
                        /* The CHOICE is empty?! */
                        erval.encoded = 0;
                if(present == 0 && td->elements_count == 0) {
                        /* The CHOICE is empty?! */
                        erval.encoded = 0;
@@ -390,8 +396,9 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
         */
        elm = &td->elements[present-1];
        if(elm->flags & ATF_POINTER) {
         */
        elm = &td->elements[present-1];
        if(elm->flags & ATF_POINTER) {
-               memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
-               if(memb_ptr == 0) {
+        memb_ptr =
+            *(const void *const *)((const char *)sptr + elm->memb_offset);
+        if(memb_ptr == 0) {
                        if(elm->optional) {
                                erval.encoded = 0;
                                ASN__ENCODED_OK(erval);
                        if(elm->optional) {
                                erval.encoded = 0;
                                ASN__ENCODED_OK(erval);
@@ -400,8 +407,8 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
                        ASN__ENCODE_FAILED;
                }
        } else {
                        ASN__ENCODE_FAILED;
                }
        } else {
-               memb_ptr = (void *)((char *)sptr + elm->memb_offset);
-       }
+        memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+    }
 
        /*
         * If the CHOICE itself is tagged EXPLICIT:
 
        /*
         * If the CHOICE itself is tagged EXPLICIT:
@@ -415,7 +422,7 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
                ssize_t ret;
 
                /* Encode member with its tag */
                ssize_t ret;
 
                /* Encode member with its tag */
-               erval = elm->type->der_encoder(elm->type, memb_ptr,
+               erval = elm->type->op->der_encoder(elm->type, memb_ptr,
                        elm->tag_mode, elm->tag, 0, 0);
                if(erval.encoded == -1)
                        return erval;
                        elm->tag_mode, elm->tag, 0, 0);
                if(erval.encoded == -1)
                        return erval;
@@ -431,7 +438,7 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
        /*
         * Encode the single underlying member.
         */
        /*
         * Encode the single underlying member.
         */
-       erval = elm->type->der_encoder(elm->type, memb_ptr,
+       erval = elm->type->op->der_encoder(elm->type, memb_ptr,
                elm->tag_mode, elm->tag, cb, app_key);
        if(erval.encoded == -1)
                return erval;
                elm->tag_mode, elm->tag, cb, app_key);
        if(erval.encoded == -1)
                return erval;
@@ -446,8 +453,8 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
 
 ber_tlv_tag_t
 CHOICE_outmost_tag(const asn_TYPE_descriptor_t *td, const void *ptr, int tag_mode, ber_tlv_tag_t tag) {
 
 ber_tlv_tag_t
 CHOICE_outmost_tag(const asn_TYPE_descriptor_t *td, const void *ptr, int tag_mode, ber_tlv_tag_t tag) {
-       asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
-       int present;
+       const asn_CHOICE_specifics_t *specs = (const asn_CHOICE_specifics_t *)td->specifics;
+       unsigned present;
 
        assert(tag_mode == 0); (void)tag_mode;
        assert(tag == 0); (void)tag;
 
        assert(tag_mode == 0); (void)tag_mode;
        assert(tag == 0); (void)tag;
@@ -457,7 +464,7 @@ CHOICE_outmost_tag(const asn_TYPE_descriptor_t *td, const void *ptr, int tag_mod
         */
        present = _fetch_present_idx(ptr, specs->pres_offset, specs->pres_size);
 
         */
        present = _fetch_present_idx(ptr, specs->pres_offset, specs->pres_size);
 
-       if(present > 0 || present <= td->elements_count) {
+       if(present > 0 && present <= td->elements_count) {
                const asn_TYPE_member_t *elm = &td->elements[present-1];
                const void *memb_ptr;
 
                const asn_TYPE_member_t *elm = &td->elements[present-1];
                const void *memb_ptr;
 
@@ -477,10 +484,11 @@ CHOICE_outmost_tag(const asn_TYPE_descriptor_t *td, const void *ptr, int tag_mod
 }
 
 int
 }
 
 int
-CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-               asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
-       int present;
+CHOICE_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+                  asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+    const asn_CHOICE_specifics_t *specs =
+        (const asn_CHOICE_specifics_t *)td->specifics;
+    unsigned present;
 
        if(!sptr) {
                ASN__CTFAIL(app_key, td, sptr,
 
        if(!sptr) {
                ASN__CTFAIL(app_key, td, sptr,
@@ -511,18 +519,12 @@ CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
                        memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
                }
 
                        memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
                }
 
-               if(elm->memb_constraints) {
-                       return elm->memb_constraints(elm->type, memb_ptr,
+               if(elm->encoding_constraints.general_constraints) {
+                       return elm->encoding_constraints.general_constraints(elm->type, memb_ptr,
                                ctfailcb, app_key);
                } else {
                                ctfailcb, app_key);
                } else {
-                       int ret = elm->type->check_constraints(elm->type,
+                       return elm->type->encoding_constraints.general_constraints(elm->type,
                                        memb_ptr, ctfailcb, app_key);
                                        memb_ptr, ctfailcb, app_key);
-                       /*
-                        * Cannot inherit it eralier:
-                        * need to make sure we get the updated version.
-                        */
-                       elm->memb_constraints = elm->type->check_constraints;
-                       return ret;
                }
        } else {
                ASN__CTFAIL(app_key, td, sptr,
                }
        } else {
                ASN__CTFAIL(app_key, td, sptr,
@@ -544,13 +546,13 @@ CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
  * Decode the XER (XML) data.
  */
 asn_dec_rval_t
  * Decode the XER (XML) data.
  */
 asn_dec_rval_t
-CHOICE_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) {
-       /*
+CHOICE_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
+                  const 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.
         */
         * Bring closer parts of structure description.
         */
-       asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
+       const asn_CHOICE_specifics_t *specs = (const asn_CHOICE_specifics_t *)td->specifics;
        const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
 
        /*
        const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
 
        /*
@@ -561,7 +563,7 @@ CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 
        asn_dec_rval_t rval;            /* Return value of a decoder */
        ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
 
        asn_dec_rval_t rval;            /* Return value of a decoder */
        ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
-       int edx;                        /* Element index */
+       size_t edx;                     /* Element index */
 
        /*
         * Create the target structure if it is not present already.
 
        /*
         * Create the target structure if it is not present already.
@@ -600,6 +602,7 @@ CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        asn_dec_rval_t tmprval;
                        void *memb_ptr;         /* Pointer to the member */
                        void **memb_ptr2;       /* Pointer to that pointer */
                        asn_dec_rval_t tmprval;
                        void *memb_ptr;         /* Pointer to the member */
                        void **memb_ptr2;       /* Pointer to that pointer */
+                       unsigned old_present;
 
                        elm = &td->elements[edx];
 
 
                        elm = &td->elements[edx];
 
@@ -613,19 +616,20 @@ CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        }
 
                        /* Start/Continue decoding the inner member */
                        }
 
                        /* Start/Continue decoding the inner member */
-                       tmprval = elm->type->xer_decoder(opt_codec_ctx,
+                       tmprval = elm->type->op->xer_decoder(opt_codec_ctx,
                                        elm->type, memb_ptr2, elm->name,
                                        buf_ptr, size);
                        XER_ADVANCE(tmprval.consumed);
                        ASN_DEBUG("XER/CHOICE: itdf: [%s] code=%d",
                                elm->type->name, tmprval.code);
                                        elm->type, memb_ptr2, elm->name,
                                        buf_ptr, size);
                        XER_ADVANCE(tmprval.consumed);
                        ASN_DEBUG("XER/CHOICE: itdf: [%s] code=%d",
                                elm->type->name, tmprval.code);
-                       if(tmprval.code != RC_OK)
-                               RETURN(tmprval.code);
-                       assert(_fetch_present_idx(st,
-                               specs->pres_offset, specs->pres_size) == 0);
+                       old_present = _fetch_present_idx(st,
+                               specs->pres_offset, specs->pres_size);
+                       assert(old_present == 0 || old_present == edx + 1);
                        /* Record what we've got */
                        _set_present_idx(st,
                                specs->pres_offset, specs->pres_size, edx + 1);
                        /* Record what we've got */
                        _set_present_idx(st,
                                specs->pres_offset, specs->pres_size, edx + 1);
+                       if(tmprval.code != RC_OK)
+                               RETURN(tmprval.code);
                        ctx->phase = 3;
                        /* Fall through */
                }
                        ctx->phase = 3;
                        /* Fall through */
                }
@@ -671,7 +675,6 @@ CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        case -1:
                                ctx->phase = 5;
                                RETURN(RC_FAIL);
                        case -1:
                                ctx->phase = 5;
                                RETURN(RC_FAIL);
-                               continue;
                        case 1:
                                ctx->phase = 3;
                                /* Fall through */
                        case 1:
                                ctx->phase = 3;
                                /* Fall through */
@@ -773,12 +776,13 @@ CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 
 
 asn_enc_rval_t
 
 
 asn_enc_rval_t
-CHOICE_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_CHOICE_specifics_t *specs=(asn_CHOICE_specifics_t *)td->specifics;
-       asn_enc_rval_t er;
-       int present;
+CHOICE_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+                  enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
+                  void *app_key) {
+    const asn_CHOICE_specifics_t *specs =
+        (const asn_CHOICE_specifics_t *)td->specifics;
+    asn_enc_rval_t er;
+       unsigned present;
 
        if(!sptr)
                ASN__ENCODE_FAILED;
 
        if(!sptr)
                ASN__ENCODE_FAILED;
@@ -788,34 +792,34 @@ CHOICE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
         */
        present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
 
         */
        present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size);
 
-       if(present <= 0 || present > td->elements_count) {
+       if(present == 0 || present > td->elements_count) {
                ASN__ENCODE_FAILED;
        }  else {
                asn_enc_rval_t tmper;
                asn_TYPE_member_t *elm = &td->elements[present-1];
                ASN__ENCODE_FAILED;
        }  else {
                asn_enc_rval_t tmper;
                asn_TYPE_member_t *elm = &td->elements[present-1];
-               void *memb_ptr;
+               const void *memb_ptr;
                const char *mname = elm->name;
                unsigned int mlen = strlen(mname);
 
                if(elm->flags & ATF_POINTER) {
                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) ASN__ENCODE_FAILED;
+            memb_ptr =
+                *(const void *const *)((const char *)sptr + elm->memb_offset);
+            if(!memb_ptr) ASN__ENCODE_FAILED;
                } else {
                } else {
-                       memb_ptr = (void *)((char *)sptr + elm->memb_offset);
-               }
+            memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+        }
 
 
-               er.encoded = 0;
+        er.encoded = 0;
 
 
-                if(!(flags & XER_F_CANONICAL)) ASN__TEXT_INDENT(1, ilevel);
+               if(!(flags & XER_F_CANONICAL)) ASN__TEXT_INDENT(1, ilevel);
                ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
 
                ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
 
-               tmper = elm->type->xer_encoder(elm->type, memb_ptr,
+               tmper = elm->type->op->xer_encoder(elm->type, memb_ptr,
                                ilevel + 1, flags, cb, app_key);
                if(tmper.encoded == -1) return tmper;
                                ilevel + 1, flags, cb, app_key);
                if(tmper.encoded == -1) return tmper;
+               er.encoded += tmper.encoded;
 
                ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
 
                ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
-
-               er.encoded += 5 + (2 * mlen) + tmper.encoded;
        }
 
        if(!(flags & XER_F_CANONICAL)) ASN__TEXT_INDENT(1, ilevel - 1);
        }
 
        if(!(flags & XER_F_CANONICAL)) ASN__TEXT_INDENT(1, ilevel - 1);
@@ -826,11 +830,14 @@ cb_failed:
 }
 
 asn_dec_rval_t
 }
 
 asn_dec_rval_t
-CHOICE_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_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
-       asn_dec_rval_t rv;
-       asn_per_constraint_t *ct;
+CHOICE_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                   const asn_TYPE_descriptor_t *td,
+                   const asn_per_constraints_t *constraints, void **sptr,
+                   asn_per_data_t *pd) {
+    const asn_CHOICE_specifics_t *specs =
+        (const asn_CHOICE_specifics_t *)td->specifics;
+    asn_dec_rval_t rv;
+       const asn_per_constraint_t *ct;
        asn_TYPE_member_t *elm; /* CHOICE's element */
        void *memb_ptr;
        void **memb_ptr2;
        asn_TYPE_member_t *elm; /* CHOICE's element */
        void *memb_ptr;
        void **memb_ptr2;
@@ -849,7 +856,7 @@ CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
        }
 
        if(constraints) ct = &constraints->value;
        }
 
        if(constraints) ct = &constraints->value;
-       else if(td->per_constraints) ct = &td->per_constraints->value;
+       else if(td->encoding_constraints.per_constraints) ct = &td->encoding_constraints.per_constraints->value;
        else ct = 0;
 
        if(ct && ct->flags & APC_EXTENSIBLE) {
        else ct = 0;
 
        if(ct && ct->flags & APC_EXTENSIBLE) {
@@ -871,13 +878,16 @@ CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                value = uper_get_nsnnwn(pd);
                if(value < 0) ASN__DECODE_STARVED;
                value += specs->ext_start;
                value = uper_get_nsnnwn(pd);
                if(value < 0) ASN__DECODE_STARVED;
                value += specs->ext_start;
-               if(value >= td->elements_count)
+               if((unsigned)value >= td->elements_count)
                        ASN__DECODE_FAILED;
        }
 
        /* Adjust if canonical order is different from natural order */
                        ASN__DECODE_FAILED;
        }
 
        /* Adjust if canonical order is different from natural order */
-       if(specs->canonical_order)
-               value = specs->canonical_order[value];
+       if(specs->from_canonical_order) {
+        ASN_DEBUG("CHOICE presence from wire %d", value);
+               value = specs->from_canonical_order[value];
+        ASN_DEBUG("CHOICE presence index effective %d", value);
+    }
 
        /* Set presence to be able to free it later */
        _set_present_idx(st, specs->pres_offset, specs->pres_size, value + 1);
 
        /* Set presence to be able to free it later */
        _set_present_idx(st, specs->pres_offset, specs->pres_size, value + 1);
@@ -893,11 +903,11 @@ CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
        ASN_DEBUG("Discovered CHOICE %s encodes %s", td->name, elm->name);
 
        if(ct && ct->range_bits >= 0) {
        ASN_DEBUG("Discovered CHOICE %s encodes %s", td->name, elm->name);
 
        if(ct && ct->range_bits >= 0) {
-               rv = elm->type->uper_decoder(opt_codec_ctx, elm->type,
-                       elm->per_constraints, memb_ptr2, pd);
+               rv = elm->type->op->uper_decoder(opt_codec_ctx, elm->type,
+                       elm->encoding_constraints.per_constraints, memb_ptr2, pd);
        } else {
                rv = uper_open_type_get(opt_codec_ctx, elm->type,
        } else {
                rv = uper_open_type_get(opt_codec_ctx, elm->type,
-                       elm->per_constraints, memb_ptr2, pd);
+                       elm->encoding_constraints.per_constraints, memb_ptr2, pd);
        }
 
        if(rv.code != RC_OK)
        }
 
        if(rv.code != RC_OK)
@@ -905,15 +915,16 @@ CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        elm->name, td->name, rv.code);
        return rv;
 }
                        elm->name, td->name, rv.code);
        return rv;
 }
-   
+
 asn_enc_rval_t
 asn_enc_rval_t
-CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
-       asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-       asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
+CHOICE_encode_uper(const asn_TYPE_descriptor_t *td,
+                   const asn_per_constraints_t *constraints, const void *sptr,
+                   asn_per_outp_t *po) {
+    const asn_CHOICE_specifics_t *specs = (const asn_CHOICE_specifics_t *)td->specifics;
        asn_TYPE_member_t *elm; /* CHOICE's element */
        asn_TYPE_member_t *elm; /* CHOICE's element */
-       asn_per_constraint_t *ct;
-       void *memb_ptr;
-       int present;
+       const asn_per_constraint_t *ct;
+       const void *memb_ptr;
+       unsigned present;
        int present_enc;
 
        if(!sptr) ASN__ENCODE_FAILED;
        int present_enc;
 
        if(!sptr) ASN__ENCODE_FAILED;
@@ -921,34 +932,37 @@ CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
        ASN_DEBUG("Encoding %s as CHOICE", td->name);
 
        if(constraints) ct = &constraints->value;
        ASN_DEBUG("Encoding %s as CHOICE", td->name);
 
        if(constraints) ct = &constraints->value;
-       else if(td->per_constraints) ct = &td->per_constraints->value;
+       else if(td->encoding_constraints.per_constraints)
+               ct = &td->encoding_constraints.per_constraints->value;
        else ct = 0;
 
        else ct = 0;
 
-       present = _fetch_present_idx(sptr,
-               specs->pres_offset, specs->pres_size);
+       present = _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
 
        /*
         * If the structure was not initialized properly, it cannot be encoded:
         * can't deduce what to encode in the choice type.
         */
 
        /*
         * If the structure was not initialized properly, it cannot be encoded:
         * can't deduce what to encode in the choice type.
         */
-       if(present <= 0 || present > td->elements_count)
+       if(present == 0 || present > td->elements_count)
                ASN__ENCODE_FAILED;
        else
                present--;
 
        ASN_DEBUG("Encoding %s CHOICE element %d", td->name, present);
 
                ASN__ENCODE_FAILED;
        else
                present--;
 
        ASN_DEBUG("Encoding %s CHOICE element %d", td->name, present);
 
-       /* Adjust if canonical order is different from natural order */
-       if(specs->canonical_order)
-               present_enc = specs->canonical_order[present];
-       else
-               present_enc = present;
+    /* Adjust if canonical order is different from natural order */
+    if(specs->to_canonical_order)
+        present_enc = specs->to_canonical_order[present];
+    else
+        present_enc = present;
 
 
-       if(ct && ct->range_bits >= 0) {
+    if(ct && ct->range_bits >= 0) {
                if(present_enc < ct->lower_bound
                || present_enc > ct->upper_bound) {
                        if(ct->flags & APC_EXTENSIBLE) {
                if(present_enc < ct->lower_bound
                || present_enc > ct->upper_bound) {
                        if(ct->flags & APC_EXTENSIBLE) {
-                               if(per_put_few_bits(po, 1, 1))
+                ASN_DEBUG(
+                    "CHOICE member %d (enc %d) is an extension (%ld..%ld)",
+                    present, present_enc, ct->lower_bound, ct->upper_bound);
+                if(per_put_few_bits(po, 1, 1))
                                        ASN__ENCODE_FAILED;
                        } else {
                                ASN__ENCODE_FAILED;
                                        ASN__ENCODE_FAILED;
                        } else {
                                ASN__ENCODE_FAILED;
@@ -956,45 +970,52 @@ CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
                        ct = 0;
                }
        }
                        ct = 0;
                }
        }
-       if(ct && ct->flags & APC_EXTENSIBLE)
-               if(per_put_few_bits(po, 0, 1))
+       if(ct && ct->flags & APC_EXTENSIBLE) {
+        ASN_DEBUG("CHOICE member %d (enc %d) is not an extension (%ld..%ld)",
+                  present, present_enc, ct->lower_bound, ct->upper_bound);
+        if(per_put_few_bits(po, 0, 1))
                        ASN__ENCODE_FAILED;
                        ASN__ENCODE_FAILED;
+    }
+
 
        elm = &td->elements[present];
 
        elm = &td->elements[present];
-       if(elm->flags & ATF_POINTER) {
+    ASN_DEBUG("CHOICE member \"%s\" %d (as %d)", elm->name, present,
+              present_enc);
+    if(elm->flags & ATF_POINTER) {
                /* Member is a pointer to another structure */
                /* Member is a pointer to another structure */
-               memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
-               if(!memb_ptr) ASN__ENCODE_FAILED;
-       } else {
-               memb_ptr = (char *)sptr + elm->memb_offset;
-       }
-
-       if(ct && ct->range_bits >= 0) {
-               if(per_put_few_bits(po, present_enc, ct->range_bits))
-                       ASN__ENCODE_FAILED;
-
-               return elm->type->uper_encoder(elm->type, elm->per_constraints,
-                       memb_ptr, po);
+        memb_ptr =
+            *(const void *const *)((const char *)sptr + elm->memb_offset);
+        if(!memb_ptr) ASN__ENCODE_FAILED;
        } else {
        } else {
-               asn_enc_rval_t rval;
-               if(specs->ext_start == -1)
-                       ASN__ENCODE_FAILED;
-               if(uper_put_nsnnwn(po, present_enc - specs->ext_start))
-                       ASN__ENCODE_FAILED;
-               if(uper_open_type_put(elm->type, elm->per_constraints,
-                       memb_ptr, po))
-                       ASN__ENCODE_FAILED;
-               rval.encoded = 0;
-               ASN__ENCODED_OK(rval);
-       }
+        memb_ptr = (const char *)sptr + elm->memb_offset;
+    }
+
+    if(ct && ct->range_bits >= 0) {
+        if(per_put_few_bits(po, present_enc, ct->range_bits))
+            ASN__ENCODE_FAILED;
+
+        return elm->type->op->uper_encoder(
+            elm->type, elm->encoding_constraints.per_constraints, memb_ptr, po);
+    } else {
+        asn_enc_rval_t rval;
+        if(specs->ext_start == -1) ASN__ENCODE_FAILED;
+        if(uper_put_nsnnwn(po, present_enc - specs->ext_start))
+            ASN__ENCODE_FAILED;
+        if(uper_open_type_put(elm->type,
+                              elm->encoding_constraints.per_constraints,
+                              memb_ptr, po))
+            ASN__ENCODE_FAILED;
+        rval.encoded = 0;
+        ASN__ENCODED_OK(rval);
+    }
 }
 }
-   
+
 
 int
 
 int
-CHOICE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
-               asn_app_consume_bytes_f *cb, void *app_key) {
-       asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
-       int present;
+CHOICE_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+             asn_app_consume_bytes_f *cb, void *app_key) {
+    const asn_CHOICE_specifics_t *specs = (const asn_CHOICE_specifics_t *)td->specifics;
+       unsigned present;
 
        if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
 
 
        if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
 
@@ -1024,7 +1045,7 @@ CHOICE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
                                return -1;
                }
 
                                return -1;
                }
 
-               return elm->type->print_struct(elm->type, memb_ptr, ilevel,
+               return elm->type->op->print_struct(elm->type, memb_ptr, ilevel,
                        cb, app_key);
        } else {
                return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
                        cb, app_key);
        } else {
                return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
@@ -1032,9 +1053,11 @@ CHOICE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 }
 
 void
 }
 
 void
-CHOICE_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
-       asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
-       int present;
+CHOICE_free(const asn_TYPE_descriptor_t *td, void *ptr,
+            enum asn_struct_free_method method) {
+    const asn_CHOICE_specifics_t *specs =
+        (const asn_CHOICE_specifics_t *)td->specifics;
+    unsigned present;
 
        if(!td || !ptr)
                return;
 
        if(!td || !ptr)
                return;
@@ -1063,9 +1086,16 @@ CHOICE_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
                }
        }
 
                }
        }
 
-       if(!contents_only) {
-               FREEMEM(ptr);
-       }
+    switch(method) {
+    case ASFM_FREE_EVERYTHING:
+        FREEMEM(ptr);
+        break;
+    case ASFM_FREE_UNDERLYING:
+        break;
+    case ASFM_FREE_UNDERLYING_AND_RESET:
+        memset(ptr, 0, specs->struct_size);
+        break;
+    }
 }
 
 
 }
 
 
@@ -1078,17 +1108,18 @@ CHOICE_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
  * is guaranteed to be aligned properly. ASN.1 compiler itself does not
  * produce packed code.
  */
  * is guaranteed to be aligned properly. ASN.1 compiler itself does not
  * produce packed code.
  */
-static int
-_fetch_present_idx(const void *struct_ptr, int pres_offset, int pres_size) {
-       const void *present_ptr;
-       int present;
+static unsigned
+_fetch_present_idx(const void *struct_ptr, unsigned pres_offset,
+                   unsigned pres_size) {
+    const void *present_ptr;
+       unsigned present;
 
        present_ptr = ((const char *)struct_ptr) + pres_offset;
 
        switch(pres_size) {
 
        present_ptr = ((const char *)struct_ptr) + pres_offset;
 
        switch(pres_size) {
-       case sizeof(int):       present =   *(const int *)present_ptr; break;
-       case sizeof(short):     present = *(const short *)present_ptr; break;
-       case sizeof(char):      present =  *(const char *)present_ptr; break;
+       case sizeof(int):       present = *(const unsigned int *)present_ptr; break;
+       case sizeof(short):     present = *(const unsigned short *)present_ptr; break;
+       case sizeof(char):      present = *(const unsigned char *)present_ptr; break;
        default:
                /* ANSI C mandates enum to be equivalent to integer */
                assert(pres_size != sizeof(int));
        default:
                /* ANSI C mandates enum to be equivalent to integer */
                assert(pres_size != sizeof(int));
@@ -1099,16 +1130,211 @@ _fetch_present_idx(const void *struct_ptr, int pres_offset, int pres_size) {
 }
 
 static void
 }
 
 static void
-_set_present_idx(void *struct_ptr, int pres_offset, int pres_size, int present) {
-       void *present_ptr;
+_set_present_idx(void *struct_ptr, unsigned pres_offset, unsigned pres_size,
+                 unsigned present) {
+    void *present_ptr;
        present_ptr = ((char *)struct_ptr) + pres_offset;
 
        switch(pres_size) {
        present_ptr = ((char *)struct_ptr) + pres_offset;
 
        switch(pres_size) {
-       case sizeof(int):       *(int *)present_ptr   = present; break;
-       case sizeof(short):     *(short *)present_ptr = present; break;
-       case sizeof(char):      *(char *)present_ptr  = present; break;
+       case sizeof(int):       *(unsigned int *)present_ptr   = present; break;
+       case sizeof(short):     *(unsigned short *)present_ptr = present; break;
+       case sizeof(char):      *(unsigned char *)present_ptr  = present; break;
        default:
                /* ANSI C mandates enum to be equivalent to integer */
                assert(pres_size != sizeof(int));
        }
 }
        default:
                /* ANSI C mandates enum to be equivalent to integer */
                assert(pres_size != sizeof(int));
        }
 }
+
+static const void *
+_get_member_ptr(const asn_TYPE_descriptor_t *td, const void *sptr,
+                asn_TYPE_member_t **elm_ptr, unsigned *present_out) {
+    const asn_CHOICE_specifics_t *specs =
+        (const asn_CHOICE_specifics_t *)td->specifics;
+    unsigned present;
+
+    if(!sptr) {
+        *elm_ptr = NULL;
+        *present_out = 0;
+        return NULL;
+    }
+
+    /*
+        * Figure out which CHOICE element is encoded.
+        */
+       present = _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
+    *present_out = present;
+
+    /*
+     * The presence index is intentionally 1-based to avoid
+     * treating zeroed structure as a valid one.
+     */
+       if(present > 0 && present <= td->elements_count) {
+        asn_TYPE_member_t *const elm = &td->elements[present - 1];
+        const void *memb_ptr;
+
+               if(elm->flags & ATF_POINTER) {
+            memb_ptr =
+                *(const void *const *)((const char *)sptr + elm->memb_offset);
+        } else {
+            memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+        }
+        *elm_ptr = elm;
+        return memb_ptr;
+    } else {
+        *elm_ptr = NULL;
+        return NULL;
+    }
+
+}
+
+int
+CHOICE_compare(const asn_TYPE_descriptor_t *td, const void *aptr, const void *bptr) {
+    asn_TYPE_member_t *aelm;
+    asn_TYPE_member_t *belm;
+    unsigned apresent = 0;
+    unsigned bpresent = 0;
+    const void *amember = _get_member_ptr(td, aptr, &aelm, &apresent);
+    const void *bmember = _get_member_ptr(td, bptr, &belm, &bpresent);
+
+    if(amember && bmember) {
+        if(apresent == bpresent) {
+            assert(aelm == belm);
+            return aelm->type->op->compare_struct(aelm->type, amember, bmember);
+        } else if(apresent < bpresent) {
+            return -1;
+        } else {
+            return 1;
+        }
+    } else if(!amember) {
+        return -1;
+    } else {
+        return 1;
+    }
+}
+
+/*
+ * Return the 1-based choice variant presence index.
+ * Returns 0 in case of error.
+ */
+unsigned
+CHOICE_variant_get_presence(const asn_TYPE_descriptor_t *td, const void *sptr) {
+    const asn_CHOICE_specifics_t *specs =
+        (const asn_CHOICE_specifics_t *)td->specifics;
+    return _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
+}
+
+/*
+ * Sets or resets the 1-based choice variant presence index.
+ * In case a previous index is not zero, the currently selected structure
+ * member is freed and zeroed-out first.
+ * Returns 0 on success and -1 on error.
+ */
+int
+CHOICE_variant_set_presence(const asn_TYPE_descriptor_t *td, void *sptr,
+                            unsigned present) {
+    const asn_CHOICE_specifics_t *specs =
+        (const asn_CHOICE_specifics_t *)td->specifics;
+    unsigned old_present;
+
+    if(!sptr) {
+        return -1;
+    }
+
+    if(present > td->elements_count)
+        return -1;
+
+    old_present =
+        _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
+    if(present == old_present)
+        return 0;
+
+    if(old_present != 0) {
+        assert(old_present <= td->elements_count);
+        ASN_STRUCT_RESET(*td, sptr);
+    }
+
+    _set_present_idx(sptr, specs->pres_offset, specs->pres_size, present);
+
+    return 0;
+}
+
+
+asn_random_fill_result_t
+CHOICE_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                   const asn_encoding_constraints_t *constr,
+                   size_t max_length) {
+    const asn_CHOICE_specifics_t *specs =
+        (const asn_CHOICE_specifics_t *)td->specifics;
+    asn_random_fill_result_t res;
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    const asn_TYPE_member_t *elm;
+    unsigned present;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *st = *sptr;
+
+    if(max_length == 0) return result_skipped;
+
+    (void)constr;
+
+    if(st == NULL) {
+        st = CALLOC(1, specs->struct_size);
+        if(st == NULL) {
+            return result_failed;
+        }
+    }
+
+    present = asn_random_between(1, td->elements_count);
+    elm = &td->elements[present - 1];
+
+       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;
+       }
+
+    res = elm->type->op->random_fill(elm->type, memb_ptr2,
+                                    &elm->encoding_constraints, max_length);
+    _set_present_idx(st, specs->pres_offset, specs->pres_size, present);
+    if(res.code == ARFILL_OK) {
+        *sptr = st;
+    } else {
+        if(st == *sptr) {
+            ASN_STRUCT_RESET(*td, st);
+        } else {
+            ASN_STRUCT_FREE(*td, st);
+        }
+    }
+
+    return res;
+}
+
+
+asn_TYPE_operation_t asn_OP_CHOICE = {
+       CHOICE_free,
+       CHOICE_print,
+       CHOICE_compare,
+       CHOICE_decode_ber,
+       CHOICE_encode_der,
+       CHOICE_decode_xer,
+       CHOICE_encode_xer,
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       CHOICE_decode_oer,
+       CHOICE_encode_oer,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
+       CHOICE_decode_uper,
+       CHOICE_encode_uper,
+#endif /* ASN_DISABLE_PER_SUPPORT */
+       CHOICE_random_fill,
+       CHOICE_outmost_tag
+};
diff --git a/libs/smux/constr_CHOICE_oer.c b/libs/smux/constr_CHOICE_oer.c
new file mode 100644 (file)
index 0000000..6480a96
--- /dev/null
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_DISABLE_OER_SUPPORT
+
+#include <asn_internal.h>
+#include <constr_CHOICE.h>
+#include <errno.h>
+
+/*
+ * Return a standardized complex structure.
+ */
+#undef  RETURN
+#define RETURN(_code)                    \
+    do {                                 \
+        asn_dec_rval_t rval;             \
+        rval.code = _code;               \
+        rval.consumed = consumed_myself; \
+        return rval;                     \
+    } while(0)
+
+#undef  ADVANCE
+#define ADVANCE(num_bytes)               \
+    do {                                 \
+        size_t num = num_bytes;          \
+        ptr = ((const char *)ptr) + num; \
+        size -= num;                     \
+        consumed_myself += num;          \
+    } while(0)
+
+/*
+ * Switch to the next phase of parsing.
+ */
+#undef  NEXT_PHASE
+#define NEXT_PHASE(ctx) \
+    do {                \
+        ctx->phase++;   \
+        ctx->step = 0;  \
+    } while(0)
+#undef  SET_PHASE
+#define SET_PHASE(ctx, value) \
+    do {                      \
+        ctx->phase = value;   \
+        ctx->step = 0;        \
+    } while(0)
+
+/*
+ * Tags are canonically sorted in the tag to member table.
+ */
+static int
+_search4tag(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)
+            return 0;
+        else if(a_value < b_value)
+            return -1;
+        else
+            return 1;
+    } else if(a_class < b_class) {
+        return -1;
+    } else {
+        return 1;
+    }
+}
+
+/*
+ * X.696 (08/2015) #8.7 Encoding of tags
+ */
+static ssize_t
+oer_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 & 0x3F) != 0x3F) {
+        /* #8.7.1 */
+        *tag_r = ((val & 0x3F) << 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 */
+}
+
+asn_dec_rval_t
+CHOICE_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
+                  const asn_TYPE_descriptor_t *td,
+                  const asn_oer_constraints_t *constraints, void **struct_ptr,
+                  const void *ptr, size_t size) {
+    /*
+     * Bring closer parts of structure description.
+     */
+    const asn_CHOICE_specifics_t *specs =
+        (const asn_CHOICE_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 */
+
+    ssize_t consumed_myself = 0; /* Consumed bytes from ptr */
+
+    (void)constraints;
+
+    ASN_DEBUG("Decoding %s as CHOICE", 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);
+    switch(ctx->phase) {
+    case 0: {
+        /*
+         * Discover the tag.
+         */
+        ber_tlv_tag_t tlv_tag; /* T from TLV */
+        ssize_t tag_len;       /* Length of TLV's T */
+
+        tag_len = oer_fetch_tag(ptr, size, &tlv_tag);
+        switch(tag_len) {
+        case 0:
+            ASN__DECODE_STARVED;
+        case -1:
+            ASN__DECODE_FAILED;
+        }
+
+        do {
+            const asn_TYPE_tag2member_t *t2m;
+            asn_TYPE_tag2member_t key = {0, 0, 0, 0};
+            key.el_tag = tlv_tag;
+
+            t2m = (const asn_TYPE_tag2member_t *)bsearch(
+                &key, specs->tag2el, specs->tag2el_count,
+                sizeof(specs->tag2el[0]), _search4tag);
+            if(t2m) {
+                /*
+                 * Found the element corresponding to the tag.
+                 */
+                NEXT_PHASE(ctx);
+                ctx->step = t2m->el_no;
+                break;
+            } else if(specs->ext_start == -1) {
+                ASN_DEBUG(
+                    "Unexpected tag %s "
+                    "in non-extensible CHOICE %s",
+                    ber_tlv_tag_string(tlv_tag), td->name);
+                RETURN(RC_FAIL);
+            } else {
+                /* Skip open type extension */
+                ASN_DEBUG(
+                    "Not implemented skipping open type extension for tag %s",
+                    ber_tlv_tag_string(tlv_tag));
+                RETURN(RC_FAIL);
+            }
+        } while(0);
+
+
+        ADVANCE(tag_len);
+    }
+        /* Fall through */
+    case 1: {
+        asn_TYPE_member_t *elm = &elements[ctx->step]; /* CHOICE's element */
+        void *memb_ptr;         /* Pointer to the member */
+        void **memb_ptr2;       /* Pointer to that pointer */
+        asn_dec_rval_t rval;
+
+        /*
+         * 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(elm->flags & ATF_POINTER) {
+            /* Member is a pointer to another structure */
+            memb_ptr2 = (void **)((char *)st + elm->memb_offset);
+        } else {
+            /*
+             * A pointer to a pointer
+             * holding the start of the structure
+             */
+            memb_ptr = (char *)st + elm->memb_offset;
+            memb_ptr2 = &memb_ptr;
+        }
+
+        /* Set presence to be able to free it properly at any time */
+        (void)CHOICE_variant_set_presence(td, st, ctx->step + 1);
+
+        if(specs->ext_start >= 0 && specs->ext_start <= ctx->step) {
+            ssize_t got =
+                oer_open_type_get(opt_codec_ctx, elm->type,
+                                  elm->encoding_constraints.oer_constraints,
+                                  memb_ptr2, ptr, size);
+            if(got < 0) ASN__DECODE_FAILED;
+            if(got == 0) ASN__DECODE_STARVED;
+            rval.code = RC_OK;
+            rval.consumed = got;
+        } else {
+            rval = elm->type->op->oer_decoder(
+                opt_codec_ctx, elm->type,
+                elm->encoding_constraints.oer_constraints, memb_ptr2, ptr,
+                size);
+        }
+        rval.consumed += consumed_myself;
+        switch(rval.code) {
+        case RC_OK:
+            NEXT_PHASE(ctx);
+        case RC_WMORE:
+            break;
+        case RC_FAIL:
+            SET_PHASE(ctx, 3);  /* => 3 */
+        }
+        return rval;
+    }
+    case 2:
+        /* Already decoded everything */
+        RETURN(RC_OK);
+    case 3:
+        /* Failed to decode, after all */
+        RETURN(RC_FAIL);
+    }
+
+    RETURN(RC_FAIL);
+}
+
+/*
+ * X.696 (08/2015) #8.7 Encoding of tags
+ */
+static ssize_t
+oer_put_tag(ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) {
+    uint8_t tclass = BER_TAG_CLASS(tag);
+    ber_tlv_tag_t tval = BER_TAG_VALUE(tag);
+
+    if(tval < 0x3F) {
+        uint8_t b = (uint8_t)((tclass << 6) | tval);
+        if(cb(&b, 1, app_key) < 0) {
+            return -1;
+        }
+        return 1;
+    } else {
+        uint8_t buf[1 + 2 * sizeof(tval)];
+        uint8_t *b = &buf[sizeof(buf)-1]; /* Last addressable */
+        size_t encoded;
+        for(; ; tval >>= 7) {
+            if(tval >> 7) {
+                *b-- = 0x80 | (tval & 0x7f);
+            } else {
+                *b-- = tval & 0x7f;
+                break;
+            }
+        }
+        *b = (uint8_t)((tclass << 6) | 0x3F);
+        encoded = sizeof(buf) - (b - buf);
+        if(cb(b, encoded, app_key) < 0) {
+            return -1;
+        }
+        return encoded;
+    }
+
+}
+
+/*
+ * Encode as Canonical OER.
+ */
+asn_enc_rval_t
+CHOICE_encode_oer(const asn_TYPE_descriptor_t *td,
+                  const asn_oer_constraints_t *constraints, const void *sptr,
+                  asn_app_consume_bytes_f *cb, void *app_key) {
+    const asn_CHOICE_specifics_t *specs =
+        (const asn_CHOICE_specifics_t *)td->specifics;
+    asn_TYPE_member_t *elm; /* CHOICE element */
+    unsigned present;
+    const void *memb_ptr;
+    ber_tlv_tag_t tag;
+    ssize_t tag_len;
+    asn_enc_rval_t er = {0, 0, 0};
+
+    (void)constraints;
+
+    if(!sptr) ASN__ENCODE_FAILED;
+
+    ASN_DEBUG("OER %s encoding as CHOICE", td->name);
+
+    present = CHOICE_variant_get_presence(td, sptr);
+    if(present == 0 || present > td->elements_count) {
+        ASN_DEBUG("CHOICE %s member is not selected", td->name);
+        ASN__ENCODE_FAILED;
+    }
+
+    elm = &td->elements[present-1];
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr =
+            *(const void *const *)((const char *)sptr + elm->memb_offset);
+        if(memb_ptr == 0) {
+            /* Mandatory element absent */
+            ASN__ENCODE_FAILED;
+        }
+    } else {
+        memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+    }
+
+    tag = asn_TYPE_outmost_tag(elm->type, memb_ptr, elm->tag_mode, elm->tag);
+    if(tag == 0) {
+        ASN__ENCODE_FAILED;
+    }
+
+    tag_len = oer_put_tag(tag, cb, app_key);
+    if(tag_len < 0) {
+        ASN__ENCODE_FAILED;
+    }
+
+    if(specs->ext_start >= 0 && (unsigned)specs->ext_start <= (present-1)) {
+        ssize_t encoded = oer_open_type_put(elm->type,
+                               elm->encoding_constraints.oer_constraints,
+                               memb_ptr, cb, app_key);
+        if(encoded < 0) ASN__ENCODE_FAILED;
+        er.encoded = tag_len + encoded;
+    } else {
+        er = elm->type->op->oer_encoder(
+            elm->type, elm->encoding_constraints.oer_constraints, memb_ptr, cb,
+            app_key);
+        if(er.encoded >= 0) er.encoded += tag_len;
+    }
+
+    return er;
+}
+
+#endif  /* ASN_DISABLE_OER_SUPPORT */
index 5923023dee1dbf545b4daeb140f2ea8bd4dfcbf6..2fbf97b67150a405dccd94e59f06a452dae3cd99 100644 (file)
@@ -1,10 +1,11 @@
-/*-
- * Copyright (c) 2003, 2004, 2005, 2006, 2007 Lev Walkin <vlm@lionet.info>.
+/*
+ * Copyright (c) 2003-2017 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>
  * All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_internal.h>
 #include <constr_SEQUENCE.h>
+#include <OPEN_TYPE.h>
 #include <per_opentype.h>
 
 /*
 #include <per_opentype.h>
 
 /*
 /*
  * Check whether we are inside the extensions group.
  */
 /*
  * 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))
-
+#define IN_EXTENSION_GROUP(specs, memb_idx) \
+    ((specs)->first_extension >= 0          \
+     && (unsigned)(specs)->first_extension <= (memb_idx))
 
 /*
  * Tags are canonically sorted in the tag2element map.
 
 /*
  * Tags are canonically sorted in the tag2element map.
@@ -109,15 +109,16 @@ _t2e_cmp(const void *ap, const void *bp) {
  * The decoder of the SEQUENCE type.
  */
 asn_dec_rval_t
  * 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) {
-       /*
+SEQUENCE_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
+                    const asn_TYPE_descriptor_t *td, void **struct_ptr,
+                    const void *ptr, size_t size, int tag_mode) {
+    /*
         * Bring closer parts of structure description.
         */
         * 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 asn_SEQUENCE_specifics_t *specs = (const asn_SEQUENCE_specifics_t *)td->specifics;
+    const asn_TYPE_member_t *elements = td->elements;
 
 
-       /*
+    /*
         * Parts of the structure being constructed.
         */
        void *st = *struct_ptr; /* Target structure. */
         * Parts of the structure being constructed.
         */
        void *st = *struct_ptr; /* Target structure. */
@@ -127,7 +128,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
        asn_dec_rval_t rval;    /* Return code from subparsers */
 
        ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
        asn_dec_rval_t rval;    /* Return code from subparsers */
 
        ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
-       int edx;                        /* SEQUENCE element's index */
+       size_t edx;                     /* SEQUENCE element's index */
 
        ASN_DEBUG("Decoding %s as SEQUENCE", td->name);
        
 
        ASN_DEBUG("Decoding %s as SEQUENCE", td->name);
        
@@ -186,14 +187,14 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                 * that member:
                 *      step = (<member_number> * 2 + <microphase>).
                 */
                 * that member:
                 *      step = (<member_number> * 2 + <microphase>).
                 */
-         for(edx = (ctx->step >> 1); edx < td->elements_count;
+         for(edx = ((size_t)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 */
                        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 */
+               size_t opt_edx_end;     /* Next non-optional element */
+               size_t n;
                int use_bsearch;
                int use_bsearch;
-               int n;
 
                if(ctx->step & 1)
                        goto microphase2;
 
                if(ctx->step & 1)
                        goto microphase2;
@@ -201,36 +202,31 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                /*
                 * MICROPHASE 1: Synchronize decoding.
                 */
                /*
                 * MICROPHASE 1: Synchronize decoding.
                 */
-               ASN_DEBUG("In %s SEQUENCE left %d, edx=%d flags=%d"
+               ASN_DEBUG("In %s SEQUENCE left %d, edx=%" ASN_PRI_SIZE " flags=%d"
                                " opt=%d ec=%d",
                        td->name, (int)ctx->left, edx,
                        elements[edx].flags, elements[edx].optional,
                        td->elements_count);
 
                                " 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);
-               }
+        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))) {
+            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);
 
                /*
                 * Fetch the T from TLV.
                 */
                tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag);
-               ASN_DEBUG("Current tag in %s SEQUENCE for element %d "
+               ASN_DEBUG("Current tag in %s SEQUENCE for element %" ASN_PRI_SIZE " "
                        "(%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);
                        "(%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);
@@ -240,34 +236,31 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                case -1: RETURN(RC_FAIL);
                }
 
                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;
-                               }
-                       }
-               }
+        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 = %" ASN_PRI_SIZE ", opt = %d, ec=%d", edx,
+                          elements[edx].optional, td->elements_count);
+                if((edx + elements[edx].optional == td->elements_count)
+                   || IN_EXTENSION_GROUP(specs, edx)) {
+                    /*
+                     * 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.
 
                /*
                 * Find the next available type with this tag.
@@ -292,7 +285,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                                edx = n;
                                ctx->step = 1 + 2 * edx;        /* Remember! */
                                goto microphase2;
                                edx = n;
                                ctx->step = 1 + 2 * edx;        /* Remember! */
                                goto microphase2;
-                       } else if(elements[n].flags & ATF_OPEN_TYPE) {
+                       } else if(elements[n].flags & ATF_ANY_TYPE) {
                                /*
                                 * This is the ANY type, which may bear
                                 * any flag whatsoever.
                                /*
                                 * This is the ANY type, which may bear
                                 * any flag whatsoever.
@@ -311,7 +304,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                         * sorted array of tags.
                         */
                        const asn_TYPE_tag2member_t *t2m;
                         * sorted array of tags.
                         */
                        const asn_TYPE_tag2member_t *t2m;
-                       asn_TYPE_tag2member_t key;
+                       asn_TYPE_tag2member_t key = {0, 0, 0, 0};
                        key.el_tag = tlv_tag;
                        key.el_no = edx;
                        t2m = (const asn_TYPE_tag2member_t *)bsearch(&key,
                        key.el_tag = tlv_tag;
                        key.el_no = edx;
                        t2m = (const asn_TYPE_tag2member_t *)bsearch(&key,
@@ -320,7 +313,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        if(t2m) {
                                const asn_TYPE_tag2member_t *best = 0;
                                const asn_TYPE_tag2member_t *t2m_f, *t2m_l;
                        if(t2m) {
                                const asn_TYPE_tag2member_t *best = 0;
                                const asn_TYPE_tag2member_t *t2m_f, *t2m_l;
-                               int edx_max = edx + elements[edx].optional;
+                               size_t edx_max = edx + elements[edx].optional;
                                /*
                                 * Rewind to the first element with that tag,
                                 * `cause bsearch() does not guarantee order.
                                /*
                                 * Rewind to the first element with that tag,
                                 * `cause bsearch() does not guarantee order.
@@ -349,7 +342,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                         */
                        if(!IN_EXTENSION_GROUP(specs,
                                edx + elements[edx].optional)) {
                         */
                        if(!IN_EXTENSION_GROUP(specs,
                                edx + elements[edx].optional)) {
-                               ASN_DEBUG("Unexpected tag %s (at %d)",
+                               ASN_DEBUG("Unexpected tag %s (at %" ASN_PRI_SIZE ")",
                                        ber_tlv_tag_string(tlv_tag), edx);
                                ASN_DEBUG("Expected tag %s (%s)%s",
                                        ber_tlv_tag_string(elements[edx].tag),
                                        ber_tlv_tag_string(tlv_tag), edx);
                                ASN_DEBUG("Expected tag %s (%s)%s",
                                        ber_tlv_tag_string(elements[edx].tag),
@@ -362,7 +355,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                                ssize_t skip;
                                edx += elements[edx].optional;
 
                                ssize_t skip;
                                edx += elements[edx].optional;
 
-                               ASN_DEBUG("Skipping unexpected %s (at %d)",
+                               ASN_DEBUG("Skipping unexpected %s (at %" ASN_PRI_SIZE ")",
                                        ber_tlv_tag_string(tlv_tag), edx);
                                skip = ber_skip_length(opt_codec_ctx,
                                        BER_TLV_CONSTRUCTED(ptr),
                                        ber_tlv_tag_string(tlv_tag), edx);
                                skip = ber_skip_length(opt_codec_ctx,
                                        BER_TLV_CONSTRUCTED(ptr),
@@ -409,11 +402,15 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                /*
                 * Invoke the member fetch routine according to member's type
                 */
                /*
                 * 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 "
+               if(elements[edx].flags & ATF_OPEN_TYPE) {
+                       rval = OPEN_TYPE_ber_get(opt_codec_ctx, td, st, &elements[edx], ptr, LEFT);
+        } else {
+                       rval = elements[edx].type->op->ber_decoder(opt_codec_ctx,
+                                       elements[edx].type,
+                                       memb_ptr2, ptr, LEFT,
+                                       elements[edx].tag_mode);
+               }
+               ASN_DEBUG("In %s SEQUENCE decoded %" ASN_PRI_SIZE " %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);
                        "in %d bytes rval.code %d, size=%d",
                        td->name, edx, elements[edx].type->name,
                        (int)LEFT, (int)rval.consumed, rval.code, (int)size);
@@ -437,6 +434,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 
        phase3:
                ctx->phase = 3;
 
        phase3:
                ctx->phase = 3;
+        /* Fall through */
        case 3: /* 00 and other tags expected */
        case 4: /* only 00's expected */
 
        case 3: /* 00 and other tags expected */
        case 4: /* only 00's expected */
 
@@ -510,13 +508,13 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
  * The DER encoder of the SEQUENCE type.
  */
 asn_enc_rval_t
  * 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;
+SEQUENCE_encode_der(const asn_TYPE_descriptor_t *td, const 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;
        asn_enc_rval_t erval;
        ssize_t ret;
-       int edx;
+       size_t edx;
 
        ASN_DEBUG("%s %s as SEQUENCE",
                cb?"Encoding":"Estimating", td->name);
 
        ASN_DEBUG("%s %s as SEQUENCE",
                cb?"Encoding":"Estimating", td->name);
@@ -526,24 +524,37 @@ SEQUENCE_encode_der(asn_TYPE_descriptor_t *td,
         */
        for(edx = 0; edx < td->elements_count; edx++) {
                asn_TYPE_member_t *elm = &td->elements[edx];
         */
        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;
+
+               const void *memb_ptr;           /* Pointer to the member */
+        const void *const *memb_ptr2; /* Pointer to that pointer */
+
+        if(elm->flags & ATF_POINTER) {
+            memb_ptr2 =
+                (const void *const *)((const char *)sptr + elm->memb_offset);
+            if(!*memb_ptr2) {
+                               ASN_DEBUG("Element %s %" ASN_PRI_SIZE " not present",
+                                       elm->name, edx);
+                               if(elm->optional)
+                                       continue;
                                /* Mandatory element is missing */
                                ASN__ENCODE_FAILED;
                        }
                } else {
                                /* Mandatory element is missing */
                                ASN__ENCODE_FAILED;
                        }
                } else {
-                       memb_ptr = (void *)((char *)sptr + elm->memb_offset);
+            memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+            memb_ptr2 = &memb_ptr;
                }
                }
-               erval = elm->type->der_encoder(elm->type, memb_ptr,
+
+               /* Eliminate default values */
+               if(elm->default_value_cmp && elm->default_value_cmp(*memb_ptr2) == 0)
+                       continue;
+
+               erval = elm->type->op->der_encoder(elm->type, *memb_ptr2,
                        elm->tag_mode, elm->tag,
                        0, 0);
                if(erval.encoded == -1)
                        return erval;
                computed_size += erval.encoded;
                        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",
+               ASN_DEBUG("Member %" ASN_PRI_SIZE " %s estimated %ld bytes",
                        edx, elm->name, (long)erval.encoded);
        }
 
                        edx, elm->name, (long)erval.encoded);
        }
 
@@ -564,21 +575,28 @@ SEQUENCE_encode_der(asn_TYPE_descriptor_t *td,
        for(edx = 0; edx < td->elements_count; edx++) {
                asn_TYPE_member_t *elm = &td->elements[edx];
                asn_enc_rval_t tmperval;
        for(edx = 0; edx < td->elements_count; edx++) {
                asn_TYPE_member_t *elm = &td->elements[edx];
                asn_enc_rval_t tmperval;
-               void *memb_ptr;
+        const void *memb_ptr;           /* Pointer to the member */
+        const void *const *memb_ptr2;   /* Pointer to that pointer */
 
 
-               if(elm->flags & ATF_POINTER) {
-                       memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
-                       if(!memb_ptr) continue;
+        if(elm->flags & ATF_POINTER) {
+            memb_ptr2 =
+                (const void *const *)((const char *)sptr + elm->memb_offset);
+            if(!*memb_ptr2) continue;
                } else {
                } else {
-                       memb_ptr = (void *)((char *)sptr + elm->memb_offset);
+            memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+            memb_ptr2 = &memb_ptr;
                }
                }
-               tmperval = elm->type->der_encoder(elm->type, memb_ptr,
-                       elm->tag_mode, elm->tag,
-                       cb, app_key);
+
+               /* Eliminate default values */
+        if(elm->default_value_cmp && elm->default_value_cmp(*memb_ptr2) == 0)
+            continue;
+
+               tmperval = elm->type->op->der_encoder(elm->type, *memb_ptr2,
+                       elm->tag_mode, elm->tag, cb, app_key);
                if(tmperval.encoded == -1)
                        return tmperval;
                computed_size -= tmperval.encoded;
                if(tmperval.encoded == -1)
                        return tmperval;
                computed_size -= tmperval.encoded;
-               ASN_DEBUG("Member %d %s of SEQUENCE %s encoded in %ld bytes",
+               ASN_DEBUG("Member %" ASN_PRI_SIZE " %s of SEQUENCE %s encoded in %ld bytes",
                        edx, elm->name, td->name, (long)tmperval.encoded);
        }
 
                        edx, elm->name, td->name, (long)tmperval.encoded);
        }
 
@@ -593,25 +611,26 @@ SEQUENCE_encode_der(asn_TYPE_descriptor_t *td,
 
 
 #undef XER_ADVANCE
 
 
 #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)
+#define XER_ADVANCE(num_bytes)           \
+    do {                                 \
+        size_t num = (num_bytes);        \
+        ptr = ((const char *)ptr) + num; \
+        size -= num;                     \
+        consumed_myself += num;          \
+    } while(0)
 
 /*
  * Decode the XER (XML) data.
  */
 asn_dec_rval_t
 
 /*
  * 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) {
-       /*
+SEQUENCE_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
+                    const asn_TYPE_descriptor_t *td, void **struct_ptr,
+                    const char *opt_mname, const void *ptr, size_t size) {
+    /*
         * Bring closer parts of structure description.
         */
         * Bring closer parts of structure description.
         */
-       asn_SEQUENCE_specifics_t *specs
-               = (asn_SEQUENCE_specifics_t *)td->specifics;
+       const asn_SEQUENCE_specifics_t *specs
+               = (const asn_SEQUENCE_specifics_t *)td->specifics;
        asn_TYPE_member_t *elements = td->elements;
        const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
 
        asn_TYPE_member_t *elements = td->elements;
        const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
 
@@ -623,8 +642,7 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 
        asn_dec_rval_t rval;            /* Return value from a decoder */
        ssize_t consumed_myself = 0;    /* Consumed bytes from ptr */
 
        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;
+       size_t edx;                     /* Element index */
 
        /*
         * Create the target structure if it is not present already.
 
        /*
         * Create the target structure if it is not present already.
@@ -653,14 +671,13 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                ssize_t ch_size;                /* Chunk size */
                xer_check_tag_e tcv;            /* Tag check value */
                asn_TYPE_member_t *elm;
                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;
 
                /*
                 * 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_ptr_dontuse;         /* Pointer to the member */
                        void **memb_ptr2;       /* Pointer to that pointer */
 
                        elm = &td->elements[edx];
                        void **memb_ptr2;       /* Pointer to that pointer */
 
                        elm = &td->elements[edx];
@@ -669,14 +686,18 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                                /* Member is a pointer to another structure */
                                memb_ptr2 = (void **)((char *)st + elm->memb_offset);
                        } else {
                                /* 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;
+                               memb_ptr_dontuse = (char *)st + elm->memb_offset;
+                               memb_ptr2 = &memb_ptr_dontuse;  /* Only use of memb_ptr_dontuse */
                        }
 
                        }
 
-                       /* 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);
+                       if(elm->flags & ATF_OPEN_TYPE) {
+                               tmprval = OPEN_TYPE_xer_get(opt_codec_ctx, td, st, elm, ptr, size);
+                       } else {
+                               /* Invoke the inner type decoder, m.b. multiple times */
+                               tmprval = elm->type->op->xer_decoder(opt_codec_ctx,
+                                               elm->type, memb_ptr2, elm->name,
+                                               ptr, size);
+                       }
                        XER_ADVANCE(tmprval.consumed);
                        if(tmprval.code != RC_OK)
                                RETURN(tmprval.code);
                        XER_ADVANCE(tmprval.consumed);
                        if(tmprval.code != RC_OK)
                                RETURN(tmprval.code);
@@ -690,14 +711,14 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                /*
                 * Get the next part of the XML stream.
                 */
                /*
                 * Get the next part of the XML stream.
                 */
-               ch_size = xer_next_token(&ctx->context, buf_ptr, size,
+               ch_size = xer_next_token(&ctx->context, ptr, size,
                        &ch_type);
                if(ch_size == -1) {
                    RETURN(RC_FAIL);
                        &ch_type);
                if(ch_size == -1) {
                    RETURN(RC_FAIL);
-        } else {
+               } else {
                        switch(ch_type) {
                        switch(ch_type) {
-            case PXER_WMORE:
-                RETURN(RC_WMORE);
+                       case PXER_WMORE:
+                               RETURN(RC_WMORE);
                        case PXER_COMMENT:      /* Got XML comment */
                        case PXER_TEXT:         /* Ignore free-standing text */
                                XER_ADVANCE(ch_size);   /* Skip silently */
                        case PXER_COMMENT:      /* Got XML comment */
                        case PXER_TEXT:         /* Ignore free-standing text */
                                XER_ADVANCE(ch_size);   /* Skip silently */
@@ -707,7 +728,7 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        }
                }
 
                        }
                }
 
-               tcv = xer_check_tag(buf_ptr, ch_size, xml_tag);
+               tcv = xer_check_tag(ptr, ch_size, xml_tag);
                ASN_DEBUG("XER/SEQUENCE: tcv = %d, ph=%d [%s]",
                        tcv, ctx->phase, xml_tag);
 
                ASN_DEBUG("XER/SEQUENCE: tcv = %d, ph=%d [%s]",
                        tcv, ctx->phase, xml_tag);
 
@@ -736,19 +757,13 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        ctx->phase = 0;
                        /* Fall through */
                case XCT_BOTH:
                        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);
+            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)) {
+                    XER_ADVANCE(ch_size);
                                        ctx->phase = 4; /* Phase out */
                                        RETURN(RC_OK);
                                } else {
                                        ctx->phase = 4; /* Phase out */
                                        RETURN(RC_OK);
                                } else {
@@ -767,7 +782,7 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                case XCT_UNKNOWN_OP:
                case XCT_UNKNOWN_BO:
 
                case XCT_UNKNOWN_OP:
                case XCT_UNKNOWN_BO:
 
-                       ASN_DEBUG("XER/SEQUENCE: tcv=%d, ph=%d, edx=%d",
+                       ASN_DEBUG("XER/SEQUENCE: tcv=%d, ph=%d, edx=%" ASN_PRI_SIZE "",
                                tcv, ctx->phase, edx);
                        if(ctx->phase != 1) {
                                break;  /* Really unexpected */
                                tcv, ctx->phase, edx);
                        if(ctx->phase != 1) {
                                break;  /* Really unexpected */
@@ -777,13 +792,13 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                                /*
                                 * Search which member corresponds to this tag.
                                 */
                                /*
                                 * Search which member corresponds to this tag.
                                 */
-                               edx_end = edx + elements[edx].optional + 1;
+                               size_t n;
+                               size_t 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];
                                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);
+                                       tcv = xer_check_tag(ptr, ch_size, elm->name);
                                        switch(tcv) {
                                        case XCT_BOTH:
                                        case XCT_OPENING:
                                        switch(tcv) {
                                        case XCT_BOTH:
                                        case XCT_OPENING:
@@ -805,7 +820,7 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                                if(n != edx_end)
                                        continue;
                        } else {
                                if(n != edx_end)
                                        continue;
                        } else {
-                               ASN_DEBUG("Out of defined members: %d/%d",
+                               ASN_DEBUG("Out of defined members: %" ASN_PRI_SIZE "/%u",
                                        edx, td->elements_count);
                        }
 
                                        edx, td->elements_count);
                        }
 
@@ -813,7 +828,7 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        if(IN_EXTENSION_GROUP(specs,
                                edx + (edx < td->elements_count
                                        ? elements[edx].optional : 0))) {
                        if(IN_EXTENSION_GROUP(specs,
                                edx + (edx < td->elements_count
                                        ? elements[edx].optional : 0))) {
-                               ASN_DEBUG("Got anticipated extension at %d",
+                               ASN_DEBUG("Got anticipated extension at %" ASN_PRI_SIZE "",
                                        edx);
                                /*
                                 * Check for (XCT_BOTH or XCT_UNKNOWN_BO)
                                        edx);
                                /*
                                 * Check for (XCT_BOTH or XCT_UNKNOWN_BO)
@@ -836,12 +851,12 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                }
 
                ASN_DEBUG("Unexpected XML tag in SEQUENCE [%c%c%c%c%c%c]",
                }
 
                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]:'.');
+                       size>0?((const char *)ptr)[0]:'.',
+                       size>1?((const char *)ptr)[1]:'.',
+                       size>2?((const char *)ptr)[2]:'.',
+                       size>3?((const char *)ptr)[3]:'.',
+                       size>4?((const char *)ptr)[4]:'.',
+                       size>5?((const char *)ptr)[5]:'.');
                break;
        }
 
                break;
        }
 
@@ -850,60 +865,77 @@ SEQUENCE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 }
 
 asn_enc_rval_t
 }
 
 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);
-               }
+SEQUENCE_encode_xer(const asn_TYPE_descriptor_t *td, const 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);
+    asn_TYPE_descriptor_t *tmp_def_val_td = 0;
+    void *tmp_def_val = 0;
+       size_t 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];
+        const void *memb_ptr;
+        const char *mname = elm->name;
+        unsigned int mlen = strlen(mname);
+
+        if(elm->flags & ATF_POINTER) {
+            memb_ptr =
+                *(const void *const *)((const char *)sptr + elm->memb_offset);
+            if(!memb_ptr) {
+                assert(tmp_def_val == 0);
+                if(elm->default_value_set) {
+                    if(elm->default_value_set(&tmp_def_val)) {
+                        ASN__ENCODE_FAILED;
+                    } else {
+                        memb_ptr = tmp_def_val;
+                        tmp_def_val_td = elm->type;
+                    }
+                } else if(elm->optional) {
+                    continue;
+                } else {
+                    /* Mandatory element is missing */
+                    ASN__ENCODE_FAILED;
+                }
+            }
+        } else {
+            memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+        }
 
 
-               if(!xcan) ASN__TEXT_INDENT(1, ilevel);
-               ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
+        if(!xcan) 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;
+        /* Print the member itself */
+        tmper = elm->type->op->xer_encoder(elm->type, memb_ptr, ilevel + 1,
+                                           flags, cb, app_key);
+        if(tmp_def_val) {
+            ASN_STRUCT_FREE(*tmp_def_val_td, tmp_def_val);
+            tmp_def_val = 0;
+        }
+        if(tmper.encoded == -1) return tmper;
+        er.encoded += tmper.encoded;
 
 
-               ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
-               er.encoded += 5 + (2 * mlen) + tmper.encoded;
-       }
+        ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
+    }
 
 
-       if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
+    if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
 
 
-       ASN__ENCODED_OK(er);
+    ASN__ENCODED_OK(er);
 cb_failed:
 cb_failed:
-       ASN__ENCODE_FAILED;
+    if(tmp_def_val) ASN_STRUCT_FREE(*tmp_def_val_td, tmp_def_val);
+    ASN__ENCODE_FAILED;
 }
 
 int
 }
 
 int
-SEQUENCE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
-               asn_app_consume_bytes_f *cb, void *app_key) {
-       int edx;
+SEQUENCE_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+    size_t edx;
        int ret;
 
        if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
        int ret;
 
        if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
@@ -937,7 +969,7 @@ SEQUENCE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
                        return -1;
 
                /* Print the member itself */
                        return -1;
 
                /* Print the member itself */
-               ret = elm->type->print_struct(elm->type, memb_ptr, ilevel + 1,
+               ret = elm->type->op->print_struct(elm->type, memb_ptr, ilevel + 1,
                        cb, app_key);
                if(ret) return ret;
        }
                        cb, app_key);
                if(ret) return ret;
        }
@@ -949,8 +981,12 @@ SEQUENCE_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 }
 
 void
 }
 
 void
-SEQUENCE_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
-       int edx;
+SEQUENCE_free(const asn_TYPE_descriptor_t *td, void *sptr,
+              enum asn_struct_free_method method) {
+    size_t edx;
+    const asn_SEQUENCE_specifics_t *specs =
+        (const asn_SEQUENCE_specifics_t *)td->specifics;
+    asn_struct_ctx_t *ctx; /* Decoder context */
 
        if(!td || !sptr)
                return;
 
        if(!td || !sptr)
                return;
@@ -970,15 +1006,28 @@ SEQUENCE_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
                }
        }
 
                }
        }
 
-       if(!contents_only) {
-               FREEMEM(sptr);
-       }
+       /* Clean parsing context */
+       ctx = (asn_struct_ctx_t *)((char *)sptr + specs->ctx_offset);
+       FREEMEM(ctx->ptr);
+
+    switch(method) {
+    case ASFM_FREE_EVERYTHING:
+        FREEMEM(sptr);
+        break;
+    case ASFM_FREE_UNDERLYING:
+        break;
+    case ASFM_FREE_UNDERLYING_AND_RESET:
+        memset(
+            sptr, 0,
+            ((const asn_SEQUENCE_specifics_t *)(td->specifics))->struct_size);
+        break;
+    }
 }
 
 int
 }
 
 int
-SEQUENCE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-               asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       int edx;
+SEQUENCE_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+                    asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+    size_t edx;
 
        if(!sptr) {
                ASN__CTFAIL(app_key, td, sptr,
 
        if(!sptr) {
                ASN__CTFAIL(app_key, td, sptr,
@@ -1008,35 +1057,33 @@ SEQUENCE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
                        memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
                }
 
                        memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
                }
 
-               if(elm->memb_constraints) {
-                       int ret = elm->memb_constraints(elm->type, memb_ptr,
+               if(elm->encoding_constraints.general_constraints) {
+                       int ret = elm->encoding_constraints.general_constraints(elm->type, memb_ptr,
                                ctfailcb, app_key);
                        if(ret) return ret;
                } else {
                                ctfailcb, app_key);
                        if(ret) return ret;
                } else {
-                       int ret = elm->type->check_constraints(elm->type,
+                       return elm->type->encoding_constraints.general_constraints(elm->type,
                                memb_ptr, ctfailcb, app_key);
                                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;
 }
 
                }
        }
 
        return 0;
 }
 
+#ifndef ASN_DISABLE_PER_SUPPORT
+
 asn_dec_rval_t
 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;
+SEQUENCE_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                     const asn_TYPE_descriptor_t *td,
+                     const asn_per_constraints_t *constraints, void **sptr,
+                     asn_per_data_t *pd) {
+    const asn_SEQUENCE_specifics_t *specs = (const 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;
        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;
+       size_t edx;
 
        (void)constraints;
 
 
        (void)constraints;
 
@@ -1051,11 +1098,11 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
        ASN_DEBUG("Decoding %s as SEQUENCE (UPER)", td->name);
 
        /* Handle extensions */
        ASN_DEBUG("Decoding %s as SEQUENCE (UPER)", td->name);
 
        /* Handle extensions */
-       if(specs->ext_before >= 0) {
+       if(specs->first_extension < 0) {
+               extpresent = 0;
+       } else {
                extpresent = per_get_few_bits(pd, 1);
                if(extpresent < 0) ASN__DECODE_STARVED;
                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 */
        }
 
        /* Prepare a place and read-in the presence bitmap */
@@ -1079,13 +1126,15 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
        /*
         * Get the sequence ROOT elements.
         */
        /*
         * Get the sequence ROOT elements.
         */
-       for(edx = 0; edx < td->elements_count; edx++) {
-               asn_TYPE_member_t *elm = &td->elements[edx];
+    for(edx = 0;
+        edx < (specs->first_extension < 0 ? td->elements_count
+                                          : (size_t)specs->first_extension);
+        edx++) {
+        asn_TYPE_member_t *elm = &td->elements[edx];
                void *memb_ptr;         /* Pointer to the member */
                void **memb_ptr2;       /* Pointer to that pointer */
 
                void *memb_ptr;         /* Pointer to the member */
                void **memb_ptr2;       /* Pointer to that pointer */
 
-               if(IN_EXTENSION_GROUP(specs, edx))
-                       continue;
+               assert(!IN_EXTENSION_GROUP(specs, edx));
 
                /* Fetch the pointer to this member */
                if(elm->flags & ATF_POINTER) {
 
                /* Fetch the pointer to this member */
                if(elm->flags & ATF_POINTER) {
@@ -1103,9 +1152,9 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                                (int)opmd.nboff, (int)opmd.nbits);
                        if(present == 0) {
                                /* This element is not present */
                                (int)opmd.nboff, (int)opmd.nbits);
                        if(present == 0) {
                                /* This element is not present */
-                               if(elm->default_value) {
+                               if(elm->default_value_set) {
                                        /* Fill-in DEFAULT */
                                        /* Fill-in DEFAULT */
-                                       if(elm->default_value(1, memb_ptr2)) {
+                                       if(elm->default_value_set(memb_ptr2)) {
                                                FREEMEM(opres);
                                                ASN__DECODE_FAILED;
                                        }
                                                FREEMEM(opres);
                                                ASN__DECODE_FAILED;
                                        }
@@ -1118,9 +1167,14 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                }
 
                /* Fetch the member from the stream */
                }
 
                /* 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);
+               ASN_DEBUG("Decoding member \"%s\" in %s", elm->name, td->name);
+
+               if(elm->flags & ATF_OPEN_TYPE) {
+                       rv = OPEN_TYPE_uper_get(opt_codec_ctx, td, st, elm, pd);
+               } else {
+                       rv = elm->type->op->uper_decoder(opt_codec_ctx, elm->type,
+                                       elm->encoding_constraints.per_constraints, memb_ptr2, pd);
+               }
                if(rv.code != RC_OK) {
                        ASN_DEBUG("Failed decode %s in %s",
                                elm->name, td->name);
                if(rv.code != RC_OK) {
                        ASN_DEBUG("Failed decode %s in %s",
                                elm->name, td->name);
@@ -1143,7 +1197,7 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                bmlength = uper_get_nslength(pd);
                if(bmlength < 0) ASN__DECODE_STARVED;
 
                bmlength = uper_get_nslength(pd);
                if(bmlength < 0) ASN__DECODE_STARVED;
 
-               ASN_DEBUG("Extensions %ld present in %s", (long)bmlength, td->name);
+               ASN_DEBUG("Extensions %" ASN_PRI_SSIZE " present in %s", bmlength, td->name);
 
                epres = (uint8_t *)MALLOC((bmlength + 15) >> 3);
                if(!epres) ASN__DECODE_STARVED;
 
                epres = (uint8_t *)MALLOC((bmlength + 15) >> 3);
                if(!epres) ASN__DECODE_STARVED;
@@ -1161,38 +1215,35 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                        td->name, (long)bmlength, *epres);
 
            /* Go over extensions and read them in */
                        td->name, (long)bmlength, *epres);
 
            /* Go over extensions and read them in */
-           for(edx = specs->ext_after + 1; 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 */
-               int present;
-
-               if(!IN_EXTENSION_GROUP(specs, edx)) {
-                       ASN_DEBUG("%d is not extension", edx);
-                       continue;
-               }
-
-               /* Fetch the pointer to this member */
-               if(elm->flags & ATF_POINTER) {
-                       memb_ptr2 = (void **)((char *)st + elm->memb_offset);
-               } else {
-                       memb_ptr = (void *)((char *)st + elm->memb_offset);
-                       memb_ptr2 = &memb_ptr;
-               }
-
-               present = per_get_few_bits(&epmd, 1);
-               if(present <= 0) {
-                       if(present < 0) break;  /* No more extensions */
-                       continue;
-               }
-
-               ASN_DEBUG("Decoding member %s in %s %p", elm->name, td->name, *memb_ptr2);
-               rv = uper_open_type_get(opt_codec_ctx, elm->type,
-                       elm->per_constraints, memb_ptr2, pd);
-               if(rv.code != RC_OK) {
-                       FREEMEM(epres);
-                       return rv;
-               }
+        for(edx = specs->first_extension; 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 */
+            int present;
+
+            /* Fetch the pointer to this member */
+            if(elm->flags & ATF_POINTER) {
+                memb_ptr2 = (void **)((char *)st + elm->memb_offset);
+            } else {
+                memb_ptr = (void *)((char *)st + elm->memb_offset);
+                memb_ptr2 = &memb_ptr;
+            }
+
+            present = per_get_few_bits(&epmd, 1);
+            if(present <= 0) {
+                if(present < 0) break; /* No more extensions */
+                continue;
+            }
+
+            ASN_DEBUG("Decoding member %s in %s %p", elm->name, td->name,
+                      *memb_ptr2);
+            rv = uper_open_type_get(opt_codec_ctx, elm->type,
+                                    elm->encoding_constraints.per_constraints,
+                                    memb_ptr2, pd);
+            if(rv.code != RC_OK) {
+                FREEMEM(epres);
+                return rv;
+            }
            }
 
                /* Skip over overflow extensions which aren't present
            }
 
                /* Skip over overflow extensions which aren't present
@@ -1207,6 +1258,8 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                                        FREEMEM(epres);
                                        ASN__DECODE_STARVED;
                                }
                                        FREEMEM(epres);
                                        ASN__DECODE_STARVED;
                                }
+                ASN_DEBUG("Skipped overflow extension");
+                continue;
                        }
                        break;
                }
                        }
                        break;
                }
@@ -1214,28 +1267,33 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                FREEMEM(epres);
        }
 
                FREEMEM(epres);
        }
 
-       /* Fill DEFAULT members in extensions */
-       for(edx = specs->roms_count; edx < specs->roms_count
-                       + specs->aoms_count; edx++) {
-               asn_TYPE_member_t *elm = &td->elements[edx];
-               void **memb_ptr2;       /* Pointer to member pointer */
-
-               if(!elm->default_value) continue;
-
-               /* Fetch the pointer to this member */
-               if(elm->flags & ATF_POINTER) {
-                       memb_ptr2 = (void **)((char *)st
-                                       + elm->memb_offset);
-                       if(*memb_ptr2) continue;
-               } else {
-                       continue;       /* Extensions are all optionals */
-               }
-
-               /* Set default value */
-               if(elm->default_value(1, memb_ptr2)) {
-                       ASN__DECODE_FAILED;
-               }
-       }
+    if(specs->first_extension >= 0) {
+        unsigned i;
+        /* Fill DEFAULT members in extensions */
+        for(i = specs->roms_count; i < specs->roms_count + specs->aoms_count;
+            i++) {
+            asn_TYPE_member_t *elm;
+            void **memb_ptr2; /* Pointer to member pointer */
+
+            edx = specs->oms[i];
+            elm = &td->elements[edx];
+
+            if(!elm->default_value_set) continue;
+
+            /* Fetch the pointer to this member */
+            if(elm->flags & ATF_POINTER) {
+                memb_ptr2 = (void **)((char *)st + elm->memb_offset);
+                if(*memb_ptr2) continue;
+            } else {
+                continue; /* Extensions are all optionals */
+            }
+
+            /* Set default value */
+            if(elm->default_value_set(memb_ptr2)) {
+                ASN__DECODE_FAILED;
+            }
+        }
+    }
 
        rv.consumed = 0;
        rv.code = RC_OK;
 
        rv.consumed = 0;
        rv.code = RC_OK;
@@ -1243,66 +1301,66 @@ SEQUENCE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 }
 
 static int
 }
 
 static int
-SEQUENCE_handle_extensions(asn_TYPE_descriptor_t *td, void *sptr,
-               asn_per_outp_t *po1, asn_per_outp_t *po2) {
-       asn_SEQUENCE_specifics_t *specs
-               = (asn_SEQUENCE_specifics_t *)td->specifics;
-       int exts_present = 0;
-       int exts_count = 0;
-       int edx;
-
-       if(specs->ext_before < 0)
-               return 0;
-
-       /* Find out which extensions are present */
-       for(edx = specs->ext_after + 1; 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 */
-               int present;
-
-               if(!IN_EXTENSION_GROUP(specs, edx)) {
-                       ASN_DEBUG("%s (@%d) is not extension", elm->type->name, edx);
-                       continue;
-               }
-
-               /* Fetch the pointer to this member */
-               if(elm->flags & ATF_POINTER) {
-                       memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
-                       present = (*memb_ptr2 != 0);
-               } else {
-                       memb_ptr = (void *)((char *)sptr + elm->memb_offset);
-                       memb_ptr2 = &memb_ptr;
+SEQUENCE__handle_extensions(const asn_TYPE_descriptor_t *td, const void *sptr,
+                            asn_per_outp_t *po1, asn_per_outp_t *po2) {
+    const asn_SEQUENCE_specifics_t *specs =
+        (const asn_SEQUENCE_specifics_t *)td->specifics;
+    int exts_present = 0;
+    int exts_count = 0;
+    size_t edx;
+
+    if(specs->first_extension < 0) {
+        return 0;
+    }
+
+    /* Find out which extensions are present */
+    for(edx = specs->first_extension; edx < td->elements_count; edx++) {
+        asn_TYPE_member_t *elm = &td->elements[edx];
+        const void *memb_ptr;         /* Pointer to the member */
+        const void *const *memb_ptr2; /* Pointer to that pointer */
+        int present;
+
+        /* Fetch the pointer to this member */
+        if(elm->flags & ATF_POINTER) {
+            memb_ptr2 =
+                (const void *const *)((const char *)sptr + elm->memb_offset);
+            present = (*memb_ptr2 != 0);
+        } else {
+            memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+            memb_ptr2 = &memb_ptr;
                        present = 1;
                }
 
                        present = 1;
                }
 
-               ASN_DEBUG("checking %s (@%d) present => %d",
-                       elm->type->name, edx, present);
-               exts_count++;
-               exts_present += present;
-
-               /* Encode as presence marker */
-               if(po1 && per_put_few_bits(po1, present, 1))
-                       return -1;
-               /* Encode as open type field */
-               if(po2 && present && uper_open_type_put(elm->type,
-                               elm->per_constraints, *memb_ptr2, po2))
-                       return -1;
-
-       }
-
-       return exts_present ? exts_count : 0;
+        ASN_DEBUG("checking %s:%s (@%" ASN_PRI_SIZE ") present => %d", elm->name,
+                  elm->type->name, edx, present);
+        exts_count++;
+        exts_present += present;
+
+        /* Encode as presence marker */
+        if(po1 && per_put_few_bits(po1, present, 1)) {
+            return -1;
+        }
+        /* Encode as open type field */
+        if(po2 && present
+           && uper_open_type_put(elm->type,
+                                 elm->encoding_constraints.per_constraints,
+                                 *memb_ptr2, po2))
+            return -1;
+    }
+
+    return exts_present ? exts_count : 0;
 }
 
 asn_enc_rval_t
 }
 
 asn_enc_rval_t
-SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td,
-       asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-       asn_SEQUENCE_specifics_t *specs
-               = (asn_SEQUENCE_specifics_t *)td->specifics;
+SEQUENCE_encode_uper(const asn_TYPE_descriptor_t *td,
+                     const asn_per_constraints_t *constraints, const void *sptr,
+                     asn_per_outp_t *po) {
+    const asn_SEQUENCE_specifics_t *specs
+               = (const asn_SEQUENCE_specifics_t *)td->specifics;
        asn_enc_rval_t er;
        int n_extensions;
        asn_enc_rval_t er;
        int n_extensions;
-       int edx;
-       int i;
+       size_t edx;
+       size_t i;
 
        (void)constraints;
 
 
        (void)constraints;
 
@@ -1313,46 +1371,49 @@ SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td,
 
        ASN_DEBUG("Encoding %s as SEQUENCE (UPER)", td->name);
 
 
        ASN_DEBUG("Encoding %s as SEQUENCE (UPER)", td->name);
 
-
        /*
         * X.691#18.1 Whether structure is extensible
         * and whether to encode extensions
         */
        /*
         * X.691#18.1 Whether structure is extensible
         * and whether to encode extensions
         */
-       if(specs->ext_before >= 0) {
-               n_extensions = SEQUENCE_handle_extensions(td, sptr, 0, 0);
-               per_put_few_bits(po, n_extensions ? 1 : 0, 1);
-       } else {
-               n_extensions = 0;       /* There are no extensions to encode */
-       }
+    if(specs->first_extension < 0) {
+        n_extensions = 0; /* There are no extensions to encode */
+    } else {
+        n_extensions = SEQUENCE__handle_extensions(td, sptr, 0, 0);
+        if(n_extensions < 0) ASN__ENCODE_FAILED;
+        if(per_put_few_bits(po, n_extensions ? 1 : 0, 1)) {
+            ASN__ENCODE_FAILED;
+        }
+    }
 
        /* Encode a presence bitmap */
        for(i = 0; i < specs->roms_count; i++) {
                asn_TYPE_member_t *elm;
 
        /* Encode a presence bitmap */
        for(i = 0; i < specs->roms_count; i++) {
                asn_TYPE_member_t *elm;
-               void *memb_ptr;         /* Pointer to the member */
-               void **memb_ptr2;       /* Pointer to that pointer */
-               int present;
+               const void *memb_ptr;           /* Pointer to the member */
+        const void *const *memb_ptr2; /* Pointer to that pointer */
+        int present;
 
                edx = specs->oms[i];
                elm = &td->elements[edx];
 
                /* Fetch the pointer to this member */
                if(elm->flags & ATF_POINTER) {
 
                edx = specs->oms[i];
                elm = &td->elements[edx];
 
                /* Fetch the pointer to this member */
                if(elm->flags & ATF_POINTER) {
-                       memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
-                       present = (*memb_ptr2 != 0);
+            memb_ptr2 =
+                (const void *const *)((const char *)sptr + elm->memb_offset);
+            present = (*memb_ptr2 != 0);
                } else {
                } else {
-                       memb_ptr = (void *)((char *)sptr + elm->memb_offset);
-                       memb_ptr2 = &memb_ptr;
+            memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+            memb_ptr2 = &memb_ptr;
                        present = 1;
                }
 
                /* Eliminate default values */
                        present = 1;
                }
 
                /* Eliminate default values */
-               if(present && elm->default_value
-               && elm->default_value(0, memb_ptr2) == 1)
-                       present = 0;
+        if(present && elm->default_value_cmp
+           && elm->default_value_cmp(*memb_ptr2) == 0)
+            present = 0;
 
                ASN_DEBUG("Element %s %s %s->%s is %s",
                        elm->flags & ATF_POINTER ? "ptr" : "inline",
 
                ASN_DEBUG("Element %s %s %s->%s is %s",
                        elm->flags & ATF_POINTER ? "ptr" : "inline",
-                       elm->default_value ? "def" : "wtv",
+                       elm->default_value_cmp ? "def" : "wtv",
                        td->name, elm->name, present ? "present" : "absent");
                if(per_put_few_bits(po, present, 1))
                        ASN__ENCODE_FAILED;
                        td->name, elm->name, present ? "present" : "absent");
                if(per_put_few_bits(po, present, 1))
                        ASN__ENCODE_FAILED;
@@ -1361,24 +1422,24 @@ SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td,
        /*
         * Encode the sequence ROOT elements.
         */
        /*
         * Encode the sequence ROOT elements.
         */
-       ASN_DEBUG("ext_after = %d, ec = %d, eb = %d", specs->ext_after, td->elements_count, specs->ext_before);
-       for(edx = 0; edx < ((specs->ext_after < 0)
-               ? td->elements_count : specs->ext_before - 1); edx++) {
-
+    ASN_DEBUG("first_extension = %d, elements = %d", specs->first_extension,
+              td->elements_count);
+       for(edx = 0;
+               edx < ((specs->first_extension < 0) ? td->elements_count
+                                            : (size_t)specs->first_extension);
+               edx++) {
                asn_TYPE_member_t *elm = &td->elements[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;
+               const void *memb_ptr;         /* Pointer to the member */
+               const void *const *memb_ptr2; /* Pointer to that pointer */
 
                ASN_DEBUG("About to encode %s", elm->type->name);
 
                /* Fetch the pointer to this member */
                if(elm->flags & ATF_POINTER) {
 
                ASN_DEBUG("About to encode %s", elm->type->name);
 
                /* Fetch the pointer to this member */
                if(elm->flags & ATF_POINTER) {
-                       memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
-                       if(!*memb_ptr2) {
-                               ASN_DEBUG("Element %s %d not present",
+            memb_ptr2 =
+                (const void *const *)((const char *)sptr + elm->memb_offset);
+            if(!*memb_ptr2) {
+                               ASN_DEBUG("Element %s %" ASN_PRI_SIZE " not present",
                                        elm->name, edx);
                                if(elm->optional)
                                        continue;
                                        elm->name, edx);
                                if(elm->optional)
                                        continue;
@@ -1386,25 +1447,25 @@ SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td,
                                ASN__ENCODE_FAILED;
                        }
                } else {
                                ASN__ENCODE_FAILED;
                        }
                } else {
-                       memb_ptr = (void *)((char *)sptr + elm->memb_offset);
-                       memb_ptr2 = &memb_ptr;
+            memb_ptr = (const void *)((const char *)sptr + elm->memb_offset);
+            memb_ptr2 = &memb_ptr;
                }
 
                /* Eliminate default values */
                }
 
                /* Eliminate default values */
-               if(elm->default_value && elm->default_value(0, memb_ptr2) == 1)
+               if(elm->default_value_cmp && elm->default_value_cmp(*memb_ptr2) == 0)
                        continue;
 
                        continue;
 
-               ASN_DEBUG("Encoding %s->%s", td->name, elm->name);
-               er = elm->type->uper_encoder(elm->type, elm->per_constraints,
-                       *memb_ptr2, po);
-               if(er.encoded == -1)
-                       return er;
-       }
+        ASN_DEBUG("Encoding %s->%s:%s", td->name, elm->name, elm->type->name);
+        er = elm->type->op->uper_encoder(
+            elm->type, elm->encoding_constraints.per_constraints, *memb_ptr2,
+            po);
+        if(er.encoded == -1) return er;
+    }
 
        /* No extensions to encode */
        if(!n_extensions) ASN__ENCODED_OK(er);
 
 
        /* No extensions to encode */
        if(!n_extensions) ASN__ENCODED_OK(er);
 
-       ASN_DEBUG("Length of %d bit-map", n_extensions);
+       ASN_DEBUG("Length of extensions %d bit-map", n_extensions);
        /* #18.8. Write down the presence bit-map length. */
        if(uper_put_nslength(po, n_extensions))
                ASN__ENCODE_FAILED;
        /* #18.8. Write down the presence bit-map length. */
        if(uper_put_nslength(po, n_extensions))
                ASN__ENCODE_FAILED;
@@ -1412,14 +1473,154 @@ SEQUENCE_encode_uper(asn_TYPE_descriptor_t *td,
        ASN_DEBUG("Bit-map of %d elements", n_extensions);
        /* #18.7. Encoding the extensions presence bit-map. */
        /* TODO: act upon NOTE in #18.7 for canonical PER */
        ASN_DEBUG("Bit-map of %d elements", n_extensions);
        /* #18.7. Encoding the extensions presence bit-map. */
        /* TODO: act upon NOTE in #18.7 for canonical PER */
-       if(SEQUENCE_handle_extensions(td, sptr, po, 0) != n_extensions)
+       if(SEQUENCE__handle_extensions(td, sptr, po, 0) != n_extensions)
                ASN__ENCODE_FAILED;
 
        ASN_DEBUG("Writing %d extensions", n_extensions);
        /* #18.9. Encode extensions as open type fields. */
                ASN__ENCODE_FAILED;
 
        ASN_DEBUG("Writing %d extensions", n_extensions);
        /* #18.9. Encode extensions as open type fields. */
-       if(SEQUENCE_handle_extensions(td, sptr, 0, po) != n_extensions)
+       if(SEQUENCE__handle_extensions(td, sptr, 0, po) != n_extensions)
                ASN__ENCODE_FAILED;
 
        ASN__ENCODED_OK(er);
 }
 
                ASN__ENCODE_FAILED;
 
        ASN__ENCODED_OK(er);
 }
 
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
+int
+SEQUENCE_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
+                 const void *bptr) {
+    size_t edx;
+
+       for(edx = 0; edx < td->elements_count; edx++) {
+               asn_TYPE_member_t *elm = &td->elements[edx];
+               const void *amemb;
+               const void *bmemb;
+        int ret;
+
+               if(elm->flags & ATF_POINTER) {
+            amemb =
+                *(const void *const *)((const char *)aptr + elm->memb_offset);
+            bmemb =
+                *(const void *const *)((const char *)bptr + elm->memb_offset);
+            if(!amemb) {
+                if(!bmemb) continue;
+                if(elm->default_value_cmp
+                   && elm->default_value_cmp(bmemb) == 0) {
+                    /* A is absent, but B is present and equal to DEFAULT */
+                    continue;
+                }
+                return -1;
+            } else if(!bmemb) {
+                if(elm->default_value_cmp
+                   && elm->default_value_cmp(amemb) == 0) {
+                    /* B is absent, but A is present and equal to DEFAULT */
+                    continue;
+                }
+                return 1;
+            }
+               } else {
+            amemb = (const void *)((const char *)aptr + elm->memb_offset);
+            bmemb = (const void *)((const char *)bptr + elm->memb_offset);
+               }
+
+        ret = elm->type->op->compare_struct(elm->type, amemb, bmemb);
+        if(ret != 0) return ret;
+    }
+
+    return 0;
+}
+
+asn_TYPE_operation_t asn_OP_SEQUENCE = {
+       SEQUENCE_free,
+       SEQUENCE_print,
+       SEQUENCE_compare,
+       SEQUENCE_decode_ber,
+       SEQUENCE_encode_der,
+       SEQUENCE_decode_xer,
+       SEQUENCE_encode_xer,
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       SEQUENCE_decode_oer,
+       SEQUENCE_encode_oer,
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
+       SEQUENCE_decode_uper,
+       SEQUENCE_encode_uper,
+#endif /* ASN_DISABLE_PER_SUPPORT */
+       SEQUENCE_random_fill,
+       0       /* Use generic outmost tag fetcher */
+};
+
+
+asn_random_fill_result_t
+SEQUENCE_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                   const asn_encoding_constraints_t *constr,
+                   size_t max_length) {
+    const asn_SEQUENCE_specifics_t *specs =
+        (const asn_SEQUENCE_specifics_t *)td->specifics;
+    asn_random_fill_result_t result_ok = {ARFILL_OK, 0};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    void *st = *sptr;
+    size_t edx;
+
+    if(max_length == 0) return result_skipped;
+
+    (void)constr;
+
+    if(st == NULL) {
+        st = CALLOC(1, specs->struct_size);
+        if(st == NULL) {
+            return result_failed;
+        }
+    }
+
+    for(edx = 0; edx < td->elements_count; edx++) {
+        const asn_TYPE_member_t *elm = &td->elements[edx];
+        void *memb_ptr;   /* Pointer to the member */
+        void **memb_ptr2; /* Pointer to that pointer */
+        asn_random_fill_result_t tmpres;
+
+        if(elm->optional && asn_random_between(0, 4) == 2) {
+            /* Sometimes decide not to fill the optional value */
+            continue;
+        }
+
+        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;
+        }
+
+        tmpres = elm->type->op->random_fill(
+            elm->type, memb_ptr2, &elm->encoding_constraints,
+            max_length > result_ok.length ? max_length - result_ok.length : 0);
+        switch(tmpres.code) {
+        case ARFILL_OK:
+            result_ok.length += tmpres.length;
+            continue;
+        case ARFILL_SKIPPED:
+            assert(!(elm->flags & ATF_POINTER) || *memb_ptr2 == NULL);
+            continue;
+        case ARFILL_FAILED:
+            if(st == *sptr) {
+                ASN_STRUCT_RESET(*td, st);
+            } else {
+                ASN_STRUCT_FREE(*td, st);
+            }
+            return tmpres;
+        }
+    }
+
+    *sptr = st;
+
+    return result_ok;
+}
+
index 8a08ee8aa16a0dc5a419d3753c690b73511198de..2fdc38f2a5cbf2f89208e39586a0b7a23328ea5d 100644 (file)
  * The DER encoder of the SEQUENCE OF type.
  */
 asn_enc_rval_t
  * The DER encoder of the SEQUENCE OF type.
  */
 asn_enc_rval_t
-SEQUENCE_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
-       int tag_mode, ber_tlv_tag_t tag,
-       asn_app_consume_bytes_f *cb, void *app_key) {
-       asn_TYPE_member_t *elm = td->elements;
-       asn_anonymous_sequence_ *list = _A_SEQUENCE_FROM_VOID(ptr);
+SEQUENCE_OF_encode_der(const asn_TYPE_descriptor_t *td, const void *ptr,
+                       int tag_mode, ber_tlv_tag_t tag,
+                       asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_TYPE_member_t *elm = td->elements;
+       const asn_anonymous_sequence_ *list = _A_CSEQUENCE_FROM_VOID(ptr);
        size_t computed_size = 0;
        ssize_t encoding_size = 0;
        asn_enc_rval_t erval;
        size_t computed_size = 0;
        ssize_t encoding_size = 0;
        asn_enc_rval_t erval;
@@ -29,7 +29,7 @@ SEQUENCE_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
        for(edx = 0; edx < list->count; edx++) {
                void *memb_ptr = list->array[edx];
                if(!memb_ptr) continue;
        for(edx = 0; edx < list->count; edx++) {
                void *memb_ptr = list->array[edx];
                if(!memb_ptr) continue;
-               erval = elm->type->der_encoder(elm->type, memb_ptr,
+               erval = elm->type->op->der_encoder(elm->type, memb_ptr,
                        0, elm->tag,
                        0, 0);
                if(erval.encoded == -1)
                        0, elm->tag,
                        0, 0);
                if(erval.encoded == -1)
@@ -63,7 +63,7 @@ SEQUENCE_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
        for(edx = 0; edx < list->count; edx++) {
                void *memb_ptr = list->array[edx];
                if(!memb_ptr) continue;
        for(edx = 0; edx < list->count; edx++) {
                void *memb_ptr = list->array[edx];
                if(!memb_ptr) continue;
-               erval = elm->type->der_encoder(elm->type, memb_ptr,
+               erval = elm->type->op->der_encoder(elm->type, memb_ptr,
                        0, elm->tag,
                        cb, app_key);
                if(erval.encoded == -1)
                        0, elm->tag,
                        cb, app_key);
                if(erval.encoded == -1)
@@ -88,121 +88,197 @@ SEQUENCE_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
 }
 
 asn_enc_rval_t
 }
 
 asn_enc_rval_t
-SEQUENCE_OF_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;
-        asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
-       asn_TYPE_member_t *elm = td->elements;
-       asn_anonymous_sequence_ *list = _A_SEQUENCE_FROM_VOID(sptr);
-       const char *mname = specs->as_XMLValueList
-               ? 0 : ((*elm->name) ? elm->name : elm->type->xml_tag);
-       unsigned int mlen = mname ? strlen(mname) : 0;
-       int xcan = (flags & XER_F_CANONICAL);
-       int i;
+SEQUENCE_OF_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
+                       int ilevel, enum xer_encoder_flags_e flags,
+                       asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_enc_rval_t er;
+    const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;
+    const asn_TYPE_member_t *elm = td->elements;
+    const asn_anonymous_sequence_ *list = _A_CSEQUENCE_FROM_VOID(sptr);
+    const char *mname = specs->as_XMLValueList
+                            ? 0
+                            : ((*elm->name) ? elm->name : elm->type->xml_tag);
+    size_t mlen = mname ? strlen(mname) : 0;
+    int xcan = (flags & XER_F_CANONICAL);
+    int i;
 
 
-       if(!sptr) ASN__ENCODE_FAILED;
+    if(!sptr) ASN__ENCODE_FAILED;
 
 
-       er.encoded = 0;
+    er.encoded = 0;
 
 
-       for(i = 0; i < list->count; i++) {
-               asn_enc_rval_t tmper;
-               void *memb_ptr = list->array[i];
-               if(!memb_ptr) continue;
+    for(i = 0; i < list->count; i++) {
+        asn_enc_rval_t tmper;
+        void *memb_ptr = list->array[i];
+        if(!memb_ptr) continue;
 
 
-               if(mname) {
-                       if(!xcan) ASN__TEXT_INDENT(1, ilevel);
-                       ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
-               }
-
-               tmper = elm->type->xer_encoder(elm->type, memb_ptr,
-                               ilevel + 1, flags, cb, app_key);
-               if(tmper.encoded == -1) return tmper;
-                if(tmper.encoded == 0 && specs->as_XMLValueList) {
-                        const char *name = elm->type->xml_tag;
-                       size_t len = strlen(name);
-                       if(!xcan) ASN__TEXT_INDENT(1, ilevel + 1);
-                       ASN__CALLBACK3("<", 1, name, len, "/>", 2);
-                }
-
-               if(mname) {
-                       ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
-                       er.encoded += 5;
-               }
-
-               er.encoded += (2 * mlen) + tmper.encoded;
-       }
+        if(mname) {
+            if(!xcan) ASN__TEXT_INDENT(1, ilevel);
+            ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
+        }
 
 
-       if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
+        tmper = elm->type->op->xer_encoder(elm->type, memb_ptr, ilevel + 1,
+                                           flags, cb, app_key);
+        if(tmper.encoded == -1) return tmper;
+        er.encoded += tmper.encoded;
+        if(tmper.encoded == 0 && specs->as_XMLValueList) {
+            const char *name = elm->type->xml_tag;
+            size_t len = strlen(name);
+            if(!xcan) ASN__TEXT_INDENT(1, ilevel + 1);
+            ASN__CALLBACK3("<", 1, name, len, "/>", 2);
+        }
 
 
-       ASN__ENCODED_OK(er);
+        if(mname) {
+            ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
+        }
+    }
+
+    if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
+
+    ASN__ENCODED_OK(er);
 cb_failed:
 cb_failed:
-       ASN__ENCODE_FAILED;
+    ASN__ENCODE_FAILED;
 }
 
 }
 
+#ifndef ASN_DISABLE_PER_SUPPORT
+
 asn_enc_rval_t
 asn_enc_rval_t
-SEQUENCE_OF_encode_uper(asn_TYPE_descriptor_t *td,
-       asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-       asn_anonymous_sequence_ *list;
-       asn_per_constraint_t *ct;
+SEQUENCE_OF_encode_uper(const asn_TYPE_descriptor_t *td,
+                        const asn_per_constraints_t *constraints,
+                        const void *sptr, asn_per_outp_t *po) {
+    const asn_anonymous_sequence_ *list;
+       const asn_per_constraint_t *ct;
        asn_enc_rval_t er;
        asn_enc_rval_t er;
-       asn_TYPE_member_t *elm = td->elements;
-       int seq;
+       const asn_TYPE_member_t *elm = td->elements;
+       size_t encoded_edx;
 
        if(!sptr) ASN__ENCODE_FAILED;
 
        if(!sptr) ASN__ENCODE_FAILED;
-       list = _A_SEQUENCE_FROM_VOID(sptr);
+    list = _A_CSEQUENCE_FROM_VOID(sptr);
 
 
-       er.encoded = 0;
+    er.encoded = 0;
 
        ASN_DEBUG("Encoding %s as SEQUENCE OF (%d)", td->name, list->count);
 
 
        ASN_DEBUG("Encoding %s as SEQUENCE OF (%d)", td->name, list->count);
 
-       if(constraints) ct = &constraints->size;
-       else if(td->per_constraints) ct = &td->per_constraints->size;
-       else ct = 0;
-
-       /* If extensible constraint, check if size is in root */
-       if(ct) {
-               int not_in_root = (list->count < ct->lower_bound
-                               || list->count > ct->upper_bound);
-               ASN_DEBUG("lb %ld ub %ld %s",
-                       ct->lower_bound, ct->upper_bound,
-                       ct->flags & APC_EXTENSIBLE ? "ext" : "fix");
-               if(ct->flags & APC_EXTENSIBLE) {
-                       /* Declare whether size is in extension root */
-                       if(per_put_few_bits(po, not_in_root, 1))
-                               ASN__ENCODE_FAILED;
-                       if(not_in_root) ct = 0;
-               } else if(not_in_root && ct->effective_bits >= 0)
-                       ASN__ENCODE_FAILED;
-       }
+    if(constraints) ct = &constraints->size;
+    else if(td->encoding_constraints.per_constraints)
+        ct = &td->encoding_constraints.per_constraints->size;
+    else ct = 0;
 
 
-       if(ct && ct->effective_bits >= 0) {
-               /* X.691, #19.5: No length determinant */
-               if(per_put_few_bits(po, list->count - ct->lower_bound,
-                               ct->effective_bits))
-                       ASN__ENCODE_FAILED;
-       }
+    /* If extensible constraint, check if size is in root */
+    if(ct) {
+        int not_in_root =
+            (list->count < ct->lower_bound || list->count > ct->upper_bound);
+        ASN_DEBUG("lb %ld ub %ld %s", ct->lower_bound, ct->upper_bound,
+                  ct->flags & APC_EXTENSIBLE ? "ext" : "fix");
+        if(ct->flags & APC_EXTENSIBLE) {
+            /* Declare whether size is in extension root */
+            if(per_put_few_bits(po, not_in_root, 1)) ASN__ENCODE_FAILED;
+            if(not_in_root) ct = 0;
+        } else if(not_in_root && ct->effective_bits >= 0) {
+            ASN__ENCODE_FAILED;
+        }
 
 
-       for(seq = -1; seq < list->count;) {
-               ssize_t mayEncode;
-               if(seq < 0) seq = 0;
-               if(ct && ct->effective_bits >= 0) {
-                       mayEncode = list->count;
-               } else {
-                       mayEncode = uper_put_length(po, list->count - seq);
-                       if(mayEncode < 0) ASN__ENCODE_FAILED;
-               }
-
-               while(mayEncode--) {
-                       void *memb_ptr = list->array[seq++];
-                       if(!memb_ptr) ASN__ENCODE_FAILED;
-                       er = elm->type->uper_encoder(elm->type,
-                               elm->per_constraints, memb_ptr, po);
-                       if(er.encoded == -1)
-                               ASN__ENCODE_FAILED;
-               }
-       }
+    }
+
+    if(ct && ct->effective_bits >= 0) {
+        /* X.691, #19.5: No length determinant */
+        if(per_put_few_bits(po, list->count - ct->lower_bound,
+                            ct->effective_bits))
+            ASN__ENCODE_FAILED;
+    } else if(list->count == 0) {
+        /* When the list is empty add only the length determinant
+         * X.691, #20.6 and #11.9.4.1
+         */
+        if (uper_put_length(po, 0, 0)) {
+            ASN__ENCODE_FAILED;
+        }
+        ASN__ENCODED_OK(er);
+    }
+
+    for(encoded_edx = 0; (ssize_t)encoded_edx < list->count;) {
+        ssize_t may_encode;
+        size_t edx;
+        int need_eom = 0;
+
+        if(ct && ct->effective_bits >= 0) {
+            may_encode = list->count;
+        } else {
+            may_encode =
+                uper_put_length(po, list->count - encoded_edx, &need_eom);
+            if(may_encode < 0) ASN__ENCODE_FAILED;
+        }
+
+        for(edx = encoded_edx; edx < encoded_edx + may_encode; edx++) {
+            void *memb_ptr = list->array[edx];
+            if(!memb_ptr) ASN__ENCODE_FAILED;
+            er = elm->type->op->uper_encoder(
+                elm->type, elm->encoding_constraints.per_constraints, memb_ptr,
+                po);
+            if(er.encoded == -1) ASN__ENCODE_FAILED;
+        }
+
+        if(need_eom && uper_put_length(po, 0, 0))
+            ASN__ENCODE_FAILED; /* End of Message length */
+
+        encoded_edx += may_encode;
+    }
 
        ASN__ENCODED_OK(er);
 }
 
 
        ASN__ENCODED_OK(er);
 }
 
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
+int
+SEQUENCE_OF_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
+               const void *bptr) {
+    const asn_anonymous_sequence_ *a = _A_CSEQUENCE_FROM_VOID(aptr);
+    const asn_anonymous_sequence_ *b = _A_CSEQUENCE_FROM_VOID(bptr);
+    ssize_t idx;
+
+    if(a && b) {
+        ssize_t common_length = (a->count < b->count ? a->count : b->count);
+        for(idx = 0; idx < common_length; idx++) {
+            int ret = td->elements->type->op->compare_struct(
+                td->elements->type, a->array[idx], b->array[idx]);
+            if(ret) return ret;
+        }
+
+        if(idx < b->count) /* more elements in b */
+            return -1;    /* a is shorter, so put it first */
+        if(idx < a->count) return 1;
+
+    } else if(!a) {
+        return -1;
+    } else if(!b) {
+        return 1;
+    }
+
+    return 0;
+}
+
+
+asn_TYPE_operation_t asn_OP_SEQUENCE_OF = {
+       SEQUENCE_OF_free,
+       SEQUENCE_OF_print,
+       SEQUENCE_OF_compare,
+       SEQUENCE_OF_decode_ber,
+       SEQUENCE_OF_encode_der,
+       SEQUENCE_OF_decode_xer,
+       SEQUENCE_OF_encode_xer,
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       SEQUENCE_OF_decode_oer, /* Same as SET OF decoder. */
+       SEQUENCE_OF_encode_oer, /* Same as SET OF encoder */
+#endif  /* ASN_DISABLE_OER_SUPPORT */
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
+       SEQUENCE_OF_decode_uper, /* Same as SET OF decoder */
+       SEQUENCE_OF_encode_uper,
+#endif /* ASN_DISABLE_PER_SUPPORT */
+       SEQUENCE_OF_random_fill,
+       0       /* Use generic outmost tag fetcher */
+};
+
diff --git a/libs/smux/constr_SEQUENCE_oer.c b/libs/smux/constr_SEQUENCE_oer.c
new file mode 100644 (file)
index 0000000..4f290a1
--- /dev/null
@@ -0,0 +1,561 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_DISABLE_OER_SUPPORT
+
+#include <asn_internal.h>
+#include <constr_SEQUENCE.h>
+#include <OPEN_TYPE.h>
+#include <errno.h>
+
+/*
+ * 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;                         \
+        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)
+
+/*
+ * Check whether we are inside the extensions group.
+ */
+#define IN_EXTENSION_GROUP(specs, memb_idx) \
+    ((specs)->first_extension >= 0          \
+     && (unsigned)(specs)->first_extension <= (memb_idx))
+
+#define IN_ROOT_GROUP_PRED(edx)                            \
+    edx < (specs->first_extension < 0 ? td->elements_count \
+                                      : (size_t)specs->first_extension)
+
+#define FOR_IN_ROOT_GROUP(edx) for(edx = 0; IN_ROOT_GROUP_PRED(edx); edx++)
+
+/*
+ * Return a standardized complex structure.
+ */
+#undef  RETURN
+#define RETURN(_code)   do {                    \
+                rval.code = _code;              \
+                rval.consumed = consumed_myself;\
+                return rval;                    \
+        } while(0)
+
+/*
+ * Return pointer to a member.
+ */
+static void **
+element_ptrptr(void *struct_ptr, asn_TYPE_member_t *elm, void **tmp_save_ptr) {
+    if(elm->flags & ATF_POINTER) {
+        /* Member is a pointer to another structure */
+        return (void **)((char *)struct_ptr + elm->memb_offset);
+    } else {
+        assert(tmp_save_ptr);
+        *tmp_save_ptr = (void *)((char *)struct_ptr + elm->memb_offset);
+        return tmp_save_ptr;
+    }
+}
+
+static const void *
+element_ptr(const void *struct_ptr, const asn_TYPE_member_t *elm) {
+    if(elm->flags & ATF_POINTER) {
+        /* Member is a pointer to another structure */
+        return *(const void *const *)((const char *)struct_ptr
+                                      + elm->memb_offset);
+    } else {
+        return (const void *)((const char *)struct_ptr + elm->memb_offset);
+    }
+}
+
+asn_dec_rval_t
+SEQUENCE_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
+                    const asn_TYPE_descriptor_t *td,
+                    const asn_oer_constraints_t *constraints, void **struct_ptr,
+                    const void *ptr, size_t size) {
+    const asn_SEQUENCE_specifics_t *specs =
+        (const asn_SEQUENCE_specifics_t *)td->specifics;
+    asn_dec_rval_t rval = {RC_OK, 0};
+    void *st = *struct_ptr; /* Target structure */
+    asn_struct_ctx_t *ctx; /* Decoder context */
+    size_t consumed_myself = 0; /* Consumed bytes from ptr. */
+
+    (void)constraints;
+
+    if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
+        ASN__DECODE_FAILED;
+
+    /*
+     * 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: {
+        /*
+         * Fetch preamble.
+         */
+        asn_bit_data_t *preamble;
+        int has_extensions_bit = (specs->first_extension >= 0);
+        size_t preamble_bits = (has_extensions_bit + specs->roms_count);
+        size_t preamble_bytes = ((7 + preamble_bits) >> 3);
+
+        ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 0", td->name);
+
+        ASN_DEBUG(
+            "Expecting preamble bits %" ASN_PRI_SIZE " for %s (including %d extension bits)",
+            preamble_bits, td->name, has_extensions_bit);
+
+        if(preamble_bytes > size) {
+            ASN__DECODE_STARVED;
+        }
+
+        preamble = asn_bit_data_new_contiguous(ptr, preamble_bits);
+        if(!preamble) {
+            RETURN(RC_FAIL);
+        }
+        preamble->nboff = has_extensions_bit;
+        ctx->ptr = preamble;
+        ADVANCE(preamble_bytes);
+    }
+        NEXT_PHASE(ctx);
+        /* FALL THROUGH */
+    case 1: {
+        /* Decode components of the extension root */
+        asn_bit_data_t *preamble = ctx->ptr;
+        size_t edx;
+
+        ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 1 (Root)", td->name);
+
+        assert(preamble);
+
+        for(edx = (ctx->step >> 1); IN_ROOT_GROUP_PRED(edx);
+            edx++, ctx->step = (ctx->step & ~1) + 2) {
+            asn_TYPE_member_t *elm = &td->elements[edx];
+
+            ASN_DEBUG("Decoding %s->%s", td->name, elm->name);
+
+            assert(!IN_EXTENSION_GROUP(specs, edx));
+
+            if(ctx->step & 1) {
+                goto microphase2_decode_continues;
+            }
+
+
+            if(elm->optional) {
+                int32_t present = asn_get_few_bits(preamble, 1);
+                if(present < 0) {
+                    ASN_DEBUG("Presence map ended prematurely: %d", present);
+                    RETURN(RC_FAIL);
+                } else if(present == 0) {
+                    if(elm->default_value_set) {
+                        /* Fill-in DEFAULT */
+                        void *tmp;
+                        if(elm->default_value_set(
+                               element_ptrptr(st, elm, &tmp))) {
+                            RETURN(RC_FAIL);
+                        }
+                    }
+                    /* The member is not present. */
+                    continue;
+                }
+                /* Present OPTIONAL or DEFAULT component. */
+            }
+
+            /*
+             * MICROPHASE 2: Invoke the member-specific decoder.
+             */
+            ctx->step |= 1; /* Confirm entering next microphase */
+        microphase2_decode_continues:
+            if(elm->flags & ATF_OPEN_TYPE) {
+                rval = OPEN_TYPE_oer_get(opt_codec_ctx, td, st, elm, ptr, size);
+            } else {
+                void *save_memb_ptr; /* Temporary reference. */
+                void **memb_ptr2;  /* Pointer to a pointer to a memmber */
+
+                memb_ptr2 = element_ptrptr(st, elm, &save_memb_ptr);
+
+                rval = elm->type->op->oer_decoder(
+                    opt_codec_ctx, elm->type,
+                    elm->encoding_constraints.oer_constraints, memb_ptr2, ptr,
+                    size);
+            }
+            switch(rval.code) {
+            case RC_OK:
+                ADVANCE(rval.consumed);
+                break;
+            case RC_WMORE:
+                ASN_DEBUG("More bytes needed at element %s \"%s\"", td->name,
+                          elm->name);
+                ADVANCE(rval.consumed);
+                RETURN(RC_WMORE);
+            case RC_FAIL:
+                ASN_DEBUG("Decoding failed at element %s \"%s\"", td->name,
+                          elm->name);
+                RETURN(RC_FAIL);
+            }
+        } /* for(all root members) */
+
+    }
+        NEXT_PHASE(ctx);
+        /* FALL THROUGH */
+    case 2:
+        assert(ctx->ptr);
+        {
+        /* Cleanup preamble. */
+        asn_bit_data_t *preamble = ctx->ptr;
+        asn_bit_data_t *extadds;
+        int has_extensions_bit = (specs->first_extension >= 0);
+        int extensions_present =
+            has_extensions_bit
+            && (preamble->buffer == NULL
+                || (((const uint8_t *)preamble->buffer)[0] & 0x80));
+        uint8_t unused_bits;
+        size_t len = 0;
+        ssize_t len_len;
+
+        ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 2", td->name);
+
+        preamble->buffer = 0; /* Will do extensions_present==1 next time. */
+
+        if(!extensions_present) {
+            ctx->phase = 10;
+            RETURN(RC_OK);
+        }
+
+        /*
+         * X.696 (08/2015) #16.1 (c), #16.4
+         * Read in the extension addition presence bitmap.
+         */
+
+        len_len = oer_fetch_length(ptr, size, &len);
+        if(len_len > 0) {
+            ADVANCE(len_len);
+        } else if(len_len < 0) {
+            RETURN(RC_FAIL);
+        } else {
+            RETURN(RC_WMORE);
+        }
+
+        if(len == 0) {
+            /* 16.4.1-2 */
+            RETURN(RC_FAIL);
+        } else if(len > size) {
+            RETURN(RC_WMORE);
+        }
+
+        /* Account for unused bits */
+        unused_bits = 0x7 & *(const uint8_t *)ptr;
+        ADVANCE(1);
+        len--;
+        if(unused_bits && len == 0) {
+            RETURN(RC_FAIL);
+        }
+
+        /* Get the extensions map */
+        extadds = asn_bit_data_new_contiguous(ptr, len * 8 - unused_bits);
+        if(!extadds) {
+            RETURN(RC_FAIL);
+        }
+        FREEMEM(preamble);
+        ctx->ptr = extadds;
+        ADVANCE(len);
+    }
+        NEXT_PHASE(ctx);
+        ctx->step =
+            (specs->first_extension < 0 ? td->elements_count
+                                        : (size_t)specs->first_extension);
+        /* Fall through */
+    case 3:
+        ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 3 (Extensions)", td->name);
+        for(; ctx->step < (signed)td->elements_count; ctx->step++) {
+            asn_bit_data_t *extadds = ctx->ptr;
+            size_t edx = ctx->step;
+            asn_TYPE_member_t *elm = &td->elements[edx];
+            void *tmp_memb_ptr;
+            void **memb_ptr2 = element_ptrptr(st, elm, &tmp_memb_ptr);
+
+            switch(asn_get_few_bits(extadds, 1)) {
+            case -1:
+                /*
+                 * Not every one of our extensions is known to the remote side.
+                 * Continue filling in their defaults though.
+                 */
+                /* Fall through */
+            case 0:
+                /* Fill-in DEFAULT */
+                if(elm->default_value_set
+                   && elm->default_value_set(memb_ptr2)) {
+                    RETURN(RC_FAIL);
+                }
+                continue;
+            case 1: {
+                /* Read OER open type */
+                ssize_t ot_size =
+                    oer_open_type_get(opt_codec_ctx, elm->type,
+                                      elm->encoding_constraints.oer_constraints,
+                                      memb_ptr2, ptr, size);
+                assert(ot_size <= (ssize_t)size);
+                if(ot_size > 0) {
+                    ADVANCE(ot_size);
+                } else if(ot_size < 0) {
+                    RETURN(RC_FAIL);
+                } else {
+                    /* Roll back open type parsing */
+                    asn_get_undo(extadds, 1);
+                    RETURN(RC_WMORE);
+                }
+                break;
+            }
+            default:
+                RETURN(RC_FAIL);
+            }
+        }
+
+        NEXT_PHASE(ctx);
+        /* Fall through */
+    case 4:
+        ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 4", td->name);
+        /* Read in the rest of Open Types while ignoring them */
+        for(;;) {
+            asn_bit_data_t *extadds = ctx->ptr;
+            switch(asn_get_few_bits(extadds, 1)) {
+            case 0:
+                continue;
+            case 1: {
+                ssize_t skipped = oer_open_type_skip(ptr, size);
+                if(skipped > 0) {
+                    ADVANCE(skipped);
+                } else if(skipped < 0) {
+                    RETURN(RC_FAIL);
+                } else {
+                    asn_get_undo(extadds, 1);
+                    RETURN(RC_WMORE);
+                }
+                continue;
+            }
+            case -1:
+                /* No more Open Type encoded components */
+                break;
+            default:
+                RETURN(RC_FAIL);
+            }
+            break;
+        }
+    }
+
+    RETURN(RC_OK);
+}
+
+/*
+ * Encode as Canonical OER.
+ */
+asn_enc_rval_t
+SEQUENCE_encode_oer(const asn_TYPE_descriptor_t *td,
+                    const asn_oer_constraints_t *constraints, const void *sptr,
+                    asn_app_consume_bytes_f *cb, void *app_key) {
+    const asn_SEQUENCE_specifics_t *specs = (const asn_SEQUENCE_specifics_t *)td->specifics;
+    size_t computed_size = 0;
+    int has_extensions_bit = (specs->first_extension >= 0);
+    size_t preamble_bits = (has_extensions_bit + specs->roms_count);
+    uint32_t has_extensions = 0;
+    size_t edx;
+    int ret;
+
+    (void)constraints;
+
+    if(preamble_bits) {
+        asn_bit_outp_t preamble;
+
+        memset(&preamble, 0, sizeof(preamble));
+        preamble.output = cb;
+        preamble.op_key = app_key;
+
+        if(has_extensions_bit) {
+            for(edx = specs->first_extension; edx < td->elements_count; edx++) {
+                asn_TYPE_member_t *elm = &td->elements[edx];
+                const void *memb_ptr = element_ptr(sptr, elm);
+                if(memb_ptr) {
+                    if(elm->default_value_cmp
+                       && elm->default_value_cmp(memb_ptr) == 0) {
+                        /* Do not encode default values in extensions */
+                    } else {
+                        has_extensions = 1;
+                        break;
+                    }
+                }
+            }
+            ret = asn_put_few_bits(&preamble, has_extensions, 1);
+            assert(ret == 0);
+            if(ret < 0) {
+                ASN__ENCODE_FAILED;
+            }
+        }
+
+        /*
+         * Encode optional components bitmap.
+         */
+        if(specs->roms_count) {
+            FOR_IN_ROOT_GROUP(edx) {
+                asn_TYPE_member_t *elm = &td->elements[edx];
+
+                if(IN_EXTENSION_GROUP(specs, edx)) break;
+
+                if(elm->optional) {
+                    const void *memb_ptr = element_ptr(sptr, elm);
+                    uint32_t has_component = memb_ptr != NULL;
+                    if(has_component && elm->default_value_cmp
+                       && elm->default_value_cmp(memb_ptr) == 0) {
+                        has_component = 0;
+                    }
+                    ret = asn_put_few_bits(&preamble, has_component, 1);
+                    if(ret < 0) {
+                        ASN__ENCODE_FAILED;
+                    }
+                }
+            }
+        }
+
+        asn_put_aligned_flush(&preamble);
+        computed_size += preamble.flushed_bytes;
+    }   /* if(preamble_bits) */
+
+    /*
+     * Put root components and extensions root.
+     */
+    for(edx = 0; edx < td->elements_count; edx++) {
+        asn_TYPE_member_t *elm = &td->elements[edx];
+        asn_enc_rval_t er;
+        const void *memb_ptr;
+
+        if(IN_EXTENSION_GROUP(specs, edx)) break;
+
+        memb_ptr = element_ptr(sptr, elm);
+        if(memb_ptr) {
+            if(elm->default_value_cmp
+               && elm->default_value_cmp(memb_ptr) == 0) {
+                /* Skip default values in encoding */
+                continue;
+            }
+        } else {
+            if(elm->optional) continue;
+            /* Mandatory element is missing */
+            ASN__ENCODE_FAILED;
+        }
+        if(!elm->type->op->oer_encoder) {
+            ASN_DEBUG("OER encoder is not defined for type %s", elm->type->name);
+            ASN__ENCODE_FAILED;
+        }
+        er = elm->type->op->oer_encoder(
+            elm->type, elm->encoding_constraints.oer_constraints, memb_ptr, cb,
+            app_key);
+        if(er.encoded == -1) {
+            ASN_DEBUG("... while encoding %s member \"%s\"\n", td->name,
+                      elm->name);
+            return er;
+        }
+        computed_size += er.encoded;
+    }
+
+    /*
+     * Before encode extensions, encode extensions additions presense bitmap
+     # X.696 (08/2015) #16.4.
+     */
+    if(has_extensions) {
+        asn_bit_outp_t extadds;
+
+        /* Special case allowing us to use exactly one byte for #8.6 */
+        size_t aoms_length_bits = specs->aoms_count;
+        size_t aoms_length_bytes = (7 + aoms_length_bits) >> 3;
+        uint8_t unused_bits = 0x07 & (8 - (aoms_length_bits & 0x07));
+
+        assert(1 + aoms_length_bytes <= 127);
+
+        memset(&extadds, 0, sizeof(extadds));
+        extadds.output = cb;
+        extadds.op_key = app_key;
+
+        /* #8.6 length determinant */
+        ret = asn_put_few_bits(&extadds, (1 + aoms_length_bytes), 8);
+        if(ret < 0) ASN__ENCODE_FAILED;
+
+        /* Number of unused bytes, #16.4.2 */
+        ret = asn_put_few_bits(&extadds, unused_bits, 8);
+        if(ret < 0) ASN__ENCODE_FAILED;
+
+        /* Encode presence bitmap #16.4.3 */
+        for(edx = specs->first_extension; edx < td->elements_count; edx++) {
+            asn_TYPE_member_t *elm = &td->elements[edx];
+            const void *memb_ptr = element_ptr(sptr, elm);
+            if(memb_ptr && elm->default_value_cmp
+               && elm->default_value_cmp(memb_ptr) == 0) {
+                memb_ptr = 0;   /* Do not encode default value. */
+            }
+            ret |= asn_put_few_bits(&extadds, memb_ptr ? 1 : 0, 1);
+        }
+        if(ret < 0) ASN__ENCODE_FAILED;
+
+        asn_put_aligned_flush(&extadds);
+        computed_size += extadds.flushed_bytes;
+
+        /* Now, encode extensions */
+        for(edx = specs->first_extension; edx < td->elements_count; edx++) {
+            asn_TYPE_member_t *elm = &td->elements[edx];
+            const void *memb_ptr = element_ptr(sptr, elm);
+
+            if(memb_ptr) {
+                if(elm->default_value_cmp
+                   && elm->default_value_cmp(memb_ptr) == 0) {
+                    /* Do not encode default value. */
+                } else {
+                    ssize_t wrote = oer_open_type_put(
+                        elm->type, elm->encoding_constraints.oer_constraints,
+                        memb_ptr, cb, app_key);
+                    if(wrote == -1) {
+                        ASN__ENCODE_FAILED;
+                    }
+                    computed_size += wrote;
+                }
+            } else if(!elm->optional) {
+                ASN__ENCODE_FAILED;
+            }
+        }
+    }   /* if(has_extensions) */
+
+
+    {
+        asn_enc_rval_t er = {0, 0, 0};
+        er.encoded = computed_size;
+        ASN__ENCODED_OK(er);
+    }
+}
+
+#endif  /* ASN_DISABLE_OER_SUPPORT */
index 2dbc6e518846e3f9ce6eeef9b6e12d3d28c3e5b2..02fc515622e56226b21369090e9bb91c44067a09 100644 (file)
@@ -1,5 +1,5 @@
-/*-
- * Copyright (c) 2003, 2004, 2005 Lev Walkin <vlm@lionet.info>.
+/*
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>.
  * All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
  * All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
  * The decoder of the SET OF type.
  */
 asn_dec_rval_t
  * The decoder of the SET OF type.
  */
 asn_dec_rval_t
-SET_OF_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) {
-       /*
+SET_OF_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
+                  const asn_TYPE_descriptor_t *td, void **struct_ptr,
+                  const void *ptr, size_t size, int tag_mode) {
+    /*
         * Bring closer parts of structure description.
         */
         * Bring closer parts of structure description.
         */
-       asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
-       asn_TYPE_member_t *elm = td->elements;  /* Single one */
+       const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;
+    const asn_TYPE_member_t *elm = td->elements; /* Single one */
 
 
-       /*
+    /*
         * Parts of the structure being constructed.
         */
        void *st = *struct_ptr; /* Target structure. */
         * Parts of the structure being constructed.
         */
        void *st = *struct_ptr; /* Target structure. */
@@ -205,7 +206,7 @@ SET_OF_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                /*
                 * Invoke the member fetch routine according to member's type
                 */
                /*
                 * Invoke the member fetch routine according to member's type
                 */
-               rval = elm->type->ber_decoder(opt_codec_ctx,
+               rval = elm->type->op->ber_decoder(opt_codec_ctx,
                                elm->type, &ctx->ptr, ptr, LEFT, 0);
                ASN_DEBUG("In %s SET OF %s code %d consumed %d",
                        td->name, elm->type->name,
                                elm->type, &ctx->ptr, ptr, LEFT, 0);
                ASN_DEBUG("In %s SET OF %s code %d consumed %d",
                        td->name, elm->type->name,
@@ -270,188 +271,230 @@ SET_OF_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 struct _el_buffer {
        uint8_t *buf;
        size_t length;
 struct _el_buffer {
        uint8_t *buf;
        size_t length;
-       size_t size;
+       size_t allocated_size;
+    unsigned bits_unused;
 };
 /* Append bytes to the above structure */
 static int _el_addbytes(const void *buffer, size_t size, void *el_buf_ptr) {
 };
 /* Append bytes to the above structure */
 static int _el_addbytes(const void *buffer, size_t size, void *el_buf_ptr) {
-       struct _el_buffer *el_buf = (struct _el_buffer *)el_buf_ptr;
+    struct _el_buffer *el_buf = (struct _el_buffer *)el_buf_ptr;
 
 
-       if(el_buf->length + size > el_buf->size)
-               return -1;
+    if(el_buf->length + size > el_buf->allocated_size) {
+        size_t new_size = el_buf->allocated_size ? el_buf->allocated_size : 8;
+        void *p;
 
 
-       memcpy(el_buf->buf + el_buf->length, buffer, size);
+        do {
+            new_size <<= 2;
+        } while(el_buf->length + size > new_size);
 
 
-       el_buf->length += size;
-       return 0;
+        p = REALLOC(el_buf->buf, new_size);
+        if(p) {
+            el_buf->buf = p;
+            el_buf->allocated_size = new_size;
+        } else {
+            return -1;
+        }
+    }
+
+    memcpy(el_buf->buf + el_buf->length, buffer, size);
+
+    el_buf->length += size;
+    return 0;
 }
 }
-static int _el_buf_cmp(const void *ap, const void *bp) {
-       const struct _el_buffer *a = (const struct _el_buffer *)ap;
-       const struct _el_buffer *b = (const struct _el_buffer *)bp;
-       int ret;
-       size_t common_len;
-
-       if(a->length < b->length)
-               common_len = a->length;
-       else
-               common_len = b->length;
-
-       ret = memcmp(a->buf, b->buf, common_len);
-       if(ret == 0) {
-               if(a->length < b->length)
-                       ret = -1;
-               else if(a->length > b->length)
-                       ret = 1;
-       }
 
 
-       return ret;
+static void assert_unused_bits(const struct _el_buffer* p) {
+    if(p->length) {
+        assert((p->buf[p->length-1] & ~(0xff << p->bits_unused)) == 0);
+    } else {
+        assert(p->bits_unused == 0);
+    }
 }
 
 }
 
-/*
- * The DER encoder of the SET OF type.
- */
-asn_enc_rval_t
-SET_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
-       int tag_mode, ber_tlv_tag_t tag,
-       asn_app_consume_bytes_f *cb, void *app_key) {
-       asn_TYPE_member_t *elm = td->elements;
-       asn_TYPE_descriptor_t *elm_type = elm->type;
-       der_type_encoder_f *der_encoder = elm_type->der_encoder;
-       asn_anonymous_set_ *list = _A_SET_FROM_VOID(ptr);
-       size_t computed_size = 0;
-       ssize_t encoding_size = 0;
-       struct _el_buffer *encoded_els;
-       ssize_t eels_count = 0;
-       size_t max_encoded_len = 1;
-       asn_enc_rval_t erval;
-       int ret;
-       int edx;
+static int _el_buf_cmp(const void *ap, const void *bp) {
+    const struct _el_buffer *a = (const struct _el_buffer *)ap;
+    const struct _el_buffer *b = (const struct _el_buffer *)bp;
+    size_t common_len;
+    int ret = 0;
+
+    if(a->length < b->length)
+        common_len = a->length;
+    else
+        common_len = b->length;
+
+    if (a->buf && b->buf) {
+        ret = memcmp(a->buf, b->buf, common_len);
+    }
+    if(ret == 0) {
+        if(a->length < b->length)
+            ret = -1;
+        else if(a->length > b->length)
+            ret = 1;
+        /* Ignore unused bits. */
+        assert_unused_bits(a);
+        assert_unused_bits(b);
+    }
+
+    return ret;
+}
 
 
-       ASN_DEBUG("Estimating size for SET OF %s", td->name);
+static void
+SET_OF__encode_sorted_free(struct _el_buffer *el_buf, size_t count) {
+    size_t i;
 
 
-       /*
-        * Gather the length of the underlying members sequence.
-        */
-       for(edx = 0; edx < list->count; edx++) {
-               void *memb_ptr = list->array[edx];
-               if(!memb_ptr) continue;
-               erval = der_encoder(elm_type, memb_ptr, 0, elm->tag, 0, 0);
-               if(erval.encoded == -1)
-                       return erval;
-               computed_size += erval.encoded;
-
-               /* Compute maximum encoding's size */
-               if(max_encoded_len < (size_t)erval.encoded)
-                       max_encoded_len = erval.encoded;
-       }
+    for(i = 0; i < count; i++) {
+        FREEMEM(el_buf[i].buf);
+    }
 
 
-       /*
-        * Encode the TLV for the sequence itself.
-        */
-       encoding_size = der_write_tags(td, computed_size, tag_mode, 1, tag,
-               cb, app_key);
-       if(encoding_size == -1) {
-               erval.encoded = -1;
-               erval.failed_type = td;
-               erval.structure_ptr = ptr;
-               return erval;
-       }
-       computed_size += encoding_size;
+    FREEMEM(el_buf);
+}
 
 
-       if(!cb || list->count == 0) {
-               erval.encoded = computed_size;
-               ASN__ENCODED_OK(erval);
-       }
+enum SET_OF__encode_method {
+    SOES_DER,   /* Distinguished Encoding Rules */
+    SOES_CUPER  /* Canonical Unaligned Packed Encoding Rules */
+};
 
 
-       /*
-        * DER mandates dynamic sorting of the SET OF elements
-        * according to their encodings. Build an array of the
-        * encoded elements.
-        */
-       encoded_els = (struct _el_buffer *)MALLOC(
-                               list->count * sizeof(encoded_els[0]));
-       if(encoded_els == NULL) {
-               erval.encoded = -1;
-               erval.failed_type = td;
-               erval.structure_ptr = ptr;
-               return erval;
-       }
+static struct _el_buffer *
+SET_OF__encode_sorted(const asn_TYPE_member_t *elm,
+                      const asn_anonymous_set_ *list,
+                      enum SET_OF__encode_method method) {
+    struct _el_buffer *encoded_els;
+    int edx;
 
 
-       ASN_DEBUG("Encoding members of %s SET OF", td->name);
+    encoded_els =
+        (struct _el_buffer *)CALLOC(list->count, sizeof(encoded_els[0]));
+    if(encoded_els == NULL) {
+        return NULL;
+    }
 
        /*
         * Encode all members.
         */
 
        /*
         * Encode all members.
         */
-       for(edx = 0; edx < list->count; edx++) {
-               void *memb_ptr = list->array[edx];
-               struct _el_buffer *encoded_el = &encoded_els[eels_count];
-
-               if(!memb_ptr) continue;
+    for(edx = 0; edx < list->count; edx++) {
+        const void *memb_ptr = list->array[edx];
+        struct _el_buffer *encoding_el = &encoded_els[edx];
+        asn_enc_rval_t erval;
 
 
-               /*
-                * Prepare space for encoding.
-                */
-               encoded_el->buf = (uint8_t *)MALLOC(max_encoded_len);
-               if(encoded_el->buf) {
-                       encoded_el->length = 0;
-                       encoded_el->size = max_encoded_len;
-               } else {
-                       for(edx--; edx >= 0; edx--)
-                               FREEMEM(encoded_els[edx].buf);
-                       FREEMEM(encoded_els);
-                       erval.encoded = -1;
-                       erval.failed_type = td;
-                       erval.structure_ptr = ptr;
-                       return erval;
-               }
+        if(!memb_ptr) break;
 
 
-               /*
+        /*
                 * Encode the member into the prepared space.
                 */
                 * Encode the member into the prepared space.
                 */
-               erval = der_encoder(elm_type, memb_ptr, 0, elm->tag,
-                       _el_addbytes, encoded_el);
-               if(erval.encoded == -1) {
-                       for(; edx >= 0; edx--)
-                               FREEMEM(encoded_els[edx].buf);
-                       FREEMEM(encoded_els);
-                       return erval;
-               }
-               encoding_size += erval.encoded;
-               eels_count++;
+        switch(method) {
+        case SOES_DER:
+            erval = elm->type->op->der_encoder(elm->type, memb_ptr, 0, elm->tag,
+                                               _el_addbytes, encoding_el);
+            break;
+        case SOES_CUPER:
+            erval = uper_encode(elm->type,
+                                elm->encoding_constraints.per_constraints,
+                                memb_ptr, _el_addbytes, encoding_el);
+            if(erval.encoded != -1) {
+                size_t extra_bits = erval.encoded % 8;
+                assert(encoding_el->length == (size_t)(erval.encoded + 7) / 8);
+                encoding_el->bits_unused = (8 - extra_bits) & 0x7;
+            }
+            break;
+        default:
+            assert(!"Unreachable");
+            break;
+        }
+        if(erval.encoded < 0) break;
        }
 
        }
 
-       /*
-        * Sort the encoded elements according to their encoding.
-        */
-       qsort(encoded_els, eels_count, sizeof(encoded_els[0]), _el_buf_cmp);
+    if(edx == list->count) {
+        /*
+         * Sort the encoded elements according to their encoding.
+         */
+        qsort(encoded_els, list->count, sizeof(encoded_els[0]), _el_buf_cmp);
+
+        return encoded_els;
+    } else {
+        SET_OF__encode_sorted_free(encoded_els, edx);
+        return NULL;
+    }
+}
 
 
-       /*
-        * Report encoded elements to the application.
-        * Dispose of temporary sorted members table.
-        */
-       ret = 0;
-       for(edx = 0; edx < eels_count; edx++) {
-               struct _el_buffer *encoded_el = &encoded_els[edx];
-               /* Report encoded chunks to the application */
-               if(ret == 0
-               && cb(encoded_el->buf, encoded_el->length, app_key) < 0)
-                       ret = -1;
-               FREEMEM(encoded_el->buf);
-       }
-       FREEMEM(encoded_els);
 
 
-       if(ret || computed_size != (size_t)encoding_size) {
-               /*
-                * Standard callback failed, or
-                * encoded size is not equal to the computed size.
-                */
-               erval.encoded = -1;
-               erval.failed_type = td;
-               erval.structure_ptr = ptr;
-       } else {
-               erval.encoded = computed_size;
+/*
+ * The DER encoder of the SET OF type.
+ */
+asn_enc_rval_t
+SET_OF_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,
+                  int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,
+                  void *app_key) {
+    const asn_TYPE_member_t *elm = td->elements;
+    const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
+    size_t computed_size = 0;
+    ssize_t encoding_size = 0;
+    struct _el_buffer *encoded_els;
+    int edx;
+
+       ASN_DEBUG("Estimating size for SET OF %s", td->name);
+
+    /*
+     * Gather the length of the underlying members sequence.
+     */
+    for(edx = 0; edx < list->count; edx++) {
+        void *memb_ptr = list->array[edx];
+        asn_enc_rval_t erval;
+
+        if(!memb_ptr) ASN__ENCODE_FAILED;
+
+        erval =
+            elm->type->op->der_encoder(elm->type, memb_ptr, 0, elm->tag, 0, 0);
+        if(erval.encoded == -1) return erval;
+        computed_size += erval.encoded;
        }
 
        }
 
-       ASN__ENCODED_OK(erval);
+
+    /*
+     * Encode the TLV for the sequence itself.
+     */
+    encoding_size =
+        der_write_tags(td, computed_size, tag_mode, 1, tag, cb, app_key);
+    if(encoding_size < 0) {
+        ASN__ENCODE_FAILED;
+    }
+    computed_size += encoding_size;
+
+    if(!cb || list->count == 0) {
+        asn_enc_rval_t erval;
+        erval.encoded = computed_size;
+        ASN__ENCODED_OK(erval);
+    }
+
+    ASN_DEBUG("Encoding members of %s SET OF", td->name);
+
+    /*
+     * DER mandates dynamic sorting of the SET OF elements
+     * according to their encodings. Build an array of the
+     * encoded elements.
+     */
+    encoded_els = SET_OF__encode_sorted(elm, list, SOES_DER);
+
+    /*
+     * Report encoded elements to the application.
+     * Dispose of temporary sorted members table.
+     */
+    for(edx = 0; edx < list->count; edx++) {
+        struct _el_buffer *encoded_el = &encoded_els[edx];
+        /* Report encoded chunks to the application */
+        if(cb(encoded_el->buf, encoded_el->length, app_key) < 0) {
+            break;
+        } else {
+            encoding_size += encoded_el->length;
+        }
+    }
+
+    SET_OF__encode_sorted_free(encoded_els, list->count);
+
+    if(edx == list->count) {
+        asn_enc_rval_t erval;
+        assert(computed_size == (size_t)encoding_size);
+        erval.encoded = computed_size;
+        ASN__ENCODED_OK(erval);
+    } else {
+        ASN__ENCODE_FAILED;
+    }
 }
 
 #undef XER_ADVANCE
 }
 
 #undef XER_ADVANCE
@@ -466,14 +509,14 @@ SET_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
  * Decode the XER (XML) data.
  */
 asn_dec_rval_t
  * Decode the XER (XML) data.
  */
 asn_dec_rval_t
-SET_OF_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) {
-       /*
+SET_OF_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
+                  const 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.
         */
         * Bring closer parts of structure description.
         */
-       asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
-       asn_TYPE_member_t *element = td->elements;
+       const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;
+       const asn_TYPE_member_t *element = td->elements;
        const char *elm_tag;
        const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
 
        const char *elm_tag;
        const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
 
@@ -526,7 +569,7 @@ SET_OF_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 
                        /* Invoke the inner type decoder, m.b. multiple times */
                        ASN_DEBUG("XER/SET OF element [%s]", elm_tag);
 
                        /* Invoke the inner type decoder, m.b. multiple times */
                        ASN_DEBUG("XER/SET OF element [%s]", elm_tag);
-                       tmprval = element->type->xer_decoder(opt_codec_ctx,
+                       tmprval = element->type->op->xer_decoder(opt_codec_ctx,
                                        element->type, &ctx->ptr, elm_tag,
                                        buf_ptr, size);
                        if(tmprval.code == RC_OK) {
                                        element->type, &ctx->ptr, elm_tag,
                                        buf_ptr, size);
                        if(tmprval.code == RC_OK) {
@@ -651,14 +694,14 @@ SET_OF_xer_order(const void *aptr, const void *bptr) {
 
 
 asn_enc_rval_t
 
 
 asn_enc_rval_t
-SET_OF_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;
-       asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
-       asn_TYPE_member_t *elm = td->elements;
-       asn_anonymous_set_ *list = _A_SET_FROM_VOID(sptr);
-       const char *mname = specs->as_XMLValueList
+SET_OF_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+                  enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
+                  void *app_key) {
+    asn_enc_rval_t er;
+       const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;
+       const asn_TYPE_member_t *elm = td->elements;
+    const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
+    const char *mname = specs->as_XMLValueList
                ? 0 : ((*elm->name) ? elm->name : elm->type->xml_tag);
        size_t mlen = mname ? strlen(mname) : 0;
        int xcan = (flags & XER_F_CANONICAL);
                ? 0 : ((*elm->name) ? elm->name : elm->type->xml_tag);
        size_t mlen = mname ? strlen(mname) : 0;
        int xcan = (flags & XER_F_CANONICAL);
@@ -697,14 +740,11 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 
                if(!xcan && specs->as_XMLValueList == 1)
                        ASN__TEXT_INDENT(1, ilevel + 1);
 
                if(!xcan && specs->as_XMLValueList == 1)
                        ASN__TEXT_INDENT(1, ilevel + 1);
-               tmper = elm->type->xer_encoder(elm->type, memb_ptr,
+               tmper = elm->type->op->xer_encoder(elm->type, memb_ptr,
                                ilevel + (specs->as_XMLValueList != 2),
                                flags, cb, app_key);
                                ilevel + (specs->as_XMLValueList != 2),
                                flags, cb, app_key);
-               if(tmper.encoded == -1) {
-                       td = tmper.failed_type;
-                       sptr = tmper.structure_ptr;
-                       goto cb_failed;
-               }
+               if(tmper.encoded == -1) return tmper;
+               er.encoded += tmper.encoded;
                if(tmper.encoded == 0 && specs->as_XMLValueList) {
                        const char *name = elm->type->xml_tag;
                        size_t len = strlen(name);
                if(tmper.encoded == 0 && specs->as_XMLValueList) {
                        const char *name = elm->type->xml_tag;
                        size_t len = strlen(name);
@@ -713,10 +753,8 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 
                if(mname) {
                        ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
 
                if(mname) {
                        ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
-                       er.encoded += 5;
                }
 
                }
 
-               er.encoded += (2 * mlen) + tmper.encoded;
        }
 
        if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
        }
 
        if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
@@ -726,6 +764,7 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
                xer_tmp_enc_t *end = encs + encs_count;
                ssize_t control_size = 0;
 
                xer_tmp_enc_t *end = encs + encs_count;
                ssize_t control_size = 0;
 
+               er.encoded = 0;
                cb = original_cb;
                app_key = original_app_key;
                qsort(encs, encs_count, sizeof(encs[0]), SET_OF_xer_order);
                cb = original_cb;
                app_key = original_app_key;
                qsort(encs, encs_count, sizeof(encs[0]), SET_OF_xer_order);
@@ -741,14 +780,12 @@ SET_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 
        goto cleanup;
 cb_failed:
 
        goto cleanup;
 cb_failed:
-       er.encoded = -1;
-       er.failed_type = td;
-       er.structure_ptr = sptr;
+       ASN__ENCODE_FAILED;
 cleanup:
        if(encs) {
 cleanup:
        if(encs) {
-               while(encs_count-- > 0) {
-                       if(encs[encs_count].buffer)
-                               FREEMEM(encs[encs_count].buffer);
+               size_t n;
+               for(n = 0; n < encs_count; n++) {
+                       FREEMEM(encs[n].buffer);
                }
                FREEMEM(encs);
        }
                }
                FREEMEM(encs);
        }
@@ -756,9 +793,9 @@ cleanup:
 }
 
 int
 }
 
 int
-SET_OF_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
-               asn_app_consume_bytes_f *cb, void *app_key) {
-       asn_TYPE_member_t *elm = td->elements;
+SET_OF_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+             asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_TYPE_member_t *elm = td->elements;
        const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
        int ret;
        int i;
        const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
        int ret;
        int i;
@@ -776,7 +813,7 @@ SET_OF_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 
                _i_INDENT(1);
 
 
                _i_INDENT(1);
 
-               ret = elm->type->print_struct(elm->type, memb_ptr,
+               ret = elm->type->op->print_struct(elm->type, memb_ptr,
                        ilevel + 1, cb, app_key);
                if(ret) return ret;
        }
                        ilevel + 1, cb, app_key);
                if(ret) return ret;
        }
@@ -788,9 +825,10 @@ SET_OF_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 }
 
 void
 }
 
 void
-SET_OF_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
-       if(td && ptr) {
-               asn_SET_OF_specifics_t *specs;
+SET_OF_free(const asn_TYPE_descriptor_t *td, void *ptr,
+            enum asn_struct_free_method method) {
+    if(td && ptr) {
+               const asn_SET_OF_specifics_t *specs;
                asn_TYPE_member_t *elm = td->elements;
                asn_anonymous_set_ *list = _A_SET_FROM_VOID(ptr);
                asn_struct_ctx_t *ctx;  /* Decoder context */
                asn_TYPE_member_t *elm = td->elements;
                asn_anonymous_set_ *list = _A_SET_FROM_VOID(ptr);
                asn_struct_ctx_t *ctx;  /* Decoder context */
@@ -809,23 +847,30 @@ SET_OF_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
 
                asn_set_empty(list);    /* Remove (list->array) */
 
 
                asn_set_empty(list);    /* Remove (list->array) */
 
-               specs = (asn_SET_OF_specifics_t *)td->specifics;
+               specs = (const asn_SET_OF_specifics_t *)td->specifics;
                ctx = (asn_struct_ctx_t *)((char *)ptr + specs->ctx_offset);
                if(ctx->ptr) {
                        ASN_STRUCT_FREE(*elm->type, ctx->ptr);
                        ctx->ptr = 0;
                }
 
                ctx = (asn_struct_ctx_t *)((char *)ptr + specs->ctx_offset);
                if(ctx->ptr) {
                        ASN_STRUCT_FREE(*elm->type, ctx->ptr);
                        ctx->ptr = 0;
                }
 
-               if(!contents_only) {
-                       FREEMEM(ptr);
-               }
-       }
+        switch(method) {
+        case ASFM_FREE_EVERYTHING:
+            FREEMEM(ptr);
+            break;
+        case ASFM_FREE_UNDERLYING:
+            break;
+        case ASFM_FREE_UNDERLYING_AND_RESET:
+            memset(ptr, 0, specs->struct_size);
+            break;
+        }
+    }
 }
 
 int
 }
 
 int
-SET_OF_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-               asn_app_constraint_failed_f *ctfailcb, void *app_key) {
-       asn_TYPE_member_t *elm = td->elements;
+SET_OF_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
+                  asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+    const asn_TYPE_member_t *elm = td->elements;
        asn_constr_check_f *constr;
        const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
        int i;
        asn_constr_check_f *constr;
        const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
        int i;
@@ -837,8 +882,8 @@ SET_OF_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
                return -1;
        }
 
                return -1;
        }
 
-       constr = elm->memb_constraints;
-       if(!constr) constr = elm->type->check_constraints;
+       constr = elm->encoding_constraints.general_constraints;
+       if(!constr) constr = elm->type->encoding_constraints.general_constraints;
 
        /*
         * Iterate over the members of an array.
 
        /*
         * Iterate over the members of an array.
@@ -854,25 +899,22 @@ SET_OF_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
                if(ret) return ret;
        }
 
                if(ret) return ret;
        }
 
-       /*
-        * Cannot inherit it eralier:
-        * need to make sure we get the updated version.
-        */
-       if(!elm->memb_constraints)
-               elm->memb_constraints = elm->type->check_constraints;
-
        return 0;
 }
 
        return 0;
 }
 
+#ifndef ASN_DISABLE_PER_SUPPORT
+
 asn_dec_rval_t
 asn_dec_rval_t
-SET_OF_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_dec_rval_t rv;
-        asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
-       asn_TYPE_member_t *elm = td->elements;  /* Single one */
-       void *st = *sptr;
+SET_OF_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
+                   const asn_TYPE_descriptor_t *td,
+                   const asn_per_constraints_t *constraints, void **sptr,
+                   asn_per_data_t *pd) {
+    asn_dec_rval_t rv;
+       const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;
+    const asn_TYPE_member_t *elm = td->elements; /* Single one */
+    void *st = *sptr;
        asn_anonymous_set_ *list;
        asn_anonymous_set_ *list;
-       asn_per_constraint_t *ct;
+       const asn_per_constraint_t *ct;
        int repeat = 0;
        ssize_t nelems;
 
        int repeat = 0;
        ssize_t nelems;
 
@@ -890,7 +932,8 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 
        /* Figure out which constraints to use */
        if(constraints) ct = &constraints->size;
 
        /* Figure out which constraints to use */
        if(constraints) ct = &constraints->size;
-       else if(td->per_constraints) ct = &td->per_constraints->size;
+       else if(td->encoding_constraints.per_constraints)
+               ct = &td->encoding_constraints.per_constraints->size;
        else ct = 0;
 
        if(ct && ct->flags & APC_EXTENSIBLE) {
        else ct = 0;
 
        if(ct && ct->flags & APC_EXTENSIBLE) {
@@ -913,23 +956,27 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
        do {
                int i;
                if(nelems < 0) {
        do {
                int i;
                if(nelems < 0) {
-                       nelems = uper_get_length(pd,
-                               ct ? ct->effective_bits : -1, &repeat);
-                       ASN_DEBUG("Got to decode %d elements (eff %d)",
-                               (int)nelems, (int)(ct ? ct->effective_bits : -1));
-                       if(nelems < 0) ASN__DECODE_STARVED;
+                       nelems = uper_get_length(pd, -1, 0, &repeat);
+            ASN_DEBUG("Got to decode %" ASN_PRI_SSIZE " elements (eff %d)",
+                      nelems, (int)(ct ? ct->effective_bits : -1));
+            if(nelems < 0) ASN__DECODE_STARVED;
                }
 
                for(i = 0; i < nelems; i++) {
                        void *ptr = 0;
                        ASN_DEBUG("SET OF %s decoding", elm->type->name);
                }
 
                for(i = 0; i < nelems; i++) {
                        void *ptr = 0;
                        ASN_DEBUG("SET OF %s decoding", elm->type->name);
-                       rv = elm->type->uper_decoder(opt_codec_ctx, elm->type,
-                               elm->per_constraints, &ptr, pd);
+                       rv = elm->type->op->uper_decoder(opt_codec_ctx, elm->type,
+                               elm->encoding_constraints.per_constraints, &ptr, pd);
                        ASN_DEBUG("%s SET OF %s decoded %d, %p",
                                td->name, elm->type->name, rv.code, ptr);
                        if(rv.code == RC_OK) {
                        ASN_DEBUG("%s SET OF %s decoded %d, %p",
                                td->name, elm->type->name, rv.code, ptr);
                        if(rv.code == RC_OK) {
-                               if(ASN_SET_ADD(list, ptr) == 0)
+                               if(ASN_SET_ADD(list, ptr) == 0) {
+                    if(rv.consumed == 0 && nelems > 200) {
+                        /* Protect from SET OF NULL compression bombs. */
+                        ASN__DECODE_FAILED;
+                    }
                                        continue;
                                        continue;
+                }
                                ASN_DEBUG("Failed to add element into %s",
                                        td->name);
                                /* Fall through */
                                ASN_DEBUG("Failed to add element into %s",
                                        td->name);
                                /* Fall through */
@@ -952,3 +999,350 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
        return rv;
 }
 
        return rv;
 }
 
+asn_enc_rval_t
+SET_OF_encode_uper(const asn_TYPE_descriptor_t *td,
+                   const asn_per_constraints_t *constraints, const void *sptr,
+                   asn_per_outp_t *po) {
+    const asn_anonymous_set_ *list;
+    const asn_per_constraint_t *ct;
+    const asn_TYPE_member_t *elm = td->elements;
+    struct _el_buffer *encoded_els;
+    asn_enc_rval_t er;
+    size_t encoded_edx;
+
+    if(!sptr) ASN__ENCODE_FAILED;
+
+    list = _A_CSET_FROM_VOID(sptr);
+
+    er.encoded = 0;
+
+    ASN_DEBUG("Encoding %s as SEQUENCE OF (%d)", td->name, list->count);
+
+    if(constraints) ct = &constraints->size;
+    else if(td->encoding_constraints.per_constraints)
+        ct = &td->encoding_constraints.per_constraints->size;
+    else ct = 0;
+
+    /* If extensible constraint, check if size is in root */
+    if(ct) {
+        int not_in_root =
+            (list->count < ct->lower_bound || list->count > ct->upper_bound);
+        ASN_DEBUG("lb %ld ub %ld %s", ct->lower_bound, ct->upper_bound,
+                  ct->flags & APC_EXTENSIBLE ? "ext" : "fix");
+        if(ct->flags & APC_EXTENSIBLE) {
+            /* Declare whether size is in extension root */
+            if(per_put_few_bits(po, not_in_root, 1)) ASN__ENCODE_FAILED;
+            if(not_in_root) ct = 0;
+        } else if(not_in_root && ct->effective_bits >= 0) {
+            ASN__ENCODE_FAILED;
+        }
+
+    }
+
+    if(ct && ct->effective_bits >= 0) {
+        /* X.691, #19.5: No length determinant */
+        if(per_put_few_bits(po, list->count - ct->lower_bound,
+                            ct->effective_bits))
+            ASN__ENCODE_FAILED;
+    } else if(list->count == 0) {
+        /* When the list is empty add only the length determinant
+         * X.691, #20.6 and #11.9.4.1
+         */
+        if (uper_put_length(po, 0, 0)) {
+            ASN__ENCODE_FAILED;
+        }
+        ASN__ENCODED_OK(er);
+    }
+
+
+    /*
+     * Canonical UPER #22.1 mandates dynamic sorting of the SET OF elements
+     * according to their encodings. Build an array of the encoded elements.
+     */
+    encoded_els = SET_OF__encode_sorted(elm, list, SOES_CUPER);
+
+    for(encoded_edx = 0; (ssize_t)encoded_edx < list->count;) {
+        ssize_t may_encode;
+        size_t edx;
+        int need_eom = 0;
+
+        if(ct && ct->effective_bits >= 0) {
+            may_encode = list->count;
+        } else {
+            may_encode =
+                uper_put_length(po, list->count - encoded_edx, &need_eom);
+            if(may_encode < 0) ASN__ENCODE_FAILED;
+        }
+
+        for(edx = encoded_edx; edx < encoded_edx + may_encode; edx++) {
+            const struct _el_buffer *el = &encoded_els[edx];
+            if(asn_put_many_bits(po, el->buf,
+                                 (8 * el->length) - el->bits_unused) < 0) {
+                break;
+            }
+        }
+
+        if(need_eom && uper_put_length(po, 0, 0))
+            ASN__ENCODE_FAILED; /* End of Message length */
+
+        encoded_edx += may_encode;
+    }
+
+    SET_OF__encode_sorted_free(encoded_els, list->count);
+
+    if((ssize_t)encoded_edx == list->count) {
+        ASN__ENCODED_OK(er);
+    } else {
+        ASN__ENCODE_FAILED;
+    }
+}
+
+
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
+struct comparable_ptr {
+    const asn_TYPE_descriptor_t *td;
+    const void *sptr;
+};
+
+static int
+SET_OF__compare_cb(const void *aptr, const void *bptr) {
+    const struct comparable_ptr *a = aptr;
+    const struct comparable_ptr *b = bptr;
+    assert(a->td == b->td);
+    return a->td->op->compare_struct(a->td, a->sptr, b->sptr);
+}
+
+int
+SET_OF_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
+               const void *bptr) {
+    const asn_anonymous_set_ *a = _A_CSET_FROM_VOID(aptr);
+    const asn_anonymous_set_ *b = _A_CSET_FROM_VOID(bptr);
+
+    if(a && b) {
+        struct comparable_ptr *asorted;
+        struct comparable_ptr *bsorted;
+        ssize_t common_length;
+        ssize_t idx;
+
+        if(a->count == 0) {
+            if(b->count) return -1;
+            return 0;
+        } else if(b->count == 0) {
+            return 1;
+        }
+
+        asorted = MALLOC(a->count * sizeof(asorted[0]));
+        bsorted = MALLOC(b->count * sizeof(bsorted[0]));
+        if(!asorted || !bsorted) {
+            FREEMEM(asorted);
+            FREEMEM(bsorted);
+            return -1;
+        }
+
+        for(idx = 0; idx < a->count; idx++) {
+            asorted[idx].td = td->elements->type;
+            asorted[idx].sptr = a->array[idx];
+        }
+
+        for(idx = 0; idx < b->count; idx++) {
+            bsorted[idx].td = td->elements->type;
+            bsorted[idx].sptr = b->array[idx];
+        }
+
+        qsort(asorted, a->count, sizeof(asorted[0]), SET_OF__compare_cb);
+        qsort(bsorted, b->count, sizeof(bsorted[0]), SET_OF__compare_cb);
+
+        common_length = (a->count < b->count ? a->count : b->count);
+        for(idx = 0; idx < common_length; idx++) {
+            int ret = td->elements->type->op->compare_struct(
+                td->elements->type, asorted[idx].sptr, bsorted[idx].sptr);
+            if(ret) {
+                FREEMEM(asorted);
+                FREEMEM(bsorted);
+                return ret;
+            }
+        }
+
+        FREEMEM(asorted);
+        FREEMEM(bsorted);
+
+        if(idx < b->count) /* more elements in b */
+            return -1;     /* a is shorter, so put it first */
+        if(idx < a->count) return 1;
+    } else if(!a) {
+        return -1;
+    } else if(!b) {
+        return 1;
+    }
+
+       return 0;
+}
+
+
+asn_TYPE_operation_t asn_OP_SET_OF = {
+       SET_OF_free,
+       SET_OF_print,
+       SET_OF_compare,
+       SET_OF_decode_ber,
+       SET_OF_encode_der,
+       SET_OF_decode_xer,
+       SET_OF_encode_xer,
+#ifdef ASN_DISABLE_OER_SUPPORT
+       0,
+       0,
+#else
+       SET_OF_decode_oer,
+       SET_OF_encode_oer,
+#endif
+#ifdef ASN_DISABLE_PER_SUPPORT
+       0,
+       0,
+#else
+       SET_OF_decode_uper,
+       SET_OF_encode_uper,
+#endif /* ASN_DISABLE_PER_SUPPORT */
+       SET_OF_random_fill,
+       0       /* Use generic outmost tag fetcher */
+};
+
+
+asn_random_fill_result_t
+SET_OF_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
+                   const asn_encoding_constraints_t *constraints,
+                   size_t max_length) {
+    const asn_SET_OF_specifics_t *specs =
+        (const asn_SET_OF_specifics_t *)td->specifics;
+    asn_random_fill_result_t res_ok = {ARFILL_OK, 0};
+    asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
+    asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
+    const asn_TYPE_member_t *elm = td->elements;
+    void *st = *sptr;
+    long max_elements = 5;
+    long slb = 0;   /* Lower size bound */
+    long sub = 0;   /* Upper size bound */
+    size_t rnd_len;
+
+    if(max_length == 0) return result_skipped;
+
+    if(st == NULL) {
+        st = (*sptr = CALLOC(1, specs->struct_size));
+        if(st == NULL) {
+            return result_failed;
+        }
+    }
+
+    switch(asn_random_between(0, 6)) {
+    case 0: max_elements = 0; break;
+    case 1: max_elements = 1; break;
+    case 2: max_elements = 5; break;
+    case 3: max_elements = max_length; break;
+    case 4: max_elements = max_length / 2; break;
+    case 5: max_elements = max_length / 4; break;
+    default: break;
+    }
+    sub = slb + max_elements;
+
+    if(!constraints || !constraints->per_constraints)
+        constraints = &td->encoding_constraints;
+    if(constraints->per_constraints) {
+        const asn_per_constraint_t *pc = &constraints->per_constraints->size;
+        if(pc->flags & APC_SEMI_CONSTRAINED) {
+            slb = pc->lower_bound;
+            sub = pc->lower_bound + max_elements;
+        } else if(pc->flags & APC_CONSTRAINED) {
+            slb = pc->lower_bound;
+            sub = pc->upper_bound;
+            if(sub - slb > max_elements) sub = slb + max_elements;
+        }
+    }
+
+    /* Bias towards edges of allowed space */
+    switch(asn_random_between(-1, 4)) {
+    default:
+    case -1:
+        /* Prepare lengths somewhat outside of constrained range. */
+        if(constraints->per_constraints
+           && (constraints->per_constraints->size.flags & APC_EXTENSIBLE)) {
+            switch(asn_random_between(0, 5)) {
+            default:
+            case 0:
+                rnd_len = 0;
+                break;
+            case 1:
+                if(slb > 0) {
+                    rnd_len = slb - 1;
+                } else {
+                    rnd_len = 0;
+                }
+                break;
+            case 2:
+                rnd_len = asn_random_between(0, slb);
+                break;
+            case 3:
+                if(sub < (ssize_t)max_length) {
+                    rnd_len = sub + 1;
+                } else {
+                    rnd_len = max_length;
+                }
+                break;
+            case 4:
+                if(sub < (ssize_t)max_length) {
+                    rnd_len = asn_random_between(sub + 1, max_length);
+                } else {
+                    rnd_len = max_length;
+                }
+                break;
+            case 5:
+                rnd_len = max_length;
+                break;
+            }
+            break;
+        }
+        /* Fall through */
+    case 0:
+        rnd_len = asn_random_between(slb, sub);
+        break;
+    case 1:
+        if(slb < sub) {
+            rnd_len = asn_random_between(slb + 1, sub);
+            break;
+        }
+        /* Fall through */
+    case 2:
+        rnd_len = asn_random_between(slb, slb);
+        break;
+    case 3:
+        if(slb < sub) {
+            rnd_len = asn_random_between(slb, sub - 1);
+            break;
+        }
+        /* Fall through */
+    case 4:
+        rnd_len = asn_random_between(sub, sub);
+        break;
+    }
+
+    for(; rnd_len > 0; rnd_len--) {
+        asn_anonymous_set_ *list = _A_SET_FROM_VOID(st);
+        void *ptr = 0;
+        asn_random_fill_result_t tmpres = elm->type->op->random_fill(
+            elm->type, &ptr, &elm->encoding_constraints,
+            (max_length > res_ok.length ? max_length - res_ok.length : 0)
+                / rnd_len);
+        switch(tmpres.code) {
+        case ARFILL_OK:
+            ASN_SET_ADD(list, ptr);
+            res_ok.length += tmpres.length;
+            break;
+        case ARFILL_SKIPPED:
+            break;
+        case ARFILL_FAILED:
+            assert(ptr == 0);
+            return tmpres;
+        }
+    }
+
+    return res_ok;
+}
+
diff --git a/libs/smux/constr_SET_OF_oer.c b/libs/smux/constr_SET_OF_oer.c
new file mode 100644 (file)
index 0000000..88d7a2a
--- /dev/null
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_DISABLE_OER_SUPPORT
+
+#include <asn_internal.h>
+#include <constr_SET_OF.h>
+#include <asn_SET_OF.h>
+#include <errno.h>
+
+/*
+ * 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;                         \
+        consumed_myself += num;              \
+    } while(0)
+
+/*
+ * Switch to the next phase of parsing.
+ */
+#undef  NEXT_PHASE
+#define NEXT_PHASE(ctx) \
+    do {                \
+        ctx->phase++;   \
+        ctx->step = 0;  \
+    } while(0)
+#undef  SET_PHASE
+#define SET_PHASE(ctx, value) \
+    do {                      \
+        ctx->phase = value;   \
+        ctx->step = 0;        \
+    } while(0)
+
+/*
+ * Return a standardized complex structure.
+ */
+#undef  RETURN
+#define RETURN(_code)                    \
+    do {                                 \
+        asn_dec_rval_t rval;             \
+        rval.code = _code;               \
+        rval.consumed = consumed_myself; \
+        return rval;                     \
+    } while(0)
+
+/*
+ * The SEQUENCE OF and SET OF values utilize a "quantity field".
+ * It is is a pointless combination of #8.6 (length determinant, capable
+ * of encoding tiny and huge numbers in the shortest possible number of octets)
+ * and the variable sized integer. What could have been encoded by #8.6 alone
+ * is required to be encoded by #8.6 followed by that number of unsigned octets.
+ * This doesn't make too much sense. It seems that the original version of OER
+ * standard have been using the unconstrained unsigned integer as a quantity
+ * field, and this legacy have gone through ISO/ITU-T standardization process.
+ */
+static ssize_t
+oer_fetch_quantity(const void *ptr, size_t size, size_t *qty_r) {
+    const uint8_t *b;
+    const uint8_t *bend;
+    size_t len = 0;
+    size_t qty;
+
+    ssize_t len_len = oer_fetch_length(ptr, size, &len);
+    if(len_len <= 0) {
+        *qty_r = 0;
+        return len_len;
+    }
+
+    if((len_len + len) > size) {
+        *qty_r = 0;
+        return 0;
+    }
+
+    b = (const uint8_t *)ptr + len_len;
+    bend = b + len;
+
+    /* Skip the leading 0-bytes */
+    for(; b < bend && *b == 0; b++) {
+    }
+
+    if((bend - b) > (ssize_t)sizeof(size_t)) {
+        /* Length is not representable by the native size_t type */
+        *qty_r = 0;
+        return -1;
+    }
+
+    for(qty = 0; b < bend; b++) {
+        qty = (qty << 8) + *b;
+    }
+
+    if(qty > RSIZE_MAX) { /* A bit of C11 validation */
+        *qty_r = 0;
+        return -1;
+    }
+
+    *qty_r = qty;
+    assert((size_t)len_len + len == (size_t)(bend - (const uint8_t *)ptr));
+    return len_len + len;
+}
+
+asn_dec_rval_t
+SET_OF_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
+                  const asn_TYPE_descriptor_t *td,
+                  const asn_oer_constraints_t *constraints, void **struct_ptr,
+                  const void *ptr, size_t size) {
+    const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;
+    asn_dec_rval_t rval = {RC_OK, 0};
+    void *st = *struct_ptr; /* Target structure */
+    asn_struct_ctx_t *ctx; /* Decoder context */
+    size_t consumed_myself = 0; /* Consumed bytes from ptr. */
+
+    (void)constraints;
+
+    if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
+        ASN__DECODE_FAILED;
+
+    /*
+     * 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: {
+        /*
+         * Fetch number of elements to decode.
+         */
+        size_t length = 0;
+        size_t len_size = oer_fetch_quantity(ptr, size, &length);
+        switch(len_size) {
+        case 0:
+            RETURN(RC_WMORE);
+        case -1:
+            RETURN(RC_FAIL);
+        default:
+            ADVANCE(len_size);
+            ctx->left = length;
+        }
+    }
+        NEXT_PHASE(ctx);
+        /* FALL THROUGH */
+    case 1: {
+        /* Decode components of the extension root */
+        asn_TYPE_member_t *elm = td->elements;
+        asn_anonymous_set_ *list = _A_SET_FROM_VOID(st);
+        const void *base_ptr = ptr;
+        ber_tlv_len_t base_ctx_left = ctx->left;
+
+        assert(td->elements_count == 1);
+
+        ASN_DEBUG("OER SET OF %s Decoding PHASE 1", td->name);
+
+        for(; ctx->left > 0; ctx->left--) {
+            asn_dec_rval_t rv = elm->type->op->oer_decoder(
+                opt_codec_ctx, elm->type,
+                elm->encoding_constraints.oer_constraints, &ctx->ptr, ptr,
+                size);
+            ADVANCE(rv.consumed);
+            switch(rv.code) {
+            case RC_OK:
+                if(ASN_SET_ADD(list, ctx->ptr) != 0) {
+                    RETURN(RC_FAIL);
+                } else {
+                    ctx->ptr = 0;
+                    /*
+                     * This check is to avoid compression bomb with
+                     * specs like SEQUENCE/SET OF NULL which don't
+                     * consume data at all.
+                     */
+                    if(rv.consumed == 0 && base_ptr == ptr
+                       && (base_ctx_left - ctx->left) > 200) {
+                        ASN__DECODE_FAILED;
+                    }
+                    break;
+                }
+            case RC_WMORE:
+                RETURN(RC_WMORE);
+            case RC_FAIL:
+                ASN_STRUCT_FREE(*elm->type, ctx->ptr);
+                ctx->ptr = 0;
+                SET_PHASE(ctx, 3);
+                RETURN(RC_FAIL);
+            }
+        }
+        /* Decoded decently. */
+        NEXT_PHASE(ctx);
+    }
+        /* Fall through */
+    case 2:
+        /* Ignore fully decoded */
+        assert(ctx->left == 0);
+        RETURN(RC_OK);
+    case 3:
+        /* Failed to decode. */
+        RETURN(RC_FAIL);
+    }
+
+    return rval;
+}
+
+static ssize_t
+oer_put_quantity(size_t qty, asn_app_consume_bytes_f *cb, void *app_key) {
+    uint8_t buf[1 + sizeof(size_t)];
+    uint8_t *b = &buf[sizeof(size_t)]; /* Last addressable */
+    size_t encoded;
+
+    do {
+        *b-- = qty;
+        qty >>= 8;
+    } while(qty);
+
+    *b = sizeof(buf) - (b-buf) - 1;
+    encoded = sizeof(buf) - (b-buf);
+    if(cb(b, encoded, app_key) < 0)
+        return -1;
+    return encoded;
+}
+
+/*
+ * Encode as Canonical OER.
+ */
+asn_enc_rval_t
+SET_OF_encode_oer(const asn_TYPE_descriptor_t *td,
+                  const asn_oer_constraints_t *constraints, const void *sptr,
+                  asn_app_consume_bytes_f *cb, void *app_key) {
+    const asn_TYPE_member_t *elm;
+    const asn_anonymous_set_ *list;
+    size_t computed_size = 0;
+    ssize_t qty_len;
+    int n;
+
+    (void)constraints;
+
+    if(!sptr) ASN__ENCODE_FAILED;
+
+    elm = td->elements;
+    list = _A_CSET_FROM_VOID(sptr);
+
+    qty_len = oer_put_quantity(list->count, cb, app_key);
+    if(qty_len < 0) {
+        ASN__ENCODE_FAILED;
+    }
+    computed_size += qty_len;
+
+    for(n = 0; n < list->count; n++) {
+        void *memb_ptr = list->array[n];
+        asn_enc_rval_t er;
+        er = elm->type->op->oer_encoder(
+            elm->type, elm->encoding_constraints.oer_constraints, memb_ptr, cb,
+            app_key);
+        if(er.encoded < 0) {
+            return er;
+        } else {
+            computed_size += er.encoded;
+        }
+    }
+
+    {
+        asn_enc_rval_t erval;
+        erval.encoded = computed_size;
+        ASN__ENCODED_OK(erval);
+    }
+}
+
+#endif  /* ASN_DISABLE_OER_SUPPORT */
index 322f68c86c8bf35e5176da275f3c21c9df762303..aefaefdb718a315c68ec88f0ebcc49a4912d8b77 100644 (file)
@@ -26,29 +26,32 @@ asn_TYPE_outmost_tag(const asn_TYPE_descriptor_t *type_descriptor,
        if(type_descriptor->tags_count)
                return type_descriptor->tags[0];
 
        if(type_descriptor->tags_count)
                return type_descriptor->tags[0];
 
-       return type_descriptor->outmost_tag(type_descriptor, struct_ptr, 0, 0);
+       return type_descriptor->op->outmost_tag(type_descriptor, struct_ptr, 0, 0);
 }
 
 /*
  * Print the target language's structure in human readable form.
  */
 int
 }
 
 /*
  * Print the target language's structure in human readable form.
  */
 int
-asn_fprint(FILE *stream, asn_TYPE_descriptor_t *td, const void *struct_ptr) {
-       if(!stream) stream = stdout;
-       if(!td || !struct_ptr) {
-               errno = EINVAL;
-               return -1;
+asn_fprint(FILE *stream, const asn_TYPE_descriptor_t *td,
+           const void *struct_ptr) {
+    if(!stream) stream = stdout;
+    if(!td || !struct_ptr) {
+        errno = EINVAL;
+        return -1;
        }
 
        /* Invoke type-specific printer */
        }
 
        /* Invoke type-specific printer */
-       if(td->print_struct(td, struct_ptr, 1, _print2fp, stream))
-               return -1;
+    if(td->op->print_struct(td, struct_ptr, 1, _print2fp, stream)) {
+        return -1;
+    }
 
 
-       /* Terminate the output */
-       if(_print2fp("\n", 1, stream))
-               return -1;
+    /* Terminate the output */
+    if(_print2fp("\n", 1, stream)) {
+        return -1;
+    }
 
 
-       return fflush(stream);
+    return fflush(stream);
 }
 
 /* Dump the data into the specified stdio stream */
 }
 
 /* Dump the data into the specified stdio stream */
index 1bdda73e5d68cba8311e3fda444fd86d20865d2d..df3c6c194864596d9d816c0cba1933537e55d2fe 100644 (file)
@@ -1,11 +1,11 @@
-#include "asn_internal.h"
-#include "constraints.h"
+#include <asn_internal.h>
+#include <constraints.h>
 
 int
 
 int
-asn_generic_no_constraint(asn_TYPE_descriptor_t *type_descriptor,
-       const void *struct_ptr, asn_app_constraint_failed_f *cb, void *key) {
-
-       (void)type_descriptor;  /* Unused argument */
+asn_generic_no_constraint(const asn_TYPE_descriptor_t *type_descriptor,
+                          const void *struct_ptr,
+                          asn_app_constraint_failed_f *cb, void *key) {
+    (void)type_descriptor;     /* Unused argument */
        (void)struct_ptr;       /* Unused argument */
        (void)cb;       /* Unused argument */
        (void)key;      /* Unused argument */
        (void)struct_ptr;       /* Unused argument */
        (void)cb;       /* Unused argument */
        (void)key;      /* Unused argument */
@@ -15,10 +15,10 @@ asn_generic_no_constraint(asn_TYPE_descriptor_t *type_descriptor,
 }
 
 int
 }
 
 int
-asn_generic_unknown_constraint(asn_TYPE_descriptor_t *type_descriptor,
-       const void *struct_ptr, asn_app_constraint_failed_f *cb, void *key) {
-
-       (void)type_descriptor;  /* Unused argument */
+asn_generic_unknown_constraint(const asn_TYPE_descriptor_t *type_descriptor,
+                               const void *struct_ptr,
+                               asn_app_constraint_failed_f *cb, void *key) {
+    (void)type_descriptor;     /* Unused argument */
        (void)struct_ptr;       /* Unused argument */
        (void)cb;       /* Unused argument */
        (void)key;      /* Unused argument */
        (void)struct_ptr;       /* Unused argument */
        (void)cb;       /* Unused argument */
        (void)key;      /* Unused argument */
@@ -28,15 +28,16 @@ asn_generic_unknown_constraint(asn_TYPE_descriptor_t *type_descriptor,
 }
 
 struct errbufDesc {
 }
 
 struct errbufDesc {
-       asn_TYPE_descriptor_t *failed_type;
-       const void *failed_struct_ptr;
+    const asn_TYPE_descriptor_t *failed_type;
+    const void *failed_struct_ptr;
        char *errbuf;
        size_t errlen;
 };
 
 static void
        char *errbuf;
        size_t errlen;
 };
 
 static void
-_asn_i_ctfailcb(void *key, asn_TYPE_descriptor_t *td, const void *sptr, const char *fmt, ...) {
-       struct errbufDesc *arg = key;
+_asn_i_ctfailcb(void *key, const asn_TYPE_descriptor_t *td, const void *sptr,
+                const char *fmt, ...) {
+    struct errbufDesc *arg = key;
        va_list ap;
        ssize_t vlen;
        ssize_t maxlen;
        va_list ap;
        ssize_t vlen;
        ssize_t maxlen;
@@ -73,21 +74,20 @@ _asn_i_ctfailcb(void *key, asn_TYPE_descriptor_t *td, const void *sptr, const ch
 }
 
 int
 }
 
 int
-asn_check_constraints(asn_TYPE_descriptor_t *type_descriptor,
-               const void *struct_ptr, char *errbuf, size_t *errlen) {
-       struct errbufDesc arg;
-       int ret;
+asn_check_constraints(const asn_TYPE_descriptor_t *type_descriptor,
+                      const void *struct_ptr, char *errbuf, size_t *errlen) {
+    struct errbufDesc arg;
+    int ret;
 
 
-       arg.failed_type = 0;
-       arg.failed_struct_ptr = 0;
-       arg.errbuf = errbuf;
-       arg.errlen = errlen ? *errlen : 0;
+    arg.failed_type = 0;
+    arg.failed_struct_ptr = 0;
+    arg.errbuf = errbuf;
+    arg.errlen = errlen ? *errlen : 0;
 
 
-       ret = type_descriptor->check_constraints(type_descriptor,
-               struct_ptr, _asn_i_ctfailcb, &arg);
-       if(ret == -1 && errlen)
-               *errlen = arg.errlen;
+    ret = type_descriptor->encoding_constraints.general_constraints(
+        type_descriptor, struct_ptr, _asn_i_ctfailcb, &arg);
+    if(ret == -1 && errlen) *errlen = arg.errlen;
 
 
-       return ret;
+    return ret;
 }
 
 }
 
index 1c014802a8e815e1adac5b320e2fdc3dfd7c0256..2c6a6f769b92c34f9e5809d2d38bd1f3f40f69b3 100644 (file)
@@ -12,19 +12,17 @@ static ssize_t der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len,
  * The DER encoder of any type.
  */
 asn_enc_rval_t
  * The DER encoder of any type.
  */
 asn_enc_rval_t
-der_encode(asn_TYPE_descriptor_t *type_descriptor, void *struct_ptr,
-       asn_app_consume_bytes_f *consume_bytes, void *app_key) {
-
-       ASN_DEBUG("DER encoder invoked for %s",
+der_encode(const asn_TYPE_descriptor_t *type_descriptor, const void *struct_ptr,
+           asn_app_consume_bytes_f *consume_bytes, void *app_key) {
+    ASN_DEBUG("DER encoder invoked for %s",
                type_descriptor->name);
 
        /*
         * Invoke type-specific encoder.
         */
                type_descriptor->name);
 
        /*
         * Invoke type-specific encoder.
         */
-       return type_descriptor->der_encoder(type_descriptor,
-               struct_ptr,     /* Pointer to the destination structure */
-               0, 0,
-               consume_bytes, app_key);
+    return type_descriptor->op->der_encoder(
+        type_descriptor, struct_ptr, /* Pointer to the destination structure */
+        0, 0, consume_bytes, app_key);
 }
 
 /*
 }
 
 /*
@@ -51,15 +49,15 @@ static int encode_to_buffer_cb(const void *buffer, size_t size, void *key) {
  * A variant of the der_encode() which encodes the data into the provided buffer
  */
 asn_enc_rval_t
  * A variant of the der_encode() which encodes the data into the provided buffer
  */
 asn_enc_rval_t
-der_encode_to_buffer(asn_TYPE_descriptor_t *type_descriptor, void *struct_ptr,
-       void *buffer, size_t buffer_size) {
-       enc_to_buf_arg arg;
+der_encode_to_buffer(const asn_TYPE_descriptor_t *type_descriptor,
+                     const void *struct_ptr, void *buffer, size_t buffer_size) {
+    enc_to_buf_arg arg;
        asn_enc_rval_t ec;
 
        arg.buffer = buffer;
        arg.left = buffer_size;
 
        asn_enc_rval_t ec;
 
        arg.buffer = buffer;
        arg.left = buffer_size;
 
-       ec = type_descriptor->der_encoder(type_descriptor,
+       ec = type_descriptor->op->der_encoder(type_descriptor,
                struct_ptr,     /* Pointer to the destination structure */
                0, 0, encode_to_buffer_cb, &arg);
        if(ec.encoded != -1) {
                struct_ptr,     /* Pointer to the destination structure */
                0, 0, encode_to_buffer_cb, &arg);
        if(ec.encoded != -1) {
@@ -74,19 +72,20 @@ der_encode_to_buffer(asn_TYPE_descriptor_t *type_descriptor, void *struct_ptr,
  * Write out leading TL[v] sequence according to the type definition.
  */
 ssize_t
  * Write out leading TL[v] sequence according to the type definition.
  */
 ssize_t
-der_write_tags(asn_TYPE_descriptor_t *sd,
-               size_t struct_length,
-               int tag_mode, int last_tag_form,
-               ber_tlv_tag_t tag,      /* EXPLICIT or IMPLICIT tag */
-               asn_app_consume_bytes_f *cb,
-               void *app_key) {
-       const ber_tlv_tag_t *tags;      /* Copy of tags stream */
-       int tags_count;                 /* Number of tags */
-       size_t overall_length;
-       ssize_t *lens;
-       int i;
-
-       ASN_DEBUG("Writing tags (%s, tm=%d, tc=%d, tag=%s, mtc=%d)",
+der_write_tags(const asn_TYPE_descriptor_t *sd, size_t struct_length,
+               int tag_mode, int last_tag_form,
+               ber_tlv_tag_t tag, /* EXPLICIT or IMPLICIT tag */
+               asn_app_consume_bytes_f *cb, void *app_key) {
+#define ASN1_DER_MAX_TAGS_COUNT 4
+    ber_tlv_tag_t
+        tags_buf_scratch[ASN1_DER_MAX_TAGS_COUNT * sizeof(ber_tlv_tag_t)];
+    ssize_t lens[ASN1_DER_MAX_TAGS_COUNT * sizeof(ssize_t)];
+    const ber_tlv_tag_t *tags; /* Copy of tags stream */
+    int tags_count;            /* Number of tags */
+    size_t overall_length;
+    int i;
+
+    ASN_DEBUG("Writing tags (%s, tm=%d, tc=%d, tag=%s, mtc=%d)",
                sd->name, tag_mode, sd->tags_count,
                ber_tlv_tag_string(tag),
                tag_mode
                sd->name, tag_mode, sd->tags_count,
                ber_tlv_tag_string(tag),
                tag_mode
@@ -95,6 +94,11 @@ der_write_tags(asn_TYPE_descriptor_t *sd,
                        :sd->tags_count
        );
 
                        :sd->tags_count
        );
 
+    if(sd->tags_count + 1 > ASN1_DER_MAX_TAGS_COUNT) {
+        ASN_DEBUG("System limit %d on tags count", ASN1_DER_MAX_TAGS_COUNT);
+        return -1;
+    }
+
        if(tag_mode) {
                /*
                 * Instead of doing shaman dance like we do in ber_check_tags(),
        if(tag_mode) {
                /*
                 * Instead of doing shaman dance like we do in ber_check_tags(),
@@ -102,12 +106,7 @@ der_write_tags(asn_TYPE_descriptor_t *sd,
                 * and initialize it appropriately.
                 */
                int stag_offset;
                 * and initialize it appropriately.
                 */
                int stag_offset;
-               ber_tlv_tag_t *tags_buf;
-               tags_buf = (ber_tlv_tag_t *)alloca((sd->tags_count + 1) * sizeof(ber_tlv_tag_t));
-               if(!tags_buf) { /* Can fail on !x86 */
-                       errno = ENOMEM;
-                       return -1;
-               }
+               ber_tlv_tag_t *tags_buf = tags_buf_scratch;
                tags_count = sd->tags_count
                        + 1     /* EXPLICIT or IMPLICIT tag is given */
                        - ((tag_mode == -1) && sd->tags_count);
                tags_count = sd->tags_count
                        + 1     /* EXPLICIT or IMPLICIT tag is given */
                        - ((tag_mode == -1) && sd->tags_count);
@@ -126,12 +125,6 @@ der_write_tags(asn_TYPE_descriptor_t *sd,
        if(tags_count == 0)
                return 0;
 
        if(tags_count == 0)
                return 0;
 
-       lens = (ssize_t *)alloca(tags_count * sizeof(lens[0]));
-       if(!lens) {
-               errno = ENOMEM;
-               return -1;
-       }
-
        /*
         * Array of tags is initialized.
         * Now, compute the size of the TLV pairs, from right to left.
        /*
         * Array of tags is initialized.
         * Now, compute the size of the TLV pairs, from right to left.
@@ -146,8 +139,8 @@ der_write_tags(asn_TYPE_descriptor_t *sd,
 
        if(!cb) return overall_length - struct_length;
 
 
        if(!cb) return overall_length - struct_length;
 
-       ASN_DEBUG("%s %s TL sequence (%d elements)",
-               cb?"Encoding":"Estimating", sd->name, tags_count);
+       ASN_DEBUG("Encoding %s TL sequence (%d elements)", sd->name,
+                  tags_count);
 
        /*
         * Encode the TL sequence for real.
 
        /*
         * Encode the TL sequence for real.
index b7d92fa982654e31bae8ca4104080a6981030538..70d42a9e9f8729420d7a62209c588076905fb0c1 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef ASN_TYPE_ANY_H
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef ASN_TYPE_ANY_H
@@ -19,12 +19,24 @@ typedef struct ANY {
 } ANY_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_ANY;
 } ANY_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_ANY;
+extern asn_TYPE_operation_t asn_OP_ANY;
+extern asn_OCTET_STRING_specifics_t asn_SPC_ANY_specs;
 
 asn_struct_free_f ANY_free;
 asn_struct_print_f ANY_print;
 ber_type_decoder_f ANY_decode_ber;
 der_type_encoder_f ANY_encode_der;
 xer_type_encoder_f ANY_encode_xer;
 
 asn_struct_free_f ANY_free;
 asn_struct_print_f ANY_print;
 ber_type_decoder_f ANY_decode_ber;
 der_type_encoder_f ANY_encode_der;
 xer_type_encoder_f ANY_encode_xer;
+per_type_decoder_f ANY_decode_uper;
+per_type_encoder_f ANY_encode_uper;
+
+#define ANY_free         OCTET_STRING_free
+#define ANY_print        OCTET_STRING_print
+#define ANY_compare      OCTET_STRING_compare
+#define ANY_constraint   asn_generic_no_constraint
+#define ANY_decode_ber   OCTET_STRING_decode_ber
+#define ANY_encode_der   OCTET_STRING_encode_der
+#define ANY_decode_xer   OCTET_STRING_decode_xer_hex
 
 /******************************
  * Handy conversion routines. *
 
 /******************************
  * Handy conversion routines. *
index a0f375455e0868ece995c06ba944d5f1899f6c3d..c1f36cabec7a343954db0029607d76785f77c223 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _ApplicationSyntax_H_
  */
 
 #ifndef        _ApplicationSyntax_H_
@@ -50,6 +50,9 @@ typedef struct ApplicationSyntax {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_ApplicationSyntax;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_ApplicationSyntax;
+extern asn_CHOICE_specifics_t asn_SPC_ApplicationSyntax_specs_1;
+extern asn_TYPE_member_t asn_MBR_ApplicationSyntax_1[5];
+extern asn_per_constraints_t asn_PER_type_ApplicationSyntax_constr_1;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index d07e8e94c8f25bcf50cd0ec8caa4c6abebb30b05..d45b915c74a406f252a26c5c4449b6581f07fed0 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _AtEntry_H_
  */
 
 #ifndef        _AtEntry_H_
index 732e878bcad1694e685153934afd8ce91f869e83..bd2d23db01f5c1c89a80700291135c1c00cff0ff 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _BIT_STRING_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _BIT_STRING_H_
@@ -13,7 +13,7 @@ extern "C" {
 
 typedef struct BIT_STRING_s {
        uint8_t *buf;   /* BIT STRING body */
 
 typedef struct BIT_STRING_s {
        uint8_t *buf;   /* BIT STRING body */
-       int size;       /* Size of the above buffer */
+       size_t size;    /* Size of the above buffer */
 
        int bits_unused;/* Unused trailing bits in the last octet (0..7) */
 
 
        int bits_unused;/* Unused trailing bits in the last octet (0..7) */
 
@@ -21,10 +21,23 @@ typedef struct BIT_STRING_s {
 } BIT_STRING_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
 } BIT_STRING_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
+extern asn_TYPE_operation_t asn_OP_BIT_STRING;
+extern asn_OCTET_STRING_specifics_t asn_SPC_BIT_STRING_specs;
 
 asn_struct_print_f BIT_STRING_print;   /* Human-readable output */
 
 asn_struct_print_f BIT_STRING_print;   /* Human-readable output */
+asn_struct_compare_f BIT_STRING_compare;
 asn_constr_check_f BIT_STRING_constraint;
 xer_type_encoder_f BIT_STRING_encode_xer;
 asn_constr_check_f BIT_STRING_constraint;
 xer_type_encoder_f BIT_STRING_encode_xer;
+oer_type_decoder_f BIT_STRING_decode_oer;
+oer_type_encoder_f BIT_STRING_encode_oer;
+per_type_decoder_f BIT_STRING_decode_uper;
+per_type_encoder_f BIT_STRING_encode_uper;
+asn_random_fill_f  BIT_STRING_random_fill;
+
+#define BIT_STRING_free              OCTET_STRING_free
+#define BIT_STRING_decode_ber        OCTET_STRING_decode_ber
+#define BIT_STRING_encode_der        OCTET_STRING_encode_der
+#define BIT_STRING_decode_xer        OCTET_STRING_decode_xer_binary
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
diff --git a/libs/smux/include/stg/BOOLEAN.h b/libs/smux/include/stg/BOOLEAN.h
deleted file mode 100644 (file)
index 217d0f1..0000000
+++ /dev/null
@@ -1,36 +0,0 @@
-/*-
- * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * Redistribution and modifications are permitted subject to BSD license.
- */
-#ifndef        _BOOLEAN_H_
-#define        _BOOLEAN_H_
-
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * The underlying integer may contain various values, but everything
- * non-zero is capped to 0xff by the DER encoder. The BER decoder may
- * yield non-zero values different from 1, beware.
- */
-typedef int BOOLEAN_t;
-
-extern asn_TYPE_descriptor_t asn_DEF_BOOLEAN;
-
-asn_struct_free_f BOOLEAN_free;
-asn_struct_print_f BOOLEAN_print;
-ber_type_decoder_f BOOLEAN_decode_ber;
-der_type_encoder_f BOOLEAN_encode_der;
-xer_type_decoder_f BOOLEAN_decode_xer;
-xer_type_encoder_f BOOLEAN_encode_xer;
-per_type_decoder_f BOOLEAN_decode_uper;
-per_type_encoder_f BOOLEAN_encode_uper;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _BOOLEAN_H_ */
index 0e90b6c4458a08728e932d647538e4dfb38769f6..e5d209c616ce0064d43af9620581f87ce85a4dac 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _ClosePDU_H_
  */
 
 #ifndef        _ClosePDU_H_
@@ -40,6 +40,10 @@ ber_type_decoder_f ClosePDU_decode_ber;
 der_type_encoder_f ClosePDU_encode_der;
 xer_type_decoder_f ClosePDU_decode_xer;
 xer_type_encoder_f ClosePDU_encode_xer;
 der_type_encoder_f ClosePDU_encode_der;
 xer_type_decoder_f ClosePDU_decode_xer;
 xer_type_encoder_f ClosePDU_encode_xer;
+oer_type_decoder_f ClosePDU_decode_oer;
+oer_type_encoder_f ClosePDU_encode_oer;
+per_type_decoder_f ClosePDU_decode_uper;
+per_type_encoder_f ClosePDU_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 3b7b76998b35437756f2c6e992da8ee2b20c6c11..cecde4a26b29f4f8bc79d33c841e626b958a2465 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _Counter_H_
  */
 
 #ifndef        _Counter_H_
@@ -22,7 +22,9 @@ extern "C" {
 typedef unsigned long   Counter_t;
 
 /* Implementation */
 typedef unsigned long   Counter_t;
 
 /* Implementation */
+extern asn_per_constraints_t asn_PER_type_Counter_constr_1;
 extern asn_TYPE_descriptor_t asn_DEF_Counter;
 extern asn_TYPE_descriptor_t asn_DEF_Counter;
+extern const asn_INTEGER_specifics_t asn_SPC_Counter_specs_1;
 asn_struct_free_f Counter_free;
 asn_struct_print_f Counter_print;
 asn_constr_check_f Counter_constraint;
 asn_struct_free_f Counter_free;
 asn_struct_print_f Counter_print;
 asn_constr_check_f Counter_constraint;
@@ -30,6 +32,10 @@ ber_type_decoder_f Counter_decode_ber;
 der_type_encoder_f Counter_encode_der;
 xer_type_decoder_f Counter_decode_xer;
 xer_type_encoder_f Counter_encode_xer;
 der_type_encoder_f Counter_encode_der;
 xer_type_decoder_f Counter_decode_xer;
 xer_type_encoder_f Counter_encode_xer;
+oer_type_decoder_f Counter_decode_oer;
+oer_type_encoder_f Counter_encode_oer;
+per_type_decoder_f Counter_decode_uper;
+per_type_encoder_f Counter_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 0be1c6cb6b23c38e7a6dcb43ac39167a78fbebf1..c676dacc295be252d1a98df3baed368a686e453c 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _DisplayString_H_
  */
 
 #ifndef        _DisplayString_H_
@@ -30,6 +30,10 @@ ber_type_decoder_f DisplayString_decode_ber;
 der_type_encoder_f DisplayString_encode_der;
 xer_type_decoder_f DisplayString_decode_xer;
 xer_type_encoder_f DisplayString_encode_xer;
 der_type_encoder_f DisplayString_encode_der;
 xer_type_decoder_f DisplayString_decode_xer;
 xer_type_encoder_f DisplayString_encode_xer;
+oer_type_decoder_f DisplayString_decode_oer;
+oer_type_encoder_f DisplayString_encode_oer;
+per_type_decoder_f DisplayString_decode_uper;
+per_type_encoder_f DisplayString_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 422ce2df32821b29740b74bb166540f1b82f6ce3..afbb1daefce919768a94ee6a87f3ca4d1bd8ddd7 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _EgpNeighEntry_H_
  */
 
 #ifndef        _EgpNeighEntry_H_
index 1fba79e9a5a79354e60f0c70aa448cd345411841..c5c6d21ef6df32dddbf484167d1b6fb1384e2669 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _Gauge_H_
  */
 
 #ifndef        _Gauge_H_
@@ -22,7 +22,9 @@ extern "C" {
 typedef unsigned long   Gauge_t;
 
 /* Implementation */
 typedef unsigned long   Gauge_t;
 
 /* Implementation */
+extern asn_per_constraints_t asn_PER_type_Gauge_constr_1;
 extern asn_TYPE_descriptor_t asn_DEF_Gauge;
 extern asn_TYPE_descriptor_t asn_DEF_Gauge;
+extern const asn_INTEGER_specifics_t asn_SPC_Gauge_specs_1;
 asn_struct_free_f Gauge_free;
 asn_struct_print_f Gauge_print;
 asn_constr_check_f Gauge_constraint;
 asn_struct_free_f Gauge_free;
 asn_struct_print_f Gauge_print;
 asn_constr_check_f Gauge_constraint;
@@ -30,6 +32,10 @@ ber_type_decoder_f Gauge_decode_ber;
 der_type_encoder_f Gauge_encode_der;
 xer_type_decoder_f Gauge_decode_xer;
 xer_type_encoder_f Gauge_encode_xer;
 der_type_encoder_f Gauge_encode_der;
 xer_type_decoder_f Gauge_decode_xer;
 xer_type_encoder_f Gauge_encode_xer;
+oer_type_decoder_f Gauge_decode_oer;
+oer_type_encoder_f Gauge_encode_oer;
+per_type_decoder_f Gauge_decode_uper;
+per_type_encoder_f Gauge_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index cecfd5aed57bb2bb5e5296d6d9c9d41553935ecc..7eed8d0e57c82a67a54f55b114fcff91067fa73b 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _GetNextRequest_PDU_H_
  */
 
 #ifndef        _GetNextRequest_PDU_H_
@@ -30,6 +30,10 @@ ber_type_decoder_f GetNextRequest_PDU_decode_ber;
 der_type_encoder_f GetNextRequest_PDU_encode_der;
 xer_type_decoder_f GetNextRequest_PDU_decode_xer;
 xer_type_encoder_f GetNextRequest_PDU_encode_xer;
 der_type_encoder_f GetNextRequest_PDU_encode_der;
 xer_type_decoder_f GetNextRequest_PDU_decode_xer;
 xer_type_encoder_f GetNextRequest_PDU_encode_xer;
+oer_type_decoder_f GetNextRequest_PDU_decode_oer;
+oer_type_encoder_f GetNextRequest_PDU_encode_oer;
+per_type_decoder_f GetNextRequest_PDU_decode_uper;
+per_type_encoder_f GetNextRequest_PDU_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 872c5a2e56ce55b4f8f07ce8403c4e7a874a369a..ff4d88c7707fba28eaedc4f62492330400af8fa8 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _GetRequest_PDU_H_
  */
 
 #ifndef        _GetRequest_PDU_H_
@@ -30,6 +30,10 @@ ber_type_decoder_f GetRequest_PDU_decode_ber;
 der_type_encoder_f GetRequest_PDU_encode_der;
 xer_type_decoder_f GetRequest_PDU_decode_xer;
 xer_type_encoder_f GetRequest_PDU_encode_xer;
 der_type_encoder_f GetRequest_PDU_encode_der;
 xer_type_decoder_f GetRequest_PDU_decode_xer;
 xer_type_encoder_f GetRequest_PDU_encode_xer;
+oer_type_decoder_f GetRequest_PDU_decode_oer;
+oer_type_encoder_f GetRequest_PDU_encode_oer;
+per_type_decoder_f GetRequest_PDU_decode_uper;
+per_type_encoder_f GetRequest_PDU_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index b154ea3da681d8150dc39e875ec755dccedb3657..00997bbc17512e9518bedde01b6c8d1bf1752d78 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _GetResponse_PDU_H_
  */
 
 #ifndef        _GetResponse_PDU_H_
@@ -30,6 +30,10 @@ ber_type_decoder_f GetResponse_PDU_decode_ber;
 der_type_encoder_f GetResponse_PDU_encode_der;
 xer_type_decoder_f GetResponse_PDU_decode_xer;
 xer_type_encoder_f GetResponse_PDU_encode_xer;
 der_type_encoder_f GetResponse_PDU_encode_der;
 xer_type_decoder_f GetResponse_PDU_decode_xer;
 xer_type_encoder_f GetResponse_PDU_encode_xer;
+oer_type_decoder_f GetResponse_PDU_decode_oer;
+oer_type_encoder_f GetResponse_PDU_encode_oer;
+per_type_decoder_f GetResponse_PDU_decode_uper;
+per_type_encoder_f GetResponse_PDU_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 9a88097075770e27d522e5ee35c4cb9a61e654c3..cc760ffa9de5e3d502a185248a4fa05f8e8e70de 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _INTEGER_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _INTEGER_H_
@@ -15,6 +15,7 @@ extern "C" {
 typedef ASN__PRIMITIVE_TYPE_t INTEGER_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_INTEGER;
 typedef ASN__PRIMITIVE_TYPE_t INTEGER_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_INTEGER;
+extern asn_TYPE_operation_t asn_OP_INTEGER;
 
 /* Map with <tag> to integer value association */
 typedef struct asn_INTEGER_enum_map_s {
 
 /* Map with <tag> to integer value association */
 typedef struct asn_INTEGER_enum_map_s {
@@ -24,7 +25,7 @@ typedef struct asn_INTEGER_enum_map_s {
 } asn_INTEGER_enum_map_t;
 
 /* This type describes an enumeration for INTEGER and ENUMERATED types */
 } asn_INTEGER_enum_map_t;
 
 /* This type describes an enumeration for INTEGER and ENUMERATED types */
-typedef const struct asn_INTEGER_specifics_s {
+typedef struct asn_INTEGER_specifics_s {
        const asn_INTEGER_enum_map_t *value2enum;       /* N -> "tag"; sorted by N */
        const unsigned int *enum2value;         /* "tag" => N; sorted by tag */
        int map_count;                          /* Elements in either map */
        const asn_INTEGER_enum_map_t *value2enum;       /* N -> "tag"; sorted by N */
        const unsigned int *enum2value;         /* "tag" => N; sorted by tag */
        int map_count;                          /* Elements in either map */
@@ -34,46 +35,67 @@ typedef const struct asn_INTEGER_specifics_s {
        int field_unsigned;                     /* Signed=0, unsigned=1 */
 } asn_INTEGER_specifics_t;
 
        int field_unsigned;                     /* Signed=0, unsigned=1 */
 } asn_INTEGER_specifics_t;
 
+#define INTEGER_free    ASN__PRIMITIVE_TYPE_free
+#define INTEGER_decode_ber     ber_decode_primitive
+#define INTEGER_constraint     asn_generic_no_constraint
 asn_struct_print_f INTEGER_print;
 asn_struct_print_f INTEGER_print;
-ber_type_decoder_f INTEGER_decode_ber;
+asn_struct_compare_f INTEGER_compare;
 der_type_encoder_f INTEGER_encode_der;
 xer_type_decoder_f INTEGER_decode_xer;
 xer_type_encoder_f INTEGER_encode_xer;
 der_type_encoder_f INTEGER_encode_der;
 xer_type_decoder_f INTEGER_decode_xer;
 xer_type_encoder_f INTEGER_encode_xer;
+oer_type_decoder_f INTEGER_decode_oer;
+oer_type_encoder_f INTEGER_encode_oer;
 per_type_decoder_f INTEGER_decode_uper;
 per_type_encoder_f INTEGER_encode_uper;
 per_type_decoder_f INTEGER_decode_uper;
 per_type_encoder_f INTEGER_encode_uper;
+asn_random_fill_f  INTEGER_random_fill;
 
 /***********************************
  * Some handy conversion routines. *
  ***********************************/
 
 /*
 
 /***********************************
  * Some handy conversion routines. *
  ***********************************/
 
 /*
+ * Natiwe size-independent conversion of native integers to/from INTEGER.
+ * (l_size) is in bytes.
  * 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
  * 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()).
+ * -1/ENOMEM: Memory allocation failed (in asn_*2INTEGER()).
+ */
+int asn_INTEGER2imax(const INTEGER_t *i, intmax_t *l);
+int asn_INTEGER2umax(const INTEGER_t *i, uintmax_t *l);
+int asn_imax2INTEGER(INTEGER_t *i, intmax_t l);
+int asn_umax2INTEGER(INTEGER_t *i, uintmax_t l);
+
+/*
+ * Size-specific conversion helpers.
  */
 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);
 
  */
 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 */
+/* A version of strtol/strtoimax(3) with nicer error reporting. */
+enum asn_strtox_result_e {
+    ASN_STRTOX_ERROR_RANGE = -3,  /* Input outside of supported numeric range */
+    ASN_STRTOX_ERROR_INVAL = -2,  /* Invalid data encountered (e.g., "+-") */
+    ASN_STRTOX_EXPECT_MORE = -1,  /* More data expected (e.g. "+") */
+    ASN_STRTOX_OK          =  0,  /* Conversion succeded, number ends at (*end) */
+    ASN_STRTOX_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);
+enum asn_strtox_result_e asn_strtol_lim(const char *str, const char **end,
+                                        long *l);
+enum asn_strtox_result_e asn_strtoul_lim(const char *str, const char **end,
+                                         unsigned long *l);
+enum asn_strtox_result_e asn_strtoimax_lim(const char *str, const char **end,
+                                           intmax_t *l);
+enum asn_strtox_result_e asn_strtoumax_lim(const char *str, const char **end,
+                                           uintmax_t *l);
 
 /*
  * Convert the integer value into the corresponding enumeration map entry.
  */
 
 /*
  * 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);
+const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(
+    const asn_INTEGER_specifics_t *specs, long value);
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 9fdd9477c9ca23ae74d1b96d2ca3ffd5c3d07e0f..dba4236871acb1bc838ee8435d51897d2b21f64c 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _IfEntry_H_
  */
 
 #ifndef        _IfEntry_H_
index 0a44b3cb4e3b85bc7d9323b1dc2cfb5f8484e945..3108892538f13c4fb0db964343668ad8a525c3f1 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _IpAddrEntry_H_
  */
 
 #ifndef        _IpAddrEntry_H_
index 544cb40c41eea498c69e051a7b0aa13252a277a1..99521e0111c92f9164bff7b75365466e4a3bdba2 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _IpAddress_H_
  */
 
 #ifndef        _IpAddress_H_
@@ -22,6 +22,7 @@ extern "C" {
 typedef OCTET_STRING_t  IpAddress_t;
 
 /* Implementation */
 typedef OCTET_STRING_t  IpAddress_t;
 
 /* Implementation */
+extern asn_per_constraints_t asn_PER_type_IpAddress_constr_1;
 extern asn_TYPE_descriptor_t asn_DEF_IpAddress;
 asn_struct_free_f IpAddress_free;
 asn_struct_print_f IpAddress_print;
 extern asn_TYPE_descriptor_t asn_DEF_IpAddress;
 asn_struct_free_f IpAddress_free;
 asn_struct_print_f IpAddress_print;
@@ -30,6 +31,10 @@ ber_type_decoder_f IpAddress_decode_ber;
 der_type_encoder_f IpAddress_encode_der;
 xer_type_decoder_f IpAddress_decode_xer;
 xer_type_encoder_f IpAddress_encode_xer;
 der_type_encoder_f IpAddress_encode_der;
 xer_type_decoder_f IpAddress_decode_xer;
 xer_type_encoder_f IpAddress_encode_xer;
+oer_type_decoder_f IpAddress_decode_oer;
+oer_type_encoder_f IpAddress_encode_oer;
+per_type_decoder_f IpAddress_decode_uper;
+per_type_encoder_f IpAddress_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index ca72bff6bff5068b60cab55d04b3162d4979a26e..f795d7fb041b056e175b54b60e9dbb0e235f2f96 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _IpNetToMediaEntry_H_
  */
 
 #ifndef        _IpNetToMediaEntry_H_
index 28030dcb24b9d61aa6cc55e5afecb8cd1172cbb1..999e34219d35d8c3f8f86892d46fde22a5714e1a 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _IpRouteEntry_H_
  */
 
 #ifndef        _IpRouteEntry_H_
index 3049e4771af22d5841fb4fee72ad745fbfdadd40..51aba78982d7aef6458de7a9e3ee096dd795807a 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _Message_H_
  */
 
 #ifndef        _Message_H_
index 131e775926122ab539ccbaec39ed92db67fe6af0..c8e05d23159aaec52e99d073ae43e184b92c1605 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN_TYPE_NULL_H
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN_TYPE_NULL_H
@@ -12,19 +12,28 @@ extern "C" {
 #endif
 
 /*
 #endif
 
 /*
- * The value of the NULL type is meaningless: see BOOLEAN if you want to
- * carry true/false semantics.
+ * The value of the NULL type is meaningless.
+ * Use the BOOLEAN type if you need to carry true/false semantics.
  */
 typedef int NULL_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_NULL;
  */
 typedef int NULL_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_NULL;
+extern asn_TYPE_operation_t asn_OP_NULL;
 
 
+asn_struct_free_f NULL_free;
 asn_struct_print_f NULL_print;
 asn_struct_print_f NULL_print;
+asn_struct_compare_f NULL_compare;
+ber_type_decoder_f NULL_decode_ber;
 der_type_encoder_f NULL_encode_der;
 xer_type_decoder_f NULL_decode_xer;
 xer_type_encoder_f NULL_encode_xer;
 der_type_encoder_f NULL_encode_der;
 xer_type_decoder_f NULL_decode_xer;
 xer_type_encoder_f NULL_encode_xer;
+oer_type_decoder_f NULL_decode_oer;
+oer_type_encoder_f NULL_encode_oer;
 per_type_decoder_f NULL_decode_uper;
 per_type_encoder_f NULL_encode_uper;
 per_type_decoder_f NULL_decode_uper;
 per_type_encoder_f NULL_encode_uper;
+asn_random_fill_f  NULL_random_fill;
+
+#define NULL_constraint        asn_generic_no_constraint
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
diff --git a/libs/smux/include/stg/NativeEnumerated.h b/libs/smux/include/stg/NativeEnumerated.h
deleted file mode 100644 (file)
index c59bb1b..0000000
+++ /dev/null
@@ -1,32 +0,0 @@
-/*-
- * 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_ */
index 4e63a8355d12b7c90ce53a23a43cb5583f811257..e2741c201f2b0ff12c74c844a10bec4a10629082 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 /*
  * Redistribution and modifications are permitted subject to BSD license.
  */
 /*
@@ -20,15 +20,22 @@ extern "C" {
 #endif
 
 extern asn_TYPE_descriptor_t asn_DEF_NativeInteger;
 #endif
 
 extern asn_TYPE_descriptor_t asn_DEF_NativeInteger;
+extern asn_TYPE_operation_t asn_OP_NativeInteger;
 
 asn_struct_free_f  NativeInteger_free;
 asn_struct_print_f NativeInteger_print;
 
 asn_struct_free_f  NativeInteger_free;
 asn_struct_print_f NativeInteger_print;
+asn_struct_compare_f NativeInteger_compare;
 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;
 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;
+oer_type_decoder_f NativeInteger_decode_oer;
+oer_type_encoder_f NativeInteger_encode_oer;
 per_type_decoder_f NativeInteger_decode_uper;
 per_type_encoder_f NativeInteger_encode_uper;
 per_type_decoder_f NativeInteger_decode_uper;
 per_type_encoder_f NativeInteger_encode_uper;
+asn_random_fill_f  NativeInteger_random_fill;
+
+#define NativeInteger_constraint  asn_generic_no_constraint
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 8bcba17d85eca2f25bc7be11a20e608bfc742b80..f3ba6a69a4238ecfc243f8770b3ed3cc39167b1e 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _NetworkAddress_H_
  */
 
 #ifndef        _NetworkAddress_H_
@@ -38,6 +38,9 @@ typedef struct NetworkAddress {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_NetworkAddress;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_NetworkAddress;
+extern asn_CHOICE_specifics_t asn_SPC_NetworkAddress_specs_1;
+extern asn_TYPE_member_t asn_MBR_NetworkAddress_1[1];
+extern asn_per_constraints_t asn_PER_type_NetworkAddress_constr_1;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index c2c6373e3bc26ff9e6efcf1227525b2a75fc8f6e..aa0d5c7084ec092f1ce420e4417e637c222df7d0 100644 (file)
@@ -1,6 +1,5 @@
-/*-
- * Copyright (c) 2003, 2004, 2005 Lev Walkin <vlm@lionet.info>.
- *     All rights reserved.
+/*
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _OBJECT_IDENTIFIER_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _OBJECT_IDENTIFIER_H_
@@ -8,70 +7,80 @@
 
 #include <asn_application.h>
 #include <asn_codecs_prim.h>
 
 #include <asn_application.h>
 #include <asn_codecs_prim.h>
+#include <OCTET_STRING.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+typedef uint32_t asn_oid_arc_t;
+#define ASN_OID_ARC_MAX (~((asn_oid_arc_t)0))
+
 typedef ASN__PRIMITIVE_TYPE_t OBJECT_IDENTIFIER_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER;
 typedef ASN__PRIMITIVE_TYPE_t OBJECT_IDENTIFIER_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER;
+extern asn_TYPE_operation_t asn_OP_OBJECT_IDENTIFIER;
 
 asn_struct_print_f OBJECT_IDENTIFIER_print;
 asn_constr_check_f OBJECT_IDENTIFIER_constraint;
 der_type_encoder_f OBJECT_IDENTIFIER_encode_der;
 xer_type_decoder_f OBJECT_IDENTIFIER_decode_xer;
 xer_type_encoder_f OBJECT_IDENTIFIER_encode_xer;
 
 asn_struct_print_f OBJECT_IDENTIFIER_print;
 asn_constr_check_f OBJECT_IDENTIFIER_constraint;
 der_type_encoder_f OBJECT_IDENTIFIER_encode_der;
 xer_type_decoder_f OBJECT_IDENTIFIER_decode_xer;
 xer_type_encoder_f OBJECT_IDENTIFIER_encode_xer;
+asn_random_fill_f  OBJECT_IDENTIFIER_random_fill;
+
+#define OBJECT_IDENTIFIER_free           ASN__PRIMITIVE_TYPE_free
+#define OBJECT_IDENTIFIER_compare        OCTET_STRING_compare
+#define OBJECT_IDENTIFIER_decode_ber     ber_decode_primitive
+#define OBJECT_IDENTIFIER_encode_der     der_encode_primitive
+#define OBJECT_IDENTIFIER_decode_oer     oer_decode_primitive
+#define OBJECT_IDENTIFIER_encode_oer     oer_encode_primitive
+#define OBJECT_IDENTIFIER_decode_uper    OCTET_STRING_decode_uper
+#define OBJECT_IDENTIFIER_encode_uper    OCTET_STRING_encode_uper
 
 /**********************************
  * Some handy conversion routines *
  **********************************/
 
 /*
 
 /**********************************
  * Some handy conversion routines *
  **********************************/
 
 /*
- * This function fills an (_arcs) array with OBJECT IDENTIFIER arcs
- * up to specified (_arc_slots) elements.
- * 
+ * This function fills an (arcs) array with OBJECT IDENTIFIER arcs
+ * up to specified (arc_slots) elements.
+ *
  * EXAMPLE:
  *     void print_arcs(OBJECT_IDENTIFIER_t *oid) {
  * EXAMPLE:
  *     void print_arcs(OBJECT_IDENTIFIER_t *oid) {
- *             unsigned long fixed_arcs[10];   // Try with fixed space first
- *             unsigned long *arcs = fixed_arcs;
- *             int arc_type_size = sizeof(fixed_arcs[0]);      // sizeof(long)
- *             int arc_slots = sizeof(fixed_arcs)/sizeof(fixed_arcs[0]); // 10
- *             int count;      // Real number of arcs.
+ *             asn_oid_arc_t fixed_arcs[10];   // Try with fixed space first
+ *             asn_oid_arc_t *arcs = fixed_arcs;
+ *             size_t arc_slots = sizeof(fixed_arcs)/sizeof(fixed_arcs[0]); // 10
+ *             ssize_t count;  // Real number of arcs.
  *             int i;
  *             int i;
- * 
- *             count = OBJECT_IDENTIFIER_get_arcs(oid, arcs,
- *                     arc_type_size, arc_slots);
+ *
+ *             count = OBJECT_IDENTIFIER_get_arcs(oid, arcs, arc_slots);
  *             // If necessary, reallocate arcs array and try again.
  *             if(count > arc_slots) {
  *                     arc_slots = count;
  *             // If necessary, reallocate arcs array and try again.
  *             if(count > arc_slots) {
  *                     arc_slots = count;
- *                     arcs = malloc(arc_type_size * arc_slots);
+ *                     arcs = malloc(sizeof(asn_oid_arc_t) * arc_slots);
  *                     if(!arcs) return;
  *                     if(!arcs) return;
- *                     count = OBJECT_IDENTIFIER_get_arcs(oid, arcs,
- *                             arc_type_size, arc_slots);
+ *                     count = OBJECT_IDENTIFIER_get_arcs(oid, arcs, arc_slots);
  *                     assert(count == arc_slots);
  *             }
  *                     assert(count == arc_slots);
  *             }
- * 
+ *
  *             // Print the contents of the arcs array.
  *             for(i = 0; i < count; i++)
  *             // Print the contents of the arcs array.
  *             for(i = 0; i < count; i++)
- *                     printf("%d\n", arcs[i]);
- * 
+ *                     printf("%"PRIu32"\n", arcs[i]);
+ *
  *             // Avoid memory leak.
  *             if(arcs != fixed_arcs) free(arcs);
  *     }
  *             // Avoid memory leak.
  *             if(arcs != fixed_arcs) free(arcs);
  *     }
- * 
+ *
  * RETURN VALUES:
  * -1/EINVAL:  Invalid arguments (oid is missing)
  * -1/ERANGE:  One or more arcs have value out of array cell type range.
  * >=0:                Number of arcs contained in the OBJECT IDENTIFIER
  * RETURN VALUES:
  * -1/EINVAL:  Invalid arguments (oid is missing)
  * -1/ERANGE:  One or more arcs have value out of array cell type range.
  * >=0:                Number of arcs contained in the OBJECT IDENTIFIER
- * 
- * WARNING: The function always returns the real number of arcs,
- * even if there is no sufficient (_arc_slots) provided.
+ *
+ * WARNING: The function always returns the actual number of arcs,
+ * even if there is no sufficient (arc_slots) provided.
  */
  */
-int OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *_oid,
-       void *_arcs,                    /* e.g., unsigned int arcs[N] */
-       unsigned int _arc_type_size,    /* e.g., sizeof(arcs[0]) */
-       unsigned int _arc_slots         /* e.g., N */);
+ssize_t OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *oid,
+                                   asn_oid_arc_t *arcs, size_t arc_slots);
 
 /*
  * This functions initializes the OBJECT IDENTIFIER object with
 
 /*
  * This functions initializes the OBJECT IDENTIFIER object with
@@ -83,25 +92,13 @@ int OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *_oid,
  * -1/ENOMEM:  Memory allocation failed
  * 0:          The object was initialized with new arcs.
  */
  * -1/ENOMEM:  Memory allocation failed
  * 0:          The object was initialized with new arcs.
  */
-int OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *_oid,
-       const void *_arcs,              /* e.g., unsigned int arcs[N] */
-       unsigned int _arc_type_size,    /* e.g., sizeof(arcs[0]) */
-       unsigned int _arc_slots         /* e.g., N */);
+int OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *oid,
+                               const asn_oid_arc_t *arcs, size_t arcs_count);
 
 
-/*
- * Print the specified OBJECT IDENTIFIER arc.
- */
-int OBJECT_IDENTIFIER_print_arc(const uint8_t *arcbuf, int arclen,
-       int add, /* Arbitrary offset, required to process the first two arcs */
-       asn_app_consume_bytes_f *cb, void *app_key);
-
-/* Same as above, but returns the number of written digits, instead of 0 */
-ssize_t OBJECT_IDENTIFIER__dump_arc(const uint8_t *arcbuf, int arclen, int add,
-       asn_app_consume_bytes_f *cb, void *app_key);
 
 /*
  * Parse the OBJECT IDENTIFIER textual representation ("1.3.6.1.4.1.9363").
 
 /*
  * Parse the OBJECT IDENTIFIER textual representation ("1.3.6.1.4.1.9363").
- * No arc can exceed the (0..signed_long_max) range (typically, 0..2G if L32).
+ * No arc can exceed the (0..ASN_OID_ARC_MAX, which is the same as UINT32_MAX).
  * This function is not specific to OBJECT IDENTIFIER, it may be used to parse
  * the RELATIVE-OID data, or any other data consisting of dot-separated
  * series of numeric values.
  * This function is not specific to OBJECT IDENTIFIER, it may be used to parse
  * the RELATIVE-OID data, or any other data consisting of dot-separated
  * series of numeric values.
@@ -117,20 +114,38 @@ ssize_t OBJECT_IDENTIFIER__dump_arc(const uint8_t *arcbuf, int arclen, int add,
  * >= 0:       Number of arcs contained in the OBJECT IDENTIFIER.
  * 
  * WARNING: The function always returns the real number of arcs,
  * >= 0:       Number of arcs contained in the OBJECT IDENTIFIER.
  * 
  * WARNING: The function always returns the real number of arcs,
- * even if there is no sufficient (_arc_slots) provided.
- * This is useful for (_arc_slots) value estimation.
+ * even if there is no sufficient (arc_slots) provided.
+ * This is useful for (arc_slots) value estimation.
  */
  */
-int OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
-       long arcs[], unsigned int arcs_slots, const char **opt_oid_text_end);
+ssize_t OBJECT_IDENTIFIER_parse_arcs(const char *oid_text,
+                                     ssize_t oid_txt_length,
+                                     asn_oid_arc_t *arcs, size_t arcs_count,
+                                     const char **opt_oid_text_end);
 
 /*
  * Internal functions.
  * Used by RELATIVE-OID implementation in particular.
  */
 
 /*
  * Internal functions.
  * Used by RELATIVE-OID implementation in particular.
  */
-int OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, unsigned int arclen,
-       signed int add, void *value, unsigned int value_size);
-int OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf,
-       const void *arcval, unsigned int arcval_size, int _prepared_order);
+
+/*
+ * Retrieve a single arc of size from the (arcbuf) buffer.
+ * RETURN VALUES:
+ *  -1: Failed to retrieve the value from the (arcbuf).
+ *  >0: Number of bytes consumed from the (arcbuf), <= (arcbuf_len).
+ */
+ssize_t OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf,
+                                         size_t arcbuf_len,
+                                         asn_oid_arc_t *ret_value);
+
+/*
+ * Write the unterminated arc value into the (arcbuf) which has the size at
+ * least (arcbuf_len).
+ * RETURN VALUES:
+ *   -1: (arcbuf_len) size is not sufficient to write the value.
+ *  <n>: Number of bytes appended to the arcbuf (<= arcbuf_len).
+ */
+ssize_t OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, size_t arcbuf_len,
+                                         asn_oid_arc_t arc_value);
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 013c7b13f96c46952b92492583bdd277b0391f8b..bb06dc62d4a60eb14e30cc7aff46181111c7be6e 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _OCTET_STRING_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _OCTET_STRING_H_
@@ -13,16 +13,18 @@ extern "C" {
 
 typedef struct OCTET_STRING {
        uint8_t *buf;   /* Buffer with consecutive OCTET_STRING bits */
 
 typedef struct OCTET_STRING {
        uint8_t *buf;   /* Buffer with consecutive OCTET_STRING bits */
-       int size;       /* Size of the buffer */
+       size_t 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_ctx_t _asn_ctx;      /* Parsing across buffer boundaries */
 } OCTET_STRING_t;
 
 extern asn_TYPE_descriptor_t asn_DEF_OCTET_STRING;
+extern asn_TYPE_operation_t asn_OP_OCTET_STRING;
 
 asn_struct_free_f OCTET_STRING_free;
 asn_struct_print_f OCTET_STRING_print;
 asn_struct_print_f OCTET_STRING_print_utf8;
 
 asn_struct_free_f OCTET_STRING_free;
 asn_struct_print_f OCTET_STRING_print;
 asn_struct_print_f OCTET_STRING_print_utf8;
+asn_struct_compare_f OCTET_STRING_compare;
 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 */
 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 */
@@ -30,8 +32,14 @@ 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;
 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;
+oer_type_decoder_f OCTET_STRING_decode_oer;
+oer_type_encoder_f OCTET_STRING_encode_oer;
 per_type_decoder_f OCTET_STRING_decode_uper;
 per_type_encoder_f OCTET_STRING_encode_uper;
 per_type_decoder_f OCTET_STRING_decode_uper;
 per_type_encoder_f OCTET_STRING_encode_uper;
+asn_random_fill_f  OCTET_STRING_random_fill;
+
+#define OCTET_STRING_constraint  asn_generic_no_constraint
+#define OCTET_STRING_decode_xer  OCTET_STRING_decode_xer_hex
 
 /******************************
  * Handy conversion routines. *
 
 /******************************
  * Handy conversion routines. *
@@ -56,29 +64,35 @@ int OCTET_STRING_fromBuf(OCTET_STRING_t *s, const char *str, int size);
  * allocated object. NULL is permitted in str: the function will just allocate
  * empty OCTET STRING.
  */
  * 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);
+OCTET_STRING_t *OCTET_STRING_new_fromBuf(const asn_TYPE_descriptor_t *td,
+                                         const char *str, int size);
 
 /****************************
  * Internally useful stuff. *
  ****************************/
 
 
 /****************************
  * Internally useful stuff. *
  ****************************/
 
-typedef const 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;
+typedef struct asn_OCTET_STRING_specifics_s {
+    /*
+     * Target structure description.
+     */
+    unsigned struct_size;   /* Size of the structure */
+    unsigned 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;
 
 } asn_OCTET_STRING_specifics_t;
 
+extern asn_OCTET_STRING_specifics_t asn_SPC_OCTET_STRING_specs;
+
+size_t OCTET_STRING_random_length_constrained(
+    const asn_TYPE_descriptor_t *, const asn_encoding_constraints_t *,
+    size_t max_length);
+
 #ifdef __cplusplus
 }
 #endif
 #ifdef __cplusplus
 }
 #endif
diff --git a/libs/smux/include/stg/OPEN_TYPE.h b/libs/smux/include/stg/OPEN_TYPE.h
new file mode 100644 (file)
index 0000000..d0f02fd
--- /dev/null
@@ -0,0 +1,63 @@
+/*-
+ * Copyright (c) 2017-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_OPEN_TYPE_H
+#define ASN_OPEN_TYPE_H
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OPEN_TYPE_free CHOICE_free
+#define OPEN_TYPE_print CHOICE_print
+#define OPEN_TYPE_compare CHOICE_compare
+#define OPEN_TYPE_constraint CHOICE_constraint
+#define OPEN_TYPE_decode_ber NULL
+#define OPEN_TYPE_encode_der CHOICE_encode_der
+#define OPEN_TYPE_decode_xer NULL
+#define OPEN_TYPE_encode_xer CHOICE_encode_xer
+#define OPEN_TYPE_decode_uper NULL
+
+extern asn_TYPE_operation_t asn_OP_OPEN_TYPE;
+
+/*
+ * Decode an Open Type which is potentially constraiend
+ * by the other members of the parent structure.
+ */
+asn_dec_rval_t OPEN_TYPE_ber_get(const asn_codec_ctx_t *opt_codec_ctx,
+                                 const asn_TYPE_descriptor_t *parent_type,
+                                 void *parent_structure,
+                                 const asn_TYPE_member_t *element,
+                                 const void *ptr, size_t size);
+
+asn_dec_rval_t OPEN_TYPE_xer_get(const asn_codec_ctx_t *opt_codec_ctx,
+                                 const asn_TYPE_descriptor_t *parent_type,
+                                 void *parent_structure,
+                                 const asn_TYPE_member_t *element,
+                                 const void *ptr, size_t size);
+
+asn_dec_rval_t OPEN_TYPE_oer_get(const asn_codec_ctx_t *opt_codec_ctx,
+                                 const asn_TYPE_descriptor_t *parent_type,
+                                 void *parent_structure,
+                                 asn_TYPE_member_t *element, const void *ptr,
+                                 size_t size);
+
+asn_dec_rval_t OPEN_TYPE_uper_get(const asn_codec_ctx_t *opt_codec_ctx,
+                                  const asn_TYPE_descriptor_t *parent_type,
+                                  void *parent_structure,
+                                  const asn_TYPE_member_t *element,
+                                  asn_per_data_t *pd);
+
+asn_enc_rval_t OPEN_TYPE_encode_uper(
+    const asn_TYPE_descriptor_t *type_descriptor,
+    const asn_per_constraints_t *constraints, const void *struct_ptr,
+    asn_per_outp_t *per_output);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ASN_OPEN_TYPE_H */
index 4187cd0c4eb637f087aa5084f2bc648776bc14b8..2e8c238d06d77dde6ed2d3cc277f8bb33aa6885a 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _ObjectName_H_
  */
 
 #ifndef        _ObjectName_H_
@@ -30,6 +30,10 @@ ber_type_decoder_f ObjectName_decode_ber;
 der_type_encoder_f ObjectName_encode_der;
 xer_type_decoder_f ObjectName_decode_xer;
 xer_type_encoder_f ObjectName_encode_xer;
 der_type_encoder_f ObjectName_encode_der;
 xer_type_decoder_f ObjectName_decode_xer;
 xer_type_encoder_f ObjectName_encode_xer;
+oer_type_decoder_f ObjectName_decode_oer;
+oer_type_encoder_f ObjectName_encode_oer;
+per_type_decoder_f ObjectName_decode_uper;
+per_type_encoder_f ObjectName_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index ad56e7e04f6793b4e7daefe5eaea941b805044dc..eb83dbf24e72afc78a4e5d163330b6fe7f90e819 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _ObjectSyntax_H_
  */
 
 #ifndef        _ObjectSyntax_H_
@@ -41,6 +41,9 @@ typedef struct ObjectSyntax {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_ObjectSyntax;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_ObjectSyntax;
+extern asn_CHOICE_specifics_t asn_SPC_ObjectSyntax_specs_1;
+extern asn_TYPE_member_t asn_MBR_ObjectSyntax_1[2];
+extern asn_per_constraints_t asn_PER_type_ObjectSyntax_constr_1;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index ff94eff6de686bbc619a1816558e935f9a9791f7..7dfd338b08093c78a328b7320863f845e75f16e6 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _Opaque_H_
  */
 
 #ifndef        _Opaque_H_
@@ -30,6 +30,10 @@ ber_type_decoder_f Opaque_decode_ber;
 der_type_encoder_f Opaque_encode_der;
 xer_type_decoder_f Opaque_decode_xer;
 xer_type_encoder_f Opaque_encode_xer;
 der_type_encoder_f Opaque_encode_der;
 xer_type_decoder_f Opaque_decode_xer;
 xer_type_encoder_f Opaque_encode_xer;
+oer_type_decoder_f Opaque_decode_oer;
+oer_type_encoder_f Opaque_encode_oer;
+per_type_decoder_f Opaque_decode_uper;
+per_type_encoder_f Opaque_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 1b77d558391f054e800dbc08447c5c593b78c85a..cab800ca901ccb0239ac3950e580624829eb9844 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _OpenPDU_H_
  */
 
 #ifndef        _OpenPDU_H_
@@ -38,6 +38,9 @@ typedef struct OpenPDU {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_OpenPDU;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_OpenPDU;
+extern asn_CHOICE_specifics_t asn_SPC_OpenPDU_specs_1;
+extern asn_TYPE_member_t asn_MBR_OpenPDU_1[1];
+extern asn_per_constraints_t asn_PER_type_OpenPDU_constr_1;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 10e30f17c6a7f402edec0735fc116820af303cbf..5d9f69b66b6542e367caad55b3a9a396e0980ef9 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _PDU_H_
  */
 
 #ifndef        _PDU_H_
@@ -43,6 +43,8 @@ typedef struct PDU {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_PDU;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_PDU;
+extern asn_SEQUENCE_specifics_t asn_SPC_PDU_specs_1;
+extern asn_TYPE_member_t asn_MBR_PDU_1[4];
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index db197d316cd1714ada76302bbd5ca1a9dcacbc33..6baf7ce5e4962d7a449bef48360598f2d16f0d91 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _PDUs_H_
  */
 
 #ifndef        _PDUs_H_
@@ -50,6 +50,9 @@ typedef struct PDUs {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_PDUs;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_PDUs;
+extern asn_CHOICE_specifics_t asn_SPC_PDUs_specs_1;
+extern asn_TYPE_member_t asn_MBR_PDUs_1[5];
+extern asn_per_constraints_t asn_PER_type_PDUs_constr_1;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 08e43e91751173dc807b985d15a8c120f8dec049..738e970b0efeac34e3d62ab5b60d767f33f43f68 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _PhysAddress_H_
  */
 
 #ifndef        _PhysAddress_H_
@@ -30,6 +30,10 @@ ber_type_decoder_f PhysAddress_decode_ber;
 der_type_encoder_f PhysAddress_encode_der;
 xer_type_decoder_f PhysAddress_decode_xer;
 xer_type_encoder_f PhysAddress_encode_xer;
 der_type_encoder_f PhysAddress_encode_der;
 xer_type_decoder_f PhysAddress_decode_xer;
 xer_type_encoder_f PhysAddress_encode_xer;
+oer_type_decoder_f PhysAddress_decode_oer;
+oer_type_encoder_f PhysAddress_encode_oer;
+per_type_decoder_f PhysAddress_decode_uper;
+per_type_encoder_f PhysAddress_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 570c1964b093e3444600e7b2625af39acc8386c6..c7a482429e9d1145aa054bfc874bcf57012d1bbc 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _RReqPDU_H_
  */
 
 #ifndef        _RReqPDU_H_
@@ -40,6 +40,8 @@ typedef struct RReqPDU {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_RReqPDU;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_RReqPDU;
+extern asn_SEQUENCE_specifics_t asn_SPC_RReqPDU_specs_1;
+extern asn_TYPE_member_t asn_MBR_RReqPDU_1[3];
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index f9b43874f31cf960123b3afd31b5fd20ee904a5d..158e1353ce316fbbfa5ce7ab6b706d181f5ee24f 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _RRspPDU_H_
  */
 
 #ifndef        _RRspPDU_H_
@@ -35,6 +35,10 @@ ber_type_decoder_f RRspPDU_decode_ber;
 der_type_encoder_f RRspPDU_encode_der;
 xer_type_decoder_f RRspPDU_decode_xer;
 xer_type_encoder_f RRspPDU_encode_xer;
 der_type_encoder_f RRspPDU_encode_der;
 xer_type_decoder_f RRspPDU_decode_xer;
 xer_type_encoder_f RRspPDU_encode_xer;
+oer_type_decoder_f RRspPDU_decode_oer;
+oer_type_encoder_f RRspPDU_encode_oer;
+per_type_decoder_f RRspPDU_decode_uper;
+per_type_encoder_f RRspPDU_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 033875420b3440deb0f7bd19b7a872b0b308c0bd..9bac69c05054a1f9e7183db98a37e26bf110a75a 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _SMUX_PDUs_H_
  */
 
 #ifndef        _SMUX_PDUs_H_
index d0259f9ad73f75df5c5e82e76665158e1a3b353e..08fa3db8746df02965feb7e0580d5c075c742853 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _SOutPDU_H_
  */
 
 #ifndef        _SOutPDU_H_
@@ -36,6 +36,10 @@ ber_type_decoder_f SOutPDU_decode_ber;
 der_type_encoder_f SOutPDU_encode_der;
 xer_type_decoder_f SOutPDU_decode_xer;
 xer_type_encoder_f SOutPDU_encode_xer;
 der_type_encoder_f SOutPDU_encode_der;
 xer_type_decoder_f SOutPDU_decode_xer;
 xer_type_encoder_f SOutPDU_encode_xer;
+oer_type_decoder_f SOutPDU_decode_oer;
+oer_type_encoder_f SOutPDU_encode_oer;
+per_type_decoder_f SOutPDU_decode_uper;
+per_type_encoder_f SOutPDU_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 1a5636fb0f9c038f7f7850b712719b6344e11e04..4c5a5a69aabc50b0bee8dd4ba06d236a46e2abcc 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _SetRequest_PDU_H_
  */
 
 #ifndef        _SetRequest_PDU_H_
@@ -30,6 +30,10 @@ ber_type_decoder_f SetRequest_PDU_decode_ber;
 der_type_encoder_f SetRequest_PDU_encode_der;
 xer_type_decoder_f SetRequest_PDU_decode_xer;
 xer_type_encoder_f SetRequest_PDU_encode_xer;
 der_type_encoder_f SetRequest_PDU_encode_der;
 xer_type_decoder_f SetRequest_PDU_decode_xer;
 xer_type_encoder_f SetRequest_PDU_encode_xer;
+oer_type_decoder_f SetRequest_PDU_decode_oer;
+oer_type_encoder_f SetRequest_PDU_encode_oer;
+per_type_decoder_f SetRequest_PDU_decode_uper;
+per_type_encoder_f SetRequest_PDU_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 4f838ade0f20077fc8d189bc28200fec27ff1e89..f6e94d7d07aa69590e8aebae29efcc15230c9ba8 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
  * From ASN.1 module "SMUX"
  *     found in "SMUX.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _SimpleOpen_H_
  */
 
 #ifndef        _SimpleOpen_H_
@@ -40,6 +40,8 @@ typedef struct SimpleOpen {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_SimpleOpen;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_SimpleOpen;
+extern asn_SEQUENCE_specifics_t asn_SPC_SimpleOpen_specs_1;
+extern asn_TYPE_member_t asn_MBR_SimpleOpen_1[4];
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index dcf32c95ad86dbe97bd83732ce899627d74a4b9b..0b7c13b83024d54fa62e497affa592302c8a9af1 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _SimpleSyntax_H_
  */
 
 #ifndef        _SimpleSyntax_H_
@@ -47,6 +47,9 @@ typedef struct SimpleSyntax {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_SimpleSyntax;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_SimpleSyntax;
+extern asn_CHOICE_specifics_t asn_SPC_SimpleSyntax_specs_1;
+extern asn_TYPE_member_t asn_MBR_SimpleSyntax_1[4];
+extern asn_per_constraints_t asn_PER_type_SimpleSyntax_constr_1;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index fb3d33ca957851e70eaea7d679c03b0f2294ace4..5ebd315b4ed89e7cd6f56b55b2c1ba0195a71ee0 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _TcpConnEntry_H_
  */
 
 #ifndef        _TcpConnEntry_H_
index fe7ea1db338318e56622d2b510db5160c16c0d98..52210c03a822ecc57af8cb46bbc23841472c61ca 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
  * From ASN.1 module "RFC1155-SMI"
  *     found in "RFC1155-SMI.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _TimeTicks_H_
  */
 
 #ifndef        _TimeTicks_H_
@@ -22,7 +22,9 @@ extern "C" {
 typedef unsigned long   TimeTicks_t;
 
 /* Implementation */
 typedef unsigned long   TimeTicks_t;
 
 /* Implementation */
+extern asn_per_constraints_t asn_PER_type_TimeTicks_constr_1;
 extern asn_TYPE_descriptor_t asn_DEF_TimeTicks;
 extern asn_TYPE_descriptor_t asn_DEF_TimeTicks;
+extern const asn_INTEGER_specifics_t asn_SPC_TimeTicks_specs_1;
 asn_struct_free_f TimeTicks_free;
 asn_struct_print_f TimeTicks_print;
 asn_constr_check_f TimeTicks_constraint;
 asn_struct_free_f TimeTicks_free;
 asn_struct_print_f TimeTicks_print;
 asn_constr_check_f TimeTicks_constraint;
@@ -30,6 +32,10 @@ ber_type_decoder_f TimeTicks_decode_ber;
 der_type_encoder_f TimeTicks_encode_der;
 xer_type_decoder_f TimeTicks_decode_xer;
 xer_type_encoder_f TimeTicks_encode_xer;
 der_type_encoder_f TimeTicks_encode_der;
 xer_type_decoder_f TimeTicks_decode_xer;
 xer_type_encoder_f TimeTicks_encode_xer;
+oer_type_decoder_f TimeTicks_decode_oer;
+oer_type_encoder_f TimeTicks_encode_oer;
+per_type_decoder_f TimeTicks_decode_uper;
+per_type_encoder_f TimeTicks_encode_uper;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index f4169aeb1d4e0aab67960d952ed48693feff01d0..9dbde79428c08b11f038d36d12044527b9b01e9c 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _Trap_PDU_H_
  */
 
 #ifndef        _Trap_PDU_H_
@@ -49,6 +49,8 @@ typedef struct Trap_PDU {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_Trap_PDU;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_Trap_PDU;
+extern asn_SEQUENCE_specifics_t asn_SPC_Trap_PDU_specs_1;
+extern asn_TYPE_member_t asn_MBR_Trap_PDU_1[6];
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index af9772d568110c3e1995065689fd574be5ae69c4..945810710f1a2107309cce7d6a28c09c45c4f7d1 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
  * From ASN.1 module "RFC1213-MIB"
  *     found in "RFC1213-MIB.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _UdpEntry_H_
  */
 
 #ifndef        _UdpEntry_H_
index 6291d640f9e25724ce066d8047b6c20b3c79d777..988eebe312bc9c5b1eb807d23b9906427e80df0f 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _VarBind_H_
  */
 
 #ifndef        _VarBind_H_
@@ -31,6 +31,8 @@ typedef struct VarBind {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_VarBind;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_VarBind;
+extern asn_SEQUENCE_specifics_t asn_SPC_VarBind_specs_1;
+extern asn_TYPE_member_t asn_MBR_VarBind_1[2];
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index b9061796a5cbd3ddbbfb8ac31e0b3e98a3282284..508354b3659e061c01d324c49cbd8ace83e7f238 100644 (file)
@@ -1,8 +1,8 @@
 /*
 /*
- * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
  * From ASN.1 module "RFC1157-SNMP"
  *     found in "RFC1157-SNMP.asn1"
- *     `asn1c -S/mnt/data/software/asn1c/skeletons -fcompound-names -fwide-types`
+ *     `asn1c -S /home/faust/software/asn1c/skeletons/ -fcompound-names -fwide-types`
  */
 
 #ifndef        _VarBindList_H_
  */
 
 #ifndef        _VarBindList_H_
@@ -32,6 +32,8 @@ typedef struct VarBindList {
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_VarBindList;
 
 /* Implementation */
 extern asn_TYPE_descriptor_t asn_DEF_VarBindList;
+extern asn_SET_OF_specifics_t asn_SPC_VarBindList_specs_1;
+extern asn_TYPE_member_t asn_MBR_VarBindList_1[1];
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index e678f0347221f96698668bf6d8461655f8e40d82..e35bc447a26555c1186581949ec218a668df31aa 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN_SEQUENCE_OF_H
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN_SEQUENCE_OF_H
index 7edf14b51b984d545b818fcf3a93204935d46a80..882e1a47d4ad0b8cdfd359be63b8f577d158cd43 100644 (file)
@@ -1,21 +1,31 @@
 /*-
 /*-
- * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN_SET_OF_H
 #define        ASN_SET_OF_H
 
 #ifdef __cplusplus
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN_SET_OF_H
 #define        ASN_SET_OF_H
 
 #ifdef __cplusplus
-extern "C" {
+#define A_SET_OF(type)                   \
+    struct {                             \
+        type **array;                    \
+        int count; /* Meaningful size */ \
+        int size;  /* Allocated size */  \
+        void (*free)(decltype(*array));  \
+    }
+#else   /* C */
+#define A_SET_OF(type)                   \
+    struct {                             \
+        type **array;                    \
+        int count; /* Meaningful size */ \
+        int size;  /* Allocated size */  \
+        void (*free)(type *);    \
+    }
 #endif
 
 #endif
 
-#define        A_SET_OF(type)                                  \
-       struct {                                        \
-               type **array;                           \
-               int count;      /* Meaningful size */   \
-               int size;       /* Allocated size */    \
-               void (*free)(type *);                   \
-       }
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 #define        ASN_SET_ADD(headptr, ptr)               \
        asn_set_add((headptr), (ptr))
 
 #define        ASN_SET_ADD(headptr, ptr)               \
        asn_set_add((headptr), (ptr))
index 71e9ba61b2e8f69682d5147bdd8963ff648b89e6..3ca9f138eee7b4ef777d165e7032f449e068720a 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2004, 2006 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 /*
  * Redistribution and modifications are permitted subject to BSD license.
  */
 /*
 extern "C" {
 #endif
 
 extern "C" {
 #endif
 
+/*
+ * A selection of ASN.1 Transfer Syntaxes to use with generalized
+ * encoders and decoders declared further in this .h file.
+ */
+enum asn_transfer_syntax {
+    /* Avoid appearance of a default transfer syntax. */
+    ATS_INVALID = 0,
+    /* Plaintext output (not conforming to any standard), for debugging. */
+    ATS_NONSTANDARD_PLAINTEXT,
+    /* Returns a randomly generatede structure. */
+    ATS_RANDOM,
+    /*
+     * X.690:
+     * BER: Basic Encoding Rules.
+     * DER: Distinguished Encoding Rules.
+     * CER: Canonical Encoding Rules.
+     * DER and CER are more strict variants of BER.
+     */
+    ATS_BER,
+    ATS_DER,
+    ATS_CER, /* Only decoding is supported */
+    /*
+     * X.696:
+     * OER: Octet Encoding Rules.
+     * CANONICAL-OER is a more strict variant of BASIC-OER.
+     */
+    ATS_BASIC_OER,
+    ATS_CANONICAL_OER,
+    /*
+     * X.691:
+     * PER: Packed Encoding Rules.
+     * CANONICAL-PER is a more strict variant of BASIC-PER.
+     * NOTE: Produces or consumes a complete encoding (X.691 (08/2015) #11.1).
+     */
+    ATS_UNALIGNED_BASIC_PER,
+    ATS_UNALIGNED_CANONICAL_PER,
+    /*
+     * X.693:
+     * XER: XML Encoding Rules.
+     * CANONICAL-XER is a more strict variant of BASIC-XER.
+     */
+    ATS_BASIC_XER,
+    ATS_CANONICAL_XER
+};
+
+/*
+ * A generic encoder for any supported transfer syntax.
+ * RETURN VALUES:
+ * The (.encoded) field of the return value is REDEFINED to mean the following:
+ * >=0: The computed size of the encoded data. Can exceed the (buffer_size).
+ *  -1: Error encoding the structure. See the error code in (errno):
+ *      EINVAL: Incorrect parameters to the function, such as NULLs.
+ *      ENOENT: Encoding transfer syntax is not defined (for this type).
+ *      EBADF:  The structure has invalid form or content constraint failed.
+ *      The (.failed_type) and (.structure_ptr) MIGHT be set to the appropriate
+ *      values at the place of failure, if at all possible.
+ * WARNING: The (.encoded) field of the return value can exceed the buffer_size.
+ * This is similar to snprintf(3) contract which might return values
+ * greater than the buffer size.
+ */
+asn_enc_rval_t asn_encode_to_buffer(
+    const asn_codec_ctx_t *opt_codec_parameters, /* See asn_codecs.h */
+    enum asn_transfer_syntax,
+    const struct asn_TYPE_descriptor_s *type_to_encode,
+    const void *structure_to_encode, void *buffer, size_t buffer_size);
+
+/*
+ * A variant of asn_encode_to_buffer() with automatically allocated buffer.
+ * RETURN VALUES:
+ * On success, returns a newly allocated (.buffer) containing the whole message.
+ * The message size is returned in (.result.encoded).
+ * On failure:
+ *  (.buffer) is NULL,
+ *  (.result.encoded) as in asn_encode_to_buffer(),
+ *  The errno codes as in asn_encode_to_buffer(), plus the following:
+ *      ENOMEM: Memory allocation failed due to system or internal limits.
+ * The user is responsible for freeing the (.buffer).
+ */
+typedef struct asn_encode_to_new_buffer_result_s {
+    void *buffer;   /* NULL if failed to encode. */
+    asn_enc_rval_t result;
+} asn_encode_to_new_buffer_result_t;
+asn_encode_to_new_buffer_result_t asn_encode_to_new_buffer(
+    const asn_codec_ctx_t *opt_codec_parameters, /* See asn_codecs.h */
+    enum asn_transfer_syntax,
+    const struct asn_TYPE_descriptor_s *type_to_encode,
+    const void *structure_to_encode);
+
+
 /*
  * Generic type of an application-defined callback to return various
  * types of data to the application.
 /*
  * Generic type of an application-defined callback to return various
  * types of data to the application.
@@ -22,8 +111,40 @@ extern "C" {
  *  -1: Failed to consume bytes. Abort the mission.
  * Non-negative return values indicate success, and ignored.
  */
  *  -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);
+typedef int(asn_app_consume_bytes_f)(const void *buffer, size_t size,
+                                     void *application_specific_key);
+
+
+/*
+ * A generic encoder for any supported transfer syntax.
+ * Returns the comprehensive encoding result descriptor (see asn_codecs.h).
+ * RETURN VALUES:
+ * The negative (.encoded) field of the return values is accompanied with the
+ * following error codes (errno):
+ *      EINVAL: Incorrect parameters to the function, such as NULLs.
+ *      ENOENT: Encoding transfer syntax is not defined (for this type).
+ *      EBADF:  The structure has invalid form or content constraint failed.
+ *      EIO:    The (callback) has returned negative value during encoding.
+ */
+asn_enc_rval_t asn_encode(
+    const asn_codec_ctx_t *opt_codec_parameters, /* See asn_codecs.h */
+    enum asn_transfer_syntax,
+    const struct asn_TYPE_descriptor_s *type_to_encode,
+    const void *structure_to_encode,
+    asn_app_consume_bytes_f *callback, void *callback_key);
+
+
+/*
+ * A generic decoder for any supported transfer syntax.
+ */
+asn_dec_rval_t asn_decode(
+    const asn_codec_ctx_t *opt_codec_parameters, enum asn_transfer_syntax,
+    const struct asn_TYPE_descriptor_s *type_to_decode,
+    void **structure_ptr, /* Pointer to a target structure's pointer */
+    const void *buffer,   /* Data to be decoded */
+    size_t size           /* Size of that buffer */
+);
+
 
 /*
  * A callback of this type is called whenever constraint validation fails
 
 /*
  * A callback of this type is called whenever constraint validation fails
@@ -34,9 +155,10 @@ typedef int (asn_app_consume_bytes_f)(const void *buffer, size_t size,
  * particular constraint has failed.
  */
 typedef void (asn_app_constraint_failed_f)(void *application_specific_key,
  * 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 struct asn_TYPE_descriptor_s *type_descriptor_which_failed,
        const void *structure_which_failed_ptr,
        const void *structure_which_failed_ptr,
-       const char *error_message_format, ...) GCC_PRINTFLIKE(4, 5);
+       const char *error_message_format, ...) CC_PRINTFLIKE(4, 5);
+
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
diff --git a/libs/smux/include/stg/asn_bit_data.h b/libs/smux/include/stg/asn_bit_data.h
new file mode 100644 (file)
index 0000000..59de7af
--- /dev/null
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2005-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        ASN_BIT_DATA
+#define        ASN_BIT_DATA
+
+#include <asn_system.h>                /* Platform-specific types */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * This structure describes a position inside an incoming PER bit stream.
+ */
+typedef struct asn_bit_data_s {
+  const uint8_t *buffer;  /* Pointer to the octet stream */
+         size_t  nboff;   /* Bit offset to the meaningful bit */
+         size_t  nbits;   /* Number of bits in the stream */
+         size_t  moved;   /* Number of bits moved through this bit stream */
+  int (*refill)(struct asn_bit_data_s *);
+  void *refill_key;
+} asn_bit_data_t;
+
+/*
+ * Create a contiguous non-refillable bit data structure.
+ * Can be freed by FREEMEM().
+ */
+asn_bit_data_t *asn_bit_data_new_contiguous(const void *data, size_t size_bits);
+
+/*
+ * Extract a small number of bits (<= 31) from the specified PER data pointer.
+ * This function returns -1 if the specified number of bits could not be
+ * extracted due to EOD or other conditions.
+ */
+int32_t asn_get_few_bits(asn_bit_data_t *, int get_nbits);
+
+/* Undo the immediately preceeding "get_few_bits" operation */
+void asn_get_undo(asn_bit_data_t *, int get_nbits);
+
+/*
+ * Extract a large number of bits from the specified PER data pointer.
+ * This function returns -1 if the specified number of bits could not be
+ * extracted due to EOD or other conditions.
+ */
+int asn_get_many_bits(asn_bit_data_t *, uint8_t *dst, int right_align,
+                       int get_nbits);
+
+/* Non-thread-safe debugging function, don't use it */
+char *asn_bit_data_string(asn_bit_data_t *);
+
+/*
+ * This structure supports forming bit output.
+ */
+typedef struct asn_bit_outp_s {
+       uint8_t *buffer;        /* Pointer into the (tmpspace) */
+       size_t nboff;           /* Bit offset to the meaningful bit */
+       size_t nbits;           /* Number of bits left in (tmpspace) */
+       uint8_t tmpspace[32];   /* Preliminary storage to hold data */
+       int (*output)(const void *data, size_t size, void *op_key);
+       void *op_key;           /* Key for (output) data callback */
+       size_t flushed_bytes;   /* Bytes already flushed through (output) */
+} asn_bit_outp_t;
+
+/* Output a small number of bits (<= 31) */
+int asn_put_few_bits(asn_bit_outp_t *, uint32_t bits, int obits);
+
+/* Output a large number of bits */
+int asn_put_many_bits(asn_bit_outp_t *, const uint8_t *src, int put_nbits);
+
+/*
+ * Flush whole bytes (0 or more) through (outper) member.
+ * The least significant bits which are not used are guaranteed to be set to 0.
+ * Returns -1 if callback returns -1. Otherwise, 0.
+ */
+int asn_put_aligned_flush(asn_bit_outp_t *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ASN_BIT_DATA */
index 4b2a294293c22d84ebafdd0d581739c6969fd447..e75c2709cd956507df15791c7b602996fbced9a8 100644 (file)
@@ -1,6 +1,5 @@
-/*-
- * Copyright (c) 2003, 2004, 2005 Lev Walkin <vlm@lionet.info>.
- * All rights reserved.
+/*
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN_CODECS_H
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN_CODECS_H
@@ -52,10 +51,10 @@ typedef struct asn_enc_rval_s {
         */
 
        /* Type which cannot be encoded */
         */
 
        /* Type which cannot be encoded */
-       struct asn_TYPE_descriptor_s *failed_type;
+       const struct asn_TYPE_descriptor_s *failed_type;
 
        /* Pointer to the structure of that type */
 
        /* Pointer to the structure of that type */
-       void *structure_ptr;
+       const void *structure_ptr;
 } asn_enc_rval_t;
 #define        ASN__ENCODE_FAILED do {                                 \
        asn_enc_rval_t tmp_error;                               \
 } asn_enc_rval_t;
 #define        ASN__ENCODE_FAILED do {                                 \
        asn_enc_rval_t tmp_error;                               \
index 0f683fdd0ac7d5be56c55b1363fa4fddb0d48198..fbc557648d15b502afe31b6fa1a5b8a3e86afafd 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN_CODECS_PRIM_H
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN_CODECS_PRIM_H
@@ -12,8 +12,8 @@ extern "C" {
 #endif
 
 typedef struct ASN__PRIMITIVE_TYPE_s {
 #endif
 
 typedef struct ASN__PRIMITIVE_TYPE_s {
-       uint8_t *buf;   /* Buffer with consecutive primitive encoding bytes */
-       int size;       /* Size of the buffer */
+    uint8_t *buf;   /* Buffer with consecutive primitive encoding bytes */
+    size_t size;    /* Size of the buffer */
 } ASN__PRIMITIVE_TYPE_t;       /* Do not use this type directly! */
 
 asn_struct_free_f ASN__PRIMITIVE_TYPE_free;
 } ASN__PRIMITIVE_TYPE_t;       /* Do not use this type directly! */
 
 asn_struct_free_f ASN__PRIMITIVE_TYPE_free;
@@ -24,27 +24,25 @@ der_type_encoder_f der_encode_primitive;
  * A callback specification for the xer_decode_primitive() function below.
  */
 enum xer_pbd_rval {
  * 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 */
+    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);
+typedef enum xer_pbd_rval(xer_primitive_body_decoder_f)(
+    const 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
  */
 
 /*
  * 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
-);
+asn_dec_rval_t xer_decode_primitive(
+    const asn_codec_ctx_t *opt_codec_ctx,
+    const 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
 }
 
 #ifdef __cplusplus
 }
index 9c94ca6c3b77b069c657d3c03ea0e3e650128747..4e72d62f30addb09bc9fd92c354ff1233d321e69 100644 (file)
@@ -1,6 +1,5 @@
-/*-
- * Copyright (c) 2003, 2004, 2005, 2007 Lev Walkin <vlm@lionet.info>.
- * All rights reserved.
+/*
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 /*
  * Redistribution and modifications are permitted subject to BSD license.
  */
 /*
@@ -8,7 +7,9 @@
  */
 #ifndef        ASN_INTERNAL_H
 #define        ASN_INTERNAL_H
  */
 #ifndef        ASN_INTERNAL_H
 #define        ASN_INTERNAL_H
-
+#ifndef __EXTENSIONS__
+#define __EXTENSIONS__          /* for Sun */
+#endif
 #include "asn_application.h"   /* Application-visible API */
 
 #ifndef        __NO_ASSERT_H__         /* Include assert.h only for internal use. */
 #include "asn_application.h"   /* Application-visible API */
 
 #ifndef        __NO_ASSERT_H__         /* Include assert.h only for internal use. */
@@ -31,13 +32,18 @@ int get_asn1c_environment_version(void);    /* Run-time version */
 #define        asn_debug_indent        0
 #define ASN_DEBUG_INDENT_ADD(i) do{}while(0)
 
 #define        asn_debug_indent        0
 #define ASN_DEBUG_INDENT_ADD(i) do{}while(0)
 
+#ifdef  EMIT_ASN_DEBUG
+#warning "Use ASN_EMIT_DEBUG instead of EMIT_ASN_DEBUG"
+#define ASN_EMIT_DEBUG  EMIT_ASN_DEBUG
+#endif
+
 /*
  * A macro for debugging the ASN.1 internals.
  * You may enable or override it.
  */
 #ifndef        ASN_DEBUG       /* If debugging code is not defined elsewhere... */
 /*
  * 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__
+#if    ASN_EMIT_DEBUG == 1     /* And it was asked to emit this code... */
+#if __STDC_VERSION__ >= 199901L
 #ifdef ASN_THREAD_SAFE
 /* Thread safety requires sacrifice in output indentation:
  * Retain empty definition of ASN_DEBUG_INDENT_ADD. */
 #ifdef ASN_THREAD_SAFE
 /* Thread safety requires sacrifice in output indentation:
  * Retain empty definition of ASN_DEBUG_INDENT_ADD. */
@@ -54,40 +60,58 @@ int asn_debug_indent;
                fprintf(stderr, " (%s:%d)\n",           \
                        __FILE__, __LINE__);            \
        } while(0)
                fprintf(stderr, " (%s:%d)\n",           \
                        __FILE__, __LINE__);            \
        } while(0)
-#else  /* !__GNUC__ */
-void ASN_DEBUG_f(const char *fmt, ...);
+#else  /* !C99 */
+void CC_PRINTFLIKE(1, 2) ASN_DEBUG_f(const char *fmt, ...);
 #define        ASN_DEBUG       ASN_DEBUG_f
 #define        ASN_DEBUG       ASN_DEBUG_f
-#endif /* __GNUC__ */
-#else  /* EMIT_ASN_DEBUG != 1 */
-static void ASN_DEBUG(const char *fmt, ...) { (void)fmt; }
-#endif /* EMIT_ASN_DEBUG */
+#endif /* C99 */
+#else  /* ASN_EMIT_DEBUG != 1 */
+#if __STDC_VERSION__ >= 199901L
+#define ASN_DEBUG(...) do{}while(0)
+#else   /* not C99 */
+static void CC_PRINTFLIKE(1, 2) ASN_DEBUG(const char *fmt, ...) { (void)fmt; }
+#endif  /* C99 or better */
+#endif /* ASN_EMIT_DEBUG */
 #endif /* ASN_DEBUG */
 
 #endif /* ASN_DEBUG */
 
+/*
+ * Print to a callback.
+ * The callback is expected to return negative values on error.
+ * 0 and positive values are treated as success.
+ * RETURN VALUES:
+ *  -1: Failed to format or invoke the callback.
+ *  >0: Size of the data that got delivered to the callback.
+ */
+ssize_t CC_PRINTFLIKE(3, 4)
+asn__format_to_callback(
+    int (*callback)(const void *, size_t, void *key), void *key,
+    const char *fmt, ...);
+
 /*
  * Invoke the application-supplied callback and fail, if something is wrong.
  */
 /*
  * 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        ASN__TEXT_INDENT(nl, level) do {            \
-        int tmp_level = (level);                    \
-        int tmp_nl = ((nl) != 0);                   \
-        int tmp_i;                                  \
-        if(tmp_nl) ASN__CALLBACK("\n", 1);          \
-        if(tmp_level < 0) tmp_level = 0;            \
-        for(tmp_i = 0; tmp_i < tmp_level; tmp_i++)  \
-            ASN__CALLBACK("    ", 4);               \
-        er.encoded += tmp_nl + 4 * tmp_level;       \
+#define ASN__E_cbc(buf, size) (cb((buf), (size), app_key) < 0)
+#define ASN__E_CALLBACK(size, foo) \
+    do {                           \
+        if(foo) goto cb_failed;    \
+        er.encoded += (size);      \
+    } while(0)
+#define ASN__CALLBACK(buf, size) ASN__E_CALLBACK(size, ASN__E_cbc(buf, size))
+#define ASN__CALLBACK2(buf1, size1, buf2, size2) \
+    ASN__E_CALLBACK((size1) + (size2),           \
+                    ASN__E_cbc(buf1, size1) || ASN__E_cbc(buf2, size2))
+#define ASN__CALLBACK3(buf1, size1, buf2, size2, buf3, size3)          \
+    ASN__E_CALLBACK((size1) + (size2) + (size3),                       \
+                    ASN__E_cbc(buf1, size1) || ASN__E_cbc(buf2, size2) \
+                        || ASN__E_cbc(buf3, size3))
+
+#define ASN__TEXT_INDENT(nl, level)                                          \
+    do {                                                                     \
+        int tmp_level = (level);                                             \
+        int tmp_nl = ((nl) != 0);                                            \
+        int tmp_i;                                                           \
+        if(tmp_nl) ASN__CALLBACK("\n", 1);                                   \
+        if(tmp_level < 0) tmp_level = 0;                                     \
+        for(tmp_i = 0; tmp_i < tmp_level; tmp_i++) ASN__CALLBACK("    ", 4); \
     } while(0)
 
 #define        _i_INDENT(nl)   do {                        \
     } while(0)
 
 #define        _i_INDENT(nl)   do {                        \
@@ -103,12 +127,12 @@ static void ASN_DEBUG(const char *fmt, ...) { (void)fmt; }
  * Check stack against overflow, if limit is set.
  */
 #define        ASN__DEFAULT_STACK_MAX  (30000)
  * Check stack against overflow, if limit is set.
  */
 #define        ASN__DEFAULT_STACK_MAX  (30000)
-static int __attribute__((unused))
-ASN__STACK_OVERFLOW_CHECK(asn_codec_ctx_t *ctx) {
+static int CC_NOTUSED
+ASN__STACK_OVERFLOW_CHECK(const asn_codec_ctx_t *ctx) {
        if(ctx && ctx->max_stack_size) {
 
                /* ctx MUST be allocated on the stack */
        if(ctx && ctx->max_stack_size) {
 
                /* ctx MUST be allocated on the stack */
-               ptrdiff_t usedstack = ((char *)ctx - (char *)&ctx);
+               ptrdiff_t usedstack = ((const char *)ctx - (const char *)&ctx);
                if(usedstack > 0) usedstack = -usedstack; /* grows up! */
 
                /* double negative required to avoid int wrap-around */
                if(usedstack > 0) usedstack = -usedstack; /* grows up! */
 
                /* double negative required to avoid int wrap-around */
diff --git a/libs/smux/include/stg/asn_ioc.h b/libs/smux/include/stg/asn_ioc.h
new file mode 100644 (file)
index 0000000..d2fe365
--- /dev/null
@@ -0,0 +1,50 @@
+/*
+ * Run-time support for Information Object Classes.
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        ASN_IOC_H
+#define        ASN_IOC_H
+
+#include <asn_system.h>                /* Platform-specific types */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct asn_TYPE_descriptor_s;
+struct asn_ioc_cell_s;
+
+/*
+ * X.681, #13
+ */
+typedef struct asn_ioc_set_s {
+    size_t rows_count;
+    size_t columns_count;
+    const struct asn_ioc_cell_s *rows;
+} asn_ioc_set_t;
+
+
+typedef struct asn_ioc_cell_s {
+    const char *field_name; /* Is equal to corresponding column_name */
+    enum {
+        aioc__value,
+        aioc__type,
+        aioc__open_type,
+    } cell_kind;
+    struct asn_TYPE_descriptor_s *type_descriptor;
+    const void *value_sptr;
+    struct {
+        size_t types_count;
+        struct {
+            unsigned choice_position;
+        } *types;
+    } open_type;
+} asn_ioc_cell_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ASN_IOC_H */
diff --git a/libs/smux/include/stg/asn_random_fill.h b/libs/smux/include/stg/asn_random_fill.h
new file mode 100644 (file)
index 0000000..47f9b8a
--- /dev/null
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        ASN_RANDOM_FILL
+#define        ASN_RANDOM_FILL
+
+/* Forward declarations */
+struct asn_TYPE_descriptor_s;
+struct asn_encoding_constraints_s;
+
+/*
+ * Initialize a structure with random data according to the type specification
+ * and optional member constraints.
+ * ARGUMENTS:
+ *  (max_length)        - See (approx_max_length_limit).
+ *  (memb_constraints)  - Member constraints, if exist.
+ *                        The type can be constrained differently according
+ *                        to PER and OER specifications, so we find a value
+ *                        at the intersection of these constraints.
+ * In case the return differs from ARFILL_OK, the (struct_ptr) contents
+ * and (current_length) value remain in their original state.
+ */
+typedef struct asn_random_fill_result_s {
+    enum {
+        ARFILL_FAILED = -1, /* System error (memory?) */
+        ARFILL_OK = 0,      /* Initialization succeeded */
+        ARFILL_SKIPPED = 1  /* Not done due to (length?) constraint */
+    } code;
+    size_t length; /* Approximate number of bytes created. */
+} asn_random_fill_result_t;
+typedef asn_random_fill_result_t(asn_random_fill_f)(
+    const struct asn_TYPE_descriptor_s *td, void **struct_ptr,
+    const struct asn_encoding_constraints_s *memb_constraints,
+    size_t max_length);
+
+/*
+ * Returns 0 if the structure was properly initialized, -1 otherwise.
+ * The (approx_max_length_limit) specifies the approximate limit of the
+ * resulting structure in units closely resembling bytes. The actual result
+ * might be several times larger or smaller than the length limit.
+ */
+int asn_random_fill(const struct asn_TYPE_descriptor_s *td, void **struct_ptr,
+                    size_t approx_max_length_limit);
+
+/*
+ * Returns a random number between min and max.
+ */
+intmax_t asn_random_between(intmax_t min, intmax_t max);
+
+#endif /* ASN_RANDOM_FILL */
index d19837edf59e4222c64ab885e63a5f61e6657728..fa8cf116576e2b620cb85d35099f8bf130997721 100644 (file)
@@ -1,6 +1,5 @@
-/*-
- * Copyright (c) 2003, 2004, 2007 Lev Walkin <vlm@lionet.info>.
- * All rights reserved.
+/*
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 /*
  * Redistribution and modifications are permitted subject to BSD license.
  */
 /*
 #include "config.h"
 #endif
 
 #include "config.h"
 #endif
 
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE 1
+#endif
+
 #ifndef _BSD_SOURCE
 #define _BSD_SOURCE /* for snprintf() on some linux systems  */
 #endif
 #ifndef _BSD_SOURCE
 #define _BSD_SOURCE /* for snprintf() on some linux systems  */
 #endif
 #include <stdarg.h>    /* For va_start */
 #include <stddef.h>    /* for offsetof and ptrdiff_t */
 
 #include <stdarg.h>    /* For va_start */
 #include <stddef.h>    /* for offsetof and ptrdiff_t */
 
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>    /* For alloca(3) */
-#endif
-
 #ifdef _WIN32
 
 #include <malloc.h>
 #ifdef _WIN32
 
 #include <malloc.h>
 #endif
 #ifndef        ASSUMESTDTYPES  /* Standard types have been defined elsewhere */
 #define        ssize_t         SSIZE_T
 #endif
 #ifndef        ASSUMESTDTYPES  /* Standard types have been defined elsewhere */
 #define        ssize_t         SSIZE_T
+#if _MSC_VER < 1600
 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;
 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;
+#else /* _MSC_VER >= 1600 */
+#include <stdint.h>
+#endif /* _MSC_VER < 1600 */
 #endif /* ASSUMESTDTYPES */
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #endif /* ASSUMESTDTYPES */
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
@@ -72,48 +75,21 @@ typedef     unsigned int    uint32_t;
 #else  /* !defined(__vxworks) */
 
 #include <inttypes.h>  /* C99 specifies this file */
 #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)
 #include <netinet/in.h> /* for ntohl() */
 #define        sys_ntohl(foo)  ntohl(foo)
-
 #endif /* defined(__vxworks) */
 
 #endif /* _WIN32 */
 
 #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
+#if    __GNUC__ >= 3 || defined(__clang__)
+#define CC_ATTRIBUTE(attr)    __attribute__((attr))
 #else
 #else
-#ifndef        GCC_PRINTFLIKE
-#define        GCC_PRINTFLIKE(fmt,var) /* nothing */
-#endif
-#ifndef        GCC_NOTUSED
-#define        GCC_NOTUSED
+#define CC_ATTRIBUTE(attr)
 #endif
 #endif
+#define CC_PRINTFLIKE(fmt, var)     CC_ATTRIBUTE(format(printf, fmt, var))
+#define        CC_NOTUSED                  CC_ATTRIBUTE(unused)
+#ifndef CC_ATTR_NO_SANITIZE
+#define CC_ATTR_NO_SANITIZE(what)   CC_ATTRIBUTE(no_sanitize(what))
 #endif
 
 /* Figure out if thread safety is requested */
 #endif
 
 /* Figure out if thread safety is requested */
@@ -134,4 +110,41 @@ typedef    unsigned int    uint32_t;
 #endif /* __GNUC__ */
 #endif /* MIN */
 
 #endif /* __GNUC__ */
 #endif /* MIN */
 
+#if __STDC_VERSION__ >= 199901L
+#ifndef SIZE_MAX
+#define SIZE_MAX   ((~((size_t)0)) >> 1)
+#endif
+
+#ifndef RSIZE_MAX   /* C11, Annex K */
+#define RSIZE_MAX   (SIZE_MAX >> 1)
+#endif
+#ifndef RSSIZE_MAX   /* Halve signed size even further than unsigned */
+#define RSSIZE_MAX   ((ssize_t)(RSIZE_MAX >> 1))
+#endif
+#else   /* Old compiler */
+#undef  SIZE_MAX
+#undef  RSIZE_MAX
+#undef  RSSIZE_MAX
+#define SIZE_MAX   ((~((size_t)0)) >> 1)
+#define RSIZE_MAX   (SIZE_MAX >> 1)
+#define RSSIZE_MAX   ((ssize_t)(RSIZE_MAX >> 1))
+#endif
+
+#if __STDC_VERSION__ >= 199901L
+#define ASN_PRI_SIZE "zu"
+#define ASN_PRI_SSIZE "zd"
+#define ASN_PRIuMAX PRIuMAX
+#define ASN_PRIdMAX PRIdMAX
+#else
+#define ASN_PRI_SIZE "lu"
+#define ASN_PRI_SSIZE "ld"
+#if LLONG_MAX > LONG_MAX
+#define ASN_PRIuMAX "llu"
+#define ASN_PRIdMAX "lld"
+#else
+#define ASN_PRIuMAX "lu"
+#define ASN_PRIdMAX "ld"
+#endif
+#endif
+
 #endif /* ASN_SYSTEM_H */
 #endif /* ASN_SYSTEM_H */
index 9fe2e895dfb65375948b83a893629959d5c576b1..1ac2a5ef0d90ea16bf8a3e1d5725fe921a34b3d5 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _BER_DECODER_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _BER_DECODER_H_
@@ -17,23 +17,26 @@ struct asn_codec_ctx_s;             /* Forward declaration */
 /*
  * The BER decoder of any type.
  * This function may be invoked directly from the application.
 /*
  * 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().
+ * Decodes BER, DER and CER data (DER and CER are different subsets of BER).
+ *
+ * NOTE: Use the der_encode() function (der_encoder.h) to produce encoding
+ * which is compliant with 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 */
-       );
+asn_dec_rval_t ber_decode(
+    const struct asn_codec_ctx_s *opt_codec_ctx,
+    const 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.
  */
 
 /*
  * 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);
+typedef asn_dec_rval_t(ber_type_decoder_f)(
+    const struct asn_codec_ctx_s *opt_codec_ctx,
+    const struct asn_TYPE_descriptor_s *type_descriptor, void **struct_ptr,
+    const void *buf_ptr, size_t size, int tag_mode);
 
 /*******************************
  * INTERNALLY USEFUL FUNCTIONS *
 
 /*******************************
  * INTERNALLY USEFUL FUNCTIONS *
@@ -47,15 +50,14 @@ typedef asn_dec_rval_t (ber_type_decoder_f)(
  * head->last_tag_form is non-zero.
  */
 asn_dec_rval_t ber_check_tags(
  * 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 */
-       );
+    const struct asn_codec_ctx_s *opt_codec_ctx, /* codec options */
+    const 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
 }
 
 #ifdef __cplusplus
 }
index 3496802244013c6c3652d5d067bccdf022e719cf..d1e4d48dd73fecb6d5d1b3cfe5529df7e2975363 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _BER_TLV_LENGTH_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _BER_TLV_LENGTH_H_
@@ -32,7 +32,7 @@ ssize_t ber_fetch_length(int _is_constructed, const void *bufptr, size_t size,
  *     Standard {-1,0,>0} convention.
  */
 ssize_t ber_skip_length(
  *     Standard {-1,0,>0} convention.
  */
 ssize_t ber_skip_length(
-       struct asn_codec_ctx_s *opt_codec_ctx,  /* optional context */
+       const struct asn_codec_ctx_s *opt_codec_ctx,    /* optional context */
        int _is_constructed, const void *bufptr, size_t size);
 
 /*
        int _is_constructed, const void *bufptr, size_t size);
 
 /*
index 60e866861b28b3861f1e482452dcde1c844e5253..ce227add6d1918cbf6dbd5edbbb1ab6eb49b027d 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _BER_TLV_TAG_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _BER_TLV_TAG_H_
index e824a2206e0895151de540ac3a3096c6f47846c1..7649480942d3c5a8cf391eaa2e90ea27e94fb935 100644 (file)
@@ -1,6 +1,5 @@
-/*-
- * Copyright (c) 2003, 2004, 2005 Lev Walkin <vlm@lionet.info>.
- * All rights reserved.
+/*
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _CONSTR_CHOICE_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _CONSTR_CHOICE_H_
 extern "C" {
 #endif
 
 extern "C" {
 #endif
 
-typedef const struct asn_CHOICE_specifics_s {
+typedef struct asn_CHOICE_specifics_s {
        /*
         * Target structure description.
         */
        /*
         * Target structure description.
         */
-       int struct_size;        /* Size of the target structure. */
-       int ctx_offset;         /* Offset of the asn_codec_ctx_t member */
-       int pres_offset;        /* Identifier of the present member */
-       int pres_size;          /* Size of the identifier (enum) */
+       unsigned struct_size;       /* Size of the target structure. */
+       unsigned ctx_offset;        /* Offset of the asn_codec_ctx_t member */
+       unsigned pres_offset;       /* Identifier of the present member */
+       unsigned pres_size;         /* Size of the identifier (enum) */
 
        /*
         * Tags to members mapping table.
         */
        const asn_TYPE_tag2member_t *tag2el;
 
        /*
         * Tags to members mapping table.
         */
        const asn_TYPE_tag2member_t *tag2el;
-       int tag2el_count;
+       unsigned tag2el_count;
 
        /* Canonical ordering of CHOICE elements, for PER */
 
        /* Canonical ordering of CHOICE elements, for PER */
-       int *canonical_order;
+       const unsigned *to_canonical_order;
+       const unsigned *from_canonical_order;
 
        /*
         * Extensions-related stuff.
         */
 
        /*
         * Extensions-related stuff.
         */
-       int ext_start;          /* First member of extensions, or -1 */
+       signed ext_start; /* First member of extensions, or -1 */
 } asn_CHOICE_specifics_t;
 
 /*
 } asn_CHOICE_specifics_t;
 
 /*
@@ -41,14 +41,35 @@ typedef const struct asn_CHOICE_specifics_s {
  */
 asn_struct_free_f CHOICE_free;
 asn_struct_print_f CHOICE_print;
  */
 asn_struct_free_f CHOICE_free;
 asn_struct_print_f CHOICE_print;
+asn_struct_compare_f CHOICE_compare;
 asn_constr_check_f CHOICE_constraint;
 ber_type_decoder_f CHOICE_decode_ber;
 der_type_encoder_f CHOICE_encode_der;
 xer_type_decoder_f CHOICE_decode_xer;
 xer_type_encoder_f CHOICE_encode_xer;
 asn_constr_check_f CHOICE_constraint;
 ber_type_decoder_f CHOICE_decode_ber;
 der_type_encoder_f CHOICE_encode_der;
 xer_type_decoder_f CHOICE_decode_xer;
 xer_type_encoder_f CHOICE_encode_xer;
+oer_type_decoder_f CHOICE_decode_oer;
+oer_type_encoder_f CHOICE_encode_oer;
 per_type_decoder_f CHOICE_decode_uper;
 per_type_encoder_f CHOICE_encode_uper;
 asn_outmost_tag_f CHOICE_outmost_tag;
 per_type_decoder_f CHOICE_decode_uper;
 per_type_encoder_f CHOICE_encode_uper;
 asn_outmost_tag_f CHOICE_outmost_tag;
+asn_random_fill_f CHOICE_random_fill;
+extern asn_TYPE_operation_t asn_OP_CHOICE;
+
+/*
+ * Return the 1-based choice variant presence index.
+ * Returns 0 in case of error.
+ */
+unsigned CHOICE_variant_get_presence(const asn_TYPE_descriptor_t *td,
+                                     const void *structure_ptr);
+
+/*
+ * Sets or resets the 1-based choice variant presence index.
+ * In case a previous index is not zero, the currently selected structure
+ * member is freed and zeroed-out first.
+ * Returns 0 on success and -1 on error.
+ */
+int CHOICE_variant_set_presence(const asn_TYPE_descriptor_t *td,
+                                void *structure_ptr, unsigned present);
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index c2aeb66767571075ec41cc2aac5557879eab051a..f9dd4e5ef952d0c8eac86e4a9f3f25678c6a81d9 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _CONSTR_SEQUENCE_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _CONSTR_SEQUENCE_H_
 extern "C" {
 #endif
 
 extern "C" {
 #endif
 
-typedef const struct asn_SEQUENCE_specifics_s {
+typedef struct asn_SEQUENCE_specifics_s {
        /*
         * Target structure description.
         */
        /*
         * Target structure description.
         */
-       int struct_size;        /* Size of the target structure. */
-       int ctx_offset;         /* Offset of the asn_struct_ctx_t member */
+       unsigned struct_size;   /* Size of the target structure. */
+       unsigned ctx_offset;    /* Offset of the asn_struct_ctx_t member */
 
        /*
         * Tags to members mapping table (sorted).
         */
        const asn_TYPE_tag2member_t *tag2el;
 
        /*
         * Tags to members mapping table (sorted).
         */
        const asn_TYPE_tag2member_t *tag2el;
-       int tag2el_count;
+       unsigned tag2el_count;
 
        /*
         * Optional members of the extensions root (roms) or additions (aoms).
         * Meaningful for PER.
         */
 
        /*
         * Optional members of the extensions root (roms) or additions (aoms).
         * Meaningful for PER.
         */
-       const int *oms;         /* Optional MemberS */
-       int  roms_count;        /* Root optional members count */
-       int  aoms_count;        /* Additions optional members count */
+       const int *oms;         /* Optional MemberS */
+       unsigned roms_count;    /* Root optional members count */
+       unsigned aoms_count;    /* Additions optional members count */
 
        /*
         * Description of an extensions group.
 
        /*
         * Description of an extensions group.
+        * Root components are clustered at the beginning of the structure,
+        * whereas extensions are clustered at the end. -1 means not extensible.
         */
         */
-       int ext_after;          /* Extensions start after this member */
-       int ext_before;         /* Extensions stop before this member */
+       signed first_extension;       /* First extension addition */
 } asn_SEQUENCE_specifics_t;
 
 
 } asn_SEQUENCE_specifics_t;
 
 
@@ -45,13 +46,18 @@ typedef const struct asn_SEQUENCE_specifics_s {
  */
 asn_struct_free_f SEQUENCE_free;
 asn_struct_print_f SEQUENCE_print;
  */
 asn_struct_free_f SEQUENCE_free;
 asn_struct_print_f SEQUENCE_print;
+asn_struct_compare_f SEQUENCE_compare;
 asn_constr_check_f SEQUENCE_constraint;
 ber_type_decoder_f SEQUENCE_decode_ber;
 der_type_encoder_f SEQUENCE_encode_der;
 xer_type_decoder_f SEQUENCE_decode_xer;
 xer_type_encoder_f SEQUENCE_encode_xer;
 asn_constr_check_f SEQUENCE_constraint;
 ber_type_decoder_f SEQUENCE_decode_ber;
 der_type_encoder_f SEQUENCE_encode_der;
 xer_type_decoder_f SEQUENCE_decode_xer;
 xer_type_encoder_f SEQUENCE_encode_xer;
+oer_type_decoder_f SEQUENCE_decode_oer;
+oer_type_encoder_f SEQUENCE_encode_oer;
 per_type_decoder_f SEQUENCE_decode_uper;
 per_type_encoder_f SEQUENCE_encode_uper;
 per_type_decoder_f SEQUENCE_decode_uper;
 per_type_encoder_f SEQUENCE_encode_uper;
+asn_random_fill_f  SEQUENCE_random_fill;
+extern asn_TYPE_operation_t asn_OP_SEQUENCE;
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index e2272f326ba1b961f3f0539c160481f9348b49da..f21b91e1677dbc075fed48014cea17c4ac130ab8 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _CONSTR_SEQUENCE_OF_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _CONSTR_SEQUENCE_OF_H_
@@ -16,15 +16,21 @@ extern "C" {
  * A set specialized functions dealing with the SEQUENCE OF type.
  * Generally implemented using SET OF.
  */
  * A set specialized functions dealing with the SEQUENCE OF type.
  * Generally implemented using SET OF.
  */
+asn_struct_compare_f SEQUENCE_OF_compare;
+der_type_encoder_f SEQUENCE_OF_encode_der;
+xer_type_encoder_f SEQUENCE_OF_encode_xer;
+per_type_encoder_f SEQUENCE_OF_encode_uper;
+extern asn_TYPE_operation_t asn_OP_SEQUENCE_OF;
+
 #define        SEQUENCE_OF_free        SET_OF_free
 #define        SEQUENCE_OF_print       SET_OF_print
 #define        SEQUENCE_OF_constraint  SET_OF_constraint
 #define        SEQUENCE_OF_decode_ber  SET_OF_decode_ber
 #define        SEQUENCE_OF_decode_xer  SET_OF_decode_xer
 #define        SEQUENCE_OF_decode_uper SET_OF_decode_uper
 #define        SEQUENCE_OF_free        SET_OF_free
 #define        SEQUENCE_OF_print       SET_OF_print
 #define        SEQUENCE_OF_constraint  SET_OF_constraint
 #define        SEQUENCE_OF_decode_ber  SET_OF_decode_ber
 #define        SEQUENCE_OF_decode_xer  SET_OF_decode_xer
 #define        SEQUENCE_OF_decode_uper SET_OF_decode_uper
-der_type_encoder_f SEQUENCE_OF_encode_der;
-xer_type_encoder_f SEQUENCE_OF_encode_xer;
-per_type_encoder_f SEQUENCE_OF_encode_uper;
+#define        SEQUENCE_OF_decode_oer  SET_OF_decode_oer
+#define        SEQUENCE_OF_encode_oer  SET_OF_encode_oer
+#define        SEQUENCE_OF_random_fill SET_OF_random_fill
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 75e18cfa0c5f0db1df2610055db41307c7a3303c..f32e607bad05aa35d3f4056eabb5b46b38cbbaa6 100644 (file)
@@ -1,9 +1,9 @@
 /*-
 /*-
- * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
  * Redistribution and modifications are permitted subject to BSD license.
  */
-#ifndef        _CONSTR_SET_OF_H_
-#define        _CONSTR_SET_OF_H_
+#ifndef        CONSTR_SET_OF_H
+#define        CONSTR_SET_OF_H
 
 #include <asn_application.h>
 
 
 #include <asn_application.h>
 
 extern "C" {
 #endif
 
 extern "C" {
 #endif
 
-typedef const struct asn_SET_OF_specifics_s {
-       /*
-        * Target structure description.
-        */
-       int struct_size;        /* Size of the target structure. */
-       int ctx_offset;         /* Offset of the asn_struct_ctx_t member */
+typedef struct asn_SET_OF_specifics_s {
+    /*
+     * Target structure description.
+     */
+    unsigned struct_size;       /* Size of the target structure. */
+    unsigned ctx_offset;        /* Offset of the asn_struct_ctx_t member */
 
 
-       /* XER-specific stuff */
-       int as_XMLValueList;    /* The member type must be encoded like this */
+    /* XER-specific stuff */
+    int as_XMLValueList; /* The member type must be encoded like this */
 } asn_SET_OF_specifics_t;
 
 /*
 } asn_SET_OF_specifics_t;
 
 /*
@@ -27,16 +27,21 @@ typedef const struct asn_SET_OF_specifics_s {
  */
 asn_struct_free_f SET_OF_free;
 asn_struct_print_f SET_OF_print;
  */
 asn_struct_free_f SET_OF_free;
 asn_struct_print_f SET_OF_print;
+asn_struct_compare_f SET_OF_compare;
 asn_constr_check_f SET_OF_constraint;
 ber_type_decoder_f SET_OF_decode_ber;
 der_type_encoder_f SET_OF_encode_der;
 xer_type_decoder_f SET_OF_decode_xer;
 xer_type_encoder_f SET_OF_encode_xer;
 asn_constr_check_f SET_OF_constraint;
 ber_type_decoder_f SET_OF_decode_ber;
 der_type_encoder_f SET_OF_encode_der;
 xer_type_decoder_f SET_OF_decode_xer;
 xer_type_encoder_f SET_OF_encode_xer;
+oer_type_decoder_f SET_OF_decode_oer;
+oer_type_encoder_f SET_OF_encode_oer;
 per_type_decoder_f SET_OF_decode_uper;
 per_type_encoder_f SET_OF_encode_uper;
 per_type_decoder_f SET_OF_decode_uper;
 per_type_encoder_f SET_OF_encode_uper;
+asn_random_fill_f  SET_OF_random_fill;
+extern asn_TYPE_operation_t asn_OP_SET_OF;
 
 #ifdef __cplusplus
 }
 #endif
 
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* _CONSTR_SET_OF_H_ */
+#endif /* CONSTR_SET_OF_H */
index a9cd86dc3d6543657242021a9518b8e0ed472872..10bb0f36df7c9c0f1855abd37b1b2b62d997cb2f 100644 (file)
@@ -1,6 +1,5 @@
-/*-
- * Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
- * All rights reserved.
+/*
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 /*
  * Redistribution and modifications are permitted subject to BSD license.
  */
 /*
@@ -42,29 +41,77 @@ typedef struct asn_struct_ctx_s {
 #include <per_decoder.h>       /* Packet Encoding Rules decoder */
 #include <per_encoder.h>       /* Packet Encoding Rules encoder */
 #include <constraints.h>       /* Subtype constraints support */
 #include <per_decoder.h>       /* Packet Encoding Rules decoder */
 #include <per_encoder.h>       /* Packet Encoding Rules encoder */
 #include <constraints.h>       /* Subtype constraints support */
+#include <asn_random_fill.h>   /* Random structures support */
+
+#ifdef  ASN_DISABLE_OER_SUPPORT
+typedef void (oer_type_decoder_f)(void);
+typedef void (oer_type_encoder_f)(void);
+typedef void asn_oer_constraints_t;
+#else
+#include <oer_decoder.h>       /* Octet Encoding Rules encoder */
+#include <oer_encoder.h>       /* Octet Encoding Rules encoder */
+#endif
 
 /*
  * Free the structure according to its specification.
 
 /*
  * Free the structure according to its specification.
- * If (free_contents_only) is set, the wrapper structure itself (struct_ptr)
- * will not be freed. (It may be useful in case the structure is allocated
- * statically or arranged on the stack, yet its elements are allocated
- * dynamically.)
+ * Use one of ASN_STRUCT_{FREE,RESET,CONTENTS_ONLY} macros instead.
+ * Do not use directly.
  */
  */
+enum asn_struct_free_method {
+    ASFM_FREE_EVERYTHING,   /* free(struct_ptr) and underlying members */
+    ASFM_FREE_UNDERLYING,   /* free underlying members */
+    ASFM_FREE_UNDERLYING_AND_RESET   /* FREE_UNDERLYING + memset(0) */
+};
 typedef void (asn_struct_free_f)(
 typedef void (asn_struct_free_f)(
-               struct asn_TYPE_descriptor_s *type_descriptor,
-               void *struct_ptr, int free_contents_only);
-#define        ASN_STRUCT_FREE(asn_DEF, ptr)   (asn_DEF).free_struct(&(asn_DEF),ptr,0)
-#define        ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF, ptr)     \
-                                       (asn_DEF).free_struct(&(asn_DEF),ptr,1)
+               const struct asn_TYPE_descriptor_s *type_descriptor,
+               void *struct_ptr, enum asn_struct_free_method);
+
+/*
+ * Free the structure including freeing the memory pointed to by ptr itself.
+ */
+#define ASN_STRUCT_FREE(asn_DEF, ptr) \
+    (asn_DEF).op->free_struct(&(asn_DEF), (ptr), ASFM_FREE_EVERYTHING)
+
+/*
+ * Free the memory used by the members of the structure without freeing the
+ * the structure pointer itself.
+ * ZERO-OUT the structure to the safe clean state.
+ * (Retaining the pointer may be useful in case the structure is allocated
+ *  statically or arranged on the stack, yet its elements are dynamic.)
+ */
+#define ASN_STRUCT_RESET(asn_DEF, ptr) \
+    (asn_DEF).op->free_struct(&(asn_DEF), (ptr), ASFM_FREE_UNDERLYING_AND_RESET)
+
+/*
+ * Free memory used by the members of the structure without freeing
+ * the structure pointer itself.
+ * (Retaining the pointer may be useful in case the structure is allocated
+ *  statically or arranged on the stack, yet its elements are dynamic.)
+ * AVOID using it in the application code;
+ * Use a safer ASN_STRUCT_RESET() instead.
+ */
+#define ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF, ptr) \
+    (asn_DEF).op->free_struct(&(asn_DEF), (ptr), ASFM_FREE_UNDERLYING)
 
 /*
  * Print the structure according to its specification.
  */
 
 /*
  * Print the structure according to its specification.
  */
-typedef int (asn_struct_print_f)(
-               struct asn_TYPE_descriptor_s *type_descriptor,
-               const void *struct_ptr,
-               int level,      /* Indentation level */
-               asn_app_consume_bytes_f *callback, void *app_key);
+typedef int(asn_struct_print_f)(
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const void *struct_ptr,
+    int level, /* Indentation level */
+    asn_app_consume_bytes_f *callback, void *app_key);
+
+/*
+ * Compare two structs between each other.
+ * Returns <0 if struct_A is "smaller" than struct_B, >0 if "greater",
+ * and =0 if "equal to", for some type-specific, stable definition of
+ * "smaller", "greater" and "equal to".
+ */
+typedef int (asn_struct_compare_f)(
+               const struct asn_TYPE_descriptor_s *type_descriptor,
+               const void *struct_A,
+               const void *struct_B);
 
 /*
  * Return the outmost tag of the type.
 
 /*
  * Return the outmost tag of the type.
@@ -78,54 +125,86 @@ typedef ber_tlv_tag_t (asn_outmost_tag_f)(
 /* The instance of the above function type; used internally. */
 asn_outmost_tag_f asn_TYPE_outmost_tag;
 
 /* The instance of the above function type; used internally. */
 asn_outmost_tag_f asn_TYPE_outmost_tag;
 
-\f
+/*
+ * Fetch the desired type of the Open Type based on the
+ * Information Object Set driven constraints.
+ */
+typedef struct asn_type_selector_result_s {
+    const struct asn_TYPE_descriptor_s *type_descriptor; /* Type encoded. */
+    unsigned presence_index; /* Associated choice variant. */
+} asn_type_selector_result_t;
+typedef asn_type_selector_result_t(asn_type_selector_f)(
+    const struct asn_TYPE_descriptor_s *parent_type_descriptor,
+    const void *parent_structure_ptr);
+
+/*
+ * Generalized functions for dealing with the speciic type.
+ * May be directly invoked by applications.
+ */
+typedef struct asn_TYPE_operation_s {
+    asn_struct_free_f *free_struct;     /* Free the structure */
+    asn_struct_print_f *print_struct;   /* Human readable output */
+    asn_struct_compare_f *compare_struct; /* Compare two structures */
+    ber_type_decoder_f *ber_decoder;      /* Generic BER decoder */
+    der_type_encoder_f *der_encoder;      /* Canonical DER encoder */
+    xer_type_decoder_f *xer_decoder;      /* Generic XER decoder */
+    xer_type_encoder_f *xer_encoder;      /* [Canonical] XER encoder */
+    oer_type_decoder_f *oer_decoder;      /* Generic OER decoder */
+    oer_type_encoder_f *oer_encoder;      /* Canonical OER encoder */
+    per_type_decoder_f *uper_decoder;     /* Unaligned PER decoder */
+    per_type_encoder_f *uper_encoder;     /* Unaligned PER encoder */
+    asn_random_fill_f *random_fill;       /* Initialize with a random value */
+    asn_outmost_tag_f *outmost_tag;       /* <optional, internal> */
+} asn_TYPE_operation_t;
+
+/*
+ * A constraints tuple specifying both the OER and PER constraints.
+ */
+typedef struct asn_encoding_constraints_s {
+    const struct asn_oer_constraints_s *oer_constraints;
+    const struct asn_per_constraints_s *per_constraints;
+    asn_constr_check_f *general_constraints;
+} asn_encoding_constraints_t;
+
 /*
  * The definitive description of the destination language's structure.
  */
 typedef struct asn_TYPE_descriptor_s {
 /*
  * The definitive description of the destination language's structure.
  */
 typedef struct asn_TYPE_descriptor_s {
-       const char *name;       /* A name of the ASN.1 type. "" in some cases. */
-       const char *xml_tag;    /* Name used in XML tag */
-
-       /*
-        * Generalized functions for dealing with the specific type.
-        * May be directly invoked by applications.
-        */
-       asn_struct_free_f  *free_struct;        /* Free the structure */
-       asn_struct_print_f *print_struct;       /* Human readable output */
-       asn_constr_check_f *check_constraints;  /* Constraints validator */
-       ber_type_decoder_f *ber_decoder;        /* Generic BER decoder */
-       der_type_encoder_f *der_encoder;        /* Canonical DER encoder */
-       xer_type_decoder_f *xer_decoder;        /* Generic XER decoder */
-       xer_type_encoder_f *xer_encoder;        /* [Canonical] XER encoder */
-       per_type_decoder_f *uper_decoder;       /* Unaligned PER decoder */
-       per_type_encoder_f *uper_encoder;       /* Unaligned PER encoder */
-
-       /***********************************************************************
-        * Internally useful members. Not to be used by applications directly. *
-        **********************************************************************/
-
-       /*
-        * Tags that are expected to occur.
-        */
-       asn_outmost_tag_f  *outmost_tag;        /* <optional, internal> */
-       const ber_tlv_tag_t *tags;      /* Effective tags sequence for this type */
-       int tags_count;                 /* Number of tags which are expected */
-       const ber_tlv_tag_t *all_tags;  /* Every tag for BER/containment */
-       int all_tags_count;             /* Number of tags */
-
-       asn_per_constraints_t *per_constraints; /* PER compiled constraints */
-
-       /*
-        * An ASN.1 production type members (members of SEQUENCE, SET, CHOICE).
-        */
-       struct asn_TYPE_member_s *elements;
-       int elements_count;
-
-       /*
-        * Additional information describing the type, used by appropriate
-        * functions above.
-        */
-       const void *specifics;
+    const char *name;       /* A name of the ASN.1 type. "" in some cases. */
+    const char *xml_tag;    /* Name used in XML tag */
+
+    /*
+     * Generalized functions for dealing with the specific type.
+     * May be directly invoked by applications.
+     */
+    asn_TYPE_operation_t *op;
+
+    /***********************************************************************
+     * Internally useful members. Not to be used by applications directly. *
+     **********************************************************************/
+
+    /*
+     * Tags that are expected to occur.
+     */
+    const ber_tlv_tag_t *tags;      /* Effective tags sequence for this type */
+    unsigned tags_count;            /* Number of tags which are expected */
+    const ber_tlv_tag_t *all_tags;  /* Every tag for BER/containment */
+    unsigned all_tags_count;        /* Number of tags */
+
+    /* OER, PER, and general constraints */
+    asn_encoding_constraints_t encoding_constraints;
+
+    /*
+     * An ASN.1 production type members (members of SEQUENCE, SET, CHOICE).
+     */
+    struct asn_TYPE_member_s *elements;
+    unsigned elements_count;
+
+    /*
+     * Additional information describing the type, used by appropriate
+     * functions above.
+     */
+    const void *specifics;
 } asn_TYPE_descriptor_t;
 
 /*
 } asn_TYPE_descriptor_t;
 
 /*
@@ -133,45 +212,46 @@ typedef struct asn_TYPE_descriptor_s {
  * i.e. SEQUENCE, SET, CHOICE, etc.
  */
   enum asn_TYPE_flags_e {
  * i.e. SEQUENCE, SET, CHOICE, etc.
  */
   enum asn_TYPE_flags_e {
-       ATF_NOFLAGS,
-       ATF_POINTER     = 0x01, /* Represented by the pointer */
-       ATF_OPEN_TYPE   = 0x02  /* ANY type, without meaningful tag */
+    ATF_NOFLAGS,
+    ATF_POINTER = 0x01,   /* Represented by the pointer */
+    ATF_OPEN_TYPE = 0x02, /* Open Type */
+    ATF_ANY_TYPE = 0x04   /* ANY type (deprecated!) */
   };
 typedef struct asn_TYPE_member_s {
   };
 typedef struct asn_TYPE_member_s {
-       enum asn_TYPE_flags_e flags;    /* Element's presentation flags */
-       int optional;   /* Following optional members, including current */
-       int memb_offset;                /* Offset of the element */
-       ber_tlv_tag_t tag;              /* Outmost (most immediate) tag */
-       int tag_mode;           /* IMPLICIT/no/EXPLICIT tag at current level */
-       asn_TYPE_descriptor_t *type;    /* Member type descriptor */
-       asn_constr_check_f *memb_constraints;   /* Constraints validator */
-       asn_per_constraints_t *per_constraints; /* PER compiled constraints */
-       int (*default_value)(int setval, void **sptr);  /* DEFAULT <value> */
-       const char *name;                       /* ASN.1 identifier of the element */
+    enum asn_TYPE_flags_e flags; /* Element's presentation flags */
+    unsigned optional;      /* Following optional members, including current */
+    unsigned memb_offset;   /* Offset of the element */
+    ber_tlv_tag_t tag;      /* Outmost (most immediate) tag */
+    int tag_mode;           /* IMPLICIT/no/EXPLICIT tag at current level */
+    asn_TYPE_descriptor_t *type;            /* Member type descriptor */
+    asn_type_selector_f *type_selector;     /* IoS runtime type selector */
+    asn_encoding_constraints_t encoding_constraints;
+    int (*default_value_cmp)(const void *sptr); /* Compare DEFAULT <value> */
+    int (*default_value_set)(void **sptr);      /* Set DEFAULT <value> */
+    const char *name; /* ASN.1 identifier of the element */
 } asn_TYPE_member_t;
 
 /*
  * BER tag to element number mapping.
  */
 typedef struct asn_TYPE_tag2member_s {
 } asn_TYPE_member_t;
 
 /*
  * BER tag to element number mapping.
  */
 typedef struct asn_TYPE_tag2member_s {
-       ber_tlv_tag_t el_tag;   /* Outmost tag of the member */
-       int el_no;              /* Index of the associated member, base 0 */
-       int toff_first;         /* First occurence of the el_tag, relative */
-       int toff_last;          /* Last occurence of the el_tag, relatvie */
+    ber_tlv_tag_t el_tag;   /* Outmost tag of the member */
+    unsigned el_no;         /* Index of the associated member, base 0 */
+    int toff_first;         /* First occurence of the el_tag, relative */
+    int toff_last;          /* Last occurence of the el_tag, relative */
 } asn_TYPE_tag2member_t;
 
 /*
 } asn_TYPE_tag2member_t;
 
 /*
- * This function is a wrapper around (td)->print_struct, which prints out
- * the contents of the target language's structure (struct_ptr) into the
- * file pointer (stream) in human readable form.
+ * This function prints out the contents of the target language's structure
+ * (struct_ptr) into the file pointer (stream) in human readable form.
  * RETURN VALUES:
  *      0: The structure is printed.
  *     -1: Problem dumping the structure.
  * (See also xer_fprint() in xer_encoder.h)
  */
  * RETURN VALUES:
  *      0: The structure is printed.
  *     -1: Problem dumping the structure.
  * (See also xer_fprint() in xer_encoder.h)
  */
-int asn_fprint(FILE *stream,           /* Destination stream descriptor */
-       asn_TYPE_descriptor_t *td,      /* ASN.1 type descriptor */
-       const void *struct_ptr);        /* Structure to be printed */
+int asn_fprint(FILE *stream, /* Destination stream descriptor */
+               const asn_TYPE_descriptor_t *td, /* ASN.1 type descriptor */
+               const void *struct_ptr);         /* Structure to be printed */
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 48d49e246a3ff3a2f0bcb81c0e42ba854bef28d9..0bd86a96bf17ee0e532dd04ed16268eb2001aaf2 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2004, 2006 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN1_CONSTRAINTS_VALIDATOR_H
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        ASN1_CONSTRAINTS_VALIDATOR_H
@@ -25,24 +25,23 @@ struct asn_TYPE_descriptor_s;               /* Forward declaration */
  * This function returns 0 in case all ASN.1 constraints are met
  * and -1 if one or more constraints were failed.
  */
  * This function returns 0 in case all ASN.1 constraints are met
  * and -1 if one or more constraints were failed.
  */
-int
-asn_check_constraints(struct asn_TYPE_descriptor_s *type_descriptor,
-       const void *struct_ptr, /* Target language's structure */
-       char *errbuf,           /* Returned error description */
-       size_t *errlen          /* Length of the error description */
-       );
+int asn_check_constraints(
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const void *struct_ptr, /* Target language's structure */
+    char *errbuf,           /* Returned error description */
+    size_t *errlen          /* Length of the error description */
+);
 
 
 /*
  * Generic type for constraint checking callback,
  * associated with every type descriptor.
  */
 
 
 /*
  * Generic type for constraint checking callback,
  * associated with every type descriptor.
  */
-typedef int (asn_constr_check_f)(
-       struct asn_TYPE_descriptor_s *type_descriptor,
-       const void *struct_ptr,
-       asn_app_constraint_failed_f *optional_callback, /* Log the error */
-       void *optional_app_key          /* Opaque key passed to a callback */
-       );
+typedef int(asn_constr_check_f)(
+    const struct asn_TYPE_descriptor_s *type_descriptor, const void *struct_ptr,
+    asn_app_constraint_failed_f *optional_callback, /* Log the error */
+    void *optional_app_key /* Opaque key passed to a callback */
+);
 
 /*******************************
  * INTERNALLY USEFUL FUNCTIONS *
 
 /*******************************
  * INTERNALLY USEFUL FUNCTIONS *
index 61431c6dbdc87e98de8b7804d438476bca86caa5..e93944edc2a7fecef22c0281151fec9ea16b2b49 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _DER_ENCODER_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _DER_ENCODER_H_
@@ -15,33 +15,35 @@ struct asn_TYPE_descriptor_s;       /* Forward declaration */
 
 /*
  * The DER encoder of any type. May be invoked by the application.
 
 /*
  * The DER encoder of any type. May be invoked by the application.
- * The ber_decode() function (ber_decoder.h) is an opposite of der_encode().
+ * Produces DER- and BER-compliant encoding. (DER is a subset of BER).
+ *
+ * NOTE: Use the ber_decode() function (ber_decoder.h) to decode data
+ * produced by der_encode().
  */
  */
-asn_enc_rval_t der_encode(struct asn_TYPE_descriptor_s *type_descriptor,
-               void *struct_ptr,       /* Structure to be encoded */
-               asn_app_consume_bytes_f *consume_bytes_cb,
-               void *app_key           /* Arbitrary callback argument */
-       );
+asn_enc_rval_t der_encode(const struct asn_TYPE_descriptor_s *type_descriptor,
+                          const void *struct_ptr, /* Structure to be encoded */
+                          asn_app_consume_bytes_f *consume_bytes_cb,
+                          void *app_key /* Arbitrary callback argument */
+);
 
 /* A variant of der_encode() which encodes data into the pre-allocated buffer */
 asn_enc_rval_t der_encode_to_buffer(
 
 /* A variant of der_encode() which encodes data into the pre-allocated buffer */
 asn_enc_rval_t der_encode_to_buffer(
-               struct asn_TYPE_descriptor_s *type_descriptor,
-               void *struct_ptr,       /* Structure to be encoded */
-               void *buffer,           /* Pre-allocated buffer */
-               size_t buffer_size      /* Initial buffer size (maximum) */
-       );
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const void *struct_ptr, /* Structure to be encoded */
+    void *buffer,           /* Pre-allocated buffer */
+    size_t buffer_size      /* Initial buffer size (maximum) */
+);
 
 /*
  * Type of the generic DER encoder.
  */
 
 /*
  * Type of the generic DER encoder.
  */
-typedef asn_enc_rval_t (der_type_encoder_f)(
-               struct asn_TYPE_descriptor_s *type_descriptor,
-               void *struct_ptr,       /* Structure to be encoded */
-               int tag_mode,           /* {-1,0,1}: IMPLICIT, no, EXPLICIT */
-               ber_tlv_tag_t tag,
-               asn_app_consume_bytes_f *consume_bytes_cb,      /* Callback */
-               void *app_key           /* Arbitrary callback argument */
-       );
+typedef asn_enc_rval_t(der_type_encoder_f)(
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const void *struct_ptr, /* Structure to be encoded */
+    int tag_mode,           /* {-1,0,1}: IMPLICIT, no, EXPLICIT */
+    ber_tlv_tag_t tag, asn_app_consume_bytes_f *consume_bytes_cb, /* Callback */
+    void *app_key /* Arbitrary callback argument */
+);
 
 
 /*******************************
 
 
 /*******************************
@@ -51,15 +53,13 @@ typedef asn_enc_rval_t (der_type_encoder_f)(
 /*
  * Write out leading TL[v] sequence according to the type definition.
  */
 /*
  * Write out leading TL[v] sequence according to the type definition.
  */
-ssize_t der_write_tags(
-               struct asn_TYPE_descriptor_s *type_descriptor,
-               size_t struct_length,
-               int tag_mode,           /* {-1,0,1}: IMPLICIT, no, EXPLICIT */
-               int last_tag_form,      /* {0,!0}: prim, constructed */
-               ber_tlv_tag_t tag,
-               asn_app_consume_bytes_f *consume_bytes_cb,
-               void *app_key
-       );
+ssize_t der_write_tags(const struct asn_TYPE_descriptor_s *type_descriptor,
+                       size_t struct_length,
+                       int tag_mode,      /* {-1,0,1}: IMPLICIT, no, EXPLICIT */
+                       int last_tag_form, /* {0,!0}: prim, constructed */
+                       ber_tlv_tag_t tag,
+                       asn_app_consume_bytes_f *consume_bytes_cb,
+                       void *app_key);
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
diff --git a/libs/smux/include/stg/oer_decoder.h b/libs/smux/include/stg/oer_decoder.h
new file mode 100644 (file)
index 0000000..40992e9
--- /dev/null
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        OER_DECODER_H
+#define        OER_DECODER_H
+
+#include <asn_application.h>
+#include <oer_support.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct asn_TYPE_descriptor_s;  /* Forward declaration */
+struct asn_codec_ctx_s;                /* Forward declaration */
+
+/*
+ * The Octet Encoding Rules (OER, X.696 08/2015) decoder for any given type.
+ * This function may be invoked directly by the application.
+ * Parses CANONICAL-OER and BASIC-OER.
+ */
+asn_dec_rval_t oer_decode(const struct asn_codec_ctx_s *opt_codec_ctx,
+       const 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(oer_type_decoder_f)(
+    const struct asn_codec_ctx_s *opt_codec_ctx,
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const asn_oer_constraints_t *constraints,
+    void **struct_ptr,
+    const void *buf_ptr,
+    size_t size);
+
+/*
+ * Swallow the Open Type (X.696 (08/2015), #30) into /dev/null.
+ * RETURN VALUES:
+ *      -1:     Fatal error deciphering length.
+ *       0:     More data expected than bufptr contains.
+ *      >0:     Number of bytes used from bufptr.
+ */
+ssize_t oer_open_type_skip(const void *bufptr, size_t size);
+
+/*
+ * Read the Open Type (X.696 (08/2015), #30).
+ * RETURN VALUES:
+ *       0:     More data expected than bufptr contains.
+ *      -1:     Fatal error deciphering length.
+ *      >0:     Number of bytes used from bufptr.
+ */
+ssize_t oer_open_type_get(const asn_codec_ctx_t *opt_codec_ctx,
+                          const struct asn_TYPE_descriptor_s *td,
+                          const asn_oer_constraints_t *constraints,
+                          void **struct_ptr, const void *bufptr, size_t size);
+
+/*
+ * Length-prefixed buffer decoding for primitive types.
+ */
+oer_type_decoder_f oer_decode_primitive;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OER_DECODER_H */
diff --git a/libs/smux/include/stg/oer_encoder.h b/libs/smux/include/stg/oer_encoder.h
new file mode 100644 (file)
index 0000000..6a7b681
--- /dev/null
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        OER_ENCODER_H
+#define        OER_ENCODER_H
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct asn_TYPE_descriptor_s;  /* Forward declaration */
+
+/*
+ * The Octet Encoding Rules (OER, X.696 08/2015) encoder for any type.
+ * This function may be invoked directly by the application.
+ * Produces CANONICAL-OER output compatible with CANONICAL-OER
+ * and BASIC-OER decoders.
+ */
+asn_enc_rval_t oer_encode(const struct asn_TYPE_descriptor_s *type_descriptor,
+                          const void *struct_ptr, /* Structure to be encoded */
+                          asn_app_consume_bytes_f *consume_bytes_cb,
+                          void *app_key /* Arbitrary callback argument */
+);
+
+/* A variant of oer_encode() which encodes data into the pre-allocated buffer */
+asn_enc_rval_t oer_encode_to_buffer(
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const asn_oer_constraints_t *constraints,
+    const void *struct_ptr, /* Structure to be encoded */
+    void *buffer,           /* Pre-allocated buffer */
+    size_t buffer_size      /* Initial buffer size (maximum) */
+);
+
+/*
+ * Type of the generic OER encoder.
+ */
+typedef asn_enc_rval_t(oer_type_encoder_f)(
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const asn_oer_constraints_t *constraints,
+    const void *struct_ptr,                    /* Structure to be encoded */
+    asn_app_consume_bytes_f *consume_bytes_cb, /* Callback */
+    void *app_key                              /* Arbitrary callback argument */
+);
+
+/*
+ * Write out the Open Type (X.696 (08/2015), #30).
+ * RETURN VALUES:
+ *  -1: Fatal error encoding the type.
+ *  >0: Number of bytes serialized.
+ */
+ssize_t oer_open_type_put(const struct asn_TYPE_descriptor_s *td,
+                          const asn_oer_constraints_t *constraints,
+                          const void *struct_ptr,
+                          asn_app_consume_bytes_f *consume_bytes_cb,
+                          void *app_key);
+
+
+/*
+ * Length-prefixed buffer encoding for primitive types.
+ */
+oer_type_encoder_f oer_encode_primitive;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OER_ENCODER_H */
diff --git a/libs/smux/include/stg/oer_support.h b/libs/smux/include/stg/oer_support.h
new file mode 100644 (file)
index 0000000..dbc9b5f
--- /dev/null
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef        OER_SUPPORT_H
+#define        OER_SUPPORT_H
+
+#include <asn_system.h>                /* Platform-specific types */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Pre-computed OER constraints.
+ */
+typedef struct asn_oer_constraint_number_s {
+    unsigned width;    /* Â±8,4,2,1 fixed bytes */
+    unsigned positive; /* 1 for unsigned number, 0 for signed */
+} asn_oer_constraint_number_t;
+typedef struct asn_oer_constraints_s {
+    asn_oer_constraint_number_t value;
+    ssize_t size;    /* -1 (no constraint) or >= 0 */
+} asn_oer_constraints_t;
+
+
+/*
+ * Fetch the length determinant (X.696 (08/2015), #8.6) into *len_r.
+ * RETURN VALUES:
+ *       0:     More data expected than bufptr contains.
+ *      -1:     Fatal error deciphering length.
+ *      >0:     Number of bytes used from bufptr.
+ */
+ssize_t oer_fetch_length(const void *bufptr, size_t size, size_t *len_r);
+
+/*
+ * Serialize OER length. Returns the number of bytes serialized
+ * or -1 if a given callback returned with negative result.
+ */
+ssize_t oer_serialize_length(size_t length, asn_app_consume_bytes_f *cb, void *app_key);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OER_SUPPORT_H */
index 8397a545fb9b2e950942aae892a32385730989e7..710f4ee096fad95ae948b79ed05659a4851ddd99 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2005, 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2005-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _PER_DECODER_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _PER_DECODER_H_
@@ -15,39 +15,40 @@ extern "C" {
 struct asn_TYPE_descriptor_s;  /* Forward declaration */
 
 /*
 struct asn_TYPE_descriptor_s;  /* Forward declaration */
 
 /*
- * Unaligned PER decoder of a "complete encoding" as per X.691#10.1.
- * On success, this call always returns (.consumed >= 1), as per X.691#10.1.3.
+ * Unaligned PER decoder of a "complete encoding" as per X.691 (08/2015) #11.1.
+ * On success, this call always returns (.consumed >= 1), as per #11.1.3.
  */
  */
-asn_dec_rval_t uper_decode_complete(struct asn_codec_ctx_s *opt_codec_ctx,
-       struct asn_TYPE_descriptor_s *type_descriptor,  /* Type to decode */
-       void **struct_ptr,      /* Pointer to a target structure's pointer */
-       const void *buffer,     /* Data to be decoded */
-       size_t size             /* Size of data buffer */
-       );
+asn_dec_rval_t uper_decode_complete(
+    const struct asn_codec_ctx_s *opt_codec_ctx,
+    const struct asn_TYPE_descriptor_s *type_descriptor, /* Type to decode */
+    void **struct_ptr,  /* Pointer to a target structure's pointer */
+    const void *buffer, /* Data to be decoded */
+    size_t size         /* Size of data buffer */
+);
 
 /*
  * Unaligned PER decoder of any ASN.1 type. May be invoked by the application.
  * WARNING: This call returns the number of BITS read from the stream. Beware.
  */
 
 /*
  * Unaligned PER decoder of any ASN.1 type. May be invoked by the application.
  * WARNING: This call returns the number of BITS read from the stream. Beware.
  */
-asn_dec_rval_t uper_decode(struct asn_codec_ctx_s *opt_codec_ctx,
-       struct asn_TYPE_descriptor_s *type_descriptor,  /* Type to decode */
-       void **struct_ptr,      /* Pointer to a target structure's pointer */
-       const void *buffer,     /* Data to be decoded */
-       size_t size,            /* Size of data buffer */
-       int skip_bits,          /* Number of unused leading bits, 0..7 */
-       int unused_bits         /* Number of unused tailing bits, 0..7 */
-       );
+asn_dec_rval_t uper_decode(
+    const struct asn_codec_ctx_s *opt_codec_ctx,
+    const struct asn_TYPE_descriptor_s *type_descriptor, /* Type to decode */
+    void **struct_ptr,  /* Pointer to a target structure's pointer */
+    const void *buffer, /* Data to be decoded */
+    size_t size,        /* Size of the input data buffer, in bytes */
+    int skip_bits,      /* Number of unused leading bits, 0..7 */
+    int unused_bits     /* Number of unused tailing bits, 0..7 */
+);
 
 
 /*
  * Type of the type-specific PER decoder function.
  */
 
 
 /*
  * Type of the type-specific PER decoder function.
  */
-typedef asn_dec_rval_t (per_type_decoder_f)(asn_codec_ctx_t *opt_codec_ctx,
-               struct asn_TYPE_descriptor_s *type_descriptor,
-               asn_per_constraints_t *constraints,
-               void **struct_ptr,
-               asn_per_data_t *per_data
-       );
+typedef asn_dec_rval_t(per_type_decoder_f)(
+    const asn_codec_ctx_t *opt_codec_ctx,
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const asn_per_constraints_t *constraints, void **struct_ptr,
+    asn_per_data_t *per_data);
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 95a6506e47b54695ad1eab616dbe02cded6f6338..44d8e8ac62fdac9d0026642e61544aaa2d8f2168 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2006, 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2006-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _PER_ENCODER_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _PER_ENCODER_H_
@@ -20,10 +20,12 @@ struct asn_TYPE_descriptor_s;       /* Forward declaration */
  * field of the return value. Use the following formula to convert to bytes:
  *     bytes = ((.encoded + 7) / 8)
  */
  * field of the return value. Use the following formula to convert to bytes:
  *     bytes = ((.encoded + 7) / 8)
  */
-asn_enc_rval_t uper_encode(struct asn_TYPE_descriptor_s *type_descriptor,
-       void *struct_ptr,       /* Structure to be encoded */
-       asn_app_consume_bytes_f *consume_bytes_cb,      /* Data collector */
-       void *app_key           /* Arbitrary callback argument */
+asn_enc_rval_t uper_encode(
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const asn_per_constraints_t *constraints,
+    const void *struct_ptr,                    /* Structure to be encoded */
+    asn_app_consume_bytes_f *consume_bytes_cb, /* Data collector */
+    void *app_key                              /* Arbitrary callback argument */
 );
 
 /*
 );
 
 /*
@@ -32,10 +34,11 @@ asn_enc_rval_t uper_encode(struct asn_TYPE_descriptor_s *type_descriptor,
  * field of the return value.
  */
 asn_enc_rval_t uper_encode_to_buffer(
  * field of the return value.
  */
 asn_enc_rval_t uper_encode_to_buffer(
-       struct asn_TYPE_descriptor_s *type_descriptor,
-       void *struct_ptr,       /* Structure to be encoded */
-       void *buffer,           /* Pre-allocated buffer */
-       size_t buffer_size      /* Initial buffer size (max) */
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const asn_per_constraints_t *constraints,
+    const void *struct_ptr, /* Structure to be encoded */
+    void *buffer,           /* Pre-allocated buffer */
+    size_t buffer_size      /* Initial buffer size (max) */
 );
 
 /*
 );
 
 /*
@@ -46,21 +49,19 @@ asn_enc_rval_t uper_encode_to_buffer(
  * encoding of uper_encode() and uper_encode_to_buffer().
  */
 ssize_t uper_encode_to_new_buffer(
  * encoding of uper_encode() and uper_encode_to_buffer().
  */
 ssize_t uper_encode_to_new_buffer(
-       struct asn_TYPE_descriptor_s *type_descriptor,
-       asn_per_constraints_t *constraints,
-       void *struct_ptr,       /* Structure to be encoded */
-       void **buffer_r         /* Buffer allocated and returned */
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const asn_per_constraints_t *constraints,
+    const void *struct_ptr, /* Structure to be encoded */
+    void **buffer_r         /* Buffer allocated and returned */
 );
 
 /*
  * Type of the generic PER encoder function.
  */
 );
 
 /*
  * Type of the generic PER encoder function.
  */
-typedef asn_enc_rval_t (per_type_encoder_f)(
-       struct asn_TYPE_descriptor_s *type_descriptor,
-       asn_per_constraints_t *constraints,
-       void *struct_ptr,
-       asn_per_outp_t *per_output
-);
+typedef asn_enc_rval_t(per_type_encoder_f)(
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const asn_per_constraints_t *constraints, const void *struct_ptr,
+    asn_per_outp_t *per_output);
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index facfaa6377bddcc85e23ac8c511f3d047a56324b..7e7dc61091f9eef271f4bcd17c9a7cf34a70bc43 100644 (file)
@@ -1,5 +1,5 @@
 /*
 /*
- * Copyright (c) 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2007-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _PER_OPENTYPE_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _PER_OPENTYPE_H_
@@ -9,11 +9,21 @@
 extern "C" {
 #endif
 
 extern "C" {
 #endif
 
-asn_dec_rval_t uper_open_type_get(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_dec_rval_t uper_open_type_get(const asn_codec_ctx_t *opt_codec_ctx,
+                                  const asn_TYPE_descriptor_t *td,
+                                  const asn_per_constraints_t *constraints,
+                                  void **sptr, asn_per_data_t *pd);
 
 
-int uper_open_type_skip(asn_codec_ctx_t *opt_codec_ctx, asn_per_data_t *pd);
+int uper_open_type_skip(const asn_codec_ctx_t *opt_codec_ctx,
+                        asn_per_data_t *pd);
 
 
-int uper_open_type_put(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po);
+/*
+ * X.691 (2015/08), #11.2
+ * Returns -1 if error is encountered. 0 if all OK.
+ */
+int uper_open_type_put(const asn_TYPE_descriptor_t *td,
+                       const asn_per_constraints_t *constraints,
+                       const void *sptr, asn_per_outp_t *po);
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index a75ac94fc4a98ed41e4b32c4a1c31d66446c1121..3e905a8b971babae81e9afc3b8dd728f68b36d05 100644 (file)
@@ -1,12 +1,12 @@
 /*
 /*
- * Copyright (c) 2005-2014 Lev Walkin <vlm@lionet.info>.
- * All rights reserved.
+ * Copyright (c) 2005-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _PER_SUPPORT_H_
 #define        _PER_SUPPORT_H_
 
 #include <asn_system.h>                /* Platform-specific types */
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _PER_SUPPORT_H_
 #define        _PER_SUPPORT_H_
 
 #include <asn_system.h>                /* Platform-specific types */
+#include <asn_bit_data.h>
 
 #ifdef __cplusplus
 extern "C" {
 
 #ifdef __cplusplus
 extern "C" {
@@ -15,7 +15,7 @@ extern "C" {
 /*
  * Pre-computed PER constraints.
  */
 /*
  * Pre-computed PER constraints.
  */
-typedef const struct asn_per_constraint_s {
+typedef struct asn_per_constraint_s {
        enum asn_per_constraint_flags {
                APC_UNCONSTRAINED       = 0x0,  /* No PER visible constraints */
                APC_SEMI_CONSTRAINED    = 0x1,  /* Constrained at "lb" */
        enum asn_per_constraint_flags {
                APC_UNCONSTRAINED       = 0x0,  /* No PER visible constraints */
                APC_SEMI_CONSTRAINED    = 0x1,  /* Constrained at "lb" */
@@ -27,49 +27,26 @@ typedef const struct asn_per_constraint_s {
        long lower_bound;               /* "lb" value */
        long upper_bound;               /* "ub" value */
 } asn_per_constraint_t;
        long lower_bound;               /* "lb" value */
        long upper_bound;               /* "ub" value */
 } asn_per_constraint_t;
-typedef const struct asn_per_constraints_s {
-       struct asn_per_constraint_s value;
-       struct asn_per_constraint_s size;
+typedef struct asn_per_constraints_s {
+       asn_per_constraint_t value;
+       asn_per_constraint_t size;
        int (*value2code)(unsigned int value);
        int (*code2value)(unsigned int code);
 } asn_per_constraints_t;
 
        int (*value2code)(unsigned int value);
        int (*code2value)(unsigned int code);
 } asn_per_constraints_t;
 
-/*
- * This structure describes a position inside an incoming PER bit stream.
- */
-typedef struct asn_per_data_s {
-  const uint8_t *buffer;  /* Pointer to the octet stream */
-         size_t  nboff;   /* Bit offset to the meaningful bit */
-         size_t  nbits;   /* Number of bits in the stream */
-         size_t  moved;   /* Number of bits moved through this bit stream */
-  int (*refill)(struct asn_per_data_s *);
-  void *refill_key;
-} asn_per_data_t;
-
-/*
- * Extract a small number of bits (<= 31) from the specified PER data pointer.
- * This function returns -1 if the specified number of bits could not be
- * extracted due to EOD or other conditions.
- */
-int32_t per_get_few_bits(asn_per_data_t *per_data, int get_nbits);
-
-/* Undo the immediately preceeding "get_few_bits" operation */
-void per_get_undo(asn_per_data_t *per_data, int get_nbits);
-
-/*
- * Extract a large number of bits from the specified PER data pointer.
- * This function returns -1 if the specified number of bits could not be
- * extracted due to EOD or other conditions.
- */
-int per_get_many_bits(asn_per_data_t *pd, uint8_t *dst, int right_align,
-                       int get_nbits);
+/* Temporary compatibility layer. Will get removed. */
+typedef struct asn_bit_data_s asn_per_data_t;
+#define per_get_few_bits(data, bits)   asn_get_few_bits(data, bits)
+#define per_get_undo(data, bits)   asn_get_undo(data, bits)
+#define per_get_many_bits(data, dst, align, bits) \
+    asn_get_many_bits(data, dst, align, bits)
 
 /*
 
 /*
+ * X.691 (08/2015) #11.9 "General rules for encoding a length determinant"
  * Get the length "n" from the Unaligned PER stream.
  */
  * Get the length "n" from the Unaligned PER stream.
  */
-ssize_t uper_get_length(asn_per_data_t *pd,
-                       int effective_bound_bits,
-                       int *repeat);
+ssize_t uper_get_length(asn_per_data_t *pd, int effective_bound_bits,
+                        size_t lower_bound, int *repeat);
 
 /*
  * Get the normally small length "n".
 
 /*
  * Get the normally small length "n".
@@ -84,38 +61,38 @@ ssize_t uper_get_nsnnwn(asn_per_data_t *pd);
 /* X.691-2008/11, #11.5.6 */
 int uper_get_constrained_whole_number(asn_per_data_t *pd, unsigned long *v, int nbits);
 
 /* X.691-2008/11, #11.5.6 */
 int uper_get_constrained_whole_number(asn_per_data_t *pd, unsigned long *v, int nbits);
 
-/* Non-thread-safe debugging function, don't use it */
-char *per_data_string(asn_per_data_t *pd);
+
+/* Temporary compatibility layer. Will get removed. */
+typedef struct asn_bit_outp_s asn_per_outp_t;
+#define per_put_few_bits(out, bits, obits) asn_put_few_bits(out, bits, obits)
+#define per_put_many_bits(out, src, nbits) asn_put_many_bits(out, src, nbits)
+#define per_put_aligned_flush(out) asn_put_aligned_flush(out)
+
 
 /*
 
 /*
- * This structure supports forming PER output.
+ * Rebase the given value as an offset into the range specified by the
+ * lower bound (lb) and upper bound (ub).
+ * RETURN VALUES:
+ *  -1: Conversion failed due to range problems.
+ *   0: Conversion was successful.
  */
  */
-typedef struct asn_per_outp_s {
-       uint8_t *buffer;        /* Pointer into the (tmpspace) */
-       size_t nboff;           /* Bit offset to the meaningful bit */
-       size_t nbits;           /* Number of bits left in (tmpspace) */
-       uint8_t tmpspace[32];   /* Preliminary storage to hold data */
-       int (*outper)(const void *data, size_t size, void *op_key);
-       void *op_key;           /* Key for (outper) data callback */
-       size_t flushed_bytes;   /* Bytes already flushed through (outper) */
-} asn_per_outp_t;
-
-/* Output a small number of bits (<= 31) */
-int per_put_few_bits(asn_per_outp_t *per_data, uint32_t bits, int obits);
-
-/* Output a large number of bits */
-int per_put_many_bits(asn_per_outp_t *po, const uint8_t *src, int put_nbits);
+int per_long_range_rebase(long v, long lb, long ub, unsigned long *output);
+/* The inverse operation: restores the value by the offset and its bounds. */
+int per_long_range_unrebase(unsigned long inp, long lb, long ub, long *outp);
 
 /* X.691-2008/11, #11.5 */
 
 /* X.691-2008/11, #11.5 */
-int uper_put_constrained_whole_number_s(asn_per_outp_t *po, long v, int nbits);
 int uper_put_constrained_whole_number_u(asn_per_outp_t *po, unsigned long v, int nbits);
 
 /*
 int uper_put_constrained_whole_number_u(asn_per_outp_t *po, unsigned long v, int nbits);
 
 /*
- * Put the length "n" to the Unaligned PER stream.
+ * X.691 (08/2015) #11.9 "General rules for encoding a length determinant"
+ * Put the length "whole_length" to the Unaligned PER stream.
+ * If (opt_need_eom) is given, it will be set to 1 if final 0-length is needed.
+ * In that case, invoke uper_put_length(po, 0, 0) after encoding the last block.
  * This function returns the number of units which may be flushed
  * in the next units saving iteration.
  */
  * This function returns the number of units which may be flushed
  * in the next units saving iteration.
  */
-ssize_t uper_put_length(asn_per_outp_t *po, size_t whole_length);
+ssize_t uper_put_length(asn_per_outp_t *po, size_t whole_length,
+                        int *opt_need_eom);
 
 /*
  * Put the normally small length "n" to the Unaligned PER stream.
 
 /*
  * Put the normally small length "n" to the Unaligned PER stream.
index 301b613cf4bdc62aa6e50953eb15e19c08d957c6..b951c41d1b48563609822120d262b20add68887a 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _XER_DECODER_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _XER_DECODER_H_
@@ -15,23 +15,24 @@ struct asn_TYPE_descriptor_s;       /* Forward declaration */
 
 /*
  * The XER decoder of any ASN.1 type. May be invoked by the application.
 
 /*
  * The XER decoder of any ASN.1 type. May be invoked by the application.
+ * Decodes CANONICAL-XER and BASIC-XER.
  */
  */
-asn_dec_rval_t xer_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 data buffer */
-       );
+asn_dec_rval_t xer_decode(
+    const struct asn_codec_ctx_s *opt_codec_ctx,
+    const 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 data buffer */
+);
 
 /*
  * Type of the type-specific XER decoder function.
  */
 
 /*
  * Type of the type-specific XER decoder function.
  */
-typedef asn_dec_rval_t (xer_type_decoder_f)(asn_codec_ctx_t *opt_codec_ctx,
-               struct asn_TYPE_descriptor_s *type_descriptor,
-               void **struct_ptr,
-               const char *opt_mname,  /* Member name */
-               const void *buf_ptr, size_t size
-       );
+typedef asn_dec_rval_t(xer_type_decoder_f)(
+    const asn_codec_ctx_t *opt_codec_ctx,
+    const struct asn_TYPE_descriptor_s *type_descriptor, void **struct_ptr,
+    const char *opt_mname, /* Member name */
+    const void *buf_ptr, size_t size);
 
 /*******************************
  * INTERNALLY USEFUL FUNCTIONS *
 
 /*******************************
  * INTERNALLY USEFUL FUNCTIONS *
@@ -43,17 +44,16 @@ typedef asn_dec_rval_t (xer_type_decoder_f)(asn_codec_ctx_t *opt_codec_ctx,
  * and others. This function should not be used by applications, as its API
  * is subject to changes.
  */
  * and others. This function should not be used by applications, as its API
  * is subject to changes.
  */
-asn_dec_rval_t xer_decode_general(asn_codec_ctx_t *opt_codec_ctx,
-       asn_struct_ctx_t *ctx,  /* Type decoder context */
-       void *struct_key,       /* Treated as opaque pointer */
-       const char *xml_tag,    /* Expected XML tag name */
-       const void *buf_ptr, size_t size,
-       int (*opt_unexpected_tag_decoder)
-               (void *struct_key, const void *chunk_buf, size_t chunk_size),
-       ssize_t (*body_receiver)
-               (void *struct_key, const void *chunk_buf, size_t chunk_size,
-                       int have_more)
-       );
+asn_dec_rval_t xer_decode_general(
+    const asn_codec_ctx_t *opt_codec_ctx,
+    asn_struct_ctx_t *ctx, /* Type decoder context */
+    void *struct_key,      /* Treated as opaque pointer */
+    const char *xml_tag,   /* Expected XML tag name */
+    const void *buf_ptr, size_t size,
+    int (*opt_unexpected_tag_decoder)(void *struct_key, const void *chunk_buf,
+                                      size_t chunk_size),
+    ssize_t (*body_receiver)(void *struct_key, const void *chunk_buf,
+                             size_t chunk_size, int have_more));
 
 
 /*
 
 
 /*
index 055e73c0c8b0dfd330c8d3f80c6d2b02270b3100..9d75922c5338a2e1e8ad77227d6dfb5d07c2af06 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _XER_ENCODER_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _XER_ENCODER_H_
@@ -22,13 +22,14 @@ enum xer_encoder_flags_e {
 
 /*
  * The XER encoder of any type. May be invoked by the application.
 
 /*
  * The XER encoder of any type. May be invoked by the application.
+ * Produces CANONICAL-XER and BASIC-XER depending on the (xer_flags).
  */
  */
-asn_enc_rval_t xer_encode(struct asn_TYPE_descriptor_s *type_descriptor,
-               void *struct_ptr,       /* Structure to be encoded */
-               enum xer_encoder_flags_e xer_flags,
-               asn_app_consume_bytes_f *consume_bytes_cb,
-               void *app_key           /* Arbitrary callback argument */
-       );
+asn_enc_rval_t xer_encode(const struct asn_TYPE_descriptor_s *type_descriptor,
+                          const void *struct_ptr, /* Structure to be encoded */
+                          enum xer_encoder_flags_e xer_flags,
+                          asn_app_consume_bytes_f *consume_bytes_cb,
+                          void *app_key /* Arbitrary callback argument */
+);
 
 /*
  * The variant of the above function which dumps the BASIC-XER (XER_F_BASIC)
 
 /*
  * The variant of the above function which dumps the BASIC-XER (XER_F_BASIC)
@@ -38,19 +39,42 @@ asn_enc_rval_t xer_encode(struct asn_TYPE_descriptor_s *type_descriptor,
  *     -1: Problem printing the structure.
  * WARNING: No sensible errno value is returned.
  */
  *     -1: Problem printing the structure.
  * WARNING: No sensible errno value is returned.
  */
-int xer_fprint(FILE *stream, struct asn_TYPE_descriptor_s *td, void *sptr);
+int xer_fprint(FILE *stream, const struct asn_TYPE_descriptor_s *td,
+               const void *struct_ptr);
+
+/*
+ * A helper function that uses XER encoding/decoding to verify that:
+ * - Both structures encode into the same BASIC XER.
+ * - Both resulting XER byte streams can be decoded back.
+ * - Both decoded structures encode into the same BASIC XER (round-trip).
+ * All of this verifies equivalence between structures and a round-trip.
+ * ARGUMENTS:
+ *  (opt_debug_stream)  - If specified, prints ongoing details.
+ */
+enum xer_equivalence_e {
+    XEQ_SUCCESS,          /* The only completely positive return value */
+    XEQ_FAILURE,          /* General failure */
+    XEQ_ENCODE1_FAILED,   /* First sructure XER encoding failed */
+    XEQ_ENCODE2_FAILED,   /* Second structure XER encoding failed */
+    XEQ_DIFFERENT,        /* Structures encoded into different XER */
+    XEQ_DECODE_FAILED,    /* Decode of the XER data failed */
+    XEQ_ROUND_TRIP_FAILED /* Bad round-trip */
+};
+enum xer_equivalence_e xer_equivalent(
+    const struct asn_TYPE_descriptor_s *type_descriptor, const void *struct1,
+    const void *struct2, FILE *opt_debug_stream);
 
 /*
  * Type of the generic XER encoder.
  */
 
 /*
  * Type of the generic XER encoder.
  */
-typedef asn_enc_rval_t (xer_type_encoder_f)(
-               struct asn_TYPE_descriptor_s *type_descriptor,
-               void *struct_ptr,       /* Structure to be encoded */
-               int ilevel,             /* Level of indentation */
-               enum xer_encoder_flags_e xer_flags,
-               asn_app_consume_bytes_f *consume_bytes_cb,      /* Callback */
-               void *app_key           /* Arbitrary callback argument */
-       );
+typedef asn_enc_rval_t(xer_type_encoder_f)(
+    const struct asn_TYPE_descriptor_s *type_descriptor,
+    const void *struct_ptr, /* Structure to be encoded */
+    int ilevel,             /* Level of indentation */
+    enum xer_encoder_flags_e xer_flags,
+    asn_app_consume_bytes_f *consume_bytes_cb, /* Callback */
+    void *app_key                              /* Arbitrary callback argument */
+);
 
 #ifdef __cplusplus
 }
 
 #ifdef __cplusplus
 }
index 8b01944ab584c4bca90139c4b322fa5103030f49..c3a36e72047ad71a726856d36aa8d7ea414d69d9 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2003, 2004 X/IO Labs, xiolabs.com.
 /*
  * Copyright (c) 2003, 2004 X/IO Labs, xiolabs.com.
- * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2003-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _XER_SUPPORT_H_
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #ifndef        _XER_SUPPORT_H_
diff --git a/libs/smux/oer_decoder.c b/libs/smux/oer_decoder.c
new file mode 100644 (file)
index 0000000..0701738
--- /dev/null
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2017 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>
+
+/*
+ * The OER decoder of any type.
+ */
+asn_dec_rval_t
+oer_decode(const asn_codec_ctx_t *opt_codec_ctx,
+           const 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->op->oer_decoder(opt_codec_ctx, type_descriptor, 0,
+               struct_ptr,     /* Pointer to the destination structure */
+               ptr, size       /* Buffer and its size */
+               );
+}
+
+/*
+ * Open Type is encoded as a length (#8.6) followed by that number of bytes.
+ * Since we're just skipping, reading the length would be enough.
+ */
+ssize_t
+oer_open_type_skip(const void *bufptr, size_t size) {
+    size_t len = 0;
+    return oer_fetch_length(bufptr, size, &len);
+}
+
+/*
+ * Read the Open Type (X.696 (08/2015), #30).
+ * RETURN VALUES:
+ *       0:     More data expected than bufptr contains.
+ *      -1:     Fatal error deciphering length.
+ *      >0:     Number of bytes used from bufptr.
+ */
+ssize_t
+oer_open_type_get(const asn_codec_ctx_t *opt_codec_ctx,
+                  const struct asn_TYPE_descriptor_s *td,
+                  const asn_oer_constraints_t *constraints, void **struct_ptr,
+                  const void *bufptr, size_t size) {
+    asn_dec_rval_t dr;
+    size_t container_len = 0;
+    ssize_t len_len;
+    enum asn_struct_free_method dispose_method =
+        (*struct_ptr) ? ASFM_FREE_UNDERLYING_AND_RESET : ASFM_FREE_EVERYTHING;
+
+    /* Get the size of a length determinant */
+    len_len = oer_fetch_length(bufptr, size, &container_len);
+    if(len_len <= 0) {
+        return len_len; /* Error or more data expected */
+    }
+
+    /*
+     * len_len can't be bigger than size, but size without len_len
+     * should be bigger or equal to container length
+     */
+    if(size - len_len < container_len) {
+        /* More data is expected */
+        return 0;
+    }
+
+    dr = td->op->oer_decoder(opt_codec_ctx, td, constraints, struct_ptr,
+                         (const uint8_t *)bufptr + len_len, container_len);
+    if(dr.code == RC_OK) {
+        return len_len + container_len;
+    } else {
+        /* Even if RC_WMORE, we can't get more data into a closed container. */
+        td->op->free_struct(td, *struct_ptr, dispose_method);
+        *struct_ptr = NULL;
+        return -1;
+    }
+}
+
+
+asn_dec_rval_t
+oer_decode_primitive(const asn_codec_ctx_t *opt_codec_ctx,
+                     const asn_TYPE_descriptor_t *td,
+                     const asn_oer_constraints_t *constraints, void **sptr,
+                     const void *ptr, size_t size) {
+    ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)*sptr;
+    asn_dec_rval_t rval = {RC_OK, 0};
+    size_t expected_length = 0;
+    ssize_t len_len;
+
+    (void)td;
+    (void)opt_codec_ctx;
+    (void)constraints;
+
+    if(!st) {
+        st = (ASN__PRIMITIVE_TYPE_t *)(*sptr = CALLOC(
+                                           1, sizeof(ASN__PRIMITIVE_TYPE_t)));
+        if(!st) ASN__DECODE_FAILED;
+    }
+
+
+    /*
+     * X.696 (08/2015) #27.2
+     * Encode length determinant as _number of octets_, but only
+     * if upper bound is not equal to lower bound.
+     */
+    len_len = oer_fetch_length(ptr, size, &expected_length);
+    if(len_len > 0) {
+        rval.consumed = len_len;
+        ptr = (const char *)ptr + len_len;
+        size -= len_len;
+    } else if(len_len == 0) {
+        ASN__DECODE_STARVED;
+    } else if(len_len < 0) {
+        ASN__DECODE_FAILED;
+    }
+
+    if(size < expected_length) {
+        ASN__DECODE_STARVED;
+    } else {
+        uint8_t *buf = MALLOC(expected_length + 1);
+        if(buf == NULL) {
+            ASN__DECODE_FAILED;
+        } else {
+            memcpy(buf, ptr, expected_length);
+            buf[expected_length] = '\0';
+        }
+        FREEMEM(st->buf);
+        st->buf = buf;
+        st->size = expected_length;
+
+        rval.consumed += expected_length;
+        return rval;
+    }
+}
diff --git a/libs/smux/oer_encoder.c b/libs/smux/oer_encoder.c
new file mode 100644 (file)
index 0000000..895aed4
--- /dev/null
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2017 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>
+
+/*
+ * The OER encoder of any type.
+ */
+asn_enc_rval_t
+oer_encode(const asn_TYPE_descriptor_t *type_descriptor, const void *struct_ptr,
+           asn_app_consume_bytes_f *consume_bytes, void *app_key) {
+    ASN_DEBUG("OER encoder invoked for %s", type_descriptor->name);
+
+    /*
+     * Invoke type-specific encoder.
+     */
+    return type_descriptor->op->oer_encoder(
+        type_descriptor, 0,
+        struct_ptr, /* Pointer to the destination structure */
+        consume_bytes, app_key);
+}
+
+/*
+ * Argument type and callback necessary for oer_encode_to_buffer().
+ */
+typedef struct enc_to_buf_arg {
+        void *buffer;
+        size_t left;
+} enc_to_buf_arg;
+static int
+encode_to_buffer_cb(const void *buffer, size_t size, void *key) {
+    enc_to_buf_arg *arg = (enc_to_buf_arg *)key;
+
+    if(arg->left < size) return -1; /* Data exceeds the available buffer size */
+
+    memcpy(arg->buffer, buffer, size);
+    arg->buffer = ((char *)arg->buffer) + size;
+    arg->left -= size;
+
+    return 0;
+}
+
+/*
+ * A variant of the oer_encode() which encodes the data into the provided buffer
+ */
+asn_enc_rval_t
+oer_encode_to_buffer(const asn_TYPE_descriptor_t *type_descriptor,
+                     const asn_oer_constraints_t *constraints,
+                     const void *struct_ptr, /* Structure to be encoded */
+                     void *buffer,           /* Pre-allocated buffer */
+                     size_t buffer_size      /* Initial buffer size (maximum) */
+) {
+    enc_to_buf_arg arg;
+    asn_enc_rval_t ec;
+
+    arg.buffer = buffer;
+    arg.left = buffer_size;
+
+    if(type_descriptor->op->oer_encoder == NULL) {
+        ec.encoded = -1;
+        ec.failed_type = type_descriptor;
+        ec.structure_ptr = struct_ptr;
+        ASN_DEBUG("OER encoder is not defined for %s",
+                type_descriptor->name);
+    } else {
+        ec = type_descriptor->op->oer_encoder(
+            type_descriptor, constraints,
+            struct_ptr, /* Pointer to the destination structure */
+            encode_to_buffer_cb, &arg);
+        if(ec.encoded != -1) {
+            assert(ec.encoded == (ssize_t)(buffer_size - arg.left));
+            /* Return the encoded contents size */
+        }
+    }
+    return ec;
+}
+
+asn_enc_rval_t
+oer_encode_primitive(const asn_TYPE_descriptor_t *td,
+                     const asn_oer_constraints_t *constraints, const void *sptr,
+                     asn_app_consume_bytes_f *cb, void *app_key) {
+    const ASN__PRIMITIVE_TYPE_t *st = (const ASN__PRIMITIVE_TYPE_t *)sptr;
+    asn_enc_rval_t er = {0, 0, 0};
+    ssize_t ret;
+
+    (void)constraints;
+
+    if(!st) ASN__ENCODE_FAILED;
+
+    ASN_DEBUG("Encoding %s (%" ASN_PRI_SIZE " bytes)", td ? td->name : "", st->size);
+
+    /*
+     * X.696 (08/2015) #27.2
+     */
+    ret = oer_serialize_length(st->size, cb, app_key);
+    if(ret < 0) {
+        ASN__ENCODE_FAILED;
+    }
+    er.encoded += ret;
+
+    er.encoded += st->size;
+    if(cb(st->buf, st->size, app_key) < 0) {
+        ASN__ENCODE_FAILED;
+    } else {
+        ASN__ENCODED_OK(er);
+    }
+}
+
+static int
+oer__count_bytes(const void *buffer, size_t size, void *bytes_ptr) {
+    size_t *bytes = bytes_ptr;
+    (void)buffer;
+    *bytes += size;
+    return 0;
+}
+
+ssize_t
+oer_open_type_put(const asn_TYPE_descriptor_t *td,
+                  const asn_oer_constraints_t *constraints, const void *sptr,
+                  asn_app_consume_bytes_f *cb, void *app_key) {
+    size_t serialized_byte_count = 0;
+    asn_enc_rval_t er;
+    ssize_t len_len;
+
+    er = td->op->oer_encoder(td, constraints, sptr, oer__count_bytes,
+                             &serialized_byte_count);
+    if(er.encoded < 0) return -1;
+    assert(serialized_byte_count == (size_t)er.encoded);
+
+    len_len = oer_serialize_length(serialized_byte_count, cb, app_key);
+    if(len_len == -1) return -1;
+
+    er = td->op->oer_encoder(td, constraints, sptr, cb, app_key);
+    if(er.encoded < 0) return -1;
+    assert(serialized_byte_count == (size_t)er.encoded);
+
+    return len_len + er.encoded;
+}
+
diff --git a/libs/smux/oer_support.c b/libs/smux/oer_support.c
new file mode 100644 (file)
index 0000000..b15a3bc
--- /dev/null
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_system.h>
+#include <asn_internal.h>
+
+#include <oer_support.h>
+
+/*
+ * Fetch the length determinant (X.696 08/2015, #8.6) into *len_r.
+ * RETURN VALUES:
+ *       0:     More data expected than bufptr contains.
+ *      -1:     Fatal error deciphering length.
+ *      >0:     Number of bytes used from bufptr.
+ */
+ssize_t
+oer_fetch_length(const void *bufptr, size_t size, size_t *len_r) {
+    uint8_t first_byte;
+    size_t len_len;    /* Length of the length determinant */
+    const uint8_t *b;
+    const uint8_t *bend;
+    size_t len;
+
+    if(size == 0) {
+        *len_r = 0;
+        return 0;
+    }
+
+    first_byte = *(const uint8_t *)bufptr;
+    if((first_byte & 0x80) == 0) {   /* Short form */
+        *len_r = first_byte; /* 0..127 */
+        return 1;
+    }
+
+    len_len = (first_byte & 0x7f);
+    if((1 + len_len) > size) {
+        *len_r = 0;
+        return 0;
+    }
+
+    b = (const uint8_t *)bufptr + 1;
+    bend = b + len_len;
+
+    for(; b < bend && *b == 0; b++) {
+        /* Skip the leading 0-bytes */
+    }
+
+    if((bend - b) > (ssize_t)sizeof(size_t)) {
+        /* Length is not representable by the native size_t type */
+        *len_r = 0;
+        return -1;
+    }
+
+    for(len = 0; b < bend; b++) {
+        len = (len << 8) + *b;
+    }
+
+    if(len > RSIZE_MAX) { /* A bit of C11 validation */
+        *len_r = 0;
+        return -1;
+    }
+
+    *len_r = len;
+    assert(len_len + 1 == (size_t)(bend - (const uint8_t *)bufptr));
+    return len_len + 1;
+}
+
+
+/*
+ * Serialize OER length. Returns the number of bytes serialized
+ * or -1 if a given callback returned with negative result.
+ */
+ssize_t
+oer_serialize_length(size_t length, asn_app_consume_bytes_f *cb,
+                     void *app_key) {
+    uint8_t scratch[1 + sizeof(length)];
+    uint8_t *sp = scratch;
+    int littleEndian = 1;   /* Run-time detection */
+    const uint8_t *pstart;
+    const uint8_t *pend;
+    const uint8_t *p;
+    int add;
+
+    if(length <= 127) {
+        uint8_t b = length;
+        if(cb(&b, 1, app_key) < 0) {
+            return -1;
+        }
+        return 1;
+    }
+
+    if(*(char *)&littleEndian) {
+        pstart = (const uint8_t *)&length + sizeof(length) - 1;
+        pend = (const uint8_t *)&length;
+        add = -1;
+    } else {
+        pstart = (const uint8_t *)&length;
+        pend = pstart + sizeof(length);
+        add = 1;
+    }
+
+    for(p = pstart; p != pend; p += add) {
+        /* Skip leading zeros. */
+        if(*p) break;
+    }
+
+    for(sp = scratch + 1; ; p += add) {
+        *sp++ = *p;
+        if(p == pend) break;
+    }
+    assert((sp - scratch) - 1 <= 0x7f);
+    scratch[0] = 0x80 + ((sp - scratch) - 1);
+
+    if(cb(scratch, sp - scratch, app_key) < 0) {
+        return -1;
+    }
+
+    return sp - scratch;
+}
+
diff --git a/libs/smux/pdu_collection.c b/libs/smux/pdu_collection.c
new file mode 100644 (file)
index 0000000..b34c67f
--- /dev/null
@@ -0,0 +1,35 @@
+/*
+ * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
+ */
+
+struct asn_TYPE_descriptor_s;  /* Forward declaration */
+
+extern struct asn_TYPE_descriptor_s asn_DEF_IfEntry;
+extern struct asn_TYPE_descriptor_s asn_DEF_AtEntry;
+extern struct asn_TYPE_descriptor_s asn_DEF_IpAddrEntry;
+extern struct asn_TYPE_descriptor_s asn_DEF_IpRouteEntry;
+extern struct asn_TYPE_descriptor_s asn_DEF_IpNetToMediaEntry;
+extern struct asn_TYPE_descriptor_s asn_DEF_TcpConnEntry;
+extern struct asn_TYPE_descriptor_s asn_DEF_UdpEntry;
+extern struct asn_TYPE_descriptor_s asn_DEF_EgpNeighEntry;
+extern struct asn_TYPE_descriptor_s asn_DEF_Message;
+extern struct asn_TYPE_descriptor_s asn_DEF_SMUX_PDUs;
+
+
+struct asn_TYPE_descriptor_s *asn_pdu_collection[] = {
+       /* From module RFC1213-MIB in RFC1213-MIB.asn1 */
+       &asn_DEF_IfEntry,       
+       &asn_DEF_AtEntry,       
+       &asn_DEF_IpAddrEntry,   
+       &asn_DEF_IpRouteEntry,  
+       &asn_DEF_IpNetToMediaEntry,     
+       &asn_DEF_TcpConnEntry,  
+       &asn_DEF_UdpEntry,      
+       &asn_DEF_EgpNeighEntry, 
+       /* From module RFC1157-SNMP in RFC1157-SNMP.asn1 */
+       &asn_DEF_Message,       
+       /* From module SMUX in SMUX.asn1 */
+       &asn_DEF_SMUX_PDUs,     
+       0
+};
+
index 461b7262f1d9874cf33ce2c252c1abd8d1e2636e..a9051fb7981beea276ec9c9a873cb5bbf1115855 100644 (file)
@@ -8,8 +8,10 @@
  * multiple of 8 bytes.
  */
 asn_dec_rval_t
  * multiple of 8 bytes.
  */
 asn_dec_rval_t
-uper_decode_complete(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr, const void *buffer, size_t size) {
-       asn_dec_rval_t rval;
+uper_decode_complete(const asn_codec_ctx_t *opt_codec_ctx,
+                     const asn_TYPE_descriptor_t *td, void **sptr,
+                     const void *buffer, size_t size) {
+    asn_dec_rval_t rval;
 
        rval = uper_decode(opt_codec_ctx, td, sptr, buffer, size, 0, 0);
        if(rval.consumed) {
 
        rval = uper_decode(opt_codec_ctx, td, sptr, buffer, size, 0, 0);
        if(rval.consumed) {
@@ -37,8 +39,10 @@ uper_decode_complete(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 }
 
 asn_dec_rval_t
 }
 
 asn_dec_rval_t
-uper_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr, const void *buffer, size_t size, int skip_bits, int unused_bits) {
-       asn_codec_ctx_t s_codec_ctx;
+uper_decode(const asn_codec_ctx_t *opt_codec_ctx,
+            const asn_TYPE_descriptor_t *td, void **sptr, const void *buffer,
+            size_t size, int skip_bits, int unused_bits) {
+    asn_codec_ctx_t s_codec_ctx;
        asn_dec_rval_t rval;
        asn_per_data_t pd;
 
        asn_dec_rval_t rval;
        asn_per_data_t pd;
 
@@ -74,9 +78,9 @@ uper_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sp
        /*
         * Invoke type-specific decoder.
         */
        /*
         * Invoke type-specific decoder.
         */
-       if(!td->uper_decoder)
+       if(!td->op->uper_decoder)
                ASN__DECODE_FAILED;     /* PER is not compiled in */
                ASN__DECODE_FAILED;     /* PER is not compiled in */
-       rval = td->uper_decoder(opt_codec_ctx, td, 0, sptr, &pd);
+       rval = td->op->uper_decoder(opt_codec_ctx, td, 0, sptr, &pd);
        if(rval.code == RC_OK) {
                /* Return the number of consumed bits */
                rval.consumed = ((pd.buffer - (const uint8_t *)buffer) << 3)
        if(rval.code == RC_OK) {
                /* Return the number of consumed bits */
                rval.consumed = ((pd.buffer - (const uint8_t *)buffer) << 3)
index 47f3c916dacb044e763b27e24eeff98915991e66..86aec4ea56e48d5f8c8bb322ea58c1ffa90fd1fe 100644 (file)
@@ -2,11 +2,49 @@
 #include <asn_internal.h>
 #include <per_encoder.h>
 
 #include <asn_internal.h>
 #include <per_encoder.h>
 
-static asn_enc_rval_t uper_encode_internal(asn_TYPE_descriptor_t *td, asn_per_constraints_t *, void *sptr, asn_app_consume_bytes_f *cb, void *app_key);
+static int _uper_encode_flush_outp(asn_per_outp_t *po);
+
+static int
+ignore_output(const void *data, size_t size, void *app_key) {
+    (void)data;
+    (void)size;
+    (void)app_key;
+    return 0;
+}
 
 asn_enc_rval_t
 
 asn_enc_rval_t
-uper_encode(asn_TYPE_descriptor_t *td, void *sptr, asn_app_consume_bytes_f *cb, void *app_key) {
-       return uper_encode_internal(td, 0, sptr, cb, app_key);
+uper_encode(const asn_TYPE_descriptor_t *td,
+            const asn_per_constraints_t *constraints, const void *sptr,
+            asn_app_consume_bytes_f *cb, void *app_key) {
+    asn_per_outp_t po;
+    asn_enc_rval_t er;
+
+    /*
+     * Invoke type-specific encoder.
+     */
+    if(!td || !td->op->uper_encoder)
+        ASN__ENCODE_FAILED;    /* PER is not compiled in */
+
+    po.buffer = po.tmpspace;
+    po.nboff = 0;
+    po.nbits = 8 * sizeof(po.tmpspace);
+    po.output = cb ? cb : ignore_output;
+    po.op_key = app_key;
+    po.flushed_bytes = 0;
+
+    er = td->op->uper_encoder(td, constraints, sptr, &po);
+    if(er.encoded != -1) {
+        size_t bits_to_flush;
+
+        bits_to_flush = ((po.buffer - po.tmpspace) << 3) + po.nboff;
+
+        /* Set number of bits encoded to a firm value */
+        er.encoded = (po.flushed_bytes << 3) + bits_to_flush;
+
+        if(_uper_encode_flush_outp(&po)) ASN__ENCODE_FAILED;
+    }
+
+    return er;
 }
 
 /*
 }
 
 /*
@@ -30,15 +68,17 @@ static int encode_to_buffer_cb(const void *buffer, size_t size, void *key) {
 }
 
 asn_enc_rval_t
 }
 
 asn_enc_rval_t
-uper_encode_to_buffer(asn_TYPE_descriptor_t *td, void *sptr, void *buffer, size_t buffer_size) {
-       enc_to_buf_arg key;
+uper_encode_to_buffer(const asn_TYPE_descriptor_t *td,
+                      const asn_per_constraints_t *constraints,
+                      const void *sptr, void *buffer, size_t buffer_size) {
+    enc_to_buf_arg key;
 
 
-       key.buffer = buffer;
-       key.left = buffer_size;
+    key.buffer = buffer;
+    key.left = buffer_size;
 
 
-       if(td) ASN_DEBUG("Encoding \"%s\" using UNALIGNED PER", td->name);
+    if(td) ASN_DEBUG("Encoding \"%s\" using UNALIGNED PER", td->name);
 
 
-       return uper_encode_internal(td, 0, sptr, encode_to_buffer_cb, &key);
+    return uper_encode(td, constraints, sptr, encode_to_buffer_cb, &key);
 }
 
 typedef struct enc_dyn_arg {
 }
 
 typedef struct enc_dyn_arg {
@@ -48,30 +88,38 @@ typedef struct enc_dyn_arg {
 } enc_dyn_arg;
 static int
 encode_dyn_cb(const void *buffer, size_t size, void *key) {
 } enc_dyn_arg;
 static int
 encode_dyn_cb(const void *buffer, size_t size, void *key) {
-       enc_dyn_arg *arg = key;
-       if(arg->length + size >= arg->allocated) {
-               void *p;
-               arg->allocated = arg->allocated ? (arg->allocated << 2) : size;
-               p = REALLOC(arg->buffer, arg->allocated);
-               if(!p) {
-                       FREEMEM(arg->buffer);
-                       memset(arg, 0, sizeof(*arg));
-                       return -1;
-               }
-               arg->buffer = p;
-       }
-       memcpy(((char *)arg->buffer) + arg->length, buffer, size);
-       arg->length += size;
-       return 0;
+    enc_dyn_arg *arg = key;
+    if(arg->length + size >= arg->allocated) {
+        size_t new_size = arg->allocated ? arg->allocated : 8;
+        void *p;
+
+        do {
+            new_size <<= 2;
+        } while(arg->length + size >= new_size);
+
+        p = REALLOC(arg->buffer, new_size);
+        if(!p) {
+            FREEMEM(arg->buffer);
+            memset(arg, 0, sizeof(*arg));
+            return -1;
+        }
+        arg->buffer = p;
+        arg->allocated = new_size;
+    }
+    memcpy(((char *)arg->buffer) + arg->length, buffer, size);
+    arg->length += size;
+    return 0;
 }
 ssize_t
 }
 ssize_t
-uper_encode_to_new_buffer(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, void **buffer_r) {
-       asn_enc_rval_t er;
+uper_encode_to_new_buffer(const asn_TYPE_descriptor_t *td,
+                          const asn_per_constraints_t *constraints,
+                          const void *sptr, void **buffer_r) {
+    asn_enc_rval_t er;
        enc_dyn_arg key;
 
        memset(&key, 0, sizeof(key));
 
        enc_dyn_arg key;
 
        memset(&key, 0, sizeof(key));
 
-       er = uper_encode_internal(td, constraints, sptr, encode_dyn_cb, &key);
+       er = uper_encode(td, constraints, sptr, encode_dyn_cb, &key);
        switch(er.encoded) {
        case -1:
                FREEMEM(key.buffer);
        switch(er.encoded) {
        case -1:
                FREEMEM(key.buffer);
@@ -112,40 +160,6 @@ _uper_encode_flush_outp(asn_per_outp_t *po) {
                buf++;
        }
 
                buf++;
        }
 
-       return po->outper(po->tmpspace, buf - po->tmpspace, po->op_key);
-}
-
-static asn_enc_rval_t
-uper_encode_internal(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_app_consume_bytes_f *cb, void *app_key) {
-       asn_per_outp_t po;
-       asn_enc_rval_t er;
-
-       /*
-        * Invoke type-specific encoder.
-        */
-       if(!td || !td->uper_encoder)
-               ASN__ENCODE_FAILED;     /* PER is not compiled in */
-
-       po.buffer = po.tmpspace;
-       po.nboff = 0;
-       po.nbits = 8 * sizeof(po.tmpspace);
-       po.outper = cb;
-       po.op_key = app_key;
-       po.flushed_bytes = 0;
-
-       er = td->uper_encoder(td, constraints, sptr, &po);
-       if(er.encoded != -1) {
-               size_t bits_to_flush;
-
-               bits_to_flush = ((po.buffer - po.tmpspace) << 3) + po.nboff;
-
-               /* Set number of bits encoded to a firm value */
-               er.encoded = (po.flushed_bytes << 3) + bits_to_flush;
-
-               if(_uper_encode_flush_outp(&po))
-                       ASN__ENCODE_FAILED;
-       }
-
-       return er;
+       return po->output(po->tmpspace, buf - po->tmpspace, po->op_key);
 }
 
 }
 
index 404aa72645555f515a439167eb2aece3a66be603..f86dad70d84fc4858d77a018fc15cefe870162b5 100644 (file)
@@ -16,47 +16,60 @@ typedef struct uper_ugot_key {
 
 static int uper_ugot_refill(asn_per_data_t *pd);
 static int per_skip_bits(asn_per_data_t *pd, int skip_nbits);
 
 static int uper_ugot_refill(asn_per_data_t *pd);
 static int per_skip_bits(asn_per_data_t *pd, int skip_nbits);
-static asn_dec_rval_t uper_sot_suck(asn_codec_ctx_t *, asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd);
+static asn_dec_rval_t uper_sot_suck(const asn_codec_ctx_t *,
+                                    const asn_TYPE_descriptor_t *td,
+                                    const asn_per_constraints_t *constraints,
+                                    void **sptr, asn_per_data_t *pd);
 
 /*
  * Encode an "open type field".
  * #10.1, #10.2
  */
 int
 
 /*
  * Encode an "open type field".
  * #10.1, #10.2
  */
 int
-uper_open_type_put(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
-       void *buf;
-       void *bptr;
-       ssize_t size;
-       size_t toGo;
-
-       ASN_DEBUG("Open type put %s ...", td->name);
-
-       size = uper_encode_to_new_buffer(td, constraints, sptr, &buf);
-       if(size <= 0) return -1;
-
-       for(bptr = buf, toGo = size; toGo;) {
-               ssize_t maySave = uper_put_length(po, toGo);
-               ASN_DEBUG("Prepending length %d to %s and allowing to save %d",
-                       (int)size, td->name, (int)maySave);
-               if(maySave < 0) break;
-               if(per_put_many_bits(po, bptr, maySave * 8)) break;
-               bptr = (char *)bptr + maySave;
-               toGo -= maySave;
-       }
-
-       FREEMEM(buf);
-       if(toGo) return -1;
-
-       ASN_DEBUG("Open type put %s of length %ld + overhead (1byte?)",
-               td->name, (long)size);
-
-       return 0;
+uper_open_type_put(const asn_TYPE_descriptor_t *td,
+                   const asn_per_constraints_t *constraints, const void *sptr,
+                   asn_per_outp_t *po) {
+    void *buf;
+    void *bptr;
+    ssize_t size;
+
+    ASN_DEBUG("Open type put %s ...", td->name);
+
+    size = uper_encode_to_new_buffer(td, constraints, sptr, &buf);
+    if(size <= 0) return -1;
+
+    ASN_DEBUG("Open type put %s of length %" ASN_PRI_SSIZE " + overhead (1byte?)", td->name,
+              size);
+
+    bptr = buf;
+    do {
+        int need_eom = 0;
+        ssize_t may_save = uper_put_length(po, size, &need_eom);
+        ASN_DEBUG("Prepending length %" ASN_PRI_SSIZE
+                  " to %s and allowing to save %" ASN_PRI_SSIZE,
+                  size, td->name, may_save);
+        if(may_save < 0) break;
+        if(per_put_many_bits(po, bptr, may_save * 8)) break;
+        bptr = (char *)bptr + may_save;
+        size -= may_save;
+        if(need_eom && uper_put_length(po, 0, 0)) {
+            FREEMEM(buf);
+            return -1;
+        }
+    } while(size);
+
+    FREEMEM(buf);
+    if(size) return -1;
+
+    return 0;
 }
 
 static asn_dec_rval_t
 }
 
 static asn_dec_rval_t
-uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
-       asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-       asn_dec_rval_t rv;
+uper_open_type_get_simple(const asn_codec_ctx_t *ctx,
+                          const asn_TYPE_descriptor_t *td,
+                          const asn_per_constraints_t *constraints, void **sptr,
+                          asn_per_data_t *pd) {
+    asn_dec_rval_t rv;
        ssize_t chunk_bytes;
        int repeat;
        uint8_t *buf = 0;
        ssize_t chunk_bytes;
        int repeat;
        uint8_t *buf = 0;
@@ -70,7 +83,7 @@ uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
        ASN_DEBUG("Getting open type %s...", td->name);
 
        do {
        ASN_DEBUG("Getting open type %s...", td->name);
 
        do {
-               chunk_bytes = uper_get_length(pd, -1, &repeat);
+               chunk_bytes = uper_get_length(pd, -1, 0, &repeat);
                if(chunk_bytes < 0) {
                        FREEMEM(buf);
                        ASN__DECODE_STARVED;
                if(chunk_bytes < 0) {
                        FREEMEM(buf);
                        ASN__DECODE_STARVED;
@@ -100,7 +113,7 @@ uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
        spd.nbits = bufLen << 3;
 
        ASN_DEBUG_INDENT_ADD(+4);
        spd.nbits = bufLen << 3;
 
        ASN_DEBUG_INDENT_ADD(+4);
-       rv = td->uper_decoder(ctx, td, constraints, sptr, &spd);
+       rv = td->op->uper_decoder(ctx, td, constraints, sptr, &spd);
        ASN_DEBUG_INDENT_ADD(-4);
 
        if(rv.code == RC_OK) {
        ASN_DEBUG_INDENT_ADD(-4);
 
        if(rv.code == RC_OK) {
@@ -131,17 +144,19 @@ uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
        return rv;
 }
 
        return rv;
 }
 
-static asn_dec_rval_t GCC_NOTUSED
-uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
-       asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-       uper_ugot_key arg;
+static asn_dec_rval_t CC_NOTUSED
+uper_open_type_get_complex(const asn_codec_ctx_t *ctx,
+                           const asn_TYPE_descriptor_t *td,
+                           asn_per_constraints_t *constraints, void **sptr,
+                           asn_per_data_t *pd) {
+    uper_ugot_key arg;
        asn_dec_rval_t rv;
        ssize_t padding;
 
        ASN__STACK_OVERFLOW_CHECK(ctx);
 
        ASN_DEBUG("Getting open type %s from %s", td->name,
        asn_dec_rval_t rv;
        ssize_t padding;
 
        ASN__STACK_OVERFLOW_CHECK(ctx);
 
        ASN_DEBUG("Getting open type %s from %s", td->name,
-               per_data_string(pd));
+               asn_bit_data_string(pd));
        arg.oldpd = *pd;
        arg.unclaimed = 0;
        arg.ot_moved = 0;
        arg.oldpd = *pd;
        arg.unclaimed = 0;
        arg.ot_moved = 0;
@@ -152,7 +167,7 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
        pd->moved = 0;  /* This now counts the open type size in bits */
 
        ASN_DEBUG_INDENT_ADD(+4);
        pd->moved = 0;  /* This now counts the open type size in bits */
 
        ASN_DEBUG_INDENT_ADD(+4);
-       rv = td->uper_decoder(ctx, td, constraints, sptr, pd);
+       rv = td->op->uper_decoder(ctx, td, constraints, sptr, pd);
        ASN_DEBUG_INDENT_ADD(-4);
 
 #define        UPDRESTOREPD    do {                                            \
        ASN_DEBUG_INDENT_ADD(-4);
 
 #define        UPDRESTOREPD    do {                                            \
@@ -169,8 +184,8 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
        }
 
        ASN_DEBUG("OpenType %s pd%s old%s unclaimed=%d, repeat=%d", td->name,
        }
 
        ASN_DEBUG("OpenType %s pd%s old%s unclaimed=%d, repeat=%d", td->name,
-               per_data_string(pd),
-               per_data_string(&arg.oldpd),
+               asn_bit_data_string(pd),
+               asn_bit_data_string(&arg.oldpd),
                (int)arg.unclaimed, (int)arg.repeat);
 
        padding = pd->moved % 8;
                (int)arg.unclaimed, (int)arg.repeat);
 
        padding = pd->moved % 8;
@@ -201,7 +216,7 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
        }
        if(pd->nboff != pd->nbits) {
                ASN_DEBUG("Open type %s overhead pd%s old%s", td->name,
        }
        if(pd->nboff != pd->nbits) {
                ASN_DEBUG("Open type %s overhead pd%s old%s", td->name,
-                       per_data_string(pd), per_data_string(&arg.oldpd));
+                       asn_bit_data_string(pd), asn_bit_data_string(&arg.oldpd));
                if(1) {
                        UPDRESTOREPD;
                        ASN__DECODE_FAILED;
                if(1) {
                        UPDRESTOREPD;
                        ASN__DECODE_FAILED;
@@ -242,19 +257,21 @@ uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
 
 
 asn_dec_rval_t
 
 
 asn_dec_rval_t
-uper_open_type_get(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
-       asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-
-       return uper_open_type_get_simple(ctx, td, constraints, sptr, pd);
+uper_open_type_get(const asn_codec_ctx_t *ctx, const asn_TYPE_descriptor_t *td,
+                   const asn_per_constraints_t *constraints, void **sptr,
+                   asn_per_data_t *pd) {
+    return uper_open_type_get_simple(ctx, td, constraints, sptr, pd);
 }
 
 int
 }
 
 int
-uper_open_type_skip(asn_codec_ctx_t *ctx, asn_per_data_t *pd) {
+uper_open_type_skip(const asn_codec_ctx_t *ctx, asn_per_data_t *pd) {
        asn_TYPE_descriptor_t s_td;
        asn_TYPE_descriptor_t s_td;
+    asn_TYPE_operation_t s_op;
        asn_dec_rval_t rv;
 
        s_td.name = "<unknown extension>";
        asn_dec_rval_t rv;
 
        s_td.name = "<unknown extension>";
-       s_td.uper_decoder = uper_sot_suck;
+       s_td.op = &s_op;
+    s_op.uper_decoder = uper_sot_suck;
 
        rv = uper_open_type_get(ctx, &s_td, 0, 0, pd);
        if(rv.code != RC_OK)
 
        rv = uper_open_type_get(ctx, &s_td, 0, 0, pd);
        if(rv.code != RC_OK)
@@ -268,9 +285,10 @@ uper_open_type_skip(asn_codec_ctx_t *ctx, asn_per_data_t *pd) {
  */
 
 static asn_dec_rval_t
  */
 
 static asn_dec_rval_t
-uper_sot_suck(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
-       asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
-       asn_dec_rval_t rv;
+uper_sot_suck(const asn_codec_ctx_t *ctx, const asn_TYPE_descriptor_t *td,
+              const asn_per_constraints_t *constraints, void **sptr,
+              asn_per_data_t *pd) {
+    asn_dec_rval_t rv;
 
        (void)ctx;
        (void)td;
 
        (void)ctx;
        (void)td;
@@ -324,7 +342,7 @@ uper_ugot_refill(asn_per_data_t *pd) {
                return -1;
        }
 
                return -1;
        }
 
-       next_chunk_bytes = uper_get_length(oldpd, -1, &arg->repeat);
+       next_chunk_bytes = uper_get_length(oldpd, -1, 0, &arg->repeat);
        ASN_DEBUG("Open type LENGTH %ld bytes at off %ld, repeat %ld",
                (long)next_chunk_bytes, (long)oldpd->moved, (long)arg->repeat);
        if(next_chunk_bytes < 0) return -1;
        ASN_DEBUG("Open type LENGTH %ld bytes at off %ld, repeat %ld",
                (long)next_chunk_bytes, (long)oldpd->moved, (long)arg->repeat);
        if(next_chunk_bytes < 0) return -1;
@@ -351,7 +369,7 @@ uper_ugot_refill(asn_per_data_t *pd) {
        pd->buffer = oldpd->buffer;
        pd->nboff = oldpd->nboff;
        ASN_DEBUG("Refilled pd%s old%s",
        pd->buffer = oldpd->buffer;
        pd->nboff = oldpd->nboff;
        ASN_DEBUG("Refilled pd%s old%s",
-               per_data_string(pd), per_data_string(oldpd));
+               asn_bit_data_string(pd), asn_bit_data_string(oldpd));
        return 0;
 }
 
        return 0;
 }
 
index 14b4c4c76be09431ac0e17af7e6cf3d4843b560a..8f4d46040bbfffb22a10a144e29263b02fa85741 100644 (file)
 /*
 /*
- * Copyright (c) 2005-2014 Lev Walkin <vlm@lionet.info>.
- * All rights reserved.
+ * Copyright (c) 2005-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_system.h>
 #include <asn_internal.h>
 #include <per_support.h>
 
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_system.h>
 #include <asn_internal.h>
 #include <per_support.h>
 
-char *
-per_data_string(asn_per_data_t *pd) {
-       static char buf[2][32];
-       static int n;
-       n = (n+1) % 2;
-       snprintf(buf[n], sizeof(buf[n]),
-               "{m=%ld span %+ld[%d..%d] (%d)}",
-               (long)pd->moved,
-               (((long)pd->buffer) & 0xf),
-               (int)pd->nboff, (int)pd->nbits,
-               (int)(pd->nbits - pd->nboff));
-       return buf[n];
-}
-
-void
-per_get_undo(asn_per_data_t *pd, int nbits) {
-       if((ssize_t)pd->nboff < nbits) {
-               assert((ssize_t)pd->nboff < nbits);
-       } else {
-               pd->nboff -= nbits;
-               pd->moved -= nbits;
-       }
-}
-
-/*
- * Extract a small number of bits (<= 31) from the specified PER data pointer.
- */
-int32_t
-per_get_few_bits(asn_per_data_t *pd, int nbits) {
-       size_t off;     /* Next after last bit offset */
-       ssize_t nleft;  /* Number of bits left in this stream */
-       uint32_t accum;
-       const uint8_t *buf;
-
-       if(nbits < 0)
-               return -1;
-
-       nleft = pd->nbits - pd->nboff;
-       if(nbits > nleft) {
-               int32_t tailv, vhead;
-               if(!pd->refill || nbits > 31) return -1;
-               /* Accumulate unused bytes before refill */
-               ASN_DEBUG("Obtain the rest %d bits (want %d)",
-                       (int)nleft, (int)nbits);
-               tailv = per_get_few_bits(pd, nleft);
-               if(tailv < 0) return -1;
-               /* Refill (replace pd contents with new data) */
-               if(pd->refill(pd))
-                       return -1;
-               nbits -= nleft;
-               vhead = per_get_few_bits(pd, nbits);
-               /* Combine the rest of previous pd with the head of new one */
-               tailv = (tailv << nbits) | vhead;  /* Could == -1 */
-               return tailv;
-       }
-
-       /*
-        * Normalize position indicator.
-        */
-       if(pd->nboff >= 8) {
-               pd->buffer += (pd->nboff >> 3);
-               pd->nbits  -= (pd->nboff & ~0x07);
-               pd->nboff  &= 0x07;
-       }
-       pd->moved += nbits;
-       pd->nboff += nbits;
-       off = pd->nboff;
-       buf = pd->buffer;
-
-       /*
-        * Extract specified number of bits.
-        */
-       if(off <= 8)
-               accum = nbits ? (buf[0]) >> (8 - off) : 0;
-       else if(off <= 16)
-               accum = ((buf[0] << 8) + buf[1]) >> (16 - off);
-       else if(off <= 24)
-               accum = ((buf[0] << 16) + (buf[1] << 8) + buf[2]) >> (24 - off);
-       else if(off <= 31)
-               accum = ((buf[0] << 24) + (buf[1] << 16)
-                       + (buf[2] << 8) + (buf[3])) >> (32 - off);
-       else if(nbits <= 31) {
-               asn_per_data_t tpd = *pd;
-               /* Here are we with our 31-bits limit plus 1..7 bits offset. */
-               per_get_undo(&tpd, nbits);
-               /* The number of available bits in the stream allow
-                * for the following operations to take place without
-                * invoking the ->refill() function */
-               accum  = per_get_few_bits(&tpd, nbits - 24) << 24;
-               accum |= per_get_few_bits(&tpd, 24);
-       } else {
-               per_get_undo(pd, nbits);
-               return -1;
-       }
-
-       accum &= (((uint32_t)1 << nbits) - 1);
-
-       ASN_DEBUG("  [PER got %2d<=%2d bits => span %d %+ld[%d..%d]:%02x (%d) => 0x%x]",
-               (int)nbits, (int)nleft,
-               (int)pd->moved,
-               (((long)pd->buffer) & 0xf),
-               (int)pd->nboff, (int)pd->nbits,
-               ((pd->buffer != NULL)?pd->buffer[0]:0),
-               (int)(pd->nbits - pd->nboff),
-               (int)accum);
-
-       return accum;
-}
-
 /*
 /*
- * Extract a large number of bits from the specified PER data pointer.
- */
-int
-per_get_many_bits(asn_per_data_t *pd, uint8_t *dst, int alright, int nbits) {
-       int32_t value;
-
-       if(alright && (nbits & 7)) {
-               /* Perform right alignment of a first few bits */
-               value = per_get_few_bits(pd, nbits & 0x07);
-               if(value < 0) return -1;
-               *dst++ = value; /* value is already right-aligned */
-               nbits &= ~7;
-       }
-
-       while(nbits) {
-               if(nbits >= 24) {
-                       value = per_get_few_bits(pd, 24);
-                       if(value < 0) return -1;
-                       *(dst++) = value >> 16;
-                       *(dst++) = value >> 8;
-                       *(dst++) = value;
-                       nbits -= 24;
-               } else {
-                       value = per_get_few_bits(pd, nbits);
-                       if(value < 0) return -1;
-                       if(nbits & 7) { /* implies left alignment */
-                               value <<= 8 - (nbits & 7),
-                               nbits += 8 - (nbits & 7);
-                               if(nbits > 24)
-                                       *dst++ = value >> 24;
-                       }
-                       if(nbits > 16)
-                               *dst++ = value >> 16;
-                       if(nbits > 8)
-                               *dst++ = value >> 8;
-                       *dst++ = value;
-                       break;
-               }
-       }
-
-       return 0;
-}
-
-/*
- * Get the length "n" from the stream.
+ * X.691-201508 #10.9 General rules for encoding a length determinant.
+ * Get the optionally constrained length "n" from the stream.
  */
 ssize_t
  */
 ssize_t
-uper_get_length(asn_per_data_t *pd, int ebits, int *repeat) {
-       ssize_t value;
+uper_get_length(asn_per_data_t *pd, int ebits, size_t lower_bound,
+                int *repeat) {
+    ssize_t value;
 
 
-       *repeat = 0;
+    *repeat = 0;
 
 
-       if(ebits >= 0) return per_get_few_bits(pd, ebits);
+    /* #11.9.4.1 Encoding if constrained (according to effective bits) */
+    if(ebits >= 0 && ebits <= 16) {
+        value = per_get_few_bits(pd, ebits);
+        if(value >= 0) value += lower_bound;
+        return value;
+    }
 
        value = per_get_few_bits(pd, 8);
 
        value = per_get_few_bits(pd, 8);
-       if(value < 0) return -1;
-       if((value & 128) == 0)  /* #10.9.3.6 */
-               return (value & 0x7F);
-       if((value & 64) == 0) { /* #10.9.3.7 */
-               value = ((value & 63) << 8) | per_get_few_bits(pd, 8);
-               if(value < 0) return -1;
-               return value;
-       }
-       value &= 63;    /* this is "m" from X.691, #10.9.3.8 */
-       if(value < 1 || value > 4)
-               return -1;
-       *repeat = 1;
-       return (16384 * value);
+    if((value & 0x80) == 0) { /* #11.9.3.6 */
+        return (value & 0x7F);
+    } else if((value & 0x40) == 0) { /* #11.9.3.7 */
+        /* bit 8 ... set to 1 and bit 7 ... set to zero */
+        value = ((value & 0x3f) << 8) | per_get_few_bits(pd, 8);
+        return value; /* potential -1 from per_get_few_bits passes through. */
+    } else if(value < 0) {
+        ASN_DEBUG("END of stream reached for PER");
+        return -1;
+    }
+    value &= 0x3f; /* this is "m" from X.691, #11.9.3.8 */
+    if(value < 1 || value > 4) {
+        return -1; /* Prohibited by #11.9.3.8 */
+    }
+    *repeat = 1;
+    return (16384 * value);
 }
 
 /*
 }
 
 /*
@@ -205,7 +61,7 @@ uper_get_nslength(asn_per_data_t *pd) {
                return length;
        } else {
                int repeat;
                return length;
        } else {
                int repeat;
-               length = uper_get_length(pd, -1, &repeat);
+               length = uper_get_length(pd, -1, 0, &repeat);
                if(length >= 0 && !repeat) return length;
                return -1; /* Error, or do not support >16K extensions */
        }
                if(length >= 0 && !repeat) return length;
                return -1; /* Error, or do not support >16K extensions */
        }
@@ -291,171 +147,48 @@ int uper_get_constrained_whole_number(asn_per_data_t *pd, unsigned long *out_val
 
 
 /* X.691-2008/11, #11.5.6 -> #11.3 */
 
 
 /* X.691-2008/11, #11.5.6 -> #11.3 */
-int uper_put_constrained_whole_number_s(asn_per_outp_t *po, long v, int nbits) {
-       /*
-        * Assume signed number can be safely coerced into
-        * unsigned of the same range.
-        * The following testing code will likely be optimized out
-        * by compiler if it is true.
-        */
-       unsigned long uvalue1 = ULONG_MAX;
-                long svalue  = uvalue1;
-       unsigned long uvalue2 = svalue;
-       assert(uvalue1 == uvalue2);
-       return uper_put_constrained_whole_number_u(po, v, nbits);
-}
-
-int uper_put_constrained_whole_number_u(asn_per_outp_t *po, unsigned long v, int nbits) {
-       if(nbits <= 31) {
-               return per_put_few_bits(po, v, nbits);
-       } else {
-               /* Put higher portion first, followed by lower 31-bit */
-               if(uper_put_constrained_whole_number_u(po, v >> 31, nbits - 31))
-                       return -1;
-               return per_put_few_bits(po, v, 31);
-       }
-}
-
-/*
- * Put a small number of bits (<= 31).
- */
 int
 int
-per_put_few_bits(asn_per_outp_t *po, uint32_t bits, int obits) {
-       size_t off;     /* Next after last bit offset */
-       size_t omsk;    /* Existing last byte meaningful bits mask */
-       uint8_t *buf;
-
-       if(obits <= 0 || obits >= 32) return obits ? -1 : 0;
-
-       ASN_DEBUG("[PER put %d bits %x to %p+%d bits]",
-                       obits, (int)bits, po->buffer, (int)po->nboff);
-
-       /*
-        * Normalize position indicator.
-        */
-       if(po->nboff >= 8) {
-               po->buffer += (po->nboff >> 3);
-               po->nbits  -= (po->nboff & ~0x07);
-               po->nboff  &= 0x07;
-       }
-
-       /*
-        * Flush whole-bytes output, if necessary.
-        */
-       if(po->nboff + obits > po->nbits) {
-               int complete_bytes = (po->buffer - po->tmpspace);
-               ASN_DEBUG("[PER output %ld complete + %ld]",
-                       (long)complete_bytes, (long)po->flushed_bytes);
-               if(po->outper(po->tmpspace, complete_bytes, po->op_key) < 0)
-                       return -1;
-               if(po->nboff)
-                       po->tmpspace[0] = po->buffer[0];
-               po->buffer = po->tmpspace;
-               po->nbits = 8 * sizeof(po->tmpspace);
-               po->flushed_bytes += complete_bytes;
-       }
-
-       /*
-        * Now, due to sizeof(tmpspace), we are guaranteed large enough space.
-        */
-       buf = po->buffer;
-       omsk = ~((1 << (8 - po->nboff)) - 1);
-       off = (po->nboff + obits);
-
-       /* Clear data of debris before meaningful bits */
-       bits &= (((uint32_t)1 << obits) - 1);
-
-       ASN_DEBUG("[PER out %d %u/%x (t=%d,o=%d) %x&%x=%x]", obits,
-               (int)bits, (int)bits,
-               (int)po->nboff, (int)off,
-               buf[0], (int)(omsk&0xff),
-               (int)(buf[0] & omsk));
-
-       if(off <= 8)    /* Completely within 1 byte */
-               po->nboff = off,
-               bits <<= (8 - off),
-               buf[0] = (buf[0] & omsk) | bits;
-       else if(off <= 16)
-               po->nboff = off,
-               bits <<= (16 - off),
-               buf[0] = (buf[0] & omsk) | (bits >> 8),
-               buf[1] = bits;
-       else if(off <= 24)
-               po->nboff = off,
-               bits <<= (24 - off),
-               buf[0] = (buf[0] & omsk) | (bits >> 16),
-               buf[1] = bits >> 8,
-               buf[2] = bits;
-       else if(off <= 31)
-               po->nboff = off,
-               bits <<= (32 - off),
-               buf[0] = (buf[0] & omsk) | (bits >> 24),
-               buf[1] = bits >> 16,
-               buf[2] = bits >> 8,
-               buf[3] = bits;
-       else {
-               per_put_few_bits(po, bits >> (obits - 24), 24);
-               per_put_few_bits(po, bits, obits - 24);
-       }
-
-       ASN_DEBUG("[PER out %u/%x => %02x buf+%ld]",
-               (int)bits, (int)bits, buf[0],
-               (long)(po->buffer - po->tmpspace));
-
-       return 0;
-}
-
-
-/*
- * Output a large number of bits.
- */
-int
-per_put_many_bits(asn_per_outp_t *po, const uint8_t *src, int nbits) {
-
-       while(nbits) {
-               uint32_t value;
-
-               if(nbits >= 24) {
-                       value = (src[0] << 16) | (src[1] << 8) | src[2];
-                       src += 3;
-                       nbits -= 24;
-                       if(per_put_few_bits(po, value, 24))
-                               return -1;
-               } else {
-                       value = src[0];
-                       if(nbits > 8)
-                               value = (value << 8) | src[1];
-                       if(nbits > 16)
-                               value = (value << 8) | src[2];
-                       if(nbits & 0x07)
-                               value >>= (8 - (nbits & 0x07));
-                       if(per_put_few_bits(po, value, nbits))
-                               return -1;
-                       break;
-               }
-       }
-
-       return 0;
+uper_put_constrained_whole_number_u(asn_per_outp_t *po, unsigned long v,
+                                    int nbits) {
+    if(nbits <= 31) {
+        return per_put_few_bits(po, v, nbits);
+    } else {
+        /* Put higher portion first, followed by lower 31-bit */
+        if(uper_put_constrained_whole_number_u(po, v >> 31, nbits - 31))
+            return -1;
+        return per_put_few_bits(po, v, 31);
+    }
 }
 
 /*
 }
 
 /*
+ * X.691 (08/2015) #11.9 "General rules for encoding a length determinant"
  * Put the length "n" (or part of it) into the stream.
  */
 ssize_t
  * Put the length "n" (or part of it) into the stream.
  */
 ssize_t
-uper_put_length(asn_per_outp_t *po, size_t length) {
-
-       if(length <= 127)       /* #10.9.3.6 */
-               return per_put_few_bits(po, length, 8)
-                       ? -1 : (ssize_t)length;
-       else if(length < 16384) /* #10.9.3.7 */
-               return per_put_few_bits(po, length|0x8000, 16)
-                       ? -1 : (ssize_t)length;
-
-       length >>= 14;
-       if(length > 4) length = 4;
+uper_put_length(asn_per_outp_t *po, size_t length, int *need_eom) {
+    int dummy = 0;
+    if(!need_eom) need_eom = &dummy;
+
+    if(length <= 127) {        /* #11.9.3.6 */
+        *need_eom = 0;
+        return per_put_few_bits(po, length, 8)
+            ? -1 : (ssize_t)length;
+    } else if(length < 16384) { /* #10.9.3.7 */
+        *need_eom = 0;
+        return per_put_few_bits(po, length|0x8000, 16)
+            ? -1 : (ssize_t)length;
+    }
+
+    *need_eom = 0 == (length & 16383);
+    length >>= 14;
+    if(length > 4) {
+        *need_eom = 0;
+        length = 4;
+    }
+
+    return per_put_few_bits(po, 0xC0 | length, 8)
+            ? -1 : (ssize_t)(length << 14);
 
 
-       return per_put_few_bits(po, 0xC0 | length, 8)
-                       ? -1 : (ssize_t)(length << 14);
 }
 
 
 }
 
 
@@ -466,18 +199,97 @@ uper_put_length(asn_per_outp_t *po, size_t length) {
  */
 int
 uper_put_nslength(asn_per_outp_t *po, size_t length) {
  */
 int
 uper_put_nslength(asn_per_outp_t *po, size_t length) {
+    if(length <= 64) {
+        /* #11.9.3.4 */
+        if(length == 0) return -1;
+        return per_put_few_bits(po, length - 1, 7) ? -1 : 0;
+    } else {
+        int need_eom = 0;
+        if(uper_put_length(po, length, &need_eom) != (ssize_t)length
+           || need_eom) {
+            /* This might happen in case of >16K extensions */
+            return -1;
+        }
+    }
+
+    return 0;
+}
 
 
-       if(length <= 64) {
-               /* #10.9.3.4 */
-               if(length == 0) return -1;
-               return per_put_few_bits(po, length-1, 7) ? -1 : 0;
-       } else {
-               if(uper_put_length(po, length) != (ssize_t)length) {
-                       /* This might happen in case of >16K extensions */
-                       return -1;
-               }
-       }
+static int
+per__long_range(long lb, long ub, unsigned long *range_r) {
+    unsigned long bounds_range;
+    if((ub < 0) == (lb < 0)) {
+        bounds_range = ub - lb;
+    } else if(lb < 0) {
+        assert(ub >= 0);
+        bounds_range = 1 + ((unsigned long)ub + (unsigned long)-(lb + 1));
+    } else {
+        assert(!"Unreachable");
+        return -1;
+    }
+    *range_r = bounds_range;
+    return 0;
+}
 
 
-       return 0;
+int
+per_long_range_rebase(long v, long lb, long ub, unsigned long *output) {
+    unsigned long range;
+
+    assert(lb <= ub);
+
+    if(v < lb || v > ub || per__long_range(lb, ub, &range) < 0) {
+        /* Range error. */
+        return -1;
+    }
+
+    /*
+     * Fundamentally what we're doing is returning (v-lb).
+     * However, this triggers undefined behavior when the word width
+     * of signed (v) is the same as the size of unsigned (*output).
+     * In practice, it triggers the UndefinedSanitizer. Therefore we shall
+     * compute the ranges accurately to avoid C's undefined behavior.
+     */
+    if((v < 0) == (lb < 0)) {
+        *output = v-lb;
+        return 0;
+    } else if(v < 0) {
+        unsigned long rebased = 1 + (unsigned long)-(v+1) + (unsigned long)lb;
+        assert(rebased <= range);   /* By construction */
+        *output = rebased;
+        return 0;
+    } else if(lb < 0) {
+        unsigned long rebased = 1 + (unsigned long)-(lb+1) + (unsigned long)v;
+        assert(rebased <= range);   /* By construction */
+        *output = rebased;
+        return 0;
+    } else {
+        assert(!"Unreachable");
+        return -1;
+    }
 }
 
 }
 
+int
+per_long_range_unrebase(unsigned long inp, long lb, long ub, long *outp) {
+    unsigned long range;
+
+    if(per__long_range(lb, ub, &range) != 0) {
+        return -1;
+    }
+
+    if(inp > range) {
+        /*
+         * We can encode something in the given number of bits that technically
+         * exceeds the range. This is an avenue for security errors,
+         * so we don't allow that.
+         */
+        return -1;
+    }
+
+    if(inp <= LONG_MAX) {
+        *outp = (long)inp + lb;
+    } else {
+        *outp = (lb + LONG_MAX + 1) + (long)((inp - LONG_MAX) - 1);
+    }
+
+    return 0;
+}
index 2624ffd11ef191518186109d5bbafb0826bc589c..926ed30dbcf666969373947081235fc353e1d8b9 100755 (executable)
@@ -8,5 +8,9 @@ ASN1C_FLAGS="${ASN1C_FLAGS:-""} -fcompound-names -fwide-types"
 
 ${ASN1C} ${ASN1C_FLAGS} RFC1213-MIB.asn1 RFC1155-SMI.asn1 RFC1157-SNMP.asn1 SMUX.asn1
 mv *.h include/stg/
 
 ${ASN1C} ${ASN1C_FLAGS} RFC1213-MIB.asn1 RFC1155-SMI.asn1 RFC1157-SNMP.asn1 SMUX.asn1
 mv *.h include/stg/
-rm Makefile.am.sample
-rm converter-sample.c
+rm -f Makefile.am.sample
+rm -f converter-sample.c
+rm -f Makefile.am.asn1convert
+rm -f Makefile.am.libasncodec
+rm -f converter-example.mk
+rm -f converter-example.c
index 299a7c1eed8ae2bb9056ce3091612e072a6fe069..5b87703a33175f96e09c3125e4d83b4197a8f4ca 100644 (file)
@@ -1,5 +1,5 @@
 /*
 /*
- * Copyright (c) 2004, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_application.h>
  * Redistribution and modifications are permitted subject to BSD license.
  */
 #include <asn_application.h>
  * Decode the XER encoding of a given type.
  */
 asn_dec_rval_t
  * Decode the XER encoding of a given type.
  */
 asn_dec_rval_t
-xer_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
-               void **struct_ptr, const void *buffer, size_t size) {
-       asn_codec_ctx_t s_codec_ctx;
+xer_decode(const asn_codec_ctx_t *opt_codec_ctx,
+           const asn_TYPE_descriptor_t *td, void **struct_ptr,
+           const void *buffer, size_t size) {
+    asn_codec_ctx_t s_codec_ctx;
 
        /*
         * Stack checker requires that the codec context
 
        /*
         * Stack checker requires that the codec context
@@ -34,7 +35,7 @@ xer_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
        /*
         * Invoke type-specific decoder.
         */
        /*
         * Invoke type-specific decoder.
         */
-       return td->xer_decoder(opt_codec_ctx, td, struct_ptr, 0, buffer, size);
+       return td->op->xer_decoder(opt_codec_ctx, td, struct_ptr, 0, buffer, size);
 }
 
 
 }
 
 
@@ -85,8 +86,8 @@ xer_next_token(int *stateContext, const void *buffer, size_t size, pxer_chunk_ty
                *ch_type = PXER_TEXT;
                break;
        case PXML_TAG:
                *ch_type = PXER_TEXT;
                break;
        case PXML_TAG:
-        *ch_type = PXER_WMORE;
-        return 0;      /* Want more */
+               *ch_type = PXER_WMORE;
+               return 0;       /* Want more */
        case PXML_TAG_END:
                *ch_type = PXER_TAG;
                break;
        case PXML_TAG_END:
                *ch_type = PXER_TAG;
                break;
@@ -201,7 +202,7 @@ xer_check_tag(const void *buf_ptr, int size, const char *need_tag) {
  * Generalized function for decoding the primitive values.
  */
 asn_dec_rval_t
  * Generalized function for decoding the primitive values.
  */
 asn_dec_rval_t
-xer_decode_general(asn_codec_ctx_t *opt_codec_ctx,
+xer_decode_general(const asn_codec_ctx_t *opt_codec_ctx,
        asn_struct_ctx_t *ctx,  /* Type decoder context */
        void *struct_key,
        const char *xml_tag,    /* Expected XML tag */
        asn_struct_ctx_t *ctx,  /* Type decoder context */
        void *struct_key,
        const char *xml_tag,    /* Expected XML tag */
index 4606575800d66298cbe6fd258080aa515f15949e..dff3c44e8c2ed2f991a0ee68f4f058c90321464c 100644 (file)
  * The XER encoder of any type. May be invoked by the application.
  */
 asn_enc_rval_t
  * The XER encoder of any type. May be invoked by the application.
  */
 asn_enc_rval_t
-xer_encode(asn_TYPE_descriptor_t *td, void *sptr,
-       enum xer_encoder_flags_e xer_flags,
-               asn_app_consume_bytes_f *cb, void *app_key) {
-       asn_enc_rval_t er, tmper;
+xer_encode(const asn_TYPE_descriptor_t *td, const void *sptr,
+           enum xer_encoder_flags_e xer_flags, asn_app_consume_bytes_f *cb,
+           void *app_key) {
+    asn_enc_rval_t er = {0, 0, 0};
+       asn_enc_rval_t tmper;
        const char *mname;
        size_t mlen;
        int xcan = (xer_flags & XER_F_CANONICAL) ? 1 : 2;
        const char *mname;
        size_t mlen;
        int xcan = (xer_flags & XER_F_CANONICAL) ? 1 : 2;
@@ -25,13 +26,12 @@ xer_encode(asn_TYPE_descriptor_t *td, void *sptr,
 
        ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
 
 
        ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
 
-       tmper = td->xer_encoder(td, sptr, 1, xer_flags, cb, app_key);
+       tmper = td->op->xer_encoder(td, sptr, 1, xer_flags, cb, app_key);
        if(tmper.encoded == -1) return tmper;
        if(tmper.encoded == -1) return tmper;
+       er.encoded += tmper.encoded;
 
        ASN__CALLBACK3("</", 2, mname, mlen, ">\n", xcan);
 
 
        ASN__CALLBACK3("</", 2, mname, mlen, ">\n", xcan);
 
-       er.encoded = 4 + xcan + (2 * mlen) + tmper.encoded;
-
        ASN__ENCODED_OK(er);
 cb_failed:
        ASN__ENCODE_FAILED;
        ASN__ENCODED_OK(er);
 cb_failed:
        ASN__ENCODE_FAILED;
@@ -52,8 +52,8 @@ xer__print2fp(const void *buffer, size_t size, void *app_key) {
 }
 
 int
 }
 
 int
-xer_fprint(FILE *stream, asn_TYPE_descriptor_t *td, void *sptr) {
-       asn_enc_rval_t er;
+xer_fprint(FILE *stream, const asn_TYPE_descriptor_t *td, const void *sptr) {
+    asn_enc_rval_t er;
 
        if(!stream) stream = stdout;
        if(!td || !sptr)
 
        if(!stream) stream = stdout;
        if(!td || !sptr)
@@ -65,3 +65,173 @@ xer_fprint(FILE *stream, asn_TYPE_descriptor_t *td, void *sptr) {
 
        return fflush(stream);
 }
 
        return fflush(stream);
 }
+
+struct xer_buffer {
+    char *buffer;
+    size_t buffer_size;
+    size_t allocated_size;
+};
+
+static int
+xer__buffer_append(const void *buffer, size_t size, void *app_key) {
+    struct xer_buffer *xb = app_key;
+
+    while(xb->buffer_size + size + 1 > xb->allocated_size) {
+        size_t new_size = 2 * (xb->allocated_size ? xb->allocated_size : 64);
+        char *new_buf = MALLOC(new_size);
+        if(!new_buf) return -1;
+        if (xb->buffer) {
+            memcpy(new_buf, xb->buffer, xb->buffer_size);
+        }
+        FREEMEM(xb->buffer);
+        xb->buffer = new_buf;
+        xb->allocated_size = new_size;
+    }
+
+    memcpy(xb->buffer + xb->buffer_size, buffer, size);
+    xb->buffer_size += size;
+    xb->buffer[xb->buffer_size] = '\0';
+    return 0;
+}
+
+enum xer_equivalence_e
+xer_equivalent(const struct asn_TYPE_descriptor_s *td, const void *struct1,
+               const void *struct2, FILE *opt_debug_stream) {
+    struct xer_buffer xb1 = {0, 0, 0};
+    struct xer_buffer xb2 = {0, 0, 0};
+    asn_enc_rval_t e1, e2;
+    asn_dec_rval_t rval;
+    void *sptr = NULL;
+
+    if(!td || !struct1 || !struct2) {
+        if(opt_debug_stream) {
+            if(!td) fprintf(opt_debug_stream, "Type descriptor missing\n");
+            if(!struct1) fprintf(opt_debug_stream, "Structure 1 missing\n");
+            if(!struct2) fprintf(opt_debug_stream, "Structure 2 missing\n");
+        }
+        return XEQ_FAILURE;
+    }
+
+    e1 = xer_encode(td, struct1, XER_F_BASIC, xer__buffer_append, &xb1);
+    if(e1.encoded == -1) {
+        if(opt_debug_stream) {
+            fprintf(stderr, "XER Encoding of %s failed\n", td->name);
+        }
+        FREEMEM(xb1.buffer);
+        return XEQ_ENCODE1_FAILED;
+    }
+
+    e2 = xer_encode(td, struct2, XER_F_BASIC, xer__buffer_append, &xb2);
+    if(e2.encoded == -1) {
+        if(opt_debug_stream) {
+            fprintf(stderr, "XER Encoding of %s failed\n", td->name);
+        }
+        FREEMEM(xb1.buffer);
+        FREEMEM(xb2.buffer);
+        return XEQ_ENCODE1_FAILED;
+    }
+
+    if(xb1.buffer_size != xb2.buffer_size
+       || memcmp(xb1.buffer, xb2.buffer, xb1.buffer_size) != 0) {
+        if(opt_debug_stream) {
+            fprintf(opt_debug_stream,
+                    "Structures XER-encoded into different byte streams:\n=== "
+                    "Structure 1 ===\n%s\n=== Structure 2 ===\n%s\n",
+                    xb1.buffer, xb2.buffer);
+        }
+        FREEMEM(xb1.buffer);
+        FREEMEM(xb2.buffer);
+        return XEQ_DIFFERENT;
+    } else {
+        if(opt_debug_stream) {
+            fprintf(opt_debug_stream,
+                    "Both structures encoded into the same XER byte stream "
+                    "of size %" ASN_PRI_SIZE ":\n%s",
+                    xb1.buffer_size, xb1.buffer);
+        }
+    }
+
+    rval = xer_decode(NULL, td, (void **)&sptr, xb1.buffer,
+               xb1.buffer_size);
+    switch(rval.code) {
+    case RC_OK:
+        break;
+    case RC_WMORE:
+        if(opt_debug_stream) {
+            fprintf(opt_debug_stream,
+                    "Structure %s XER decode unexpectedly requires "
+                    "more data:\n%s\n",
+                    td->name, xb1.buffer);
+        }
+        /* Fall through */
+    case RC_FAIL:
+    default:
+        if(opt_debug_stream) {
+            fprintf(opt_debug_stream,
+                    "Structure %s XER decoding resulted in failure.\n",
+                    td->name);
+        }
+        ASN_STRUCT_FREE(*td, sptr);
+        FREEMEM(xb1.buffer);
+        FREEMEM(xb2.buffer);
+        return XEQ_DECODE_FAILED;
+    }
+
+    if(rval.consumed != xb1.buffer_size
+       && ((rval.consumed > xb1.buffer_size)
+           || xer_whitespace_span(xb1.buffer + rval.consumed,
+                                  xb1.buffer_size - rval.consumed)
+                  != (xb1.buffer_size - rval.consumed))) {
+        if(opt_debug_stream) {
+            fprintf(opt_debug_stream,
+                    "Round-trip decode of %s required less bytes (%" ASN_PRI_SIZE ") than "
+                    "encoded (%" ASN_PRI_SIZE ")\n",
+                    td->name, rval.consumed, xb1.buffer_size);
+        }
+        ASN_STRUCT_FREE(*td, sptr);
+        FREEMEM(xb1.buffer);
+        FREEMEM(xb2.buffer);
+        return XEQ_ROUND_TRIP_FAILED;
+    }
+
+    /*
+     * Reuse xb2 to encode newly decoded structure.
+     */
+    FREEMEM(xb2.buffer);
+    memset(&xb2, 0, sizeof(xb2));
+
+    e2 = xer_encode(td, sptr, XER_F_BASIC, xer__buffer_append, &xb2);
+    if(e2.encoded == -1) {
+        if(opt_debug_stream) {
+            fprintf(stderr, "XER Encoding of round-trip decode of %s failed\n",
+                    td->name);
+        }
+        ASN_STRUCT_FREE(*td, sptr);
+        FREEMEM(xb1.buffer);
+        FREEMEM(xb2.buffer);
+        return XEQ_ROUND_TRIP_FAILED;
+    }
+
+    ASN_STRUCT_FREE(*td, sptr);
+    sptr = 0;
+
+    if(xb1.buffer_size != xb2.buffer_size
+       || memcmp(xb1.buffer, xb2.buffer, xb1.buffer_size) != 0) {
+        if(opt_debug_stream) {
+            fprintf(opt_debug_stream,
+                    "XER Encoding of round-trip decode of %s resulted in "
+                    "different byte stream:\n"
+                    "=== Original ===\n%s\n"
+                    "=== Round-tripped ===\n%s\n",
+                    xb1.buffer, xb2.buffer, td->name);
+        }
+        FREEMEM(xb1.buffer);
+        FREEMEM(xb2.buffer);
+        return XEQ_ROUND_TRIP_FAILED;
+    }
+
+       FREEMEM(xb1.buffer);
+       FREEMEM(xb2.buffer);
+       return XEQ_SUCCESS;
+}
+
index 8132bca0c2bc599dcd279527a3c39142f0097432..5dc19b6faa4d96630043f37cc58accc900222d1e 100644 (file)
@@ -8,11 +8,11 @@
 namespace
 {
 
 namespace
 {
 
-bool ParseArcs(const char * str, ptrdiff_t length, unsigned * a, size_t * pos);
-bool StringToArcs(const char * str, size_t length, std::vector<unsigned> & arcs);
-bool AppendToArcs(const char * str, size_t length, std::vector<unsigned> & arcs);
+bool ParseArcs(const char * str, ptrdiff_t length, uint32_t * a, size_t * pos);
+bool StringToArcs(const char * str, size_t length, std::vector<uint32_t> & arcs);
+bool AppendToArcs(const char * str, size_t length, std::vector<uint32_t> & arcs);
 
 
-bool ParseArcs(const char * str, ptrdiff_t length, unsigned * a, size_t * pos)
+bool ParseArcs(const char * str, ptrdiff_t length, uint32_t * a, size_t * pos)
 {
 if (length == 0)
     return false;
 {
 if (length == 0)
     return false;
@@ -23,7 +23,7 @@ size_t arcPos = 0;
 while ((left - str) < length)
     {
     char * p = NULL;
 while ((left - str) < length)
     {
     char * p = NULL;
-    unsigned arc = static_cast<unsigned int>(strtoul(left, &p, 10));
+    uint32_t arc = static_cast<uint32_t>(strtoul(left, &p, 10));
     if (p == left)
         return false;
     a[arcPos++] = arc;
     if (p == left)
         return false;
     a[arcPos++] = arc;
@@ -35,9 +35,9 @@ while ((left - str) < length)
 return true;
 }
 
 return true;
 }
 
-bool StringToArcs(const char * str, size_t length, std::vector<unsigned> & arcs)
+bool StringToArcs(const char * str, size_t length, std::vector<uint32_t> & arcs)
 {
 {
-unsigned a[1024];
+uint32_t a[1024];
 size_t pos = 0;
 
 if (!ParseArcs(str, length, a, &pos))
 size_t pos = 0;
 
 if (!ParseArcs(str, length, a, &pos))
@@ -47,9 +47,9 @@ arcs.assign(a, a + pos);
 return true;
 }
 
 return true;
 }
 
-bool AppendToArcs(const char * str, size_t length, std::vector<unsigned> & arcs)
+bool AppendToArcs(const char * str, size_t length, std::vector<uint32_t> & arcs)
 {
 {
-unsigned a[1024];
+uint32_t a[1024];
 size_t pos = 0;
 
 if (!ParseArcs(str, length, a, &pos))
 size_t pos = 0;
 
 if (!ParseArcs(str, length, a, &pos))
@@ -75,28 +75,28 @@ if (!StringToArcs(str, length, arcs))
     throw std::runtime_error("Invalid oid");
 }
 
     throw std::runtime_error("Invalid oid");
 }
 
-OID::OID(const std::vector<unsigned> & a)
+OID::OID(const std::vector<uint32_t> & a)
     : arcs(a)
 {
 }
 
     : arcs(a)
 {
 }
 
-OID::OID(const unsigned * a, size_t length)
+OID::OID(const uint32_t * a, size_t length)
     : arcs()
 {
     : arcs()
 {
-std::vector<unsigned> newArcs(a, a + length);
+std::vector<uint32_t> newArcs(a, a + length);
 arcs.swap(newArcs);
 }
 
 OID::OID(OBJECT_IDENTIFIER_t * oid)
     : arcs()
 {
 arcs.swap(newArcs);
 }
 
 OID::OID(OBJECT_IDENTIFIER_t * oid)
     : arcs()
 {
-unsigned a[1024];
-int count = OBJECT_IDENTIFIER_get_arcs(oid, a, sizeof(a[0]), 1024);
+uint32_t a[1024];
+int count = OBJECT_IDENTIFIER_get_arcs(oid, a, 1024);
 
 if (count > 1024)
     throw std::runtime_error("OID is too long");
 
 
 if (count > 1024)
     throw std::runtime_error("OID is too long");
 
-std::vector<unsigned> newArcs(a, a + count);
+std::vector<uint32_t> newArcs(a, a + count);
 arcs.swap(newArcs);
 }
 
 arcs.swap(newArcs);
 }
 
@@ -123,19 +123,19 @@ if (!AppendToArcs(suffix.c_str(), suffix.length(), arcs))
 return true;
 }
 
 return true;
 }
 
-bool OID::addSuffix(const unsigned * suffix, size_t length)
+bool OID::addSuffix(const uint32_t * suffix, size_t length)
 {
 std::copy(suffix, suffix + length, std::back_inserter(arcs));
 return true;
 }
 
 {
 std::copy(suffix, suffix + length, std::back_inserter(arcs));
 return true;
 }
 
-bool OID::addSuffix(const std::vector<unsigned> & suffix)
+bool OID::addSuffix(const std::vector<uint32_t> & suffix)
 {
 std::copy(suffix.begin(), suffix.end(), std::back_inserter(arcs));
 return true;
 }
 
 {
 std::copy(suffix.begin(), suffix.end(), std::back_inserter(arcs));
 return true;
 }
 
-bool OID::addSuffix(unsigned a, unsigned b)
+bool OID::addSuffix(uint32_t a, uint32_t b)
 {
 arcs.push_back(a);
 arcs.push_back(b);
 {
 arcs.push_back(a);
 arcs.push_back(b);
@@ -158,7 +158,7 @@ if (!oid.addSuffix(suffix))
 return oid;
 }
 
 return oid;
 }
 
-OID OID::copyWithSuffix(const unsigned * suffix, size_t length) const
+OID OID::copyWithSuffix(const uint32_t * suffix, size_t length) const
 {
 OID oid(*this);
 if (!oid.addSuffix(suffix, length))
 {
 OID oid(*this);
 if (!oid.addSuffix(suffix, length))
@@ -166,7 +166,7 @@ if (!oid.addSuffix(suffix, length))
 return oid;
 }
 
 return oid;
 }
 
-OID OID::copyWithSuffix(const std::vector<unsigned> & suffix) const
+OID OID::copyWithSuffix(const std::vector<uint32_t> & suffix) const
 {
 OID oid(*this);
 if (!oid.addSuffix(suffix))
 {
 OID oid(*this);
 if (!oid.addSuffix(suffix))
@@ -174,7 +174,7 @@ if (!oid.addSuffix(suffix))
 return oid;
 }
 
 return oid;
 }
 
-OID OID::copyWithSuffix(unsigned a, unsigned b) const
+OID OID::copyWithSuffix(uint32_t a, uint32_t b) const
 {
 OID oid(*this);
 oid.addSuffix(a, b);
 {
 OID oid(*this);
 oid.addSuffix(a, b);
@@ -191,7 +191,7 @@ return stream.str();
 
 void OID::ToOID(OBJECT_IDENTIFIER_t * oid) const
 {
 
 void OID::ToOID(OBJECT_IDENTIFIER_t * oid) const
 {
-OBJECT_IDENTIFIER_set_arcs(oid, &arcs.front(), sizeof(unsigned), static_cast<unsigned int>(arcs.size()));
+OBJECT_IDENTIFIER_set_arcs(oid, &arcs.front(), static_cast<uint32_t>(arcs.size()));
 }
 
 OID & OID::operator=(const OID & rvalue)
 }
 
 OID & OID::operator=(const OID & rvalue)
index f6b145f7e001094ca0a4d67b572a7a4ea68c9fdf..e7fcbeefcf917862c399c453277aac99b44d3c02 100644 (file)
@@ -14,26 +14,26 @@ class OID
     public:
         explicit OID(const std::string & str);
         OID(const char * str, size_t length);
     public:
         explicit OID(const std::string & str);
         OID(const char * str, size_t length);
-        explicit OID(const std::vector<unsigned> & arcs);
-        OID(const unsigned * arcs, size_t length);
+        explicit OID(const std::vector<uint32_t> & arcs);
+        OID(const uint32_t * arcs, size_t length);
         explicit OID(OBJECT_IDENTIFIER_t * oid);
         OID(const OID & rvalue);
         ~OID();
 
         bool addSuffix(const char * suffix, size_t length);
         bool addSuffix(const std::string & suffix);
         explicit OID(OBJECT_IDENTIFIER_t * oid);
         OID(const OID & rvalue);
         ~OID();
 
         bool addSuffix(const char * suffix, size_t length);
         bool addSuffix(const std::string & suffix);
-        bool addSuffix(const unsigned * suffix, size_t length);
-        bool addSuffix(const std::vector<unsigned> & suffix);
-        bool addSuffix(unsigned a, unsigned b);
+        bool addSuffix(const uint32_t * suffix, size_t length);
+        bool addSuffix(const std::vector<uint32_t> & suffix);
+        bool addSuffix(uint32_t a, uint32_t b);
 
         OID copyWithSuffix(const char * suffix, size_t length) const;
         OID copyWithSuffix(const std::string & suffix) const;
 
         OID copyWithSuffix(const char * suffix, size_t length) const;
         OID copyWithSuffix(const std::string & suffix) const;
-        OID copyWithSuffix(const unsigned * suffix, size_t length) const;
-        OID copyWithSuffix(const std::vector<unsigned> & suffix) const;
-        OID copyWithSuffix(unsigned a, unsigned b) const;
+        OID copyWithSuffix(const uint32_t * suffix, size_t length) const;
+        OID copyWithSuffix(const std::vector<uint32_t> & suffix) const;
+        OID copyWithSuffix(uint32_t a, uint32_t b) const;
 
         std::string ToString() const;
 
         std::string ToString() const;
-        const std::vector<unsigned> & ToVector() const { return arcs; }
+        const std::vector<uint32_t> & ToVector() const { return arcs; }
         void ToOID(OBJECT_IDENTIFIER_t * oid) const;
 
         OID & operator=(const OID & rvalue);
         void ToOID(OBJECT_IDENTIFIER_t * oid) const;
 
         OID & operator=(const OID & rvalue);
@@ -48,7 +48,7 @@ class OID
         friend std::ostream & operator<<(std::ostream & stream, const OID & oid);
 
     private:
         friend std::ostream & operator<<(std::ostream & stream, const OID & oid);
 
     private:
-        std::vector<unsigned> arcs;
+        std::vector<uint32_t> arcs;
 };
 
 inline
 };
 
 inline
index a2c1a47f0943fe56114d491916d902f16af72167..d1a0c281a585dec96f34d532bba0e0338f60b1c2 100644 (file)
@@ -20,7 +20,7 @@
 bool String2OI(const std::string & str, OBJECT_IDENTIFIER_t * oi)
 {
 size_t left = 0, pos = 0, arcPos = 0;
 bool String2OI(const std::string & str, OBJECT_IDENTIFIER_t * oi)
 {
 size_t left = 0, pos = 0, arcPos = 0;
-int arcs[1024];
+uint32_t arcs[1024];
 pos = str.find_first_of('.', left);
 if (pos == 0)
     {
 pos = str.find_first_of('.', left);
 if (pos == 0)
     {
@@ -47,7 +47,7 @@ if (left < str.length())
         }
     arcs[arcPos++] = arc;
     }
         }
     arcs[arcPos++] = arc;
     }
-OBJECT_IDENTIFIER_set_arcs(oi, arcs, sizeof(arcs[0]), static_cast<unsigned int>(arcPos));
+OBJECT_IDENTIFIER_set_arcs(oi, arcs, static_cast<unsigned int>(arcPos));
 return true;
 }
 
 return true;
 }
 
@@ -125,7 +125,7 @@ return true;
 
 bool SendRReqPDU(int fd)
 {
 
 bool SendRReqPDU(int fd)
 {
-int oid[] = {1, 3, 6, 1, 4, 1, 38313, 1};
+uint32_t oid[] = {1, 3, 6, 1, 4, 1, 38313, 1};
 asn_enc_rval_t error;
 RReqPDU_t msg;
 
 asn_enc_rval_t error;
 RReqPDU_t msg;
 
@@ -135,7 +135,6 @@ msg.priority = 0;
 asn_long2INTEGER(&msg.operation, RReqPDU__operation_readOnly);
 OBJECT_IDENTIFIER_set_arcs(&msg.subtree,
                            oid,
 asn_long2INTEGER(&msg.operation, RReqPDU__operation_readOnly);
 OBJECT_IDENTIFIER_set_arcs(&msg.subtree,
                            oid,
-                           sizeof(oid[0]),
                            8);
 
 char buffer[1024];
                            8);
 
 char buffer[1024];