Merge branch 'dedup' of https://github.com/orlando017/gnss-sdr into orlando017-dedup

src/core/libs/supl/CMakeLists.txt

@@ -12,6 +12,10 @@ file(GLOB ASN_SUPL_SOURCES "${CMAKE_SOURCE_DIR}/src/core/libs/supl/asn-supl/*.c"
 list(SORT ASN_SUPL_SOURCES)
 file(GLOB ASN_SUPL_HEADERS "${CMAKE_SOURCE_DIR}/src/core/libs/supl/asn-supl/*.h")
 list(SORT ASN_SUPL_HEADERS)
+file(GLOB ASN_TYPES_SOURCES "${CMAKE_SOURCE_DIR}/src/core/libs/supl/types/*.c")
+list(SORT ASN_TYPES_SOURCES)
+file(GLOB ASN_TYPES_HEADERS "${CMAKE_SOURCE_DIR}/src/core/libs/supl/types/*.h")
+list(SORT ASN_TYPES_HEADERS)
 
 if(USE_CMAKE_TARGET_SOURCES)
     add_library(core_libs_supl STATIC)
@@ -19,8 +23,10 @@ if(USE_CMAKE_TARGET_SOURCES)
         PRIVATE
             ${ASN_RRLP_SOURCES}
             ${ASN_SUPL_SOURCES}
+            ${ASN_TYPES_SOURCES}
             ${ASN_RRLP_HEADERS}
             ${ASN_SUPL_HEADERS}
+            ${ASN_TYPES_HEADERS}
             ${CMAKE_CURRENT_LIST_DIR}/supl.c
         PUBLIC
             ${CMAKE_CURRENT_LIST_DIR}/supl.h
@@ -30,6 +36,7 @@ else()
         STATIC
             ${ASN_RRLP_SOURCES}
             ${ASN_SUPL_SOURCES}
+            ${ASN_TYPES_SOURCES}
             supl.c
     )
 endif()
@@ -55,9 +62,10 @@ target_include_directories(core_libs_supl
         ${CMAKE_CURRENT_SOURCE_DIR}
         ${CMAKE_SOURCE_DIR}/src/core/libs/supl/asn-supl
         ${CMAKE_SOURCE_DIR}/src/core/libs/supl/asn-rrlp
+        ${CMAKE_SOURCE_DIR}/src/core/libs/supl/types
 )
 
 set_target_properties(core_libs_supl PROPERTIES
     LINKER_LANGUAGE C
-    INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR};${CMAKE_SOURCE_DIR}/src/core/libs/supl/asn-supl;${CMAKE_SOURCE_DIR}/src/core/libs/supl/asn-rrlp;${GNUTLS_INCLUDE_DIR}"
+    INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR};${CMAKE_SOURCE_DIR}/src/core/libs/supl/asn-supl;${CMAKE_SOURCE_DIR}/src/core/libs/supl/asn-rrlp;${CMAKE_SOURCE_DIR}/src/core/libs/supl/types;${GNUTLS_INCLUDE_DIR}"
 )

src/core/libs/supl/asn-rrlp/INTEGER.h

@@ -1,74 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _INTEGER_H
-#define _INTEGER_H
-
-#include <asn_application.h>
-#include <asn_codecs_prim.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    typedef ASN__PRIMITIVE_TYPE_t INTEGER_t;
-
-    extern asn_TYPE_descriptor_t asn_DEF_INTEGER;
-
-    /* Map with <tag> to integer value association */
-    typedef struct asn_INTEGER_enum_map_s
-    {
-        int64_t nat_value;     /* associated native integer value */
-        size_t enum_len;       /* strlen("tag") */
-        const char *enum_name; /* "tag" */
-    } asn_INTEGER_enum_map_t;
-
-    /* This type describes an enumeration for INTEGER and ENUMERATED types */
-    typedef struct asn_INTEGER_specifics_s
-    {
-        asn_INTEGER_enum_map_t *value2enum; /* N -> "tag"; sorted by N */
-        unsigned int *enum2value;           /* "tag" => N; sorted by tag */
-        int map_count;                      /* Elements in either map */
-        int extension;                      /* This map is extensible */
-        int strict_enumeration;             /* Enumeration set is fixed */
-        int field_width;                    /* Size of native integer */
-        int field_unsigned;                 /* Signed=0, unsigned=1 */
-    } asn_INTEGER_specifics_t;
-
-    asn_struct_print_f INTEGER_print;
-    ber_type_decoder_f INTEGER_decode_ber;
-    der_type_encoder_f INTEGER_encode_der;
-    xer_type_decoder_f INTEGER_decode_xer;
-    xer_type_encoder_f INTEGER_encode_xer;
-    per_type_decoder_f INTEGER_decode_uper;
-    per_type_encoder_f INTEGER_encode_uper;
-
-    /***********************************
-     * Some handy conversion routines. *
-     ***********************************/
-
-    /*
-     * Returns 0 if it was possible to convert, -1 otherwise.
-     * -1/EINVAL: Mandatory argument missing
-     * -1/ERANGE: Value encoded is out of range for long representation
-     * -1/ENOMEM: Memory allocation failed (in asn_long2INTEGER()).
-     */
-    int asn_INTEGER2long(const INTEGER_t *i, int64_t *l);
-    int asn_INTEGER2ulong(const INTEGER_t *i, uint64_t *l);
-    int asn_long2INTEGER(INTEGER_t *i, int64_t l);
-    int asn_ulong2INTEGER(INTEGER_t *i, uint64_t l);
-
-    /*
-     * Convert the integer value into the corresponding enumeration map entry.
-     */
-    const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(
-        asn_INTEGER_specifics_t *specs, int64_t value);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _INTEGER_H_ */

src/core/libs/supl/asn-rrlp/NativeInteger.c

@@ -1,377 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-/*
- * 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 <NativeInteger.h>
-#include <asn_internal.h>
-
-/*
- * NativeInteger basic type description.
- */
-static ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = {
-    (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))};
-asn_TYPE_descriptor_t asn_DEF_NativeInteger = {
-    "INTEGER", /* The ASN.1 type is still INTEGER */
-    "INTEGER",
-    NativeInteger_free,
-    NativeInteger_print,
-    asn_generic_no_constraint,
-    NativeInteger_decode_ber,
-    NativeInteger_encode_der,
-    NativeInteger_decode_xer,
-    NativeInteger_encode_xer,
-    NativeInteger_decode_uper, /* Unaligned PER decoder */
-    NativeInteger_encode_uper, /* Unaligned PER encoder */
-    0,                         /* Use generic outmost tag fetcher */
-    asn_DEF_NativeInteger_tags,
-    sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
-    asn_DEF_NativeInteger_tags, /* Same as above */
-    sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
-    0, /* No PER visible constraints */
-    0,
-    0, /* No members */
-    0  /* No specifics */
-};
-
-/*
- * Decode INTEGER type.
- */
-asn_dec_rval_t NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
-    asn_TYPE_descriptor_t *td,
-    void **nint_ptr, const void *buf_ptr,
-    size_t size, int tag_mode)
-{
-    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
-    long *native = (long *)*nint_ptr;
-    asn_dec_rval_t rval;
-    ber_tlv_len_t length;
-
-    /*
-     * If the structure is not there, allocate it.
-     */
-    if (native == NULL)
-        {
-            native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native)));
-            if (native == NULL)
-                {
-                    rval.code = RC_FAIL;
-                    rval.consumed = 0;
-                    return rval;
-                }
-        }
-
-    ASN_DEBUG("Decoding %s as INTEGER (tm=%d)", td->name, tag_mode);
-
-    /*
-     * Check tags.
-     */
-    rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size, tag_mode, 0,
-        &length, 0);
-    if (rval.code != RC_OK)
-        {
-            return rval;
-        }
-
-    ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
-
-    /*
-     * Make sure we have this length.
-     */
-    buf_ptr = ((const char *)buf_ptr) + rval.consumed;
-    size -= rval.consumed;
-    if (length > (ber_tlv_len_t)size)
-        {
-            rval.code = RC_WMORE;
-            rval.consumed = 0;
-            return rval;
-        }
-
-    /*
-     * ASN.1 encoded INTEGER: buf_ptr, length
-     * Fill the native, at the same time checking for overflow.
-     * If overflow occurred, return with RC_FAIL.
-     */
-    {
-        INTEGER_t tmp;
-        union
-        {
-            const void *constbuf;
-            void *nonconstbuf;
-        } unconst_buf;
-        int64_t l;
-
-        unconst_buf.constbuf = buf_ptr;
-        tmp.buf = (uint8_t *)unconst_buf.nonconstbuf;
-        tmp.size = length;
-
-        if ((specs && specs->field_unsigned)
-                ? asn_INTEGER2ulong(&tmp, (uint64_t *)&l)
-                : asn_INTEGER2long(&tmp, &l))
-            {
-                rval.code = RC_FAIL;
-                rval.consumed = 0;
-                return rval;
-            }
-
-        *native = l;
-    }
-
-    rval.code = RC_OK;
-    rval.consumed += length;
-
-    ASN_DEBUG("Took %ld/%ld bytes to encode %s (%ld)", (long)rval.consumed,
-        (long)length, td->name, *native);
-
-    return rval;
-}
-
-// clang-format off
-/*
- * 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)
-{
-    uint64_t native = *(uint64_t *)ptr; /* Disable sign ext. */
-    asn_enc_rval_t erval;
-    INTEGER_t tmp;
-
-#ifdef WORDS_BIGENDIAN /* Opportunistic optimization */
-
-    tmp.buf = (uint8_t *)&native;
-    tmp.size = sizeof(native);
-
-#else  /* Works even if WORDS_BIGENDIAN is not set where should've been */
-    uint8_t buf[sizeof(native)];
-    uint8_t *p;
-
-    /* Prepare a fake INTEGER */
-    for (p = buf + sizeof(buf) - 1; p >= buf; p--, native >>= 8)
-        {
-            *p = (uint8_t)native;
-        }
-
-    tmp.buf = buf;
-    tmp.size = sizeof(buf);
-#endif /* WORDS_BIGENDIAN */
-
-    /* Encode fake INTEGER */
-    erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key);
-    if (erval.encoded == -1)
-        {
-            assert(erval.structure_ptr == &tmp);
-            erval.structure_ptr = ptr;
-        }
-    return erval;
-}
-// clang-format on
-
-/*
- * Decode the chunk of XML text encoding INTEGER.
- */
-asn_dec_rval_t NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
-    asn_TYPE_descriptor_t *td, void **sptr,
-    const char *opt_mname,
-    const void *buf_ptr, size_t size)
-{
-    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
-    asn_dec_rval_t rval;
-    INTEGER_t st;
-    void *st_ptr = (void *)&st;
-    long *native = (long *)*sptr;
-
-    if (!native)
-        {
-            native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
-            if (!native)
-                {
-                    _ASN_DECODE_FAILED;
-                }
-        }
-
-    memset(&st, 0, sizeof(st));
-    rval = INTEGER_decode_xer(opt_codec_ctx, td, &st_ptr, opt_mname, buf_ptr,
-        size);
-    if (rval.code == RC_OK)
-        {
-            int64_t l;
-            if ((specs && specs->field_unsigned)
-                    ? asn_INTEGER2ulong(&st, (uint64_t *)&l)
-                    : asn_INTEGER2long(&st, &l))
-                {
-                    rval.code = RC_FAIL;
-                    rval.consumed = 0;
-                }
-            else
-                {
-                    *native = l;
-                }
-        }
-    else
-        {
-            /*
-             * Cannot restart from the middle;
-             * there is no place to save state in the native type.
-             * Request a continuation from the very beginning.
-             */
-            rval.consumed = 0;
-        }
-    ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &st);
-    return rval;
-}
-
-asn_enc_rval_t NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
-    int ilevel,
-    enum xer_encoder_flags_e flags,
-    asn_app_consume_bytes_f *cb,
-    void *app_key)
-{
-    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
-    char scratch[32]; /* Enough for 64-bit int */
-    asn_enc_rval_t er;
-    const long *native = (const long *)sptr;
-
-    (void)ilevel;
-    (void)flags;
-
-    if (!native)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    er.encoded =
-        snprintf(scratch, sizeof(scratch),
-            (specs && specs->field_unsigned) ? "%lu" : "%ld", *native);
-    if (er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch) ||
-        cb(scratch, er.encoded, app_key) < 0)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    _ASN_ENCODED_OK(er);
-}
-
-asn_dec_rval_t NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
-    asn_TYPE_descriptor_t *td,
-    asn_per_constraints_t *constraints,
-    void **sptr, asn_per_data_t *pd)
-{
-    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
-    asn_dec_rval_t rval;
-    int64_t *native = (int64_t *)*sptr;
-    INTEGER_t tmpint;
-    void *tmpintptr = &tmpint;
-
-    (void)opt_codec_ctx;
-    ASN_DEBUG("Decoding NativeInteger %s (UPER)", td->name);
-
-    if (!native)
-        {
-            native = (int64_t *)(*sptr = CALLOC(1, sizeof(*native)));
-            if (!native)
-                {
-                    _ASN_DECODE_FAILED;
-                }
-        }
-
-    memset(&tmpint, 0, sizeof tmpint);
-    rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints, &tmpintptr, pd);
-    if (rval.code == RC_OK)
-        {
-            if ((specs && specs->field_unsigned)
-                    ? asn_INTEGER2ulong(&tmpint, (uint64_t *)native)
-                    : asn_INTEGER2long(&tmpint, native))
-                {
-                    rval.code = RC_FAIL;
-                }
-            else
-                {
-                    ASN_DEBUG("NativeInteger %s got value %ld", td->name, *native);
-                }
-        }
-    ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
-
-    return rval;
-}
-
-asn_enc_rval_t NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
-    asn_per_constraints_t *constraints,
-    void *sptr, asn_per_outp_t *po)
-{
-    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
-    asn_enc_rval_t er;
-    long native;
-    INTEGER_t tmpint;
-
-    if (!sptr)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    native = *(long *)sptr;
-
-    ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);
-
-    memset(&tmpint, 0, sizeof(tmpint));
-    if ((specs && specs->field_unsigned) ? asn_ulong2INTEGER(&tmpint, native)
-                                         : asn_long2INTEGER(&tmpint, native))
-        {
-            _ASN_ENCODE_FAILED;
-        }
-    er = INTEGER_encode_uper(td, constraints, &tmpint, po);
-    ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
-    return er;
-}
-
-/*
- * INTEGER specific human-readable output.
- */
-int NativeInteger_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
-    asn_app_consume_bytes_f *cb, void *app_key)
-{
-    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
-    const long *native = (const long *)sptr;
-    char scratch[32]; /* Enough for 64-bit int */
-    int ret;
-
-    (void)td;     /* Unused argument */
-    (void)ilevel; /* Unused argument */
-
-    if (native)
-        {
-            ret = snprintf(scratch, sizeof(scratch),
-                (specs && specs->field_unsigned) ? "%lu" : "%ld",
-                *native);
-            assert(ret > 0 && (size_t)ret < sizeof(scratch));
-            return (cb(scratch, ret, app_key) < 0) ? -1 : 0;
-        }
-    else
-        {
-            return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
-        }
-}
-
-void NativeInteger_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only)
-{
-    if (!td || !ptr)
-        {
-            return;
-        }
-
-    ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)", td->name, contents_only,
-        ptr);
-
-    if (!contents_only)
-        {
-            FREEMEM(ptr);
-        }
-}

src/core/libs/supl/asn-rrlp/OCTET_STRING.h

@@ -1,90 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _OCTET_STRING_H
-#define _OCTET_STRING_H
-
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    typedef struct OCTET_STRING
-    {
-        uint8_t *buf; /* Buffer with consecutive OCTET_STRING bits */
-        int size;     /* Size of the buffer */
-
-        asn_struct_ctx_t _asn_ctx; /* Parsing across buffer boundaries */
-    } OCTET_STRING_t;
-
-    extern asn_TYPE_descriptor_t asn_DEF_OCTET_STRING;
-
-    asn_struct_free_f OCTET_STRING_free;
-    asn_struct_print_f OCTET_STRING_print;
-    asn_struct_print_f OCTET_STRING_print_utf8;
-    ber_type_decoder_f OCTET_STRING_decode_ber;
-    der_type_encoder_f OCTET_STRING_encode_der;
-    xer_type_decoder_f OCTET_STRING_decode_xer_hex;    /* Hexadecimal */
-    xer_type_decoder_f OCTET_STRING_decode_xer_binary; /* 01010111010 */
-    xer_type_decoder_f OCTET_STRING_decode_xer_utf8;   /* ASCII/UTF-8 */
-    xer_type_encoder_f OCTET_STRING_encode_xer;
-    xer_type_encoder_f OCTET_STRING_encode_xer_utf8;
-    per_type_decoder_f OCTET_STRING_decode_uper;
-    per_type_encoder_f OCTET_STRING_encode_uper;
-
-    /******************************
-     * Handy conversion routines. *
-     ******************************/
-
-    /*
-     * This function clears the previous value of the OCTET STRING (if any)
-     * and then allocates a new memory with the specified content (str/size).
-     * If size = -1, the size of the original string will be determined
-     * using strlen(str).
-     * If str equals to NULL, the function will silently clear the
-     * current contents of the OCTET STRING.
-     * Returns 0 if it was possible to perform operation, -1 otherwise.
-     */
-    int OCTET_STRING_fromBuf(OCTET_STRING_t *s, const char *str, int size);
-
-/* Handy conversion from the C string into the OCTET STRING. */
-#define OCTET_STRING_fromString(s, str) OCTET_STRING_fromBuf(s, str, -1)
-
-    /*
-     * Allocate and fill the new OCTET STRING and return a pointer to the newly
-     * allocated object. NULL is permitted in str: the function will just
-     * allocate empty OCTET STRING.
-     */
-    OCTET_STRING_t *OCTET_STRING_new_fromBuf(asn_TYPE_descriptor_t *td,
-        const char *str, int size);
-
-    /****************************
-     * Internally useful stuff. *
-     ****************************/
-
-    typedef struct asn_OCTET_STRING_specifics_s
-    {
-        /*
-         * Target structure description.
-         */
-        int struct_size; /* Size of the structure */
-        int ctx_offset;  /* Offset of the asn_struct_ctx_t member */
-
-        enum asn_OS_Subvariant
-        {
-            ASN_OSUBV_ANY, /* The open type (ANY) */
-            ASN_OSUBV_BIT, /* BIT STRING */
-            ASN_OSUBV_STR, /* String types, not {BMP,Universal}String  */
-            ASN_OSUBV_U16, /* 16-bit character (BMPString) */
-            ASN_OSUBV_U32  /* 32-bit character (UniversalString) */
-        } subvariant;
-    } asn_OCTET_STRING_specifics_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _OCTET_STRING_H_ */

src/core/libs/supl/asn-rrlp/asn_codecs_prim.h

@@ -1,54 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef ASN_CODECS_PRIM_H
-#define ASN_CODECS_PRIM_H
-
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    typedef struct ASN__PRIMITIVE_TYPE_s
-    {
-        uint8_t *buf;        /* Buffer with consecutive primitive encoding bytes */
-        int size;            /* Size of the buffer */
-    } ASN__PRIMITIVE_TYPE_t; /* Do not use this type directly! */
-
-    asn_struct_free_f ASN__PRIMITIVE_TYPE_free;
-    ber_type_decoder_f ber_decode_primitive;
-    der_type_encoder_f der_encode_primitive;
-
-    /*
-     * A callback specification for the xer_decode_primitive() function below.
-     */
-    enum xer_pbd_rval
-    {
-        XPBD_SYSTEM_FAILURE,  /* System failure (memory shortage, etc) */
-        XPBD_DECODER_LIMIT,   /* Hit some decoder limitation or deficiency */
-        XPBD_BROKEN_ENCODING, /* Encoding of a primitive body is broken */
-        XPBD_NOT_BODY_IGNORE, /* Not a body format, but safe to ignore */
-        XPBD_BODY_CONSUMED    /* Body is recognized and consumed */
-    };
-    typedef enum xer_pbd_rval(xer_primitive_body_decoder_f)(
-        asn_TYPE_descriptor_t *td, void *struct_ptr, const void *chunk_buf,
-        size_t chunk_size);
-
-    /*
-     * Specific function to decode simple primitive types.
-     * Also see xer_decode_general() in xer_decoder.h
-     */
-    asn_dec_rval_t xer_decode_primitive(
-        asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *type_descriptor,
-        void **struct_ptr, size_t struct_size, const char *opt_mname,
-        const void *buf_ptr, size_t size,
-        xer_primitive_body_decoder_f *prim_body_decoder);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* ASN_CODECS_PRIM_H */

src/core/libs/supl/asn-rrlp/ber_decoder.h

