int
SET_OF_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_TYPE_member_t *elm = td->elements;
const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
int ret;
int i;
if(!sptr) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
/* Dump preamble */
if(cb(td->name, strlen(td->name), app_key) < 0
|| cb(" ::= {", 6, app_key) < 0)
return -1;
for(i = 0; i < list->count; i++) {
const void *memb_ptr = list->array[i];
if(!memb_ptr) continue;
_i_INDENT(1);
ret = elm->type->print_struct(elm->type, memb_ptr,
ilevel + 1, cb, app_key);
if(ret) return ret;
}
ilevel--;
_i_INDENT(1);
return (cb("}", 1, app_key) < 0) ? -1 : 0;
}
int
SET_OF_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
const asn_TYPE_member_t *elm = td->elements;
asn_constr_check_f *constr;
const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
int i;
if(!sptr) {
ASN__CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
constr = elm->encoding_constraints.general_constraints;
if(!constr) constr = elm->type->encoding_constraints.general_constraints;
/*
* Iterate over the members of an array.
* Validate each in turn, until one fails.
*/
for(i = 0; i < list->count; i++) {
const void *memb_ptr = list->array[i];
int ret;
if(!memb_ptr) continue;
ret = constr(elm->type, memb_ptr, ctfailcb, app_key);
if(ret) return ret;
}
return 0;
}
int
SET_OF_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
asn_TYPE_member_t *elm = td->elements;
asn_constr_check_f *constr;
const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
int i;
if(!sptr) {
_ASN_CTFAIL(app_key, td, sptr,
"%s: value not given (%s:%d)",
td->name, __FILE__, __LINE__);
return -1;
}
constr = elm->memb_constraints;
if(!constr) constr = elm->type->check_constraints;
/*
* Iterate over the members of an array.
* Validate each in turn, until one fails.
*/
for(i = 0; i < list->count; i++) {
const void *memb_ptr = list->array[i];
int ret;
if(!memb_ptr) continue;
ret = constr(elm->type, memb_ptr, ctfailcb, app_key);
if(ret) return ret;
}
/*
* Cannot inherit it eralier:
* need to make sure we get the updated version.
*/
if(!elm->memb_constraints)
elm->memb_constraints = elm->type->check_constraints;
return 0;
}
asn_enc_rval_t
SET_OF_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
void *app_key) {
asn_enc_rval_t er;
const asn_SET_OF_specifics_t *specs = (const asn_SET_OF_specifics_t *)td->specifics;
const asn_TYPE_member_t *elm = td->elements;
const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
const char *mname = specs->as_XMLValueList
? 0 : ((*elm->name) ? elm->name : elm->type->xml_tag);
size_t mlen = mname ? strlen(mname) : 0;
int xcan = (flags & XER_F_CANONICAL);
xer_tmp_enc_t *encs = 0;
size_t encs_count = 0;
void *original_app_key = app_key;
asn_app_consume_bytes_f *original_cb = cb;
int i;
if(!sptr) ASN__ENCODE_FAILED;
if(xcan) {
encs = (xer_tmp_enc_t *)MALLOC(list->count * sizeof(encs[0]));
if(!encs) ASN__ENCODE_FAILED;
cb = SET_OF_encode_xer_callback;
}
er.encoded = 0;
for(i = 0; i < list->count; i++) {
asn_enc_rval_t tmper;
void *memb_ptr = list->array[i];
if(!memb_ptr) continue;
if(encs) {
memset(&encs[encs_count], 0, sizeof(encs[0]));
app_key = &encs[encs_count];
encs_count++;
}
if(mname) {
if(!xcan) ASN__TEXT_INDENT(1, ilevel);
ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
}
if(!xcan && specs->as_XMLValueList == 1)
ASN__TEXT_INDENT(1, ilevel + 1);
tmper = elm->type->op->xer_encoder(elm->type, memb_ptr,
ilevel + (specs->as_XMLValueList != 2),
flags, cb, app_key);
if(tmper.encoded == -1) return tmper;
er.encoded += tmper.encoded;
if(tmper.encoded == 0 && specs->as_XMLValueList) {
const char *name = elm->type->xml_tag;
size_t len = strlen(name);
ASN__CALLBACK3("<", 1, name, len, "/>", 2);
}
if(mname) {
ASN__CALLBACK3("</", 2, mname, mlen, ">", 1);
}
}
if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
if(encs) {
xer_tmp_enc_t *enc = encs;
xer_tmp_enc_t *end = encs + encs_count;
ssize_t control_size = 0;
er.encoded = 0;
cb = original_cb;
app_key = original_app_key;
qsort(encs, encs_count, sizeof(encs[0]), SET_OF_xer_order);
for(; enc < end; enc++) {
ASN__CALLBACK(enc->buffer, enc->offset);
FREEMEM(enc->buffer);
enc->buffer = 0;
control_size += enc->offset;
}
assert(control_size == er.encoded);
}
goto cleanup;
cb_failed:
ASN__ENCODE_FAILED;
cleanup:
if(encs) {
size_t n;
for(n = 0; n < encs_count; n++) {
FREEMEM(encs[n].buffer);
}
FREEMEM(encs);
}
ASN__ENCODED_OK(er);
}
/*
* The DER encoder of the SET OF type.
*/
asn_enc_rval_t
SET_OF_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,
int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,
void *app_key) {
const asn_TYPE_member_t *elm = td->elements;
const asn_anonymous_set_ *list = _A_CSET_FROM_VOID(sptr);
size_t computed_size = 0;
ssize_t encoding_size = 0;
struct _el_buffer *encoded_els;
int edx;
ASN_DEBUG("Estimating size for SET OF %s", td->name);
/*
* Gather the length of the underlying members sequence.
*/
for(edx = 0; edx < list->count; edx++) {
void *memb_ptr = list->array[edx];
asn_enc_rval_t erval;
if(!memb_ptr) ASN__ENCODE_FAILED;
erval =
elm->type->op->der_encoder(elm->type, memb_ptr, 0, elm->tag, 0, 0);
if(erval.encoded == -1) return erval;
computed_size += erval.encoded;
}
/*
* Encode the TLV for the sequence itself.
*/
encoding_size =
der_write_tags(td, computed_size, tag_mode, 1, tag, cb, app_key);
if(encoding_size < 0) {
ASN__ENCODE_FAILED;
}
computed_size += encoding_size;
if(!cb || list->count == 0) {
asn_enc_rval_t erval;
erval.encoded = computed_size;
ASN__ENCODED_OK(erval);
}
ASN_DEBUG("Encoding members of %s SET OF", td->name);
/*
* DER mandates dynamic sorting of the SET OF elements
* according to their encodings. Build an array of the
* encoded elements.
*/
encoded_els = SET_OF__encode_sorted(elm, list, SOES_DER);
/*
* Report encoded elements to the application.
* Dispose of temporary sorted members table.
*/
for(edx = 0; edx < list->count; edx++) {
struct _el_buffer *encoded_el = &encoded_els[edx];
/* Report encoded chunks to the application */
if(cb(encoded_el->buf, encoded_el->length, app_key) < 0) {
break;
} else {
encoding_size += encoded_el->length;
}
}
SET_OF__encode_sorted_free(encoded_els, list->count);
if(edx == list->count) {
asn_enc_rval_t erval;
assert(computed_size == (size_t)encoding_size);
erval.encoded = computed_size;
ASN__ENCODED_OK(erval);
} else {
ASN__ENCODE_FAILED;
}
}
int
SET_OF_compare(const asn_TYPE_descriptor_t *td, const void *aptr,
const void *bptr) {
const asn_anonymous_set_ *a = _A_CSET_FROM_VOID(aptr);
const asn_anonymous_set_ *b = _A_CSET_FROM_VOID(bptr);
if(a && b) {
struct comparable_ptr *asorted;
struct comparable_ptr *bsorted;
ssize_t common_length;
ssize_t idx;
if(a->count == 0) {
if(b->count) return -1;
return 0;
} else if(b->count == 0) {
return 1;
}
asorted = MALLOC(a->count * sizeof(asorted[0]));
bsorted = MALLOC(b->count * sizeof(bsorted[0]));
if(!asorted || !bsorted) {
FREEMEM(asorted);
FREEMEM(bsorted);
return -1;
}
for(idx = 0; idx < a->count; idx++) {
asorted[idx].td = td->elements->type;
asorted[idx].sptr = a->array[idx];
}
for(idx = 0; idx < b->count; idx++) {
bsorted[idx].td = td->elements->type;
bsorted[idx].sptr = b->array[idx];
}
qsort(asorted, a->count, sizeof(asorted[0]), SET_OF__compare_cb);
qsort(bsorted, b->count, sizeof(bsorted[0]), SET_OF__compare_cb);
common_length = (a->count < b->count ? a->count : b->count);
for(idx = 0; idx < common_length; idx++) {
int ret = td->elements->type->op->compare_struct(
td->elements->type, asorted[idx].sptr, bsorted[idx].sptr);
if(ret) {
FREEMEM(asorted);
FREEMEM(bsorted);
return ret;
}
}
FREEMEM(asorted);
FREEMEM(bsorted);
if(idx < b->count) /* more elements in b */
return -1; /* a is shorter, so put it first */
if(idx < a->count) return 1;
} else if(!a) {
return -1;
} else if(!b) {
return 1;
}
return 0;
}
asn_enc_rval_t
SET_OF_encode_uper(const asn_TYPE_descriptor_t *td,
const asn_per_constraints_t *constraints, const void *sptr,
asn_per_outp_t *po) {
const asn_anonymous_set_ *list;
const asn_per_constraint_t *ct;
const asn_TYPE_member_t *elm = td->elements;
struct _el_buffer *encoded_els;
asn_enc_rval_t er;
size_t encoded_edx;
if(!sptr) ASN__ENCODE_FAILED;
list = _A_CSET_FROM_VOID(sptr);
er.encoded = 0;
ASN_DEBUG("Encoding %s as SEQUENCE OF (%d)", td->name, list->count);
if(constraints) ct = &constraints->size;
else if(td->encoding_constraints.per_constraints)
ct = &td->encoding_constraints.per_constraints->size;
else ct = 0;
/* If extensible constraint, check if size is in root */
if(ct) {
int not_in_root =
(list->count < ct->lower_bound || list->count > ct->upper_bound);
ASN_DEBUG("lb %ld ub %ld %s", ct->lower_bound, ct->upper_bound,
ct->flags & APC_EXTENSIBLE ? "ext" : "fix");
if(ct->flags & APC_EXTENSIBLE) {
/* Declare whether size is in extension root */
if(per_put_few_bits(po, not_in_root, 1)) ASN__ENCODE_FAILED;
if(not_in_root) ct = 0;
} else if(not_in_root && ct->effective_bits >= 0) {
ASN__ENCODE_FAILED;
}
}
if(ct && ct->effective_bits >= 0) {
/* X.691, #19.5: No length determinant */
if(per_put_few_bits(po, list->count - ct->lower_bound,
ct->effective_bits))
ASN__ENCODE_FAILED;
} else if(list->count == 0) {
/* When the list is empty add only the length determinant
* X.691, #20.6 and #11.9.4.1
*/
if (uper_put_length(po, 0, 0)) {
ASN__ENCODE_FAILED;
}
ASN__ENCODED_OK(er);
}
/*
* Canonical UPER #22.1 mandates dynamic sorting of the SET OF elements
* according to their encodings. Build an array of the encoded elements.
*/
encoded_els = SET_OF__encode_sorted(elm, list, SOES_CUPER);
for(encoded_edx = 0; (ssize_t)encoded_edx < list->count;) {
ssize_t may_encode;
size_t edx;
int need_eom = 0;
if(ct && ct->effective_bits >= 0) {
may_encode = list->count;
} else {
may_encode =
uper_put_length(po, list->count - encoded_edx, &need_eom);
if(may_encode < 0) ASN__ENCODE_FAILED;
}
for(edx = encoded_edx; edx < encoded_edx + may_encode; edx++) {
const struct _el_buffer *el = &encoded_els[edx];
if(asn_put_many_bits(po, el->buf,
(8 * el->length) - el->bits_unused) < 0) {
break;
}
}
if(need_eom && uper_put_length(po, 0, 0))
ASN__ENCODE_FAILED; /* End of Message length */
encoded_edx += may_encode;
}
SET_OF__encode_sorted_free(encoded_els, list->count);
if((ssize_t)encoded_edx == list->count) {
ASN__ENCODED_OK(er);
} else {
ASN__ENCODE_FAILED;
}
}
