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