@@ -1,65 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _BER_DECODER_H
-#define _BER_DECODER_H
-
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    struct asn_TYPE_descriptor_s; /* Forward declaration */
-    struct asn_codec_ctx_s;       /* Forward declaration */
-
-    /*
-     * The BER decoder of any type.
-     * This function may be invoked directly from the application.
-     * The der_encode() function (der_encoder.h) is an opposite to ber_decode().
-     */
-    asn_dec_rval_t ber_decode(
-        struct asn_codec_ctx_s *opt_codec_ctx,
-        struct asn_TYPE_descriptor_s *type_descriptor,
-        void **struct_ptr,  /* Pointer to a target structure's pointer */
-        const void *buffer, /* Data to be decoded */
-        size_t size         /* Size of that buffer */
-    );
-
-    /*
-     * Type of generic function which decodes the byte stream into the
-     * structure.
-     */
-    typedef asn_dec_rval_t(ber_type_decoder_f)(
-        struct asn_codec_ctx_s *opt_codec_ctx,
-        struct asn_TYPE_descriptor_s *type_descriptor, void **struct_ptr,
-        const void *buf_ptr, size_t size, int tag_mode);
-
-    /*******************************
-     * INTERNALLY USEFUL FUNCTIONS *
-     *******************************/
-
-    /*
-     * Check that all tags correspond to the type definition (as given in head).
-     * On return, last_length would contain either a non-negative length of the
-     * value part of the last TLV, or the negative number of expected
-     * "end of content" sequences. The number may only be negative if the
-     * head->last_tag_form is non-zero.
-     */
-    asn_dec_rval_t ber_check_tags(
-        struct asn_codec_ctx_s *opt_codec_ctx, /* codec options */
-        struct asn_TYPE_descriptor_s *type_descriptor,
-        asn_struct_ctx_t *opt_ctx, /* saved decoding context */
-        const void *ptr, size_t size,
-        int tag_mode,                                 /* {-1,0,1}: IMPLICIT, no, EXPLICIT */
-        int last_tag_form,                            /* {-1,0:1}: any, primitive, constr */
-        ber_tlv_len_t *last_length, int *opt_tlv_form /* optional tag form */
-    );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _BER_DECODER_H_ */

src/core/libs/supl/asn-rrlp/ber_tlv_tag.h

@@ -1,63 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _BER_TLV_TAG_H
-#define _BER_TLV_TAG_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    enum asn_tag_class
-    {
-        ASN_TAG_CLASS_UNIVERSAL = 0,   /* 0b00 */
-        ASN_TAG_CLASS_APPLICATION = 1, /* 0b01 */
-        ASN_TAG_CLASS_CONTEXT = 2,     /* 0b10 */
-        ASN_TAG_CLASS_PRIVATE = 3      /* 0b11 */
-    };
-    typedef unsigned ber_tlv_tag_t; /* BER TAG from Tag-Length-Value */
-
-/*
- * Tag class is encoded together with tag value for optimization purposes.
- */
-#define BER_TAG_CLASS(tag) ((tag)&0x3)
-#define BER_TAG_VALUE(tag) ((tag) >> 2)
-#define BER_TLV_CONSTRUCTED(tagptr) \
-    (((*(const uint8_t *)tagptr) & 0x20) ? 1 : 0)
-
-#define BER_TAGS_EQUAL(tag1, tag2) ((tag1) == (tag2))
-
-    /*
-     * Several functions for printing the TAG in the canonical form
-     * (i.e. "[PRIVATE 0]").
-     * Return values correspond to their libc counterparts (if any).
-     */
-    ssize_t ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t buflen);
-    ssize_t ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *);
-    char *ber_tlv_tag_string(ber_tlv_tag_t tag);
-
-    /*
-     * This function tries to fetch the tag from the input stream.
-     * RETURN VALUES:
-     *      0:    More data expected than bufptr contains.
-     *     -1:    Fatal error deciphering tag.
-     *    >0:    Number of bytes used from bufptr. tag_r will contain the tag.
-     */
-    ssize_t ber_fetch_tag(const void *bufptr, size_t size,
-        ber_tlv_tag_t *tag_r);
-
-    /*
-     * This function serializes the tag (T from TLV) in BER format.
-     * It always returns number of bytes necessary to represent the tag,
-     * it is a caller's responsibility to check the return value
-     * against the supplied buffer's size.
-     */
-    size_t ber_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufptr, size_t size);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _BER_TLV_TAG_H_ */

src/core/libs/supl/asn-rrlp/constraints.c

@@ -1,108 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-
-// clang-format off
-#include "asn_internal.h"
-#include "constraints.h"
-// clang-format on
-
-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 */
-    (void)struct_ptr;      /* Unused argument */
-    (void)cb;              /* Unused argument */
-    (void)key;             /* Unused argument */
-
-    /* Nothing to check */
-    return 0;
-}
-
-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 */
-    (void)struct_ptr;      /* Unused argument */
-    (void)cb;              /* Unused argument */
-    (void)key;             /* Unused argument */
-
-    /* Unknown how to check */
-    return 0;
-}
-
-struct errbufDesc
-{
-    asn_TYPE_descriptor_t *failed_type;
-    const void *failed_struct_ptr;
-    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;
-    va_list ap;
-    ssize_t vlen;
-    ssize_t maxlen;
-
-    arg->failed_type = td;
-    arg->failed_struct_ptr = sptr;
-
-    maxlen = arg->errlen;
-    if (maxlen <= 0)
-        {
-            return;
-        }
-
-    va_start(ap, fmt);
-    vlen = vsnprintf(arg->errbuf, maxlen, fmt, ap);
-    va_end(ap);
-    if (vlen >= maxlen)
-        {
-            arg->errbuf[maxlen - 1] = '\0'; /* Ensuring libc correctness */
-            arg->errlen = maxlen - 1;       /* Not counting termination */
-            return;
-        }
-    else if (vlen >= 0)
-        {
-            arg->errbuf[vlen] = '\0'; /* Ensuring libc correctness */
-            arg->errlen = vlen;       /* Not counting termination */
-        }
-    else
-        {
-            /*
-             * The libc on this system is broken.
-             */
-            vlen = sizeof("<broken vsnprintf>") - 1;
-            maxlen--;
-            arg->errlen = vlen < maxlen ? vlen : maxlen;
-            memcpy(arg->errbuf, "<broken vsnprintf>", arg->errlen);
-            arg->errbuf[arg->errlen] = 0;
-        }
-}
-
-int asn_check_constraints(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;
-
-    ret = type_descriptor->check_constraints(type_descriptor, struct_ptr,
-        asn_i_ctfailcb, &arg);
-    if (ret == -1 && errlen)
-        {
-            *errlen = arg.errlen;
-        }
-
-    return ret;
-}

src/core/libs/supl/asn-rrlp/der_encoder.h

@@ -1,67 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _DER_ENCODER_H
-#define _DER_ENCODER_H
-
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    struct asn_TYPE_descriptor_s; /* Forward declaration */
-
-    /*
-     * 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().
-     */
-    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 */
-    );
-
-    /* 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) */
-    );
-
-    /*
-     * 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 */
-    );
-
-    /*******************************
-     * INTERNALLY USEFUL FUNCTIONS *
-     *******************************/
-
-    /*
-     * 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);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _DER_ENCODER_H_ */

src/core/libs/supl/asn-rrlp/per_decoder.h

@@ -1,59 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _PER_DECODER_H
-#define _PER_DECODER_H
-
-#include <asn_application.h>
-#include <per_support.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    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.
-     */
-    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 */
-    );
-
-    /*
-     * 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 */
-    );
-
-    /*
-     * 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);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _PER_DECODER_H_ */

src/core/libs/supl/asn-rrlp/per_encoder.h

@@ -1,69 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _PER_ENCODER_H
-#define _PER_ENCODER_H
-
-#include <asn_application.h>
-#include <per_support.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    struct asn_TYPE_descriptor_s; /* Forward declaration */
-
-    /*
-     * Unaligned PER encoder of any ASN.1 type. May be invoked by the
-     * application. WARNING: This function returns the number of encoded bits in
-     * the .encoded 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 */
-    );
-
-    /*
-     * A variant of uper_encode() which encodes data into the existing buffer
-     * WARNING: This function returns the number of encoded bits in the .encoded
-     * 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) */
-    );
-
-    /*
-     * A variant of uper_encode_to_buffer() which allocates buffer itself.
-     * Returns the number of bytes in the buffer or -1 in case of failure.
-     * WARNING: This function produces a "Production of the complete encoding",
-     * with length of at least one octet. Contrast this to precise bit-packing
-     * 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 */
-    );
-
-    /*
-     * 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);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _PER_ENCODER_H_ */

src/core/libs/supl/asn-rrlp/per_support.h

@@ -1,150 +0,0 @@
-/*
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _PER_SUPPORT_H
-#define _PER_SUPPORT_H
-
-#include <asn_system.h> /* Platform-specific types */
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    /*
-     * Pre-computed PER constraints.
-     */
-    typedef const struct asn_per_constraint_s
-    {
-        enum asn_per_constraint_flags
-        {
-            APC_UNCONSTRAINED = 0x0,    /* No PER visible constraints */
-            APC_SEMI_CONSTRAINED = 0x1, /* Constrained at "lb" */
-            APC_CONSTRAINED = 0x2,      /* Fully constrained */
-            APC_EXTENSIBLE = 0x4        /* May have extension */
-        } flags;
-        int range_bits;     /* Full number of bits in the range */
-        int effective_bits; /* Effective bits */
-        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;
-        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 preceding "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);
-
-    /*
-     * 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);
-
-    /*
-     * Get the normally small length "n".
-     */
-    ssize_t uper_get_nslength(asn_per_data_t *pd);
-
-    /*
-     * Get the normally small non-negative whole number.
-     */
-    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);
-
-    /* Non-thread-safe debugging function, don't use it */
-    char *per_data_string(asn_per_data_t *pd);
-
-    /*
-     * This structure supports forming PER output.
-     */
-    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);
-
-    /*
-     * 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 per_put_aligned_flush(asn_per_outp_t *po);
-
-    /* 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);
-
-    /*
-     * Put the length "n" to the Unaligned PER stream.
-     * 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);
-
-    /*
-     * Put the normally small length "n" to the Unaligned PER stream.
-     * Returns 0 or -1.
-     */
-    int uper_put_nslength(asn_per_outp_t *po, size_t length);
-
-    /*
-     * Put the normally small non-negative whole number.
-     */
-    int uper_put_nsnnwn(asn_per_outp_t *po, int n);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _PER_SUPPORT_H_ */

src/core/libs/supl/asn-rrlp/xer_decoder.h

@@ -1,109 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _XER_DECODER_H
-#define _XER_DECODER_H
-
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    struct asn_TYPE_descriptor_s; /* Forward declaration */
-
-    /*
-     * The XER decoder of any ASN.1 type. May be invoked by the application.
-     */
-    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 */
-    );
-
-    /*
-     * 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);
-
-    /*******************************
-     * INTERNALLY USEFUL FUNCTIONS *
-     *******************************/
-
-    /*
-     * Generalized function for decoding the primitive values.
-     * Used by more specialized functions, such as OCTET_STRING_decode_xer_utf8
-     * 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));
-
-    /*
-     * Fetch the next XER (XML) token from the stream.
-     * The function returns the number of bytes occupied by the chunk type,
-     * returned in the _ch_type. The _ch_type is only set (and valid) when
-     * the return value is greater than 0.
-     */
-    typedef enum pxer_chunk_type
-    {
-        PXER_TAG,    /* Complete XER tag */
-        PXER_TEXT,   /* Plain text between XER tags */
-        PXER_COMMENT /* A comment, may be part of */
-    } pxer_chunk_type_e;
-    ssize_t xer_next_token(int *stateContext, const void *buffer, size_t size,
-        pxer_chunk_type_e *_ch_type);
-
-    /*
-     * This function checks the buffer against the tag name is expected to
-     * occur.
-     */
-    typedef enum xer_check_tag
-    {
-        XCT_BROKEN = 0,     /* The tag is broken */
-        XCT_OPENING = 1,    /* This is the <opening> tag */
-        XCT_CLOSING = 2,    /* This is the </closing> tag */
-        XCT_BOTH = 3,       /* This is the <modified/> tag */
-        XCT__UNK__MASK = 4, /* Mask of everything unexpected */
-        XCT_UNKNOWN_OP = 5, /* Unexpected <opening> tag */
-        XCT_UNKNOWN_CL = 6, /* Unexpected </closing> tag */
-        XCT_UNKNOWN_BO = 7  /* Unexpected <modified/> tag */
-    } xer_check_tag_e;
-    xer_check_tag_e xer_check_tag(const void *buf_ptr, int size,
-        const char *need_tag);
-
-    /*
-     * Check whether this buffer consists of entirely XER whitespace characters.
-     * RETURN VALUES:
-     * 1:    Whitespace or empty string
-     * 0:    Non-whitespace
-     */
-    int xer_is_whitespace(const void *chunk_buf, size_t chunk_size);
-
-    /*
-     * Skip the series of anticipated extensions.
-     */
-    int xer_skip_unknown(xer_check_tag_e tcv, ber_tlv_len_t *depth);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _XER_DECODER_H_ */

src/core/libs/supl/asn-rrlp/xer_encoder.h

@@ -1,62 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _XER_ENCODER_H
-#define _XER_ENCODER_H
-
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    struct asn_TYPE_descriptor_s; /* Forward declaration */
-
-    /* Flags used by the xer_encode() and (*xer_type_encoder_f), defined below
-     */
-    enum xer_encoder_flags_e
-    {
-        /* Mode of encoding */
-        XER_F_BASIC = 0x01,    /* BASIC-XER (pretty-printing) */
-        XER_F_CANONICAL = 0x02 /* Canonical XER (strict rules) */
-    };
-
-    /*
-     * The XER encoder of any type. May be invoked by the application.
-     */
-    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 */
-    );
-
-    /*
-     * The variant of the above function which dumps the BASIC-XER (XER_F_BASIC)
-     * output into the chosen file pointer.
-     * RETURN VALUES:
-     *      0: The structure is printed.
-     *     -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);
-
-    /*
-     * 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 */
-    );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _XER_ENCODER_H_ */

src/core/libs/supl/asn-rrlp/xer_support.h

@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2003, 2004 X/IO Labs, xiolabs.com.
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _XER_SUPPORT_H
-#define _XER_SUPPORT_H
-
-#include <asn_system.h> /* Platform-specific types */
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    /*
-     * Types of data transferred to the application.
-     */
-    typedef enum
-    {
-        PXML_TEXT,    /* Plain text between XML tags. */
-        PXML_TAG,     /* A tag, starting with '<'. */
-        PXML_COMMENT, /* An XML comment, including "<!--" and "-->". */
-        /*
-         * The following chunk types are reported if the chunk
-         * terminates the specified XML element.
-         */
-        PXML_TAG_END,    /* Tag ended */
-        PXML_COMMENT_END /* Comment ended */
-    } pxml_chunk_type_e;
-
-    /*
-     * Callback function that is called by the parser when parsed data is
-     * available. The _opaque is the pointer to a field containing opaque user
-     * data specified in pxml_create() call. The chunk type is _type and the
-     * text data is the piece of buffer identified by _bufid (as supplied to
-     * pxml_feed() call) starting at offset _offset and of _size bytes size.
-     * The chunk is NOT '\0'-terminated.
-     */
-    typedef int(pxml_callback_f)(pxml_chunk_type_e _type,
-        const void *_chunk_data, size_t _chunk_size,
-        void *_key);
-
-    /*
-     * Parse the given buffer as it were a chunk of XML data.
-     * Invoke the specified callback each time the meaningful data is found.
-     * This function returns number of bytes consumed from the buffer.
-     * It will always be lesser than or equal to the specified _size.
-     * The next invocation of this function must account the difference.
-     */
-    ssize_t pxml_parse(int *_stateContext, const void *_buf, size_t _size,
-        pxml_callback_f *cb, void *_key);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _XER_SUPPORT_H_ */

src/core/libs/supl/asn-supl/BIT_STRING.c

@@ -1,207 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <BIT_STRING.h>
-#include <asn_internal.h>
-
-/*
- * BIT STRING basic type description.
- */
-static ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
-    (ASN_TAG_CLASS_UNIVERSAL | (3 << 2))};
-static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = {
-    sizeof(BIT_STRING_t), offsetof(BIT_STRING_t, _asn_ctx), ASN_OSUBV_BIT};
-asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
-    "BIT STRING",
-    "BIT_STRING",
-    OCTET_STRING_free, /* Implemented in terms of OCTET STRING */
-    BIT_STRING_print,
-    BIT_STRING_constraint,
-    OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */
-    OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */
-    OCTET_STRING_decode_xer_binary,
-    BIT_STRING_encode_xer,
-    OCTET_STRING_decode_uper, /* Unaligned PER decoder */
-    OCTET_STRING_encode_uper, /* Unaligned PER encoder */
-    0,                        /* Use generic outmost tag fetcher */
-    asn_DEF_BIT_STRING_tags,
-    sizeof(asn_DEF_BIT_STRING_tags) / sizeof(asn_DEF_BIT_STRING_tags[0]),
-    asn_DEF_BIT_STRING_tags, /* Same as above */
-    sizeof(asn_DEF_BIT_STRING_tags) / sizeof(asn_DEF_BIT_STRING_tags[0]),
-    0, /* No PER visible constraints */
-    0,
-    0, /* No members */
-    &asn_DEF_BIT_STRING_specs};
-
-/*
- * BIT STRING generic constraint.
- */
-int BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
-    asn_app_constraint_failed_f *ctfailcb, void *app_key)
-{
-    const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
-
-    if (st && st->buf)
-        {
-            if ((st->size == 0 && st->bits_unused) || st->bits_unused < 0 ||
-                st->bits_unused > 7)
-                {
-                    _ASN_CTFAIL(app_key, td, sptr,
-                        "%s: invalid padding byte (%s:%d)", td->name,
-                        __FILE__, __LINE__);
-                    return -1;
-                }
-        }
-    else
-        {
-            _ASN_CTFAIL(app_key, td, sptr, "%s: value not given (%s:%d)",
-                td->name, __FILE__, __LINE__);
-            return -1;
-        }
-
-    return 0;
-}
-
-static char *bit_pattern[16] = {"0000", "0001", "0010", "0011", "0100", "0101",
-    "0110", "0111", "1000", "1001", "1010", "1011",
-    "1100", "1101", "1110", "1111"};
-
-asn_enc_rval_t BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
-    int ilevel, enum xer_encoder_flags_e flags,
-    asn_app_consume_bytes_f *cb, void *app_key)
-{
-    asn_enc_rval_t er;
-    char scratch[128];
-    char *p = scratch;
-    char *scend = scratch + (sizeof(scratch) - 10);
-    const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
-    int xcan = (flags & XER_F_CANONICAL);
-    uint8_t *buf;
-    uint8_t *end;
-
-    if (!st || !st->buf)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    er.encoded = 0;
-
-    buf = st->buf;
-    end = buf + st->size - 1; /* Last byte is special */
-
-    /*
-     * Binary dump
-     */
-    for (; buf < end; buf++)
-        {
-            int v = *buf;
-            int nline = xcan ? 0 : (((buf - st->buf) % 8) == 0);
-            if (p >= scend || nline)
-                {
-                    er.encoded += p - scratch;
-                    _ASN_CALLBACK(scratch, p - scratch);
-                    p = scratch;
-                    if (nline)
-                        {
-                            _i_ASN_TEXT_INDENT(1, ilevel);
-                        }
-                }
-            memcpy(p + 0, bit_pattern[v >> 4], 4);
-            memcpy(p + 4, bit_pattern[v & 0x0f], 4);
-            p += 8;
-        }
-
-    if (!xcan && ((buf - st->buf) % 8) == 0)
-        {
-            _i_ASN_TEXT_INDENT(1, ilevel);
-        }
-    er.encoded += p - scratch;
-    _ASN_CALLBACK(scratch, p - scratch);
-    p = scratch;
-
-    if (buf == end)
-        {
-            int v = *buf;
-            int ubits = st->bits_unused;
-            int i;
-            for (i = 7; i >= ubits; i--)
-                {
-                    *p++ = (v & (1 << i)) ? 0x31 : 0x30;
-                }
-            er.encoded += p - scratch;
-            _ASN_CALLBACK(scratch, p - scratch);
-        }
-
-    if (!xcan)
-        {
-            _i_ASN_TEXT_INDENT(1, ilevel - 1);
-        }
-
-    _ASN_ENCODED_OK(er);
-cb_failed:
-    _ASN_ENCODE_FAILED;
-}
-
-/*
- * BIT STRING specific contents printer.
- */
-int BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
-    asn_app_consume_bytes_f *cb, void *app_key)
-{
-    static const char *h2c = "0123456789ABCDEF";
-    char scratch[64];
-    const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
-    uint8_t *buf;
-    uint8_t *end;
-    char *p = scratch;
-
-    (void)td; /* Unused argument */
-
-    if (!st || !st->buf)
-        {
-            return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
-        }
-
-    ilevel++;
-    buf = st->buf;
-    end = buf + st->size;
-
-    /*
-     * Hexadecimal dump.
-     */
-    for (; buf < end; buf++)
-        {
-            if ((buf - st->buf) % 16 == 0 && (st->size > 16) && buf != st->buf)
-                {
-                    _i_INDENT(1);
-                    /* Dump the string */
-                    if (cb(scratch, p - scratch, app_key) < 0)
-                        {
-                            return -1;
-                        }
-                    p = scratch;
-                }
-            *p++ = h2c[*buf >> 4];
-            *p++ = h2c[*buf & 0x0F];
-            *p++ = 0x20;
-        }
-
-    if (p > scratch)
-        {
-            p--; /* Eat the tailing space */
-
-            if ((st->size > 16))
-                {
-                    _i_INDENT(1);
-                }
-
-            /* Dump the incomplete 16-bytes row */
-            if (cb(scratch, p - scratch, app_key) < 0)
-                {
-                    return -1;
-                }
-        }
-
-    return 0;
-}

src/core/libs/supl/asn-supl/BIT_STRING.h

