mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-12-14 20:20:35 +00:00
Code Issues Releases Wiki Activity

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

Browse Source
This commit is contained in:
Carles Fernandez 2022-04-27 00:08:24 +02:00
commit 2b30b95a8f
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
117 changed files with 9 additions and 15586 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/core/libs/supl/CMakeLists.txt
View File

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

1265
src/core/libs/supl/asn-rrlp/INTEGER.c
View File

File diff suppressed because it is too large Load Diff

74
src/core/libs/supl/asn-rrlp/INTEGER.h
View File

@ -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_ */

377
src/core/libs/supl/asn-rrlp/NativeInteger.c
View File

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

90
src/core/libs/supl/asn-rrlp/OCTET_STRING.h
View File

@ -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_ */

54
src/core/libs/supl/asn-rrlp/asn_codecs_prim.h
View File

@ -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 */

65
src/core/libs/supl/asn-rrlp/ber_decoder.h
View File

@ -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_ */

63
src/core/libs/supl/asn-rrlp/ber_tlv_tag.h
View File

@ -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_ */

1783
src/core/libs/supl/asn-rrlp/constr_SEQUENCE.c
View File

File diff suppressed because it is too large Load Diff

108
src/core/libs/supl/asn-rrlp/constraints.c
View File

@ -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;
}

67
src/core/libs/supl/asn-rrlp/der_encoder.h
View File

@ -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_ */

59
src/core/libs/supl/asn-rrlp/per_decoder.h
View File

@ -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_ */

69
src/core/libs/supl/asn-rrlp/per_encoder.h
View File

@ -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_ */

150
src/core/libs/supl/asn-rrlp/per_support.h
View File

@ -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_ */

109
src/core/libs/supl/asn-rrlp/xer_decoder.h
View File

@ -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_ */

62
src/core/libs/supl/asn-rrlp/xer_encoder.h
View File

@ -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_ */

58
src/core/libs/supl/asn-rrlp/xer_support.h
View File

@ -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_ */

207
src/core/libs/supl/asn-supl/BIT_STRING.c
View File

@ -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;
}

35
src/core/libs/supl/asn-supl/BIT_STRING.h
View File

@ -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_ */

330
src/core/libs/supl/asn-supl/BOOLEAN.c
View File

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

37
src/core/libs/supl/asn-supl/BOOLEAN.h
View File

@ -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_ */

82
src/core/libs/supl/asn-supl/ENUMERATED.c
View File

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

26
src/core/libs/supl/asn-supl/ENUMERATED.h
View File

@ -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_ */

302
src/core/libs/supl/asn-supl/NativeEnumerated.c
View File

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

32
src/core/libs/supl/asn-supl/NativeEnumerated.h
View File

@ -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_ */

38
src/core/libs/supl/asn-supl/NativeInteger.h
View File

@ -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_ */

2308
src/core/libs/supl/asn-supl/OCTET_STRING.c
View File

File diff suppressed because it is too large Load Diff

51
src/core/libs/supl/asn-supl/asn_SEQUENCE_OF.c
View File

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

52
src/core/libs/supl/asn-supl/asn_SEQUENCE_OF.h
View File

@ -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 */

105
src/core/libs/supl/asn-supl/asn_SET_OF.c
View File

@ -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;
}
}

63
src/core/libs/supl/asn-supl/asn_SET_OF.h
View File

@ -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 */

51
src/core/libs/supl/asn-supl/asn_application.h
View File

@ -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_ */

127
src/core/libs/supl/asn-supl/asn_codecs.h
View File

@ -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_ */

327
src/core/libs/supl/asn-supl/asn_codecs_prim.c
View File

@ -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;
}

133
src/core/libs/supl/asn-supl/asn_internal.h
View File

@ -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_ */

133
src/core/libs/supl/asn-supl/asn_system.h
View File

@ -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_ */

337
src/core/libs/supl/asn-supl/ber_decoder.c
View File

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

214
src/core/libs/supl/asn-supl/ber_tlv_length.c
View File

