--- /dev/null
+/*****************************************************************************
+# *
+# Copyright 2019 AT&T Intellectual Property *
+# Copyright 2019 Nokia *
+# *
+# Licensed under the Apache License, Version 2.0 (the "License"); *
+# you may not use this file except in compliance with the License. *
+# You may obtain a copy of the License at *
+# *
+# http://www.apache.org/licenses/LICENSE-2.0 *
+# *
+# Unless required by applicable law or agreed to in writing, software *
+# distributed under the License is distributed on an "AS IS" BASIS, *
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+# See the License for the specific language governing permissions and *
+# limitations under the License. *
+# *
+******************************************************************************/
+
+#include "asn_x2ap.hpp"
+#include "asn_x2ap_wrapper.hpp"
+
+/*-----------------------------------------------------------------------
+ COMMON ROUTINES
+-------------------------------------------------------------------------
+*/
+x2ap_pdu_t* new_x2ap_pdu(void)
+{
+ X2APpduWrapper* pduWrapper = new X2APpduWrapper();
+ return reinterpret_cast<x2ap_pdu_t*>(pduWrapper);
+}
+
+void x2ap_asn_print(x2ap_pdu_t* pdu, char* buf, size_t buf_size)
+{
+ X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
+
+ buf[0] = 0;
+
+ strncat(buf, asn::get_printed(pduWrapper->ref_pdu()).c_str(), buf_size - 1);
+}
+
+int x2ap_asn_per_encode(x2ap_pdu_t* pdu, unsigned char* buf, size_t buf_size,
+ char* err_buf, size_t err_buf_size)
+{
+ X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
+
+ asn::per::EncoderCtx ctx{ buf, buf_size };
+
+ if (!asn::per::pack(pduWrapper->ref_pdu(), ctx)) {
+ err_buf[0] = 0;
+ // strncat(err_buf, ctx.refErrorCtx().toString().c_str(), err_buf_size - 1);
+ return -1;
+ } else {
+ return static_cast<int>(ctx.refBuffer().getBytesUsed());
+ }
+
+}
+
+int x2ap_asn_per_decode(x2ap_pdu_t* pdu, unsigned char const* buf, size_t buf_size,
+ char* err_buf, size_t err_buf_size)
+{
+ X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
+
+ asn::per::DecoderCtx ctx{ buf,
+ buf_size,
+ pduWrapper->m_allocation_buffer,
+ pduWrapper->m_allocation_buffer_size };
+
+ if (!asn::per::unpack(pduWrapper->ref_pdu(), ctx)) {
+ err_buf[0] = 0;
+ // strncat(err_buf, ctx.refErrorCtx().toString().c_str(), err_buf_size - 1);
+ return -1;
+ }
+
+ return 0;
+
+}
+
+int x2ap_get_index(x2ap_pdu_t* pdu)
+{
+ X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
+
+ return pduWrapper->ref_pdu().get_index();
+}
+
+int x2ap_get_procedureCode(x2ap_pdu_t* pdu)
+{
+ X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
+
+ switch(pduWrapper->ref_pdu().get_index())
+ {
+ case 1:
+ return pduWrapper->ref_pdu().get_initiatingMessage()->ref_procedureCode().get();
+ break;
+
+ case 2:
+ return pduWrapper->ref_pdu().get_successfulOutcome()->ref_procedureCode().get();
+ break;
+
+ case 3:
+ return pduWrapper->ref_pdu().get_unsuccessfulOutcome()->ref_procedureCode().get();
+ break;
+
+ default:
+ return -1;
+ }
+
+}
+
+/*-----------------------------------------------------------------------
+ MESSAGE GENERATORS
+-------------------------------------------------------------------------
+*/
+//X2Setup
+bool x2ap_init_X2SetupRequest(x2ap_pdu_t* pdu)
+{
+ X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
+
+ //Initialization
+ pduWrapper->ref_pdu().select_initiatingMessage();
+ pduWrapper->ref_pdu().select_initiatingMessage().clear();
+ pduWrapper->ref_pdu().select_initiatingMessage().ref_procedureCode().select_id_x2Setup();
+ pduWrapper->ref_pdu().select_initiatingMessage().ref_criticality().select_id_x2Setup();
+ pduWrapper->ref_pdu().select_initiatingMessage().ref_value().select_id_x2Setup();
+
+ return true;
+}
+
+bool x2ap_create_X2SetupRequest(x2ap_pdu_t* pdu, eNB_config &cfg)
+{
+ X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
+
+ /* Initiaization */
+ pduWrapper->ref_pdu().select_initiatingMessage().ref_procedureCode().select_id_x2Setup();
+ pduWrapper->ref_pdu().select_initiatingMessage().ref_criticality().select_id_x2Setup();
+
+ X2SetupRequest* container =
+ &(pduWrapper->ref_pdu().select_initiatingMessage().ref_value().select_id_x2Setup());
+
+ using IE_value_t = X2SetupRequest::protocolIEs_t::value_type;
+
+ /* X2SetupRequest-IEs : GlobalENB-ID*/
+ IE_value_t* val_GlobalENB_ID = new IE_value_t;
+ container->ref_protocolIEs().push_back(*val_GlobalENB_ID);
+
+ val_GlobalENB_ID->ref_id().select_id_GlobalENB_ID();
+ val_GlobalENB_ID->ref_criticality().select_id_GlobalENB_ID();
+ val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID().ref_pLMN_Identity()
+ .set(3, cfg.pLMN_Identity);
+
+ val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID().ref_eNB_ID()
+ .select_macro_eNB_ID().set_buffer(20, cfg.macro_eNB_ID);
+
+ /* X2SetupRequest-IEs : ServedCells*/
+ IE_value_t* val_ServedCells = new IE_value_t;
+ container->ref_protocolIEs().push_back(*val_ServedCells);
+
+ val_ServedCells->ref_id().select_id_ServedCells();
+ val_ServedCells->ref_criticality().select_id_ServedCells();
+ val_ServedCells->ref_value().select_id_ServedCells();
+
+ //Add servedCellInfo
+ ServedCells::value_type* elm = new ServedCells::value_type();
+ ServedCell_Information* info = &(elm->ref_servedCellInfo());
+ {
+ //Set ServedCell-Information: pCI, cellId, tAC, broadcastPLMNs, eUTRA-Mode-Info
+ info->ref_pCI().set(cfg.pCI);
+ info->ref_cellId().ref_pLMN_Identity().set(3, cfg.pLMN_Identity);
+ info->ref_cellId().ref_eUTRANcellIdentifier().set_buffer(28, cfg.eUTRANcellIdentifier);
+ info->ref_tAC().set(2, cfg.tAC);
+
+ BroadcastPLMNs_Item::value_type* item = new BroadcastPLMNs_Item::value_type();
+ item->set(3, cfg.pLMN_Identity);
+ info->ref_broadcastPLMNs().push_back(*item);
+
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_EARFCN().set(cfg.uL_EARFCN);
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_EARFCN().set(cfg.dL_EARFCN);
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_Transmission_Bandwidth()
+ .set(static_cast<Transmission_Bandwidth::index_t>(cfg.uL_Bandwidth));
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_Transmission_Bandwidth()
+ .set(static_cast<Transmission_Bandwidth::index_t>(cfg.dL_Bandwidth));
+ }
+ val_ServedCells->ref_value().select_id_ServedCells().push_back(*elm);
+
+ return true;
+}
+
+bool x2ap_create_X2SetupResponse(x2ap_pdu_t* pdu, eNB_config &cfg)
+{
+ X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
+
+ /* Initiaization */
+ pduWrapper->ref_pdu().select_successfulOutcome().ref_procedureCode().select_id_x2Setup();
+ pduWrapper->ref_pdu().select_successfulOutcome().ref_criticality().select_id_x2Setup();
+
+ X2SetupResponse* container =
+ &(pduWrapper->ref_pdu().select_successfulOutcome().ref_value().select_id_x2Setup());
+
+ using IE_value_t = X2SetupResponse::protocolIEs_t::value_type;
+
+ /* X2SetupResponse-IEs : GlobalENB-ID*/
+ IE_value_t* val_GlobalENB_ID = new IE_value_t;
+ container->ref_protocolIEs().push_back(*val_GlobalENB_ID);
+
+ val_GlobalENB_ID->ref_id().select_id_GlobalENB_ID();
+ val_GlobalENB_ID->ref_criticality().select_id_GlobalENB_ID();
+ val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID().ref_pLMN_Identity()
+ .set(3, cfg.pLMN_Identity);
+
+ val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID().ref_eNB_ID()
+ .select_macro_eNB_ID().set_buffer(20, cfg.macro_eNB_ID);
+
+ /* X2SetupResponse-IEs : ServedCells*/
+ IE_value_t* val_ServedCells = new IE_value_t;
+ container->ref_protocolIEs().push_back(*val_ServedCells);
+
+ val_ServedCells->ref_id().select_id_ServedCells();
+ val_ServedCells->ref_criticality().select_id_ServedCells();
+ val_ServedCells->ref_value().select_id_ServedCells();
+
+ //Add servedCellInfo
+ ServedCells::value_type* elm = new ServedCells::value_type();
+ ServedCell_Information* info = &(elm->ref_servedCellInfo());
+ {
+ //Set ServedCell-Information: pCI, cellId, tAC, broadcastPLMNs, eUTRA-Mode-Info
+ info->ref_pCI().set(cfg.pCI);
+ info->ref_cellId().ref_pLMN_Identity().set(3, cfg.pLMN_Identity);
+ info->ref_cellId().ref_eUTRANcellIdentifier().set_buffer(28, cfg.eUTRANcellIdentifier);
+ info->ref_tAC().set(2, cfg.tAC);
+
+ BroadcastPLMNs_Item::value_type* item = new BroadcastPLMNs_Item::value_type();
+ item->set(3, cfg.pLMN_Identity);
+ info->ref_broadcastPLMNs().push_back(*item);
+
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_EARFCN().set(cfg.uL_EARFCN);
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_EARFCN().set(cfg.dL_EARFCN);
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_Transmission_Bandwidth()
+ .set(static_cast<Transmission_Bandwidth::index_t>(cfg.uL_Bandwidth));
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_Transmission_Bandwidth()
+ .set(static_cast<Transmission_Bandwidth::index_t>(cfg.dL_Bandwidth));
+ }
+ val_ServedCells->ref_value().select_id_ServedCells().push_back(*elm);
+
+ return true;
+}
+
+bool x2ap_create_X2SetupFailure(x2ap_pdu_t* pdu)
+{
+ X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
+
+ /* Initiaization */
+ pduWrapper->ref_pdu().select_unsuccessfulOutcome().ref_procedureCode().select_id_x2Setup();
+ pduWrapper->ref_pdu().select_unsuccessfulOutcome().ref_criticality().select_id_x2Setup();
+
+ X2SetupFailure* container =
+ &(pduWrapper->ref_pdu().select_unsuccessfulOutcome().ref_value().select_id_x2Setup());
+
+ using IE_value_t = X2SetupFailure::protocolIEs_t::value_type;
+
+ /* X2SetupFailure-IEs << id-Cause */
+ IE_value_t* val_cause = new IE_value_t;
+ container->ref_protocolIEs().push_back(*val_cause);
+
+ val_cause->ref_id().select_id_Cause();
+ val_cause->ref_criticality().select_id_Cause();
+
+ /* Cause << radioNetwork */
+ val_cause->ref_value().select_id_Cause().select_radioNetwork();
+
+ /* CauseRadioNetwork = ho-target-not-allowed (enum = 8)*/
+ val_cause->ref_value().select_id_Cause().select_radioNetwork()
+ .set(static_cast<CauseRadioNetwork::index_t>(8));
+
+ return true;
+}
+
+//ENDCX2Setup
+bool x2ap_create_ENDCX2SetupRequest(x2ap_pdu_t* pdu, eNB_config &cfg)
+{
+ X2APpduWrapper* pduWrapper = reinterpret_cast<X2APpduWrapper*>(pdu);
+
+ /* Initiaization */
+ pduWrapper->ref_pdu().select_initiatingMessage().ref_procedureCode().select_id_endcX2Setup();
+ pduWrapper->ref_pdu().select_initiatingMessage().ref_criticality().select_id_endcX2Setup();
+
+ ENDCX2SetupRequest* container =
+ &(pduWrapper->ref_pdu().select_initiatingMessage().ref_value().select_id_endcX2Setup());
+
+ using IE_value_t = ENDCX2SetupRequest::protocolIEs_t::value_type;
+
+ /* ENDCX2SetupRequest-IEs = id-InitiatingNodeType-EndcX2Setup */
+ IE_value_t* ie = new IE_value_t;
+ container->ref_protocolIEs().push_back(*ie);
+ ie->ref_id().select_id_InitiatingNodeType_EndcX2Setup();
+ ie->ref_criticality().select_id_InitiatingNodeType_EndcX2Setup();
+ ie->ref_value().select_id_InitiatingNodeType_EndcX2Setup();
+
+ /* InitiatingNodeType-EndcX2Setup = init-eNB {ENB-ENDCX2SetupReqIEs} */
+ ie->ref_value().select_id_InitiatingNodeType_EndcX2Setup().select_init_eNB();
+
+ using eNB_val_t = InitiatingNodeType_EndcX2Setup::init_eNB_t::value_type;
+
+ ProtocolIE_Container<ENB_ENDCX2SetupReqIEs>* eNB_node =
+ &(ie->ref_value().select_id_InitiatingNodeType_EndcX2Setup().select_init_eNB());
+
+ /* ENB-ENDCX2SetupReqIEs <-- id-GlobalENB-ID */
+ eNB_val_t* val_GlobalENB_ID = new eNB_val_t;
+ eNB_node->push_back(*val_GlobalENB_ID);
+
+ val_GlobalENB_ID->ref_id().select_id_GlobalENB_ID();
+ val_GlobalENB_ID->ref_criticality().select_id_GlobalENB_ID();
+ val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID()
+ .ref_pLMN_Identity().set(3, cfg.pLMN_Identity);
+ val_GlobalENB_ID->ref_value().select_id_GlobalENB_ID().ref_eNB_ID()
+ .select_macro_eNB_ID().set_buffer(20, cfg.macro_eNB_ID);
+
+ /* ENB-ENDCX2SetupReqIEs <-- id-ServedEUTRAcellsENDCX2ManagementList */
+ eNB_val_t* val_EUTRAlist = new eNB_val_t;
+ eNB_node->push_back(*val_EUTRAlist);
+
+ val_EUTRAlist->ref_id().select_id_ServedEUTRAcellsENDCX2ManagementList();
+ val_EUTRAlist->ref_criticality().select_id_ServedEUTRAcellsENDCX2ManagementList();
+ val_EUTRAlist->ref_value().select_id_ServedEUTRAcellsENDCX2ManagementList();
+
+ /* ServedEUTRAcellsENDCX2ManagementList <-- servedEUTRACellInfo */
+ ServedEUTRAcellsENDCX2ManagementList::value_type* elm =
+ new ServedEUTRAcellsENDCX2ManagementList::value_type();
+ ServedCell_Information* info = &(elm->ref_servedEUTRACellInfo());
+ {
+ //Set ServedCell-Information: pCI, cellId, tAC, broadcastPLMNs, eUTRA-Mode-Info
+ info->ref_pCI().set(cfg.pCI);
+ info->ref_cellId().ref_pLMN_Identity().set(3, cfg.pLMN_Identity);
+ info->ref_cellId().ref_eUTRANcellIdentifier().set_buffer(28, cfg.eUTRANcellIdentifier);
+ info->ref_tAC().set(2, cfg.tAC);
+
+ BroadcastPLMNs_Item::value_type* item = new BroadcastPLMNs_Item::value_type();
+ item->set(3, cfg.pLMN_Identity);
+ info->ref_broadcastPLMNs().push_back(*item);
+
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_EARFCN().set(cfg.uL_EARFCN);
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_EARFCN().set(cfg.dL_EARFCN);
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_uL_Transmission_Bandwidth()
+ .set(static_cast<Transmission_Bandwidth::index_t>(cfg.uL_Bandwidth));
+ info->ref_eUTRA_Mode_Info().select_fDD().ref_dL_Transmission_Bandwidth()
+ .set(static_cast<Transmission_Bandwidth::index_t>(cfg.dL_Bandwidth));
+ }
+ val_EUTRAlist->ref_value().select_id_ServedEUTRAcellsENDCX2ManagementList()
+ .push_back(*elm);
+
+ return true;
+}
+
+/*-----------------------------------------------------------------------
+ TESTS
+-------------------------------------------------------------------------
+*/
+void test_X2Setup_codec(void)
+{
+ x2ap_pdu_t* pdu = new_x2ap_pdu();
+
+ eNB_config cfg;
+ x2ap_create_X2SetupRequest(pdu, cfg);
+
+ char pdu_str[1024];
+ x2ap_asn_print(pdu, pdu_str, sizeof(pdu_str));
+ printf("%s\n", pdu_str);
+
+ //Test encode
+ unsigned char packed_buf[4096];
+ char err_buf[1024];
+
+ int packed_len = x2ap_asn_per_encode(pdu, packed_buf, sizeof(packed_buf),
+ err_buf, sizeof(err_buf));
+ if(packed_len != -1) {
+ printf("Encode successful, packed_len = %d\n", packed_len);
+ } else {
+ printf("Encode Error: %s\n", err_buf);
+ }
+
+ //Test encode error
+ x2ap_pdu_t* pdu1 = new_x2ap_pdu();
+ x2ap_init_X2SetupRequest(pdu1);
+
+ int packed_len1 = x2ap_asn_per_encode(pdu1, packed_buf, sizeof(packed_buf),
+ err_buf, sizeof(err_buf));
+ if(packed_len1 != -1) {
+ printf("Encode successful, packed_len = %d\n", packed_len1);
+ } else {
+ printf("Encode Error: %s\n", err_buf);
+ }
+
+ //Test decode
+ x2ap_pdu_t* pdu2 = new_x2ap_pdu();
+ int rc = x2ap_asn_per_decode(pdu2, packed_buf, packed_len, err_buf, sizeof(err_buf));
+ if(rc == -1) {
+ printf("Decode error: %s\n", err_buf);
+ } else {
+ printf("Decode successful\n");
+ }
+
+ x2ap_asn_print(pdu2, pdu_str, sizeof(pdu_str));
+ printf("%s\n", pdu_str);
+
+ printf("index = %d\n", x2ap_get_index(pdu2));
+ printf("procedureCode = %d\n", x2ap_get_procedureCode(pdu2));
+
+
+ //Test decode error
+ x2ap_pdu_t* pdu3 = new_x2ap_pdu();
+ int rc2 = x2ap_asn_per_decode(pdu3, packed_buf, 1, err_buf, sizeof(err_buf));
+ if(rc2 == -1) {
+ printf("Decode error: %s\n", err_buf);
+ } else {
+ printf("Decode successful\n");
+ }
+
+ //Test X2SetupResponse
+ x2ap_pdu_t* pdu_resp = new_x2ap_pdu();
+ x2ap_create_X2SetupResponse(pdu_resp, cfg);
+ x2ap_asn_print(pdu_resp, pdu_str, sizeof(pdu_str));
+ printf("%s\n", pdu_str);
+
+ //Test X2SetupFailure
+ x2ap_pdu_t* pdu_failure = new_x2ap_pdu();
+ x2ap_create_X2SetupFailure(pdu_failure);
+ x2ap_asn_print(pdu_failure, pdu_str, sizeof(pdu_str));
+ printf("%s \n", pdu_str);
+}
Code Review / sim / e2-interface.git / blobdiff