moved out common bit manipulation code
diff --git a/skeletons/Makefile.am b/skeletons/Makefile.am
index dedd0c6..1af93c2 100644
--- a/skeletons/Makefile.am
+++ b/skeletons/Makefile.am
@@ -59,6 +59,7 @@
asn_application.h asn_codecs.h \
asn_codecs_prim.c asn_codecs_prim.h \
asn_internal.h asn_system.h \
+ asn_bit_data.c asn_bit_data.h \
ber_decoder.c ber_decoder.h \
ber_tlv_length.c ber_tlv_length.h \
ber_tlv_tag.c ber_tlv_tag.h \
diff --git a/skeletons/OPEN_TYPE_oer.c b/skeletons/OPEN_TYPE_oer.c
new file mode 100644
index 0000000..3de9574
--- /dev/null
+++ b/skeletons/OPEN_TYPE_oer.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <OPEN_TYPE.h>
+#include <constr_CHOICE.h>
+#include <oer_opentype.h>
+#include <errno.h>
+
+asn_dec_rval_t
+OPEN_TYPE_oer_get(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+ void *sptr, asn_TYPE_member_t *elm, const void *ptr,
+ size_t size) {
+ asn_type_selector_result_t selected;
+ void *memb_ptr; /* Pointer to the member */
+ void **memb_ptr2; /* Pointer to that pointer */
+ void *inner_value;
+ asn_dec_rval_t rv;
+ size_t ot_ret;
+
+ if(!(elm->flags & ATF_OPEN_TYPE) || !elm->type_selector) {
+ ASN__DECODE_FAILED;
+ }
+
+ selected = elm->type_selector(td, sptr);
+ if(!selected.presence_index) {
+ ASN__DECODE_FAILED;
+ }
+
+ /* Fetch the pointer to this member */
+ if(elm->flags & ATF_POINTER) {
+ memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+ } else {
+ memb_ptr = (char *)sptr + elm->memb_offset;
+ memb_ptr2 = &memb_ptr;
+ }
+ if(*memb_ptr2 != NULL) {
+ /* Make sure we reset the structure first before encoding */
+ if(CHOICE_variant_set_presence(selected.type_descriptor, *memb_ptr2, 0)
+ != 0) {
+ ASN__DECODE_FAILED;
+ }
+ }
+
+ inner_value =
+ (char *)*memb_ptr2
+ + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+ ot_ret = oer_open_type_get(opt_codec_ctx, selected.type_descriptor, NULL,
+ &inner_value, ptr, size);
+ switch(ot_ret) {
+ default:
+ if(CHOICE_variant_set_presence(selected.type_descriptor, *memb_ptr2,
+ selected.presence_index)
+ == 0) {
+ rv.code = RC_OK;
+ rv.consumed = ot_ret;
+ return rv;
+ } else {
+ /* Oh, now a full-blown failure failure */
+ }
+ /* Fall through */
+ case -1:
+ rv.code = RC_FAIL;
+ rv.consumed = 0;
+ break;
+ case 0:
+ rv.code = RC_WMORE;
+ rv.consumed = 0;
+ break;
+ }
+
+ if(*memb_ptr2) {
+ asn_CHOICE_specifics_t *specs = selected.type_descriptor->specifics;
+ if(elm->flags & ATF_POINTER) {
+ ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+ *memb_ptr2 = NULL;
+ } else {
+ ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
+ inner_value);
+ memset(*memb_ptr2, 0, specs->struct_size);
+ }
+ }
+ return rv;
+}
diff --git a/skeletons/asn_bit_data.c b/skeletons/asn_bit_data.c
new file mode 100644
index 0000000..2852c2d
--- /dev/null
+++ b/skeletons/asn_bit_data.c
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 2005-2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_system.h>
+#include <asn_internal.h>
+#include <asn_bit_data.h>
+
+char *
+asn_bit_data_string(asn_bit_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
+asn_get_undo(asn_bit_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
+asn_get_few_bits(asn_bit_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, vhead;
+ if(!pd->refill || nbits > 31) return -1;
+ /* Accumulate unused bytes before refill */
+ ASN_DEBUG("Obtain the rest %d bits (want %d)",
+ (int)nleft, (int)nbits);
+ tailv = asn_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 = asn_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_bit_data_t tpd = *pd;
+ /* Here are we with our 31-bits limit plus 1..7 bits offset. */
+ asn_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 */
+ accum = asn_get_few_bits(&tpd, nbits - 24) << 24;
+ accum |= asn_get_few_bits(&tpd, 24);
+ } else {
+ asn_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]",
+ (int)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
+asn_get_many_bits(asn_bit_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 = asn_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 = asn_get_few_bits(pd, 24);
+ if(value < 0) return -1;
+ *(dst++) = value >> 16;
+ *(dst++) = value >> 8;
+ *(dst++) = value;
+ nbits -= 24;
+ } else {
+ value = asn_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;
+}
+
+/*
+ * Put a small number of bits (<= 31).
+ */
+int
+asn_put_few_bits(asn_bit_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->output(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(asn_put_few_bits(po, bits >> (obits - 24), 24)) return -1;
+ if(asn_put_few_bits(po, bits, obits - 24)) return -1;
+ }
+
+ ASN_DEBUG("[PER out %u/%x => %02x buf+%ld]",
+ (int)bits, (int)bits, buf[0],
+ (long)(po->buffer - po->tmpspace));
+
+ return 0;
+}
+
+
+/*
+ * Output a large number of bits.
+ */
+int
+asn_put_many_bits(asn_bit_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(asn_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(asn_put_few_bits(po, value, nbits))
+ return -1;
+ break;
+ }
+ }
+
+ return 0;
+}
+
+
+int
+asn_put_aligned_flush(asn_bit_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->output(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;
+ }
+}
+
diff --git a/skeletons/asn_bit_data.h b/skeletons/asn_bit_data.h
new file mode 100644
index 0000000..750522b
--- /dev/null
+++ b/skeletons/asn_bit_data.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2005-2017 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_BIT_DATA
+#define ASN_BIT_DATA
+
+#include <asn_system.h> /* Platform-specific types */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * This structure describes a position inside an incoming PER bit stream.
+ */
+typedef struct asn_bit_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_bit_data_s *);
+ void *refill_key;
+} asn_bit_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 asn_get_few_bits(asn_bit_data_t *, int get_nbits);
+
+/* Undo the immediately preceeding "get_few_bits" operation */
+void asn_get_undo(asn_bit_data_t *, 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 asn_get_many_bits(asn_bit_data_t *, uint8_t *dst, int right_align,
+ int get_nbits);
+
+/* Non-thread-safe debugging function, don't use it */
+char *asn_bit_data_string(asn_bit_data_t *);
+
+/*
+ * This structure supports forming bit output.
+ */
+typedef struct asn_bit_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 (*output)(const void *data, size_t size, void *op_key);
+ void *op_key; /* Key for (output) data callback */
+ size_t flushed_bytes; /* Bytes already flushed through (output) */
+} asn_bit_outp_t;
+
+/* Output a small number of bits (<= 31) */
+int asn_put_few_bits(asn_bit_outp_t *, uint32_t bits, int obits);
+
+/* Output a large number of bits */
+int asn_put_many_bits(asn_bit_outp_t *, 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 asn_put_aligned_flush(asn_bit_outp_t *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ASN_BIT_DATA */
diff --git a/skeletons/constr_SEQUENCE_oer.c b/skeletons/constr_SEQUENCE_oer.c
index 91e4ac3..fa3ca31 100644
--- a/skeletons/constr_SEQUENCE_oer.c
+++ b/skeletons/constr_SEQUENCE_oer.c
@@ -98,7 +98,7 @@
*/
ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
if(ctx->ptr == 0) {
- ctx->ptr = CALLOC(1, sizeof(asn_per_data_t));
+ ctx->ptr = CALLOC(1, sizeof(asn_bit_data_t));
if(!ctx->ptr) {
RETURN(RC_FAIL);
}
@@ -112,7 +112,7 @@
/*
* Fetch preamble.
*/
- asn_per_data_t *preamble = ctx->ptr;
+ asn_bit_data_t *preamble = ctx->ptr;
int has_extensions_bit = (specs->ext_before >= 0);
size_t preamble_bits = (has_extensions_bit + specs->roms_count);
size_t preamble_bytes = ((7 + preamble_bits) >> 3);
@@ -143,7 +143,7 @@
/* FALL THROUGH */
case 1: {
/* Decode components of the extension root */
- asn_per_data_t *preamble = ctx->ptr;
+ asn_bit_data_t *preamble = ctx->ptr;
size_t edx;
ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 1", td->name);
@@ -165,7 +165,7 @@
}
if(elm->optional) {
- int32_t present = per_get_few_bits(preamble, 1);
+ int32_t present = asn_get_few_bits(preamble, 1);
if(present < 0) {
ASN_DEBUG("Presence map ended prematurely: %d", present);
RETURN(RC_FAIL);
@@ -226,8 +226,8 @@
/* FALL THROUGH */
case 2: {
/* Cleanup preamble. */
- asn_per_data_t *preamble = ctx->ptr;
- asn_per_data_t *extadds;
+ asn_bit_data_t *preamble = ctx->ptr;
+ asn_bit_data_t *extadds;
int has_extensions_bit = (specs->ext_before >= 0);
int extensions_present =
has_extensions_bit && (((const uint8_t *)preamble->buffer)[0] & 0x80);
@@ -303,12 +303,12 @@
case 3:
ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 3", td->name);
for(; ctx->step < specs->ext_before - 1; ctx->step++) {
- asn_per_data_t *extadds = ctx->ptr;
+ asn_bit_data_t *extadds = ctx->ptr;
size_t edx = ctx->step;
asn_TYPE_member_t *elm = &td->elements[edx];
void **memb_ptr2 = element_ptrptr(st, elm);
- switch(per_get_few_bits(extadds, 1)) {
+ switch(asn_get_few_bits(extadds, 1)) {
case -1:
/*
* Not every one of our extensions is known to the remote side.
@@ -332,7 +332,7 @@
RETURN(RC_FAIL);
} else {
/* Roll back open type parsing */
- per_get_undo(extadds, 1);
+ asn_get_undo(extadds, 1);
ASN_STRUCT_FREE(*elm->type, *memb_ptr2);
*memb_ptr2 = NULL;
RETURN(RC_WMORE);
@@ -350,8 +350,8 @@
ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 4", td->name);
/* Read in the rest of Open Types while ignoring them */
for(;;) {
- asn_per_data_t *extadds = ctx->ptr;
- switch(per_get_few_bits(extadds, 1)) {
+ asn_bit_data_t *extadds = ctx->ptr;
+ switch(asn_get_few_bits(extadds, 1)) {
case 0:
continue;
case 1: {
@@ -361,7 +361,7 @@
} else if(skipped < 0) {
RETURN(RC_FAIL);
} else {
- per_get_undo(extadds, 1);
+ asn_get_undo(extadds, 1);
RETURN(RC_WMORE);
}
continue;
@@ -397,10 +397,10 @@
(void)constraints;
if(preamble_bits) {
- asn_per_outp_t preamble;
+ asn_bit_outp_t preamble;
memset(&preamble, 0, sizeof(preamble));
- preamble.outper = cb;
+ preamble.output = cb;
preamble.op_key = app_key;
if(has_extensions_bit) {
@@ -412,7 +412,7 @@
break;
}
}
- ret = per_put_few_bits(&preamble, has_extensions, 1);
+ ret = asn_put_few_bits(&preamble, has_extensions, 1);
assert(ret == 0);
if(ret < 0) {
ASN__ENCODE_FAILED;
@@ -430,7 +430,7 @@
if(elm->optional) {
uint32_t has_component = (element_ptr(sptr, elm) != NULL);
- ret = per_put_few_bits(&preamble, has_component, 1);
+ ret = asn_put_few_bits(&preamble, has_component, 1);
if(ret < 0) {
ASN__ENCODE_FAILED;
}
@@ -438,7 +438,7 @@
}
}
- per_put_aligned_flush(&preamble);
+ asn_put_aligned_flush(&preamble);
computed_size += preamble.flushed_bytes;
} /* if(preamble_bits) */
@@ -477,7 +477,7 @@
# X.696 (08/2015) #16.4.
*/
if(has_extensions) {
- asn_per_outp_t extadds;
+ asn_bit_outp_t extadds;
/* Special case allowing us to use exactly one byte for #8.6 */
size_t aoms_length_bits = specs->aoms_count;
@@ -487,15 +487,15 @@
assert(1 + aoms_length_bytes <= 127);
memset(&extadds, 0, sizeof(extadds));
- extadds.outper = cb;
+ extadds.output = cb;
extadds.op_key = app_key;
/* #8.6 length determinant */
- ret = per_put_few_bits(&extadds, (1 + aoms_length_bytes), 8);
+ ret = asn_put_few_bits(&extadds, (1 + aoms_length_bytes), 8);
if(ret < 0) ASN__ENCODE_FAILED;
/* Number of unused bytes, #16.4.2 */
- ret = per_put_few_bits(&extadds, unused_bits, 8);
+ ret = asn_put_few_bits(&extadds, unused_bits, 8);
if(ret < 0) ASN__ENCODE_FAILED;
/* Encode presence bitmap #16.4.3 */
@@ -503,11 +503,11 @@
edx++) {
asn_TYPE_member_t *elm = &td->elements[edx];
void *memb_ptr = element_ptr(sptr, elm);
- ret |= per_put_few_bits(&extadds, memb_ptr ? 1 : 0, 1);
+ ret |= asn_put_few_bits(&extadds, memb_ptr ? 1 : 0, 1);
}
if(ret < 0) ASN__ENCODE_FAILED;
- per_put_aligned_flush(&extadds);
+ asn_put_aligned_flush(&extadds);
computed_size += extadds.flushed_bytes;
/* Now, encode extensions */
diff --git a/skeletons/file-dependencies b/skeletons/file-dependencies
index 10022f5..1a2c79b 100644
--- a/skeletons/file-dependencies
+++ b/skeletons/file-dependencies
@@ -46,6 +46,7 @@
asn_system.h # Platform-dependent types
asn_codecs.h # Return types of encoders and decoders
asn_internal.h # Internal stuff
+asn_bit_data.h asn_bit_data.c # Bit streaming support
OCTET_STRING.h OCTET_STRING.c # This one is used too widely
BIT_STRING.h BIT_STRING.c # This one is necessary for the above one
asn_codecs_prim.c asn_codecs_prim.h # enc/decoders for primitive types
diff --git a/skeletons/per_encoder.c b/skeletons/per_encoder.c
index 5e3a77a..adee4e6 100644
--- a/skeletons/per_encoder.c
+++ b/skeletons/per_encoder.c
@@ -114,7 +114,7 @@
buf++;
}
- return po->outper(po->tmpspace, buf - po->tmpspace, po->op_key);
+ return po->output(po->tmpspace, buf - po->tmpspace, po->op_key);
}
static asn_enc_rval_t
@@ -133,7 +133,7 @@
po.buffer = po.tmpspace;
po.nboff = 0;
po.nbits = 8 * sizeof(po.tmpspace);
- po.outper = cb;
+ po.output = cb;
po.op_key = app_key;
po.flushed_bytes = 0;
diff --git a/skeletons/per_opentype.c b/skeletons/per_opentype.c
index 2ccaf39..8ed0933 100644
--- a/skeletons/per_opentype.c
+++ b/skeletons/per_opentype.c
@@ -144,7 +144,7 @@
ASN__STACK_OVERFLOW_CHECK(ctx);
ASN_DEBUG("Getting open type %s from %s", td->name,
- per_data_string(pd));
+ asn_bit_data_string(pd));
arg.oldpd = *pd;
arg.unclaimed = 0;
arg.ot_moved = 0;
@@ -172,8 +172,8 @@
}
ASN_DEBUG("OpenType %s pd%s old%s unclaimed=%d, repeat=%d", td->name,
- per_data_string(pd),
- per_data_string(&arg.oldpd),
+ asn_bit_data_string(pd),
+ asn_bit_data_string(&arg.oldpd),
(int)arg.unclaimed, (int)arg.repeat);
padding = pd->moved % 8;
@@ -204,7 +204,7 @@
}
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));
+ asn_bit_data_string(pd), asn_bit_data_string(&arg.oldpd));
if(1) {
UPDRESTOREPD;
ASN__DECODE_FAILED;
@@ -354,7 +354,7 @@
pd->buffer = oldpd->buffer;
pd->nboff = oldpd->nboff;
ASN_DEBUG("Refilled pd%s old%s",
- per_data_string(pd), per_data_string(oldpd));
+ asn_bit_data_string(pd), asn_bit_data_string(oldpd));
return 0;
}
diff --git a/skeletons/per_support.c b/skeletons/per_support.c
index 9153e58..f2c9013 100644
--- a/skeletons/per_support.c
+++ b/skeletons/per_support.c
@@ -7,159 +7,6 @@
#include <asn_internal.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, vhead;
- if(!pd->refill || nbits > 31) return -1;
- /* Accumulate unused bytes before refill */
- ASN_DEBUG("Obtain the rest %d bits (want %d)",
- (int)nleft, (int)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 */
- accum = per_get_few_bits(&tpd, nbits - 24) << 24;
- 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]",
- (int)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.
@@ -322,151 +169,6 @@
}
}
-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(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],
- (long)(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.
*/
diff --git a/skeletons/per_support.h b/skeletons/per_support.h
index 4dcc9e6..9b564a2 100644
--- a/skeletons/per_support.h
+++ b/skeletons/per_support.h
@@ -7,6 +7,7 @@
#define _PER_SUPPORT_H_
#include <asn_system.h> /* Platform-specific types */
+#include <asn_bit_data.h>
#ifdef __cplusplus
extern "C" {
@@ -34,35 +35,12 @@
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 preceeding "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);
+/* Temporary compatibility layer. Will get removed. */
+typedef struct asn_bit_data_s asn_per_data_t;
+#define per_get_few_bits(data, bits) asn_get_few_bits(data, bits)
+#define per_get_undo(data, bits) asn_get_undo(data, bits)
+#define per_get_many_bits(data, dst, align, bits) \
+ asn_get_many_bits(data, dst, align, bits)
/*
* Get the length "n" from the Unaligned PER stream.
@@ -84,34 +62,12 @@
/* 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);
+/* Temporary compatibility layer. Will get removed. */
+typedef struct asn_bit_outp_s asn_per_outp_t;
+#define per_put_few_bits(out, bits, obits) asn_put_few_bits(out, bits, obits)
+#define per_put_many_bits(out, src, nbits) asn_put_many_bits(out, src, nbits)
+#define per_put_aligned_flush(out) asn_put_aligned_flush(out)
/* X.691-2008/11, #11.5 */
int uper_put_constrained_whole_number_s(asn_per_outp_t *po, long v, int nbits);