@@ -1,35 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _BIT_STRING_H
-#define _BIT_STRING_H
-
-#include <OCTET_STRING.h> /* Some help from OCTET STRING */
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    typedef struct BIT_STRING_s
-    {
-        uint8_t *buf; /* BIT STRING body */
-        int size;     /* Size of the above buffer */
-
-        int bits_unused; /* Unused trailing bits in the last octet (0..7) */
-
-        asn_struct_ctx_t _asn_ctx; /* Parsing across buffer boundaries */
-    } BIT_STRING_t;
-
-    extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
-
-    asn_struct_print_f BIT_STRING_print; /* Human-readable output */
-    asn_constr_check_f BIT_STRING_constraint;
-    xer_type_encoder_f BIT_STRING_encode_xer;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _BIT_STRING_H_ */

src/core/libs/supl/asn-supl/BOOLEAN.c

@@ -1,330 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <BOOLEAN.h>
-#include <asn_codecs_prim.h>
-#include <asn_internal.h>
-
-/*
- * BOOLEAN basic type description.
- */
-static 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
-        {
-            if (xer_is_whitespace(chunk_buf, chunk_size))
-                {
-                    return XPBD_NOT_BODY_IGNORE;
-                }
-            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;
-
-    (void)constraints;
-
-    if (!st)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    per_put_few_bits(po, *st ? 1 : 0, 1);
-
-    _ASN_ENCODED_OK(er);
-}

src/core/libs/supl/asn-supl/BOOLEAN.h

@@ -1,37 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#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_ */

src/core/libs/supl/asn-supl/ENUMERATED.c

@@ -1,82 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <ENUMERATED.h>
-#include <NativeEnumerated.h>
-#include <asn_codecs_prim.h> /* Encoder and decoder of a primitive type */
-#include <asn_internal.h>
-
-/*
- * ENUMERATED basic type description.
- */
-static ber_tlv_tag_t asn_DEF_ENUMERATED_tags[] = {
-    (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))};
-asn_TYPE_descriptor_t asn_DEF_ENUMERATED = {
-    "ENUMERATED",
-    "ENUMERATED",
-    ASN__PRIMITIVE_TYPE_free,
-    INTEGER_print, /* Implemented in terms of INTEGER */
-    asn_generic_no_constraint,
-    ber_decode_primitive,
-    INTEGER_encode_der, /* Implemented in terms of INTEGER */
-    INTEGER_decode_xer, /* This is temporary! */
-    INTEGER_encode_xer,
-    ENUMERATED_decode_uper, /* Unaligned PER decoder */
-    ENUMERATED_encode_uper, /* Unaligned PER encoder */
-    0,                      /* Use generic outmost tag fetcher */
-    asn_DEF_ENUMERATED_tags,
-    sizeof(asn_DEF_ENUMERATED_tags) / sizeof(asn_DEF_ENUMERATED_tags[0]),
-    asn_DEF_ENUMERATED_tags, /* Same as above */
-    sizeof(asn_DEF_ENUMERATED_tags) / sizeof(asn_DEF_ENUMERATED_tags[0]),
-    0, /* No PER visible constraints */
-    0,
-    0, /* No members */
-    0  /* No specifics */
-};
-
-asn_dec_rval_t ENUMERATED_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 rval;
-    ENUMERATED_t *st = (ENUMERATED_t *)*sptr;
-    long value;
-    void *vptr = &value;
-
-    if (!st)
-        {
-            st = (ENUMERATED_t *)(*sptr = CALLOC(1, sizeof(*st)));
-            if (!st)
-                {
-                    _ASN_DECODE_FAILED;
-                }
-        }
-
-    rval =
-        NativeEnumerated_decode_uper(opt_codec_ctx, td, constraints, &vptr, pd);
-    if (rval.code == RC_OK)
-        {
-            if (asn_long2INTEGER(st, value))
-                {
-                    rval.code = RC_FAIL;
-                }
-        }
-    return rval;
-}
-
-asn_enc_rval_t ENUMERATED_encode_uper(asn_TYPE_descriptor_t *td,
-    asn_per_constraints_t *constraints,
-    void *sptr, asn_per_outp_t *po)
-{
-    ENUMERATED_t *st = (ENUMERATED_t *)sptr;
-    int64_t value;
-
-    if (asn_INTEGER2long(st, &value))
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    return NativeEnumerated_encode_uper(td, constraints, &value, po);
-}

src/core/libs/supl/asn-supl/ENUMERATED.h

@@ -1,26 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _ENUMERATED_H
-#define _ENUMERATED_H
-
-#include <INTEGER.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    typedef INTEGER_t ENUMERATED_t; /* Implemented via INTEGER */
-
-    extern asn_TYPE_descriptor_t asn_DEF_ENUMERATED;
-
-    per_type_decoder_f ENUMERATED_decode_uper;
-    per_type_encoder_f ENUMERATED_encode_uper;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _ENUMERATED_H_ */

src/core/libs/supl/asn-supl/NativeEnumerated.c

@@ -1,302 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-/*
- * 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 <NativeEnumerated.h>
-#include <asn_internal.h>
-
-/*
- * NativeEnumerated basic type description.
- */
-static ber_tlv_tag_t asn_DEF_NativeEnumerated_tags[] = {
-    (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))};
-asn_TYPE_descriptor_t asn_DEF_NativeEnumerated = {
-    "ENUMERATED", /* The ASN.1 type is still ENUMERATED */
-    "ENUMERATED",
-    NativeInteger_free,
-    NativeInteger_print,
-    asn_generic_no_constraint,
-    NativeInteger_decode_ber,
-    NativeInteger_encode_der,
-    NativeInteger_decode_xer,
-    NativeEnumerated_encode_xer,
-    NativeEnumerated_decode_uper,
-    NativeEnumerated_encode_uper,
-    0, /* Use generic outmost tag fetcher */
-    asn_DEF_NativeEnumerated_tags,
-    sizeof(asn_DEF_NativeEnumerated_tags) /
-        sizeof(asn_DEF_NativeEnumerated_tags[0]),
-    asn_DEF_NativeEnumerated_tags, /* Same as above */
-    sizeof(asn_DEF_NativeEnumerated_tags) /
-        sizeof(asn_DEF_NativeEnumerated_tags[0]),
-    0, /* No PER visible constraints */
-    0,
-    0, /* No members */
-    0  /* No specifics */
-};
-
-asn_enc_rval_t NativeEnumerated_encode_xer(asn_TYPE_descriptor_t *td,
-    void *sptr, int ilevel,
-    enum xer_encoder_flags_e flags,
-    asn_app_consume_bytes_f *cb,
-    void *app_key)
-{
-    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
-    asn_enc_rval_t er;
-    const long *native = (const long *)sptr;
-    const asn_INTEGER_enum_map_t *el;
-
-    (void)ilevel;
-    (void)flags;
-
-    if (!native)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    el = INTEGER_map_value2enum(specs, *native);
-    if (el)
-        {
-            size_t srcsize = el->enum_len + 5;
-            char *src = (char *)alloca(srcsize);
-
-            er.encoded = snprintf(src, srcsize, "<%s/>", el->enum_name);
-            assert(er.encoded > 0 && (size_t)er.encoded < srcsize);
-            if (cb(src, er.encoded, app_key) < 0)
-                {
-                    _ASN_ENCODE_FAILED;
-                }
-            _ASN_ENCODED_OK(er);
-        }
-    else
-        {
-            ASN_DEBUG(
-                "ASN.1 forbids dealing with "
-                "unknown value of ENUMERATED type");
-            _ASN_ENCODE_FAILED;
-        }
-}
-
-asn_dec_rval_t NativeEnumerated_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
-    asn_TYPE_descriptor_t *td,
-    asn_per_constraints_t *constraints,
-    void **sptr, asn_per_data_t *pd)
-{
-    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
-    asn_dec_rval_t rval = {RC_OK, 0};
-    long *native = (long *)*sptr;
-    asn_per_constraint_t *ct;
-    long value;
-
-    (void)opt_codec_ctx;
-
-    if (constraints)
-        {
-            ct = &constraints->value;
-        }
-    else if (td->per_constraints)
-        {
-            ct = &td->per_constraints->value;
-        }
-    else
-        {
-            _ASN_DECODE_FAILED; /* Mandatory! */
-        }
-    if (!specs)
-        {
-            _ASN_DECODE_FAILED;
-        }
-
-    if (!native)
-        {
-            native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
-            if (!native)
-                {
-                    _ASN_DECODE_FAILED;
-                }
-        }
-
-    ASN_DEBUG("Decoding %s as NativeEnumerated", td->name);
-
-    if (ct->flags & APC_EXTENSIBLE)
-        {
-            int inext = per_get_few_bits(pd, 1);
-            if (inext < 0)
-                {
-                    _ASN_DECODE_STARVED;
-                }
-            if (inext)
-                {
-                    ct = 0;
-                }
-        }
-
-    if (ct && ct->range_bits >= 0)
-        {
-            value = per_get_few_bits(pd, ct->range_bits);
-            if (value < 0)
-                {
-                    _ASN_DECODE_STARVED;
-                }
-            if (value >=
-                (specs->extension ? specs->extension - 1 : specs->map_count))
-                {
-                    _ASN_DECODE_FAILED;
-                }
-        }
-    else
-        {
-            if (!specs->extension)
-                {
-                    _ASN_DECODE_FAILED;
-                }
-            /*
-             * X.691, #10.6: normally small non-negative whole number;
-             */
-            value = uper_get_nsnnwn(pd);
-            if (value < 0)
-                {
-                    _ASN_DECODE_STARVED;
-                }
-            value += specs->extension - 1;
-            if (value >= specs->map_count)
-                {
-                    _ASN_DECODE_FAILED;
-                }
-        }
-
-    *native = specs->value2enum[value].nat_value;
-    ASN_DEBUG("Decoded %s = %ld", td->name, *native);
-
-    return rval;
-}
-
-static int NativeEnumerated__compar_value2enum(const void *ap, const void *bp)
-{
-    const asn_INTEGER_enum_map_t *a = ap;
-    const asn_INTEGER_enum_map_t *b = bp;
-    if (a->nat_value == b->nat_value)
-        {
-            return 0;
-        }
-    if (a->nat_value < b->nat_value)
-        {
-            return -1;
-        }
-    return 1;
-}
-
-asn_enc_rval_t NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td,
-    asn_per_constraints_t *constraints,
-    void *sptr, asn_per_outp_t *po)
-{
-    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
-    asn_enc_rval_t er;
-    long native;
-    long value;
-    asn_per_constraint_t *ct;
-    int inext = 0;
-    asn_INTEGER_enum_map_t key;
-    asn_INTEGER_enum_map_t *kf;
-
-    if (!sptr)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-    if (!specs)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    if (constraints)
-        {
-            ct = &constraints->value;
-        }
-    else if (td->per_constraints)
-        {
-            ct = &td->per_constraints->value;
-        }
-    else
-        {
-            _ASN_ENCODE_FAILED; /* Mandatory! */
-        }
-
-    ASN_DEBUG("Encoding %s as NativeEnumerated", td->name);
-
-    er.encoded = 0;
-
-    native = *(long *)sptr;
-    if (native < 0)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    key.nat_value = native;
-    kf = bsearch(&key, specs->value2enum, specs->map_count, sizeof(key),
-        NativeEnumerated__compar_value2enum);
-    if (!kf)
-        {
-            ASN_DEBUG("No element corresponds to %ld", native);
-            _ASN_ENCODE_FAILED;
-        }
-    value = kf - specs->value2enum;
-
-    if (ct->range_bits >= 0)
-        {
-            int cmpWith =
-                specs->extension ? specs->extension - 1 : specs->map_count;
-            if (value >= cmpWith)
-                {
-                    inext = 1;
-                }
-        }
-    if (ct->flags & APC_EXTENSIBLE)
-        {
-            if (per_put_few_bits(po, inext, 1))
-                {
-                    _ASN_ENCODE_FAILED;
-                }
-            if (inext)
-                {
-                    ct = 0;
-                }
-        }
-    else if (inext)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    if (ct && ct->range_bits >= 0)
-        {
-            if (per_put_few_bits(po, value, ct->range_bits))
-                {
-                    _ASN_ENCODE_FAILED;
-                }
-            _ASN_ENCODED_OK(er);
-        }
-
-    if (!specs->extension)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    /*
-     * X.691, #10.6: normally small non-negative whole number;
-     */
-    ASN_DEBUG("value = %ld, ext = %d, inext = %d, res = %ld", value,
-        specs->extension, inext,
-        value - (inext ? (specs->extension - 1) : 0));
-    if (uper_put_nsnnwn(po, value - (inext ? (specs->extension - 1) : 0)))
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    _ASN_ENCODED_OK(er);
-}

src/core/libs/supl/asn-supl/NativeEnumerated.h

@@ -1,32 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-/*
- * 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_ */

src/core/libs/supl/asn-supl/NativeInteger.h

@@ -1,38 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-/*
- * This type differs from the standard INTEGER in that it is modelled using
- * the fixed machine type (long, int, short), so it can hold only values of
- * limited length. There is no type (i.e., NativeInteger_t, any integer type
- * will do).
- * This type may be used when integer range is limited by subtype constraints.
- */
-#ifndef _NativeInteger_H
-#define _NativeInteger_H
-
-#include <INTEGER.h>
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    extern asn_TYPE_descriptor_t asn_DEF_NativeInteger;
-
-    asn_struct_free_f NativeInteger_free;
-    asn_struct_print_f NativeInteger_print;
-    ber_type_decoder_f NativeInteger_decode_ber;
-    der_type_encoder_f NativeInteger_encode_der;
-    xer_type_decoder_f NativeInteger_decode_xer;
-    xer_type_encoder_f NativeInteger_encode_xer;
-    per_type_decoder_f NativeInteger_decode_uper;
-    per_type_encoder_f NativeInteger_encode_uper;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _NativeInteger_H_ */

src/core/libs/supl/asn-supl/asn_SEQUENCE_OF.c

@@ -1,51 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_SEQUENCE_OF.h>
-#include <asn_internal.h>
-
-typedef A_SEQUENCE_OF(void) asn_sequence;
-
-void asn_sequence_del(void *asn_sequence_of_x, int number, int _do_free)
-{
-    asn_sequence *as = (asn_sequence *)asn_sequence_of_x;
-
-    if (as)
-        {
-            void *ptr;
-            int n;
-
-            if (number < 0 || number >= as->count)
-                {
-                    return; /* Nothing to delete */
-                }
-
-            if (_do_free && as->free)
-                {
-                    ptr = as->array[number];
-                }
-            else
-                {
-                    ptr = 0;
-                }
-
-            /*
-             * Shift all elements to the left to hide the gap.
-             */
-            --as->count;
-            for (n = number; n < as->count; n++)
-                {
-                    as->array[n] = as->array[n + 1];
-                }
-
-            /*
-             * Invoke the third-party function only when the state
-             * of the parent structure is consistent.
-             */
-            if (ptr)
-                {
-                    as->free(ptr);
-                }
-        }
-}

src/core/libs/supl/asn-supl/asn_SEQUENCE_OF.h

@@ -1,52 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef ASN_SEQUENCE_OF_H
-#define ASN_SEQUENCE_OF_H
-
-#include <asn_SET_OF.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/*
- * SEQUENCE OF is the same as SET OF with a tiny difference:
- * the delete operation preserves the initial order of elements
- * and thus MAY operate in non-constant time.
- */
-#define A_SEQUENCE_OF(type) A_SET_OF(type)
-
-#define ASN_SEQUENCE_ADD(headptr, ptr) asn_sequence_add((headptr), (ptr))
-
-    /***********************************************
-     * Implementation of the SEQUENCE OF structure.
-     */
-
-#define asn_sequence_add asn_set_add
-#define asn_sequence_empty asn_set_empty
-
-    /*
-     * Delete the element from the set by its number (base 0).
-     * This is NOT a constant-time operation.
-     * The order of elements is preserved.
-     * If _do_free is given AND the (*free) is initialized, the element
-     * will be freed using the custom (*free) function as well.
-     */
-    void asn_sequence_del(void *asn_sequence_of_x, int number, int _do_free);
-
-    /*
-     * Cope with different conversions requirements to/from void in C and C++.
-     * This is mostly useful for support library.
-     */
-    typedef A_SEQUENCE_OF(void) asn_anonymous_sequence_;
-#define _A_SEQUENCE_FROM_VOID(ptr) ((asn_anonymous_sequence_ *)(ptr))
-#define _A_CSEQUENCE_FROM_VOID(ptr) ((const asn_anonymous_sequence_ *)(ptr))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* ASN_SEQUENCE_OF_H */

src/core/libs/supl/asn-supl/asn_SET_OF.c

@@ -1,105 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_SET_OF.h>
-#include <asn_internal.h>
-#include <errno.h>
-
-/*
- * Add another element into the set.
- */
-int asn_set_add(void *asn_set_of_x, void *ptr)
-{
-    asn_anonymous_set_ *as = _A_SET_FROM_VOID(asn_set_of_x);
-
-    if (as == 0 || ptr == 0)
-        {
-            errno = EINVAL; /* Invalid arguments */
-            return -1;
-        }
-
-    /*
-     * Make sure there's enough space to insert an element.
-     */
-    if (as->count == as->size)
-        {
-            int _newsize = as->size ? (as->size << 1) : 4;
-            void *_new_arr;
-            _new_arr = REALLOC(as->array, _newsize * sizeof(as->array[0]));
-            if (_new_arr)
-                {
-                    as->array = (void **)_new_arr;
-                    as->size = _newsize;
-                }
-            else
-                {
-                    /* ENOMEM */
-                    return -1;
-                }
-        }
-
-    as->array[as->count++] = ptr;
-
-    return 0;
-}
-
-void asn_set_del(void *asn_set_of_x, int number, int _do_free)
-{
-    asn_anonymous_set_ *as = _A_SET_FROM_VOID(asn_set_of_x);
-
-    if (as)
-        {
-            void *ptr;
-            if (number < 0 || number >= as->count)
-                {
-                    return;
-                }
-
-            if (_do_free && as->free)
-                {
-                    ptr = as->array[number];
-                }
-            else
-                {
-                    ptr = 0;
-                }
-
-            as->array[number] = as->array[--as->count];
-
-            /*
-             * Invoke the third-party function only when the state
-             * of the parent structure is consistent.
-             */
-            if (ptr)
-                {
-                    as->free(ptr);
-                }
-        }
-}
-
-/*
- * Free the contents of the set, do not free the set itself.
- */
-void asn_set_empty(void *asn_set_of_x)
-{
-    asn_anonymous_set_ *as = _A_SET_FROM_VOID(asn_set_of_x);
-
-    if (as)
-        {
-            if (as->array)
-                {
-                    if (as->free)
-                        {
-                            while (as->count--)
-                                {
-                                    as->free(as->array[as->count]);
-                                }
-                        }
-                    FREEMEM(as->array);
-                    as->array = 0;
-                }
-            as->count = 0;
-            as->size = 0;
-        }
-}

src/core/libs/supl/asn-supl/asn_SET_OF.h

@@ -1,63 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef ASN_SET_OF_H
-#define ASN_SET_OF_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#define A_SET_OF(type)                   \
-    struct                               \
-    {                                    \
-        type **array;                    \
-        int count; /* Meaningful size */ \
-        int size;  /* Allocated size */  \
-        void (*free)(type *);            \
-    }
-
-#define ASN_SET_ADD(headptr, ptr) asn_set_add((headptr), (ptr))
-
-    /*******************************************
-     * Implementation of the SET OF structure.
-     */
-
-    /*
-     * Add another structure into the set by its pointer.
-     * RETURN VALUES:
-     * 0 for success and -1/errno for failure.
-     */
-    int asn_set_add(void *asn_set_of_x, void *ptr);
-
-    /*
-     * Delete the element from the set by its number (base 0).
-     * This is a constant-time operation. The order of elements before the
-     * deleted ones is guaranteed, the order of elements after the deleted
-     * one is NOT guaranteed.
-     * If _do_free is given AND the (*free) is initialized, the element
-     * will be freed using the custom (*free) function as well.
-     */
-    void asn_set_del(void *asn_set_of_x, int number, int _do_free);
-
-    /*
-     * Empty the contents of the set. Will free the elements, if (*free) is
-     * given. Will NOT free the set itself.
-     */
-    void asn_set_empty(void *asn_set_of_x);
-
-    /*
-     * Cope with different conversions requirements to/from void in C and C++.
-     * This is mostly useful for support library.
-     */
-    typedef A_SET_OF(void) asn_anonymous_set_;
-#define _A_SET_FROM_VOID(ptr) ((asn_anonymous_set_ *)(ptr))
-#define _A_CSET_FROM_VOID(ptr) ((const asn_anonymous_set_ *)(ptr))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* ASN_SET_OF_H */

src/core/libs/supl/asn-supl/asn_application.h

