asn_enc_rval_t x2ap_xer_print_x2ap_resourcestatusrequest_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_ResourceStatusRequest_IEs_t *x2ap_ResourceStatusRequest_IEs;
asn_enc_rval_t er;
x2ap_ResourceStatusRequest_IEs = &message_p->msg.x2ap_ResourceStatusRequest_IEs;
cb("<X2ap-ResourceStatusRequest-IEs-PDU>\n", 37, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-ResourceStatusRequest-IEs>\n", 37, app_key);
xer_encode_local(&asn_DEF_X2ap_Measurement_ID, &x2ap_ResourceStatusRequest_IEs->enB1_Measurement_ID, cb, app_key, 2);
/* Conditional field */
if (x2ap_ResourceStatusRequest_IEs->presenceMask & X2AP_RESOURCESTATUSREQUEST_IES_ENB2_MEASUREMENT_ID_PRESENT)
xer_encode_local(&asn_DEF_X2ap_Measurement_ID, &x2ap_ResourceStatusRequest_IEs->enB2_Measurement_ID, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_Registration_Request, &x2ap_ResourceStatusRequest_IEs->registration_Request, cb, app_key, 2);
/* Optional field */
if (x2ap_ResourceStatusRequest_IEs->presenceMask & X2AP_RESOURCESTATUSREQUEST_IES_REPORTCHARACTERISTICS_PRESENT)
xer_encode_local(&asn_DEF_X2ap_ReportCharacteristics, &x2ap_ResourceStatusRequest_IEs->reportCharacteristics, cb, app_key, 2);
x2ap_xer_print_x2ap_celltoreport_list(cb, app_key, &x2ap_ResourceStatusRequest_IEs->cellToReport);
/* Optional field */
if (x2ap_ResourceStatusRequest_IEs->presenceMask & X2AP_RESOURCESTATUSREQUEST_IES_REPORTINGPERIODICITY_PRESENT)
xer_encode_local(&asn_DEF_X2ap_ReportingPeriodicity, &x2ap_ResourceStatusRequest_IEs->reportingPeriodicity, cb, app_key, 2);
/* Optional field */
if (x2ap_ResourceStatusRequest_IEs->presenceMask & X2AP_RESOURCESTATUSREQUEST_IES_PARTIALSUCCESSINDICATOR_PRESENT)
xer_encode_local(&asn_DEF_X2ap_PartialSuccessIndicator, &x2ap_ResourceStatusRequest_IEs->partialSuccessIndicator, cb, app_key, 2);
cb(" </X2ap-ResourceStatusRequest-IEs>\n", 38, app_key);
cb("</X2ap-ResourceStatusRequest-IEs-PDU>\n", 38, app_key);
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t
BIT_STRING_encode_xer(Allocator * allocator, asn_TYPE_descriptor_t *td, void *sptr,
int ilevel, enum xer_encoder_flags_e flags,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_enc_rval_t er;
char scratch[128];
char *p = scratch;
char *scend = scratch + (sizeof(scratch) - 10);
const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
int xcan = (flags & XER_F_CANONICAL);
uint8_t *buf;
uint8_t *end;
if(!st || !st->buf)
_ASN_ENCODE_FAILED;
er.encoded = 0;
buf = st->buf;
end = buf + st->size - 1; /* Last byte is special */
/*
* Binary dump
*/
for(; buf < end; buf++) {
int v = *buf;
int nline = xcan?0:(((buf - st->buf) % 8) == 0);
if(p >= scend || nline) {
er.encoded += p - scratch;
_ASN_CALLBACK(allocator, scratch, p - scratch);
p = scratch;
if(nline) _i_ASN_TEXT_INDENT(allocator, 1, ilevel);
}
memcpy(p + 0, _bit_pattern[v >> 4], 4);
memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
p += 8;
}
if(!xcan && ((buf - st->buf) % 8) == 0)
_i_ASN_TEXT_INDENT(allocator,1, ilevel);
er.encoded += p - scratch;
_ASN_CALLBACK(allocator, scratch, p - scratch);
p = scratch;
if(buf == end) {
int v = *buf;
int ubits = st->bits_unused;
int i;
for(i = 7; i >= ubits; i--)
*p++ = (v & (1 << i)) ? 0x31 : 0x30;
er.encoded += p - scratch;
_ASN_CALLBACK(allocator, scratch, p - scratch);
}
if(!xcan) _i_ASN_TEXT_INDENT(allocator, 1, ilevel - 1);
_ASN_ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
}
/*
* Encode an always-primitive type using DER.
*/
asn_enc_rval_t
der_encode_primitive(asn_TYPE_descriptor_t *td, void *sptr,
int tag_mode, ber_tlv_tag_t tag,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_enc_rval_t erval;
ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
ASN_DEBUG("%s %s as a primitive type (tm=%d)",
cb?"Encoding":"Estimating", td->name, tag_mode);
erval.encoded = der_write_tags(td, st->size, tag_mode, 0, tag,
cb, app_key);
ASN_DEBUG("%s wrote tags %d", td->name, (int)erval.encoded);
if(erval.encoded == -1) {
erval.failed_type = td;
erval.structure_ptr = sptr;
return erval;
}
if(cb && st->buf) {
if(cb(st->buf, st->size, app_key) < 0) {
erval.encoded = -1;
erval.failed_type = td;
erval.structure_ptr = sptr;
return erval;
}
} else {
assert(st->buf || st->size == 0);
}
erval.encoded += st->size;
_ASN_ENCODED_OK(erval);
}
asn_enc_rval_t x2ap_xer_print_x2ap_mobilitychangefailure_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_MobilityChangeFailure_IEs_t *x2ap_MobilityChangeFailure_IEs;
asn_enc_rval_t er;
x2ap_MobilityChangeFailure_IEs = &message_p->msg.x2ap_MobilityChangeFailure_IEs;
cb("<X2ap-MobilityChangeFailure-IEs-PDU>\n", 37, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-MobilityChangeFailure-IEs>\n", 37, app_key);
xer_encode_local(&asn_DEF_X2ap_ECGI, &x2ap_MobilityChangeFailure_IEs->enB1_Cell_ID, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_ECGI, &x2ap_MobilityChangeFailure_IEs->enB2_Cell_ID, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_Cause, &x2ap_MobilityChangeFailure_IEs->cause, cb, app_key, 2);
/* Optional field */
if (x2ap_MobilityChangeFailure_IEs->presenceMask & X2AP_MOBILITYCHANGEFAILURE_IES_ENB2_MOBILITY_PARAMETERS_MODIFICATION_RANGE_PRESENT)
xer_encode_local(&asn_DEF_X2ap_MobilityParametersModificationRange, &x2ap_MobilityChangeFailure_IEs->enB2_Mobility_Parameters_Modification_Range, cb, app_key, 2);
/* Optional field */
if (x2ap_MobilityChangeFailure_IEs->presenceMask & X2AP_MOBILITYCHANGEFAILURE_IES_CRITICALITYDIAGNOSTICS_PRESENT)
xer_encode_local(&asn_DEF_X2ap_CriticalityDiagnostics, &x2ap_MobilityChangeFailure_IEs->criticalityDiagnostics, cb, app_key, 2);
cb(" </X2ap-MobilityChangeFailure-IEs>\n", 38, app_key);
cb("</X2ap-MobilityChangeFailure-IEs-PDU>\n", 38, app_key);
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t x2ap_xer_print_x2setupresponse_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2SetupResponse_IEs_t *x2SetupResponse_IEs;
asn_enc_rval_t er;
x2SetupResponse_IEs = &message_p->msg.x2SetupResponse_IEs;
cb("<X2SetupResponse-IEs-PDU>\n", 26, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2SetupResponse-IEs>\n", 26, app_key);
xer_encode_local(&asn_DEF_X2ap_GlobalENB_ID, &x2SetupResponse_IEs->globalENB_ID, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_ServedCells, &x2SetupResponse_IEs->servedCells, cb, app_key, 2);
/* Optional field */
if (x2SetupResponse_IEs->presenceMask & X2SETUPRESPONSE_IES_GUGROUPIDLIST_PRESENT)
xer_encode_local(&asn_DEF_X2ap_GUGroupIDList, &x2SetupResponse_IEs->guGroupIDList, cb, app_key, 2);
/* Optional field */
if (x2SetupResponse_IEs->presenceMask & X2SETUPRESPONSE_IES_CRITICALITYDIAGNOSTICS_PRESENT)
xer_encode_local(&asn_DEF_X2ap_CriticalityDiagnostics, &x2SetupResponse_IEs->criticalityDiagnostics, cb, app_key, 2);
cb(" </X2SetupResponse-IEs>\n", 27, app_key);
cb("</X2SetupResponse-IEs-PDU>\n", 27, app_key);
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int ilevel,
enum xer_encoder_flags_e flags,
asn_app_consume_bytes_f *cb,
void *app_key)
{
asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
char scratch[32]; /* Enough for 64-bit int */
asn_enc_rval_t er;
const long *native = (const long *)sptr;
(void)ilevel;
(void)flags;
if (!native)
_ASN_ENCODE_FAILED;
er.encoded =
snprintf(scratch, sizeof(scratch),
(specs && specs->field_unsigned) ? "%lu" : "%ld", *native);
if (er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch) ||
cb(scratch, er.encoded, app_key) < 0)
_ASN_ENCODE_FAILED;
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t x2ap_xer_print_x2ap_handoverreport_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_HandoverReport_IEs_t *x2ap_HandoverReport_IEs;
asn_enc_rval_t er;
x2ap_HandoverReport_IEs = &message_p->msg.x2ap_HandoverReport_IEs;
cb("<X2ap-HandoverReport-IEs-PDU>\n", 30, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-HandoverReport-IEs>\n", 30, app_key);
xer_encode_local(&asn_DEF_X2ap_Cause, &x2ap_HandoverReport_IEs->cause, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_ECGI, &x2ap_HandoverReport_IEs->sourceCellECGI, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_ECGI, &x2ap_HandoverReport_IEs->failureCellECGI, cb, app_key, 2);
/* Conditional field */
if (x2ap_HandoverReport_IEs->presenceMask & X2AP_HANDOVERREPORT_IES_RE_ESTABLISHMENTCELLECGI_PRESENT)
xer_encode_local(&asn_DEF_X2ap_ECGI, &x2ap_HandoverReport_IEs->re_establishmentCellECGI, cb, app_key, 2);
/* Conditional field */
if (x2ap_HandoverReport_IEs->presenceMask & X2AP_HANDOVERREPORT_IES_TARGETCELLINUTRAN_PRESENT)
xer_encode_local(&asn_DEF_X2ap_TargetCellInUTRAN, &x2ap_HandoverReport_IEs->targetCellInUTRAN, cb, app_key, 2);
cb(" </X2ap-HandoverReport-IEs>\n", 31, app_key);
cb("</X2ap-HandoverReport-IEs-PDU>\n", 31, app_key);
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t
NativeEnumerated_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int ilevel, enum xer_encoder_flags_e flags,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
asn_enc_rval_t er;
const long *native = (const long *)sptr;
const asn_INTEGER_enum_map_t *el;
(void)ilevel;
(void)flags;
if(!native) _ASN_ENCODE_FAILED;
el = INTEGER_map_value2enum(specs, *native);
if(el) {
size_t srcsize = el->enum_len + 5;
char *src = (char *)alloca(srcsize);
er.encoded = snprintf(src, srcsize, "<%s/>", el->enum_name);
assert(er.encoded > 0 && (size_t)er.encoded < srcsize);
if(cb(src, er.encoded, app_key) < 0) _ASN_ENCODE_FAILED;
_ASN_ENCODED_OK(er);
} else {
ASN_DEBUG("ASN.1 forbids dealing with "
"unknown value of ENUMERATED type");
_ASN_ENCODE_FAILED;
}
}
asn_enc_rval_t x2ap_xer_print_x2ap_handoverrequestacknowledge_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_HandoverRequestAcknowledge_IEs_t *x2ap_HandoverRequestAcknowledge_IEs;
asn_enc_rval_t er;
x2ap_HandoverRequestAcknowledge_IEs = &message_p->msg.x2ap_HandoverRequestAcknowledge_IEs;
cb("<X2ap-HandoverRequestAcknowledge-IEs-PDU>\n", 42, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-HandoverRequestAcknowledge-IEs>\n", 42, app_key);
xer_encode_local(&asn_DEF_X2ap_UE_X2AP_ID, &x2ap_HandoverRequestAcknowledge_IEs->old_eNB_UE_X2AP_ID, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_UE_X2AP_ID, &x2ap_HandoverRequestAcknowledge_IEs->new_eNB_UE_X2AP_ID, cb, app_key, 2);
x2ap_xer_print_x2ap_e_rabs_admitted_list(cb, app_key, &x2ap_HandoverRequestAcknowledge_IEs->e_RABs_Admitted_List);
/* Optional field */
if (x2ap_HandoverRequestAcknowledge_IEs->presenceMask & X2AP_HANDOVERREQUESTACKNOWLEDGE_IES_E_RABS_NOTADMITTED_LIST_PRESENT)
xer_encode_local(&asn_DEF_X2ap_E_RAB_List, &x2ap_HandoverRequestAcknowledge_IEs->e_RABs_NotAdmitted_List, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_TargeteNBtoSource_eNBTransparentContainer, &x2ap_HandoverRequestAcknowledge_IEs->targeteNBtoSource_eNBTransparentContainer, cb, app_key, 2);
/* Optional field */
if (x2ap_HandoverRequestAcknowledge_IEs->presenceMask & X2AP_HANDOVERREQUESTACKNOWLEDGE_IES_CRITICALITYDIAGNOSTICS_PRESENT)
xer_encode_local(&asn_DEF_X2ap_CriticalityDiagnostics, &x2ap_HandoverRequestAcknowledge_IEs->criticalityDiagnostics, cb, app_key, 2);
cb(" </X2ap-HandoverRequestAcknowledge-IEs>\n", 43, app_key);
cb("</X2ap-HandoverRequestAcknowledge-IEs-PDU>\n", 43, app_key);
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t x2ap_xer_print_x2ap_resourcestatusresponse_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_ResourceStatusResponse_IEs_t *x2ap_ResourceStatusResponse_IEs;
asn_enc_rval_t er;
x2ap_ResourceStatusResponse_IEs = &message_p->msg.x2ap_ResourceStatusResponse_IEs;
cb("<X2ap-ResourceStatusResponse-IEs-PDU>\n", 38, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-ResourceStatusResponse-IEs>\n", 38, app_key);
xer_encode_local(&asn_DEF_X2ap_Measurement_ID, &x2ap_ResourceStatusResponse_IEs->enB1_Measurement_ID, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_Measurement_ID, &x2ap_ResourceStatusResponse_IEs->enB2_Measurement_ID, cb, app_key, 2);
/* Optional field */
if (x2ap_ResourceStatusResponse_IEs->presenceMask & X2AP_RESOURCESTATUSRESPONSE_IES_CRITICALITYDIAGNOSTICS_PRESENT)
xer_encode_local(&asn_DEF_X2ap_CriticalityDiagnostics, &x2ap_ResourceStatusResponse_IEs->criticalityDiagnostics, cb, app_key, 2);
/* Optional field */
if (x2ap_ResourceStatusResponse_IEs->presenceMask & X2AP_RESOURCESTATUSRESPONSE_IES_MEASUREMENTINITIATIONRESULT_LIST_PRESENT)
x2ap_xer_print_x2ap_measurementinitiationresult_list(cb, app_key, &x2ap_ResourceStatusResponse_IEs->measurementInitiationResult_List);
cb(" </X2ap-ResourceStatusResponse-IEs>\n", 39, app_key);
cb("</X2ap-ResourceStatusResponse-IEs-PDU>\n", 39, app_key);
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t x2ap_xer_print_x2ap_rlfindication_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_RLFIndication_IEs_t *x2ap_RLFIndication_IEs;
asn_enc_rval_t er;
x2ap_RLFIndication_IEs = &message_p->msg.x2ap_RLFIndication_IEs;
cb("<X2ap-RLFIndication-IEs-PDU>\n", 29, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-RLFIndication-IEs>\n", 29, app_key);
xer_encode_local(&asn_DEF_X2ap_PCI, &x2ap_RLFIndication_IEs->failureCellPCI, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_ECGI, &x2ap_RLFIndication_IEs->re_establishmentCellECGI, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_CRNTI, &x2ap_RLFIndication_IEs->failureCellCRNTI, cb, app_key, 2);
/* Optional field */
if (x2ap_RLFIndication_IEs->presenceMask & X2AP_RLFINDICATION_IES_SHORTMAC_I_PRESENT)
xer_encode_local(&asn_DEF_X2ap_ShortMAC_I, &x2ap_RLFIndication_IEs->shortMAC_I, cb, app_key, 2);
/* Optional field */
if (x2ap_RLFIndication_IEs->presenceMask & X2AP_RLFINDICATION_IES_UE_RLF_REPORT_CONTAINER_PRESENT)
xer_encode_local(&asn_DEF_X2ap_UE_RLF_Report_Container, &x2ap_RLFIndication_IEs->uE_RLF_Report_Container, cb, app_key, 2);
/* Optional field */
if (x2ap_RLFIndication_IEs->presenceMask & X2AP_RLFINDICATION_IES_RRCCONNSETUPINDICATOR_PRESENT)
xer_encode_local(&asn_DEF_X2ap_RRCConnSetupIndicator, &x2ap_RLFIndication_IEs->rrcConnSetupIndicator, cb, app_key, 2);
/* Optional field */
if (x2ap_RLFIndication_IEs->presenceMask & X2AP_RLFINDICATION_IES_RRCCONNREESTABINDICATOR_PRESENT)
xer_encode_local(&asn_DEF_X2ap_RRCConnReestabIndicator, &x2ap_RLFIndication_IEs->rrcConnReestabIndicator, cb, app_key, 2);
cb(" </X2ap-RLFIndication-IEs>\n", 30, app_key);
cb("</X2ap-RLFIndication-IEs-PDU>\n", 30, app_key);
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t x2ap_xer_print_x2ap_errorindication_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_ErrorIndication_IEs_t *x2ap_ErrorIndication_IEs;
asn_enc_rval_t er;
x2ap_ErrorIndication_IEs = &message_p->msg.x2ap_ErrorIndication_IEs;
cb("<X2ap-ErrorIndication-IEs-PDU>\n", 31, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-ErrorIndication-IEs>\n", 31, app_key);
/* Optional field */
if (x2ap_ErrorIndication_IEs->presenceMask & X2AP_ERRORINDICATION_IES_OLD_ENB_UE_X2AP_ID_PRESENT)
xer_encode_local(&asn_DEF_X2ap_UE_X2AP_ID, &x2ap_ErrorIndication_IEs->old_eNB_UE_X2AP_ID, cb, app_key, 2);
/* Optional field */
if (x2ap_ErrorIndication_IEs->presenceMask & X2AP_ERRORINDICATION_IES_NEW_ENB_UE_X2AP_ID_PRESENT)
xer_encode_local(&asn_DEF_X2ap_UE_X2AP_ID, &x2ap_ErrorIndication_IEs->new_eNB_UE_X2AP_ID, cb, app_key, 2);
/* Optional field */
if (x2ap_ErrorIndication_IEs->presenceMask & X2AP_ERRORINDICATION_IES_CAUSE_PRESENT)
xer_encode_local(&asn_DEF_X2ap_Cause, &x2ap_ErrorIndication_IEs->cause, cb, app_key, 2);
/* Optional field */
if (x2ap_ErrorIndication_IEs->presenceMask & X2AP_ERRORINDICATION_IES_CRITICALITYDIAGNOSTICS_PRESENT)
xer_encode_local(&asn_DEF_X2ap_CriticalityDiagnostics, &x2ap_ErrorIndication_IEs->criticalityDiagnostics, cb, app_key, 2);
cb(" </X2ap-ErrorIndication-IEs>\n", 32, app_key);
cb("</X2ap-ErrorIndication-IEs-PDU>\n", 32, app_key);
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t x2ap_xer_print_x2ap_handoverrequest_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_HandoverRequest_IEs_t *x2ap_HandoverRequest_IEs;
asn_enc_rval_t er;
x2ap_HandoverRequest_IEs = &message_p->msg.x2ap_HandoverRequest_IEs;
cb("<X2ap-HandoverRequest-IEs-PDU>\n", 31, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-HandoverRequest-IEs>\n", 31, app_key);
xer_encode_local(&asn_DEF_X2ap_UE_X2AP_ID, &x2ap_HandoverRequest_IEs->old_eNB_UE_X2AP_ID, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_Cause, &x2ap_HandoverRequest_IEs->cause, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_ECGI, &x2ap_HandoverRequest_IEs->targetCell_ID, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_GUMMEI, &x2ap_HandoverRequest_IEs->gummei_id, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_UE_ContextInformation, &x2ap_HandoverRequest_IEs->uE_ContextInformation, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_UE_HistoryInformation, &x2ap_HandoverRequest_IEs->uE_HistoryInformation, cb, app_key, 2);
/* Optional field */
if (x2ap_HandoverRequest_IEs->presenceMask & X2AP_HANDOVERREQUEST_IES_TRACEACTIVATION_PRESENT)
xer_encode_local(&asn_DEF_X2ap_TraceActivation, &x2ap_HandoverRequest_IEs->traceActivation, cb, app_key, 2);
/* Optional field */
if (x2ap_HandoverRequest_IEs->presenceMask & X2AP_HANDOVERREQUEST_IES_SRVCCOPERATIONPOSSIBLE_PRESENT)
xer_encode_local(&asn_DEF_X2ap_SRVCCOperationPossible, &x2ap_HandoverRequest_IEs->srvccOperationPossible, cb, app_key, 2);
/* Optional field */
if (x2ap_HandoverRequest_IEs->presenceMask & X2AP_HANDOVERREQUEST_IES_CSGMEMBERSHIPSTATUS_PRESENT)
xer_encode_local(&asn_DEF_X2ap_CSGMembershipStatus, &x2ap_HandoverRequest_IEs->csgMembershipStatus, cb, app_key, 2);
cb(" </X2ap-HandoverRequest-IEs>\n", 32, app_key);
cb("</X2ap-HandoverRequest-IEs-PDU>\n", 32, app_key);
_ASN_ENCODED_OK(er);
}
/*
* The XER encoder of any type. May be invoked by the application.
*/
asn_enc_rval_t
xer_encode(asn_TYPE_descriptor_t *td, void *sptr,
enum xer_encoder_flags_e xer_flags,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_enc_rval_t er, tmper;
const char *mname;
size_t mlen;
int xcan = (xer_flags & XER_F_CANONICAL) ? 1 : 2;
if(!td || !sptr) goto cb_failed;
mname = td->xml_tag;
mlen = strlen(mname);
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
tmper = td->xer_encoder(td, sptr, 1, xer_flags, cb, app_key);
if(tmper.encoded == -1) return tmper;
_ASN_CALLBACK3("</", 2, mname, mlen, ">\n", xcan);
er.encoded = 4 + xcan + (2 * mlen) + tmper.encoded;
_ASN_ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
}
asn_enc_rval_t x2ap_xer_print_x2ap_enbconfigurationupdate_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_ENBConfigurationUpdate_IEs_t *x2ap_ENBConfigurationUpdate_IEs;
asn_enc_rval_t er;
x2ap_ENBConfigurationUpdate_IEs = &message_p->msg.x2ap_ENBConfigurationUpdate_IEs;
cb("<X2ap-ENBConfigurationUpdate-IEs-PDU>\n", 38, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-ENBConfigurationUpdate-IEs>\n", 38, app_key);
/* Optional field */
if (x2ap_ENBConfigurationUpdate_IEs->presenceMask & X2AP_ENBCONFIGURATIONUPDATE_IES_SERVEDCELLSTOADD_PRESENT)
xer_encode_local(&asn_DEF_X2ap_ServedCells, &x2ap_ENBConfigurationUpdate_IEs->servedCellsToAdd, cb, app_key, 2);
/* Optional field */
if (x2ap_ENBConfigurationUpdate_IEs->presenceMask & X2AP_ENBCONFIGURATIONUPDATE_IES_SERVEDCELLSTOMODIFY_PRESENT)
xer_encode_local(&asn_DEF_X2ap_ServedCellsToModify, &x2ap_ENBConfigurationUpdate_IEs->servedCellsToModify, cb, app_key, 2);
/* Optional field */
if (x2ap_ENBConfigurationUpdate_IEs->presenceMask & X2AP_ENBCONFIGURATIONUPDATE_IES_SERVEDCELLSTODELETE_PRESENT)
xer_encode_local(&asn_DEF_X2ap_Old_ECGIs, &x2ap_ENBConfigurationUpdate_IEs->servedCellsToDelete, cb, app_key, 2);
/* Optional field */
if (x2ap_ENBConfigurationUpdate_IEs->presenceMask & X2AP_ENBCONFIGURATIONUPDATE_IES_GUGROUPIDTOADDLIST_PRESENT)
xer_encode_local(&asn_DEF_X2ap_GUGroupIDList, &x2ap_ENBConfigurationUpdate_IEs->guGroupIDToAddList, cb, app_key, 2);
/* Optional field */
if (x2ap_ENBConfigurationUpdate_IEs->presenceMask & X2AP_ENBCONFIGURATIONUPDATE_IES_GUGROUPIDTODELETELIST_PRESENT)
xer_encode_local(&asn_DEF_X2ap_GUGroupIDList, &x2ap_ENBConfigurationUpdate_IEs->guGroupIDToDeleteList, cb, app_key, 2);
cb(" </X2ap-ENBConfigurationUpdate-IEs>\n", 39, app_key);
cb("</X2ap-ENBConfigurationUpdate-IEs-PDU>\n", 39, app_key);
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t x2ap_xer_print_x2ap_resourcestatusfailure_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_ResourceStatusFailure_IEs_t *x2ap_ResourceStatusFailure_IEs;
asn_enc_rval_t er;
x2ap_ResourceStatusFailure_IEs = &message_p->msg.x2ap_ResourceStatusFailure_IEs;
cb("<X2ap-ResourceStatusFailure-IEs-PDU>\n", 37, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-ResourceStatusFailure-IEs>\n", 37, app_key);
xer_encode_local(&asn_DEF_X2ap_Measurement_ID, &x2ap_ResourceStatusFailure_IEs->enB1_Measurement_ID, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_Measurement_ID, &x2ap_ResourceStatusFailure_IEs->enB2_Measurement_ID, cb, app_key, 2);
xer_encode_local(&asn_DEF_X2ap_Cause, &x2ap_ResourceStatusFailure_IEs->cause, cb, app_key, 2);
/* Optional field */
if (x2ap_ResourceStatusFailure_IEs->presenceMask & X2AP_RESOURCESTATUSFAILURE_IES_CRITICALITYDIAGNOSTICS_PRESENT)
xer_encode_local(&asn_DEF_X2ap_CriticalityDiagnostics, &x2ap_ResourceStatusFailure_IEs->criticalityDiagnostics, cb, app_key, 2);
/* Optional field */
if (x2ap_ResourceStatusFailure_IEs->presenceMask & X2AP_RESOURCESTATUSFAILURE_IES_COMPLETEFAILURECAUSEINFORMATION_LIST_PRESENT)
x2ap_xer_print_x2ap_completefailurecauseinformation_list(cb, app_key, &x2ap_ResourceStatusFailure_IEs->completeFailureCauseInformation_List);
cb(" </X2ap-ResourceStatusFailure-IEs>\n", 38, app_key);
cb("</X2ap-ResourceStatusFailure-IEs-PDU>\n", 38, app_key);
_ASN_ENCODED_OK(er);
}
static asn_enc_rval_t
xer_encode_local(asn_TYPE_descriptor_t *td, void *sptr,
asn_app_consume_bytes_f *cb, void *app_key, int indent) {
asn_enc_rval_t er, tmper;
const char *mname;
size_t mlen;
int xcan = 2;
if(!td || !sptr) goto cb_failed;
mname = td->xml_tag;
mlen = strlen(mname);
_i_ASN_TEXT_INDENT(0, indent);
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
tmper = td->xer_encoder(td, sptr, indent + 1, XER_F_BASIC, cb, app_key);
if(tmper.encoded == -1) return tmper;
_ASN_CALLBACK3("</", 2, mname, mlen, ">\n", xcan);
er.encoded = 4 + xcan + (2 * mlen) + tmper.encoded;
_ASN_ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
}
asn_enc_rval_t
BOOLEAN_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
int tag_mode, ber_tlv_tag_t tag,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_enc_rval_t erval;
BOOLEAN_t *st = (BOOLEAN_t *)sptr;
erval.encoded = der_write_tags(td, 1, tag_mode, 0, tag, cb, app_key);
if(erval.encoded == -1) {
erval.failed_type = td;
erval.structure_ptr = sptr;
return erval;
}
if(cb) {
uint8_t bool_value;
bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */
if(cb(&bool_value, 1, app_key) < 0) {
erval.encoded = -1;
erval.failed_type = td;
erval.structure_ptr = sptr;
return erval;
}
}
erval.encoded += 1;
_ASN_ENCODED_OK(erval);
}
asn_enc_rval_t CHOICE_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int ilevel, enum xer_encoder_flags_e flags,
asn_app_consume_bytes_f *cb, void *app_key)
{
asn_CHOICE_specifics_t *specs = (asn_CHOICE_specifics_t *)td->specifics;
asn_enc_rval_t er;
int present;
if (!sptr)
_ASN_ENCODE_FAILED;
/*
* Figure out which CHOICE element is encoded.
*/
present = _fetch_present_idx(sptr, specs->pres_offset, specs->pres_size);
if (present <= 0 || present > td->elements_count) {
_ASN_ENCODE_FAILED;
} else {
asn_enc_rval_t tmper;
asn_TYPE_member_t *elm = &td->elements[present - 1];
void *memb_ptr;
const char *mname = elm->name;
unsigned int mlen = strlen(mname);
if (elm->flags & ATF_POINTER) {
memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
if (!memb_ptr)
_ASN_ENCODE_FAILED;
} else {
memb_ptr = (void *)((char *)sptr + elm->memb_offset);
}
er.encoded = 0;
if (!(flags & XER_F_CANONICAL))
_i_ASN_TEXT_INDENT(1, ilevel);
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
tmper = elm->type->xer_encoder(elm->type, memb_ptr, ilevel + 1, flags,
cb, app_key);
if (tmper.encoded == -1)
return tmper;
_ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
er.encoded += 5 + (2 * mlen) + tmper.encoded;
}
if (!(flags & XER_F_CANONICAL))
_i_ASN_TEXT_INDENT(1, ilevel - 1);
_ASN_ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
}
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_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);
}
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
SEQUENCE_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int ilevel, enum xer_encoder_flags_e flags,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_enc_rval_t er;
asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
asn_TYPE_member_t *elm = td->elements;
asn_anonymous_sequence_ *list = _A_SEQUENCE_FROM_VOID(sptr);
const char *mname = specs->as_XMLValueList
? 0 : ((*elm->name) ? elm->name : elm->type->xml_tag);
unsigned int mlen = mname ? strlen(mname) : 0;
int xcan = (flags & XER_F_CANONICAL);
int i;
if(!sptr) _ASN_ENCODE_FAILED;
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(mname) {
if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel);
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
}
tmper = elm->type->xer_encoder(elm->type, memb_ptr,
ilevel + 1, flags, cb, app_key);
if(tmper.encoded == -1) return tmper;
if(tmper.encoded == 0 && specs->as_XMLValueList) {
const char *name = elm->type->xml_tag;
size_t len = strlen(name);
if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel + 1);
_ASN_CALLBACK3("<", 1, name, len, "/>", 2);
}
if(mname) {
_ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
er.encoded += 5;
}
er.encoded += (2 * mlen) + tmper.encoded;
}
if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1);
_ASN_ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
}
asn_enc_rval_t
NULL_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
void *sptr, asn_per_outp_t *po) {
asn_enc_rval_t er;
(void)td;
(void)constraints;
(void)sptr;
(void)po;
er.encoded = 0;
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t
SEQUENCE_encode_xer(Allocator * allocator, asn_TYPE_descriptor_t *td, void *sptr,
int ilevel, enum xer_encoder_flags_e flags,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_enc_rval_t er;
int xcan = (flags & XER_F_CANONICAL);
int edx;
if(!sptr)
_ASN_ENCODE_FAILED;
er.encoded = 0;
for(edx = 0; edx < td->elements_count; edx++) {
asn_enc_rval_t tmper;
asn_TYPE_member_t *elm = &td->elements[edx];
void *memb_ptr;
const char *mname = elm->name;
unsigned int mlen = strlen(mname);
if(elm->flags & ATF_POINTER) {
memb_ptr = *(void **)((char *)sptr + elm->memb_offset);
if(!memb_ptr) {
if(elm->optional)
continue;
/* Mandatory element is missing */
_ASN_ENCODE_FAILED;
}
} else {
memb_ptr = (void *)((char *)sptr + elm->memb_offset);
}
if(!xcan) _i_ASN_TEXT_INDENT(allocator, 1, ilevel);
_ASN_CALLBACK3(allocator, "<", 1, mname, mlen, ">", 1);
/* Print the member itself */
tmper = elm->type->xer_encoder(allocator, elm->type, memb_ptr,
ilevel + 1, flags, cb, app_key);
if(tmper.encoded == -1) return tmper;
_ASN_CALLBACK3(allocator, "</", 2, mname, mlen, ">", 1);
er.encoded += 5 + (2 * mlen) + tmper.encoded;
}
if(!xcan) _i_ASN_TEXT_INDENT(allocator, 1, ilevel - 1);
_ASN_ENCODED_OK(er);
cb_failed:
_ASN_ENCODE_FAILED;
}
asn_enc_rval_t
NULL_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
int tag_mode, ber_tlv_tag_t tag,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_enc_rval_t erval;
erval.encoded = der_write_tags(td, 0, tag_mode, 0, tag, cb, app_key);
if(erval.encoded == -1) {
erval.failed_type = td;
erval.structure_ptr = ptr;
}
_ASN_ENCODED_OK(erval);
}
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);
}
asn_enc_rval_t
NativeReal_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int ilevel, enum xer_encoder_flags_e flags,
asn_app_consume_bytes_f *cb, void *app_key) {
const double *Dbl = (const double *)sptr;
asn_enc_rval_t er;
(void)ilevel;
if(!Dbl) _ASN_ENCODE_FAILED;
er.encoded = REAL__dump(*Dbl, flags & XER_F_CANONICAL, cb, app_key);
if(er.encoded < 0) _ASN_ENCODE_FAILED;
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t
NULL_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
int ilevel, enum xer_encoder_flags_e flags,
asn_app_consume_bytes_f *cb, void *app_key) {
asn_enc_rval_t er;
(void)td;
(void)sptr;
(void)ilevel;
(void)flags;
(void)cb;
(void)app_key;
/* XMLNullValue is empty */
er.encoded = 0;
_ASN_ENCODED_OK(er);
}
asn_enc_rval_t x2ap_xer_print_x2ap_loadinformation_(
asn_app_consume_bytes_f *cb,
void *app_key,
x2ap_message *message_p)
{
X2ap_LoadInformation_IEs_t *x2ap_LoadInformation_IEs;
asn_enc_rval_t er;
x2ap_LoadInformation_IEs = &message_p->msg.x2ap_LoadInformation_IEs;
cb("<X2ap-LoadInformation-IEs-PDU>\n", 31, app_key);
xer_encode_local(&asn_DEF_X2ap_Criticality, &message_p->criticality, cb, app_key, 1);
xer_encode_local(&asn_DEF_X2ap_ProcedureCode, &message_p->procedureCode, cb, app_key, 1);
cb(" <X2ap-LoadInformation-IEs>\n", 31, app_key);
x2ap_xer_print_x2ap_cellinformation_list(cb, app_key, &x2ap_LoadInformation_IEs->cellInformation);
cb(" </X2ap-LoadInformation-IEs>\n", 32, app_key);
cb("</X2ap-LoadInformation-IEs-PDU>\n", 32, app_key);
_ASN_ENCODED_OK(er);
}
