static void
save_object_as(PDU_t *st, enum der_or_xer how) {
asn_enc_rval_t rval; /* Return value */
buf_offset = 0;
/*
* Save object using specified method.
*/
switch(how) {
case AS_DER:
rval = der_encode(&asn_DEF_PDU, st,
_buf_writer, 0);
break;
case AS_XER:
rval = xer_encode(&asn_DEF_PDU, st, XER_F_BASIC,
_buf_writer, 0);
break;
case AS_CXER:
rval = xer_encode(&asn_DEF_PDU, st, XER_F_CANONICAL,
_buf_writer, 0);
break;
}
if (rval.encoded == -1) {
fprintf(stderr,
"Cannot encode %s: %s\n",
rval.failed_type->name, strerror(errno));
assert(rval.encoded != -1);
return;
}
fprintf(stderr, "SAVED OBJECT IN SIZE %d\n", buf_offset);
}
asn_enc_rval_t x2ap_xer_print_x2ap_e_rabs_admitted_list(
asn_app_consume_bytes_f *cb,
void *app_key,
X2ap_E_RABs_Admitted_ListIEs_t *x2ap_E_RABs_Admitted_ListIEs) {
int i;
asn_enc_rval_t er;
for (i = 0; i < x2ap_E_RABs_Admitted_ListIEs->x2ap_E_RABs_Admitted_Item.count; i++) {
er = xer_encode(&asn_DEF_X2ap_E_RABs_Admitted_Item, x2ap_E_RABs_Admitted_ListIEs->x2ap_E_RABs_Admitted_Item.array[i], XER_F_BASIC, cb, app_key);
}
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t x2ap_xer_print_x2ap_cellmeasurementresult_list(
asn_app_consume_bytes_f *cb,
void *app_key,
X2ap_CellMeasurementResult_ListIEs_t *x2ap_CellMeasurementResult_ListIEs) {
int i;
asn_enc_rval_t er;
for (i = 0; i < x2ap_CellMeasurementResult_ListIEs->x2ap_CellMeasurementResult_Item.count; i++) {
er = xer_encode(&asn_DEF_X2ap_CellMeasurementResult_Item, x2ap_CellMeasurementResult_ListIEs->x2ap_CellMeasurementResult_Item.array[i], XER_F_BASIC, cb, app_key);
}
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t x2ap_xer_print_x2ap_completefailurecauseinformation_list(
asn_app_consume_bytes_f *cb,
void *app_key,
X2ap_CompleteFailureCauseInformation_ListIEs_t *x2ap_CompleteFailureCauseInformation_ListIEs) {
int i;
asn_enc_rval_t er;
for (i = 0; i < x2ap_CompleteFailureCauseInformation_ListIEs->x2ap_CompleteFailureCauseInformation_Item.count; i++) {
er = xer_encode(&asn_DEF_X2ap_CompleteFailureCauseInformation_Item, x2ap_CompleteFailureCauseInformation_ListIEs->x2ap_CompleteFailureCauseInformation_Item.array[i], XER_F_BASIC, cb, app_key);
}
_ASN_ENCODED_OK(er);
}
int
xer_fprint(FILE *stream, asn_TYPE_descriptor_t *td, void *sptr) {
asn_enc_rval_t er;
if(!stream) stream = stdout;
if(!td || !sptr)
return -1;
er = xer_encode(td, sptr, XER_F_BASIC, xer__print2fp, stream);
if(er.encoded == -1)
return -1;
return fflush(stream);
}
static void
check_xer(e_Enum2 eval, char *xer_string) {
asn_dec_rval_t rv;
char buf2[128];
Enum2_t *e = 0;
long val;
rv = xer_decode(0, &asn_DEF_Enum2, (void **)&e,
xer_string, strlen(xer_string));
assert(rv.code == RC_OK);
assert(rv.consumed == strlen(xer_string));
asn_INTEGER2long(e, &val);
printf("%s -> %ld == %d\n", xer_string, val, eval);
assert(val == eval);
buf_offset = 0;
xer_encode(&asn_DEF_Enum2, e, XER_F_CANONICAL, buf_writer, 0);
buf[buf_offset] = 0;
sprintf(buf2, "<Enum2>%s</Enum2>", xer_string);
printf("%d -> %s == %s\n", eval, buf, buf2);
assert(0 == strcmp(buf, buf2));
}
VALUE
asn1_encode_object(asn_TYPE_descriptor_t *td, VALUE encoder_v, void *object)
{
VALUE encoded;
bufferInfo_t bi;
asn_enc_rval_t er;
char *encoder = encoder_string(encoder_v);
/*
* Setup buffer
*/
bi.buffer = (char *)malloc(512);
bi.offset = 0;
bi.length = 512;
/*
* Encode
*/
if (strcmp(encoder, "der") == 0)
{
er = td->der_encoder(td, object, 0, 0, (asn_app_consume_bytes_f *)consumeBytes, (void *)&bi);
if (er.encoded == -1)
{
rb_raise(rb_eException, "Can't encode type");
}
/* Free memory */
}
else if (strcmp(encoder, "per") == 0)
{
size_t bit_length;
size_t bits_to_flush;
int byte_length;
char *b = (char *)calloc(512, sizeof(char));
asn_per_outp_t apo;
apo.buffer = apo.tmpspace;
apo.nboff = 0;
apo.nbits = 32 * 8;
apo.outper = per_bytes;
apo.op_key = (void *)b;
apo.flushed_bytes = 0;
er = td->uper_encoder(td, td->per_constraints, object, &apo);
if (er.encoded == -1)
{
rb_raise(rb_eException, "Can't encode type");
/* Free memory */
}
/* Relies on knowledge of internals - XXXXX - bad */
bits_to_flush = ((apo.buffer - apo.tmpspace) << 3) + apo.nboff;
bit_length = (apo.flushed_bytes << 3) + bits_to_flush;
byte_length = bit_length % 8 != 0 ? bit_length / 8 + 1 : bit_length / 8;
encoded = rb_str_new(b, apo.flushed_bytes);
rb_str_cat(encoded, apo.tmpspace, byte_length - apo.flushed_bytes);
return encoded;
}
else if (strcmp(encoder, "xer") == 0)
{
xer_encode(td, object, XER_F_CANONICAL, (asn_app_consume_bytes_f *)consumeBytes, (void *)&bi);
if (er.encoded == -1)
{
rb_raise(rb_eException, "Can't encode type");
}
/* Free memory */
}
encoded = rb_str_new(bi.buffer, bi.offset);
return encoded;
}
enum xer_equivalence_e
xer_equivalent(const struct asn_TYPE_descriptor_s *td, const void *struct1,
const void *struct2, FILE *opt_debug_stream) {
struct xer_buffer xb1 = {0, 0, 0};
struct xer_buffer xb2 = {0, 0, 0};
asn_enc_rval_t e1, e2;
asn_dec_rval_t rval;
void *sptr = NULL;
if(!td || !struct1 || !struct2) {
if(opt_debug_stream) {
if(!td) fprintf(opt_debug_stream, "Type descriptor missing\n");
if(!struct1) fprintf(opt_debug_stream, "Structure 1 missing\n");
if(!struct2) fprintf(opt_debug_stream, "Structure 2 missing\n");
}
return XEQ_FAILURE;
}
e1 = xer_encode(td, struct1, XER_F_BASIC, xer__buffer_append, &xb1);
if(e1.encoded == -1) {
if(opt_debug_stream) {
fprintf(stderr, "XER Encoding of %s failed\n", td->name);
}
FREEMEM(xb1.buffer);
return XEQ_ENCODE1_FAILED;
}
e2 = xer_encode(td, struct2, XER_F_BASIC, xer__buffer_append, &xb2);
if(e2.encoded == -1) {
if(opt_debug_stream) {
fprintf(stderr, "XER Encoding of %s failed\n", td->name);
}
FREEMEM(xb1.buffer);
FREEMEM(xb2.buffer);
return XEQ_ENCODE1_FAILED;
}
if(xb1.buffer_size != xb2.buffer_size
|| memcmp(xb1.buffer, xb2.buffer, xb1.buffer_size) != 0) {
if(opt_debug_stream) {
fprintf(opt_debug_stream,
"Structures XER-encoded into different byte streams:\n=== "
"Structure 1 ===\n%s\n=== Structure 2 ===\n%s\n",
xb1.buffer, xb2.buffer);
}
FREEMEM(xb1.buffer);
FREEMEM(xb2.buffer);
return XEQ_DIFFERENT;
} else {
if(opt_debug_stream) {
fprintf(opt_debug_stream,
"Both structures encoded into the same XER byte stream "
"of size %" ASN_PRI_SIZE ":\n%s",
xb1.buffer_size, xb1.buffer);
}
}
rval = xer_decode(NULL, td, (void **)&sptr, xb1.buffer,
xb1.buffer_size);
switch(rval.code) {
case RC_OK:
break;
case RC_WMORE:
if(opt_debug_stream) {
fprintf(opt_debug_stream,
"Structure %s XER decode unexpectedly requires "
"more data:\n%s\n",
td->name, xb1.buffer);
}
/* Fall through */
case RC_FAIL:
default:
if(opt_debug_stream) {
fprintf(opt_debug_stream,
"Structure %s XER decoding resulted in failure.\n",
td->name);
}
ASN_STRUCT_FREE(*td, sptr);
FREEMEM(xb1.buffer);
FREEMEM(xb2.buffer);
return XEQ_DECODE_FAILED;
}
if(rval.consumed != xb1.buffer_size
&& ((rval.consumed > xb1.buffer_size)
|| xer_whitespace_span(xb1.buffer + rval.consumed,
xb1.buffer_size - rval.consumed)
!= (xb1.buffer_size - rval.consumed))) {
if(opt_debug_stream) {
fprintf(opt_debug_stream,
"Round-trip decode of %s required less bytes (%" ASN_PRI_SIZE ") than "
"encoded (%" ASN_PRI_SIZE ")\n",
td->name, rval.consumed, xb1.buffer_size);
}
ASN_STRUCT_FREE(*td, sptr);
FREEMEM(xb1.buffer);
FREEMEM(xb2.buffer);
return XEQ_ROUND_TRIP_FAILED;
}
/*
* Reuse xb2 to encode newly decoded structure.
*/
FREEMEM(xb2.buffer);
memset(&xb2, 0, sizeof(xb2));
e2 = xer_encode(td, sptr, XER_F_BASIC, xer__buffer_append, &xb2);
if(e2.encoded == -1) {
if(opt_debug_stream) {
fprintf(stderr, "XER Encoding of round-trip decode of %s failed\n",
td->name);
}
ASN_STRUCT_FREE(*td, sptr);
FREEMEM(xb1.buffer);
FREEMEM(xb2.buffer);
return XEQ_ROUND_TRIP_FAILED;
}
ASN_STRUCT_FREE(*td, sptr);
sptr = 0;
if(xb1.buffer_size != xb2.buffer_size
|| memcmp(xb1.buffer, xb2.buffer, xb1.buffer_size) != 0) {
if(opt_debug_stream) {
fprintf(opt_debug_stream,
"XER Encoding of round-trip decode of %s resulted in "
"different byte stream:\n"
"=== Original ===\n%s\n"
"=== Round-tripped ===\n%s\n",
xb1.buffer, xb2.buffer, td->name);
}
FREEMEM(xb1.buffer);
FREEMEM(xb2.buffer);
return XEQ_ROUND_TRIP_FAILED;
}
FREEMEM(xb1.buffer);
FREEMEM(xb2.buffer);
return XEQ_SUCCESS;
}