@@ -1,51 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-/*
- * Application-level ASN.1 callbacks.
- */
-#ifndef _ASN_APPLICATION_H
-#define _ASN_APPLICATION_H
-
-// clang-format off
-#include "asn_system.h" /* for platform-dependent types */
-#include "asn_codecs.h" /* for ASN.1 codecs specifics */
-// clang-format on
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    /*
-     * Generic type of an application-defined callback to return various
-     * types of data to the application.
-     * EXPECTED RETURN VALUES:
-     *  -1: Failed to consume bytes. Abort the mission.
-     * Non-negative return values indicate success, and ignored.
-     */
-    typedef int(asn_app_consume_bytes_f)(const void *buffer, size_t size,
-        void *application_specific_key);
-
-    /*
-     * A callback of this type is called whenever constraint validation fails
-     * on some ASN.1 type. See "constraints.h" for more details on constraint
-     * validation.
-     * This callback specifies a descriptor of the ASN.1 type which failed
-     * the constraint check, as well as human readable message on what
-     * particular constraint has failed.
-     */
-    typedef void(asn_app_constraint_failed_f)(
-        void *application_specific_key,
-        struct asn_TYPE_descriptor_s *type_descriptor_which_failed,
-        const void *structure_which_failed_ptr,
-        const char *error_message_format, ...) GCC_PRINTFLIKE(4, 5);
-
-#ifdef __cplusplus
-}
-#endif
-
-#include "constr_TYPE.h" /* for asn_TYPE_descriptor_t */
-
-#endif /* _ASN_APPLICATION_H_ */

src/core/libs/supl/asn-supl/asn_codecs.h

@@ -1,127 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _ASN_CODECS_H
-#define _ASN_CODECS_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    struct asn_TYPE_descriptor_s; /* Forward declaration */
-
-    /*
-     * This structure defines a set of parameters that may be passed
-     * to every ASN.1 encoder or decoder function.
-     * WARNING: if max_stack_size member is set, and you are calling the
-     *   function pointers of the asn_TYPE_descriptor_t directly,
-     *   this structure must be ALLOCATED ON THE STACK!
-     *   If you can't always satisfy this requirement, use ber_decode(),
-     *   xer_decode() and uper_decode() functions instead.
-     */
-    typedef struct asn_codec_ctx_s
-    {
-        /*
-         * Limit the decoder routines to use no (much) more stack than a given
-         * number of bytes. Most of decoders are stack-based, and this
-         * would protect against stack overflows if the number of nested
-         * encodings is high.
-         * The OCTET STRING, BIT STRING and ANY BER decoders are heap-based,
-         * and are safe from this kind of overflow.
-         * A value from getrlimit(RLIMIT_STACK) may be used to initialize
-         * this variable. Be careful in multithreaded environments, as the
-         * stack size is rather limited.
-         */
-        size_t max_stack_size; /* 0 disables stack bounds checking */
-    } asn_codec_ctx_t;
-
-    /*
-     * Type of the return value of the encoding functions (der_encode,
-     * xer_encode).
-     */
-    typedef struct asn_enc_rval_s
-    {
-        /*
-         * Number of bytes encoded.
-         * -1 indicates failure to encode the structure.
-         * In this case, the members below this one are meaningful.
-         */
-        ssize_t encoded;
-
-        /*
-         * Members meaningful when (encoded == -1), for post mortem analysis.
-         */
-
-        /* Type which cannot be encoded */
-        struct asn_TYPE_descriptor_s *failed_type;
-
-        /* Pointer to the structure of that type */
-        void *structure_ptr;
-    } asn_enc_rval_t;
-#define _ASN_ENCODE_FAILED                                      \
-    do                                                          \
-        {                                                       \
-            asn_enc_rval_t tmp_error;                           \
-            tmp_error.encoded = -1;                             \
-            tmp_error.failed_type = td;                         \
-            tmp_error.structure_ptr = sptr;                     \
-            ASN_DEBUG("Failed to encode element %s", td->name); \
-            return tmp_error;                                   \
-        }                                                       \
-    while (0)
-#define _ASN_ENCODED_OK(rval)       \
-    do                              \
-        {                           \
-            rval.structure_ptr = 0; \
-            rval.failed_type = 0;   \
-            return rval;            \
-        }                           \
-    while (0)
-
-    /*
-     * Type of the return value of the decoding functions (ber_decode,
-     * xer_decode)
-     *
-     * Please note that the number of consumed bytes is ALWAYS meaningful,
-     * even if code==RC_FAIL. This is to indicate the number of successfully
-     * decoded bytes, hence providing a possibility to fail with more
-     * diagnostics (i.e., print the offending remainder of the buffer).
-     */
-    enum asn_dec_rval_code_e
-    {
-        RC_OK,    /* Decoded successfully */
-        RC_WMORE, /* More data expected, call again */
-        RC_FAIL   /* Failure to decode data */
-    };
-    typedef struct asn_dec_rval_s
-    {
-        enum asn_dec_rval_code_e code; /* Result code */
-        size_t consumed;               /* Number of bytes consumed */
-    } asn_dec_rval_t;
-#define _ASN_DECODE_FAILED                                      \
-    do                                                          \
-        {                                                       \
-            asn_dec_rval_t tmp_error;                           \
-            tmp_error.code = RC_FAIL;                           \
-            tmp_error.consumed = 0;                             \
-            ASN_DEBUG("Failed to decode element %s", td->name); \
-            return tmp_error;                                   \
-        }                                                       \
-    while (0)
-#define _ASN_DECODE_STARVED            \
-    do                                 \
-        {                              \
-            asn_dec_rval_t tmp_error;  \
-            tmp_error.code = RC_WMORE; \
-            tmp_error.consumed = 0;    \
-            return tmp_error;          \
-        }                              \
-    while (0)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _ASN_CODECS_H_ */

src/core/libs/supl/asn-supl/asn_codecs_prim.c

@@ -1,327 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_codecs_prim.h>
-#include <asn_internal.h>
-#include <errno.h>
-
-/*
- * Decode an always-primitive type.
- */
-asn_dec_rval_t ber_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
-    asn_TYPE_descriptor_t *td, void **sptr,
-    const void *buf_ptr, size_t size,
-    int tag_mode)
-{
-    ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)*sptr;
-    asn_dec_rval_t rval;
-    ber_tlv_len_t length;
-
-    /*
-     * If the structure is not there, allocate it.
-     */
-    if (st == NULL)
-        {
-            st = (ASN__PRIMITIVE_TYPE_t *)CALLOC(1, sizeof(*st));
-            if (st == NULL)
-                {
-                    _ASN_DECODE_FAILED;
-                }
-            *sptr = (void *)st;
-        }
-
-    ASN_DEBUG("Decoding %s as plain primitive (tm=%d)", td->name, tag_mode);
-
-    /*
-     * Check tags and extract value length.
-     */
-    rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size, tag_mode, 0,
-        &length, 0);
-    if (rval.code != RC_OK)
-        {
-            return rval;
-        }
-
-    ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
-
-    /*
-     * Make sure we have this length.
-     */
-    buf_ptr = ((const char *)buf_ptr) + rval.consumed;
-    size -= rval.consumed;
-    if (length > (ber_tlv_len_t)size)
-        {
-            rval.code = RC_WMORE;
-            rval.consumed = 0;
-            return rval;
-        }
-
-    st->size = (int)length;
-    /* The following better be optimized away. */
-    if (sizeof(st->size) != sizeof(length) && (ber_tlv_len_t)st->size != length)
-        {
-            st->size = 0;
-            _ASN_DECODE_FAILED;
-        }
-
-    st->buf = (uint8_t *)MALLOC(length + 1);
-    if (!st->buf)
-        {
-            st->size = 0;
-            _ASN_DECODE_FAILED;
-        }
-
-    memcpy(st->buf, buf_ptr, length);
-    st->buf[length] = '\0'; /* Just in case */
-
-    rval.code = RC_OK;
-    rval.consumed += length;
-
-    ASN_DEBUG("Took %ld/%ld bytes to encode %s", (long)rval.consumed,
-        (long)length, td->name);
-
-    return rval;
-}
-
-/*
- * Encode an always-primitive type using DER.
- */
-asn_enc_rval_t der_encode_primitive(asn_TYPE_descriptor_t *td, void *sptr,
-    int tag_mode, ber_tlv_tag_t tag,
-    asn_app_consume_bytes_f *cb, void *app_key)
-{
-    asn_enc_rval_t erval;
-    ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
-
-    ASN_DEBUG("%s %s as a primitive type (tm=%d)",
-        cb ? "Encoding" : "Estimating", td->name, tag_mode);
-
-    erval.encoded = der_write_tags(td, st->size, tag_mode, 0, tag, cb, app_key);
-    ASN_DEBUG("%s wrote tags %d", td->name, (int)erval.encoded);
-    if (erval.encoded == -1)
-        {
-            erval.failed_type = td;
-            erval.structure_ptr = sptr;
-            return erval;
-        }
-
-    if (cb && st->buf)
-        {
-            if (cb(st->buf, st->size, app_key) < 0)
-                {
-                    erval.encoded = -1;
-                    erval.failed_type = td;
-                    erval.structure_ptr = sptr;
-                    return erval;
-                }
-        }
-    else
-        {
-            assert(st->buf || st->size == 0);
-        }
-
-    erval.encoded += st->size;
-    _ASN_ENCODED_OK(erval);
-}
-
-void ASN__PRIMITIVE_TYPE_free(asn_TYPE_descriptor_t *td, void *sptr,
-    int contents_only)
-{
-    ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
-
-    if (!td || !sptr)
-        {
-            return;
-        }
-
-    ASN_DEBUG("Freeing %s as a primitive type", td->name);
-
-    if (st->buf)
-        {
-            FREEMEM(st->buf);
-        }
-
-    if (!contents_only)
-        {
-            FREEMEM(st);
-        }
-}
-
-/*
- * Local internal type passed around as an argument.
- */
-struct xdp_arg_s
-{
-    asn_TYPE_descriptor_t *type_descriptor;
-    void *struct_key;
-    xer_primitive_body_decoder_f *prim_body_decoder;
-    int decoded_something;
-    int want_more;
-};
-
-static int xer_decode__unexpected_tag(void *key, const void *chunk_buf,
-    size_t chunk_size)
-{
-    struct xdp_arg_s *arg = (struct xdp_arg_s *)key;
-    enum xer_pbd_rval bret;
-
-    if (arg->decoded_something)
-        {
-            if (xer_is_whitespace(chunk_buf, chunk_size))
-                {
-                    return 0; /* Skip it. */
-                }
-            /*
-             * Decoding was done once already. Prohibit doing it again.
-             */
-            return -1;
-        }
-
-    bret = arg->prim_body_decoder(arg->type_descriptor, arg->struct_key,
-        chunk_buf, chunk_size);
-    switch (bret)
-        {
-        case XPBD_SYSTEM_FAILURE:
-        case XPBD_DECODER_LIMIT:
-        case XPBD_BROKEN_ENCODING:
-            break;
-        case XPBD_BODY_CONSUMED:
-            /* Tag decoded successfully */
-            arg->decoded_something = 1;
-            /* Fall through */
-        case XPBD_NOT_BODY_IGNORE: /* Safe to proceed further */
-            return 0;
-        }
-
-    return -1;
-}
-
-static ssize_t xer_decode__body(void *key, const void *chunk_buf,
-    size_t chunk_size, int have_more)
-{
-    struct xdp_arg_s *arg = (struct xdp_arg_s *)key;
-    enum xer_pbd_rval bret;
-
-    if (arg->decoded_something)
-        {
-            if (xer_is_whitespace(chunk_buf, chunk_size))
-                {
-                    return chunk_size;
-                }
-            /*
-             * Decoding was done once already. Prohibit doing it again.
-             */
-            return -1;
-        }
-
-    if (!have_more)
-        {
-            /*
-             * If we've received something like "1", we can't really
-             * tell whether it is really `1` or `123`, until we know
-             * that there is no more data coming.
-             * The have_more argument will be set to 1 once something
-             * like this is available to the caller of this callback:
-             * "1<tag_start..."
-             */
-            arg->want_more = 1;
-            return -1;
-        }
-
-    bret = arg->prim_body_decoder(arg->type_descriptor, arg->struct_key,
-        chunk_buf, chunk_size);
-    switch (bret)
-        {
-        case XPBD_SYSTEM_FAILURE:
-        case XPBD_DECODER_LIMIT:
-        case XPBD_BROKEN_ENCODING:
-            break;
-        case XPBD_BODY_CONSUMED:
-            /* Tag decoded successfully */
-            arg->decoded_something = 1;
-            /* Fall through */
-        case XPBD_NOT_BODY_IGNORE: /* Safe to proceed further */
-            return chunk_size;
-        }
-
-    return -1;
-}
-
-asn_dec_rval_t xer_decode_primitive(
-    asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr,
-    size_t struct_size, const char *opt_mname, const void *buf_ptr, size_t size,
-    xer_primitive_body_decoder_f *prim_body_decoder)
-{
-    const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
-    asn_struct_ctx_t s_ctx;
-    struct xdp_arg_s s_arg;
-    asn_dec_rval_t rc;
-
-    /*
-     * Create the structure if does not exist.
-     */
-    if (!*sptr)
-        {
-            *sptr = CALLOC(1, struct_size);
-            if (!*sptr)
-                {
-                    _ASN_DECODE_FAILED;
-                }
-        }
-
-    memset(&s_ctx, 0, sizeof(s_ctx));
-    s_arg.type_descriptor = td;
-    s_arg.struct_key = *sptr;
-    s_arg.prim_body_decoder = prim_body_decoder;
-    s_arg.decoded_something = 0;
-    s_arg.want_more = 0;
-
-    rc = xer_decode_general(opt_codec_ctx, &s_ctx, &s_arg, xml_tag, buf_ptr,
-        size, xer_decode__unexpected_tag, xer_decode__body);
-    switch (rc.code)
-        {
-        case RC_OK:
-            if (!s_arg.decoded_something)
-                {
-                    char ch;
-                    ASN_DEBUG(
-                        "Primitive body is not recognized, "
-                        "supplying empty one");
-                    /*
-                     * Decoding opportunity has come and gone.
-                     * Where's the result?
-                     * Try to feed with empty body, see if it eats it.
-                     */
-                    if (prim_body_decoder(s_arg.type_descriptor,
-                            s_arg.struct_key, &ch,
-                            0) != XPBD_BODY_CONSUMED)
-                        {
-                            /*
-                             * This decoder does not like empty stuff.
-                             */
-                            _ASN_DECODE_FAILED;
-                        }
-                }
-            break;
-        case RC_WMORE:
-            /*
-             * Redo the whole thing later.
-             * We don't have a context to save intermediate parsing state.
-             */
-            rc.consumed = 0;
-            break;
-        case RC_FAIL:
-            rc.consumed = 0;
-            if (s_arg.want_more)
-                {
-                    rc.code = RC_WMORE;
-                }
-            else
-                {
-                    _ASN_DECODE_FAILED;
-                }
-            break;
-        }
-    return rc;
-}

src/core/libs/supl/asn-supl/asn_internal.h

@@ -1,133 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-/*
- * Declarations internally useful for the ASN.1 support code.
- */
-#ifndef _ASN_INTERNAL_H
-#define _ASN_INTERNAL_H
-
-#include "asn_application.h" /* Application-visible API */
-
-#ifndef __NO_ASSERT_H__ /* Include assert.h only for internal use. */
-#include <assert.h>     /* for assert() macro */
-#endif
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-// clang-format off
-/* Environment version might be used to avoid running with the old library */
-#define ASN1C_ENVIRONMENT_VERSION 922        /* Compile-time version */
-    int get_asn1c_environment_version(void); /* Run-time version */
-
-#define CALLOC(nmemb, size) calloc(nmemb, size)
-#define MALLOC(size) malloc(size)
-#define REALLOC(oldptr, size) realloc(oldptr, size)
-#define FREEMEM(ptr) free(ptr)
-
-/*
- * A macro for debugging the ASN.1 internals.
- * You may enable or override it.
- */
-#ifndef ASN_DEBUG       /* If debugging code is not defined elsewhere... */
-#if EMIT_ASN_DEBUG == 1 /* And it was asked to emit this code... */
-#ifdef __GNUC__
-#ifdef ASN_THREAD_SAFE
-#define asn_debug_indent 0
-#else  /* !ASN_THREAD_SAFE */
-    int asn_debug_indent;
-#endif /* ASN_THREAD_SAFE */
-#define ASN_DEBUG(fmt, args...)                                \
-    do                                                         \
-        {                                                      \
-            int adi = asn_debug_indent;                        \
-            while (adi--) fprintf(stderr, " ");                \
-            fprintf(stderr, fmt, ##args);                      \
-            fprintf(stderr, " (%s:%d)\n", __FILE__, __LINE__); \
-        }                                                      \
-    while (0)
-#else /* !__GNUC__ */
-    void ASN_DEBUG_f(const char *fmt, ...);
-#define ASN_DEBUG ASN_DEBUG_f
-#endif /* __GNUC__ */
-#else  /* EMIT_ASN_DEBUG != 1 */
-    static inline void ASN_DEBUG(const char *fmt, ...)
-    {
-        (void)fmt;
-    }
-#endif /* EMIT_ASN_DEBUG */
-#endif /* ASN_DEBUG */
-// clang-format on
-
-/*
- * Invoke the application-supplied callback and fail, if something is wrong.
- */
-#define __ASN_E_cbc(buf, size) (cb((buf), (size), app_key) < 0)
-#define _ASN_E_CALLBACK(foo)         \
-    do                               \
-        {                            \
-            if (foo) goto cb_failed; \
-        }                            \
-    while (0)
-#define _ASN_CALLBACK(buf, size) _ASN_E_CALLBACK(__ASN_E_cbc(buf, size))
-#define _ASN_CALLBACK2(buf1, size1, buf2, size2) \
-    _ASN_E_CALLBACK(__ASN_E_cbc(buf1, size1) || __ASN_E_cbc(buf2, size2))
-#define _ASN_CALLBACK3(buf1, size1, buf2, size2, buf3, size3)               \
-    _ASN_E_CALLBACK(__ASN_E_cbc(buf1, size1) || __ASN_E_cbc(buf2, size2) || \
-                    __ASN_E_cbc(buf3, size3))
-
-#define _i_ASN_TEXT_INDENT(nl, level)                                     \
-    do                                                                    \
-        {                                                                 \
-            int __level = (level);                                        \
-            int __nl = ((nl) != 0);                                       \
-            int __i;                                                      \
-            if (__nl) _ASN_CALLBACK("\n", 1);                             \
-            if (__level < 0) __level = 0;                                 \
-            for (__i = 0; __i < __level; __i++) _ASN_CALLBACK("    ", 4); \
-            er.encoded += __nl + 4 * __level;                             \
-        }                                                                 \
-    while (0)
-
-#define _i_INDENT(nl)                                        \
-    do                                                       \
-        {                                                    \
-            int __i;                                         \
-            if ((nl) && cb("\n", 1, app_key) < 0) return -1; \
-            for (__i = 0; __i < ilevel; __i++)               \
-                if (cb("    ", 4, app_key) < 0) return -1;   \
-        }                                                    \
-    while (0)
-
-/*
- * Check stack against overflow, if limit is set.
- */
-#define _ASN_DEFAULT_STACK_MAX (30000)
-    static inline int _ASN_STACK_OVERFLOW_CHECK(asn_codec_ctx_t *ctx)
-    {
-        if (ctx && ctx->max_stack_size)
-            {
-                /* ctx MUST be allocated on the stack */
-                ptrdiff_t usedstack = ((char *)ctx - (char *)&ctx);
-                if (usedstack > 0) usedstack = -usedstack; /* grows up! */
-
-                /* double negative required to avoid int wrap-around */
-                if (usedstack < -(ptrdiff_t)ctx->max_stack_size)
-                    {
-                        ASN_DEBUG("Stack limit %ld reached",
-                            (long)ctx->max_stack_size);
-                        return -1;
-                    }
-            }
-        return 0;
-    }
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _ASN_INTERNAL_H_ */

src/core/libs/supl/asn-supl/asn_system.h

@@ -1,133 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-/*
- * Miscellaneous system-dependent types.
- */
-#ifndef _ASN_SYSTEM_H
-#define _ASN_SYSTEM_H
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <limits.h>    /* For LONG_MAX */
-#include <stdarg.h>    /* For va_start */
-#include <stddef.h>    /* for offsetof and ptrdiff_t */
-#include <stdio.h>     /* For snprintf(3) */
-#include <stdlib.h>    /* For *alloc(3) */
-#include <string.h>    /* For memcpy(3) */
-#include <sys/types.h> /* For size_t */
-
-#ifdef WIN32
-
-#include <malloc.h>
-#define snprintf _snprintf
-#define vsnprintf _vsnprintf
-
-/* To avoid linking with ws2_32.lib, here's the definition of ntohl() */
-#define sys_ntohl(l)                                         \
-    ((((l) << 24) & 0xff000000) | (((l) << 16) & 0xff0000) | \
-        (((l) << 8) & 0xff00) | ((l)&0xff))
-
-#ifdef _MSC_VER /* MSVS.Net */
-#ifndef __cplusplus
-#define inline __inline
-#endif
-#ifndef ASSUMESTDTYPES /* Standard types have been defined elsewhere */
-#define ssize_t SSIZE_T
-typedef char int8_t;
-typedef short int16_t;
-typedef int int32_t;
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-#endif /* ASSUMESTDTYPES */
-#define WIN32_LEAN_AND_MEAN
-#include <float.h>
-#include <windows.h>
-#define isnan _isnan
-#define finite _finite
-#define copysign _copysign
-#define ilogb _logb
-#else /* !_MSC_VER */
-#include <stdint.h>
-#endif /* _MSC_VER */
-
-#else /* !WIN32 */
-
-#if defined(__vxworks)
-#include <types/vxTypes.h>
-#else /* !defined(__vxworks) */
-
-// clang-format off
-#include <inttypes.h> /* C99 specifies this file */
-/*
- * 1. Earlier FreeBSD version didn't have <stdint.h>,
- * but <inttypes.h> was present.
- * 2. Sun Solaris requires <alloca.h> for alloca(3),
- * but does not have <stdint.h>.
- */
-#if (!defined(__FreeBSD__) || !defined(_SYS_INTTYPES_H_))
-#if defined(sun)
-#include <alloca.h> /* For alloca(3) */
-#include <ieeefp.h> /* for finite(3) */
-#elif defined(__hpux)
-#ifdef __GNUC__
-#include <alloca.h> /* For alloca(3) */
-#else               /* !__GNUC__ */
-#define inline
-#endif /* __GNUC__ */
-#else
-#include <stdint.h> /* SUSv2+ and C99 specify this file, for uintXX_t */
-#endif              /* defined(sun) */
-#endif
-
-#include <netinet/in.h> /* for ntohl() */
-#define sys_ntohl(foo) ntohl(foo)
-
-#endif /* defined(__vxworks) */
-
-#endif /* WIN32 */
-
-#if __GNUC__ >= 3
-#ifndef GCC_PRINTFLIKE
-#define GCC_PRINTFLIKE(fmt, var) __attribute__((format(printf, fmt, var)))
-#endif
-#ifndef GCC_NOTUSED
-#define GCC_NOTUSED __attribute__((unused))
-#endif
-#else
-#ifndef GCC_PRINTFLIKE
-#define GCC_PRINTFLIKE(fmt, var) /* nothing */
-#endif
-#ifndef GCC_NOTUSED
-#define GCC_NOTUSED
-#endif
-#endif
-
-/* Figure out if thread safety is requested */
-#if !defined(ASN_THREAD_SAFE) && (defined(THREAD_SAFE) || defined(_REENTRANT))
-#define ASN_THREAD_SAFE
-#endif /* Thread safety */
-
-#ifndef offsetof /* If not defined by <stddef.h> */
-#define offsetof(s, m) ((ptrdiff_t) & (((s *)0)->m) - (ptrdiff_t)((s *)0))
-#endif /* offsetof */
-
-#ifndef MIN /* Suitable for comparing primitive types (integers) */
-#if defined(__GNUC__)
-#define MIN(a, b)                    \
-    ({                               \
-        __typeof a _a = a;           \
-        __typeof b _b = b;           \
-        ((_a) < (_b) ? (_a) : (_b)); \
-    })
-#else                                     /* !__GNUC__ */
-#define MIN(a, b) ((a) < (b) ? (a) : (b)) /* Unsafe variant */
-#endif                                    /* __GNUC__ */
-#endif                                    /* MIN */
-// clang-format on
-
-#endif /* _ASN_SYSTEM_H_ */

src/core/libs/supl/asn-supl/ber_decoder.c

@@ -1,337 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_internal.h>
-
-#undef ADVANCE
-#define ADVANCE(num_bytes)                   \
-    do                                       \
-        {                                    \
-            size_t num = num_bytes;          \
-            ptr = ((const char *)ptr) + num; \
-            size -= num;                     \
-            consumed_myself += num;          \
-        }                                    \
-    while (0)
-#undef RETURN
-#define RETURN(_code)                                             \
-    do                                                            \
-        {                                                         \
-            asn_dec_rval_t rval;                                  \
-            rval.code = _code;                                    \
-            if (opt_ctx) opt_ctx->step = step; /* Save context */ \
-            if ((_code) == RC_OK || opt_ctx)                      \
-                rval.consumed = consumed_myself;                  \
-            else                                                  \
-                rval.consumed = 0; /* Context-free */             \
-            return rval;                                          \
-        }                                                         \
-    while (0)
-
-/*
- * The BER decoder of any type.
- */
-asn_dec_rval_t ber_decode(asn_codec_ctx_t *opt_codec_ctx,
-    asn_TYPE_descriptor_t *type_descriptor,
-    void **struct_ptr, const void *ptr, size_t size)
-{
-    asn_codec_ctx_t s_codec_ctx;
-
-    /*
-     * Stack checker requires that the codec context
-     * must be allocated on the stack.
-     */
-    if (opt_codec_ctx)
-        {
-            if (opt_codec_ctx->max_stack_size)
-                {
-                    s_codec_ctx = *opt_codec_ctx;
-                    opt_codec_ctx = &s_codec_ctx;
-                }
-        }
-    else
-        {
-            /* If context is not given, be security-conscious anyway */
-            memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
-            s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
-            opt_codec_ctx = &s_codec_ctx;
-        }
-
-    /*
-     * Invoke type-specific decoder.
-     */
-    return type_descriptor->ber_decoder(
-        opt_codec_ctx, type_descriptor,
-        struct_ptr, /* Pointer to the destination structure */
-        ptr, size,  /* Buffer and its size */
-        0           /* Default tag mode is 0 */
-    );
-}
-
-/*
- * Check the set of <TL<TL<TL...>>> tags matches the definition.
- */
-asn_dec_rval_t ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
-    asn_TYPE_descriptor_t *td,
-    asn_struct_ctx_t *opt_ctx, const void *ptr,
-    size_t size, int tag_mode, int last_tag_form,
-    ber_tlv_len_t *last_length, int *opt_tlv_form)
-{
-    ssize_t consumed_myself = 0;
-    ssize_t tag_len;
-    ssize_t len_len;
-    ber_tlv_tag_t tlv_tag;
-    ber_tlv_len_t tlv_len;
-    ber_tlv_len_t limit_len = -1;
-    int expect_00_terminators = 0;
-    int tlv_constr = -1;                    /* If CHOICE, opt_tlv_form is not given */
-    int step = opt_ctx ? opt_ctx->step : 0; /* Where we left previously */
-    int tagno;
-
-    /*
-     * Make sure we didn't exceed the maximum stack size.
-     */
-    if (_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
-        {
-            RETURN(RC_FAIL);
-        }
-
-    /*
-     * So what does all this implicit skip stuff mean?
-     * Imagine two types,
-     *     A ::= [5] IMPLICIT    T
-     *     B ::= [2] EXPLICIT    T
-     * Where T is defined as
-     *    T ::= [4] IMPLICIT SEQUENCE { ... }
-     *
-     * Let's say, we are starting to decode type A, given the
-     * following TLV stream: <5> <0>. What does this mean?
-     * It means that the type A contains type T which is,
-     * in turn, empty.
-     * Remember though, that we are still in A. We cannot
-     * just pass control to the type T decoder. Why? Because
-     * the type T decoder expects <4> <0>, not <5> <0>.
-     * So, we must make sure we are going to receive <5> while
-     * still in A, then pass control to the T decoder, indicating
-     * that the tag <4> was implicitly skipped. The decoder of T
-     * hence will be prepared to treat <4> as valid tag, and decode
-     * it appropriately.
-     */
-
-    tagno = step /* Continuing where left previously */
-            + (tag_mode == 1 ? -1 : 0);
-    ASN_DEBUG("ber_check_tags(%s, size=%ld, tm=%d, step=%d, tagno=%d)",
-        td->name, (long)size, tag_mode, step, tagno);
-    /* assert(td->tags_count >= 1) May not be the case for CHOICE or ANY */
-
-    if (tag_mode == 0 && tagno == td->tags_count)
-        {
-            /*
-             * This must be the _untagged_ ANY type,
-             * which outermost tag isn't known in advance.
-             * Fetch the tag and length separately.
-             */
-            tag_len = ber_fetch_tag(ptr, size, &tlv_tag);
-            switch (tag_len)
-                {
-                case -1:
-                    RETURN(RC_FAIL);
-                case 0:
-                    RETURN(RC_WMORE);
-                }
-            tlv_constr = BER_TLV_CONSTRUCTED(ptr);
-            len_len = ber_fetch_length(tlv_constr, (const char *)ptr + tag_len,
-                size - tag_len, &tlv_len);
-            switch (len_len)
-                {
-                case -1:
-                    RETURN(RC_FAIL);
-                case 0:
-                    RETURN(RC_WMORE);
-                }
-            ASN_DEBUG("Advancing %ld in ANY case", (tag_len + len_len));
-            ADVANCE(tag_len + len_len);
-        }
-    else
-        {
-            assert(tagno < td->tags_count); /* At least one loop */
-        }
-    for ((void)tagno; tagno < td->tags_count; tagno++, step++)
-        {
-            /*
-             * Fetch and process T from TLV.
-             */
-            tag_len = ber_fetch_tag(ptr, size, &tlv_tag);
-            ASN_DEBUG(
-                "Fetching tag from {%p,%ld}: "
-                "len %ld, step %d, tagno %d got %s",
-                ptr, (long)size, (long)tag_len, step, tagno,
-                ber_tlv_tag_string(tlv_tag));
-            switch (tag_len)
-                {
-                case -1:
-                    RETURN(RC_FAIL);
-                case 0:
-                    RETURN(RC_WMORE);
-                }
-
-            tlv_constr = BER_TLV_CONSTRUCTED(ptr);
-
-            /*
-             * If {I}, don't check anything.
-             * If {I,B,C}, check B and C unless we're at I.
-             */
-            if (tag_mode != 0 && step == 0)
-                {
-                    /*
-                     * We don't expect tag to match here.
-                     * It's just because we don't know how the tag
-                     * is supposed to look like.
-                     */
-                }
-            else
-                {
-                    assert(tagno >= 0); /* Guaranteed by the code above */
-                    if (tlv_tag != td->tags[tagno])
-                        {
-                            /*
-                             * Unexpected tag. Too bad.
-                             */
-                            ASN_DEBUG(
-                                "Expected: %s, "
-                                "expectation failed (tn=%d, tm=%d)",
-                                ber_tlv_tag_string(td->tags[tagno]), tagno,
-                                tag_mode);
-                            RETURN(RC_FAIL);
-                        }
-                }
-
-            /*
-             * Attention: if there are more tags expected,
-             * ensure that the current tag is presented
-             * in constructed form (it contains other tags!).
-             * If this one is the last one, check that the tag form
-             * matches the one given in descriptor.
-             */
-            if (tagno < (td->tags_count - 1))
-                {
-                    if (tlv_constr == 0)
-                        {
-                            ASN_DEBUG("tlv_constr = %d, expfail", tlv_constr);
-                            RETURN(RC_FAIL);
-                        }
-                }
-            else
-                {
-                    if (last_tag_form != tlv_constr && last_tag_form != -1)
-                        {
-                            ASN_DEBUG("last_tag_form %d != %d", last_tag_form,
-                                tlv_constr);
-                            RETURN(RC_FAIL);
-                        }
-                }
-
-            /*
-             * Fetch and process L from TLV.
-             */
-            len_len = ber_fetch_length(tlv_constr, (const char *)ptr + tag_len,
-                size - tag_len, &tlv_len);
-            ASN_DEBUG("Fetchinig len = %ld", (long)len_len);
-            switch (len_len)
-                {
-                case -1:
-                    RETURN(RC_FAIL);
-                case 0:
-                    RETURN(RC_WMORE);
-                }
-
-            /*
-             * FIXME
-             * As of today, the chain of tags
-             * must either contain several indefinite length TLVs,
-             * or several definite length ones.
-             * No mixing is allowed.
-             */
-            if (tlv_len == -1)
-                {
-                    /*
-                     * Indefinite length.
-                     */
-                    if (limit_len == -1)
-                        {
-                            expect_00_terminators++;
-                        }
-                    else
-                        {
-                            ASN_DEBUG(
-                                "Unexpected indefinite length "
-                                "in a chain of definite lengths");
-                            RETURN(RC_FAIL);
-                        }
-                    ADVANCE(tag_len + len_len);
-                    continue;
-                }
-            else
-                {
-                    if (expect_00_terminators)
-                        {
-                            ASN_DEBUG(
-                                "Unexpected definite length "
-                                "in a chain of indefinite lengths");
-                            RETURN(RC_FAIL);
-                        }
-                }
-
-            /*
-             * Check that multiple TLVs specify ever decreasing length,
-             * which is consistent.
-             */
-            if (limit_len == -1)
-                {
-                    limit_len = tlv_len + tag_len + len_len;
-                    if (limit_len < 0)
-                        {
-                            /* Too great tlv_len value? */
-                            RETURN(RC_FAIL);
-                        }
-                }
-            else if (limit_len != tlv_len + tag_len + len_len)
-                {
-                    /*
-                     * Inner TLV specifies length which is inconsistent
-                     * with the outer TLV's length value.
-                     */
-                    ASN_DEBUG("Outer TLV is %ld and inner is %ld",
-                        (long)limit_len, (long)tlv_len);
-                    RETURN(RC_FAIL);
-                }
-
-            ADVANCE(tag_len + len_len);
-
-            limit_len -= (tag_len + len_len);
-            if ((ssize_t)size > limit_len)
-                {
-                    /*
-                     * Make sure that we won't consume more bytes
-                     * from the parent frame than the inferred limit.
-                     */
-                    size = limit_len;
-                }
-        }
-
-    if (opt_tlv_form)
-        {
-            *opt_tlv_form = tlv_constr;
-        }
-    if (expect_00_terminators)
-        {
-            *last_length = -expect_00_terminators;
-        }
-    else
-        {
-            *last_length = tlv_len;
-        }
-
-    RETURN(RC_OK);
-}

src/core/libs/supl/asn-supl/ber_tlv_length.c

@@ -1,214 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_internal.h>
-#include <ber_tlv_length.h>
-#include <ber_tlv_tag.h>
-
-ssize_t ber_fetch_length(int _is_constructed, const void *bufptr, size_t size,
-    ber_tlv_len_t *len_r)
-{
-    const uint8_t *buf = (const uint8_t *)bufptr;
-    unsigned oct;
-
-    if (size == 0)
-        {
-            return 0; /* Want more */
-        }
-
-    oct = *buf;
-    if ((oct & 0x80) == 0)
-        {
-            /*
-             * Short definite length.
-             */
-            *len_r = oct; /* & 0x7F */
-            return 1;
-        }
-    else
-        {
-            ber_tlv_len_t len;
-            size_t skipped;
-
-            if (_is_constructed && oct == 0x80)
-                {
-                    *len_r = -1; /* Indefinite length */
-                    return 1;
-                }
-
-            if (oct == 0xff)
-                {
-                    /* Reserved in standard for future use. */
-                    return -1;
-                }
-
-            oct &= 0x7F; /* Leave only the 7 LS bits */
-            for (len = 0, buf++, skipped = 1; oct && (++skipped <= size);
-                 buf++, oct--)
-                {
-                    len = (len << 8) | *buf;
-                    if (len < 0 || (len >> ((8 * sizeof(len)) - 8) && oct > 1))
-                        {
-                            /*
-                             * Too large length value.
-                             */
-                            return -1;
-                        }
-                }
-
-            if (oct == 0)
-                {
-                    ber_tlv_len_t lenplusepsilon = (size_t)len + 1024;
-                    /*
-                     * Here length may be very close or equal to 2G.
-                     * However, the arithmetics used in some decoders
-                     * may add some (small) quantities to the length,
-                     * to check the resulting value against some limits.
-                     * This may result in integer wrap-around, which
-                     * we try to avoid by checking it earlier here.
-                     */
-                    if (lenplusepsilon < 0)
-                        {
-                            /* Too large length value */
-                            return -1;
-                        }
-
-                    *len_r = len;
-                    return skipped;
-                }
-
-            return 0; /* Want more */
-        }
-}
-
-ssize_t ber_skip_length(asn_codec_ctx_t *opt_codec_ctx, int _is_constructed,
-    const void *ptr, size_t size)
-{
-    ber_tlv_len_t vlen; /* Length of V in TLV */
-    ssize_t tl;         /* Length of L in TLV */
-    ssize_t ll;         /* Length of L in TLV */
-    size_t skip;
-
-    /*
-     * Make sure we didn't exceed the maximum stack size.
-     */
-    if (_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
-        {
-            return -1;
-        }
-
-    /*
-     * Determine the size of L in TLV.
-     */
-    ll = ber_fetch_length(_is_constructed, ptr, size, &vlen);
-    if (ll <= 0)
-        {
-            return ll;
-        }
-
-    /*
-     * Definite length.
-     */
-    if (vlen >= 0)
-        {
-            skip = ll + vlen;
-            if (skip > size)
-                {
-                    return 0; /* Want more */
-                }
-            return skip;
-        }
-
-    /*
-     * Indefinite length!
-     */
-    ASN_DEBUG("Skipping indefinite length");
-    for (skip = ll, ptr = ((const char *)ptr) + ll, size -= ll;;)
-        {
-            ber_tlv_tag_t tag;
-
-            /* Fetch the tag */
-            tl = ber_fetch_tag(ptr, size, &tag);
-            if (tl <= 0)
-                {
-                    return tl;
-                }
-
-            ll = ber_skip_length(opt_codec_ctx, BER_TLV_CONSTRUCTED(ptr),
-                ((const char *)ptr) + tl, size - tl);
-            if (ll <= 0)
-                {
-                    return ll;
-                }
-
-            skip += tl + ll;
-
-            /*
-             * This may be the end of the indefinite length structure,
-             * two consecutive 0 octets.
-             * Check if it is true.
-             */
-            if (((const uint8_t *)ptr)[0] == 0 &&
-                ((const uint8_t *)ptr)[1] == 0)
-                {
-                    return skip;
-                }
-
-            ptr = ((const char *)ptr) + tl + ll;
-            size -= tl + ll;
-        }
-
-    /* UNREACHABLE */
-}
-
-size_t der_tlv_length_serialize(ber_tlv_len_t len, void *bufp, size_t size)
-{
-    size_t required_size; /* Size of len encoding */
-    uint8_t *buf = (uint8_t *)bufp;
-    uint8_t *end;
-    size_t i;
-
-    if (len <= 127)
-        {
-            /* Encoded in 1 octet */
-            if (size)
-                {
-                    *buf = (uint8_t)len;
-                }
-            return 1;
-        }
-
-    /*
-     * Compute the size of the subsequent bytes.
-     */
-    for (required_size = 1, i = 8; i < 8 * sizeof(len); i += 8)
-        {
-            if (len >> i)
-                {
-                    required_size++;
-                }
-            else
-                {
-                    break;
-                }
-        }
-
-    if (size <= required_size)
-        {
-            return required_size + 1;
-        }
-
-    *buf++ = (uint8_t)(0x80 | required_size); /* Length of the encoding */
-
-    /*
-     * Produce the len encoding, space permitting.
-     */
-    end = buf + required_size;
-    for (i -= 8; buf < end; i -= 8, buf++)
-        {
-            *buf = (uint8_t)(len >> i);
-        }
-
-    return required_size + 1;
-}

src/core/libs/supl/asn-supl/ber_tlv_length.h

@@ -1,52 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _BER_TLV_LENGTH_H
-#define _BER_TLV_LENGTH_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    typedef ssize_t ber_tlv_len_t;
-
-    /*
-     * This function tries to fetch the length of the BER TLV value and place it
-     * in *len_r.
-     * RETURN VALUES:
-     *     0:    More data expected than bufptr contains.
-     *    -1:    Fatal error deciphering length.
-     *    >0:    Number of bytes used from bufptr.
-     * On return with >0, len_r is constrained as -1..MAX, where -1 mean
-     * that the value is of indefinite length.
-     */
-    ssize_t ber_fetch_length(int _is_constructed, const void *bufptr,
-        size_t size, ber_tlv_len_t *len_r);
-
-    /*
-     * This function expects bufptr to be positioned over L in TLV.
-     * It returns number of bytes occupied by L and V together, suitable
-     * for skipping. The function properly handles indefinite length.
-     * RETURN VALUES:
-     *     Standard {-1,0,>0} convention.
-     */
-    ssize_t ber_skip_length(
-        struct asn_codec_ctx_s *opt_codec_ctx, /* optional context */
-        int _is_constructed, const void *bufptr, size_t size);
-
-    /*
-     * This function serializes the length (L from TLV) in DER format.
-     * It always returns number of bytes necessary to represent the length,
-     * it is a caller's responsibility to check the return value
-     * against the supplied buffer's size.
-     */
-    size_t der_tlv_length_serialize(ber_tlv_len_t len, void *bufptr,
-        size_t size);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _BER_TLV_LENGTH_H_ */

src/core/libs/supl/asn-supl/ber_tlv_tag.c

@@ -1,176 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_internal.h>
-#include <ber_tlv_tag.h>
-#include <errno.h>
-
-ssize_t ber_fetch_tag(const void *ptr, size_t size, ber_tlv_tag_t *tag_r)
-{
-    ber_tlv_tag_t val;
-    ber_tlv_tag_t tclass;
-    size_t skipped;
-
-    if (size == 0)
-        {
-            return 0;
-        }
-
-    val = *(const uint8_t *)ptr;
-    tclass = (val >> 6);
-    if ((val &= 0x1F) != 0x1F)
-        {
-            /*
-             * Simple form: everything encoded in a single octet.
-             * Tag Class is encoded using two least significant bits.
-             */
-            *tag_r = (val << 2) | tclass;
-            return 1;
-        }
-
-    /*
-     * Each octet contains 7 bits of useful information.
-     * The MSB is 0 if it is the last octet of the tag.
-     */
-    for (val = 0, ptr = ((const char *)ptr) + 1, skipped = 2; skipped <= size;
-         ptr = ((const char *)ptr) + 1, skipped++)
-        {
-            unsigned int oct = *(const uint8_t *)ptr;
-            if (oct & 0x80)
-                {
-                    val = (val << 7) | (oct & 0x7F);
-                    /*
-                     * Make sure there are at least 9 bits spare
-                     * at the MS side of a value.
-                     */
-                    if (val >> ((8 * sizeof(val)) - 9))
-                        {
-                            /*
-                             * We would not be able to accommodate
-                             * any more tag bits.
-                             */
-                            return -1;
-                        }
-                }
-            else
-                {
-                    val = (val << 7) | oct;
-                    *tag_r = (val << 2) | tclass;
-                    return skipped;
-                }
-        }
-
-    return 0; /* Want more */
-}
-
-ssize_t ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *f)
-{
-    char buf[sizeof("[APPLICATION ]") + 32];
-    ssize_t ret;
-
-    ret = ber_tlv_tag_snprint(tag, buf, sizeof(buf));
-    if (ret >= (ssize_t)sizeof(buf) || ret < 2)
-        {
-            errno = EPERM;
-            return -1;
-        }
-
-    return fwrite(buf, 1, ret, f);
-}
-
-ssize_t ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t size)
-{
-    char *type = 0;
-    int ret;
-
-    switch (tag & 0x3)
-        {
-        case ASN_TAG_CLASS_UNIVERSAL:
-            type = "UNIVERSAL ";
-            break;
-        case ASN_TAG_CLASS_APPLICATION:
-            type = "APPLICATION ";
-            break;
-        case ASN_TAG_CLASS_CONTEXT:
-            type = "";
-            break;
-        case ASN_TAG_CLASS_PRIVATE:
-            type = "PRIVATE ";
-            break;
-        }
-
-    ret = snprintf(buf, size, "[%s%u]", type, ((unsigned)tag) >> 2);
-    if (ret <= 0 && size)
-        {
-            buf[0] = '\0'; /* against broken libc's */
-        }
-
-    return ret;
-}
-
-char *ber_tlv_tag_string(ber_tlv_tag_t tag)
-{
-    static char buf[sizeof("[APPLICATION ]") + 32];
-
-    (void)ber_tlv_tag_snprint(tag, buf, sizeof(buf));
-
-    return buf;
-}
-
-size_t ber_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufp, size_t size)
-{
-    int tclass = BER_TAG_CLASS(tag);
-    ber_tlv_tag_t tval = BER_TAG_VALUE(tag);
-    uint8_t *buf = (uint8_t *)bufp;
-    uint8_t *end;
-    size_t required_size;
-    size_t i;
-
-    if (tval <= 30)
-        {
-            /* Encoded in 1 octet */
-            if (size)
-                {
-                    buf[0] = (tclass << 6) | tval;
-                }
-            return 1;
-        }
-    else if (size)
-        {
-            *buf++ = (tclass << 6) | 0x1F;
-            size--;
-        }
-
-    /*
-     * Compute the size of the subsequent bytes.
-     */
-    for (required_size = 1, i = 7; i < 8 * sizeof(tval); i += 7)
-        {
-            if (tval >> i)
-                {
-                    required_size++;
-                }
-            else
-                {
-                    break;
-                }
-        }
-
-    if (size < required_size)
-        {
-            return required_size + 1;
-        }
-
-    /*
-     * Fill in the buffer, space permitting.
-     */
-    end = buf + required_size - 1;
-    for (i -= 7; buf < end; i -= 7, buf++)
-        {
-            *buf = 0x80 | ((tval >> i) & 0x7F);
-        }
-    *buf = (tval & 0x7F); /* Last octet without high bit */
-
-    return required_size + 1;
-}