@ -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;
}

52
src/core/libs/supl/asn-supl/ber_tlv_length.h
View File

@ -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_ */

176
src/core/libs/supl/asn-supl/ber_tlv_tag.c
View File

@ -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;
}

1419
src/core/libs/supl/asn-supl/constr_CHOICE.c
View File

File diff suppressed because it is too large Load Diff

58
src/core/libs/supl/asn-supl/constr_CHOICE.h
View File

@ -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_ */

61
src/core/libs/supl/asn-supl/constr_SEQUENCE.h
View File

@ -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_ */

288
src/core/libs/supl/asn-supl/constr_SEQUENCE_OF.c
View File

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

34
src/core/libs/supl/asn-supl/constr_SEQUENCE_OF.h
View File

@ -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_ */

1205
src/core/libs/supl/asn-supl/constr_SET_OF.c
View File

File diff suppressed because it is too large Load Diff

44
src/core/libs/supl/asn-supl/constr_SET_OF.h
View File

@ -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_ */

91
src/core/libs/supl/asn-supl/constr_TYPE.c
View File

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

184
src/core/libs/supl/asn-supl/constr_TYPE.h
View File

@ -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_ */

63
src/core/libs/supl/asn-supl/constraints.h
View File

@ -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_ */

234
src/core/libs/supl/asn-supl/der_encoder.c
View File

@ -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;
}

123
src/core/libs/supl/asn-supl/per_decoder.c
View File

@ -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;
}

187
src/core/libs/supl/asn-supl/per_encoder.c
View File

@ -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;
}

450
src/core/libs/supl/asn-supl/per_opentype.c
View File

@ -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;
}

28
src/core/libs/supl/asn-supl/per_opentype.h
View File

@ -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_ */

652
src/core/libs/supl/asn-supl/per_support.c
View File

@ -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;
}

436
src/core/libs/supl/asn-supl/xer_decoder.c
View File

@ -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;
}
}

83
src/core/libs/supl/asn-supl/xer_encoder.c
View File

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

274
src/core/libs/supl/asn-supl/xer_support.c
View File

@ -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;
}

0
src/core/libs/supl/asn-rrlp/BIT_STRING.c → src/core/libs/supl/types/BIT_STRING.c
View File

0
src/core/libs/supl/asn-rrlp/BIT_STRING.h → src/core/libs/supl/types/BIT_STRING.h
View File

0
src/core/libs/supl/asn-rrlp/BOOLEAN.c → src/core/libs/supl/types/BOOLEAN.c
View File

0
src/core/libs/supl/asn-rrlp/BOOLEAN.h → src/core/libs/supl/types/BOOLEAN.h
View File

0
src/core/libs/supl/asn-rrlp/ENUMERATED.c → src/core/libs/supl/types/ENUMERATED.c
View File

0
src/core/libs/supl/asn-rrlp/ENUMERATED.h → src/core/libs/supl/types/ENUMERATED.h
View File

0
src/core/libs/supl/asn-supl/INTEGER.c → src/core/libs/supl/types/INTEGER.c
View File

0
src/core/libs/supl/asn-supl/INTEGER.h → src/core/libs/supl/types/INTEGER.h
View File

0
src/core/libs/supl/asn-rrlp/NativeEnumerated.c → src/core/libs/supl/types/NativeEnumerated.c
View File

0
src/core/libs/supl/asn-rrlp/NativeEnumerated.h → src/core/libs/supl/types/NativeEnumerated.h
View File

0
src/core/libs/supl/asn-supl/NativeInteger.c → src/core/libs/supl/types/NativeInteger.c
View File

0
src/core/libs/supl/asn-rrlp/NativeInteger.h → src/core/libs/supl/types/NativeInteger.h
View File

0
src/core/libs/supl/asn-rrlp/OCTET_STRING.c → src/core/libs/supl/types/OCTET_STRING.c
View File

0
src/core/libs/supl/asn-supl/OCTET_STRING.h → src/core/libs/supl/types/OCTET_STRING.h
View File

