port/merge Eurecom APER support from OPENAIRMME
Eurecom has developed APER support for asn1c as part of the OPENAIRMME
softare (a LTE MME). This is too important to let it bit-rout out
of asn1c. Let's forward-port and merge it.
diff --git a/skeletons/per_support.c b/skeletons/per_support.c
index 5ecdc2e..21ea239 100644
--- a/skeletons/per_support.c
+++ b/skeletons/per_support.c
@@ -31,6 +31,16 @@
}
}
+int32_t
+aper_get_align(asn_per_data_t *pd) {
+
+ if(pd->nboff & 0x7) {
+ ASN_DEBUG("Aligning %d bits", 8 - (pd->nboff & 0x7));
+ return per_get_few_bits(pd, 8 - (pd->nboff & 0x7));
+ }
+ return 0;
+}
+
/*
* Extract a small number of bits (<= 31) from the specified PER data pointer.
*/
@@ -104,7 +114,7 @@
accum &= (((uint32_t)1 << nbits) - 1);
- ASN_DEBUG(" [PER got %2d<=%2d bits => span %d %+ld[%d..%d]:%02x (%d) => 0x%x]",
+ ASN_DEBUG(" [PER got %2d<=%2d bits => span %d %+ld[%d..%d]:%02x (%d) => 0x%02x]",
(int)nbits, (int)nleft,
(int)pd->moved,
(((long)pd->buffer) & 0xf),
@@ -123,6 +133,8 @@
per_get_many_bits(asn_per_data_t *pd, uint8_t *dst, int alright, int nbits) {
int32_t value;
+ ASN_DEBUG("align: %s, nbits %d", alright ? "YES":"NO", nbits);
+
if(alright && (nbits & 7)) {
/* Perform right alignment of a first few bits */
value = per_get_few_bits(pd, nbits & 0x07);
@@ -187,6 +199,36 @@
return (16384 * value);
}
+ssize_t
+aper_get_length(asn_per_data_t *pd, int range, int ebits, int *repeat) {
+ ssize_t value;
+
+ *repeat = 0;
+
+ if (range <= 65536 && range >= 0)
+ return aper_get_nsnnwn(pd, range);
+
+ if (aper_get_align(pd) < 0)
+ return -1;
+
+ if(ebits >= 0) return per_get_few_bits(pd, ebits);
+
+ value = per_get_few_bits(pd, 8);
+ if(value < 0) return -1;
+ if((value & 128) == 0) /* #10.9.3.6 */
+ return (value & 0x7F);
+ if((value & 64) == 0) { /* #10.9.3.7 */
+ value = ((value & 63) << 8) | per_get_few_bits(pd, 8);
+ if(value < 0) return -1;
+ return value;
+ }
+ value &= 63; /* this is "m" from X.691, #10.9.3.8 */
+ if(value < 1 || value > 4)
+ return -1;
+ *repeat = 1;
+ return (16384 * value);
+}
+
/*
* Get the normally small length "n".
* This procedure used to decode length of extensions bit-maps
@@ -211,6 +253,25 @@
}
}
+ssize_t
+aper_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", length);
+ return length;
+ } else {
+ int repeat;
+ length = aper_get_length(pd, -1, -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
@@ -237,6 +298,40 @@
return value;
}
+ssize_t
+aper_get_nsnnwn(asn_per_data_t *pd, int range) {
+ ssize_t value;
+ int bytes = 0;
+
+ ASN_DEBUG("getting nsnnwn with range %d", range);
+
+ if(range <= 255) {
+ if (range < 0) return -1;
+ /* 1 -> 8 bits */
+ int i;
+ for (i = 1; i <= 8; i++) {
+ int upper = 1 << i;
+ if (upper >= range)
+ break;
+ }
+ value = per_get_few_bits(pd, i);
+ return value;
+ } else if (range == 256){
+ /* 1 byte */
+ bytes = 1;
+ return -1;
+ } else if (range <= 65536) {
+ /* 2 bytes */
+ bytes = 2;
+ } else {
+ return -1;
+ }
+ if (aper_get_align(pd) < 0)
+ return -1;
+ value = per_get_few_bits(pd, 8 * bytes);
+ return value;
+}
+
/*
* X.691-11/2008, #11.6
* Encoding of a normally small non-negative whole number
@@ -245,6 +340,7 @@
uper_put_nsnnwn(asn_per_outp_t *po, int n) {
int bytes;
+ ASN_DEBUG("uper put nsnnwn n %d", n);
if(n <= 63) {
if(n < 0) return -1;
return per_put_few_bits(po, n, 7);
@@ -405,6 +501,61 @@
return 0;
}
+int
+aper_put_nsnnwn(asn_per_outp_t *po, int range, int number) {
+ int bytes;
+
+ ASN_DEBUG("aper put nsnnwn %d with range %d", number, range);
+ /* 10.5.7.1 X.691 */
+ if(range < 0) {
+ int i;
+ for (i = 1; ; i++) {
+ int bits = 1 << (8 * i);
+ if (number <= bits)
+ break;
+ }
+ bytes = i;
+ assert(i <= 4);
+ }
+ if(range <= 255) {
+ int i;
+ for (i = 1; i <= 8; i++) {
+ int bits = 1 << i;
+ if (range <= bits)
+ break;
+ }
+ return per_put_few_bits(po, number, i);
+ } else if(range == 256) {
+ bytes = 1;
+ } else if(range <= 65536) {
+ bytes = 2;
+ } else { /* Ranges > 64K */
+ int i;
+ for (i = 1; ; i++) {
+ int bits = 1 << (8 * i);
+ if (range <= bits)
+ break;
+ }
+ assert(i <= 4);
+ bytes = i;
+ }
+ if(aper_put_align(po) < 0) /* Aligning on octet */
+ return -1;
+// if(per_put_few_bits(po, bytes, 8))
+// return -1;
+
+ return per_put_few_bits(po, number, 8 * bytes);
+}
+
+int aper_put_align(asn_per_outp_t *po) {
+
+ if(po->nboff & 0x7) {
+ ASN_DEBUG("Aligning %d bits", 8 - (po->nboff & 0x7));
+ if(per_put_few_bits(po, 0x00, (8 - (po->nboff & 0x7))))
+ return -1;
+ }
+ return 0;
+}
/*
* Output a large number of bits.
@@ -444,6 +595,8 @@
ssize_t
uper_put_length(asn_per_outp_t *po, size_t length) {
+ ASN_DEBUG("UPER put length %d", length);
+
if(length <= 127) /* #10.9.3.6 */
return per_put_few_bits(po, length, 8)
? -1 : (ssize_t)length;
@@ -458,6 +611,33 @@
? -1 : (ssize_t)(length << 14);
}
+ssize_t
+aper_put_length(asn_per_outp_t *po, int range, size_t length) {
+
+ ASN_DEBUG("APER put length %d with range %d", length, range);
+
+ /* 10.9 X.691 Note 2 */
+ if (range <= 65536 && range >= 0)
+ return aper_put_nsnnwn(po, range, length);
+
+ if (aper_put_align(po) < 0)
+ return -1;
+
+ 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.
@@ -481,3 +661,19 @@
return 0;
}
+int
+aper_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(aper_put_length(po, -1, length) != (ssize_t)length) {
+ /* This might happen in case of >16K extensions */
+ return -1;
+ }
+ }
+
+ return 0;
+}