src/core/libs/supl/asn-supl/constr_CHOICE.h

@@ -1,58 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _CONSTR_CHOICE_H
-#define _CONSTR_CHOICE_H
-
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    typedef struct asn_CHOICE_specifics_s
-    {
-        /*
-         * 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) */
-
-        /*
-         * Tags to members mapping table.
-         */
-        asn_TYPE_tag2member_t *tag2el;
-        int tag2el_count;
-
-        /* Canonical ordering of CHOICE elements, for PER */
-        int *canonical_order;
-
-        /*
-         * Extensions-related stuff.
-         */
-        int ext_start; /* First member of extensions, or -1 */
-    } asn_CHOICE_specifics_t;
-
-    /*
-     * A set specialized functions dealing with the CHOICE type.
-     */
-    asn_struct_free_f CHOICE_free;
-    asn_struct_print_f CHOICE_print;
-    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;
-    per_type_decoder_f CHOICE_decode_uper;
-    per_type_encoder_f CHOICE_encode_uper;
-    asn_outmost_tag_f CHOICE_outmost_tag;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _CONSTR_CHOICE_H_ */

src/core/libs/supl/asn-supl/constr_SEQUENCE.h

@@ -1,61 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _CONSTR_SEQUENCE_H
-#define _CONSTR_SEQUENCE_H
-
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    typedef struct asn_SEQUENCE_specifics_s
-    {
-        /*
-         * Target structure description.
-         */
-        int struct_size; /* Size of the target structure. */
-        int ctx_offset;  /* Offset of the asn_struct_ctx_t member */
-
-        /*
-         * Tags to members mapping table (sorted).
-         */
-        asn_TYPE_tag2member_t *tag2el;
-        int tag2el_count;
-
-        /*
-         * Optional members of the extensions root (roms) or additions (aoms).
-         * Meaningful for PER.
-         */
-        int *oms;       /* Optional MemberS */
-        int roms_count; /* Root optional members count */
-        int aoms_count; /* Additions optional members count */
-
-        /*
-         * Description of an extensions group.
-         */
-        int ext_after;  /* Extensions start after this member */
-        int ext_before; /* Extensions stop before this member */
-    } asn_SEQUENCE_specifics_t;
-
-    /*
-     * A set specialized functions dealing with the SEQUENCE type.
-     */
-    asn_struct_free_f SEQUENCE_free;
-    asn_struct_print_f SEQUENCE_print;
-    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;
-    per_type_decoder_f SEQUENCE_decode_uper;
-    per_type_encoder_f SEQUENCE_encode_uper;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _CONSTR_SEQUENCE_H_ */

src/core/libs/supl/asn-supl/constr_SEQUENCE_OF.c

@@ -1,288 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_SEQUENCE_OF.h>
-#include <asn_internal.h>
-#include <constr_SEQUENCE_OF.h>
-
-/*
- * 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);
-    size_t computed_size = 0;
-    ssize_t encoding_size = 0;
-    asn_enc_rval_t erval;
-    int edx;
-
-    ASN_DEBUG("Estimating size of SEQUENCE 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];
-            if (!memb_ptr)
-                {
-                    continue;
-                }
-            erval =
-                elm->type->der_encoder(elm->type, memb_ptr, 0, elm->tag, 0, 0);
-            if (erval.encoded == -1)
-                {
-                    return erval;
-                }
-            computed_size += erval.encoded;
-        }
-
-    /*
-     * 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;
-    if (!cb)
-        {
-            erval.encoded = computed_size;
-            _ASN_ENCODED_OK(erval);
-        }
-
-    ASN_DEBUG("Encoding members of SEQUENCE OF %s", td->name);
-
-    /*
-     * Encode all members.
-     */
-    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, 0, elm->tag, cb,
-                app_key);
-            if (erval.encoded == -1)
-                {
-                    return erval;
-                }
-            encoding_size += erval.encoded;
-        }
-
-    if (computed_size != (size_t)encoding_size)
-        {
-            /*
-             * 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;
-            erval.structure_ptr = 0;
-            erval.failed_type = 0;
-        }
-
-    return erval;
-}
-
-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;
-
-    if (!sptr)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-
-    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;
-                }
-
-            if (mname)
-                {
-                    if (!xcan)
-                        {
-                            _i_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)
-                        {
-                            _i_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 (!xcan)
-        {
-            _i_ASN_TEXT_INDENT(1, ilevel - 1);
-        }
-
-    _ASN_ENCODED_OK(er);
-cb_failed:
-    _ASN_ENCODE_FAILED;
-}
-
-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;
-    asn_enc_rval_t er;
-    asn_TYPE_member_t *elm = td->elements;
-    int seq;
-
-    if (!sptr)
-        {
-            _ASN_ENCODE_FAILED;
-        }
-    list = _A_SEQUENCE_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->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 (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;
-                }
-        }
-
-    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;
-                        }
-                }
-        }
-
-    _ASN_ENCODED_OK(er);
-}

src/core/libs/supl/asn-supl/constr_SEQUENCE_OF.h

@@ -1,34 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _CONSTR_SEQUENCE_OF_H
-#define _CONSTR_SEQUENCE_OF_H
-
-#include <asn_application.h>
-#include <constr_SET_OF.h> /* Implemented using SET OF */
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/*
- * A set specialized functions dealing with the SEQUENCE OF type.
- * Generally implemented using SET 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
-    der_type_encoder_f SEQUENCE_OF_encode_der;
-    xer_type_encoder_f SEQUENCE_OF_encode_xer;
-    per_type_encoder_f SEQUENCE_OF_encode_uper;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _CONSTR_SET_OF_H_ */

src/core/libs/supl/asn-supl/constr_SET_OF.h

@@ -1,44 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _CONSTR_SET_OF_H
-#define _CONSTR_SET_OF_H
-
-#include <asn_application.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    typedef 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 */
-
-        /* XER-specific stuff */
-        int as_XMLValueList; /* The member type must be encoded like this */
-    } asn_SET_OF_specifics_t;
-
-    /*
-     * A set specialized functions dealing with the SET OF type.
-     */
-    asn_struct_free_f SET_OF_free;
-    asn_struct_print_f SET_OF_print;
-    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;
-    per_type_decoder_f SET_OF_decode_uper;
-    per_type_encoder_f SET_OF_encode_uper;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _CONSTR_SET_OF_H_ */

src/core/libs/supl/asn-supl/constr_TYPE.c

@@ -1,91 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_internal.h>
-#include <constr_TYPE.h>
-#include <errno.h>
-
-/*
- * Version of the ASN.1 infrastructure shipped with compiler.
- */
-int get_asn1c_environment_version() { return ASN1C_ENVIRONMENT_VERSION; }
-
-static asn_app_consume_bytes_f print2fp;
-
-/*
- * Return the outmost tag of the type.
- */
-ber_tlv_tag_t asn_TYPE_outmost_tag(asn_TYPE_descriptor_t *type_descriptor,
-    const void *struct_ptr, int tag_mode,
-    ber_tlv_tag_t tag)
-{
-    if (tag_mode)
-        {
-            return tag;
-        }
-
-    if (type_descriptor->tags_count)
-        {
-            return type_descriptor->tags[0];
-        }
-
-    return type_descriptor->outmost_tag(type_descriptor, struct_ptr, 0, 0);
-}
-
-/*
- * 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;
-        }
-
-    /* Invoke type-specific printer */
-    if (td->print_struct(td, struct_ptr, 1, print2fp, stream))
-        {
-            return -1;
-        }
-
-    /* Terminate the output */
-    if (print2fp("\n", 1, stream))
-        {
-            return -1;
-        }
-
-    return fflush(stream);
-}
-
-/* Dump the data into the specified stdio stream */
-static int print2fp(const void *buffer, size_t size, void *app_key)
-{
-    FILE *stream = (FILE *)app_key;
-
-    if (fwrite(buffer, 1, size, stream) != size)
-        {
-            return -1;
-        }
-
-    return 0;
-}
-
-/*
- * Some compilers do not support variable args macros.
- * This function is a replacement of ASN_DEBUG() macro.
- */
-void ASN_DEBUG_f(const char *fmt, ...);
-void ASN_DEBUG_f(const char *fmt, ...)
-{
-    va_list ap;
-    va_start(ap, fmt);
-    vfprintf(stderr, fmt, ap);
-    fprintf(stderr, "\n");
-    va_end(ap);
-}

src/core/libs/supl/asn-supl/constr_TYPE.h

@@ -1,184 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-/*
- * This file contains the declaration structure called "ASN.1 Type Definition",
- * which holds all information necessary for encoding and decoding routines.
- * This structure even contains pointer to these encoding and decoding routines
- * for each defined ASN.1 type.
- */
-#ifndef _CONSTR_TYPE_H
-#define _CONSTR_TYPE_H
-
-#include <ber_tlv_length.h>
-#include <ber_tlv_tag.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    struct asn_TYPE_descriptor_s; /* Forward declaration */
-    struct asn_TYPE_member_s;     /* Forward declaration */
-
-    /*
-     * This type provides the context information for various ASN.1 routines,
-     * primarily ones doing decoding. A member _asn_ctx of this type must be
-     * included into certain target language's structures, such as compound
-     * types.
-     */
-    typedef struct asn_struct_ctx_s
-    {
-        short phase;        /* Decoding phase */
-        short step;         /* Elementary step of a phase */
-        int context;        /* Other context information */
-        void *ptr;          /* Decoder-specific stuff (stack elements) */
-        ber_tlv_len_t left; /* Number of bytes left, -1 for indefinite */
-    } asn_struct_ctx_t;
-
-#include <ber_decoder.h> /* Basic Encoding Rules decoder */
-#include <constraints.h> /* Subtype constraints support */
-#include <der_encoder.h> /* Distinguished Encoding Rules encoder */
-#include <per_decoder.h> /* Packet Encoding Rules decoder */
-#include <per_encoder.h> /* Packet Encoding Rules encoder */
-#include <xer_decoder.h> /* Decoder of XER (XML, text) */
-#include <xer_encoder.h> /* Encoder into XER (XML, text) */
-
-    /*
-     * 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.)
-     */
-    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)
-
-    /*
-     * 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);
-
-    /*
-     * Return the outmost tag of the type.
-     * If the type is untagged CHOICE, the dynamic operation is performed.
-     * NOTE: This function pointer type is only useful internally.
-     * Do not use it in your application.
-     */
-    typedef ber_tlv_tag_t(asn_outmost_tag_f)(
-        struct asn_TYPE_descriptor_s *type_descriptor, const void *struct_ptr,
-        int tag_mode, ber_tlv_tag_t tag);
-    /* The instance of the above function type; used internally. */
-    asn_outmost_tag_f asn_TYPE_outmost_tag;
-
-    /*
-     * The definitive description of the destination language's structure.
-     */
-    typedef struct asn_TYPE_descriptor_s
-    {
-        char *name;    /* A name of the ASN.1 type. "" in some cases. */
-        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> */
-        ber_tlv_tag_t *tags;            /* Effective tags sequence for this type */
-        int tags_count;                 /* Number of tags which are expected */
-        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.
-         */
-        void *specifics;
-    } asn_TYPE_descriptor_t;
-
-    /*
-     * This type describes an element of the constructed type,
-     * 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 */
-    };
-    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> */
-        char *name;                                    /* ASN.1 identifier of the element */
-    } 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 occurrence of the el_tag, relative */
-        int toff_last;        /* Last occurrence of the el_tag, relatvie */
-    } 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.
-     * 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 */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _CONSTR_TYPE_H_ */

src/core/libs/supl/asn-supl/constraints.h

@@ -1,63 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _ASN1_CONSTRAINTS_VALIDATOR_H
-#define _ASN1_CONSTRAINTS_VALIDATOR_H
-
-#include <asn_system.h> /* Platform-dependent types */
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    struct asn_TYPE_descriptor_s; /* Forward declaration */
-
-    /*
-     * Validate the structure according to the ASN.1 constraints.
-     * If errbuf and errlen are given, they shall be pointing to the appropriate
-     * buffer space and its length before calling this function. Alternatively,
-     * they could be passed as NULL's. If constraints validation fails,
-     * errlen will contain the actual number of bytes taken from the errbuf
-     * to encode an error message (properly 0-terminated).
-     *
-     * RETURN VALUES:
-     * 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 */
-    );
-
-    /*
-     * 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 */
-    );
-
-    /*******************************
-     * INTERNALLY USEFUL FUNCTIONS *
-     *******************************/
-
-    asn_constr_check_f asn_generic_no_constraint;      /* No constraint whatsoever */
-    asn_constr_check_f asn_generic_unknown_constraint; /* Not fully supported */
-
-/*
- * Invoke the callback with a complete error message.
- */
-#define _ASN_CTFAIL \
-    if (ctfailcb) ctfailcb
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _ASN1_CONSTRAINTS_VALIDATOR_H_ */

src/core/libs/supl/asn-supl/der_encoder.c

@@ -1,234 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_internal.h>
-#include <errno.h>
-
-static ssize_t der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len,
-    asn_app_consume_bytes_f *cb, void *app_key,
-    int constructed);
-
-/*
- * 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", 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);
-}
-
-/*
- * Argument type and callback necessary for der_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 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;
-    asn_enc_rval_t ec;
-
-    arg.buffer = buffer;
-    arg.left = buffer_size;
-
-    ec = type_descriptor->der_encoder(
-        type_descriptor, struct_ptr, /* Pointer to the destination structure */
-        0, 0, 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;
-}
-
-/*
- * 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)
-{
-    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)", sd->name,
-        tag_mode, sd->tags_count, ber_tlv_tag_string(tag),
-        tag_mode
-            ? (sd->tags_count + 1 - ((tag_mode == -1) && sd->tags_count))
-            : sd->tags_count);
-
-    if (tag_mode)
-        {
-            /*
-             * Instead of doing shaman dance like we do in ber_check_tags(),
-             * allocate a small array on the stack
-             * and initialize it appropriately.
-             */
-            int stag_offset;
-            tags = (ber_tlv_tag_t *)alloca((sd->tags_count + 1) *
-                                           sizeof(ber_tlv_tag_t));
-            if (!tags)
-                { /* Can fail on !x86 */
-                    errno = ENOMEM;
-                    return -1;
-                }
-            tags_count = sd->tags_count +
-                         1 /* EXPLICIT or IMPLICIT tag is given */
-                         - ((tag_mode == -1) && sd->tags_count);
-            /* Copy tags over */
-            tags[0] = tag;
-            stag_offset = -1 + ((tag_mode == -1) && sd->tags_count);
-            for (i = 1; i < tags_count; i++)
-                {
-                    tags[i] = sd->tags[i + stag_offset];
-                }
-        }
-    else
-        {
-            tags = sd->tags;
-            tags_count = sd->tags_count;
-        }
-
-    /* No tags to write */
-    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.
-     */
-    overall_length = struct_length;
-    for (i = tags_count - 1; i >= 0; --i)
-        {
-            lens[i] = der_write_TL(tags[i], overall_length, 0, 0, 0);
-            if (lens[i] == -1)
-                {
-                    return -1;
-                }
-            overall_length += lens[i];
-            lens[i] = overall_length - lens[i];
-        }
-
-    if (!cb)
-        {
-            return overall_length - struct_length;
-        }
-
-    ASN_DEBUG("%s %s TL sequence (%d elements)", cb ? "Encoding" : "Estimating",
-        sd->name, tags_count);
-
-    /*
-     * Encode the TL sequence for real.
-     */
-    for (i = 0; i < tags_count; i++)
-        {
-            ssize_t len;
-            int _constr;
-
-            /* Check if this tag happens to be constructed */
-            _constr = (last_tag_form || i < (tags_count - 1));
-
-            len = der_write_TL(tags[i], lens[i], cb, app_key, _constr);
-            if (len == -1)
-                {
-                    return -1;
-                }
-        }
-
-    return overall_length - struct_length;
-}
-
-static ssize_t der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len,
-    asn_app_consume_bytes_f *cb, void *app_key,
-    int constructed)
-{
-    uint8_t buf[32];
-    size_t size = 0;
-    int buf_size = cb ? sizeof(buf) : 0;
-    ssize_t tmp;
-
-    /* Serialize tag (T from TLV) into possibly zero-length buffer */
-    tmp = ber_tlv_tag_serialize(tag, buf, buf_size);
-    if (tmp == -1 || tmp > (ssize_t)sizeof(buf))
-        {
-            return -1;
-        }
-    size += tmp;
-
-    /* Serialize length (L from TLV) into possibly zero-length buffer */
-    tmp = der_tlv_length_serialize(len, buf + size,
-        buf_size ? buf_size - size : 0);
-    if (tmp == -1)
-        {
-            return -1;
-        }
-    size += tmp;
-
-    if (size > sizeof(buf))
-        {
-            return -1;
-        }
-
-    /*
-     * If callback is specified, invoke it, and check its return value.
-     */
-    if (cb)
-        {
-            if (constructed)
-                {
-                    *buf |= 0x20;
-                }
-            if (cb(buf, size, app_key) < 0)
-                {
-                    return -1;
-                }
-        }
-
-    return size;
-}

src/core/libs/supl/asn-supl/per_decoder.c

