/* * X.691 (08/2015) #11.9 "General rules for encoding a length determinant" * Put the length "n" (or part of it) into the stream. */ ssize_t uper_put_length(asn_per_outp_t *po, size_t length, int *need_eom) { int dummy = 0; if(!need_eom) need_eom = &dummy; if(length <= 127) { /* #11.9.3.6 */ *need_eom = 0; return per_put_few_bits(po, length, 8) ? -1 : (ssize_t)length; } else if(length < 16384) { /* #10.9.3.7 */ *need_eom = 0; return per_put_few_bits(po, length|0x8000, 16) ? -1 : (ssize_t)length; } *need_eom = 0 == (length & 16383); length >>= 14; if(length > 4) { *need_eom = 0; length = 4; } return per_put_few_bits(po, 0xC0 | length, 8) ? -1 : (ssize_t)(length << 14); }
/* X.691-2008/11, #11.5.6 -> #11.3 */ int uper_put_constrained_whole_number_u(asn_per_outp_t *po, unsigned long v, int nbits) { if(nbits <= 31) { return per_put_few_bits(po, v, nbits); } else { /* Put higher portion first, followed by lower 31-bit */ if(uper_put_constrained_whole_number_u(po, v >> 31, nbits - 31)) return -1; return per_put_few_bits(po, v, 31); } }
/* * X.691-11/2008, #11.6 * Encoding of a normally small non-negative whole number */ int uper_put_nsnnwn(asn_per_outp_t *po, int n) { int bytes; if(n <= 63) { if(n < 0) return -1; return per_put_few_bits(po, n, 7); } if(n < 256) bytes = 1; else if(n < 65536) bytes = 2; else if(n < 256 * 65536) bytes = 3; else return -1; /* This is not a "normally small" value */ if(per_put_few_bits(po, bytes, 8)) return -1; return per_put_few_bits(po, n, 8 * bytes); }
asn_enc_rval_t BOOLEAN_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { const BOOLEAN_t *st = (const BOOLEAN_t *)sptr; asn_enc_rval_t er = { 0, 0, 0 }; (void)constraints; if(!st) ASN__ENCODE_FAILED; if(per_put_few_bits(po, *st ? 1 : 0, 1)) ASN__ENCODE_FAILED; ASN__ENCODED_OK(er); }
/* * Put the normally small length "n" into the stream. * This procedure used to encode length of extensions bit-maps * for SET and SEQUENCE types. */ int uper_put_nslength(asn_per_outp_t *po, size_t length) { if(length <= 64) { /* #11.9.3.4 */ if(length == 0) return -1; return per_put_few_bits(po, length - 1, 7) ? -1 : 0; } else { int need_eom = 0; if(uper_put_length(po, length, &need_eom) != (ssize_t)length || need_eom) { /* This might happen in case of >16K extensions */ return -1; } } return 0; }
asn_enc_rval_t NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics; asn_enc_rval_t er; long native, value; asn_per_constraint_t *ct; int inext = 0; asn_INTEGER_enum_map_t key; asn_INTEGER_enum_map_t *kf; if(!sptr) _ASN_ENCODE_FAILED; if(!specs) _ASN_ENCODE_FAILED; if(constraints) ct = &constraints->value; else if(td->per_constraints) ct = &td->per_constraints->value; else _ASN_ENCODE_FAILED; /* Mandatory! */ ASN_DEBUG("Encoding %s as NativeEnumerated", td->name); er.encoded = 0; native = *(long *)sptr; if(native < 0) _ASN_ENCODE_FAILED; key.nat_value = native; kf = bsearch(&key, specs->value2enum, specs->map_count, sizeof(key), NativeEnumerated__compar_value2enum); if(!kf) { ASN_DEBUG("No element corresponds to %ld", native); _ASN_ENCODE_FAILED; } value = kf - specs->value2enum; if(ct->range_bits >= 0) { int cmpWith = specs->extension ? specs->extension - 1 : specs->map_count; if(value >= cmpWith) inext = 1; } if(ct->flags & APC_EXTENSIBLE) { if(per_put_few_bits(po, inext, 0)) _ASN_ENCODE_FAILED; ct = 0; } else if(inext) { _ASN_ENCODE_FAILED; } if(ct && ct->range_bits >= 0) { if(per_put_few_bits(po, value, ct->range_bits)) _ASN_ENCODE_FAILED; _ASN_ENCODED_OK(er); } if(!specs->extension) _ASN_ENCODE_FAILED; /* * X.691, #10.6: normally small non-negative whole number; */ if(uper_put_nsnnwn(po, value - (specs->extension - 1))) _ASN_ENCODE_FAILED; _ASN_ENCODED_OK(er); }
asn_enc_rval_t CHOICE_encode_uper(Allocator * allocator, asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics; asn_TYPE_member_t *elm; /* CHOICE's element */ asn_per_constraint_t *ct; void *memb_ptr; int present; int present_enc; 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; present = _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size); /* * If the structure was not initialized properly, it cannot be encoded: * can't deduce what to encode in the choice type. */ if(present <= 0 || present > td->elements_count) _ASN_ENCODE_FAILED; else present--; ASN_DEBUG("Encoding %s CHOICE element %d", td->name, present); /* Adjust if canonical order is different from natural order */ if(specs->canonical_order) present_enc = specs->canonical_order[present]; else present_enc = present; if(ct && ct->range_bits >= 0) { if(present_enc < ct->lower_bound || present_enc > ct->upper_bound) { if(ct->flags & asn_per_constraint_s::APC_EXTENSIBLE) { if(per_put_few_bits(allocator, po, 1, 1)) _ASN_ENCODE_FAILED; } else { _ASN_ENCODE_FAILED; } ct = 0; } } if(ct && ct->flags & asn_per_constraint_s::APC_EXTENSIBLE) if(per_put_few_bits(allocator, po, 0, 1)) _ASN_ENCODE_FAILED; elm = &td->elements[present]; if(elm->flags & ATF_POINTER) { /* Member is a pointer to another structure */ memb_ptr = *(void **)((char *)sptr + elm->memb_offset); if(!memb_ptr) _ASN_ENCODE_FAILED; } else { memb_ptr = (char *)sptr + elm->memb_offset; } if(ct && ct->range_bits >= 0) { if(per_put_few_bits(allocator, po, present_enc, ct->range_bits)) _ASN_ENCODE_FAILED; return elm->type->uper_encoder(allocator, elm->type, elm->per_constraints, memb_ptr, po); } else { asn_enc_rval_t rval; if(specs->ext_start == -1) _ASN_ENCODE_FAILED; if(uper_put_nsnnwn(allocator, po, present_enc - specs->ext_start)) _ASN_ENCODE_FAILED; if(uper_open_type_put(allocator, elm->type, elm->per_constraints, memb_ptr, po)) _ASN_ENCODE_FAILED; rval.encoded = 0; _ASN_ENCODED_OK(rval); } }
asn_enc_rval_t SEQUENCE_OF_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) { asn_anonymous_sequence_ *list; asn_per_constraint_t *ct; asn_enc_rval_t er; asn_TYPE_member_t *elm = td->elements; int seq; if(!sptr) _ASN_ENCODE_FAILED; list = _A_SEQUENCE_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->per_constraints) ct = &td->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 & asn_per_constraint_t::APC_EXTENSIBLE ? "ext" : "fix"); if(ct->flags & asn_per_constraint_t::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; } for(seq = -1; seq < list->count;) { ssize_t mayEncode; if(seq < 0) seq = 0; if(ct && ct->effective_bits >= 0) { mayEncode = list->count; } else { mayEncode = uper_put_length(po, list->count - seq); if(mayEncode < 0) _ASN_ENCODE_FAILED; } while(mayEncode--) { void *memb_ptr = list->array[seq++]; if(!memb_ptr) _ASN_ENCODE_FAILED; er = elm->type->uper_encoder(elm->type, elm->per_constraints, memb_ptr, po); if(er.encoded == -1) _ASN_ENCODE_FAILED; } } _ASN_ENCODED_OK(er); }
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; } }