0
src/core/libs/supl/asn-rrlp/asn_SEQUENCE_OF.c → src/core/libs/supl/types/asn_SEQUENCE_OF.c
View File

0
src/core/libs/supl/asn-rrlp/asn_SEQUENCE_OF.h → src/core/libs/supl/types/asn_SEQUENCE_OF.h
View File

0
src/core/libs/supl/asn-rrlp/asn_SET_OF.c → src/core/libs/supl/types/asn_SET_OF.c
View File

0
src/core/libs/supl/asn-rrlp/asn_SET_OF.h → src/core/libs/supl/types/asn_SET_OF.h
View File

0
src/core/libs/supl/asn-rrlp/asn_application.h → src/core/libs/supl/types/asn_application.h
View File

0
src/core/libs/supl/asn-rrlp/asn_codecs.h → src/core/libs/supl/types/asn_codecs.h
View File

0
src/core/libs/supl/asn-rrlp/asn_codecs_prim.c → src/core/libs/supl/types/asn_codecs_prim.c
View File

0
src/core/libs/supl/asn-supl/asn_codecs_prim.h → src/core/libs/supl/types/asn_codecs_prim.h
View File

0
src/core/libs/supl/asn-rrlp/asn_internal.h → src/core/libs/supl/types/asn_internal.h
View File

0
src/core/libs/supl/asn-rrlp/asn_system.h → src/core/libs/supl/types/asn_system.h
View File

0
src/core/libs/supl/asn-rrlp/ber_decoder.c → src/core/libs/supl/types/ber_decoder.c
View File

0
src/core/libs/supl/asn-supl/ber_decoder.h → src/core/libs/supl/types/ber_decoder.h
View File

0
src/core/libs/supl/asn-rrlp/ber_tlv_length.c → src/core/libs/supl/types/ber_tlv_length.c
View File

0
src/core/libs/supl/asn-rrlp/ber_tlv_length.h → src/core/libs/supl/types/ber_tlv_length.h
View File

0
src/core/libs/supl/asn-rrlp/ber_tlv_tag.c → src/core/libs/supl/types/ber_tlv_tag.c
View File

0
src/core/libs/supl/asn-supl/ber_tlv_tag.h → src/core/libs/supl/types/ber_tlv_tag.h
View File

0
src/core/libs/supl/asn-rrlp/constr_CHOICE.c → src/core/libs/supl/types/constr_CHOICE.c
View File

0
src/core/libs/supl/asn-rrlp/constr_CHOICE.h → src/core/libs/supl/types/constr_CHOICE.h
View File

0
src/core/libs/supl/asn-supl/constr_SEQUENCE.c → src/core/libs/supl/types/constr_SEQUENCE.c
View File

0
src/core/libs/supl/asn-rrlp/constr_SEQUENCE.h → src/core/libs/supl/types/constr_SEQUENCE.h
View File

0
src/core/libs/supl/asn-rrlp/constr_SEQUENCE_OF.c → src/core/libs/supl/types/constr_SEQUENCE_OF.c
View File

0
src/core/libs/supl/asn-rrlp/constr_SEQUENCE_OF.h → src/core/libs/supl/types/constr_SEQUENCE_OF.h
View File

0
src/core/libs/supl/asn-rrlp/constr_SET_OF.c → src/core/libs/supl/types/constr_SET_OF.c
View File

0
src/core/libs/supl/asn-rrlp/constr_SET_OF.h → src/core/libs/supl/types/constr_SET_OF.h
View File

0
src/core/libs/supl/asn-rrlp/constr_TYPE.c → src/core/libs/supl/types/constr_TYPE.c
View File

0
src/core/libs/supl/asn-rrlp/constr_TYPE.h → src/core/libs/supl/types/constr_TYPE.h
View File

0
src/core/libs/supl/asn-supl/constraints.c → src/core/libs/supl/types/constraints.c
View File

Some files were not shown because too many files have changed in this diff Show More