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