Commit f80855ca authored by Tien Thinh NGUYEN's avatar Tien Thinh NGUYEN

Code refactor for PLMN ID and RAN Node name

parent ce10f608
......@@ -667,7 +667,6 @@ void amf_n2::handle_itti_message(itti_initial_ue_message& init_ue_msg) {
if (init_ue_msg.initUeMsg->getNasPdu(nas_buf, nas_len)) {
// bstring nas = blk2bstr(nas_buf, nas_len);
itti_msg->nas_buf = blk2bstr(nas_buf, nas_len);
;
} else {
Logger::amf_n2().error("Missing IE NAS-PDU");
return;
......@@ -1558,7 +1557,7 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) {
// GUAMI, PLMN
ngap::PlmnId m_plmnId = {};
m_plmnId.setMccMnc(amf_cfg.guami.mcc, amf_cfg.guami.mnc);
m_plmnId.set(amf_cfg.guami.mcc, amf_cfg.guami.mnc);
handover_request->setMobilityRestrictionList(m_plmnId);
handover_request->setGUAMI(
......
......@@ -283,3 +283,32 @@ void conv::sd_string_to_int(const std::string& sd_str, uint32_t& sd) {
sd = SD_NO_VALUE;
}
}
//------------------------------------------------------------------------------
void conv::bstring_2_string(const bstring& b_str, std::string& str) {
auto b = bstrcpy(b_str);
// std::string str_tmp((char*) bdata(b) , blength(b));
str.assign((char*) bdata(b), blength(b));
}
//------------------------------------------------------------------------------
void conv::string_2_bstring(const std::string& str, bstring& b_str) {
b_str = blk2bstr(str.c_str(), str.length());
}
//------------------------------------------------------------------------------
void conv::octet_string_2_string(
const OCTET_STRING_t& octet_str, std::string& str) {
// std::string str_tmp((char *) octet_str.buf , octet_str.size);
str.assign((char*) octet_str.buf, octet_str.size);
}
//------------------------------------------------------------------------------
void conv::string_2_octet_string(
const std::string& str, OCTET_STRING_t& o_str) {
o_str.buf = (uint8_t*) calloc(1, str.length() + 1);
// o_str.buf = strcpy(new char[str.length() + 1], str.c_str());
std::copy(str.begin(), str.end(), o_str.buf);
o_str.buf[str.length()] = '\0';
o_str.size = str.length() + 1;
}
......@@ -68,5 +68,11 @@ class conv {
const OCTET_STRING_t& octet_str, bstring& b_str);
static void bstring_2_octet_string(bstring& b_str, OCTET_STRING_t& octet_str);
static void sd_string_to_int(const std::string& sd_str, uint32_t& sd);
static void bstring_2_string(const bstring& b_str, std::string& str);
static void string_2_bstring(const std::string& str, bstring& b_str);
static void octet_string_2_string(
const OCTET_STRING_t& octet_str, std::string& str);
static void string_2_octet_string(
const std::string& str, OCTET_STRING_t& o_str);
};
#endif /* FILE_CONVERSIONS_HPP_SEEN */
......@@ -57,7 +57,7 @@ void BroadcastPLMNItem::getPlmnSliceSupportList(
//------------------------------------------------------------------------------
bool BroadcastPLMNItem::encode2BroadcastPLMNItem(
Ngap_BroadcastPLMNItem_t* plmnItem) {
if (!plmn.encode2octetstring(plmnItem->pLMNIdentity)) return false;
if (!plmn.encode(plmnItem->pLMNIdentity)) return false;
for (std::vector<S_NSSAI>::iterator it = std::begin(supportedSliceList);
it < std::end(supportedSliceList); ++it) {
......@@ -74,7 +74,7 @@ bool BroadcastPLMNItem::encode2BroadcastPLMNItem(
//------------------------------------------------------------------------------
bool BroadcastPLMNItem::decodefromBroadcastPLMNItem(
Ngap_BroadcastPLMNItem_t* pdu) {
if (!plmn.decodefromoctetstring(pdu->pLMNIdentity)) return false;
if (!plmn.decode(pdu->pLMNIdentity)) return false;
for (int i = 0; i < pdu->tAISliceSupportList.list.count; i++) {
S_NSSAI snssai = {};
if (!snssai.decodefromS_NSSAI(
......
......@@ -44,7 +44,7 @@ void EUTRA_CGI::setEUTRA_CGI(
//------------------------------------------------------------------------------
bool EUTRA_CGI::encode2EUTRA_CGI(Ngap_EUTRA_CGI_t* eutra_cgi) {
if (!plmnId->encode2octetstring(eutra_cgi->pLMNIdentity)) return false;
if (!plmnId->encode(eutra_cgi->pLMNIdentity)) return false;
if (!eUTRACellIdentity->encode2bitstring(eutra_cgi->eUTRACellIdentity))
return false;
......@@ -55,7 +55,7 @@ bool EUTRA_CGI::encode2EUTRA_CGI(Ngap_EUTRA_CGI_t* eutra_cgi) {
bool EUTRA_CGI::decodefromEUTRA_CGI(Ngap_EUTRA_CGI_t* eutra_cgi) {
if (plmnId == nullptr) plmnId = new PlmnId();
if (eUTRACellIdentity == nullptr) eUTRACellIdentity = new EUTRACellIdentity();
if (!plmnId->decodefromoctetstring(eutra_cgi->pLMNIdentity)) return false;
if (!plmnId->decode(eutra_cgi->pLMNIdentity)) return false;
if (!eUTRACellIdentity->decodefrombitstring(eutra_cgi->eUTRACellIdentity))
return false;
......
......@@ -46,7 +46,7 @@ void GUAMI::setGUAMI(
void GUAMI::setGUAMI(
const std::string& mcc, const std::string& mnc, const uint8_t& regionId,
const uint16_t& setId, const uint8_t& pointer) {
plmnId.setMccMnc(mcc, mnc);
plmnId.set(mcc, mnc);
aMFRegionID.setAMFRegionID(regionId);
aMFSetID.setAMFSetID(setId);
aMFPointer.setAMFPointer(pointer);
......@@ -56,7 +56,7 @@ void GUAMI::setGUAMI(
void GUAMI::setGUAMI(
const std::string& mcc, const std::string& mnc, const std::string& regionId,
const std::string& setId, const std::string& pointer) {
plmnId.setMccMnc(mcc, mnc);
plmnId.set(mcc, mnc);
aMFRegionID.setAMFRegionID(regionId);
aMFSetID.setAMFSetID(setId);
aMFPointer.setAMFPointer(pointer);
......@@ -64,7 +64,7 @@ void GUAMI::setGUAMI(
//------------------------------------------------------------------------------
bool GUAMI::encode2GUAMI(Ngap_GUAMI_t* guami) {
if (!plmnId.encode2octetstring(guami->pLMNIdentity)) return false;
if (!plmnId.encode(guami->pLMNIdentity)) return false;
if (!aMFRegionID.encode2bitstring(guami->aMFRegionID)) return false;
if (!aMFSetID.encode2bitstring(guami->aMFSetID)) return false;
if (!aMFPointer.encode2bitstring(guami->aMFPointer)) return false;
......@@ -74,7 +74,7 @@ bool GUAMI::encode2GUAMI(Ngap_GUAMI_t* guami) {
//------------------------------------------------------------------------------
bool GUAMI::decodefromGUAMI(Ngap_GUAMI_t* pdu) {
if (!plmnId.decodefromoctetstring(pdu->pLMNIdentity)) return false;
if (!plmnId.decode(pdu->pLMNIdentity)) return false;
if (!aMFRegionID.decodefrombitstring(pdu->aMFRegionID)) return false;
if (!aMFSetID.decodefrombitstring(pdu->aMFSetID)) return false;
if (!aMFPointer.decodefrombitstring(pdu->aMFPointer)) return false;
......
......@@ -43,15 +43,14 @@ void GlobalNgENBId::get(PlmnId& plmn_id, NgENB_ID& ng_enb_id) const {
//------------------------------------------------------------------------------
bool GlobalNgENBId::encode(Ngap_GlobalNgENB_ID_t& global_ng_enb_id) {
if (!plmn_id_.encode2octetstring(global_ng_enb_id.pLMNIdentity)) return false;
if (!plmn_id_.encode(global_ng_enb_id.pLMNIdentity)) return false;
if (!ng_enb_id_.encode(global_ng_enb_id.ngENB_ID)) return false;
return true;
}
//------------------------------------------------------------------------------
bool GlobalNgENBId::decode(Ngap_GlobalNgENB_ID_t& global_ng_enb_id) {
if (!plmn_id_.decodefromoctetstring(global_ng_enb_id.pLMNIdentity))
return false;
if (!plmn_id_.decode(global_ng_enb_id.pLMNIdentity)) return false;
if (!ng_enb_id_.decode(global_ng_enb_id.ngENB_ID)) return false;
return true;
}
......
......@@ -47,10 +47,8 @@ class GlobalRanNodeId {
void setChoiceOfRanNodeId(const Ngap_GlobalRANNodeID_PR& id_present);
Ngap_GlobalRANNodeID_PR getChoiceOfRanNodeId();
bool encode(
Ngap_GlobalRANNodeID_t*); // TODO: use reference instead of pointer
bool decode(
Ngap_GlobalRANNodeID_t*); // TODO: use reference instead of pointer
bool encode(Ngap_GlobalRANNodeID_t*);
bool decode(Ngap_GlobalRANNodeID_t*);
private:
std::optional<GlobalgNBId> global_gnb_id_;
......
......@@ -46,7 +46,7 @@ void GlobalgNBId::get(PlmnId& plmn, GNB_ID& gnbid) {
//------------------------------------------------------------------------------
bool GlobalgNBId::encode(Ngap_GlobalGNB_ID_t* globalgnbid) {
if (!plmnId.encode2octetstring(globalgnbid->pLMNIdentity)) return false;
if (!plmnId.encode(globalgnbid->pLMNIdentity)) return false;
if (!gNB_ID.encode(globalgnbid->gNB_ID)) return false;
return true;
......@@ -54,7 +54,7 @@ bool GlobalgNBId::encode(Ngap_GlobalGNB_ID_t* globalgnbid) {
//------------------------------------------------------------------------------
bool GlobalgNBId::decode(Ngap_GlobalGNB_ID_t* globalgnbid) {
if (!plmnId.decodefromoctetstring(globalgnbid->pLMNIdentity)) return false;
if (!plmnId.decode(globalgnbid->pLMNIdentity)) return false;
if (!gNB_ID.decode(globalgnbid->gNB_ID)) return false;
return true;
......
......@@ -43,7 +43,7 @@ void MobilityRestrictionList::getMobilityRestrictionList(PlmnId& sPLMN) {
//------------------------------------------------------------------------------
bool MobilityRestrictionList::encodeMobilityRestrictionList(
Ngap_MobilityRestrictionList_t* mobilityrestrictionlist) {
if (!servingPLMN.encode2octetstring(mobilityrestrictionlist->servingPLMN)) {
if (!servingPLMN.encode(mobilityrestrictionlist->servingPLMN)) {
return false;
}
return true;
......
......@@ -43,13 +43,13 @@ void NR_CGI::setNR_CGI(
void NR_CGI::setNR_CGI(
const std::string& mcc, const std::string& mnc,
const unsigned long& nrcellidentity) {
plmnId.setMccMnc(mcc, mnc);
plmnId.set(mcc, mnc);
nRCellIdentity.setNRCellIdentity(nrcellidentity);
}
//------------------------------------------------------------------------------
void NR_CGI::setNR_CGI(const struct NrCgi_s& cig) {
plmnId.setMccMnc(cig.mcc, cig.mnc);
plmnId.set(cig.mcc, cig.mnc);
nRCellIdentity.setNRCellIdentity(cig.nrCellID);
}
......@@ -62,7 +62,7 @@ void NR_CGI::getNR_CGI(struct NrCgi_s& cig) {
//------------------------------------------------------------------------------
bool NR_CGI::encode2NR_CGI(Ngap_NR_CGI_t* nr_cgi) {
if (!plmnId.encode2octetstring(nr_cgi->pLMNIdentity)) return false;
if (!plmnId.encode(nr_cgi->pLMNIdentity)) return false;
if (!nRCellIdentity.encode2bitstring(nr_cgi->nRCellIdentity)) return false;
return true;
......@@ -70,7 +70,7 @@ bool NR_CGI::encode2NR_CGI(Ngap_NR_CGI_t* nr_cgi) {
//------------------------------------------------------------------------------
bool NR_CGI::decodefromNR_CGI(Ngap_NR_CGI_t* nr_cgi) {
if (!plmnId.decodefromoctetstring(nr_cgi->pLMNIdentity)) return false;
if (!plmnId.decode(nr_cgi->pLMNIdentity)) return false;
if (!nRCellIdentity.decodefrombitstring(nr_cgi->nRCellIdentity)) return false;
return true;
}
......
......@@ -45,7 +45,7 @@ void PLMNSupportItem::setPlmnSliceSupportList(
//------------------------------------------------------------------------------
bool PLMNSupportItem::encode2PLMNSupportItem(
Ngap_PLMNSupportItem_t* plmnsupportItem) {
if (!plmn.encode2octetstring(plmnsupportItem->pLMNIdentity)) return false;
if (!plmn.encode(plmnsupportItem->pLMNIdentity)) return false;
for (std::vector<S_NSSAI>::iterator it = std::begin(snssais);
it < std::end(snssais); ++it) {
Ngap_SliceSupportItem_t* slice =
......@@ -59,7 +59,7 @@ bool PLMNSupportItem::encode2PLMNSupportItem(
//------------------------------------------------------------------------------
bool PLMNSupportItem::decodefromPLMNSupportItem(
Ngap_PLMNSupportItem_t* plmnsupportItem) {
if (!plmn.decodefromoctetstring(plmnsupportItem->pLMNIdentity)) return false;
if (!plmn.decode(plmnsupportItem->pLMNIdentity)) return false;
for (int i = 0; i < plmnsupportItem->sliceSupportList.list.count; i++) {
S_NSSAI snssai = {};
......
......@@ -26,8 +26,6 @@
extern "C" {
#include <math.h>
}
#include <iostream>
using namespace std;
namespace ngap {
......@@ -46,27 +44,33 @@ PlmnId::PlmnId() {
PlmnId::~PlmnId() {}
//------------------------------------------------------------------------------
void PlmnId::setMccMnc(const std::string mcc, const std::string mnc) {
int mccValue = fromString<int>(mcc);
int mncValue = fromString<int>(mnc);
void PlmnId::set(const std::string& mcc, const std::string& mnc) {
int mcc_value = fromString<int>(mcc);
int mnc_value = fromString<int>(mnc);
mcc_digit1 = mccValue / 100;
mcc_digit2 = (mccValue - mcc_digit1 * 100) / 10;
mcc_digit3 = mccValue % 10;
mcc_digit1 = mcc_value / 100;
mcc_digit2 = (mcc_value - mcc_digit1 * 100) / 10;
mcc_digit3 = mcc_value % 10;
if (mncValue > 99) {
mnc_digit3 = mncValue / 100;
if (mnc_value > 99) {
mnc_digit3 = mnc_value / 100;
} else {
mnc_digit3 = 0xf;
}
mnc_digit1 = (uint8_t) floor((double) (mncValue % 100) / 10);
mnc_digit2 = mncValue % 10;
mnc_digit1 = (uint8_t) std::floor((double) (mnc_value % 100) / 10);
mnc_digit2 = mnc_value % 10;
}
//------------------------------------------------------------------------------
void PlmnId::getMcc(std::string& mcc) {
void PlmnId::get(std::string& mcc, std::string& mnc) const {
getMcc(mcc);
getMnc(mnc);
}
//------------------------------------------------------------------------------
void PlmnId::getMcc(std::string& mcc) const {
int m_mcc = mcc_digit1 * 100 + mcc_digit2 * 10 + mcc_digit3;
mcc = to_string(m_mcc);
mcc = std::to_string(m_mcc);
if ((mcc_digit2 == 0) and (mcc_digit1 == 0)) {
mcc = "00" + mcc;
} else if (mcc_digit1 == 0) {
......@@ -75,37 +79,37 @@ void PlmnId::getMcc(std::string& mcc) {
}
//------------------------------------------------------------------------------
void PlmnId::getMnc(std::string& mnc) {
void PlmnId::getMnc(std::string& mnc) const {
int m_mnc = 0;
if (mnc_digit3 == 0xf) {
m_mnc = mnc_digit1 * 10 + mnc_digit2;
if (mnc_digit1 == 0) {
mnc = "0" + to_string(m_mnc);
mnc = "0" + std::to_string(m_mnc);
return;
}
} else {
m_mnc = mnc_digit3 * 100 + mnc_digit1 * 10 + mnc_digit2;
}
mnc = to_string(m_mnc);
mnc = std::to_string(m_mnc);
}
//------------------------------------------------------------------------------
bool PlmnId::encode2octetstring(Ngap_PLMNIdentity_t& plmn) {
bool PlmnId::encode(Ngap_PLMNIdentity_t& plmn) {
plmn.size = 3; // OCTET_STRING(SIZE(3)) 9.3.3.5, 3gpp ts 38.413 V15.4.0
uint8_t* buffer = (uint8_t*) calloc(1, 3 * sizeof(uint8_t));
if (!buffer) return false;
buffer[0] = 0x00 | ((mcc_digit2 & 0x0f) << 4) | (mcc_digit1 & 0x0f);
buffer[1] = 0x00 | ((mnc_digit3 & 0x0f) << 4) | (mcc_digit3 & 0x0f);
buffer[2] = 0x00 | ((mnc_digit2 & 0x0f) << 4) | (mnc_digit1 & 0x0f);
plmn.buf = buffer;
plmn.buf = (uint8_t*) calloc(1, 3 * sizeof(uint8_t));
if (!plmn.buf) return false;
plmn.buf[0] = 0x00 | ((mcc_digit2 & 0x0f) << 4) | (mcc_digit1 & 0x0f);
plmn.buf[1] = 0x00 | ((mnc_digit3 & 0x0f) << 4) | (mcc_digit3 & 0x0f);
plmn.buf[2] = 0x00 | ((mnc_digit2 & 0x0f) << 4) | (mnc_digit1 & 0x0f);
return true;
}
//------------------------------------------------------------------------------
bool PlmnId::decodefromoctetstring(Ngap_PLMNIdentity_t& plmn) {
bool PlmnId::decode(Ngap_PLMNIdentity_t& plmn) {
if (!plmn.buf) return false;
if (plmn.size < 3) return false;
mcc_digit1 = plmn.buf[0] & 0x0f;
mcc_digit2 = plmn.buf[0] >> 4;
......
......@@ -35,11 +35,12 @@ class PlmnId {
PlmnId();
virtual ~PlmnId();
bool encode2octetstring(Ngap_PLMNIdentity_t&);
bool decodefromoctetstring(Ngap_PLMNIdentity_t&);
void setMccMnc(const std::string mcc, const std::string mnc);
void getMcc(std::string& mcc);
void getMnc(std::string& mnc);
bool encode(Ngap_PLMNIdentity_t&);
bool decode(Ngap_PLMNIdentity_t&);
void set(const std::string& mcc, const std::string& mnc);
void get(std::string& mcc, std::string& mnc) const;
void getMcc(std::string& mcc) const;
void getMnc(std::string& mnc) const;
private:
uint8_t mcc_digit2;
......
......@@ -21,45 +21,38 @@
#include "RanNodeName.hpp"
#include <iostream>
using namespace std;
#include "conversions.hpp"
namespace ngap {
//------------------------------------------------------------------------------
RanNodeName::RanNodeName() {
ranNodeName = NULL;
ran_node_name_ = {};
}
//------------------------------------------------------------------------------
RanNodeName::~RanNodeName() {}
//------------------------------------------------------------------------------
void RanNodeName::setValue(const std::string ranName) {
ranNodeName = (char*) ranName.c_str();
void RanNodeName::setValue(const std::string& value) {
ran_node_name_ = value;
}
//------------------------------------------------------------------------------
bool RanNodeName::getValue(std::string& ranName) {
if (!ranNodeName) return false;
ranName = ranNodeName;
return true;
void RanNodeName::getValue(std::string& value) const {
value = ran_node_name_;
}
//------------------------------------------------------------------------------
bool RanNodeName::encode2RanNodeName(Ngap_RANNodeName_t* rannodename) {
int ret = OCTET_STRING_fromBuf(rannodename, ranNodeName, strlen(ranNodeName));
if (ret == 0)
return true;
else
return false;
bool RanNodeName::encode(Ngap_RANNodeName_t& ran_node_name) {
conv::string_2_octet_string(ran_node_name_, ran_node_name);
return true;
}
//------------------------------------------------------------------------------
bool RanNodeName::decodefromRanNodeName(Ngap_RANNodeName_t* rannodename) {
if (!rannodename->buf) return false;
ranNodeName = (char*) rannodename->buf;
bool RanNodeName::decode(Ngap_RANNodeName_t& ran_node_name) {
if (!ran_node_name.buf) return false;
conv::octet_string_2_string(ran_node_name, ran_node_name_);
return true;
}
......
......@@ -35,13 +35,14 @@ class RanNodeName {
RanNodeName();
virtual ~RanNodeName();
void setValue(const std::string ranName);
bool encode2RanNodeName(Ngap_RANNodeName_t*);
bool decodefromRanNodeName(Ngap_RANNodeName_t*);
bool getValue(std::string& ranName);
void setValue(const std::string& value);
void getValue(std::string& value) const;
bool encode(Ngap_RANNodeName_t&);
bool decode(Ngap_RANNodeName_t&);
private:
char* ranNodeName;
std::string ran_node_name_;
};
} // namespace ngap
......
......@@ -38,7 +38,7 @@ void TAI::setTAI(const PlmnId& m_plmnId, const TAC& m_tac) {
//------------------------------------------------------------------------------
void TAI::setTAI(
const std::string& mcc, const std::string& mnc, const uint32_t& m_tac) {
plmnId.setMccMnc(mcc, mnc);
plmnId.set(mcc, mnc);
tac.setTac(m_tac);
}
......@@ -51,12 +51,12 @@ void TAI::getTAI(std::string& mcc, std::string& mnc, uint32_t& m_tac) {
//------------------------------------------------------------------------------
void TAI::setTAI(const Tai_t& tai) {
plmnId.setMccMnc(tai.mcc, tai.mnc);
plmnId.set(tai.mcc, tai.mnc);
tac.setTac(tai.tac);
}
//------------------------------------------------------------------------------
bool TAI::encode2TAI(Ngap_TAI_t* tai) {
if (!plmnId.encode2octetstring(tai->pLMNIdentity)) return false;
if (!plmnId.encode(tai->pLMNIdentity)) return false;
if (!tac.encode2octetstring(tai->tAC)) return false;
return true;
......@@ -64,7 +64,7 @@ bool TAI::encode2TAI(Ngap_TAI_t* tai) {
//------------------------------------------------------------------------------
bool TAI::decodefromTAI(Ngap_TAI_t* tai) {
if (!plmnId.decodefromoctetstring(tai->pLMNIdentity)) return false;
if (!plmnId.decode(tai->pLMNIdentity)) return false;
if (!tac.decodefromoctetstring(tai->tAC)) return false;
return true;
......
......@@ -59,7 +59,7 @@ void NGSetupRequestMsg::setGlobalRanNodeID(
// TODO: other options for GlobalNgENBId/Global N3IWF ID
GlobalgNBId globalgNBId = {};
PlmnId plmn = {};
plmn.setMccMnc(mcc, mnc);
plmn.set(mcc, mnc);
GNB_ID gnbid = {};
gnbid.setValue(ranNodeId, ran_node_id_size);
globalgNBId.set(plmn, gnbid);
......@@ -92,7 +92,7 @@ void NGSetupRequestMsg::setRanNodeName(const std::string& value) {
ie->criticality = Ngap_Criticality_ignore;
ie->value.present = Ngap_NGSetupRequestIEs__value_PR_RANNodeName;
if (!ranNodeName->encode2RanNodeName(&ie->value.choice.RANNodeName)) {
if (!ranNodeName->encode(ie->value.choice.RANNodeName)) {
Logger::ngap().error("Encode NGAP RANNodeName IE error");
free_wrapper((void**) &ie);
return;
......@@ -123,8 +123,7 @@ void NGSetupRequestMsg::setSupportedTAList(
for (int j = 0; j < list[i].b_plmn_list.size(); j++) {
BroadcastPLMNItem broadcastPlmnItem = {};
PlmnId broadPlmn = {};
broadPlmn.setMccMnc(
list[i].b_plmn_list[j].mcc, list[i].b_plmn_list[j].mnc);
broadPlmn.set(list[i].b_plmn_list[j].mcc, list[i].b_plmn_list[j].mnc);
std::vector<S_NSSAI> snssais;
for (int k = 0; k < list[i].b_plmn_list[j].slice_list.size(); k++) {
......@@ -221,9 +220,9 @@ bool NGSetupRequestMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
ngSetupRequestIEs->protocolIEs.list.array[i]->value.present ==
Ngap_NGSetupRequestIEs__value_PR_RANNodeName) {
ranNodeName = new RanNodeName();
if (!ranNodeName->decodefromRanNodeName(
&ngSetupRequestIEs->protocolIEs.list.array[i]
->value.choice.RANNodeName)) {
if (!ranNodeName->decode(
ngSetupRequestIEs->protocolIEs.list.array[i]
->value.choice.RANNodeName)) {
Logger::ngap().error("Decoded NGAP RanNodeName IE error");
return false;
}
......
......@@ -131,7 +131,7 @@ void NGSetupResponseMsg::setPlmnSupportList(
for (int i = 0; i < list.size(); i++) {
PLMNSupportItem plmnSupportItem = {};
PlmnId plmn = {};
plmn.setMccMnc(list[i].mcc, list[i].mnc);
plmn.set(list[i].mcc, list[i].mnc);
Logger::ngap().debug(
"MCC %s, MNC %s", list[i].mcc.c_str(), list[i].mnc.c_str());
......
......@@ -156,7 +156,7 @@ void PagingMsg::setTAIListForPaging(const std::vector<Tai_t>& list) {
TAC tac[list.size()];
for (int i = 0; i < list.size(); i++) {
TAI tai = {};
plmnid[i].setMccMnc(list[i].mcc, list[i].mnc);
plmnid[i].set(list[i].mcc, list[i].mnc);
tac[i].setTac(list[i].tac);
tai.setTAI(plmnid[i], tac[i]);
tailist.push_back(tai);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment