- MMS: asn1 parser - removed debugging code
This commit is contained in:
Michael Zillgith
parent
a008275f37
commit
90d910625b
6 changed files with 26 additions and 296 deletions
|
|
@ -94,7 +94,6 @@ asn_TYPE_descriptor_t asn_DEF_OCTET_STRING = {
|
|||
} else { \
|
||||
RETURN(RC_FAIL); \
|
||||
} \
|
||||
ASN_DEBUG("Reallocating into %ld", (long)_ns); \
|
||||
} \
|
||||
memcpy(st->buf + st->size, bufptr, _bs); \
|
||||
/* Convenient nul-termination */ \
|
||||
|
|
@ -187,12 +186,6 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
int tlv_constr;
|
||||
OS_type_e type_variant = (OS_type_e)specs->subvariant;
|
||||
|
||||
ASN_DEBUG("Decoding %s as %s (frame %ld)",
|
||||
td->name,
|
||||
(type_variant == _TT_GENERIC) ?
|
||||
"OCTET STRING" : "OS-SpecialCase",
|
||||
(long)size);
|
||||
|
||||
/*
|
||||
* Create the string if does not exist.
|
||||
*/
|
||||
|
|
@ -254,12 +247,6 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
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,
|
||||
(long)(sel?sel->left:0),
|
||||
(long)(sel?sel->want_nulls:0),
|
||||
(long)(sel?sel->got:0)
|
||||
);
|
||||
if(sel && sel->left <= 0 && sel->want_nulls == 0) {
|
||||
if(sel->prev) {
|
||||
struct _stack_el *prev = sel->prev;
|
||||
|
|
@ -280,11 +267,7 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
}
|
||||
|
||||
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?"":"!",
|
||||
(long)(sel?sel->left:0),
|
||||
(long)(sel?sel->want_nulls:0),
|
||||
(long)tl);
|
||||
|
||||
switch(tl) {
|
||||
case -1: RETURN(RC_FAIL);
|
||||
case 0: RETURN(RC_WMORE);
|
||||
|
|
@ -294,9 +277,7 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
|
||||
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);
|
||||
|
|
@ -307,8 +288,6 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
&& ((const uint8_t *)buf_ptr)[1] == 0)
|
||||
{
|
||||
|
||||
ASN_DEBUG("Eat EOC; wn=%d--", sel->want_nulls);
|
||||
|
||||
if(type_variant == _TT_ANY
|
||||
&& (tag_mode != 1 || sel->cont_level))
|
||||
APPEND("\0\0", 2);
|
||||
|
|
@ -359,21 +338,12 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
|
|
@ -403,14 +373,9 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
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;
|
||||
}
|
||||
|
|
@ -420,9 +385,7 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
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;
|
||||
|
||||
|
|
@ -446,8 +409,6 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
}
|
||||
|
||||
if(sel->left) {
|
||||
ASN_DEBUG("OS left %ld, size = %ld, wn=%d\n",
|
||||
(long)sel->left, (long)size, sel->want_nulls);
|
||||
RETURN(RC_WMORE);
|
||||
}
|
||||
|
||||
|
|
@ -491,9 +452,6 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
|
@ -507,12 +465,6 @@ OCTET_STRING_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|||
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 == _TT_GENERIC) ? (char *)st->buf : "<data>",
|
||||
(long)st->size);
|
||||
|
||||
|
||||
RETURN(RC_OK);
|
||||
}
|
||||
|
||||
|
|
@ -531,9 +483,6 @@ OCTET_STRING_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
|
|||
OS_type_e type_variant = (OS_type_e)specs->subvariant;
|
||||
int fix_last_byte = 0;
|
||||
|
||||
ASN_DEBUG("%s %s as OCTET STRING",
|
||||
cb?"Estimating":"Encoding", td->name);
|
||||
|
||||
/*
|
||||
* Write tags.
|
||||
*/
|
||||
|
|
@ -1274,9 +1223,6 @@ OCTET_STRING_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
|
|||
if(len_bits < 0) RETURN(RC_WMORE);
|
||||
len_bits += ct->lower_bound;
|
||||
|
||||
ASN_DEBUG("Got PER length eb %ld, len %ld, %s (%s)",
|
||||
(long)ct->effective_bits, (long)len_bits,
|
||||
repeat ? "repeat" : "once", td->name);
|
||||
if(unit_bits == 1) {
|
||||
len_bytes = (len_bits + 7) >> 3;
|
||||
if(len_bits & 0x7)
|
||||
|
|
@ -1323,17 +1269,9 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
|
|||
_ASN_ENCODE_FAILED;
|
||||
|
||||
if(unit_bits == 1) {
|
||||
ASN_DEBUG("BIT STRING of %d bytes, %d bits unused",
|
||||
sizeinunits, st->bits_unused);
|
||||
sizeinunits = sizeinunits * 8 - (st->bits_unused & 0x07);
|
||||
}
|
||||
|
||||
ASN_DEBUG("Encoding %s into %d units of %d bits"
|
||||
" (%d..%d, effective %d)%s",
|
||||
td->name, sizeinunits, unit_bits,
|
||||
ct->lower_bound, ct->upper_bound,
|
||||
ct->effective_bits, ct_extensible ? " EXT" : "");
|
||||
|
||||
/* Figure out wheter size lies within PER visible consrtaint */
|
||||
|
||||
if(ct->effective_bits >= 0) {
|
||||
|
|
@ -1359,9 +1297,6 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
|
|||
/* 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(ct->effective_bits >= 0) {
|
||||
ASN_DEBUG("Encoding %d bytes (%ld), length in %d bits",
|
||||
st->size, sizeinunits - ct->lower_bound,
|
||||
ct->effective_bits);
|
||||
ret = per_put_few_bits(po, sizeinunits - ct->lower_bound,
|
||||
ct->effective_bits);
|
||||
if(ret) _ASN_ENCODE_FAILED;
|
||||
|
|
@ -1370,8 +1305,6 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
|
|||
_ASN_ENCODED_OK(er);
|
||||
}
|
||||
|
||||
ASN_DEBUG("Encoding %d bytes", st->size);
|
||||
|
||||
if(sizeinunits == 0) {
|
||||
if(uper_put_length(po, 0))
|
||||
_ASN_ENCODE_FAILED;
|
||||
|
|
@ -1383,8 +1316,6 @@ OCTET_STRING_encode_uper(asn_TYPE_descriptor_t *td,
|
|||
ssize_t maySave = uper_put_length(po, sizeinunits);
|
||||
if(maySave < 0) _ASN_ENCODE_FAILED;
|
||||
|
||||
ASN_DEBUG("Encoding %d of %d", maySave, sizeinunits);
|
||||
|
||||
ret = per_put_many_bits(po, buf, maySave * unit_bits);
|
||||
if(ret) _ASN_ENCODE_FAILED;
|
||||
|
||||
|
|
@ -1468,8 +1399,6 @@ OCTET_STRING_free(asn_TYPE_descriptor_t *td, void *sptr, int contents_only) {
|
|||
if(!td || !st)
|
||||
return;
|
||||
|
||||
ASN_DEBUG("Freeing %s as OCTET STRING", td->name);
|
||||
|
||||
if(st->buf) {
|
||||
FREEMEM(st->buf);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -108,8 +108,7 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
|
|||
tagno = step /* Continuing where left previously */
|
||||
+ (tag_mode==1?-1:0)
|
||||
;
|
||||
ASN_DEBUG("ber_check_tags(%s, size=%ld, tm=%d, step=%d, tagno=%d)",
|
||||
td->name, (long)size, tag_mode, step, tagno);
|
||||
|
||||
/* assert(td->tags_count >= 1) May not be the case for CHOICE or ANY */
|
||||
|
||||
if(tag_mode == 0 && tagno == td->tags_count) {
|
||||
|
|
@ -130,8 +129,7 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
|
|||
case -1: RETURN(RC_FAIL);
|
||||
case 0: RETURN(RC_WMORE);
|
||||
}
|
||||
ASN_DEBUG("Advancing %ld in ANY case",
|
||||
(long)(tag_len + len_len));
|
||||
|
||||
ADVANCE(tag_len + len_len);
|
||||
} else {
|
||||
assert(tagno < td->tags_count); /* At least one loop */
|
||||
|
|
@ -142,11 +140,7 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
|
|||
* Fetch and process T from TLV.
|
||||
*/
|
||||
tag_len = ber_fetch_tag(ptr, size, &tlv_tag);
|
||||
ASN_DEBUG("Fetching tag from {%p,%ld}: "
|
||||
"len %ld, step %d, tagno %d got %s",
|
||||
ptr, (long)size,
|
||||
(long)tag_len, step, tagno,
|
||||
ber_tlv_tag_string(tlv_tag));
|
||||
|
||||
switch(tag_len) {
|
||||
case -1: RETURN(RC_FAIL);
|
||||
case 0: RETURN(RC_WMORE);
|
||||
|
|
@ -170,12 +164,7 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
|
|||
/*
|
||||
* Unexpected tag. Too bad.
|
||||
*/
|
||||
ASN_DEBUG("Expected: %s, "
|
||||
"expectation failed (tn=%d, tm=%d)",
|
||||
ber_tlv_tag_string(td->tags[tagno]),
|
||||
tagno, tag_mode
|
||||
);
|
||||
RETURN(RC_FAIL);
|
||||
RETURN(RC_FAIL);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -188,15 +177,11 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
|
|||
*/
|
||||
if(tagno < (td->tags_count - 1)) {
|
||||
if(tlv_constr == 0) {
|
||||
ASN_DEBUG("tlv_constr = %d, expfail",
|
||||
tlv_constr);
|
||||
RETURN(RC_FAIL);
|
||||
}
|
||||
} else {
|
||||
if(last_tag_form != tlv_constr
|
||||
&& last_tag_form != -1) {
|
||||
ASN_DEBUG("last_tag_form %d != %d",
|
||||
last_tag_form, tlv_constr);
|
||||
RETURN(RC_FAIL);
|
||||
}
|
||||
}
|
||||
|
|
@ -206,7 +191,7 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
|
|||
*/
|
||||
len_len = ber_fetch_length(tlv_constr,
|
||||
(const char *)ptr + tag_len, size - tag_len, &tlv_len);
|
||||
ASN_DEBUG("Fetchinig len = %ld", (long)len_len);
|
||||
|
||||
switch(len_len) {
|
||||
case -1: RETURN(RC_FAIL);
|
||||
case 0: RETURN(RC_WMORE);
|
||||
|
|
@ -226,16 +211,12 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
|
|||
if(limit_len == -1) {
|
||||
expect_00_terminators++;
|
||||
} else {
|
||||
ASN_DEBUG("Unexpected indefinite length "
|
||||
"in a chain of definite lengths");
|
||||
RETURN(RC_FAIL);
|
||||
}
|
||||
ADVANCE(tag_len + len_len);
|
||||
continue;
|
||||
} else {
|
||||
if(expect_00_terminators) {
|
||||
ASN_DEBUG("Unexpected definite length "
|
||||
"in a chain of indefinite lengths");
|
||||
RETURN(RC_FAIL);
|
||||
}
|
||||
}
|
||||
|
|
@ -255,8 +236,7 @@ ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
|
|||
* Inner TLV specifies length which is inconsistent
|
||||
* with the outer TLV's length value.
|
||||
*/
|
||||
ASN_DEBUG("Outer TLV is %ld and inner is %ld",
|
||||
(long)limit_len, (long)tlv_len);
|
||||
|
||||
RETURN(RC_FAIL);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -56,50 +56,6 @@ ber_fetch_tag(const void *ptr, size_t size, ber_tlv_tag_t *tag_r) {
|
|||
|
||||
return 0; /* Want more */
|
||||
}
|
||||
|
||||
|
||||
ssize_t
|
||||
ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *f) {
|
||||
char buf[sizeof("[APPLICATION ]") + 32];
|
||||
ssize_t ret;
|
||||
|
||||
ret = ber_tlv_tag_snprint(tag, buf, sizeof(buf));
|
||||
if(ret >= (ssize_t)sizeof(buf) || ret < 2) {
|
||||
errno = EPERM;
|
||||
return -1;
|
||||
}
|
||||
|
||||
return fwrite(buf, 1, ret, f);
|
||||
}
|
||||
|
||||
ssize_t
|
||||
ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t size) {
|
||||
char *type = 0;
|
||||
int ret;
|
||||
|
||||
switch(tag & 0x3) {
|
||||
case ASN_TAG_CLASS_UNIVERSAL: type = "UNIVERSAL "; break;
|
||||
case ASN_TAG_CLASS_APPLICATION: type = "APPLICATION "; break;
|
||||
case ASN_TAG_CLASS_CONTEXT: type = ""; break;
|
||||
case ASN_TAG_CLASS_PRIVATE: type = "PRIVATE "; break;
|
||||
}
|
||||
|
||||
ret = snprintf(buf, size, "[%s%u](%02x)", type, ((unsigned)tag) >> 2, tag);
|
||||
if(ret <= 0 && size) buf[0] = '\0'; /* against broken libc's */
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
char *
|
||||
ber_tlv_tag_string(ber_tlv_tag_t tag) {
|
||||
static char buf[sizeof("[APPLICATION ]") + 32];
|
||||
|
||||
(void)ber_tlv_tag_snprint(tag, buf, sizeof(buf));
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
|
||||
size_t
|
||||
ber_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufp, size_t size) {
|
||||
int tclass = BER_TAG_CLASS(tag);
|
||||
|
|
|
|||
|
|
@ -117,8 +117,6 @@ CHOICE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
|
||||
ssize_t consumed_myself = 0; /* Consumed bytes from ptr */
|
||||
|
||||
ASN_DEBUG("Decoding %s as CHOICE", td->name);
|
||||
|
||||
/*
|
||||
* Create the target structure if it is not present already.
|
||||
*/
|
||||
|
|
@ -149,8 +147,6 @@ CHOICE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size,
|
||||
tag_mode, -1, &ctx->left, 0);
|
||||
if(rval.code != RC_OK) {
|
||||
ASN_DEBUG("%s tagging check failed: %d",
|
||||
td->name, rval.code);
|
||||
return rval;
|
||||
}
|
||||
|
||||
|
|
@ -165,16 +161,13 @@ CHOICE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
|
||||
NEXT_PHASE(ctx);
|
||||
|
||||
ASN_DEBUG("Structure consumes %ld bytes, buffer %ld",
|
||||
(long)ctx->left, (long)size);
|
||||
|
||||
/* Fall through */
|
||||
case 1:
|
||||
/*
|
||||
* Fetch the T from TLV.
|
||||
*/
|
||||
tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag);
|
||||
ASN_DEBUG("In %s CHOICE tag length %d", td->name, (int)tag_len);
|
||||
|
||||
switch(tag_len) {
|
||||
case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
|
||||
/* Fall through */
|
||||
|
|
@ -197,17 +190,11 @@ CHOICE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
ctx->step = t2m->el_no;
|
||||
break;
|
||||
} else if(specs->ext_start == -1) {
|
||||
ASN_DEBUG("Unexpected tag %s "
|
||||
"in non-extensible CHOICE %s",
|
||||
ber_tlv_tag_string(tlv_tag), td->name);
|
||||
RETURN(RC_FAIL);
|
||||
} else {
|
||||
/* Skip this tag */
|
||||
ssize_t skip;
|
||||
|
||||
ASN_DEBUG("Skipping unknown tag %s",
|
||||
ber_tlv_tag_string(tlv_tag));
|
||||
|
||||
skip = ber_skip_length(opt_codec_ctx,
|
||||
BER_TLV_CONSTRUCTED(ptr),
|
||||
(const char *)ptr + tag_len,
|
||||
|
|
@ -280,9 +267,6 @@ CHOICE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
|
||||
/* Fall through */
|
||||
case 3:
|
||||
ASN_DEBUG("CHOICE %s Leftover: %ld, size = %ld, tm=%d, tc=%d",
|
||||
td->name, (long)ctx->left, (long)size,
|
||||
tag_mode, td->tags_count);
|
||||
|
||||
if(ctx->left > 0) {
|
||||
/*
|
||||
|
|
@ -335,8 +319,6 @@ CHOICE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
continue;
|
||||
}
|
||||
} else {
|
||||
ASN_DEBUG("Unexpected continuation in %s",
|
||||
td->name);
|
||||
RETURN(RC_FAIL);
|
||||
}
|
||||
|
||||
|
|
@ -365,9 +347,6 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
|
|||
|
||||
if(!sptr) _ASN_ENCODE_FAILED;
|
||||
|
||||
ASN_DEBUG("%s %s as CHOICE",
|
||||
cb?"Encoding":"Estimating", td->name);
|
||||
|
||||
present = _fetch_present_idx(sptr,
|
||||
specs->pres_offset, specs->pres_size);
|
||||
|
||||
|
|
@ -435,9 +414,6 @@ CHOICE_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
|
|||
if(erval.encoded == -1)
|
||||
return erval;
|
||||
|
||||
ASN_DEBUG("Encoded CHOICE member in %ld bytes (+%ld)",
|
||||
(long)erval.encoded, (long)computed_size);
|
||||
|
||||
erval.encoded += computed_size;
|
||||
|
||||
return erval;
|
||||
|
|
@ -482,9 +458,6 @@ CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
|
|||
int present;
|
||||
|
||||
if(!sptr) {
|
||||
_ASN_CTFAIL(app_key, td,
|
||||
"%s: value not given (%s:%d)",
|
||||
td->name, __FILE__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -501,9 +474,7 @@ CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
|
|||
if(!memb_ptr) {
|
||||
if(elm->optional)
|
||||
return 0;
|
||||
_ASN_CTFAIL(app_key, td,
|
||||
"%s: mandatory CHOICE element %s absent (%s:%d)",
|
||||
td->name, elm->name, __FILE__, __LINE__);
|
||||
|
||||
return -1;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -524,9 +495,6 @@ CHOICE_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
|
|||
return ret;
|
||||
}
|
||||
} else {
|
||||
_ASN_CTFAIL(app_key, td,
|
||||
"%s: no CHOICE element given (%s:%d)",
|
||||
td->name, __FILE__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
|
@ -616,8 +584,7 @@ CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
elm->type, memb_ptr2, elm->name,
|
||||
buf_ptr, size);
|
||||
XER_ADVANCE(tmprval.consumed);
|
||||
ASN_DEBUG("XER/CHOICE: itdf: [%s] code=%d",
|
||||
elm->type->name, tmprval.code);
|
||||
|
||||
if(tmprval.code != RC_OK)
|
||||
RETURN(tmprval.code);
|
||||
assert(_fetch_present_idx(st,
|
||||
|
|
@ -654,17 +621,10 @@ CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
}
|
||||
|
||||
tcv = xer_check_tag(buf_ptr, ch_size, xml_tag);
|
||||
ASN_DEBUG("XER/CHOICE checked [%c%c%c%c] vs [%s], tcv=%d",
|
||||
ch_size>0?((const uint8_t *)buf_ptr)[0]:'?',
|
||||
ch_size>1?((const uint8_t *)buf_ptr)[1]:'?',
|
||||
ch_size>2?((const uint8_t *)buf_ptr)[2]:'?',
|
||||
ch_size>3?((const uint8_t *)buf_ptr)[3]:'?',
|
||||
xml_tag, tcv);
|
||||
|
||||
/* Skip the extensions section */
|
||||
if(ctx->phase == 4) {
|
||||
ASN_DEBUG("skip_unknown(%d, %ld)",
|
||||
tcv, (long)ctx->left);
|
||||
|
||||
switch(xer_skip_unknown(tcv, &ctx->left)) {
|
||||
case -1:
|
||||
ctx->phase = 5;
|
||||
|
|
@ -733,7 +693,6 @@ CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
|
||||
/* It is expected extension */
|
||||
if(specs->ext_start != -1) {
|
||||
ASN_DEBUG("Got anticipated extension");
|
||||
/*
|
||||
* Check for (XCT_BOTH or XCT_UNKNOWN_BO)
|
||||
* By using a mask. Only record a pure
|
||||
|
|
@ -755,13 +714,6 @@ CHOICE_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
break;
|
||||
}
|
||||
|
||||
ASN_DEBUG("Unexpected XML tag [%c%c%c%c] in CHOICE [%s]"
|
||||
" (ph=%d, tag=%s)",
|
||||
ch_size>0?((const uint8_t *)buf_ptr)[0]:'?',
|
||||
ch_size>1?((const uint8_t *)buf_ptr)[1]:'?',
|
||||
ch_size>2?((const uint8_t *)buf_ptr)[2]:'?',
|
||||
ch_size>3?((const uint8_t *)buf_ptr)[3]:'?',
|
||||
td->name, ctx->phase, xml_tag);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -859,8 +811,7 @@ CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
if(ct && ct->range_bits >= 0) {
|
||||
value = per_get_few_bits(pd, ct->range_bits);
|
||||
if(value < 0) _ASN_DECODE_STARVED;
|
||||
ASN_DEBUG("CHOICE %s got index %d in range %d",
|
||||
td->name, value, ct->range_bits);
|
||||
|
||||
if(value > ct->upper_bound)
|
||||
_ASN_DECODE_FAILED;
|
||||
} else {
|
||||
|
|
@ -871,7 +822,7 @@ CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
value += specs->ext_start;
|
||||
if(value >= td->elements_count)
|
||||
_ASN_DECODE_FAILED;
|
||||
ASN_DEBUG("NOT IMPLEMENTED YET");
|
||||
|
||||
_ASN_DECODE_FAILED;
|
||||
}
|
||||
|
||||
|
|
@ -890,13 +841,10 @@ CHOICE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
memb_ptr = (char *)st + elm->memb_offset;
|
||||
memb_ptr2 = &memb_ptr;
|
||||
}
|
||||
ASN_DEBUG("Discovered CHOICE %s encodes %s", td->name, elm->name);
|
||||
|
||||
rv = elm->type->uper_decoder(opt_codec_ctx, elm->type,
|
||||
elm->per_constraints, memb_ptr2, pd);
|
||||
if(rv.code != RC_OK)
|
||||
ASN_DEBUG("Failed to decode %s in %s (CHOICE)",
|
||||
elm->name, td->name);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
|
@ -911,8 +859,6 @@ CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
|
|||
|
||||
if(!sptr) _ASN_ENCODE_FAILED;
|
||||
|
||||
ASN_DEBUG("Encoding %s as CHOICE", td->name);
|
||||
|
||||
if(constraints) ct = &constraints->value;
|
||||
else if(td->per_constraints) ct = &td->per_constraints->value;
|
||||
else ct = 0;
|
||||
|
|
@ -933,8 +879,6 @@ CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
|
|||
if(specs->canonical_order)
|
||||
present = specs->canonical_order[present];
|
||||
|
||||
ASN_DEBUG("Encoding %s CHOICE element %d", td->name, present);
|
||||
|
||||
if(ct && ct->range_bits >= 0) {
|
||||
if(present < ct->lower_bound
|
||||
|| present > ct->upper_bound) {
|
||||
|
|
@ -959,7 +903,7 @@ CHOICE_encode_uper(asn_TYPE_descriptor_t *td,
|
|||
_ASN_ENCODE_FAILED;
|
||||
if(uper_put_nsnnwn(po, present - specs->ext_start))
|
||||
_ASN_ENCODE_FAILED;
|
||||
ASN_DEBUG("NOT IMPLEMENTED YET");
|
||||
|
||||
_ASN_ENCODE_FAILED;
|
||||
}
|
||||
|
||||
|
|
@ -1026,8 +970,6 @@ CHOICE_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
|
|||
if(!td || !ptr)
|
||||
return;
|
||||
|
||||
ASN_DEBUG("Freeing %s as CHOICE", td->name);
|
||||
|
||||
/*
|
||||
* Figure out which CHOICE element is encoded.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -127,8 +127,6 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
|
||||
ssize_t consumed_myself = 0; /* Consumed bytes from ptr */
|
||||
int edx; /* SEQUENCE element's index */
|
||||
|
||||
ASN_DEBUG("Decoding %s as SEQUENCE", td->name);
|
||||
|
||||
/*
|
||||
* Create the target structure if it is not present already.
|
||||
|
|
@ -159,8 +157,6 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size,
|
||||
tag_mode, 1, &ctx->left, 0);
|
||||
if(rval.code != RC_OK) {
|
||||
ASN_DEBUG("%s tagging check failed: %d",
|
||||
td->name, rval.code);
|
||||
return rval;
|
||||
}
|
||||
|
||||
|
|
@ -170,9 +166,6 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
|
||||
NEXT_PHASE(ctx);
|
||||
|
||||
ASN_DEBUG("Structure consumes %ld bytes, buffer %ld",
|
||||
(long)ctx->left, (long)size);
|
||||
|
||||
/* Fall through */
|
||||
case 1:
|
||||
/*
|
||||
|
|
@ -200,11 +193,6 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
/*
|
||||
* MICROPHASE 1: Synchronize decoding.
|
||||
*/
|
||||
ASN_DEBUG("In %s SEQUENCE left %d, edx=%d flags=%d"
|
||||
" opt=%d ec=%d",
|
||||
td->name, (int)ctx->left, edx,
|
||||
elements[edx].flags, elements[edx].optional,
|
||||
td->elements_count);
|
||||
|
||||
if(ctx->left == 0 /* No more stuff is expected */
|
||||
&& (
|
||||
|
|
@ -217,7 +205,6 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
&& specs->ext_before > td->elements_count)
|
||||
)
|
||||
) {
|
||||
ASN_DEBUG("End of SEQUENCE %s", td->name);
|
||||
/*
|
||||
* Found the legitimate end of the structure.
|
||||
*/
|
||||
|
|
@ -229,10 +216,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
* Fetch the T from TLV.
|
||||
*/
|
||||
tag_len = ber_fetch_tag(ptr, LEFT, &tlv_tag);
|
||||
ASN_DEBUG("Current tag in %s SEQUENCE for element %d "
|
||||
"(%s) is %s encoded in %d bytes, of frame %ld",
|
||||
td->name, edx, elements[edx].name,
|
||||
ber_tlv_tag_string(tlv_tag), (int)tag_len, (long)LEFT);
|
||||
|
||||
switch(tag_len) {
|
||||
case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
|
||||
/* Fall through */
|
||||
|
|
@ -246,9 +230,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
else
|
||||
RETURN(RC_WMORE);
|
||||
} else if(((const uint8_t *)ptr)[1] == 0) {
|
||||
ASN_DEBUG("edx = %d, opt = %d, ec=%d",
|
||||
edx, elements[edx].optional,
|
||||
td->elements_count);
|
||||
|
||||
if((edx + elements[edx].optional
|
||||
== td->elements_count)
|
||||
|| (IN_EXTENSION_GROUP(specs, edx)
|
||||
|
|
@ -347,13 +329,6 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
* or an end of the indefinite-length structure.
|
||||
*/
|
||||
if(!IN_EXTENSION_GROUP(specs, edx)) {
|
||||
ASN_DEBUG("Unexpected tag %s (at %d)",
|
||||
ber_tlv_tag_string(tlv_tag), edx);
|
||||
ASN_DEBUG("Expected tag %s (%s)%s",
|
||||
ber_tlv_tag_string(elements[edx].tag),
|
||||
elements[edx].name,
|
||||
elements[edx].optional
|
||||
?" or alternatives":"");
|
||||
RETURN(RC_FAIL);
|
||||
} else {
|
||||
/* Skip this tag */
|
||||
|
|
@ -363,8 +338,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
BER_TLV_CONSTRUCTED(ptr),
|
||||
(const char *)ptr + tag_len,
|
||||
LEFT - tag_len);
|
||||
ASN_DEBUG("Skip length %d in %s",
|
||||
(int)skip, td->name);
|
||||
|
||||
switch(skip) {
|
||||
case 0: if(!SIZE_VIOLATION) RETURN(RC_WMORE);
|
||||
/* Fall through */
|
||||
|
|
@ -383,7 +357,6 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
*/
|
||||
ctx->step |= 1; /* Confirm entering next microphase */
|
||||
microphase2:
|
||||
ASN_DEBUG("Inside SEQUENCE %s MF2", td->name);
|
||||
|
||||
/*
|
||||
* Compute the position of the member inside a structure,
|
||||
|
|
@ -408,10 +381,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
elements[edx].type,
|
||||
memb_ptr2, ptr, LEFT,
|
||||
elements[edx].tag_mode);
|
||||
ASN_DEBUG("In %s SEQUENCE decoded %d %s of %d "
|
||||
"in %d bytes rval.code %d, size=%d",
|
||||
td->name, edx, elements[edx].type->name,
|
||||
(int)LEFT, (int)rval.consumed, rval.code, (int)size);
|
||||
|
||||
switch(rval.code) {
|
||||
case RC_OK:
|
||||
break;
|
||||
|
|
@ -420,8 +390,7 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
ADVANCE(rval.consumed);
|
||||
RETURN(RC_WMORE);
|
||||
}
|
||||
ASN_DEBUG("Size violation (c->l=%ld <= s=%ld)",
|
||||
(long)ctx->left, (long)size);
|
||||
|
||||
/* Fall through */
|
||||
case RC_FAIL: /* Fatal error */
|
||||
RETURN(RC_FAIL);
|
||||
|
|
@ -435,9 +404,6 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
case 3: /* 00 and other tags expected */
|
||||
case 4: /* only 00's expected */
|
||||
|
||||
ASN_DEBUG("SEQUENCE %s Leftover: %ld, size = %ld",
|
||||
td->name, (long)ctx->left, (long)size);
|
||||
|
||||
/*
|
||||
* Skip everything until the end of the SEQUENCE.
|
||||
*/
|
||||
|
|
@ -474,11 +440,6 @@ SEQUENCE_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
|
||||
if(!IN_EXTENSION_GROUP(specs, td->elements_count)
|
||||
|| ctx->phase == 4) {
|
||||
ASN_DEBUG("Unexpected continuation "
|
||||
"of a non-extensible type "
|
||||
"%s (SEQUENCE): %s",
|
||||
td->name,
|
||||
ber_tlv_tag_string(tlv_tag));
|
||||
RETURN(RC_FAIL);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -84,8 +84,6 @@ SET_OF_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
asn_dec_rval_t rval; /* Return code from subparsers */
|
||||
|
||||
ssize_t consumed_myself = 0; /* Consumed bytes from ptr */
|
||||
|
||||
ASN_DEBUG("Decoding %s as SET OF", td->name);
|
||||
|
||||
/*
|
||||
* Create the target structure if it is not present already.
|
||||
|
|
@ -116,8 +114,6 @@ SET_OF_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
rval = ber_check_tags(opt_codec_ctx, td, ctx, ptr, size,
|
||||
tag_mode, 1, &ctx->left, 0);
|
||||
if(rval.code != RC_OK) {
|
||||
ASN_DEBUG("%s tagging check failed: %d",
|
||||
td->name, rval.code);
|
||||
return rval;
|
||||
}
|
||||
|
||||
|
|
@ -125,9 +121,6 @@ SET_OF_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
ctx->left += rval.consumed; /* ?Substracted below! */
|
||||
ADVANCE(rval.consumed);
|
||||
|
||||
ASN_DEBUG("Structure consumes %ld bytes, "
|
||||
"buffer %ld", (long)ctx->left, (long)size);
|
||||
|
||||
NEXT_PHASE(ctx);
|
||||
/* Fall through */
|
||||
case 1:
|
||||
|
|
@ -147,7 +140,6 @@ SET_OF_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
*/
|
||||
|
||||
if(ctx->left == 0) {
|
||||
ASN_DEBUG("End of SET OF %s", td->name);
|
||||
/*
|
||||
* No more things to decode.
|
||||
* Exit out of here.
|
||||
|
|
@ -188,10 +180,6 @@ SET_OF_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
* The new list member of expected type has arrived.
|
||||
*/
|
||||
} else {
|
||||
ASN_DEBUG("Unexpected tag %s fixed SET OF %s",
|
||||
ber_tlv_tag_string(tlv_tag), td->name);
|
||||
ASN_DEBUG("%s SET OF has tag %s",
|
||||
td->name, ber_tlv_tag_string(elm->tag));
|
||||
RETURN(RC_FAIL);
|
||||
}
|
||||
}
|
||||
|
|
@ -207,9 +195,7 @@ SET_OF_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
*/
|
||||
rval = elm->type->ber_decoder(opt_codec_ctx,
|
||||
elm->type, &ctx->ptr, ptr, LEFT, 0);
|
||||
ASN_DEBUG("In %s SET OF %s code %d consumed %d",
|
||||
td->name, elm->type->name,
|
||||
rval.code, (int)rval.consumed);
|
||||
|
||||
switch(rval.code) {
|
||||
case RC_OK:
|
||||
{
|
||||
|
|
@ -324,8 +310,6 @@ SET_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
|
|||
int ret;
|
||||
int edx;
|
||||
|
||||
ASN_DEBUG("Estimating size for SET OF %s", td->name);
|
||||
|
||||
/*
|
||||
* Gather the length of the underlying members sequence.
|
||||
*/
|
||||
|
|
@ -374,8 +358,6 @@ SET_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
|
|||
return erval;
|
||||
}
|
||||
|
||||
ASN_DEBUG("Encoding members of %s SET OF", td->name);
|
||||
|
||||
/*
|
||||
* Encode all members.
|
||||
*/
|
||||
|
|
@ -523,7 +505,6 @@ SET_OF_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
asn_dec_rval_t tmprval;
|
||||
|
||||
/* Invoke the inner type decoder, m.b. multiple times */
|
||||
ASN_DEBUG("XER/SET OF element [%s]", elm_tag);
|
||||
tmprval = element->type->xer_decoder(opt_codec_ctx,
|
||||
element->type, &ctx->ptr, elm_tag,
|
||||
buf_ptr, size);
|
||||
|
|
@ -538,7 +519,6 @@ SET_OF_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
RETURN(tmprval.code);
|
||||
}
|
||||
ctx->phase = 1; /* Back to body processing */
|
||||
ASN_DEBUG("XER/SET OF phase => %d", ctx->phase);
|
||||
/* Fall through */
|
||||
}
|
||||
|
||||
|
|
@ -562,8 +542,7 @@ SET_OF_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
}
|
||||
|
||||
tcv = xer_check_tag(buf_ptr, ch_size, xml_tag);
|
||||
ASN_DEBUG("XER/SET OF: tcv = %d, ph=%d t=%s",
|
||||
tcv, ctx->phase, xml_tag);
|
||||
|
||||
switch(tcv) {
|
||||
case XCT_CLOSING:
|
||||
if(ctx->phase == 0) break;
|
||||
|
|
@ -587,7 +566,6 @@ SET_OF_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
case XCT_UNKNOWN_OP:
|
||||
case XCT_UNKNOWN_BO:
|
||||
|
||||
ASN_DEBUG("XER/SET OF: tcv=%d, ph=%d", tcv, ctx->phase);
|
||||
if(ctx->phase == 1) {
|
||||
/*
|
||||
* Process a single possible member.
|
||||
|
|
@ -600,7 +578,6 @@ SET_OF_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
break;
|
||||
}
|
||||
|
||||
ASN_DEBUG("Unexpected XML tag in SET OF");
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -819,9 +796,6 @@ SET_OF_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
|
|||
int i;
|
||||
|
||||
if(!sptr) {
|
||||
_ASN_CTFAIL(app_key, td,
|
||||
"%s: value not given (%s:%d)",
|
||||
td->name, __FILE__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -890,8 +864,7 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
if(ct && ct->effective_bits >= 0) {
|
||||
/* X.691, #19.5: No length determinant */
|
||||
nelems = per_get_few_bits(pd, ct->effective_bits);
|
||||
ASN_DEBUG("Preparing to fetch %ld+%ld elements from %s",
|
||||
(long)nelems, ct->lower_bound, td->name);
|
||||
|
||||
if(nelems < 0) _ASN_DECODE_STARVED;
|
||||
nelems += ct->lower_bound;
|
||||
} else {
|
||||
|
|
@ -908,20 +881,11 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
|
||||
for(i = 0; i < nelems; i++) {
|
||||
void *ptr = 0;
|
||||
ASN_DEBUG("SET OF %s decoding", elm->type->name);
|
||||
rv = elm->type->uper_decoder(opt_codec_ctx, elm->type,
|
||||
elm->per_constraints, &ptr, pd);
|
||||
ASN_DEBUG("%s SET OF %s decoded %d, %p",
|
||||
td->name, elm->type->name, rv.code, ptr);
|
||||
|
||||
if(rv.code == RC_OK) {
|
||||
if(ASN_SET_ADD(list, ptr) == 0)
|
||||
continue;
|
||||
ASN_DEBUG("Failed to add element into %s",
|
||||
td->name);
|
||||
/* Fall through */
|
||||
} else {
|
||||
ASN_DEBUG("Failed decoding %s of %s (SET OF)",
|
||||
elm->type->name, td->name);
|
||||
}
|
||||
if(ptr) ASN_STRUCT_FREE(*elm->type, ptr);
|
||||
return rv;
|
||||
|
|
@ -930,8 +894,6 @@ SET_OF_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|||
nelems = -1; /* Allow uper_get_length() */
|
||||
} while(repeat);
|
||||
|
||||
ASN_DEBUG("Decoded %s as SET OF", td->name);
|
||||
|
||||
rv.code = RC_OK;
|
||||
rv.consumed = 0;
|
||||
return rv;
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue