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; } }