@@ -1,123 +0,0 @@
-/*
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-
-#include <asn_application.h>
-#include <asn_internal.h>
-#include <per_decoder.h>
-
-/*
- * Decode a "Production of a complete encoding", X.691#10.1.
- * The complete encoding contains at least one byte, and is an integral
- * 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;
-
-    rval = uper_decode(opt_codec_ctx, td, sptr, buffer, size, 0, 0);
-    if (rval.consumed)
-        {
-            /*
-             * We've always given 8-aligned data,
-             * so convert bits to integral bytes.
-             */
-            rval.consumed += 7;
-            rval.consumed >>= 3;
-        }
-    else if (rval.code == RC_OK)
-        {
-            if (size)
-                {
-                    if (((uint8_t *)buffer)[0] == 0)
-                        {
-                            rval.consumed = 1; /* 1 byte */
-                        }
-                    else
-                        {
-                            ASN_DEBUG("Expecting single zeroed byte");
-                            rval.code = RC_FAIL;
-                        }
-                }
-            else
-                {
-                    /* Must contain at least 8 bits. */
-                    rval.code = RC_WMORE;
-                }
-        }
-
-    return rval;
-}
-
-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;
-    asn_dec_rval_t rval;
-    asn_per_data_t pd;
-
-    if (skip_bits < 0 || skip_bits > 7 || unused_bits < 0 || unused_bits > 7 ||
-        (unused_bits > 0 && !size))
-        {
-            _ASN_DECODE_FAILED;
-        }
-
-    /*
-     * 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;
-        }
-
-    /* Fill in the position indicator */
-    memset(&pd, 0, sizeof(pd));
-    pd.buffer = (const uint8_t *)buffer;
-    pd.nboff = skip_bits;
-    pd.nbits = 8 * size - unused_bits; /* 8 is CHAR_BIT from <limits.h> */
-    if (pd.nboff > pd.nbits)
-        {
-            _ASN_DECODE_FAILED;
-        }
-
-    /*
-     * Invoke type-specific decoder.
-     */
-    if (!td->uper_decoder)
-        {
-            _ASN_DECODE_FAILED; /* PER is not compiled in */
-        }
-    rval = td->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) +
-                            pd.nboff - skip_bits;
-            ASN_DEBUG("PER decoding consumed %d, counted %d", rval.consumed,
-                pd.moved);
-            assert(rval.consumed == pd.moved);
-        }
-    else
-        {
-            /* PER codec is not a restartable */
-            rval.consumed = 0;
-        }
-    return rval;
-}

src/core/libs/supl/asn-supl/per_encoder.c

@@ -1,187 +0,0 @@
-/*
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-
-#include <asn_application.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 * /*constraints*/,
-    void *sptr, asn_app_consume_bytes_f *cb, void *app_key);
-
-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);
-}
-
-/*
- * Argument type and callback necessary for uper_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;
-}
-
-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;
-
-    key.buffer = buffer;
-    key.left = buffer_size;
-
-    if (td)
-        {
-            ASN_DEBUG("Encoding \"%s\" using UNALIGNED PER", td->name);
-        }
-
-    return uper_encode_internal(td, 0, sptr, encode_to_buffer_cb, &key);
-}
-
-typedef struct enc_dyn_arg
-{
-    void *buffer;
-    size_t length;
-    size_t allocated;
-} 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;
-}
-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;
-    enc_dyn_arg key;
-
-    memset(&key, 0, sizeof(key));
-
-    er = uper_encode_internal(td, constraints, sptr, encode_dyn_cb, &key);
-    switch (er.encoded)
-        {
-        case -1:
-            FREEMEM(key.buffer);
-            return -1;
-        case 0:
-            FREEMEM(key.buffer);
-            key.buffer = MALLOC(1);
-            if (key.buffer)
-                {
-                    *(char *)key.buffer = '\0';
-                    *buffer_r = key.buffer;
-                    return 1;
-                }
-            else
-                {
-                    return -1;
-                }
-        default:
-            *buffer_r = key.buffer;
-            ASN_DEBUG("Complete encoded in %d bits", er.encoded);
-            return ((er.encoded + 7) >> 3);
-        }
-}
-
-/*
- * Internally useful functions.
- */
-
-/* Flush partially filled buffer */
-static int uper_encode_flush_outp(asn_per_outp_t *po)
-{
-    uint8_t *buf;
-
-    if (po->nboff == 0 && po->buffer == po->tmpspace)
-        {
-            return 0;
-        }
-
-    buf = po->buffer + (po->nboff >> 3);
-    /* Make sure we account for the last, partially filled */
-    if (po->nboff & 0x07)
-        {
-            buf[0] &= 0xff << (8 - (po->nboff & 0x07));
-            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;
-}

src/core/libs/supl/asn-supl/per_opentype.c

@@ -1,450 +0,0 @@
-/*
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_internal.h>
-#include <constr_TYPE.h>
-#include <per_opentype.h>
-#include <per_support.h>
-
-typedef struct uper_ugot_key
-{
-    asn_per_data_t oldpd; /* Old per data source */
-    size_t unclaimed;
-    size_t ot_moved; /* Number of bits moved by OT processing */
-    int repeat;
-} 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 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);
-
-int asn_debug_indent;
-
-/*
- * 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);
-            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 %d + overhead (1byte?)", td->name,
-        size);
-
-    return 0;
-}
-
-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;
-    ssize_t chunk_bytes;
-    int repeat;
-    uint8_t *buf = 0;
-    size_t bufLen = 0;
-    size_t bufSize = 0;
-    asn_per_data_t spd;
-    size_t padding;
-
-    _ASN_STACK_OVERFLOW_CHECK(ctx);
-
-    ASN_DEBUG("Getting open type %s...", td->name);
-
-    do
-        {
-            chunk_bytes = uper_get_length(pd, -1, &repeat);
-            if (chunk_bytes < 0)
-                {
-                    FREEMEM(buf);
-                    _ASN_DECODE_STARVED;
-                }
-            if (bufLen + chunk_bytes > bufSize)
-                {
-                    void *ptr;
-                    bufSize = chunk_bytes + (bufSize << 2);
-                    ptr = REALLOC(buf, bufSize);
-                    if (!ptr)
-                        {
-                            FREEMEM(buf);
-                            _ASN_DECODE_FAILED;
-                        }
-                    buf = ptr;
-                }
-            if (per_get_many_bits(pd, buf + bufLen, 0, chunk_bytes << 3))
-                {
-                    FREEMEM(buf);
-                    _ASN_DECODE_STARVED;
-                }
-            bufLen += chunk_bytes;
-        }
-    while (repeat);
-
-    ASN_DEBUG("Getting open type %s encoded in %d bytes", td->name, bufLen);
-
-    memset(&spd, 0, sizeof(spd));
-    spd.buffer = buf;
-    spd.nbits = bufLen << 3;
-
-    asn_debug_indent += 4;
-    rv = td->uper_decoder(ctx, td, constraints, sptr, &spd);
-    asn_debug_indent -= 4;
-
-    if (rv.code == RC_OK)
-        {
-            /* Check padding validity */
-            padding = spd.nbits - spd.nboff;
-            if (padding < 8 && per_get_few_bits(&spd, padding) == 0)
-                {
-                    /* Everything is cool */
-                    FREEMEM(buf);
-                    return rv;
-                }
-            FREEMEM(buf);
-            if (padding >= 8)
-                {
-                    ASN_DEBUG("Too large padding %d in open type", padding);
-                    _ASN_DECODE_FAILED;
-                }
-            else
-                {
-                    ASN_DEBUG("Non-zero padding");
-                    _ASN_DECODE_FAILED;
-                }
-        }
-    else
-        {
-            FREEMEM(buf);
-            /* rv.code could be RC_WMORE, nonsense in this context */
-            rv.code = RC_FAIL; /* Noone would give us more */
-        }
-
-    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;
-    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));
-    arg.oldpd = *pd;
-    arg.unclaimed = 0;
-    arg.ot_moved = 0;
-    arg.repeat = 1;
-    pd->refill = uper_ugot_refill;
-    pd->refill_key = &arg;
-    pd->nbits = pd->nboff; /* 0 good bits at this point, will refill */
-    pd->moved = 0;         /* This now counts the open type size in bits */
-
-    asn_debug_indent += 4;
-    rv = td->uper_decoder(ctx, td, constraints, sptr, pd);
-    asn_debug_indent -= 4;
-
-#define UPDRESTOREPD                                                  \
-    do                                                                \
-        {                                                             \
-            /* buffer and nboff are valid, preserve them. */          \
-            pd->nbits = arg.oldpd.nbits - (pd->moved - arg.ot_moved); \
-            pd->moved = arg.oldpd.moved + (pd->moved - arg.ot_moved); \
-            pd->refill = arg.oldpd.refill;                            \
-            pd->refill_key = arg.oldpd.refill_key;                    \
-        }                                                             \
-    while (0)
-
-    if (rv.code != RC_OK)
-        {
-            UPDRESTOREPD;
-            return rv;
-        }
-
-    ASN_DEBUG("OpenType %s pd%s old%s unclaimed=%d, repeat=%d", td->name,
-        per_data_string(pd), per_data_string(&arg.oldpd), arg.unclaimed,
-        arg.repeat);
-
-    padding = pd->moved % 8;
-    if (padding)
-        {
-            int32_t pvalue;
-            if (padding > 7)
-                {
-                    ASN_DEBUG("Too large padding %d in open type", padding);
-                    rv.code = RC_FAIL;
-                    UPDRESTOREPD;
-                    return rv;
-                }
-            padding = 8 - padding;
-            ASN_DEBUG("Getting padding of %d bits", padding);
-            pvalue = per_get_few_bits(pd, padding);
-            switch (pvalue)
-                {
-                case -1:
-                    ASN_DEBUG("Padding skip failed");
-                    UPDRESTOREPD;
-                    _ASN_DECODE_STARVED;
-                case 0:
-                    break;
-                default:
-                    ASN_DEBUG("Non-blank padding (%d bits 0x%02x)", padding,
-                        (int)pvalue);
-                    UPDRESTOREPD;
-                    _ASN_DECODE_FAILED;
-                }
-        }
-    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));
-            if (1)
-                {
-                    UPDRESTOREPD;
-                    _ASN_DECODE_FAILED;
-                }
-            else
-                {
-                    arg.unclaimed += pd->nbits - pd->nboff;
-                }
-        }
-
-    /* Adjust pd back so it points to original data */
-    UPDRESTOREPD;
-
-    /* Skip data not consumed by the decoder */
-    if (arg.unclaimed)
-        {
-            ASN_DEBUG("Getting unclaimed %d", arg.unclaimed);
-        }
-    if (arg.unclaimed)
-        {
-            switch (per_skip_bits(pd, arg.unclaimed))
-                {
-                case -1:
-                    ASN_DEBUG("Claim of %d failed", arg.unclaimed);
-                    _ASN_DECODE_STARVED;
-                case 0:
-                    ASN_DEBUG("Got claim of %d", arg.unclaimed);
-                    break;
-                default:
-                    /* Padding must be blank */
-                    ASN_DEBUG("Non-blank unconsumed padding");
-                    _ASN_DECODE_FAILED;
-                }
-            arg.unclaimed = 0;
-        }
-
-    if (arg.repeat)
-        {
-            ASN_DEBUG("Not consumed the whole thing");
-            rv.code = RC_FAIL;
-            return rv;
-        }
-
-    return rv;
-}
-
-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);
-}
-
-int uper_open_type_skip(asn_codec_ctx_t *ctx, asn_per_data_t *pd)
-{
-    asn_TYPE_descriptor_t s_td;
-    asn_dec_rval_t rv;
-
-    s_td.name = "<unknown extension>";
-    s_td.uper_decoder = uper_sot_suck;
-
-    rv = uper_open_type_get(ctx, &s_td, 0, 0, pd);
-    if (rv.code != RC_OK)
-        {
-            return -1;
-        }
-    else
-        {
-            return 0;
-        }
-}
-
-/*
- * Internal functions.
- */
-
-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;
-
-    (void)ctx;
-    (void)td;
-    (void)constraints;
-    (void)sptr;
-
-    while (per_get_few_bits(pd, 24) >= 0)
-        {
-            ;
-        }
-
-    rv.code = RC_OK;
-    rv.consumed = pd->moved;
-
-    return rv;
-}
-
-static int uper_ugot_refill(asn_per_data_t *pd)
-{
-    uper_ugot_key *arg = pd->refill_key;
-    ssize_t next_chunk_bytes;
-    ssize_t next_chunk_bits;
-    ssize_t avail;
-
-    asn_per_data_t *oldpd = &arg->oldpd;
-
-    ASN_DEBUG("REFILLING pd->moved=%d, oldpd->moved=%d", pd->moved,
-        oldpd->moved);
-
-    /* Advance our position to where pd is */
-    oldpd->buffer = pd->buffer;
-    oldpd->nboff = pd->nboff;
-    oldpd->nbits -= pd->moved - arg->ot_moved;
-    oldpd->moved += pd->moved - arg->ot_moved;
-    arg->ot_moved = pd->moved;
-
-    if (arg->unclaimed)
-        {
-            /* Refill the container */
-            if (per_get_few_bits(oldpd, 1))
-                {
-                    return -1;
-                }
-            if (oldpd->nboff == 0)
-                {
-                    assert(0);
-                    return -1;
-                }
-            pd->buffer = oldpd->buffer;
-            pd->nboff = oldpd->nboff - 1;
-            pd->nbits = oldpd->nbits;
-            ASN_DEBUG("UNCLAIMED <- return from (pd->moved=%d)", pd->moved);
-            return 0;
-        }
-
-    if (!arg->repeat)
-        {
-            ASN_DEBUG("Want more but refill doesn't have it");
-            return -1;
-        }
-
-    next_chunk_bytes = uper_get_length(oldpd, -1, &arg->repeat);
-    ASN_DEBUG("Open type LENGTH %d bytes at off %d, repeat %d",
-        next_chunk_bytes, oldpd->moved, arg->repeat);
-    if (next_chunk_bytes < 0)
-        {
-            return -1;
-        }
-    if (next_chunk_bytes == 0)
-        {
-            pd->refill = 0;       /* No more refills, naturally */
-            assert(!arg->repeat); /* Implementation guarantee */
-        }
-    next_chunk_bits = next_chunk_bytes << 3;
-    avail = oldpd->nbits - oldpd->nboff;
-    if (avail >= next_chunk_bits)
-        {
-            pd->nbits = oldpd->nboff + next_chunk_bits;
-            arg->unclaimed = 0;
-            ASN_DEBUG("!+Parent frame %d bits, alloting %d [%d..%d] (%d)",
-                next_chunk_bits, oldpd->moved, oldpd->nboff, oldpd->nbits,
-                oldpd->nbits - oldpd->nboff);
-        }
-    else
-        {
-            pd->nbits = oldpd->nbits;
-            arg->unclaimed = next_chunk_bits - avail;
-            ASN_DEBUG("!-Parent frame %d, require %d, will claim %d", avail,
-                next_chunk_bits, arg->unclaimed);
-        }
-    pd->buffer = oldpd->buffer;
-    pd->nboff = oldpd->nboff;
-    ASN_DEBUG("Refilled pd%s old%s", per_data_string(pd),
-        per_data_string(oldpd));
-    return 0;
-}
-
-static int per_skip_bits(asn_per_data_t *pd, int skip_nbits)
-{
-    int hasNonZeroBits = 0;
-    while (skip_nbits > 0)
-        {
-            int skip = 0;
-            if (skip_nbits < skip)
-                {
-                    skip = skip_nbits;
-                }
-            else
-                {
-                    skip = 24;
-                }
-            skip_nbits -= skip;
-
-            switch (per_get_few_bits(pd, skip))
-                {
-                case -1:
-                    return -1; /* Starving */
-                case 0:
-                    continue; /* Skipped empty space */
-                default:
-                    hasNonZeroBits = 1;
-                    continue;
-                }
-        }
-    return hasNonZeroBits;
-}

src/core/libs/supl/asn-supl/per_opentype.h

@@ -1,28 +0,0 @@
-/*
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#ifndef _PER_OPENTYPE_H
-#define _PER_OPENTYPE_H
-
-#ifdef __cplusplus
-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);
-
-    int uper_open_type_skip(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);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _PER_OPENTYPE_H_ */

src/core/libs/supl/asn-supl/per_support.c

@@ -1,652 +0,0 @@
-/*
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_internal.h>
-#include <asn_system.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;
-            int32_t vhead;
-            if (!pd->refill || nbits > 31)
-                {
-                    return -1;
-                }
-            /* Accumulate unused bytes before refill */
-            ASN_DEBUG("Obtain the rest %d bits (want %d)", (int)nleft, 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 */
-            uint32_t two_twentyfour = 16777216;
-            accum = per_get_few_bits(&tpd, nbits - 24) * two_twentyfour;
-            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]",
-        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;
-}
-
-/*
- * X.691-201508 #10.9 General rules for encoding a length determinant.
- * Get the optionally constrained length "n" from the stream.
- */
-ssize_t uper_get_length(asn_per_data_t *pd, int ebits, int *repeat)
-{
-    ssize_t value;
-
-    *repeat = 0;
-
-    /* #11.9.4.1 Encoding if constrained (according to effective bits) */
-    if (ebits >= 0 && ebits <= 16)
-        {
-            return per_get_few_bits(pd, ebits);
-        }
-
-    value = per_get_few_bits(pd, 8);
-    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)
-        {
-            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);
-}
-
-/*
- * Get the normally small length "n".
- * This procedure used to decode length of extensions bit-maps
- * for SET and SEQUENCE types.
- */
-ssize_t uper_get_nslength(asn_per_data_t *pd)
-{
-    ssize_t length;
-
-    ASN_DEBUG("Getting normally small length");
-
-    if (per_get_few_bits(pd, 1) == 0)
-        {
-            length = per_get_few_bits(pd, 6) + 1;
-            if (length <= 0)
-                {
-                    return -1;
-                }
-            ASN_DEBUG("l=%d", (int)length);
-            return length;
-        }
-    else
-        {
-            int repeat;
-            length = uper_get_length(pd, -1, &repeat);
-            if (length >= 0 && !repeat)
-                {
-                    return length;
-                }
-            return -1; /* Error, or do not support >16K extensions */
-        }
-}
-
-/*
- * Get the normally small non-negative whole number.
- * X.691, #10.6
- */
-ssize_t uper_get_nsnnwn(asn_per_data_t *pd)
-{
-    ssize_t value;
-
-    value = per_get_few_bits(pd, 7);
-    if (value & 64)
-        { /* implicit (value < 0) */
-            value &= 63;
-            value <<= 2;
-            value |= per_get_few_bits(pd, 2);
-            if (value & 128)
-                { /* implicit (value < 0) */
-                    return -1;
-                }
-            if (value == 0)
-                {
-                    return 0;
-                }
-            if (value >= 3)
-                {
-                    return -1;
-                }
-            value = per_get_few_bits(pd, 8 * value);
-            return value;
-        }
-
-    return value;
-}
-
-/*
- * X.691-11/2008, #11.6
- * Encoding of a normally small non-negative whole number
- */
-int uper_put_nsnnwn(asn_per_outp_t *po, int n)
-{
-    int bytes;
-
-    if (n <= 63)
-        {
-            if (n < 0)
-                {
-                    return -1;
-                }
-            return per_put_few_bits(po, n, 7);
-        }
-    if (n < 256)
-        {
-            bytes = 1;
-        }
-    else if (n < 65536)
-        {
-            bytes = 2;
-        }
-    else if (n < 256 * 65536)
-        {
-            bytes = 3;
-        }
-    else
-        {
-            return -1; /* This is not a "normally small" value */
-        }
-    if (per_put_few_bits(po, bytes, 8))
-        {
-            return -1;
-        }
-
-    return per_put_few_bits(po, n, 8 * bytes);
-}
-
-/* X.691-2008/11, #11.5.6 -> #11.3 */
-int uper_get_constrained_whole_number(asn_per_data_t *pd,
-    unsigned long *out_value, int nbits)
-{
-    unsigned long lhalf; /* Lower half of the number*/
-    long half;
-
-    if (nbits <= 31)
-        {
-            half = per_get_few_bits(pd, nbits);
-            if (half < 0)
-                {
-                    return -1;
-                }
-            *out_value = half;
-            return 0;
-        }
-
-    if ((size_t)nbits > 8 * sizeof(*out_value))
-        {
-            return -1; /* RANGE */
-        }
-
-    half = per_get_few_bits(pd, 31);
-    if (half < 0)
-        {
-            return -1;
-        }
-
-    if (uper_get_constrained_whole_number(pd, &lhalf, nbits - 31))
-        {
-            return -1;
-        }
-
-    *out_value = ((unsigned long)half << (nbits - 31)) | lhalf;
-    return 0;
-}
-
-/* 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);
-        }
-}
-
-int per_put_aligned_flush(asn_per_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] &= ~0 << unused_bits;
-        }
-
-    if (po->outper(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;
-        }
-}
-
-/*
- * Put a small number of bits (<= 31).
- */
-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)
-        {
-            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->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
-        {
-            if ((obits - 24) > 0)
-                {
-                    if (per_put_few_bits(po, bits >> (obits - 24), 24))
-                        {
-                            return -1;
-                        }
-                }
-            if (per_put_few_bits(po, bits, obits - 24))
-                {
-                    return -1;
-                }
-        }
-
-    ASN_DEBUG("[PER out %u/%x => %02x buf+%ld]", (int)bits, (int)bits, buf[0],
-        (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;
-}
-
-/*
- * 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;
-        }
-
-    return per_put_few_bits(po, 0xC0 | length, 8) ? -1
-                                                  : (ssize_t)(length << 14);
-}
-
-/*
- * Put the normally small length "n" into the stream.
- * This procedure used to encode length of extensions bit-maps
- * for SET and SEQUENCE types.
- */
-int uper_put_nslength(asn_per_outp_t *po, size_t length)
-{
-    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;
-                }
-        }
-
-    return 0;
-}

src/core/libs/supl/asn-supl/xer_decoder.c

