X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=e2sim%2Fsrc%2Fencoding%2Fencode_e2apv1.cpp;h=85d8cbf295a772a0c8c5779fe716e28503c42490;hb=f5900596513e4359fc839ba361da085674e90b68;hp=6f8c5892391a1d757bcd3293750e1fbc35b6b131;hpb=4b7683efa5ee46870e550ee6fa55f765a0a1f70c;p=sim%2Fe2-interface.git diff --git a/e2sim/src/encoding/encode_e2apv1.cpp b/e2sim/src/encoding/encode_e2apv1.cpp old mode 100644 new mode 100755 index 6f8c589..85d8cbf --- a/e2sim/src/encoding/encode_e2apv1.cpp +++ b/e2sim/src/encoding/encode_e2apv1.cpp @@ -53,6 +53,11 @@ extern "C" { #include "RICsubsequentActionType.h" #include "RICsubsequentAction.h" #include "RICtimeToWait.h" +#include "E2nodeComponentInterfaceNG.h" +// #include "E2nodeComponentGNB-CU-UP-ID.h" +// #include "E2nodeComponentID.h" +// #include "E2nodeComponentConfigUpdate.h" +// #include "E2nodeComponentConfigUpdateGNB.h" } @@ -60,10 +65,7 @@ long encoding::get_function_id_from_subscription(E2AP_PDU_t *e2ap_pdu) { RICsubscriptionRequest_t orig_req = e2ap_pdu->choice.initiatingMessage->value.choice.RICsubscriptionRequest; - - RICsubscriptionResponse_IEs_t *ricreqid = - (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t)); - + int count = orig_req.protocolIEs.list.count; int size = orig_req.protocolIEs.list.size; @@ -157,9 +159,6 @@ void encoding::generate_e2apv1_service_update(E2AP_PDU_t *e2ap_pdu, std::vector< } void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu, std::vector all_funcs) { - // long ranFunctionId, uint8_t *ranFuncDescEncoded, int ranFuncLength) { - - // uint8_t *buf = (uint8_t *)"gnb1" BIT_STRING_t *gnb_bstring = (BIT_STRING_t*)calloc(1, sizeof(BIT_STRING_t));; gnb_bstring->buf = (uint8_t*)calloc(1,4); @@ -181,13 +180,17 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu, GNB_ID_Choice_PR pres2 = GNB_ID_Choice_PR_gnb_ID; gnbchoice->present = pres2; gnbchoice->choice.gnb_ID = *gnb_bstring; + if (gnb_bstring) free(gnb_bstring); GlobalgNB_ID_t *gnb = (GlobalgNB_ID_t*)calloc(1, sizeof(GlobalgNB_ID_t)); gnb->plmn_id = *plmn; gnb->gnb_id = *gnbchoice; + if (plmn) free(plmn); + if (gnbchoice) free(gnbchoice); GlobalE2node_gNB_ID_t *e2gnb = (GlobalE2node_gNB_ID_t*)calloc(1, sizeof(GlobalE2node_gNB_ID_t)); e2gnb->global_gNB_ID = *gnb; + if (gnb) free(gnb); GlobalE2node_ID_t *globale2nodeid = (GlobalE2node_ID_t*)calloc(1, sizeof(GlobalE2node_ID_t)); GlobalE2node_ID_PR pres; @@ -202,7 +205,15 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu, e2setuprid->criticality = 0; e2setuprid->value.choice.GlobalE2node_ID = *globale2nodeid; e2setuprid->value.present = pres3; + if(globale2nodeid) free(globale2nodeid); + + //seting tx id + auto *e2txid = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t)); + e2txid->id = ProtocolIE_ID_id_TransactionID; + e2txid-> criticality = 0; + e2txid->value.present = E2setupRequestIEs__value_PR_TransactionID; + e2txid->value.choice.TransactionID = 1; auto *ranFlistIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t)); ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, ranFlistIEs); @@ -223,7 +234,7 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu, itemIes->criticality = Criticality_reject; itemIes->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item; itemIes->value.choice.RANfunction_Item.ranFunctionID = nextRanFuncId; - + itemIes->value.choice.RANfunction_Item.ranFunctionOID = RANfunctionOID_t(*(nextRanFunc.ranFunctionOId)); int ranFuncLength = strlen((char*)nextRanFuncDesc); itemIes->value.choice.RANfunction_Item.ranFunctionDefinition = *nextRanFuncDesc; @@ -233,9 +244,113 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu, } +auto *e2configIE = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t)); +e2configIE->id = ProtocolIE_ID_id_E2nodeComponentConfigAddition; +e2configIE->criticality = Criticality_reject; +e2configIE->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List; + + +auto *e2configAdditionItem = (E2nodeComponentConfigAddition_ItemIEs_t *)calloc(1, sizeof(E2nodeComponentConfigAddition_ItemIEs_t)); +e2configAdditionItem->id = ProtocolIE_ID_id_E2nodeComponentConfigAddition_Item; +e2configAdditionItem->criticality = Criticality_reject; +e2configAdditionItem->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item; + +e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_ng; +e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeNG; + +auto *intfNG = (E2nodeComponentInterfaceNG_t *) calloc(1, sizeof(E2nodeComponentInterfaceNG_t)); + +OCTET_STRING_t nginterf; +nginterf.buf = (uint8_t*)calloc(1,8); +memcpy(nginterf.buf, (uint8_t *)"nginterf", 8); + +nginterf.size = 8; +intfNG->amf_name = (AMFName_t)(nginterf); + +e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeNG = intfNG; + +OCTET_STRING_t reqPart; +reqPart.buf = (uint8_t*)calloc(1,7); +memcpy(reqPart.buf, (uint8_t *)"reqpart", 7); +reqPart.size = 7; + +e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart = reqPart; + +OCTET_STRING_t resPart; +resPart.buf = (uint8_t*)calloc(1,7); +memcpy(resPart.buf, (uint8_t *)"respart", 7); +resPart.size = 7; +e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart = resPart; + + +ASN_SEQUENCE_ADD(&e2configIE->value.choice.RANfunctions_List.list, e2configAdditionItem); +/* + auto *e2nodeconfigupdatelistIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t)); + ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, e2nodeconfigupdatelistIEs); + e2nodeconfigupdatelistIEs->criticality = 0; + e2nodeconfigupdatelistIEs->id = ProtocolIE_ID_id_E2nodeComponentConfigUpdate; + e2nodeconfigupdatelistIEs->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigUpdate_List; + + + OCTET_STRING_t *ngAPconfigUpdate = (OCTET_STRING_t *)calloc(1,sizeof(OCTET_STRING_t)); + ngAPconfigUpdate->buf = (uint8_t*)calloc(1,13); + memcpy(ngAPconfigUpdate->buf, (uint8_t *)"gnbngapupdate", 13); + ngAPconfigUpdate->size = 13; + + OCTET_STRING_t *xnAPconfigUpdate = (OCTET_STRING_t *)calloc(1,sizeof(OCTET_STRING_t)); + xnAPconfigUpdate->buf = (uint8_t*)calloc(1,13); + memcpy(xnAPconfigUpdate->buf, (uint8_t *)"gnbxnapupdate", 13); + xnAPconfigUpdate->size = 13; + + OCTET_STRING_t *e1APconfigUpdate = (OCTET_STRING_t *)calloc(1,sizeof(OCTET_STRING_t)); + e1APconfigUpdate->buf = (uint8_t*)calloc(1,13); + memcpy(e1APconfigUpdate->buf, (uint8_t *)"gnbe1apupdate", 13); + e1APconfigUpdate->size = 13; + + OCTET_STRING_t *f1APconfigUpdate = (OCTET_STRING_t *)calloc(1,sizeof(OCTET_STRING_t)); + f1APconfigUpdate->buf = (uint8_t*)calloc(1,13); + memcpy(f1APconfigUpdate->buf, (uint8_t *)"gnbf1apupdate", 13); + f1APconfigUpdate->size = 13; + + E2nodeComponentConfigUpdateGNB_t *e2nodecomponentconfigupdategnb = (E2nodeComponentConfigUpdateGNB_t *)calloc(1,sizeof(E2nodeComponentConfigUpdateGNB_t)); + e2nodecomponentconfigupdategnb->ngAPconfigUpdate = ngAPconfigUpdate; + e2nodecomponentconfigupdategnb->xnAPconfigUpdate = xnAPconfigUpdate; + e2nodecomponentconfigupdategnb->e1APconfigUpdate = e1APconfigUpdate; + e2nodecomponentconfigupdategnb->f1APconfigUpdate = f1APconfigUpdate; + + E2nodeComponentConfigUpdate_t e2nodecomponentconfigupdate = {}; + e2nodecomponentconfigupdate.present = E2nodeComponentConfigUpdate_PR_gNBconfigUpdate; + e2nodecomponentconfigupdate.choice.gNBconfigUpdate = e2nodecomponentconfigupdategnb; + + GNB_CU_UP_ID_t gnbcuupid = {}; + gnbcuupid.buf = (uint8_t*)calloc(1,4); + memcpy(gnbcuupid.buf, (uint8_t *)"1234", 4); + gnbcuupid.size = 4; + + E2nodeComponentGNB_CU_UP_ID_t *e2nodecomponentgnbcuupid = (E2nodeComponentGNB_CU_UP_ID_t *)calloc(1,sizeof(E2nodeComponentGNB_CU_UP_ID_t)); + e2nodecomponentgnbcuupid->gNB_CU_UP_ID = gnbcuupid; + + E2nodeComponentID_t *e2nodecomponentid = (E2nodeComponentID_t*)calloc(1, sizeof(E2nodeComponentID_t)); + + e2nodecomponentid->present = E2nodeComponentID_PR_e2nodeComponentTypeGNB_CU_UP; + e2nodecomponentid->choice.e2nodeComponentTypeGNB_CU_UP = e2nodecomponentgnbcuupid; + + auto *configupdateitemIes = (E2nodeComponentConfigUpdate_ItemIEs_t *)calloc(1, sizeof(E2nodeComponentConfigUpdate_ItemIEs_t)); + configupdateitemIes->id = ProtocolIE_ID_id_E2nodeComponentConfigUpdate_Item; + configupdateitemIes->criticality = Criticality_reject; + configupdateitemIes->value.present = E2nodeComponentConfigUpdate_ItemIEs__value_PR_E2nodeComponentConfigUpdate_Item; + configupdateitemIes->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentType = E2nodeComponentType_gNB_CU_UP; + configupdateitemIes->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentID = e2nodecomponentid; + configupdateitemIes->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentConfigUpdate = e2nodecomponentconfigupdate; + + ASN_SEQUENCE_ADD(&e2nodeconfigupdatelistIEs->value.choice.E2nodeComponentConfigUpdate_List.list, configupdateitemIes); +*/ E2setupRequest_t *e2setupreq = (E2setupRequest_t*)calloc(1, sizeof(E2setupRequest_t)); + ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, e2txid); ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, e2setuprid); ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, ranFlistIEs); + ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, e2configIE); + InitiatingMessage__value_PR pres4; pres4 = InitiatingMessage__value_PR_E2setupRequest; @@ -245,6 +360,7 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu, initmsg->criticality = Criticality_reject; initmsg->value.present = pres4; initmsg->value.choice.E2setupRequest = *e2setupreq; + if (e2setupreq) free(e2setupreq); E2AP_PDU_PR pres5; pres5 = E2AP_PDU_PR_initiatingMessage; @@ -255,7 +371,120 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu, } +void encoding::generate_e2apv2_reset_request(E2AP_PDU *e2ap_pdu) { + E2AP_PDU_PR pr = E2AP_PDU_PR_initiatingMessage; + e2ap_pdu->present = pr; + + e2ap_pdu->choice.initiatingMessage = (InitiatingMessage_t*)calloc(1, sizeof(InitiatingMessage_t)); + e2ap_pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset; + e2ap_pdu->choice.initiatingMessage->criticality = Criticality_reject; + + e2ap_pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest; + + auto *rrIEs1 = (ResetRequestIEs_t *)calloc(1, sizeof(ResetRequestIEs_t)); + rrIEs1->id = ProtocolIE_ID_id_Cause; + rrIEs1->criticality = Criticality_ignore; + + rrIEs1->value.present = ResetRequestIEs__value_PR_Cause; + rrIEs1->value.choice.Cause.present = Cause_PR_e2Node; + rrIEs1->value.choice.Cause.choice.ricRequest = CauseE2node_e2node_component_unknown; + + auto *rrIEs2 = (ResetRequestIEs_t *)calloc(1, sizeof(ResetRequestIEs_t)); + rrIEs2->id = ProtocolIE_ID_id_TransactionID; + rrIEs2->criticality = Criticality_ignore; + + rrIEs2->value.present = ResetRequestIEs__value_PR_TransactionID; + rrIEs2->value.choice.TransactionID = 1; + + ASN_SEQUENCE_ADD(&e2ap_pdu->choice.initiatingMessage->value.choice.ResetRequest.protocolIEs.list, rrIEs2); + ASN_SEQUENCE_ADD(&e2ap_pdu->choice.initiatingMessage->value.choice.ResetRequest.protocolIEs.list, rrIEs1); +} + +void encoding::generate_e2apv2_reset_response(E2AP_PDU *e2ap_pdu) { + e2ap_pdu->present = E2AP_PDU_PR_successfulOutcome; + e2ap_pdu->choice.successfulOutcome = (SuccessfulOutcome_t*)calloc(1, sizeof(SuccessfulOutcome)); + + e2ap_pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset; + e2ap_pdu->choice.successfulOutcome->criticality = Criticality_ignore; + + e2ap_pdu->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetResponse; + + // auto *rrIEs1 = (ResetResponseIEs_t *)calloc(1, sizeof(ResetResponseIEs_t)); + // rrIEs1->id = ProtocolIE_ID_id_CriticalityDiagnostics; + // rrIEs1->criticality = Criticality_ignore; + + // rrIEs1->value.present = ResetResponseIEs__value_PR_CriticalityDiagnostics; + // rrIEs1->value.choice.CriticalityDiagnostics.procedureCode = &ProcedureCode_id_Reset; + // rrIEs1->value.choice.CriticalityDiagnostics.choice.ricRequest = CauseE2node_e2node_component_unknown; + + auto *rrIEs2 = (ResetRequestIEs_t *)calloc(1, sizeof(ResetRequestIEs_t)); + rrIEs2->id = ProtocolIE_ID_id_TransactionID; + rrIEs2->criticality = Criticality_ignore; + + rrIEs2->value.present = ResetRequestIEs__value_PR_TransactionID; + rrIEs2->value.choice.TransactionID = 1; + + ASN_SEQUENCE_ADD(&e2ap_pdu->choice.successfulOutcome->value.choice.ResetResponse.protocolIEs.list, rrIEs2); +} + +void encoding::generate_e2apv2_config_update(E2AP_PDU_t *e2ap_pdu){ + // txid + auto *e2txidIE = (E2nodeConfigurationUpdate_IEs_t *)calloc(1, sizeof(E2nodeConfigurationUpdate_IEs_t)); + e2txidIE->id = ProtocolIE_ID_id_TransactionID; + e2txidIE-> criticality = Criticality_reject; + e2txidIE->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID; + e2txidIE->value.choice.TransactionID = 1; + +/// config update id for addtion list +auto *e2configIE = (E2nodeConfigurationUpdate_IEs_t *)calloc(1, sizeof(E2nodeConfigurationUpdate_IEs_t)); +e2configIE->id = ProtocolIE_ID_id_E2nodeComponentConfigAddition; +e2configIE->criticality = Criticality_reject; +e2configIE->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigAddition_List; + + +auto *e2configAdditionItem = (E2nodeComponentConfigAddition_ItemIEs_t *)calloc(1, sizeof(E2nodeComponentConfigAddition_ItemIEs_t)); +e2configAdditionItem->id = ProtocolIE_ID_id_E2nodeComponentConfigAddition_Item; +e2configAdditionItem->criticality = Criticality_reject; +e2configAdditionItem->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item; +e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_ng; +e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeNG; + +auto *intfNG = (E2nodeComponentInterfaceNG_t *) calloc(1, sizeof(E2nodeComponentInterfaceNG_t)); + +OCTET_STRING_t nginterf; +nginterf.buf = (uint8_t*)calloc(1,8); +memcpy(nginterf.buf, (uint8_t *)"nginterf", 8); + +nginterf.size = 8; +intfNG->amf_name = (AMFName_t)(nginterf); + +e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeNG = intfNG; + +OCTET_STRING_t reqPart; +reqPart.buf = (uint8_t*)calloc(1,7); +memcpy(reqPart.buf, (uint8_t *)"reqpart", 7); +reqPart.size = 7; + +e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart = reqPart; + +OCTET_STRING_t resPart; +resPart.buf = (uint8_t*)calloc(1,7); +memcpy(resPart.buf, (uint8_t *)"respart", 7); +resPart.size = 7; +e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart = resPart; + +ASN_SEQUENCE_ADD(&e2configIE->value.choice.E2nodeComponentConfigAddition_List, e2configAdditionItem); + + InitiatingMessage *inititingMsg = (InitiatingMessage *) calloc(1, sizeof(InitiatingMessage)); + inititingMsg->procedureCode = ProcedureCode_id_E2nodeConfigurationUpdate; + inititingMsg->criticality = Criticality_reject; + inititingMsg->value.present = InitiatingMessage__value_PR_E2nodeConfigurationUpdate; + ASN_SEQUENCE_ADD(&inititingMsg->value.choice.E2nodeConfigurationUpdate.protocolIEs.list, e2txidIE); + ASN_SEQUENCE_ADD(&inititingMsg->value.choice.E2nodeConfigurationUpdate.protocolIEs.list, e2configIE); + e2ap_pdu->present = E2AP_PDU_PR_initiatingMessage; + e2ap_pdu->choice.initiatingMessage = inititingMsg; +} void encoding::generate_e2apv1_setup_response(E2AP_PDU_t *e2ap_pdu) { @@ -410,8 +639,8 @@ void encoding::generate_e2apv1_subscription_request(E2AP_PDU *e2ap_pdu) { e2ap_pdu->present = pres5; e2ap_pdu->choice.initiatingMessage = initmsg; - char *error_buf = (char*)calloc(300, sizeof(char));; - size_t errlen; + char error_buf[300] = {0, }; + size_t errlen = 0; asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen); printf("error length %d\n", errlen); @@ -451,6 +680,7 @@ void encoding::generate_e2apv1_subscription_response_success(E2AP_PDU *e2ap_pdu, RICaction_Admitted_List_t* admlist = (RICaction_Admitted_List_t*)calloc(1,sizeof(RICaction_Admitted_List_t)); ricactionadmitted->value.choice.RICaction_Admitted_List = *admlist; + if (admlist) free(admlist); int numAccept = accept_size; @@ -515,14 +745,15 @@ void encoding::generate_e2apv1_subscription_response_success(E2AP_PDU *e2ap_pdu, successoutcome->criticality = 0; successoutcome->value.present = pres2; successoutcome->value.choice.RICsubscriptionResponse = *ricsubresp; + if (ricsubresp) free(ricsubresp); E2AP_PDU_PR pres5 = E2AP_PDU_PR_successfulOutcome; e2ap_pdu->present = pres5; e2ap_pdu->choice.successfulOutcome = successoutcome; - char *error_buf = (char*)calloc(300, sizeof(char)); - size_t errlen; + char error_buf[300] = {0, }; + size_t errlen = 0; asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen); printf("error length %d\n", errlen); @@ -676,8 +907,8 @@ void encoding::generate_e2apv1_subscription_response(E2AP_PDU *e2ap_pdu, E2AP_PD e2ap_pdu->present = pres5; e2ap_pdu->choice.successfulOutcome = successoutcome; - char *error_buf = (char*)calloc(300, sizeof(char)); - size_t errlen; + char error_buf[300] = {0, }; + size_t errlen = 0; asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen); printf("error length %d\n", errlen); @@ -698,7 +929,8 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p uint8_t *ind_message_buf, int message_length) { - fprintf(stderr, "ind1\n"); + printf("Initializing E2AP request\n"); + RICindication_IEs_t *ricind_ies = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t)); RICindication_IEs_t *ricind_ies2 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t)); RICindication_IEs_t *ricind_ies3 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t)); @@ -717,8 +949,6 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p ricind_ies->value.choice.RICrequestID.ricRequestorID = requestorId; ricind_ies->value.choice.RICrequestID.ricInstanceID = instanceId; - fprintf(stderr, "ind2\n"); - pres3 = RICindication_IEs__value_PR_RANfunctionID; ricind_ies2->id = ProtocolIE_ID_id_RANfunctionID; ricind_ies2->criticality = 0; @@ -746,16 +976,6 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p ricind_ies5->value.present = pres3; ricind_ies5->value.choice.RICindicationType = 0; - - uint8_t *buf2 = (uint8_t *)"reportheader"; - OCTET_STRING_t *hdr_str = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t)); - - hdr_str->buf = (uint8_t*)calloc(1,header_length); - hdr_str->size = header_length; - memcpy(hdr_str->buf, ind_header_buf, header_length); - - fprintf(stderr, "ind3\n"); - ricind_ies6->value.choice.RICindicationHeader.buf = (uint8_t*)calloc(1,header_length); pres3 = RICindication_IEs__value_PR_RICindicationHeader; @@ -768,30 +988,19 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p ricind_ies7->value.choice.RICindicationMessage.buf = (uint8_t*)calloc(1,8192); - - pres3 = RICindication_IEs__value_PR_RICindicationMessage; ricind_ies7->id = ProtocolIE_ID_id_RICindicationMessage; - fprintf(stderr, "after encoding message 1\n"); ricind_ies7->criticality = 0; ricind_ies7->value.present = pres3; - fprintf(stderr, "after encoding message 2\n"); - - fprintf(stderr, "after encoding message 3\n"); ricind_ies7->value.choice.RICindicationMessage.size = message_length; - fprintf(stderr, "after encoding message 4\n"); memcpy(ricind_ies7->value.choice.RICindicationMessage.buf, ind_message_buf, message_length); - fprintf(stderr, "after encoding message 5\n"); - uint8_t *cpid_buf = (uint8_t *)"cpid"; OCTET_STRING_t cpid_str; - printf("5.1\n"); - int cpid_buf_len = strlen((char*)cpid_buf); pres3 = RICindication_IEs__value_PR_RICcallProcessID; ricind_ies8->id = ProtocolIE_ID_id_RICcallProcessID; @@ -804,39 +1013,16 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p memcpy(ricind_ies8->value.choice.RICcallProcessID.buf, cpid_buf, cpid_buf_len); - printf("5.2\n"); - RICindication_t *ricindication = (RICindication_t*)calloc(1, sizeof(RICindication_t)); - - int ret; - - ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies); - - ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies2); - - printf("5.3\n"); - - ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies3); - - printf("5.35\n"); - - ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies4); - - printf("5.36\n"); - - ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies5); - - printf("5.4\n"); - - ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies6); - - printf("5.5\n"); - - ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies7); - - ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies8); - + ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies); + ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies2); + ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies3); + ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies4); + ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies5); + ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies6); + ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies7); + ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies8); InitiatingMessage__value_PR pres4; pres4 = InitiatingMessage__value_PR_RICindication; @@ -845,21 +1031,23 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p initmsg->criticality = 1; initmsg->value.present = pres4; initmsg->value.choice.RICindication = *ricindication; + if (ricindication) free(ricindication); E2AP_PDU_PR pres5; pres5 = E2AP_PDU_PR_initiatingMessage; e2ap_pdu->present = pres5; e2ap_pdu->choice.initiatingMessage = initmsg; + char error_buf[300] = {0, }; + size_t errlen = 0; - char *error_buf = (char*)calloc(300, sizeof(char)); - size_t errlen; + int ret = asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen); - asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen); - printf("error length %d\n", errlen); - printf("error buf %s\n", error_buf); + if(ret) { + fprintf(stderr, "Constraint validation of E2AP PDU message failed: %s\n", error_buf); + } - xer_fprint(stderr, &asn_DEF_E2AP_PDU, e2ap_pdu); + //xer_fprint(stderr, &asn_DEF_E2AP_PDU, e2ap_pdu); }