mirror of https://github.com/gnss-sdr/gnss-sdr
2310 lines
73 KiB
C
2310 lines
73 KiB
C
/*-
|
|
* Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
|
|
* All rights reserved.
|
|
* Redistribution and modifications are permitted subject to BSD license.
|
|
*/
|
|
#include <BIT_STRING.h> /* for .bits_unused member */
|
|
#include <OCTET_STRING.h>
|
|
#include <asn_internal.h>
|
|
#include <errno.h>
|
|
|
|
/*
|
|
* OCTET STRING basic type description.
|
|
*/
|
|
static ber_tlv_tag_t asn_DEF_OCTET_STRING_tags[] = {
|
|
(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))};
|
|
static asn_OCTET_STRING_specifics_t asn_DEF_OCTET_STRING_specs = {
|
|
sizeof(OCTET_STRING_t), offsetof(OCTET_STRING_t, _asn_ctx), ASN_OSUBV_STR};
|
|
static asn_per_constraints_t ASN_DEF_OCTET_STRING_CONSTRAINTS = {
|
|
{APC_CONSTRAINED, 8, 8, 0, 255},
|
|
{APC_SEMI_CONSTRAINED, -1, -1, 0, 0},
|
|
0,
|
|
0};
|
|
asn_TYPE_descriptor_t asn_DEF_OCTET_STRING = {
|
|
"OCTET STRING", /* Canonical name */
|
|
"OCTET_STRING", /* XML tag name */
|
|
OCTET_STRING_free,
|
|
OCTET_STRING_print, /* non-ascii stuff, generally */
|
|
asn_generic_no_constraint,
|
|
OCTET_STRING_decode_ber,
|
|
OCTET_STRING_encode_der,
|
|
OCTET_STRING_decode_xer_hex,
|
|
OCTET_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_OCTET_STRING_tags,
|
|
sizeof(asn_DEF_OCTET_STRING_tags) / sizeof(asn_DEF_OCTET_STRING_tags[0]),
|
|
asn_DEF_OCTET_STRING_tags, /* Same as above */
|
|
sizeof(asn_DEF_OCTET_STRING_tags) / sizeof(asn_DEF_OCTET_STRING_tags[0]),
|
|
0, /* No PER visible constraints */
|
|
0,
|
|
0, /* No members */
|
|
&asn_DEF_OCTET_STRING_specs};
|
|
|
|
#undef _CH_PHASE
|
|
#undef NEXT_PHASE
|
|
#undef PREV_PHASE
|
|
#define _CH_PHASE(ctx, inc) \
|
|
do \
|
|
{ \
|
|
if ((ctx)->phase == 0) (ctx)->context = 0; \
|
|
(ctx)->phase += (inc); \
|
|
} \
|
|
while (0)
|
|
#define NEXT_PHASE(ctx) _CH_PHASE(ctx, +1)
|
|
#define PREV_PHASE(ctx) _CH_PHASE(ctx, -1)
|
|
|
|
#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 \
|
|
{ \
|
|
asn_dec_rval_t tmprval; \
|
|
tmprval.code = _code; \
|
|
tmprval.consumed = consumed_myself; \
|
|
return tmprval; \
|
|
} \
|
|
while (0)
|
|
|
|
#undef APPEND
|
|
#define APPEND(bufptr, bufsize) \
|
|
do \
|
|
{ \
|
|
size_t _bs = (bufsize); /* Append size */ \
|
|
size_t _ns = ctx->context; /* Allocated now */ \
|
|
size_t _es = st->size + _bs; /* Expected size */ \
|
|
/* int is really a typeof(st->size): */ \
|
|
if ((int)_es < 0) RETURN(RC_FAIL); \
|
|
if (_ns <= _es) \
|
|
{ \
|
|
void *ptr; \
|
|
/* Be nice and round to the memory allocator */ \
|
|
do \
|
|
{ \
|
|
_ns = _ns ? _ns << 1 : 16; \
|
|
} \
|
|
while (_ns <= _es); \
|
|
/* int is really a typeof(st->size): */ \
|
|
if ((int)_ns < 0) RETURN(RC_FAIL); \
|
|
ptr = REALLOC(st->buf, _ns); \
|
|
if (ptr) \
|
|
{ \
|
|
st->buf = (uint8_t *)ptr; \
|
|
ctx->context = _ns; \
|
|
} \
|
|
else \
|
|
{ \
|
|
RETURN(RC_FAIL); \
|
|
} \
|
|
ASN_DEBUG("Reallocating into %ld", (long)_ns); \
|
|
} \
|
|
memcpy(st->buf + st->size, bufptr, _bs); \
|
|
/* Convenient nul-termination */ \
|
|
st->buf[_es] = '\0'; \
|
|
st->size = _es; \
|
|
} \
|
|
while (0)
|
|
|
|
/*
|
|
* The main reason why ASN.1 is still alive is that too much time and effort
|
|
* is necessary for learning it more or less adequately, thus creating a gut
|
|
* necessity to demonstrate that acquired skill everywhere afterwards.
|
|
* No, I am not going to explain what the following stuff is.
|
|
*/
|
|
struct _stack_el
|
|
{
|
|
ber_tlv_len_t left; /* What's left to read (or -1) */
|
|
ber_tlv_len_t got; /* What was actually processed */
|
|
int cont_level; /* Depth of subcontainment */
|
|
int want_nulls; /* Want null "end of content" octets? */
|
|
int bits_chopped; /* Flag in BIT STRING mode */
|
|
ber_tlv_tag_t tag; /* For debugging purposes */
|
|
struct _stack_el *prev;
|
|
struct _stack_el *next;
|
|
};
|
|
struct _stack
|
|
{
|
|
struct _stack_el *tail;
|
|
struct _stack_el *cur_ptr;
|
|
};
|
|
|
|
static struct _stack_el *OS__add_stack_el(struct _stack *st)
|
|
{
|
|
struct _stack_el *nel;
|
|
|
|
/*
|
|
* Reuse the old stack frame or allocate a new one.
|
|
*/
|
|
if (st->cur_ptr && st->cur_ptr->next)
|
|
{
|
|
nel = st->cur_ptr->next;
|
|
nel->bits_chopped = 0;
|
|
nel->got = 0;
|
|
/* Retain the nel->cont_level, it's correct. */
|
|
}
|
|
else
|
|
{
|
|
nel = (struct _stack_el *)CALLOC(1, sizeof(struct _stack_el));
|
|
if (nel == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
if (st->tail)
|
|
{
|
|
/* Increase a subcontainment depth */
|
|
nel->cont_level = st->tail->cont_level + 1;
|
|
st->tail->next = nel;
|
|
}
|
|
nel->prev = st->tail;
|
|
st->tail = nel;
|
|
}
|
|
|
|
st->cur_ptr = nel;
|
|
|
|
return nel;
|
|
}
|
|
|
|
static struct _stack *_new_stack()
|
|
{
|
|
return (struct _stack *)CALLOC(1, sizeof(struct _stack));
|
|
}
|
|
|
|
/*
|
|
* Decode OCTET STRING type.
|
|
*/
|
|
asn_dec_rval_t OCTET_STRING_decode_ber(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_OCTET_STRING_specifics_t *specs =
|
|
td->specifics ? (asn_OCTET_STRING_specifics_t *)td->specifics
|
|
: &asn_DEF_OCTET_STRING_specs;
|
|
BIT_STRING_t *st = (BIT_STRING_t *)*sptr;
|
|
asn_dec_rval_t rval;
|
|
asn_struct_ctx_t *ctx;
|
|
ssize_t consumed_myself = 0;
|
|
struct _stack *stck; /* Expectations stack structure */
|
|
struct _stack_el *sel = 0; /* Stack element */
|
|
int tlv_constr;
|
|
enum asn_OS_Subvariant type_variant = specs->subvariant;
|
|
|
|
ASN_DEBUG(
|
|
"Decoding %s as %s (frame %ld)", td->name,
|
|
(type_variant == ASN_OSUBV_STR) ? "OCTET STRING" : "OS-SpecialCase",
|
|
(long)size);
|
|
|
|
/*
|
|
* Create the string if does not exist.
|
|
*/
|
|
if (st == NULL)
|
|
{
|
|
st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
|
|
if (st == NULL)
|
|
{
|
|
RETURN(RC_FAIL);
|
|
}
|
|
}
|
|
|
|
/* Restore parsing context */
|
|
ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
|
|
|
|
switch (ctx->phase)
|
|
{
|
|
case 0:
|
|
/*
|
|
* Check tags.
|
|
*/
|
|
rval = ber_check_tags(opt_codec_ctx, td, ctx, buf_ptr, size,
|
|
tag_mode, -1, &ctx->left, &tlv_constr);
|
|
if (rval.code != RC_OK)
|
|
{
|
|
return rval;
|
|
}
|
|
|
|
if (tlv_constr)
|
|
{
|
|
/*
|
|
* Complex operation, requires stack of expectations.
|
|
*/
|
|
ctx->ptr = _new_stack();
|
|
if (ctx->ptr)
|
|
{
|
|
stck = (struct _stack *)ctx->ptr;
|
|
}
|
|
else
|
|
{
|
|
RETURN(RC_FAIL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Jump into stackless primitive decoding.
|
|
*/
|
|
_CH_PHASE(ctx, 3);
|
|
if (type_variant == ASN_OSUBV_ANY && tag_mode != 1)
|
|
{
|
|
APPEND(buf_ptr, rval.consumed);
|
|
}
|
|
ADVANCE(rval.consumed);
|
|
goto phase3;
|
|
}
|
|
|
|
NEXT_PHASE(ctx);
|
|
/* Fall through */
|
|
case 1:
|
|
phase1:
|
|
/*
|
|
* Fill the stack with expectations.
|
|
*/
|
|
stck = (struct _stack *)ctx->ptr;
|
|
sel = stck->cur_ptr;
|
|
do
|
|
{
|
|
ber_tlv_tag_t tlv_tag;
|
|
ber_tlv_len_t tlv_len;
|
|
ber_tlv_tag_t expected_tag;
|
|
ssize_t tl;
|
|
ssize_t ll;
|
|
ssize_t tlvl;
|
|
/* This one works even if (sel->left == -1) */
|
|
ssize_t Left =
|
|
((!sel || (size_t)sel->left >= size) ? (ssize_t)size
|
|
: sel->left);
|
|
|
|
ASN_DEBUG("%p, s->l=%ld, s->wn=%ld, s->g=%ld\n", sel,
|
|
(sel ? sel->left : 0),
|
|
(long)(sel ? sel->want_nulls : 0),
|
|
(sel ? sel->got : 0));
|
|
if (sel && sel->left <= 0 && sel->want_nulls == 0)
|
|
{
|
|
if (sel->prev)
|
|
{
|
|
struct _stack_el *prev = sel->prev;
|
|
if (prev->left != -1)
|
|
{
|
|
if (prev->left < sel->got)
|
|
{
|
|
RETURN(RC_FAIL);
|
|
}
|
|
prev->left -= sel->got;
|
|
}
|
|
prev->got += sel->got;
|
|
sel = stck->cur_ptr = prev;
|
|
if (!sel)
|
|
{
|
|
break;
|
|
}
|
|
tlv_constr = 1;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
sel = stck->cur_ptr = 0;
|
|
break; /* Nothing to wait */
|
|
}
|
|
}
|
|
|
|
tl = ber_fetch_tag(buf_ptr, Left, &tlv_tag);
|
|
ASN_DEBUG(
|
|
"fetch tag(size=%ld,L=%ld), %sstack, left=%ld, "
|
|
"wn=%ld, "
|
|
"tl=%ld",
|
|
(long)size, (long)Left, sel ? "" : "!",
|
|
(sel ? sel->left : 0),
|
|
(long)(sel ? sel->want_nulls : 0), (long)tl);
|
|
switch (tl)
|
|
{
|
|
case -1:
|
|
RETURN(RC_FAIL);
|
|
case 0:
|
|
RETURN(RC_WMORE);
|
|
}
|
|
|
|
tlv_constr = BER_TLV_CONSTRUCTED(buf_ptr);
|
|
|
|
ll = ber_fetch_length(tlv_constr,
|
|
(const char *)buf_ptr + tl,
|
|
Left - tl, &tlv_len);
|
|
ASN_DEBUG(
|
|
"Got tag=%s, tc=%d, left=%ld, tl=%ld, len=%ld, "
|
|
"ll=%ld",
|
|
ber_tlv_tag_string(tlv_tag), tlv_constr, (long)Left,
|
|
(long)tl, (long)tlv_len, (long)ll);
|
|
switch (ll)
|
|
{
|
|
case -1:
|
|
RETURN(RC_FAIL);
|
|
case 0:
|
|
RETURN(RC_WMORE);
|
|
}
|
|
|
|
if (sel && sel->want_nulls &&
|
|
((const uint8_t *)buf_ptr)[0] == 0 &&
|
|
((const uint8_t *)buf_ptr)[1] == 0)
|
|
{
|
|
ASN_DEBUG("Eat EOC; wn=%d--", sel->want_nulls);
|
|
|
|
if (type_variant == ASN_OSUBV_ANY &&
|
|
(tag_mode != 1 || sel->cont_level))
|
|
{
|
|
APPEND("\0\0", 2);
|
|
}
|
|
|
|
ADVANCE(2);
|
|
sel->got += 2;
|
|
if (sel->left != -1)
|
|
{
|
|
sel->left -=
|
|
2; /* assert(sel->left >= 2) */
|
|
}
|
|
|
|
sel->want_nulls--;
|
|
if (sel->want_nulls == 0)
|
|
{
|
|
/* Move to the next expectation */
|
|
sel->left = 0;
|
|
tlv_constr = 1;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Set up expected tags,
|
|
* depending on ASN.1 type being decoded.
|
|
*/
|
|
switch (type_variant)
|
|
{
|
|
case ASN_OSUBV_BIT:
|
|
/* X.690: 8.6.4.1, NOTE 2 */
|
|
/* Fall through */
|
|
case ASN_OSUBV_STR:
|
|
default:
|
|
if (sel)
|
|
{
|
|
int level = sel->cont_level;
|
|
if (level < td->all_tags_count)
|
|
{
|
|
expected_tag =
|
|
td->all_tags[level];
|
|
break;
|
|
}
|
|
else if (td->all_tags_count)
|
|
{
|
|
expected_tag =
|
|
td->all_tags
|
|
[td->all_tags_count -
|
|
1];
|
|
break;
|
|
}
|
|
/* else, Fall through */
|
|
}
|
|
/* Fall through */
|
|
case ASN_OSUBV_ANY:
|
|
expected_tag = tlv_tag;
|
|
break;
|
|
}
|
|
|
|
if (tlv_tag != expected_tag)
|
|
{
|
|
char buf[2][32];
|
|
ber_tlv_tag_snprint(tlv_tag, buf[0],
|
|
sizeof(buf[0]));
|
|
ber_tlv_tag_snprint(
|
|
td->tags[td->tags_count - 1], buf[1],
|
|
sizeof(buf[1]));
|
|
ASN_DEBUG(
|
|
"Tag does not match expectation: %s != %s",
|
|
buf[0], buf[1]);
|
|
RETURN(RC_FAIL);
|
|
}
|
|
|
|
tlvl =
|
|
tl + ll; /* Combined length of T and L encoding */
|
|
if ((tlv_len + tlvl) < 0)
|
|
{
|
|
/* tlv_len value is too big */
|
|
ASN_DEBUG(
|
|
"TLV encoding + length (%ld) is too big",
|
|
(long)tlv_len);
|
|
RETURN(RC_FAIL);
|
|
}
|
|
|
|
/*
|
|
* Append a new expectation.
|
|
*/
|
|
sel = OS__add_stack_el(stck);
|
|
if (!sel)
|
|
{
|
|
RETURN(RC_FAIL);
|
|
}
|
|
|
|
sel->tag = tlv_tag;
|
|
|
|
sel->want_nulls = (tlv_len == -1);
|
|
if (sel->prev && sel->prev->left != -1)
|
|
{
|
|
/* Check that the parent frame is big enough */
|
|
if (sel->prev->left <
|
|
tlvl + (tlv_len == -1 ? 0 : tlv_len))
|
|
{
|
|
RETURN(RC_FAIL);
|
|
}
|
|
if (tlv_len == -1)
|
|
{
|
|
sel->left = sel->prev->left - tlvl;
|
|
}
|
|
else
|
|
{
|
|
sel->left = tlv_len;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sel->left = tlv_len;
|
|
}
|
|
if (type_variant == ASN_OSUBV_ANY &&
|
|
(tag_mode != 1 || sel->cont_level))
|
|
{
|
|
APPEND(buf_ptr, tlvl);
|
|
}
|
|
sel->got += tlvl;
|
|
ADVANCE(tlvl);
|
|
|
|
ASN_DEBUG("+EXPECT2 got=%ld left=%ld, wn=%d, clvl=%d",
|
|
(long)sel->got, (long)sel->left,
|
|
sel->want_nulls, sel->cont_level);
|
|
}
|
|
while (tlv_constr);
|
|
if (sel == NULL)
|
|
{
|
|
/* Finished operation, "phase out" */
|
|
ASN_DEBUG("Phase out");
|
|
_CH_PHASE(ctx, +3);
|
|
break;
|
|
}
|
|
|
|
NEXT_PHASE(ctx);
|
|
/* Fall through */
|
|
case 2:
|
|
stck = (struct _stack *)ctx->ptr;
|
|
sel = stck->cur_ptr;
|
|
ASN_DEBUG("Phase 2: Need %ld bytes, size=%ld, alrg=%ld, wn=%d",
|
|
(long)sel->left, (long)size, (long)sel->got,
|
|
sel->want_nulls);
|
|
{
|
|
ber_tlv_len_t len;
|
|
|
|
assert(sel->left >= 0);
|
|
|
|
len = ((ber_tlv_len_t)size < sel->left)
|
|
? (ber_tlv_len_t)size
|
|
: sel->left;
|
|
if (len > 0)
|
|
{
|
|
if (type_variant == ASN_OSUBV_BIT &&
|
|
sel->bits_chopped == 0)
|
|
{
|
|
/* Put the unused-bits-octet away */
|
|
st->bits_unused = *(const uint8_t *)buf_ptr;
|
|
APPEND(((const char *)buf_ptr + 1),
|
|
(len - 1));
|
|
sel->bits_chopped = 1;
|
|
}
|
|
else
|
|
{
|
|
APPEND(buf_ptr, len);
|
|
}
|
|
ADVANCE(len);
|
|
sel->left -= len;
|
|
sel->got += len;
|
|
}
|
|
|
|
if (sel->left)
|
|
{
|
|
ASN_DEBUG("OS left %ld, size = %ld, wn=%d\n",
|
|
(long)sel->left, (long)size,
|
|
sel->want_nulls);
|
|
RETURN(RC_WMORE);
|
|
}
|
|
|
|
PREV_PHASE(ctx);
|
|
goto phase1;
|
|
}
|
|
break;
|
|
case 3:
|
|
phase3:
|
|
/*
|
|
* Primitive form, no stack required.
|
|
*/
|
|
assert(ctx->left >= 0);
|
|
|
|
if (size < (size_t)ctx->left)
|
|
{
|
|
if (!size)
|
|
{
|
|
RETURN(RC_WMORE);
|
|
}
|
|
if (type_variant == ASN_OSUBV_BIT && !ctx->context)
|
|
{
|
|
st->bits_unused = *(const uint8_t *)buf_ptr;
|
|
ctx->left--;
|
|
ADVANCE(1);
|
|
}
|
|
APPEND(buf_ptr, size);
|
|
assert(ctx->context > 0);
|
|
ctx->left -= size;
|
|
ADVANCE(size);
|
|
RETURN(RC_WMORE);
|
|
}
|
|
else
|
|
{
|
|
if (type_variant == ASN_OSUBV_BIT && !ctx->context &&
|
|
ctx->left)
|
|
{
|
|
st->bits_unused = *(const uint8_t *)buf_ptr;
|
|
ctx->left--;
|
|
ADVANCE(1);
|
|
}
|
|
APPEND(buf_ptr, ctx->left);
|
|
ADVANCE(ctx->left);
|
|
ctx->left = 0;
|
|
|
|
NEXT_PHASE(ctx);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (sel)
|
|
{
|
|
ASN_DEBUG("3sel p=%p, wn=%d, l=%ld, g=%ld, size=%ld", sel->prev,
|
|
sel->want_nulls, (long)sel->left, (long)sel->got,
|
|
(long)size);
|
|
if (sel->prev || sel->want_nulls > 1 || sel->left > 0)
|
|
{
|
|
RETURN(RC_WMORE);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* BIT STRING-specific processing.
|
|
*/
|
|
if (type_variant == ASN_OSUBV_BIT && st->size)
|
|
{
|
|
/* Finalize BIT STRING: zero out unused bits. */
|
|
st->buf[st->size - 1] &= 0xff << st->bits_unused;
|
|
}
|
|
|
|
ASN_DEBUG("Took %ld bytes to encode %s: [%s]:%ld", (long)consumed_myself,
|
|
td->name,
|
|
(type_variant == ASN_OSUBV_STR) ? (char *)st->buf : "<data>",
|
|
(long)st->size);
|
|
|
|
RETURN(RC_OK);
|
|
}
|
|
|
|
/*
|
|
* Encode OCTET STRING type using DER.
|
|
*/
|
|
asn_enc_rval_t OCTET_STRING_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 er;
|
|
asn_OCTET_STRING_specifics_t *specs =
|
|
td->specifics ? (asn_OCTET_STRING_specifics_t *)td->specifics
|
|
: &asn_DEF_OCTET_STRING_specs;
|
|
BIT_STRING_t *st = (BIT_STRING_t *)sptr;
|
|
enum asn_OS_Subvariant type_variant = specs->subvariant;
|
|
int fix_last_byte = 0;
|
|
|
|
ASN_DEBUG("%s %s as OCTET STRING", cb ? "Estimating" : "Encoding",
|
|
td->name);
|
|
|
|
/*
|
|
* Write tags.
|
|
*/
|
|
if (type_variant != ASN_OSUBV_ANY || tag_mode == 1)
|
|
{
|
|
er.encoded = der_write_tags(
|
|
td, (type_variant == ASN_OSUBV_BIT) + st->size, tag_mode,
|
|
type_variant == ASN_OSUBV_ANY, tag, cb, app_key);
|
|
if (er.encoded == -1)
|
|
{
|
|
er.failed_type = td;
|
|
er.structure_ptr = sptr;
|
|
return er;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Disallow: [<tag>] IMPLICIT ANY */
|
|
assert(type_variant != ASN_OSUBV_ANY || tag_mode != -1);
|
|
er.encoded = 0;
|
|
}
|
|
|
|
if (!cb)
|
|
{
|
|
er.encoded += (type_variant == ASN_OSUBV_BIT) + st->size;
|
|
_ASN_ENCODED_OK(er);
|
|
}
|
|
|
|
/*
|
|
* Prepare to deal with the last octet of BIT STRING.
|
|
*/
|
|
if (type_variant == ASN_OSUBV_BIT)
|
|
{
|
|
uint8_t b = st->bits_unused & 0x07;
|
|
if (b && st->size)
|
|
{
|
|
fix_last_byte = 1;
|
|
}
|
|
_ASN_CALLBACK(&b, 1);
|
|
er.encoded++;
|
|
}
|
|
|
|
/* Invoke callback for the main part of the buffer */
|
|
_ASN_CALLBACK(st->buf, st->size - fix_last_byte);
|
|
|
|
/* The last octet should be stripped off the unused bits */
|
|
if (fix_last_byte)
|
|
{
|
|
uint8_t b = st->buf[st->size - 1] & (0xff << st->bits_unused);
|
|
_ASN_CALLBACK(&b, 1);
|
|
}
|
|
|
|
er.encoded += st->size;
|
|
_ASN_ENCODED_OK(er);
|
|
cb_failed:
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
|
|
asn_enc_rval_t OCTET_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)
|
|
{
|
|
static const char *h2c = "0123456789ABCDEF";
|
|
const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
|
|
asn_enc_rval_t er;
|
|
char scratch[16 * 3 + 4];
|
|
char *p = scratch;
|
|
uint8_t *buf;
|
|
uint8_t *end;
|
|
size_t i;
|
|
|
|
if (!st || (!st->buf && st->size))
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
|
|
er.encoded = 0;
|
|
|
|
/*
|
|
* Dump the contents of the buffer in hexadecimal.
|
|
*/
|
|
buf = st->buf;
|
|
end = buf + st->size;
|
|
if (flags & XER_F_CANONICAL)
|
|
{
|
|
char *scend = scratch + (sizeof(scratch) - 2);
|
|
for (; buf < end; buf++)
|
|
{
|
|
if (p >= scend)
|
|
{
|
|
_ASN_CALLBACK(scratch, p - scratch);
|
|
er.encoded += p - scratch;
|
|
p = scratch;
|
|
}
|
|
*p++ = h2c[(*buf >> 4) & 0x0F];
|
|
*p++ = h2c[*buf & 0x0F];
|
|
}
|
|
|
|
_ASN_CALLBACK(scratch, p - scratch); /* Dump the rest */
|
|
er.encoded += p - scratch;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; buf < end; buf++, i++)
|
|
{
|
|
if (!(i % 16) && (i || st->size > 16))
|
|
{
|
|
_ASN_CALLBACK(scratch, p - scratch);
|
|
er.encoded += (p - scratch);
|
|
p = scratch;
|
|
_i_ASN_TEXT_INDENT(1, ilevel);
|
|
}
|
|
*p++ = h2c[(*buf >> 4) & 0x0F];
|
|
*p++ = h2c[*buf & 0x0F];
|
|
*p++ = 0x20;
|
|
}
|
|
if (p - scratch)
|
|
{
|
|
p--; /* Remove the tail space */
|
|
_ASN_CALLBACK(scratch, p - scratch); /* Dump the rest */
|
|
er.encoded += p - scratch;
|
|
if (st->size > 16)
|
|
{
|
|
_i_ASN_TEXT_INDENT(1, ilevel - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
_ASN_ENCODED_OK(er);
|
|
cb_failed:
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
|
|
static struct OCTET_STRING__xer_escape_table_s
|
|
{
|
|
char *string;
|
|
int size;
|
|
} OCTET_STRING__xer_escape_table[] = {
|
|
#define OSXET(s) \
|
|
{ \
|
|
s, sizeof(s) - 1 \
|
|
}
|
|
OSXET("\074\156\165\154\057\076"), /* <nul/> */
|
|
OSXET("\074\163\157\150\057\076"), /* <soh/> */
|
|
OSXET("\074\163\164\170\057\076"), /* <stx/> */
|
|
OSXET("\074\145\164\170\057\076"), /* <etx/> */
|
|
OSXET("\074\145\157\164\057\076"), /* <eot/> */
|
|
OSXET("\074\145\156\161\057\076"), /* <enq/> */
|
|
OSXET("\074\141\143\153\057\076"), /* <ack/> */
|
|
OSXET("\074\142\145\154\057\076"), /* <bel/> */
|
|
OSXET("\074\142\163\057\076"), /* <bs/> */
|
|
OSXET("\011"), /* \t */
|
|
OSXET("\012"), /* \n */
|
|
OSXET("\074\166\164\057\076"), /* <vt/> */
|
|
OSXET("\074\146\146\057\076"), /* <ff/> */
|
|
OSXET("\015"), /* \r */
|
|
OSXET("\074\163\157\057\076"), /* <so/> */
|
|
OSXET("\074\163\151\057\076"), /* <si/> */
|
|
OSXET("\074\144\154\145\057\076"), /* <dle/> */
|
|
OSXET("\074\144\143\061\057\076"), /* <de1/> */
|
|
OSXET("\074\144\143\062\057\076"), /* <de2/> */
|
|
OSXET("\074\144\143\063\057\076"), /* <de3/> */
|
|
OSXET("\074\144\143\064\057\076"), /* <de4/> */
|
|
OSXET("\074\156\141\153\057\076"), /* <nak/> */
|
|
OSXET("\074\163\171\156\057\076"), /* <syn/> */
|
|
OSXET("\074\145\164\142\057\076"), /* <etb/> */
|
|
OSXET("\074\143\141\156\057\076"), /* <can/> */
|
|
OSXET("\074\145\155\057\076"), /* <em/> */
|
|
OSXET("\074\163\165\142\057\076"), /* <sub/> */
|
|
OSXET("\074\145\163\143\057\076"), /* <esc/> */
|
|
OSXET("\074\151\163\064\057\076"), /* <is4/> */
|
|
OSXET("\074\151\163\063\057\076"), /* <is3/> */
|
|
OSXET("\074\151\163\062\057\076"), /* <is2/> */
|
|
OSXET("\074\151\163\061\057\076"), /* <is1/> */
|
|
{0, 0}, /* " " */
|
|
{0, 0}, /* ! */
|
|
{0, 0}, /* \" */
|
|
{0, 0}, /* # */
|
|
{0, 0}, /* $ */
|
|
{0, 0}, /* % */
|
|
OSXET("\046\141\155\160\073"), /* & */
|
|
{0, 0}, /* ' */
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0}, /* ()*+,-./ */
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0}, /* 01234567 */
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0},
|
|
{0, 0}, /* 89:; */
|
|
OSXET("\046\154\164\073"), /* < */
|
|
{0, 0}, /* = */
|
|
OSXET("\046\147\164\073"), /* > */
|
|
};
|
|
|
|
static int OS__check_escaped_control_char(const void *buf, int size)
|
|
{
|
|
size_t i;
|
|
/*
|
|
* Inefficient algorithm which translates the escape sequences
|
|
* defined above into characters. Returns -1 if not found.
|
|
* TODO: replace by a faster algorithm (bsearch(), hash or
|
|
* nested table lookups).
|
|
*/
|
|
for (i = 0; i < 32 /* Don't spend time on the bottom half */; i++)
|
|
{
|
|
struct OCTET_STRING__xer_escape_table_s *el;
|
|
el = &OCTET_STRING__xer_escape_table[i];
|
|
if (el->size == size && memcmp(buf, el->string, size) == 0)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int OCTET_STRING__handle_control_chars(void *struct_ptr,
|
|
const void *chunk_buf,
|
|
size_t chunk_size)
|
|
{
|
|
/*
|
|
* This might be one of the escape sequences
|
|
* for control characters. Check it out.
|
|
* #11.15.5
|
|
*/
|
|
int control_char = OS__check_escaped_control_char(chunk_buf, chunk_size);
|
|
if (control_char >= 0)
|
|
{
|
|
OCTET_STRING_t *st = (OCTET_STRING_t *)struct_ptr;
|
|
void *p = REALLOC(st->buf, st->size + 2);
|
|
if (p)
|
|
{
|
|
st->buf = (uint8_t *)p;
|
|
st->buf[st->size++] = control_char;
|
|
st->buf[st->size] = '\0'; /* nul-termination */
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return -1; /* No, it's not */
|
|
}
|
|
|
|
asn_enc_rval_t OCTET_STRING_encode_xer_utf8(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 OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
|
|
asn_enc_rval_t er;
|
|
uint8_t *buf;
|
|
uint8_t *end;
|
|
uint8_t *ss; /* Sequence start */
|
|
ssize_t encoded_len = 0;
|
|
|
|
(void)ilevel; /* Unused argument */
|
|
(void)flags; /* Unused argument */
|
|
|
|
if (!st || (!st->buf && st->size))
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
|
|
buf = st->buf;
|
|
end = buf + st->size;
|
|
for (ss = buf; buf < end; buf++)
|
|
{
|
|
unsigned int ch = *buf;
|
|
int s_len; /* Special encoding sequence length */
|
|
|
|
/*
|
|
* Escape certain characters: X.680/11.15
|
|
*/
|
|
if (ch < sizeof(OCTET_STRING__xer_escape_table) /
|
|
sizeof(OCTET_STRING__xer_escape_table[0]) &&
|
|
(s_len = OCTET_STRING__xer_escape_table[ch].size))
|
|
{
|
|
if (((buf - ss) && cb(ss, buf - ss, app_key) < 0) ||
|
|
cb(OCTET_STRING__xer_escape_table[ch].string, s_len,
|
|
app_key) < 0)
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
encoded_len += (buf - ss) + s_len;
|
|
ss = buf + 1;
|
|
}
|
|
}
|
|
|
|
encoded_len += (buf - ss);
|
|
if ((buf - ss) && cb(ss, buf - ss, app_key) < 0)
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
|
|
er.encoded = encoded_len;
|
|
_ASN_ENCODED_OK(er);
|
|
}
|
|
|
|
/*
|
|
* Convert from hexadecimal format (cstring): "AB CD EF"
|
|
*/
|
|
static ssize_t OCTET_STRING__convert_hexadecimal(void *sptr,
|
|
const void *chunk_buf,
|
|
size_t chunk_size,
|
|
int have_more)
|
|
{
|
|
OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
|
|
const char *chunk_stop = (const char *)chunk_buf;
|
|
const char *p = chunk_stop;
|
|
const char *pend = p + chunk_size;
|
|
unsigned int clv = 0;
|
|
int half = 0; /* Half bit */
|
|
uint8_t *buf;
|
|
|
|
/* Reallocate buffer according to high cap estimation */
|
|
ssize_t _ns = st->size + (chunk_size + 1) / 2;
|
|
void *nptr = REALLOC(st->buf, _ns + 1);
|
|
if (!nptr)
|
|
{
|
|
return -1;
|
|
}
|
|
st->buf = (uint8_t *)nptr;
|
|
buf = st->buf + st->size;
|
|
|
|
/*
|
|
* If something like " a b c " appears here, the " a b":3 will be
|
|
* converted, and the rest skipped. That is, unless buf_size is greater
|
|
* than chunk_size, then it'll be equivalent to "ABC0".
|
|
*/
|
|
for (; p < pend; p++)
|
|
{
|
|
int ch = *(const unsigned char *)p;
|
|
switch (ch)
|
|
{
|
|
case 0x09:
|
|
case 0x0a:
|
|
case 0x0c:
|
|
case 0x0d:
|
|
case 0x20:
|
|
/* Ignore whitespace */
|
|
continue;
|
|
case 0x30:
|
|
case 0x31:
|
|
case 0x32:
|
|
case 0x33:
|
|
case 0x34: /*01234*/
|
|
case 0x35:
|
|
case 0x36:
|
|
case 0x37:
|
|
case 0x38:
|
|
case 0x39: /*56789*/
|
|
clv = (clv << 4) + (ch - 0x30);
|
|
break;
|
|
case 0x41:
|
|
case 0x42:
|
|
case 0x43: /* ABC */
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x46: /* DEF */
|
|
clv = (clv << 4) + (ch - 0x41 + 10);
|
|
break;
|
|
case 0x61:
|
|
case 0x62:
|
|
case 0x63: /* abc */
|
|
case 0x64:
|
|
case 0x65:
|
|
case 0x66: /* def */
|
|
clv = (clv << 4) + (ch - 0x61 + 10);
|
|
break;
|
|
default:
|
|
*buf = 0; /* JIC */
|
|
return -1;
|
|
}
|
|
if (half++)
|
|
{
|
|
half = 0;
|
|
*buf++ = clv;
|
|
chunk_stop = p + 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check partial decoding.
|
|
*/
|
|
if (half)
|
|
{
|
|
if (have_more)
|
|
{
|
|
/*
|
|
* Partial specification is fine,
|
|
* because no more more PXER_TEXT data is available.
|
|
*/
|
|
*buf++ = clv << 4;
|
|
chunk_stop = p;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
chunk_stop = p;
|
|
}
|
|
|
|
st->size = buf - st->buf; /* Adjust the buffer size */
|
|
assert(st->size <= _ns);
|
|
st->buf[st->size] = 0; /* Courtesy termination */
|
|
|
|
return (chunk_stop - (const char *)chunk_buf); /* Converted size */
|
|
}
|
|
|
|
/*
|
|
* Convert from binary format: "00101011101"
|
|
*/
|
|
static ssize_t OCTET_STRING__convert_binary(void *sptr, const void *chunk_buf,
|
|
size_t chunk_size, int have_more)
|
|
{
|
|
BIT_STRING_t *st = (BIT_STRING_t *)sptr;
|
|
const char *p = (const char *)chunk_buf;
|
|
const char *pend = p + chunk_size;
|
|
int bits_unused = st->bits_unused & 0x7;
|
|
uint8_t *buf;
|
|
|
|
/* Reallocate buffer according to high cap estimation */
|
|
ssize_t _ns = st->size + (chunk_size + 7) / 8;
|
|
void *nptr = REALLOC(st->buf, _ns + 1);
|
|
if (!nptr)
|
|
{
|
|
return -1;
|
|
}
|
|
st->buf = (uint8_t *)nptr;
|
|
buf = st->buf + st->size;
|
|
|
|
(void)have_more;
|
|
|
|
if (bits_unused == 0)
|
|
{
|
|
bits_unused = 8;
|
|
}
|
|
else if (st->size)
|
|
{
|
|
buf--;
|
|
}
|
|
|
|
/*
|
|
* Convert series of 0 and 1 into the octet string.
|
|
*/
|
|
for (; p < pend; p++)
|
|
{
|
|
int ch = *(const unsigned char *)p;
|
|
switch (ch)
|
|
{
|
|
case 0x09:
|
|
case 0x0a:
|
|
case 0x0c:
|
|
case 0x0d:
|
|
case 0x20:
|
|
/* Ignore whitespace */
|
|
break;
|
|
case 0x30:
|
|
case 0x31:
|
|
if (bits_unused-- <= 0)
|
|
{
|
|
*++buf = 0; /* Clean the cell */
|
|
bits_unused = 7;
|
|
}
|
|
*buf |= (ch & 1) << bits_unused;
|
|
break;
|
|
default:
|
|
st->bits_unused = bits_unused;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (bits_unused == 8)
|
|
{
|
|
st->size = buf - st->buf;
|
|
st->bits_unused = 0;
|
|
}
|
|
else
|
|
{
|
|
st->size = buf - st->buf + 1;
|
|
st->bits_unused = bits_unused;
|
|
}
|
|
|
|
assert(st->size <= _ns);
|
|
st->buf[st->size] = 0; /* Courtesy termination */
|
|
|
|
return chunk_size; /* Converted in full */
|
|
}
|
|
|
|
/*
|
|
* Something like strtod(), but with stricter rules.
|
|
*/
|
|
static int OS__strtoent(int base, const char *buf, const char *end,
|
|
int32_t *ret_value)
|
|
{
|
|
int32_t val = 0;
|
|
const char *p;
|
|
|
|
for (p = buf; p < end; p++)
|
|
{
|
|
int ch = *p;
|
|
|
|
/* Strange huge value */
|
|
if ((val * base + base) < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
switch (ch)
|
|
{
|
|
case 0x30:
|
|
case 0x31:
|
|
case 0x32:
|
|
case 0x33:
|
|
case 0x34: /*01234*/
|
|
case 0x35:
|
|
case 0x36:
|
|
case 0x37:
|
|
case 0x38:
|
|
case 0x39: /*56789*/
|
|
val = val * base + (ch - 0x30);
|
|
break;
|
|
case 0x41:
|
|
case 0x42:
|
|
case 0x43: /* ABC */
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x46: /* DEF */
|
|
val = val * base + (ch - 0x41 + 10);
|
|
break;
|
|
case 0x61:
|
|
case 0x62:
|
|
case 0x63: /* abc */
|
|
case 0x64:
|
|
case 0x65:
|
|
case 0x66: /* def */
|
|
val = val * base + (ch - 0x61 + 10);
|
|
break;
|
|
case 0x3b: /* ';' */
|
|
*ret_value = val;
|
|
return (p - buf) + 1;
|
|
default:
|
|
return -1; /* Character set error */
|
|
}
|
|
}
|
|
|
|
*ret_value = -1;
|
|
return (p - buf);
|
|
}
|
|
|
|
/*
|
|
* Convert from the plain UTF-8 format, expanding entity references: "2 < 3"
|
|
*/
|
|
static ssize_t OCTET_STRING__convert_entrefs(void *sptr, const void *chunk_buf,
|
|
size_t chunk_size, int have_more)
|
|
{
|
|
OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
|
|
const char *p = (const char *)chunk_buf;
|
|
const char *pend = p + chunk_size;
|
|
uint8_t *buf;
|
|
|
|
/* Reallocate buffer */
|
|
ssize_t _ns = st->size + chunk_size;
|
|
void *nptr = REALLOC(st->buf, _ns + 1);
|
|
if (!nptr)
|
|
{
|
|
return -1;
|
|
}
|
|
st->buf = (uint8_t *)nptr;
|
|
buf = st->buf + st->size;
|
|
|
|
/*
|
|
* Convert series of 0 and 1 into the octet string.
|
|
*/
|
|
for (; p < pend; p++)
|
|
{
|
|
int ch = *(const unsigned char *)p;
|
|
int len; /* Length of the rest of the chunk */
|
|
|
|
if (ch != 0x26 /* '&' */)
|
|
{
|
|
*buf++ = ch;
|
|
continue; /* That was easy... */
|
|
}
|
|
|
|
/*
|
|
* Process entity reference.
|
|
*/
|
|
len = chunk_size - (p - (const char *)chunk_buf);
|
|
if (len == 1 /* "&" */)
|
|
{
|
|
goto want_more;
|
|
}
|
|
if (p[1] == 0x23 /* '#' */)
|
|
{
|
|
const char *pval; /* Pointer to start of digits */
|
|
int32_t val = 0; /* Entity reference value */
|
|
int base;
|
|
|
|
if (len == 2 /* "&#" */)
|
|
{
|
|
goto want_more;
|
|
}
|
|
if (p[2] == 0x78 /* 'x' */)
|
|
{
|
|
pval = p + 3, base = 16;
|
|
}
|
|
else
|
|
{
|
|
pval = p + 2, base = 10;
|
|
}
|
|
len = OS__strtoent(base, pval, p + len, &val);
|
|
if (len == -1)
|
|
{
|
|
/* Invalid charset. Just copy verbatim. */
|
|
*buf++ = ch;
|
|
continue;
|
|
}
|
|
if (!len || pval[len - 1] != 0x3b)
|
|
{
|
|
goto want_more;
|
|
}
|
|
assert(val > 0);
|
|
p += (pval - p) + len - 1; /* Advance past entref */
|
|
|
|
if (val < 0x80)
|
|
{
|
|
*buf++ = (char)val;
|
|
}
|
|
else if (val < 0x800)
|
|
{
|
|
*buf++ = 0xc0 | ((val >> 6));
|
|
*buf++ = 0x80 | ((val & 0x3f));
|
|
}
|
|
else if (val < 0x10000)
|
|
{
|
|
*buf++ = 0xe0 | ((val >> 12));
|
|
*buf++ = 0x80 | ((val >> 6) & 0x3f);
|
|
*buf++ = 0x80 | ((val & 0x3f));
|
|
}
|
|
else if (val < 0x200000)
|
|
{
|
|
*buf++ = 0xf0 | ((val >> 18));
|
|
*buf++ = 0x80 | ((val >> 12) & 0x3f);
|
|
*buf++ = 0x80 | ((val >> 6) & 0x3f);
|
|
*buf++ = 0x80 | ((val & 0x3f));
|
|
}
|
|
else if (val < 0x4000000)
|
|
{
|
|
*buf++ = 0xf8 | ((val >> 24));
|
|
*buf++ = 0x80 | ((val >> 18) & 0x3f);
|
|
*buf++ = 0x80 | ((val >> 12) & 0x3f);
|
|
*buf++ = 0x80 | ((val >> 6) & 0x3f);
|
|
*buf++ = 0x80 | ((val & 0x3f));
|
|
}
|
|
else
|
|
{
|
|
*buf++ = 0xfc | ((val >> 30) & 0x1);
|
|
*buf++ = 0x80 | ((val >> 24) & 0x3f);
|
|
*buf++ = 0x80 | ((val >> 18) & 0x3f);
|
|
*buf++ = 0x80 | ((val >> 12) & 0x3f);
|
|
*buf++ = 0x80 | ((val >> 6) & 0x3f);
|
|
*buf++ = 0x80 | ((val & 0x3f));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Ugly, limited parsing of & > <
|
|
*/
|
|
char *sc = (char *)memchr(p, 0x3b, len > 5 ? 5 : len);
|
|
if (!sc)
|
|
{
|
|
goto want_more;
|
|
}
|
|
if ((sc - p) == 4 && p[1] == 0x61 /* 'a' */
|
|
&& p[2] == 0x6d /* 'm' */
|
|
&& p[3] == 0x70 /* 'p' */)
|
|
{
|
|
*buf++ = 0x26;
|
|
p = sc;
|
|
continue;
|
|
}
|
|
if ((sc - p) == 3)
|
|
{
|
|
if (p[1] == 0x6c)
|
|
{
|
|
*buf = 0x3c; /* '<' */
|
|
}
|
|
else if (p[1] == 0x67)
|
|
{
|
|
*buf = 0x3e; /* '>' */
|
|
}
|
|
else
|
|
{
|
|
/* Unsupported entity reference */
|
|
*buf++ = ch;
|
|
continue;
|
|
}
|
|
if (p[2] != 0x74)
|
|
{
|
|
/* Unsupported entity reference */
|
|
*buf++ = ch;
|
|
continue;
|
|
}
|
|
buf++;
|
|
p = sc;
|
|
continue;
|
|
}
|
|
/* Unsupported entity reference */
|
|
*buf++ = ch;
|
|
}
|
|
|
|
continue;
|
|
want_more:
|
|
if (have_more)
|
|
{
|
|
/*
|
|
* We know that no more data (of the same type)
|
|
* is coming. Copy the rest verbatim.
|
|
*/
|
|
*buf++ = ch;
|
|
continue;
|
|
}
|
|
chunk_size = (p - (const char *)chunk_buf);
|
|
/* Processing stalled: need more data */
|
|
break;
|
|
}
|
|
|
|
st->size = buf - st->buf;
|
|
assert(st->size <= _ns);
|
|
st->buf[st->size] = 0; /* Courtesy termination */
|
|
|
|
return chunk_size; /* Converted in full */
|
|
}
|
|
|
|
/*
|
|
* Decode OCTET STRING from the XML element's body.
|
|
*/
|
|
static asn_dec_rval_t OCTET_STRING__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,
|
|
int (*opt_unexpected_tag_decoder)(void *struct_ptr, const void *chunk_buf,
|
|
size_t chunk_size),
|
|
ssize_t (*body_receiver)(void *struct_ptr, const void *chunk_buf,
|
|
size_t chunk_size, int have_more))
|
|
{
|
|
OCTET_STRING_t *st = (OCTET_STRING_t *)*sptr;
|
|
asn_OCTET_STRING_specifics_t *specs =
|
|
td->specifics ? (asn_OCTET_STRING_specifics_t *)td->specifics
|
|
: &asn_DEF_OCTET_STRING_specs;
|
|
const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
|
|
asn_struct_ctx_t *ctx; /* Per-structure parser context */
|
|
asn_dec_rval_t rval; /* Return value from the decoder */
|
|
int st_allocated;
|
|
|
|
/*
|
|
* Create the string if does not exist.
|
|
*/
|
|
if (!st)
|
|
{
|
|
st = (OCTET_STRING_t *)CALLOC(1, specs->struct_size);
|
|
*sptr = (void *)st;
|
|
if (!st)
|
|
{
|
|
goto sta_failed;
|
|
}
|
|
st_allocated = 1;
|
|
}
|
|
else
|
|
{
|
|
st_allocated = 0;
|
|
}
|
|
if (!st->buf)
|
|
{
|
|
/* This is separate from above section */
|
|
st->buf = (uint8_t *)CALLOC(1, 1);
|
|
if (!st->buf)
|
|
{
|
|
if (st_allocated)
|
|
{
|
|
*sptr = 0;
|
|
goto stb_failed;
|
|
}
|
|
else
|
|
{
|
|
goto sta_failed;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Restore parsing context */
|
|
ctx = (asn_struct_ctx_t *)(((char *)*sptr) + specs->ctx_offset);
|
|
|
|
return xer_decode_general(opt_codec_ctx, ctx, *sptr, xml_tag, buf_ptr, size,
|
|
opt_unexpected_tag_decoder, body_receiver);
|
|
|
|
stb_failed:
|
|
FREEMEM(st);
|
|
sta_failed:
|
|
rval.code = RC_FAIL;
|
|
rval.consumed = 0;
|
|
return rval;
|
|
}
|
|
|
|
/*
|
|
* Decode OCTET STRING from the hexadecimal data.
|
|
*/
|
|
asn_dec_rval_t OCTET_STRING_decode_xer_hex(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 OCTET_STRING__decode_xer(opt_codec_ctx, td, sptr, opt_mname, buf_ptr,
|
|
size, 0, OCTET_STRING__convert_hexadecimal);
|
|
}
|
|
|
|
/*
|
|
* Decode OCTET STRING from the binary (0/1) data.
|
|
*/
|
|
asn_dec_rval_t OCTET_STRING_decode_xer_binary(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 OCTET_STRING__decode_xer(opt_codec_ctx, td, sptr, opt_mname, buf_ptr,
|
|
size, 0, OCTET_STRING__convert_binary);
|
|
}
|
|
|
|
/*
|
|
* Decode OCTET STRING from the string (ASCII/UTF-8) data.
|
|
*/
|
|
asn_dec_rval_t OCTET_STRING_decode_xer_utf8(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 OCTET_STRING__decode_xer(opt_codec_ctx, td, sptr, opt_mname, buf_ptr,
|
|
size, OCTET_STRING__handle_control_chars,
|
|
OCTET_STRING__convert_entrefs);
|
|
}
|
|
|
|
static int OCTET_STRING_per_get_characters(asn_per_data_t *po, uint8_t *buf,
|
|
size_t units, unsigned int bpc,
|
|
unsigned int unit_bits, long lb,
|
|
long ub, asn_per_constraints_t *pc)
|
|
{
|
|
uint8_t *end = buf + units * bpc;
|
|
|
|
ASN_DEBUG("Expanding %d characters into (%ld..%ld):%d", (int)units, lb, ub,
|
|
unit_bits);
|
|
|
|
/* X.691: 27.5.4 */
|
|
if ((unsigned long)ub <= ((unsigned long)2 << (unit_bits - 1)))
|
|
{
|
|
/* Decode without translation */
|
|
lb = 0;
|
|
}
|
|
else if (pc && pc->code2value)
|
|
{
|
|
if (unit_bits > 16)
|
|
{
|
|
return 1;
|
|
} /* FATAL: can't have constrained
|
|
* UniversalString with more than
|
|
* 16 million code points */
|
|
for (; buf < end; buf += bpc)
|
|
{
|
|
int value;
|
|
int code = per_get_few_bits(po, unit_bits);
|
|
if (code < 0)
|
|
{
|
|
return -1; /* WMORE */
|
|
}
|
|
value = pc->code2value(code);
|
|
if (value < 0)
|
|
{
|
|
ASN_DEBUG(
|
|
"Code %d (0x%02x) is"
|
|
" not in map (%ld..%ld)",
|
|
code, code, lb, ub);
|
|
return 1; /* FATAL */
|
|
}
|
|
switch (bpc)
|
|
{
|
|
case 1:
|
|
*buf = value;
|
|
break;
|
|
case 2:
|
|
buf[0] = value >> 8;
|
|
buf[1] = value;
|
|
break;
|
|
case 4:
|
|
buf[0] = value >> 24;
|
|
buf[1] = value >> 16;
|
|
buf[2] = value >> 8;
|
|
buf[3] = value;
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Shortcut the no-op copying to the aligned structure */
|
|
if (lb == 0 && (unit_bits == 8 * bpc))
|
|
{
|
|
return per_get_many_bits(po, buf, 0, unit_bits * units);
|
|
}
|
|
|
|
for (; buf < end; buf += bpc)
|
|
{
|
|
int code = per_get_few_bits(po, unit_bits);
|
|
int ch = code + lb;
|
|
if (code < 0)
|
|
{
|
|
return -1; /* WMORE */
|
|
}
|
|
if (ch > ub)
|
|
{
|
|
ASN_DEBUG("Code %d is out of range (%ld..%ld)", ch, lb, ub);
|
|
return 1; /* FATAL */
|
|
}
|
|
switch (bpc)
|
|
{
|
|
case 1:
|
|
*buf = ch;
|
|
break;
|
|
case 2:
|
|
buf[0] = ch >> 8;
|
|
buf[1] = ch;
|
|
break;
|
|
case 4:
|
|
buf[0] = ch >> 24;
|
|
buf[1] = ch >> 16;
|
|
buf[2] = ch >> 8;
|
|
buf[3] = ch;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int OCTET_STRING_per_put_characters(asn_per_outp_t *po,
|
|
const uint8_t *buf, size_t units,
|
|
unsigned int bpc,
|
|
unsigned int unit_bits, long lb,
|
|
long ub, asn_per_constraints_t *pc)
|
|
{
|
|
const uint8_t *end = buf + units * bpc;
|
|
|
|
ASN_DEBUG("Squeezing %d characters into (%ld..%ld):%d (%d bpc)", (int)units,
|
|
lb, ub, unit_bits, bpc);
|
|
|
|
/* X.691: 27.5.4 */
|
|
if ((unsigned long)ub <= ((unsigned long)2 << (unit_bits - 1)))
|
|
{
|
|
/* Encode as is */
|
|
lb = 0;
|
|
}
|
|
else if (pc && pc->value2code)
|
|
{
|
|
for (; buf < end; buf += bpc)
|
|
{
|
|
int code;
|
|
uint32_t value;
|
|
switch (bpc)
|
|
{
|
|
case 1:
|
|
value = *buf;
|
|
break;
|
|
case 2:
|
|
value = (buf[0] << 8) | buf[1];
|
|
break;
|
|
case 4:
|
|
value = (buf[0] << 24) | (buf[1] << 16) |
|
|
(buf[2] << 8) | buf[3];
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
code = pc->value2code(value);
|
|
if (code < 0)
|
|
{
|
|
ASN_DEBUG(
|
|
"Character %d (0x%02x) is"
|
|
" not in map (%ld..%ld)",
|
|
*buf, *buf, lb, ub);
|
|
return -1;
|
|
}
|
|
if (per_put_few_bits(po, code, unit_bits))
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Shortcut the no-op copying to the aligned structure */
|
|
if (lb == 0 && (unit_bits == 8 * bpc))
|
|
{
|
|
return per_put_many_bits(po, buf, unit_bits * units);
|
|
}
|
|
|
|
for (ub -= lb; buf < end; buf += bpc)
|
|
{
|
|
int ch;
|
|
uint32_t value;
|
|
switch (bpc)
|
|
{
|
|
case 1:
|
|
value = *buf;
|
|
break;
|
|
case 2:
|
|
value = (buf[0] << 8) | buf[1];
|
|
break;
|
|
case 4:
|
|
value = (buf[0] << 24) | (buf[1] << 16) |
|
|
(buf[2] << 8) | buf[3];
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
ch = value - lb;
|
|
if (ch < 0 || ch > ub)
|
|
{
|
|
ASN_DEBUG(
|
|
"Character %d (0x%02x)"
|
|
" is out of range (%ld..%ld)",
|
|
*buf, *buf, lb, ub + lb);
|
|
return -1;
|
|
}
|
|
if (per_put_few_bits(po, ch, unit_bits))
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
asn_dec_rval_t OCTET_STRING_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_OCTET_STRING_specifics_t *specs =
|
|
td->specifics ? (asn_OCTET_STRING_specifics_t *)td->specifics
|
|
: &asn_DEF_OCTET_STRING_specs;
|
|
asn_per_constraints_t *pc = constraints ? constraints : td->per_constraints;
|
|
asn_per_constraint_t *cval;
|
|
asn_per_constraint_t *csiz;
|
|
asn_dec_rval_t rval = {RC_OK, 0};
|
|
BIT_STRING_t *st = (BIT_STRING_t *)*sptr;
|
|
ssize_t consumed_myself = 0;
|
|
int repeat;
|
|
enum
|
|
{
|
|
OS__BPC_BIT = 0,
|
|
OS__BPC_CHAR = 1,
|
|
OS__BPC_U16 = 2,
|
|
OS__BPC_U32 = 4
|
|
} bpc; /* Bytes per character */
|
|
unsigned int unit_bits;
|
|
unsigned int canonical_unit_bits;
|
|
|
|
(void)opt_codec_ctx;
|
|
|
|
if (pc)
|
|
{
|
|
cval = &pc->value;
|
|
csiz = &pc->size;
|
|
}
|
|
else
|
|
{
|
|
cval = &ASN_DEF_OCTET_STRING_CONSTRAINTS.value;
|
|
csiz = &ASN_DEF_OCTET_STRING_CONSTRAINTS.size;
|
|
}
|
|
|
|
switch (specs->subvariant)
|
|
{
|
|
default:
|
|
case ASN_OSUBV_ANY:
|
|
ASN_DEBUG("Unrecognized subvariant %d", specs->subvariant);
|
|
RETURN(RC_FAIL);
|
|
case ASN_OSUBV_BIT:
|
|
canonical_unit_bits = unit_bits = 1;
|
|
bpc = OS__BPC_BIT;
|
|
break;
|
|
case ASN_OSUBV_STR:
|
|
canonical_unit_bits = unit_bits = 8;
|
|
if (cval->flags & APC_CONSTRAINED)
|
|
{
|
|
unit_bits = cval->range_bits;
|
|
}
|
|
bpc = OS__BPC_CHAR;
|
|
break;
|
|
case ASN_OSUBV_U16:
|
|
canonical_unit_bits = unit_bits = 16;
|
|
if (cval->flags & APC_CONSTRAINED)
|
|
{
|
|
unit_bits = cval->range_bits;
|
|
}
|
|
bpc = OS__BPC_U16;
|
|
break;
|
|
case ASN_OSUBV_U32:
|
|
canonical_unit_bits = unit_bits = 32;
|
|
if (cval->flags & APC_CONSTRAINED)
|
|
{
|
|
unit_bits = cval->range_bits;
|
|
}
|
|
bpc = OS__BPC_U32;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Allocate the string.
|
|
*/
|
|
if (!st)
|
|
{
|
|
st = (BIT_STRING_t *)(*sptr = CALLOC(1, specs->struct_size));
|
|
if (!st)
|
|
{
|
|
RETURN(RC_FAIL);
|
|
}
|
|
}
|
|
|
|
ASN_DEBUG("PER Decoding %s size %ld .. %ld bits %d",
|
|
csiz->flags & APC_EXTENSIBLE ? "extensible" : "non-extensible",
|
|
csiz->lower_bound, csiz->upper_bound, csiz->effective_bits);
|
|
|
|
if (csiz->flags & APC_EXTENSIBLE)
|
|
{
|
|
int inext = per_get_few_bits(pd, 1);
|
|
if (inext < 0)
|
|
{
|
|
RETURN(RC_WMORE);
|
|
}
|
|
if (inext)
|
|
{
|
|
csiz = &ASN_DEF_OCTET_STRING_CONSTRAINTS.size;
|
|
cval = &ASN_DEF_OCTET_STRING_CONSTRAINTS.value;
|
|
unit_bits = canonical_unit_bits;
|
|
}
|
|
}
|
|
|
|
if (csiz->effective_bits >= 0)
|
|
{
|
|
FREEMEM(st->buf);
|
|
if (bpc)
|
|
{
|
|
st->size = csiz->upper_bound * bpc;
|
|
}
|
|
else
|
|
{
|
|
st->size = (csiz->upper_bound + 7) >> 3;
|
|
}
|
|
st->buf = (uint8_t *)MALLOC(st->size + 1);
|
|
if (!st->buf)
|
|
{
|
|
st->size = 0;
|
|
RETURN(RC_FAIL);
|
|
}
|
|
}
|
|
|
|
/* X.691, #16.5: zero-length encoding */
|
|
/* X.691, #16.6: short fixed length encoding (up to 2 octets) */
|
|
/* X.691, #16.7: long fixed length encoding (up to 64K octets) */
|
|
if (csiz->effective_bits == 0)
|
|
{
|
|
int ret;
|
|
if (bpc)
|
|
{
|
|
ASN_DEBUG("Encoding OCTET STRING size %ld",
|
|
csiz->upper_bound);
|
|
ret = OCTET_STRING_per_get_characters(
|
|
pd, st->buf, csiz->upper_bound, bpc, unit_bits,
|
|
cval->lower_bound, cval->upper_bound, pc);
|
|
if (ret > 0)
|
|
{
|
|
RETURN(RC_FAIL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASN_DEBUG("Encoding BIT STRING size %ld",
|
|
csiz->upper_bound);
|
|
ret = per_get_many_bits(pd, st->buf, 0,
|
|
unit_bits * csiz->upper_bound);
|
|
}
|
|
if (ret < 0)
|
|
{
|
|
RETURN(RC_WMORE);
|
|
}
|
|
consumed_myself += unit_bits * csiz->upper_bound;
|
|
st->buf[st->size] = 0;
|
|
if (bpc == 0)
|
|
{
|
|
int ubs = (csiz->upper_bound & 0x7);
|
|
st->bits_unused = ubs ? 8 - ubs : 0;
|
|
}
|
|
RETURN(RC_OK);
|
|
}
|
|
|
|
st->size = 0;
|
|
do
|
|
{
|
|
ssize_t raw_len;
|
|
ssize_t len_bytes;
|
|
ssize_t len_bits;
|
|
void *p;
|
|
int ret;
|
|
|
|
/* Get the PER length */
|
|
raw_len = uper_get_length(pd, csiz->effective_bits, &repeat);
|
|
if (raw_len < 0)
|
|
{
|
|
RETURN(RC_WMORE);
|
|
}
|
|
raw_len += csiz->lower_bound;
|
|
|
|
ASN_DEBUG("Got PER length eb %ld, len %ld, %s (%s)",
|
|
(long)csiz->effective_bits, (long)raw_len,
|
|
repeat ? "repeat" : "once", td->name);
|
|
if (bpc)
|
|
{
|
|
len_bytes = raw_len * bpc;
|
|
len_bits = len_bytes * unit_bits;
|
|
}
|
|
else
|
|
{
|
|
len_bits = raw_len;
|
|
len_bytes = (len_bits + 7) >> 3;
|
|
if (len_bits & 0x7)
|
|
{
|
|
st->bits_unused = 8 - (len_bits & 0x7);
|
|
}
|
|
/* len_bits be multiple of 16K if repeat is set */
|
|
}
|
|
p = REALLOC(st->buf, st->size + len_bytes + 1);
|
|
if (!p)
|
|
{
|
|
RETURN(RC_FAIL);
|
|
}
|
|
st->buf = (uint8_t *)p;
|
|
|
|
if (bpc)
|
|
{
|
|
ret = OCTET_STRING_per_get_characters(
|
|
pd, &st->buf[st->size], raw_len, bpc, unit_bits,
|
|
cval->lower_bound, cval->upper_bound, pc);
|
|
if (ret > 0)
|
|
{
|
|
RETURN(RC_FAIL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret =
|
|
per_get_many_bits(pd, &st->buf[st->size], 0, len_bits);
|
|
}
|
|
if (ret < 0)
|
|
{
|
|
RETURN(RC_WMORE);
|
|
}
|
|
st->size += len_bytes;
|
|
}
|
|
while (repeat);
|
|
st->buf[st->size] = 0; /* nul-terminate */
|
|
|
|
return rval;
|
|
}
|
|
|
|
asn_enc_rval_t OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
|
|
asn_per_constraints_t *constraints,
|
|
void *sptr, asn_per_outp_t *po)
|
|
{
|
|
asn_OCTET_STRING_specifics_t *specs =
|
|
td->specifics ? (asn_OCTET_STRING_specifics_t *)td->specifics
|
|
: &asn_DEF_OCTET_STRING_specs;
|
|
asn_per_constraints_t *pc = constraints ? constraints : td->per_constraints;
|
|
asn_per_constraint_t *cval;
|
|
asn_per_constraint_t *csiz;
|
|
const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
|
|
asn_enc_rval_t er = {0, 0, 0};
|
|
int inext = 0; /* Lies not within extension root */
|
|
unsigned int unit_bits;
|
|
unsigned int canonical_unit_bits;
|
|
unsigned int sizeinunits;
|
|
const uint8_t *buf;
|
|
int ret;
|
|
enum
|
|
{
|
|
OS__BPC_BIT = 0,
|
|
OS__BPC_CHAR = 1,
|
|
OS__BPC_U16 = 2,
|
|
OS__BPC_U32 = 4
|
|
} bpc; /* Bytes per character */
|
|
int ct_extensible;
|
|
|
|
if (!st || (!st->buf && st->size))
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
|
|
if (pc)
|
|
{
|
|
cval = &pc->value;
|
|
csiz = &pc->size;
|
|
}
|
|
else
|
|
{
|
|
cval = &ASN_DEF_OCTET_STRING_CONSTRAINTS.value;
|
|
csiz = &ASN_DEF_OCTET_STRING_CONSTRAINTS.size;
|
|
}
|
|
ct_extensible = csiz->flags & APC_EXTENSIBLE;
|
|
|
|
switch (specs->subvariant)
|
|
{
|
|
default:
|
|
case ASN_OSUBV_ANY:
|
|
_ASN_ENCODE_FAILED;
|
|
case ASN_OSUBV_BIT:
|
|
canonical_unit_bits = unit_bits = 1;
|
|
bpc = OS__BPC_BIT;
|
|
sizeinunits = st->size * 8 - (st->bits_unused & 0x07);
|
|
ASN_DEBUG("BIT STRING of %d bytes, %d bits unused", sizeinunits,
|
|
st->bits_unused);
|
|
break;
|
|
case ASN_OSUBV_STR:
|
|
canonical_unit_bits = unit_bits = 8;
|
|
if (cval->flags & APC_CONSTRAINED)
|
|
{
|
|
unit_bits = cval->range_bits;
|
|
}
|
|
bpc = OS__BPC_CHAR;
|
|
sizeinunits = st->size;
|
|
break;
|
|
case ASN_OSUBV_U16:
|
|
canonical_unit_bits = unit_bits = 16;
|
|
if (cval->flags & APC_CONSTRAINED)
|
|
{
|
|
unit_bits = cval->range_bits;
|
|
}
|
|
bpc = OS__BPC_U16;
|
|
sizeinunits = st->size / 2;
|
|
break;
|
|
case ASN_OSUBV_U32:
|
|
canonical_unit_bits = unit_bits = 32;
|
|
if (cval->flags & APC_CONSTRAINED)
|
|
{
|
|
unit_bits = cval->range_bits;
|
|
}
|
|
bpc = OS__BPC_U32;
|
|
sizeinunits = st->size / 4;
|
|
break;
|
|
}
|
|
|
|
ASN_DEBUG(
|
|
"Encoding %s into %d units of %d bits"
|
|
" (%ld..%ld, effective %d)%s",
|
|
td->name, sizeinunits, unit_bits, csiz->lower_bound, csiz->upper_bound,
|
|
csiz->effective_bits, ct_extensible ? " EXT" : "");
|
|
|
|
/* Figure out whether size lies within PER visible constraint */
|
|
|
|
if (csiz->effective_bits >= 0)
|
|
{
|
|
if ((int)sizeinunits < csiz->lower_bound ||
|
|
(int)sizeinunits > csiz->upper_bound)
|
|
{
|
|
if (ct_extensible)
|
|
{
|
|
cval = &ASN_DEF_OCTET_STRING_CONSTRAINTS.value;
|
|
csiz = &ASN_DEF_OCTET_STRING_CONSTRAINTS.size;
|
|
unit_bits = canonical_unit_bits;
|
|
inext = 1;
|
|
}
|
|
else
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
inext = 0;
|
|
}
|
|
|
|
if (ct_extensible)
|
|
{
|
|
/* Declare whether length is [not] within extension root */
|
|
if (per_put_few_bits(po, inext, 1))
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
}
|
|
|
|
/* X.691, #16.5: zero-length encoding */
|
|
/* X.691, #16.6: short fixed length encoding (up to 2 octets) */
|
|
/* X.691, #16.7: long fixed length encoding (up to 64K octets) */
|
|
if (csiz->effective_bits >= 0)
|
|
{
|
|
ASN_DEBUG("Encoding %d bytes (%ld), length in %d bits", st->size,
|
|
sizeinunits - csiz->lower_bound, csiz->effective_bits);
|
|
ret = per_put_few_bits(po, sizeinunits - csiz->lower_bound,
|
|
csiz->effective_bits);
|
|
if (ret)
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
if (bpc)
|
|
{
|
|
ret = OCTET_STRING_per_put_characters(
|
|
po, st->buf, sizeinunits, bpc, unit_bits,
|
|
cval->lower_bound, cval->upper_bound, pc);
|
|
}
|
|
else
|
|
{
|
|
ret =
|
|
per_put_many_bits(po, st->buf, sizeinunits * unit_bits);
|
|
}
|
|
if (ret)
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
_ASN_ENCODED_OK(er);
|
|
}
|
|
|
|
ASN_DEBUG("Encoding %d bytes", st->size);
|
|
|
|
if (sizeinunits == 0)
|
|
{
|
|
if (uper_put_length(po, 0))
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
_ASN_ENCODED_OK(er);
|
|
}
|
|
|
|
buf = st->buf;
|
|
while (sizeinunits)
|
|
{
|
|
ssize_t maySave = uper_put_length(po, sizeinunits);
|
|
if (maySave < 0)
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
|
|
ASN_DEBUG("Encoding %ld of %ld", (long)maySave, (long)sizeinunits);
|
|
|
|
if (bpc)
|
|
{
|
|
ret = OCTET_STRING_per_put_characters(
|
|
po, buf, maySave, bpc, unit_bits, cval->lower_bound,
|
|
cval->upper_bound, pc);
|
|
}
|
|
else
|
|
{
|
|
ret = per_put_many_bits(po, buf, maySave * unit_bits);
|
|
}
|
|
if (ret)
|
|
{
|
|
_ASN_ENCODE_FAILED;
|
|
}
|
|
|
|
if (bpc)
|
|
{
|
|
buf += maySave * bpc;
|
|
}
|
|
else
|
|
{
|
|
buf += maySave >> 3;
|
|
}
|
|
sizeinunits -= maySave;
|
|
assert(!(maySave & 0x07) || !sizeinunits);
|
|
}
|
|
|
|
_ASN_ENCODED_OK(er);
|
|
}
|
|
|
|
int OCTET_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";
|
|
const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
|
|
char scratch[16 * 3 + 4];
|
|
char *p = scratch;
|
|
uint8_t *buf;
|
|
uint8_t *end;
|
|
size_t i;
|
|
|
|
(void)td; /* Unused argument */
|
|
|
|
if (!st || (!st->buf && st->size))
|
|
{
|
|
return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
|
|
}
|
|
|
|
/*
|
|
* Dump the contents of the buffer in hexadecimal.
|
|
*/
|
|
buf = st->buf;
|
|
end = buf + st->size;
|
|
for (i = 0; buf < end; buf++, i++)
|
|
{
|
|
if (!(i % 16) && (i || st->size > 16))
|
|
{
|
|
if (cb(scratch, p - scratch, app_key) < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
_i_INDENT(1);
|
|
p = scratch;
|
|
}
|
|
*p++ = h2c[(*buf >> 4) & 0x0F];
|
|
*p++ = h2c[*buf & 0x0F];
|
|
*p++ = 0x20;
|
|
}
|
|
|
|
if (p > scratch)
|
|
{
|
|
p--; /* Remove the tail space */
|
|
if (cb(scratch, p - scratch, app_key) < 0)
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int OCTET_STRING_print_utf8(asn_TYPE_descriptor_t *td, const void *sptr,
|
|
int ilevel, asn_app_consume_bytes_f *cb,
|
|
void *app_key)
|
|
{
|
|
const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
|
|
|
|
(void)td; /* Unused argument */
|
|
(void)ilevel; /* Unused argument */
|
|
|
|
if (st && (st->buf || !st->size))
|
|
{
|
|
return (cb(st->buf, st->size, app_key) < 0) ? -1 : 0;
|
|
}
|
|
else
|
|
{
|
|
return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
|
|
}
|
|
}
|
|
|
|
void OCTET_STRING_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only)
|
|
{
|
|
OCTET_STRING_t *st = (OCTET_STRING_t *)sptr;
|
|
asn_OCTET_STRING_specifics_t *specs =
|
|
td->specifics ? (asn_OCTET_STRING_specifics_t *)td->specifics
|
|
: &asn_DEF_OCTET_STRING_specs;
|
|
asn_struct_ctx_t *ctx =
|
|
(asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
|
|
struct _stack *stck;
|
|
|
|
if (!td || !st)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ASN_DEBUG("Freeing %s as OCTET STRING", td->name);
|
|
|
|
if (st->buf)
|
|
{
|
|
FREEMEM(st->buf);
|
|
st->buf = 0;
|
|
}
|
|
|
|
/*
|
|
* Remove decode-time stack.
|
|
*/
|
|
stck = (struct _stack *)ctx->ptr;
|
|
if (stck)
|
|
{
|
|
while (stck->tail)
|
|
{
|
|
struct _stack_el *sel = stck->tail;
|
|
stck->tail = sel->prev;
|
|
FREEMEM(sel);
|
|
}
|
|
FREEMEM(stck);
|
|
}
|
|
|
|
if (!contents_only)
|
|
{
|
|
FREEMEM(st);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Conversion routines.
|
|
*/
|
|
int OCTET_STRING_fromBuf(OCTET_STRING_t *st, const char *str, int len)
|
|
{
|
|
void *buf;
|
|
|
|
if (st == 0 || (str == 0 && len))
|
|
{
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Clear the OCTET STRING.
|
|
*/
|
|
if (str == NULL)
|
|
{
|
|
FREEMEM(st->buf);
|
|
st->buf = 0;
|
|
st->size = 0;
|
|
return 0;
|
|
}
|
|
|
|
/* Determine the original string size, if not explicitly given */
|
|
if (len < 0)
|
|
{
|
|
len = strlen(str);
|
|
}
|
|
|
|
/* Allocate and fill the memory */
|
|
buf = MALLOC(len + 1);
|
|
if (buf == NULL)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
memcpy(buf, str, len);
|
|
((uint8_t *)buf)[len] = '\0'; /* Couldn't use memcpy(len+1)! */
|
|
FREEMEM(st->buf);
|
|
st->buf = (uint8_t *)buf;
|
|
st->size = len;
|
|
|
|
return 0;
|
|
}
|
|
|
|
OCTET_STRING_t *OCTET_STRING_new_fromBuf(asn_TYPE_descriptor_t *td,
|
|
const char *str, int len)
|
|
{
|
|
asn_OCTET_STRING_specifics_t *specs =
|
|
td->specifics ? (asn_OCTET_STRING_specifics_t *)td->specifics
|
|
: &asn_DEF_OCTET_STRING_specs;
|
|
OCTET_STRING_t *st;
|
|
|
|
st = (OCTET_STRING_t *)CALLOC(1, specs->struct_size);
|
|
if (st && str && OCTET_STRING_fromBuf(st, str, len))
|
|
{
|
|
FREEMEM(st);
|
|
st = NULL;
|
|
}
|
|
|
|
return st;
|
|
}
|