-
-
Notifications
You must be signed in to change notification settings - Fork 326
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Add rel17 compiled asn and ngap files
- Loading branch information
Tim Niehoff
committed
Oct 28, 2024
1 parent
3e016e7
commit 11dd5e7
Showing
2,155 changed files
with
178,536 additions
and
41,137 deletions.
There are no files selected for viewing
Large diffs are not rendered by default.
Oops, something went wrong.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,294 @@ | ||
/*- | ||
* Copyright (c) 2003, 2004, 2006 Lev Walkin <[email protected]>. | ||
* All rights reserved. | ||
* Redistribution and modifications are permitted subject to BSD license. | ||
*/ | ||
#include <asn_internal.h> | ||
#include <UTF8String.h> | ||
|
||
/* | ||
* UTF8String basic type description. | ||
*/ | ||
static const ber_tlv_tag_t asn_DEF_UTF8String_tags[] = { | ||
(ASN_TAG_CLASS_UNIVERSAL | (12 << 2)), /* [UNIVERSAL 12] IMPLICIT ...*/ | ||
(ASN_TAG_CLASS_UNIVERSAL | (4 << 2)), /* ... OCTET STRING */ | ||
}; | ||
asn_TYPE_operation_t asn_OP_UTF8String = { | ||
OCTET_STRING_free, | ||
UTF8String_print, | ||
OCTET_STRING_compare, | ||
OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ | ||
OCTET_STRING_encode_der, | ||
OCTET_STRING_decode_xer_utf8, | ||
OCTET_STRING_encode_xer_utf8, | ||
#ifdef ASN_DISABLE_OER_SUPPORT | ||
0, | ||
0, | ||
#else | ||
OCTET_STRING_decode_oer, | ||
OCTET_STRING_encode_oer, | ||
#endif /* ASN_DISABLE_OER_SUPPORT */ | ||
#ifdef ASN_DISABLE_PER_SUPPORT | ||
0, | ||
0, | ||
0, | ||
0, | ||
#else | ||
OCTET_STRING_decode_uper, | ||
OCTET_STRING_encode_uper, | ||
OCTET_STRING_decode_aper, | ||
OCTET_STRING_encode_aper, | ||
#endif /* ASN_DISABLE_PER_SUPPORT */ | ||
UTF8String_random_fill, | ||
0 /* Use generic outmost tag fetcher */ | ||
}; | ||
asn_TYPE_descriptor_t asn_DEF_UTF8String = { | ||
"UTF8String", | ||
"UTF8String", | ||
&asn_OP_UTF8String, | ||
asn_DEF_UTF8String_tags, | ||
sizeof(asn_DEF_UTF8String_tags) | ||
/ sizeof(asn_DEF_UTF8String_tags[0]) - 1, | ||
asn_DEF_UTF8String_tags, | ||
sizeof(asn_DEF_UTF8String_tags) | ||
/ sizeof(asn_DEF_UTF8String_tags[0]), | ||
{ 0, 0, UTF8String_constraint }, | ||
0, 0, /* No members */ | ||
0 /* No specifics */ | ||
}; | ||
|
||
/* | ||
* This is the table of length expectations. | ||
* The second half of this table is only applicable to the long sequences. | ||
*/ | ||
static const int UTF8String_ht[2][16] = { | ||
{ /* 0x0 ... 0x7 */ | ||
/* 0000..0111 */ | ||
1, 1, 1, 1, 1, 1, 1, 1, | ||
/* 1000..1011(0), 1100..1101(2), 1110(3), 1111(-1) */ | ||
0, 0, 0, 0, 2, 2, 3, -1 }, | ||
{ /* 0xF0 .. 0xF7 */ | ||
/* 11110000..11110111 */ | ||
4, 4, 4, 4, 4, 4, 4, 4, | ||
5, 5, 5, 5, 6, 6, -1, -1 } | ||
}; | ||
static const int32_t UTF8String_mv[7] = { 0, 0, | ||
0x00000080, | ||
0x00000800, | ||
0x00010000, | ||
0x00200000, | ||
0x04000000 | ||
}; | ||
|
||
/* Internal aliases for return codes */ | ||
#define U8E_TRUNC -1 /* UTF-8 sequence truncated */ | ||
#define U8E_ILLSTART -2 /* Illegal UTF-8 sequence start */ | ||
#define U8E_NOTCONT -3 /* Continuation expectation failed */ | ||
#define U8E_NOTMIN -4 /* Not minimal length encoding */ | ||
#define U8E_EINVAL -5 /* Invalid arguments */ | ||
|
||
int | ||
UTF8String_constraint(const asn_TYPE_descriptor_t *td, const void *sptr, | ||
asn_app_constraint_failed_f *ctfailcb, void *app_key) { | ||
ssize_t len = UTF8String_length((const UTF8String_t *)sptr); | ||
switch(len) { | ||
case U8E_EINVAL: | ||
ASN__CTFAIL(app_key, td, sptr, | ||
"%s: value not given", td->name); | ||
break; | ||
case U8E_TRUNC: | ||
ASN__CTFAIL(app_key, td, sptr, | ||
"%s: truncated UTF-8 sequence (%s:%d)", | ||
td->name, __FILE__, __LINE__); | ||
break; | ||
case U8E_ILLSTART: | ||
ASN__CTFAIL(app_key, td, sptr, | ||
"%s: UTF-8 illegal start of encoding (%s:%d)", | ||
td->name, __FILE__, __LINE__); | ||
break; | ||
case U8E_NOTCONT: | ||
ASN__CTFAIL(app_key, td, sptr, | ||
"%s: UTF-8 not continuation (%s:%d)", | ||
td->name, __FILE__, __LINE__); | ||
break; | ||
case U8E_NOTMIN: | ||
ASN__CTFAIL(app_key, td, sptr, | ||
"%s: UTF-8 not minimal sequence (%s:%d)", | ||
td->name, __FILE__, __LINE__); | ||
break; | ||
} | ||
return (len < 0) ? -1 : 0; | ||
} | ||
|
||
static ssize_t | ||
UTF8String__process(const UTF8String_t *st, uint32_t *dst, size_t dstlen) { | ||
size_t length; | ||
uint8_t *buf = st->buf; | ||
uint8_t *end = buf + st->size; | ||
uint32_t *dstend = dst + dstlen; | ||
|
||
for(length = 0; buf < end; length++) { | ||
int ch = *buf; | ||
uint8_t *cend; | ||
int32_t value; | ||
int want; | ||
|
||
/* Compute the sequence length */ | ||
want = UTF8String_ht[0][ch >> 4]; | ||
switch(want) { | ||
case -1: | ||
/* Second half of the table, long sequence */ | ||
want = UTF8String_ht[1][ch & 0x0F]; | ||
if(want != -1) break; | ||
/* Fall through */ | ||
case 0: | ||
return U8E_ILLSTART; | ||
} | ||
|
||
/* assert(want >= 1 && want <= 6) */ | ||
|
||
/* Check character sequence length */ | ||
if(buf + want > end) return U8E_TRUNC; | ||
|
||
value = ch & (0xff >> want); | ||
cend = buf + want; | ||
for(buf++; buf < cend; buf++) { | ||
ch = *buf; | ||
if(ch < 0x80 || ch > 0xbf) return U8E_NOTCONT; | ||
value = (value << 6) | (ch & 0x3F); | ||
} | ||
if(value < UTF8String_mv[want]) | ||
return U8E_NOTMIN; | ||
if(dst < dstend) | ||
*dst++ = value; /* Record value */ | ||
} | ||
|
||
if(dst < dstend) *dst = 0; /* zero-terminate */ | ||
|
||
return length; | ||
} | ||
|
||
|
||
ssize_t | ||
UTF8String_length(const UTF8String_t *st) { | ||
if(st && st->buf) { | ||
return UTF8String__process(st, 0, 0); | ||
} else { | ||
return U8E_EINVAL; | ||
} | ||
} | ||
|
||
size_t | ||
UTF8String_to_wcs(const UTF8String_t *st, uint32_t *dst, size_t dstlen) { | ||
if(st && st->buf) { | ||
ssize_t ret = UTF8String__process(st, dst, dstlen); | ||
return (ret < 0) ? 0 : ret; | ||
} else { | ||
return 0; | ||
} | ||
} | ||
|
||
int | ||
UTF8String_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel, | ||
asn_app_consume_bytes_f *cb, void *app_key) { | ||
const UTF8String_t *st = (const UTF8String_t *)sptr; | ||
|
||
(void)td; /* Unused argument */ | ||
(void)ilevel; /* Unused argument */ | ||
|
||
if(st && st->buf) { | ||
return (cb(st->buf, st->size, app_key) < 0) ? -1 : 0; | ||
} else { | ||
return (cb("<absent>", 8, app_key) < 0) ? -1 : 0; | ||
} | ||
} | ||
|
||
|
||
/* | ||
* Biased function for randomizing UTF-8 sequences. | ||
*/ | ||
static size_t | ||
UTF8String__random_char(uint8_t *b, size_t size) { | ||
static const struct rnd_value { | ||
const char *value; | ||
size_t size; | ||
} values[] = {{"\0", 1}, | ||
{"\x01", 1}, | ||
{"\x7f", 1}, | ||
{"\xc2\xa2", 2}, | ||
{"\xe2\x82\xac", 3}, | ||
{"\xf0\x90\x8d\x88", 4}, | ||
{"\xf4\x8f\xbf\xbf", 4}}; | ||
|
||
const struct rnd_value *v; | ||
size_t max_idx = 0; | ||
|
||
switch(size) { | ||
case 0: | ||
assert(size != 0); | ||
return 0; | ||
case 1: | ||
max_idx = 2; | ||
break; | ||
case 2: | ||
max_idx = 3; | ||
break; | ||
default: | ||
case 4: | ||
max_idx = sizeof(values) / sizeof(values[0]) - 1; | ||
break; | ||
} | ||
|
||
v = &values[asn_random_between(0, max_idx)]; | ||
memcpy(b, v->value, v->size); | ||
return v->size; | ||
} | ||
|
||
asn_random_fill_result_t | ||
UTF8String_random_fill(const asn_TYPE_descriptor_t *td, void **sptr, | ||
const asn_encoding_constraints_t *constraints, | ||
size_t max_length) { | ||
asn_random_fill_result_t result_ok = {ARFILL_OK, 1}; | ||
asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0}; | ||
asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0}; | ||
uint8_t *buf; | ||
uint8_t *bend; | ||
uint8_t *b; | ||
size_t rnd_len; | ||
size_t idx; | ||
UTF8String_t *st; | ||
|
||
if(max_length == 0 && !*sptr) return result_skipped; | ||
|
||
/* Figure out how far we should go */ | ||
rnd_len = OCTET_STRING_random_length_constrained(td, constraints, | ||
max_length / 4); | ||
|
||
buf = CALLOC(4, rnd_len + 1); | ||
if(!buf) return result_failed; | ||
|
||
bend = &buf[4 * rnd_len]; | ||
|
||
for(b = buf, idx = 0; idx < rnd_len; idx++) { | ||
b += UTF8String__random_char(b, (bend - b)); | ||
} | ||
*(uint8_t *)b = 0; | ||
|
||
if(*sptr) { | ||
st = *sptr; | ||
FREEMEM(st->buf); | ||
} else { | ||
st = (OCTET_STRING_t *)(*sptr = CALLOC(1, sizeof(UTF8String_t))); | ||
if(!st) { | ||
FREEMEM(buf); | ||
return result_failed; | ||
} | ||
} | ||
|
||
st->buf = buf; | ||
st->size = b - buf; | ||
|
||
assert(UTF8String_length(st) == (ssize_t)rnd_len); | ||
|
||
return result_ok; | ||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,63 @@ | ||
/*- | ||
* Copyright (c) 2003-2017 Lev Walkin <[email protected]>. All rights reserved. | ||
* Redistribution and modifications are permitted subject to BSD license. | ||
*/ | ||
#ifndef _UTF8String_H_ | ||
#define _UTF8String_H_ | ||
|
||
#include <OCTET_STRING.h> | ||
|
||
#ifdef __cplusplus | ||
extern "C" { | ||
#endif | ||
|
||
typedef OCTET_STRING_t UTF8String_t; /* Implemented via OCTET STRING */ | ||
|
||
extern asn_TYPE_descriptor_t asn_DEF_UTF8String; | ||
extern asn_TYPE_operation_t asn_OP_UTF8String; | ||
|
||
asn_struct_print_f UTF8String_print; | ||
asn_constr_check_f UTF8String_constraint; | ||
asn_random_fill_f UTF8String_random_fill; | ||
|
||
#define UTF8String_free OCTET_STRING_free | ||
#define UTF8String_compare OCTET_STRING_compare | ||
#define UTF8String_constraint UTF8String_constraint | ||
#define UTF8String_decode_ber OCTET_STRING_decode_ber | ||
#define UTF8String_encode_der OCTET_STRING_encode_der | ||
#define UTF8String_decode_xer OCTET_STRING_decode_xer_utf8 | ||
#define UTF8String_encode_xer OCTET_STRING_encode_xer_utf8 | ||
#define UTF8String_decode_uper OCTET_STRING_decode_uper | ||
#define UTF8String_encode_uper OCTET_STRING_encode_uper | ||
#define UTF8String_decode_aper OCTET_STRING_decode_aper | ||
#define UTF8String_encode_aper OCTET_STRING_encode_aper | ||
|
||
/* | ||
* Returns length of the given UTF-8 string in characters, | ||
* or a negative error code: | ||
* -1: UTF-8 sequence truncated | ||
* -2: Illegal UTF-8 sequence start | ||
* -3: Continuation expectation failed | ||
* -4: Not minimal length encoding | ||
* -5: Invalid arguments | ||
*/ | ||
ssize_t UTF8String_length(const UTF8String_t *st); | ||
|
||
/* | ||
* Convert the UTF-8 string into a sequence of wide characters. | ||
* Returns the number of characters necessary. | ||
* Returned value might be greater than dstlen. | ||
* In case of conversion error, 0 is returned. | ||
* | ||
* If st points to a valid UTF-8 string, calling | ||
* UTF8String_to_wcs(st, 0, 0); | ||
* is equivalent to | ||
* UTF8String_length(const UTF8String_t *st); | ||
*/ | ||
size_t UTF8String_to_wcs(const UTF8String_t *st, uint32_t *dst, size_t dstlen); | ||
|
||
#ifdef __cplusplus | ||
} | ||
#endif | ||
|
||
#endif /* _UTF8String_H_ */ |
Oops, something went wrong.