--- /dev/null
+/*\r
+ * Copyright (c) 2005-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.\r
+ * Redistribution and modifications are permitted subject to BSD license.\r
+ */\r
+#include <asn_system.h>\r
+#include <asn_internal.h>\r
+#include <per_support.h>\r
+\r
+/*\r
+ * X.691-201508 #10.9 General rules for encoding a length determinant.\r
+ * Get the optionally constrained length "n" from the stream.\r
+ */\r
+ssize_t\r
+uper_get_length(asn_per_data_t *pd, int ebits, size_t lower_bound,\r
+ int *repeat) {\r
+ ssize_t value;\r
+\r
+ *repeat = 0;\r
+\r
+ /* #11.9.4.1 Encoding if constrained (according to effective bits) */\r
+ if(ebits >= 0 && ebits <= 16) {\r
+ value = per_get_few_bits(pd, ebits);\r
+ if(value >= 0) value += lower_bound;\r
+ return value;\r
+ }\r
+\r
+ value = per_get_few_bits(pd, 8);\r
+ if((value & 0x80) == 0) { /* #11.9.3.6 */\r
+ return (value & 0x7F);\r
+ } else if((value & 0x40) == 0) { /* #11.9.3.7 */\r
+ /* bit 8 ... set to 1 and bit 7 ... set to zero */\r
+ value = ((value & 0x3f) << 8) | per_get_few_bits(pd, 8);\r
+ return value; /* potential -1 from per_get_few_bits passes through. */\r
+ } else if(value < 0) {\r
+ ASN_DEBUG("END of stream reached for PER");\r
+ return -1;\r
+ }\r
+ value &= 0x3f; /* this is "m" from X.691, #11.9.3.8 */\r
+ if(value < 1 || value > 4) {\r
+ return -1; /* Prohibited by #11.9.3.8 */\r
+ }\r
+ *repeat = 1;\r
+ return (16384 * value);\r
+}\r
+\r
+/*\r
+ * Get the normally small length "n".\r
+ * This procedure used to decode length of extensions bit-maps\r
+ * for SET and SEQUENCE types.\r
+ */\r
+ssize_t\r
+uper_get_nslength(asn_per_data_t *pd) {\r
+ ssize_t length;\r
+\r
+ ASN_DEBUG("Getting normally small length");\r
+\r
+ if(per_get_few_bits(pd, 1) == 0) {\r
+ length = per_get_few_bits(pd, 6) + 1;\r
+ if(length <= 0) return -1;\r
+ ASN_DEBUG("l=%d", (int)length);\r
+ return length;\r
+ } else {\r
+ int repeat;\r
+ length = uper_get_length(pd, -1, 0, &repeat);\r
+ if(length >= 0 && !repeat) return length;\r
+ return -1; /* Error, or do not support >16K extensions */\r
+ }\r
+}\r
+\r
+/*\r
+ * Get the normally small non-negative whole number.\r
+ * X.691, #10.6\r
+ */\r
+ssize_t\r
+uper_get_nsnnwn(asn_per_data_t *pd) {\r
+ ssize_t value;\r
+\r
+ value = per_get_few_bits(pd, 7);\r
+ if(value & 64) { /* implicit (value < 0) */\r
+ value &= 63;\r
+ value <<= 2;\r
+ value |= per_get_few_bits(pd, 2);\r
+ if(value & 128) /* implicit (value < 0) */\r
+ return -1;\r
+ if(value == 0)\r
+ return 0;\r
+ if(value >= 3)\r
+ return -1;\r
+ value = per_get_few_bits(pd, 8 * value);\r
+ return value;\r
+ }\r
+\r
+ return value;\r
+}\r
+\r
+/*\r
+ * X.691-11/2008, #11.6\r
+ * Encoding of a normally small non-negative whole number\r
+ */\r
+int\r
+uper_put_nsnnwn(asn_per_outp_t *po, int n) {\r
+ int bytes;\r
+\r
+ if(n <= 63) {\r
+ if(n < 0) return -1;\r
+ return per_put_few_bits(po, n, 7);\r
+ }\r
+ if(n < 256)\r
+ bytes = 1;\r
+ else if(n < 65536)\r
+ bytes = 2;\r
+ else if(n < 256 * 65536)\r
+ bytes = 3;\r
+ else\r
+ return -1; /* This is not a "normally small" value */\r
+ if(per_put_few_bits(po, bytes, 8))\r
+ return -1;\r
+\r
+ return per_put_few_bits(po, n, 8 * bytes);\r
+}\r
+\r
+\r
+/* X.691-2008/11, #11.5.6 -> #11.3 */\r
+int uper_get_constrained_whole_number(asn_per_data_t *pd, unsigned long *out_value, int nbits) {\r
+ unsigned long lhalf; /* Lower half of the number*/\r
+ long half;\r
+\r
+ if(nbits <= 31) {\r
+ half = per_get_few_bits(pd, nbits);\r
+ if(half < 0) return -1;\r
+ *out_value = half;\r
+ return 0;\r
+ }\r
+\r
+ if((size_t)nbits > 8 * sizeof(*out_value))\r
+ return -1; /* RANGE */\r
+\r
+ half = per_get_few_bits(pd, 31);\r
+ if(half < 0) return -1;\r
+\r
+ if(uper_get_constrained_whole_number(pd, &lhalf, nbits - 31))\r
+ return -1;\r
+\r
+ *out_value = ((unsigned long)half << (nbits - 31)) | lhalf;\r
+ return 0;\r
+}\r
+\r
+\r
+/* X.691-2008/11, #11.5.6 -> #11.3 */\r
+int\r
+uper_put_constrained_whole_number_u(asn_per_outp_t *po, unsigned long v,\r
+ int nbits) {\r
+ if(nbits <= 31) {\r
+ return per_put_few_bits(po, v, nbits);\r
+ } else {\r
+ /* Put higher portion first, followed by lower 31-bit */\r
+ if(uper_put_constrained_whole_number_u(po, v >> 31, nbits - 31))\r
+ return -1;\r
+ return per_put_few_bits(po, v, 31);\r
+ }\r
+}\r
+\r
+/*\r
+ * X.691 (08/2015) #11.9 "General rules for encoding a length determinant"\r
+ * Put the length "n" (or part of it) into the stream.\r
+ */\r
+ssize_t\r
+uper_put_length(asn_per_outp_t *po, size_t length, int *need_eom) {\r
+ int dummy = 0;\r
+ if(!need_eom) need_eom = &dummy;\r
+\r
+ if(length <= 127) { /* #11.9.3.6 */\r
+ *need_eom = 0;\r
+ return per_put_few_bits(po, length, 8)\r
+ ? -1 : (ssize_t)length;\r
+ } else if(length < 16384) { /* #10.9.3.7 */\r
+ *need_eom = 0;\r
+ return per_put_few_bits(po, length|0x8000, 16)\r
+ ? -1 : (ssize_t)length;\r
+ }\r
+\r
+ *need_eom = 0 == (length & 16383);\r
+ length >>= 14;\r
+ if(length > 4) {\r
+ *need_eom = 0;\r
+ length = 4;\r
+ }\r
+\r
+ return per_put_few_bits(po, 0xC0 | length, 8)\r
+ ? -1 : (ssize_t)(length << 14);\r
+\r
+}\r
+\r
+\r
+/*\r
+ * Put the normally small length "n" into the stream.\r
+ * This procedure used to encode length of extensions bit-maps\r
+ * for SET and SEQUENCE types.\r
+ */\r
+int\r
+uper_put_nslength(asn_per_outp_t *po, size_t length) {\r
+ if(length <= 64) {\r
+ /* #11.9.3.4 */\r
+ if(length == 0) return -1;\r
+ return per_put_few_bits(po, length - 1, 7) ? -1 : 0;\r
+ } else {\r
+ int need_eom = 0;\r
+ if(uper_put_length(po, length, &need_eom) != (ssize_t)length\r
+ || need_eom) {\r
+ /* This might happen in case of >16K extensions */\r
+ return -1;\r
+ }\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+static int\r
+per__long_range(long lb, long ub, unsigned long *range_r) {\r
+ unsigned long bounds_range;\r
+ if((ub < 0) == (lb < 0)) {\r
+ bounds_range = ub - lb;\r
+ } else if(lb < 0) {\r
+ assert(ub >= 0);\r
+ bounds_range = 1 + ((unsigned long)ub + (unsigned long)-(lb + 1));\r
+ } else {\r
+ assert(!"Unreachable");\r
+ return -1;\r
+ }\r
+ *range_r = bounds_range;\r
+ return 0;\r
+}\r
+\r
+int\r
+per_long_range_rebase(long v, long lb, long ub, unsigned long *output) {\r
+ unsigned long range;\r
+\r
+ assert(lb <= ub);\r
+\r
+ if(v < lb || v > ub || per__long_range(lb, ub, &range) < 0) {\r
+ /* Range error. */\r
+ return -1;\r
+ }\r
+\r
+ /*\r
+ * Fundamentally what we're doing is returning (v-lb).\r
+ * However, this triggers undefined behavior when the word width\r
+ * of signed (v) is the same as the size of unsigned (*output).\r
+ * In practice, it triggers the UndefinedSanitizer. Therefore we shall\r
+ * compute the ranges accurately to avoid C's undefined behavior.\r
+ */\r
+ if((v < 0) == (lb < 0)) {\r
+ *output = v-lb;\r
+ return 0;\r
+ } else if(v < 0) {\r
+ unsigned long rebased = 1 + (unsigned long)-(v+1) + (unsigned long)lb;\r
+ assert(rebased <= range); /* By construction */\r
+ *output = rebased;\r
+ return 0;\r
+ } else if(lb < 0) {\r
+ unsigned long rebased = 1 + (unsigned long)-(lb+1) + (unsigned long)v;\r
+ assert(rebased <= range); /* By construction */\r
+ *output = rebased;\r
+ return 0;\r
+ } else {\r
+ assert(!"Unreachable");\r
+ return -1;\r
+ }\r
+}\r
+\r
+int\r
+per_long_range_unrebase(unsigned long inp, long lb, long ub, long *outp) {\r
+ unsigned long range;\r
+\r
+ if(per__long_range(lb, ub, &range) != 0) {\r
+ return -1;\r
+ }\r
+\r
+ if(inp > range) {\r
+ /*\r
+ * We can encode something in the given number of bits that technically\r
+ * exceeds the range. This is an avenue for security errors,\r
+ * so we don't allow that.\r
+ */\r
+ return -1;\r
+ }\r
+\r
+ if(inp <= LONG_MAX) {\r
+ *outp = (long)inp + lb;\r
+ } else {\r
+ *outp = (lb + LONG_MAX + 1) + (long)((inp - LONG_MAX) - 1);\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+int32_t\r
+aper_get_align(asn_per_data_t *pd) {\r
+\r
+ if(pd->nboff & 0x7) {\r
+ ASN_DEBUG("Aligning %ld bits", 8 - ((unsigned long)pd->nboff & 0x7));\r
+ return per_get_few_bits(pd, 8 - (pd->nboff & 0x7));\r
+ }\r
+ return 0;\r
+}\r
+\r
+ssize_t\r
+aper_get_length(asn_per_data_t *pd, int range, int ebits, int *repeat) {\r
+ ssize_t value;\r
+\r
+ *repeat = 0;\r
+\r
+ if (range <= 65536 && range >= 0)\r
+ return aper_get_nsnnwn(pd, range);\r
+\r
+ if (aper_get_align(pd) < 0)\r
+ return -1;\r
+\r
+ if(ebits >= 0) return per_get_few_bits(pd, ebits);\r
+\r
+ value = per_get_few_bits(pd, 8);\r
+ if(value < 0) return -1;\r
+ if((value & 128) == 0) /* #10.9.3.6 */\r
+ return (value & 0x7F);\r
+ if((value & 64) == 0) { /* #10.9.3.7 */\r
+ value = ((value & 63) << 8) | per_get_few_bits(pd, 8);\r
+ if(value < 0) return -1;\r
+ return value;\r
+ }\r
+ value &= 63; /* this is "m" from X.691, #10.9.3.8 */\r
+ if(value < 1 || value > 4)\r
+ return -1;\r
+ *repeat = 1;\r
+ return (16384 * value);\r
+}\r
+\r
+ssize_t\r
+aper_get_nslength(asn_per_data_t *pd) {\r
+ ssize_t length;\r
+\r
+ ASN_DEBUG("Getting normally small length");\r
+\r
+ if(per_get_few_bits(pd, 1) == 0) {\r
+ length = per_get_few_bits(pd, 6) + 1;\r
+ if(length <= 0) return -1;\r
+ ASN_DEBUG("l=%ld", length);\r
+ return length;\r
+ } else {\r
+ int repeat;\r
+ length = aper_get_length(pd, -1, -1, &repeat);\r
+ if(length >= 0 && !repeat) return length;\r
+ return -1; /* Error, or do not support >16K extensions */\r
+ }\r
+}\r
+\r
+ssize_t\r
+aper_get_nsnnwn(asn_per_data_t *pd, int range) {\r
+ ssize_t value;\r
+ int bytes = 0;\r
+\r
+ ASN_DEBUG("getting nsnnwn with range %d", range);\r
+\r
+ if(range <= 255) {\r
+ int i;\r
+\r
+ if (range < 0) return -1;\r
+ /* 1 -> 8 bits */\r
+ for (i = 1; i <= 8; i++) {\r
+ int upper = 1 << i;\r
+ if (upper >= range)\r
+ break;\r
+ }\r
+ value = per_get_few_bits(pd, i);\r
+ return value;\r
+ } else if (range == 256){\r
+ /* 1 byte */\r
+ bytes = 1;\r
+ } else if (range <= 65536) {\r
+ /* 2 bytes */\r
+ bytes = 2;\r
+ } else {\r
+ return -1;\r
+ }\r
+ if (aper_get_align(pd) < 0)\r
+ return -1;\r
+ value = per_get_few_bits(pd, 8 * bytes);\r
+ return value;\r
+}\r
+\r
+int aper_put_align(asn_per_outp_t *po) {\r
+\r
+ if(po->nboff & 0x7) {\r
+ ASN_DEBUG("Aligning %ld bits", 8 - ((unsigned long)po->nboff & 0x7));\r
+ if(per_put_few_bits(po, 0x00, (8 - (po->nboff & 0x7))))\r
+ return -1;\r
+ }\r
+ return 0;\r
+}\r
+\r
+ssize_t\r
+aper_put_length(asn_per_outp_t *po, int range, size_t length) {\r
+\r
+ ASN_DEBUG("APER put length %zu with range %d", length, range);\r
+\r
+ /* 10.9 X.691 Note 2 */\r
+ if (range <= 65536 && range >= 0)\r
+ return aper_put_nsnnwn(po, range, length);\r
+\r
+ if (aper_put_align(po) < 0)\r
+ return -1;\r
+\r
+ if(length <= 127) /* #10.9.3.6 */{\r
+ return per_put_few_bits(po, length, 8)\r
+ ? -1 : (ssize_t)length;\r
+ }\r
+ else if(length < 16384) /* #10.9.3.7 */\r
+ return per_put_few_bits(po, length|0x8000, 16)\r
+ ? -1 : (ssize_t)length;\r
+\r
+ length >>= 14;\r
+ if(length > 4) length = 4;\r
+\r
+ return per_put_few_bits(po, 0xC0 | length, 8)\r
+ ? -1 : (ssize_t)(length << 14);\r
+}\r
+\r
+\r
+int\r
+aper_put_nslength(asn_per_outp_t *po, size_t length) {\r
+\r
+ if(length <= 64) {\r
+ /* #10.9.3.4 */\r
+ if(length == 0) return -1;\r
+ return per_put_few_bits(po, length-1, 7) ? -1 : 0;\r
+ } else {\r
+ if(aper_put_length(po, -1, length) != (ssize_t)length) {\r
+ /* This might happen in case of >16K extensions */\r
+ return -1;\r
+ }\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+int\r
+aper_put_nsnnwn(asn_per_outp_t *po, int range, int number) {\r
+ int bytes;\r
+\r
+ ASN_DEBUG("aper put nsnnwn %d with range %d", number, range);\r
+ /* 10.5.7.1 X.691 */\r
+ if(range < 0) {\r
+ int i;\r
+ for (i = 1; ; i++) {\r
+ int bits = 1 << (8 * i);\r
+ if (number <= bits)\r
+ break;\r
+ }\r
+ bytes = i;\r
+ assert(i <= 4);\r
+ }\r
+ if(range <= 255) {\r
+ int i;\r
+ for (i = 1; i <= 8; i++) {\r
+ int bits = 1 << i;\r
+ if (range <= bits)\r
+ break;\r
+ }\r
+ return per_put_few_bits(po, number, i);\r
+ } else if(range == 256) {\r
+ bytes = 1;\r
+ } else if(range <= 65536) {\r
+ bytes = 2;\r
+ } else { /* Ranges > 64K */\r
+ int i;\r
+ for (i = 1; ; i++) {\r
+ int bits = 1 << (8 * i);\r
+ if (range <= bits)\r
+ break;\r
+ }\r
+ assert(i <= 4);\r
+ bytes = i;\r
+ }\r
+ if(aper_put_align(po) < 0) /* Aligning on octet */\r
+ return -1;\r
+/* if(per_put_few_bits(po, bytes, 8))\r
+ return -1;\r
+*/\r
+ return per_put_few_bits(po, number, 8 * bytes);\r
+}\r
Code Review / ric-app / kpimon.git / blobdiff