@@ -1,436 +0,0 @@
-/*
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_application.h>
-#include <asn_internal.h>
-#include <xer_support.h> /* XER/XML parsing support */
-
-/*
- * 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;
-
-    /*
-     * 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 td->xer_decoder(opt_codec_ctx, td, struct_ptr, 0, buffer, size);
-}
-
-struct xer__cb_arg
-{
-    pxml_chunk_type_e chunk_type;
-    size_t chunk_size;
-    const void *chunk_buf;
-    int callback_not_invoked;
-};
-
-static int xer__token_cb(pxml_chunk_type_e type, const void *_chunk_data,
-    size_t _chunk_size, void *key)
-{
-    struct xer__cb_arg *arg = (struct xer__cb_arg *)key;
-    arg->chunk_type = type;
-    arg->chunk_size = _chunk_size;
-    arg->chunk_buf = _chunk_data;
-    arg->callback_not_invoked = 0;
-    return -1; /* Terminate the XML parsing */
-}
-
-/*
- * Fetch the next token from the XER/XML stream.
- */
-ssize_t xer_next_token(int *stateContext, const void *buffer, size_t size,
-    pxer_chunk_type_e *ch_type)
-{
-    struct xer__cb_arg arg;
-    int new_stateContext = *stateContext;
-    ssize_t ret;
-
-    arg.callback_not_invoked = 1;
-    ret = pxml_parse(&new_stateContext, buffer, size, xer__token_cb, &arg);
-    if (ret < 0)
-        {
-            return -1;
-        }
-    if (arg.callback_not_invoked)
-        {
-            assert(ret == 0); /* No data was consumed */
-            return 0;         /* Try again with more data */
-        }
-    else
-        {
-            assert(arg.chunk_size);
-            assert(arg.chunk_buf == buffer);
-        }
-
-    /*
-     * Translate the XML chunk types into more convenient ones.
-     */
-    switch (arg.chunk_type)
-        {
-        case PXML_TEXT:
-            *ch_type = PXER_TEXT;
-            break;
-        case PXML_TAG:
-            return 0; /* Want more */
-        case PXML_TAG_END:
-            *ch_type = PXER_TAG;
-            break;
-        case PXML_COMMENT:
-        case PXML_COMMENT_END:
-            *ch_type = PXER_COMMENT;
-            break;
-        }
-
-    *stateContext = new_stateContext;
-    return arg.chunk_size;
-}
-
-#define CSLASH 0x2f /* '/' */
-#define LANGLE 0x3c /* '<' */
-#define RANGLE 0x3e /* '>' */
-
-xer_check_tag_e xer_check_tag(const void *buf_ptr, int size,
-    const char *need_tag)
-{
-    const char *buf = (const char *)buf_ptr;
-    const char *end;
-    xer_check_tag_e ct = XCT_OPENING;
-
-    if (size < 2 || buf[0] != LANGLE || buf[size - 1] != RANGLE)
-        {
-            if (size >= 2)
-                {
-                    ASN_DEBUG("Broken XML tag: \"%c...%c\"", buf[0], buf[size - 1]);
-                }
-            return XCT_BROKEN;
-        }
-
-    /*
-     * Determine the tag class.
-     */
-    if (buf[1] == CSLASH)
-        {
-            buf += 2;  /* advance past "</" */
-            size -= 3; /* strip "</" and ">" */
-            ct = XCT_CLOSING;
-            if (size > 0 && buf[size - 1] == CSLASH)
-                {
-                    return XCT_BROKEN; /* </abc/> */
-                }
-        }
-    else
-        {
-            buf++;     /* advance past "<" */
-            size -= 2; /* strip "<" and ">" */
-            if (size > 0 && buf[size - 1] == CSLASH)
-                {
-                    ct = XCT_BOTH;
-                    size--; /* One more, for "/" */
-                }
-        }
-
-    /* Sometimes we don't care about the tag */
-    if (!need_tag || !*need_tag)
-        {
-            return (xer_check_tag_e)(XCT__UNK__MASK | ct);
-        }
-
-    /*
-     * Determine the tag name.
-     */
-    for (end = buf + size; buf < end; buf++, need_tag++)
-        {
-            int b = *buf;
-            int n = *need_tag;
-            if (b != n)
-                {
-                    if (n == 0)
-                        {
-                            switch (b)
-                                {
-                                case 0x09:
-                                case 0x0a:
-                                case 0x0c:
-                                case 0x0d:
-                                case 0x20:
-                                    /* "<abc def/>": whitespace is normal */
-                                    return ct;
-                                }
-                        }
-                    return (xer_check_tag_e)(XCT__UNK__MASK | ct);
-                }
-            if (b == 0)
-                {
-                    return XCT_BROKEN; /* Embedded 0 in buf?! */
-                }
-        }
-    if (*need_tag)
-        {
-            return (xer_check_tag_e)(XCT__UNK__MASK | ct);
-        }
-
-    return ct;
-}
-
-#undef ADVANCE
-#define ADVANCE(num_bytes)                           \
-    do                                               \
-        {                                            \
-            size_t num = (num_bytes);                \
-            buf_ptr = ((const char *)buf_ptr) + num; \
-            size -= num;                             \
-            consumed_myself += num;                  \
-        }                                            \
-    while (0)
-
-#undef RETURN
-#define RETURN(_code)                                                       \
-    do                                                                      \
-        {                                                                   \
-            rval.code = _code;                                              \
-            rval.consumed = consumed_myself;                                \
-            if (rval.code != RC_OK) ASN_DEBUG("Failed with %d", rval.code); \
-            return rval;                                                    \
-        }                                                                   \
-    while (0)
-
-#define XER_GOT_BODY(chunk_buf, chunk_size, size)                      \
-    do                                                                 \
-        {                                                              \
-            ssize_t converted_size =                                   \
-                body_receiver(struct_key, chunk_buf, chunk_size,       \
-                    (size_t)(chunk_size) < (size));                    \
-            if (converted_size == -1) RETURN(RC_FAIL);                 \
-            if (converted_size == 0 && (size) == (size_t)(chunk_size)) \
-                RETURN(RC_WMORE);                                      \
-            (chunk_size) = converted_size;                             \
-        }                                                              \
-    while (0)
-#define XER_GOT_EMPTY()                                          \
-    do                                                           \
-        {                                                        \
-            if (body_receiver(struct_key, 0, 0, size > 0) == -1) \
-                RETURN(RC_FAIL);                                 \
-        }                                                        \
-    while (0)
-
-/*
- * Generalized function for decoding the primitive values.
- */
-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, const char *xml_tag, /* Expected XML tag */
-    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 rval;
-    ssize_t consumed_myself = 0;
-
-    (void)opt_codec_ctx;
-
-    /*
-     * Phases of XER/XML processing:
-     * Phase 0: Check that the opening tag matches our expectations.
-     * Phase 1: Processing body and reacting on closing tag.
-     */
-    if (ctx->phase > 1)
-        {
-            RETURN(RC_FAIL);
-        }
-    for (;;)
-        {
-            pxer_chunk_type_e ch_type; /* XER chunk type */
-            ssize_t ch_size;           /* Chunk size */
-            xer_check_tag_e tcv;       /* Tag check value */
-
-            /*
-             * Get the next part of the XML stream.
-             */
-            ch_size = xer_next_token(&ctx->context, buf_ptr, size, &ch_type);
-            switch (ch_size)
-                {
-                case -1:
-                    RETURN(RC_FAIL);
-                case 0:
-                    RETURN(RC_WMORE);
-                default:
-                    switch (ch_type)
-                        {
-                        case PXER_COMMENT:    /* Got XML comment */
-                            ADVANCE(ch_size); /* Skip silently */
-                            continue;
-                        case PXER_TEXT:
-                            if (ctx->phase == 0)
-                                {
-                                    /*
-                                     * We have to ignore whitespace
-                                     * here, but in order to be forward
-                                     * compatible with EXTENDED-XER
-                                     * (EMBED-VALUES, #25) any text is
-                                     * just ignored here.
-                                     */
-                                }
-                            else
-                                {
-                                    XER_GOT_BODY(buf_ptr, ch_size,
-                                        size);
-                                }
-                            ADVANCE(ch_size);
-                            continue;
-                        case PXER_TAG:
-                            break; /* Check the rest down there */
-                        }
-                }
-
-            assert(ch_type == PXER_TAG && size);
-
-            tcv = xer_check_tag(buf_ptr, ch_size, xml_tag);
-            /*
-             * Phase 0:
-             *     Expecting the opening tag
-             *     for the type being processed.
-             * Phase 1:
-             *     Waiting for the closing XML tag.
-             */
-            switch (tcv)
-                {
-                case XCT_BOTH:
-                    if (ctx->phase)
-                        {
-                            break;
-                        }
-                    /* Finished decoding of an empty element */
-                    XER_GOT_EMPTY();
-                    ADVANCE(ch_size);
-                    ctx->phase = 2; /* Phase out */
-                    RETURN(RC_OK);
-                case XCT_OPENING:
-                    if (ctx->phase)
-                        {
-                            break;
-                        }
-                    ADVANCE(ch_size);
-                    ctx->phase = 1; /* Processing body phase */
-                    continue;
-                case XCT_CLOSING:
-                    if (!ctx->phase)
-                        {
-                            break;
-                        }
-                    ADVANCE(ch_size);
-                    ctx->phase = 2; /* Phase out */
-                    RETURN(RC_OK);
-                case XCT_UNKNOWN_BO:
-                    /*
-                     * Certain tags in the body may be expected.
-                     */
-                    if (opt_unexpected_tag_decoder &&
-                        opt_unexpected_tag_decoder(struct_key, buf_ptr,
-                            ch_size) >= 0)
-                        {
-                            /* Tag's processed fine */
-                            ADVANCE(ch_size);
-                            if (!ctx->phase)
-                                {
-                                    /* We are not expecting
-                                     * the closing tag anymore. */
-                                    ctx->phase = 2; /* Phase out */
-                                    RETURN(RC_OK);
-                                }
-                            continue;
-                        }
-                    /* Fall through */
-                default:
-                    break; /* Unexpected tag */
-                }
-
-            ASN_DEBUG("Unexpected XML tag (expected \"%s\")", xml_tag);
-            break; /* Dark and mysterious things have just happened */
-        }
-
-    RETURN(RC_FAIL);
-}
-
-int xer_is_whitespace(const void *chunk_buf, size_t chunk_size)
-{
-    const char *p = (const char *)chunk_buf;
-    const char *pend = p + chunk_size;
-
-    for (; p < pend; p++)
-        {
-            switch (*p)
-                {
-                /* X.693, #8.1.4
-                 * HORISONTAL TAB (9)
-                 * LINE FEED (10)
-                 * CARRIAGE RETURN (13)
-                 * SPACE (32)
-                 */
-                case 0x09:
-                case 0x0a:
-                case 0x0d:
-                case 0x20:
-                    break;
-                default:
-                    return 0;
-                }
-        }
-    return 1; /* All whitespace */
-}
-
-/*
- * This is a vastly simplified, non-validating XML tree skipper.
- */
-int xer_skip_unknown(xer_check_tag_e tcv, ber_tlv_len_t *depth)
-{
-    assert(*depth > 0);
-    switch (tcv)
-        {
-        case XCT_BOTH:
-        case XCT_UNKNOWN_BO:
-            /* These negate each other. */
-            return 0;
-        case XCT_OPENING:
-        case XCT_UNKNOWN_OP:
-            ++(*depth);
-            return 0;
-        case XCT_CLOSING:
-        case XCT_UNKNOWN_CL:
-            if (--(*depth) == 0)
-                {
-                    return (tcv == XCT_CLOSING) ? 2 : 1;
-                }
-            return 0;
-        default:
-            return -1;
-        }
-}

src/core/libs/supl/asn-supl/xer_encoder.c

@@ -1,83 +0,0 @@
-/*-
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_internal.h>
-#include <errno.h>
-#include <stdio.h>
-
-/*
- * 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;
-    asn_enc_rval_t tmper;
-    const char *mname;
-    size_t mlen;
-    int xcan = (xer_flags & XER_F_CANONICAL) ? 1 : 2;
-
-    if (!td || !sptr)
-        {
-            goto cb_failed;
-        }
-
-    mname = td->xml_tag;
-    mlen = strlen(mname);
-
-    _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
-
-    tmper = td->xer_encoder(td, sptr, 1, xer_flags, cb, app_key);
-    if (tmper.encoded == -1)
-        {
-            return tmper;
-        }
-
-    _ASN_CALLBACK3("</", 2, mname, mlen, ">\n", xcan);
-
-    er.encoded = 4 + xcan + (2 * mlen) + tmper.encoded;
-
-    _ASN_ENCODED_OK(er);
-cb_failed:
-    _ASN_ENCODE_FAILED;
-}
-
-/*
- * This is a helper function for xer_fprint, which directs all incoming data
- * into the provided file descriptor.
- */
-static int xer__print2fp(const void *buffer, size_t size, void *app_key)
-{
-    FILE *stream = (FILE *)app_key;
-
-    if (fwrite(buffer, 1, size, stream) != size)
-        {
-            return -1;
-        }
-
-    return 0;
-}
-
-int xer_fprint(FILE *stream, asn_TYPE_descriptor_t *td, void *sptr)
-{
-    asn_enc_rval_t er;
-
-    if (!stream)
-        {
-            stream = stdout;
-        }
-    if (!td || !sptr)
-        {
-            return -1;
-        }
-
-    er = xer_encode(td, sptr, XER_F_BASIC, xer__print2fp, stream);
-    if (er.encoded == -1)
-        {
-            return -1;
-        }
-
-    return fflush(stream);
-}

src/core/libs/supl/asn-supl/xer_support.c

@@ -1,274 +0,0 @@
-/*
- * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
- * SPDX-License-Identifier: BSD-1-Clause
- */
-#include <asn_system.h>
-#include <xer_support.h>
-
-/* Parser states */
-typedef enum
-{
-    ST_TEXT,
-    ST_TAG_START,
-    ST_TAG_BODY,
-    ST_TAG_QUOTE_WAIT,
-    ST_TAG_QUOTED_STRING,
-    ST_TAG_UNQUOTED_STRING,
-    ST_COMMENT_WAIT_DASH1, /* "<!--"[1] */
-    ST_COMMENT_WAIT_DASH2, /* "<!--"[2] */
-    ST_COMMENT,
-    ST_COMMENT_CLO_DASH2, /* "-->"[0] */
-    ST_COMMENT_CLO_RT     /* "-->"[1] */
-} pstate_e;
-
-static pxml_chunk_type_e final_chunk_type[] = {
-    PXML_TEXT,
-    PXML_TAG_END,
-    PXML_COMMENT_END,
-    PXML_TAG_END,
-    PXML_COMMENT_END,
-};
-
-static int _charclass[256] = {
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, /* 01234567 89
-                                                                 */
-    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,             /*  ABCDEFG HIJKLMNO */
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0,             /* PQRSTUVW XYZ      */
-    0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,             /*  abcdefg hijklmno */
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0              /* pqrstuvw xyz      */
-};
-#define WHITESPACE(c) (_charclass[(unsigned char)(c)] == 1)
-#define ALNUM(c) (_charclass[(unsigned char)(c)] >= 2)
-#define ALPHA(c) (_charclass[(unsigned char)(c)] == 3)
-
-/* Aliases for characters, ASCII/UTF-8 */
-// clang-format off
-#define EXCLAM 0x21 /* '!' */
-#define CQUOTE 0x22 /* '"' */
-#define CDASH 0x2d  /* '-' */
-#define CSLASH 0x2f /* '/' */
-#define LANGLE 0x3c /* '<' */
-#define CEQUAL 0x3d /* '=' */
-#define RANGLE 0x3e /* '>' */
-#define CQUEST 0x3f /* '?' */
-// clang-format on
-
-/* Invoke token callback */
-#define TOKEN_CB_CALL(type, _ns, _current_too, _final)            \
-    do                                                            \
-        {                                                         \
-            int _ret;                                             \
-            pstate_e ns = _ns;                                    \
-            ssize_t _sz = (p - chunk_start) + (_current_too);     \
-            if (!_sz)                                             \
-                {                                                 \
-                    /* Shortcut */                                \
-                    state = _ns;                                  \
-                    break;                                        \
-                }                                                 \
-            _ret = cb(type, chunk_start, _sz, key);               \
-            if (_ret < _sz)                                       \
-                {                                                 \
-                    if ((_current_too) && _ret == -1) state = ns; \
-                    goto finish;                                  \
-                }                                                 \
-            chunk_start = p + (_current_too);                     \
-            state = ns;                                           \
-        }                                                         \
-    while (0)
-
-#define TOKEN_CB(_type, _ns, _current_too) \
-    TOKEN_CB_CALL(_type, _ns, _current_too, 0)
-
-#define TOKEN_CB_FINAL(_type, _ns, _current_too) \
-    TOKEN_CB_CALL(final_chunk_type[_type], _ns, _current_too, 1)
-
-/*
- * Parser itself
- */
-ssize_t pxml_parse(int *stateContext, const void *xmlbuf, size_t size,
-    pxml_callback_f *cb, void *key)
-{
-    pstate_e state = (pstate_e)*stateContext;
-    const char *chunk_start = (const char *)xmlbuf;
-    const char *p = chunk_start;
-    const char *end = p + size;
-
-    for (; p < end; p++)
-        {
-            int C = *(const unsigned char *)p;
-            switch (state)
-                {
-                case ST_TEXT:
-                    /*
-                     * Initial state: we're in the middle of some text,
-                     * or just have started.
-                     */
-                    if (C == LANGLE)
-                        { /* We're now in the tag, probably */
-                            TOKEN_CB(PXML_TEXT, ST_TAG_START, 0);
-                        }
-                    break;
-                case ST_TAG_START:
-                    if (ALPHA(C) || (C == CSLASH))
-                        {
-                            state = ST_TAG_BODY;
-                        }
-                    else if (C == EXCLAM)
-                        {
-                            state = ST_COMMENT_WAIT_DASH1;
-                        }
-                    else
-                        {
-                            /*
-                             * Not characters and not whitespace.
-                             * Must be something like "3 < 4".
-                             */
-                            TOKEN_CB(PXML_TEXT, ST_TEXT, 1); /* Flush as data */
-                        }
-                    break;
-                case ST_TAG_BODY:
-                    switch (C)
-                        {
-                        case RANGLE:
-                            /* End of the tag */
-                            TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1);
-                            break;
-                        case LANGLE:
-                            /*
-                             * The previous tag wasn't completed, but
-                             * still recognized as valid.
-                             * (Mozilla-compatible)
-                             */
-                            TOKEN_CB_FINAL(PXML_TAG, ST_TAG_START, 0);
-                            break;
-                        case CEQUAL:
-                            state = ST_TAG_QUOTE_WAIT;
-                            break;
-                        }
-                    break;
-                case ST_TAG_QUOTE_WAIT:
-                    /*
-                     * State after the equal sign ("=") in the tag.
-                     */
-                    switch (C)
-                        {
-                        case CQUOTE:
-                            state = ST_TAG_QUOTED_STRING;
-                            break;
-                        case RANGLE:
-                            /* End of the tag */
-                            TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1);
-                            break;
-                        default:
-                            if (!WHITESPACE(
-                                    C))
-                                { /* Unquoted string value */
-                                    state = ST_TAG_UNQUOTED_STRING;
-                                }
-                        }
-                    break;
-                case ST_TAG_QUOTED_STRING:
-                    /*
-                     * Tag attribute's string value in quotes.
-                     */
-                    if (C == CQUOTE)
-                        {
-                            /* Return back to the tag state */
-                            state = ST_TAG_BODY;
-                        }
-                    break;
-                case ST_TAG_UNQUOTED_STRING:
-                    if (C == RANGLE)
-                        {
-                            /* End of the tag */
-                            TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1);
-                        }
-                    else if (WHITESPACE(C))
-                        {
-                            /* Return back to the tag state */
-                            state = ST_TAG_BODY;
-                        }
-                    break;
-                case ST_COMMENT_WAIT_DASH1:
-                    if (C == CDASH)
-                        {
-                            state = ST_COMMENT_WAIT_DASH2;
-                        }
-                    else
-                        {
-                            /* Some ordinary tag. */
-                            state = ST_TAG_BODY;
-                        }
-                    break;
-                case ST_COMMENT_WAIT_DASH2:
-                    if (C == CDASH)
-                        {
-                            /* Seen "<--" */
-                            state = ST_COMMENT;
-                        }
-                    else
-                        {
-                            /* Some ordinary tag */
-                            state = ST_TAG_BODY;
-                        }
-                    break;
-                case ST_COMMENT:
-                    if (C == CDASH)
-                        {
-                            state = ST_COMMENT_CLO_DASH2;
-                        }
-                    break;
-                case ST_COMMENT_CLO_DASH2:
-                    if (C == CDASH)
-                        {
-                            state = ST_COMMENT_CLO_RT;
-                        }
-                    else
-                        {
-                            /* This is not an end of a comment */
-                            state = ST_COMMENT;
-                        }
-                    break;
-                case ST_COMMENT_CLO_RT:
-                    if (C == RANGLE)
-                        {
-                            TOKEN_CB_FINAL(PXML_COMMENT, ST_TEXT, 1);
-                        }
-                    else if (C == CDASH)
-                        {
-                            /* Maintain current state, still waiting for '>'
-                             */
-                        }
-                    else
-                        {
-                            state = ST_COMMENT;
-                        }
-                    break;
-                } /* switch(*ptr) */
-        }         /* for() */
-
-    /*
-     * Flush the partially processed chunk, state permitting.
-     */
-    if (p - chunk_start)
-        {
-            switch (state)
-                {
-                case ST_COMMENT:
-                    TOKEN_CB(PXML_COMMENT, state, 0);
-                    break;
-                case ST_TEXT:
-                    TOKEN_CB(PXML_TEXT, state, 0);
-                    break;
-                default:
-                    break; /* a no-op */
-                }
-        }
-
-finish:
-    *stateContext = (int)state;
-    return chunk_start - (const char *)xmlbuf;
-}