Commit 69030eef authored by Tien Thinh NGUYEN's avatar Tien Thinh NGUYEN

Code refactoring for DownlinkNasTransport and its related IEs

parent d1bb9b5f
......@@ -49,11 +49,17 @@ bool AMFSetID::set(const uint16_t& id) {
id_ = id;
return true;
}
//------------------------------------------------------------------------------
void AMFSetID::get(std::string& id) {
id = std::to_string(id_);
}
//------------------------------------------------------------------------------
void AMFSetID::get(uint16_t& id) {
id = id_;
}
//------------------------------------------------------------------------------
bool AMFSetID::encode(Ngap_AMFSetID_t& amf_set_id) const {
amf_set_id.size = 2;
......
......@@ -38,6 +38,7 @@ class AMFSetID {
bool set(const std::string&);
bool set(const uint16_t&);
void get(std::string&);
void get(uint16_t&);
bool encode(Ngap_AMFSetID_t&) const;
bool decode(const Ngap_AMFSetID_t&);
......
......@@ -34,35 +34,42 @@ AllowedNSSAI::AllowedNSSAI() {}
AllowedNSSAI::~AllowedNSSAI() {}
//------------------------------------------------------------------------------
void AllowedNSSAI::setAllowedNSSAI(const std::vector<S_NSSAI>& list) {
allowedSnssaiList = list;
void AllowedNSSAI::set(const std::vector<S_NSSAI>& list) {
// Get maximum 8 items
uint8_t number_items = (list.size() > kAllowedSNSSAIMaxItems) ?
kAllowedSNSSAIMaxItems :
list.size();
list_.insert(list_.begin(), list.begin(), list.begin() + number_items);
}
//------------------------------------------------------------------------------
void AllowedNSSAI::getAllowedNSSAI(std::vector<S_NSSAI>& list) {
list = allowedSnssaiList;
void AllowedNSSAI::get(std::vector<S_NSSAI>& list) {
list = list_;
}
//------------------------------------------------------------------------------
bool AllowedNSSAI::encode2AllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList) {
for (std::vector<S_NSSAI>::iterator it = std::begin(allowedSnssaiList);
it < std::end(allowedSnssaiList); ++it) {
Ngap_AllowedNSSAI_Item_t* allowednssaiitem =
bool AllowedNSSAI::encode(Ngap_AllowedNSSAI_t* list) {
for (std::vector<S_NSSAI>::iterator it = std::begin(list_);
it < std::end(list_); ++it) {
Ngap_AllowedNSSAI_Item_t* item =
(Ngap_AllowedNSSAI_Item_t*) calloc(1, sizeof(Ngap_AllowedNSSAI_Item_t));
if (!allowednssaiitem) return false;
if (!it->encode(&allowednssaiitem->s_NSSAI)) return false;
if (ASN_SEQUENCE_ADD(&allowedNssaiList->list, allowednssaiitem) != 0)
return false;
if (!item) return false;
if (!it->encode(&item->s_NSSAI)) return false;
if (ASN_SEQUENCE_ADD(&list->list, item) != 0) return false;
}
return true;
}
//------------------------------------------------------------------------------
bool AllowedNSSAI::decodefromAllowedNSSAI(
Ngap_AllowedNSSAI_t* allowedNssaiList) {
for (int i = 0; i < allowedNssaiList->list.count; i++) {
bool AllowedNSSAI::decode(Ngap_AllowedNSSAI_t* list) {
list_.clear();
// Get maximum 8 items
uint8_t number_items = (list->list.count > kAllowedSNSSAIMaxItems) ?
kAllowedSNSSAIMaxItems :
list->list.count;
for (int i = 0; i < number_items; i++) {
S_NSSAI snssai = {};
if (!snssai.decode(&allowedNssaiList->list.array[i]->s_NSSAI)) return false;
allowedSnssaiList.push_back(snssai);
if (!snssai.decode(&list->list.array[i]->s_NSSAI)) return false;
list_.push_back(snssai);
}
return true;
}
......
......@@ -24,6 +24,7 @@
#include "S-NSSAI.hpp"
#include <vector>
constexpr uint8_t kAllowedSNSSAIMaxItems = 8;
extern "C" {
#include "Ngap_AllowedNSSAI.h"
......@@ -36,14 +37,14 @@ class AllowedNSSAI {
AllowedNSSAI();
virtual ~AllowedNSSAI();
void setAllowedNSSAI(const std::vector<S_NSSAI>& list);
void getAllowedNSSAI(std::vector<S_NSSAI>& list);
void set(const std::vector<S_NSSAI>& list);
void get(std::vector<S_NSSAI>& list);
bool encode2AllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList);
bool decodefromAllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList);
bool encode(Ngap_AllowedNSSAI_t* allowedNssaiList);
bool decode(Ngap_AllowedNSSAI_t* allowedNssaiList);
private:
std::vector<S_NSSAI> allowedSnssaiList;
std::vector<S_NSSAI> list_;
};
} // namespace ngap
#endif
......@@ -28,31 +28,32 @@ namespace ngap {
//------------------------------------------------------------------------------
IndexToRFSP::IndexToRFSP() {
indexToRFSP = 0;
index_ = 0;
}
//------------------------------------------------------------------------------
IndexToRFSP::IndexToRFSP(const uint32_t& index) : index_(index) {}
//------------------------------------------------------------------------------
IndexToRFSP::~IndexToRFSP() {}
//------------------------------------------------------------------------------
void IndexToRFSP::setIndexToRFSP(uint8_t m_indexToRFSP) {
indexToRFSP = m_indexToRFSP;
void IndexToRFSP::set(const uint32_t& index) {
index_ = index;
}
//------------------------------------------------------------------------------
uint8_t IndexToRFSP::getIndexToRFSP() {
return indexToRFSP;
uint32_t IndexToRFSP::get() const {
return index_;
}
//------------------------------------------------------------------------------
bool IndexToRFSP::encode2IndexToRFSP(Ngap_IndexToRFSP_t& indextorfsp) {
indextorfsp = indexToRFSP;
bool IndexToRFSP::encode(Ngap_IndexToRFSP_t& index) {
index = index_;
return true;
}
//------------------------------------------------------------------------------
bool IndexToRFSP::decodefromIndexToRFSP(Ngap_IndexToRFSP_t& indextorfsp) {
indexToRFSP = indextorfsp;
bool IndexToRFSP::decode(Ngap_IndexToRFSP_t& index) {
index_ = index;
return true;
}
} // namespace ngap
......@@ -31,16 +31,17 @@ namespace ngap {
class IndexToRFSP {
public:
IndexToRFSP();
IndexToRFSP(const uint32_t&);
virtual ~IndexToRFSP();
void setIndexToRFSP(uint8_t);
uint8_t getIndexToRFSP();
void set(const uint32_t&);
uint32_t get() const;
bool encode2IndexToRFSP(Ngap_IndexToRFSP_t&);
bool decodefromIndexToRFSP(Ngap_IndexToRFSP_t&);
bool encode(Ngap_IndexToRFSP_t&);
bool decode(Ngap_IndexToRFSP_t&);
private:
uint8_t indexToRFSP;
uint32_t index_;
};
} // namespace ngap
......
......@@ -31,17 +31,17 @@ MobilityRestrictionList::MobilityRestrictionList() {}
MobilityRestrictionList::~MobilityRestrictionList() {}
//------------------------------------------------------------------------------
void MobilityRestrictionList::setMobilityRestrictionList(const PlmnId& sPLMN) {
void MobilityRestrictionList::setPLMN(const PlmnId& sPLMN) {
servingPLMN = sPLMN;
}
//------------------------------------------------------------------------------
void MobilityRestrictionList::getMobilityRestrictionList(PlmnId& sPLMN) {
void MobilityRestrictionList::getPLMN(PlmnId& sPLMN) {
sPLMN = servingPLMN;
}
//------------------------------------------------------------------------------
bool MobilityRestrictionList::encodeMobilityRestrictionList(
bool MobilityRestrictionList::encode(
Ngap_MobilityRestrictionList_t* mobilityrestrictionlist) {
if (!servingPLMN.encode(mobilityrestrictionlist->servingPLMN)) {
return false;
......
......@@ -20,7 +20,7 @@
*/
#ifndef _MOBILITY_RESTRICTION_LIST_H_
#define _MOBILITYRESTRICTION_LIST_H_
#define _MOBILITY_RESTRICTION_LIST_H_
#include "PlmnId.hpp"
extern "C" {
......@@ -32,11 +32,11 @@ class MobilityRestrictionList {
MobilityRestrictionList();
virtual ~MobilityRestrictionList();
void setMobilityRestrictionList(const PlmnId& sPlmn);
void getMobilityRestrictionList(PlmnId& sPlmn);
void setPLMN(const PlmnId& sPlmn);
void getPLMN(PlmnId& sPlmn);
bool encodeMobilityRestrictionList(
Ngap_MobilityRestrictionList_t* mobilityrestrictionlist);
bool encode(Ngap_MobilityRestrictionList_t* mobilityrestrictionlist);
// TODO: Decode
private:
PlmnId servingPLMN; // Mandatory
......
......@@ -21,40 +21,38 @@
#include "RANPagingPriority.hpp"
#include <iostream>
using namespace std;
namespace ngap {
//------------------------------------------------------------------------------
RANPagingPriority::RANPagingPriority() {
ranPagingPriority = 0;
ran_paging_priority_ = 0;
}
//------------------------------------------------------------------------------
RANPagingPriority::~RANPagingPriority() {}
//------------------------------------------------------------------------------
void RANPagingPriority::setRANPagingPriority(uint8_t m_ranPagingPriority) {
ranPagingPriority = m_ranPagingPriority;
bool RANPagingPriority::set(const uint32_t& ran_paging_priority) {
if (ran_paging_priority > kRANPagingPriorityMaxValue) return false;
ran_paging_priority_ = ran_paging_priority;
return true;
}
//------------------------------------------------------------------------------
uint8_t RANPagingPriority::getRANPagingPriority() {
return ranPagingPriority;
uint32_t RANPagingPriority::get() {
return ran_paging_priority_;
}
//------------------------------------------------------------------------------
bool RANPagingPriority::encode2RANPagingPriority(
Ngap_RANPagingPriority_t& ranpagingpriority) {
ranpagingpriority = ranPagingPriority;
bool RANPagingPriority::encode(Ngap_RANPagingPriority_t& ran_paging_priority) {
ran_paging_priority = ran_paging_priority_;
return true;
}
//------------------------------------------------------------------------------
bool RANPagingPriority::decodefromRANPagingPriority(
Ngap_RANPagingPriority_t& ranpagingpriority) {
ranPagingPriority = ranpagingpriority;
bool RANPagingPriority::decode(Ngap_RANPagingPriority_t& ran_paging_priority) {
if (ran_paging_priority > kRANPagingPriorityMaxValue) return false;
ran_paging_priority_ = ran_paging_priority;
return true;
}
} // namespace ngap
......@@ -19,8 +19,12 @@
* contact@openairinterface.org
*/
#ifndef _RANPAGINGPRIORITY_H_
#define _RANPAGINGPRIORITY_H_
#ifndef _RAN_PAGING_PRIORITY_H_
#define _RAN_PAGING_PRIORITY_H_
#include <cstdint>
constexpr uint32_t kRANPagingPriorityMaxValue = 256;
extern "C" {
#include "Ngap_RANPagingPriority.h"
......@@ -33,14 +37,14 @@ class RANPagingPriority {
RANPagingPriority();
virtual ~RANPagingPriority();
void setRANPagingPriority(uint8_t);
uint8_t getRANPagingPriority();
bool set(const uint32_t&);
uint32_t get();
bool encode2RANPagingPriority(Ngap_RANPagingPriority_t&);
bool decodefromRANPagingPriority(Ngap_RANPagingPriority_t&);
bool encode(Ngap_RANPagingPriority_t&);
bool decode(Ngap_RANPagingPriority_t&);
private:
uint8_t ranPagingPriority;
uint32_t ran_paging_priority_;
};
} // namespace ngap
......
......@@ -21,85 +21,72 @@
#include "UEAggregateMaxBitRate.hpp"
#include <iostream>
using namespace std;
namespace ngap {
//------------------------------------------------------------------------------
UEAggregateMaxBitRate::UEAggregateMaxBitRate() {
ueaggregatemaxbitratedl = 0;
ueaggregatemaxbitrateul = 0;
dl_ = 0;
ul_ = 0;
}
//------------------------------------------------------------------------------
UEAggregateMaxBitRate::~UEAggregateMaxBitRate() {}
//------------------------------------------------------------------------------
void UEAggregateMaxBitRate::setUEAggregateMaxBitRate(
long bit_rate_downlink, long bit_rate_uplink) {
ueaggregatemaxbitratedl = bit_rate_downlink;
ueaggregatemaxbitrateul = bit_rate_uplink;
void UEAggregateMaxBitRate::set(const uint64_t& dl, const uint64_t& ul) {
dl_ = dl;
ul_ = ul;
}
//------------------------------------------------------------------------------
bool UEAggregateMaxBitRate::getUEAggregateMaxBitRate(
long& bit_rate_downlink, long& bit_rate_uplink) {
bit_rate_downlink = ueaggregatemaxbitratedl;
bit_rate_uplink = ueaggregatemaxbitrateul;
bool UEAggregateMaxBitRate::get(uint64_t& dl, uint64_t& ul) const {
dl = dl_;
ul = ul_;
return true;
}
//------------------------------------------------------------------------------
bool UEAggregateMaxBitRate::encode2UEAggregateMaxBitRate(
Ngap_UEAggregateMaximumBitRate_t& ueAggregateMaxBitRate) {
ueAggregateMaxBitRate.uEAggregateMaximumBitRateDL.size = 4;
ueAggregateMaxBitRate.uEAggregateMaximumBitRateDL.buf = (uint8_t*) calloc(
1, ueAggregateMaxBitRate.uEAggregateMaximumBitRateDL.size);
if (!ueAggregateMaxBitRate.uEAggregateMaximumBitRateDL.buf) return false;
for (int i = 0; i < ueAggregateMaxBitRate.uEAggregateMaximumBitRateDL.size;
i++) {
ueAggregateMaxBitRate.uEAggregateMaximumBitRateDL.buf[i] =
(ueaggregatemaxbitratedl & (0xff000000 >> i * 8)) >>
((ueAggregateMaxBitRate.uEAggregateMaximumBitRateDL.size - i - 1) * 8);
bool UEAggregateMaxBitRate::encode(Ngap_UEAggregateMaximumBitRate_t& bit_rate) {
bit_rate.uEAggregateMaximumBitRateDL.size = 4; // TODO: 6 bytes
bit_rate.uEAggregateMaximumBitRateDL.buf =
(uint8_t*) calloc(1, bit_rate.uEAggregateMaximumBitRateDL.size);
if (!bit_rate.uEAggregateMaximumBitRateDL.buf) return false;
for (int i = 0; i < bit_rate.uEAggregateMaximumBitRateDL.size; i++) {
bit_rate.uEAggregateMaximumBitRateDL.buf[i] =
(dl_ & (0xff000000 >> i * 8)) >>
((bit_rate.uEAggregateMaximumBitRateDL.size - i - 1) * 8);
}
ueAggregateMaxBitRate.uEAggregateMaximumBitRateUL.size = 4;
ueAggregateMaxBitRate.uEAggregateMaximumBitRateUL.buf = (uint8_t*) calloc(
1, ueAggregateMaxBitRate.uEAggregateMaximumBitRateUL.size);
if (!ueAggregateMaxBitRate.uEAggregateMaximumBitRateUL.buf) return false;
bit_rate.uEAggregateMaximumBitRateUL.size = 4; // TODO: 6 bytes
bit_rate.uEAggregateMaximumBitRateUL.buf =
(uint8_t*) calloc(1, bit_rate.uEAggregateMaximumBitRateUL.size);
if (!bit_rate.uEAggregateMaximumBitRateUL.buf) return false;
for (int i = 0; i < ueAggregateMaxBitRate.uEAggregateMaximumBitRateUL.size;
i++) {
ueAggregateMaxBitRate.uEAggregateMaximumBitRateUL.buf[i] =
(ueaggregatemaxbitrateul & (0xff000000 >> i * 8)) >>
((ueAggregateMaxBitRate.uEAggregateMaximumBitRateUL.size - i - 1) * 8);
for (int i = 0; i < bit_rate.uEAggregateMaximumBitRateUL.size; i++) {
bit_rate.uEAggregateMaximumBitRateUL.buf[i] =
(ul_ & (0xff000000 >> i * 8)) >>
((bit_rate.uEAggregateMaximumBitRateUL.size - i - 1) * 8);
}
return true;
}
//------------------------------------------------------------------------------
bool UEAggregateMaxBitRate::decodefromUEAggregateMaxBitRate(
Ngap_UEAggregateMaximumBitRate_t& ueAggregateMaxBitRate) {
if (!ueAggregateMaxBitRate.uEAggregateMaximumBitRateDL.buf) return false;
if (!ueAggregateMaxBitRate.uEAggregateMaximumBitRateUL.buf) return false;
ueaggregatemaxbitratedl = 0;
ueaggregatemaxbitrateul = 0;
for (int i = 0; i < ueAggregateMaxBitRate.uEAggregateMaximumBitRateDL.size;
i++) {
ueaggregatemaxbitratedl = ueaggregatemaxbitratedl << 8;
ueaggregatemaxbitratedl |=
ueAggregateMaxBitRate.uEAggregateMaximumBitRateDL.buf[i];
bool UEAggregateMaxBitRate::decode(Ngap_UEAggregateMaximumBitRate_t& bit_rate) {
if (!bit_rate.uEAggregateMaximumBitRateDL.buf) return false;
if (!bit_rate.uEAggregateMaximumBitRateUL.buf) return false;
dl_ = 0;
ul_ = 0;
for (int i = 0; i < bit_rate.uEAggregateMaximumBitRateDL.size; i++) {
dl_ = dl_ << 8;
dl_ |= bit_rate.uEAggregateMaximumBitRateDL.buf[i];
}
for (int i = 0; i < ueAggregateMaxBitRate.uEAggregateMaximumBitRateUL.size;
i++) {
ueaggregatemaxbitrateul = ueaggregatemaxbitrateul << 8;
ueaggregatemaxbitrateul |=
ueAggregateMaxBitRate.uEAggregateMaximumBitRateUL.buf[i];
for (int i = 0; i < bit_rate.uEAggregateMaximumBitRateUL.size; i++) {
ul_ = ul_ << 8;
ul_ |= bit_rate.uEAggregateMaximumBitRateUL.buf[i];
}
return true;
......
......@@ -33,17 +33,15 @@ class UEAggregateMaxBitRate {
UEAggregateMaxBitRate();
virtual ~UEAggregateMaxBitRate();
void setUEAggregateMaxBitRate(long bit_rate_downlink, long bit_rate_uplink);
bool getUEAggregateMaxBitRate(long& bit_rate_downlink, long& bit_rate_uplink);
void set(const uint64_t& dl, const uint64_t& ul);
bool get(uint64_t& dl, uint64_t& ul) const;
bool encode2UEAggregateMaxBitRate(
Ngap_UEAggregateMaximumBitRate_t& ueAggregateMaxBitRate);
bool decodefromUEAggregateMaxBitRate(
Ngap_UEAggregateMaximumBitRate_t& ueAggregateMaxBitRate);
bool encode(Ngap_UEAggregateMaximumBitRate_t& bit_rate);
bool decode(Ngap_UEAggregateMaximumBitRate_t& bit_rate);
private:
long ueaggregatemaxbitratedl;
long ueaggregatemaxbitrateul;
uint64_t dl_;
uint64_t ul_;
};
} // namespace ngap
......
......@@ -21,41 +21,41 @@
#include "UEContextRequest.hpp"
#include <iostream>
using namespace std;
namespace ngap {
//------------------------------------------------------------------------------
UEContextRequest::UEContextRequest() {
uecontextrequest = -1;
ue_context_request_ = -1;
}
//------------------------------------------------------------------------------
UEContextRequest::UEContextRequest(
const e_Ngap_UEContextRequest& ue_context_request)
: ue_context_request_(ue_context_request) {}
//------------------------------------------------------------------------------
UEContextRequest::~UEContextRequest() {}
//------------------------------------------------------------------------------
void UEContextRequest::setUEContextRequest(
e_Ngap_UEContextRequest m_uecontextrequest) {
uecontextrequest = m_uecontextrequest;
void UEContextRequest::set(const e_Ngap_UEContextRequest& ue_context_request) {
ue_context_request_ = ue_context_request;
}
//------------------------------------------------------------------------------
int UEContextRequest::getUEContextRequest() {
return uecontextrequest;
int UEContextRequest::get() const {
return ue_context_request_;
}
//------------------------------------------------------------------------------
bool UEContextRequest::encode2UEContextRequest(
Ngap_UEContextRequest_t& uEContextRequest) {
uEContextRequest = uecontextrequest;
bool UEContextRequest::encode(
Ngap_UEContextRequest_t& ue_context_request) const {
ue_context_request = ue_context_request_;
return true;
}
//------------------------------------------------------------------------------
bool UEContextRequest::decodefromUEContextRequest(
Ngap_UEContextRequest_t& uEContextRequest) {
uecontextrequest = uEContextRequest;
bool UEContextRequest::decode(
const Ngap_UEContextRequest_t& ue_context_request) {
ue_context_request_ = ue_context_request;
return true;
}
} // namespace ngap
......@@ -19,8 +19,8 @@
* contact@openairinterface.org
*/
#ifndef _UECONTEXTREQUEST_H_
#define _UECONTEXTREQUEST_H_
#ifndef _UE_CONTEXT_REQUEST_H_
#define _UE_CONTEXT_REQUEST_H_
extern "C" {
#include "Ngap_UEContextRequest.h"
......@@ -31,16 +31,17 @@ namespace ngap {
class UEContextRequest {
public:
UEContextRequest();
UEContextRequest(const e_Ngap_UEContextRequest& ue_context_request);
virtual ~UEContextRequest();
void setUEContextRequest(e_Ngap_UEContextRequest m_uecontextrequest);
int getUEContextRequest();
void set(const e_Ngap_UEContextRequest& ue_context_request);
int get() const;
bool encode2UEContextRequest(Ngap_UEContextRequest_t& uEContextRequest);
bool decodefromUEContextRequest(Ngap_UEContextRequest_t& uEContextRequest);
bool encode(Ngap_UEContextRequest_t& ue_context_request) const;
bool decode(const Ngap_UEContextRequest_t& ue_context_request);
private:
int uecontextrequest;
int ue_context_request_;
};
} // namespace ngap
......
This diff is collapsed.
......@@ -27,6 +27,10 @@
#include "NAS-PDU.hpp"
#include "RANPagingPriority.hpp"
#include "NgapUEMessage.hpp"
#include "MobilityRestrictionList.hpp"
#include "UEAggregateMaxBitRate.hpp"
#include <optional>
namespace ngap {
......@@ -41,30 +45,32 @@ class DownLinkNasTransportMsg : public NgapUEMessage {
void setRanUeNgapId(const uint32_t& id) override;
bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
void setOldAmfName(const std::string name);
bool getOldAmfName(std::string& name);
void setOldAmf(const std::string& name);
bool getOldAmf(std::string& name);
void setRanPagingPriority(uint8_t pagingPriority); // 1~256
uint8_t getRanPagingPriority();
bool setRanPagingPriority(const uint32_t&); // 1~256
bool getRanPagingPriority(uint32_t&);
void setNasPdu(uint8_t* nas, size_t sizeofnas);
bool getNasPdu(uint8_t*& nas, size_t& sizeofnas);
void setIndex2Rat_Frequency_SelectionPriority(uint8_t value); // 1~256
uint8_t getIndex2Rat_Frequency_SelectionPriority();
void setMobilityRestrictionList(const MobilityRestrictionList&);
bool getMobilityRestrictionList(MobilityRestrictionList&) const;
void setIndex2Rat_FrequencySelectionPriority(const uint32_t& value); // 1~256
bool getIndex2Rat_FrequencySelectionPriority(uint32_t&) const;
private:
Ngap_DownlinkNASTransport_t* downLinkNasTransportIEs;
// AMF_UE_NGAP_ID (Mandatory)
// RAN_UE_NGAP_ID (Mandatory)
AmfName* oldAmfName; // Optional
RANPagingPriority* ranPagingPriority; // Optional
std::optional<AmfName> oldAMF; // Optional
std::optional<RANPagingPriority> ranPagingPriority; // Optional
NAS_PDU nasPdu; // Mandatory
// TODO: Mobility Restriction List (Optional)
IndexToRFSP*
indexToRFSP; // Index to RAT/Frequency Selection Priority (Optional)
// TODO: UE Aggregate Maximum Bit Rate (Optional)
std::optional<MobilityRestrictionList> mobilityRestrictionList; // Optional
std::optional<IndexToRFSP> indexToRFSP; // Optional
std::optional<UEAggregateMaxBitRate> uEAggregateMaxBitRate; // Optional
// TODO: Allowed NSSAI (Optional)
};
......
......@@ -167,8 +167,7 @@ void HandoverRequest::setCause(
//------------------------------------------------------------------------------
void HandoverRequest::setUEAggregateMaximumBitRate(
const long& bitRateDownlink, const long& bitRateUplink) {
ueAggregateMaximumBitRate.setUEAggregateMaxBitRate(
bitRateDownlink, bitRateUplink);
ueAggregateMaximumBitRate.set(bitRateDownlink, bitRateUplink);
Ngap_HandoverRequestIEs_t* ie =
(Ngap_HandoverRequestIEs_t*) calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
......@@ -176,8 +175,7 @@ void HandoverRequest::setUEAggregateMaximumBitRate(
ie->criticality = Ngap_Criticality_reject;
ie->value.present =
Ngap_HandoverRequestIEs__value_PR_UEAggregateMaximumBitRate;
ueAggregateMaximumBitRate.encode2UEAggregateMaxBitRate(
ie->value.choice.UEAggregateMaximumBitRate);
ueAggregateMaximumBitRate.encode(ie->value.choice.UEAggregateMaximumBitRate);
int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
if (ret != 0)
......@@ -342,9 +340,8 @@ void HandoverRequest::setMobilityRestrictionList(const PlmnId& m_plmnId) {
ie->id = Ngap_ProtocolIE_ID_id_MobilityRestrictionList;
ie->criticality = Ngap_Criticality_ignore;
ie->value.present = Ngap_HandoverRequestIEs__value_PR_MobilityRestrictionList;
mobilityRestrictionList->setMobilityRestrictionList(m_plmnId);
mobilityRestrictionList->encodeMobilityRestrictionList(
&(ie->value.choice.MobilityRestrictionList));
mobilityRestrictionList->setPLMN(m_plmnId);
mobilityRestrictionList->encode(&(ie->value.choice.MobilityRestrictionList));
int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
if (ret != 0) Logger::ngap().error("Encode MobilityRestrictionList IE error");
}
......
......@@ -102,7 +102,7 @@ void InitialContextSetupRequestMsg::setRanUeNgapId(
}
//------------------------------------------------------------------------------
void InitialContextSetupRequestMsg::setOldAmfName(const std::string& name) {
void InitialContextSetupRequestMsg::setOldAmf(const std::string& name) {
if (!oldAmfName) oldAmfName = new AmfName();
oldAmfName->setValue(name);
......@@ -126,12 +126,11 @@ void InitialContextSetupRequestMsg::setOldAmfName(const std::string& name) {
//------------------------------------------------------------------------------
void InitialContextSetupRequestMsg::setUEAggregateMaxBitRate(
const long& bit_rate_downlink, const long& bit_rate_uplink) {
const uint64_t& bit_rate_downlink, const uint64_t& bit_rate_uplink) {
if (!uEAggregateMaxBitRate)
uEAggregateMaxBitRate = new UEAggregateMaxBitRate();
uEAggregateMaxBitRate->setUEAggregateMaxBitRate(
bit_rate_downlink, bit_rate_uplink);
uEAggregateMaxBitRate->set(bit_rate_downlink, bit_rate_uplink);
Ngap_InitialContextSetupRequestIEs_t* ie =
(Ngap_InitialContextSetupRequestIEs_t*) calloc(
......@@ -141,8 +140,8 @@ void InitialContextSetupRequestMsg::setUEAggregateMaxBitRate(
ie->value.present =
Ngap_InitialContextSetupRequestIEs__value_PR_UEAggregateMaximumBitRate;
int ret = uEAggregateMaxBitRate->encode2UEAggregateMaxBitRate(
ie->value.choice.UEAggregateMaximumBitRate);
int ret =
uEAggregateMaxBitRate->encode(ie->value.choice.UEAggregateMaximumBitRate);
if (!ret) {
Logger::ngap().error("Encode UEAggregateMaxBitRate IE error!");
free_wrapper((void**) &ie);
......@@ -298,7 +297,7 @@ void InitialContextSetupRequestMsg::setAllowedNssai(
snssai.setSd(sd);
snssaiList.push_back(snssai);
}
allowedNssai.setAllowedNSSAI(snssaiList);
allowedNssai.set(snssaiList);
Ngap_InitialContextSetupRequestIEs_t* ie =
(Ngap_InitialContextSetupRequestIEs_t*) calloc(
......@@ -307,7 +306,7 @@ void InitialContextSetupRequestMsg::setAllowedNssai(
ie->criticality = Ngap_Criticality_reject;
ie->value.present = Ngap_InitialContextSetupRequestIEs__value_PR_AllowedNSSAI;
int ret = allowedNssai.encode2AllowedNSSAI(&ie->value.choice.AllowedNSSAI);
int ret = allowedNssai.encode(&ie->value.choice.AllowedNSSAI);
if (!ret) {
Logger::ngap().error("Encode AllowedNSSAI IE error!");
free_wrapper((void**) &ie);
......@@ -505,7 +504,7 @@ bool InitialContextSetupRequestMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
->value.present ==
Ngap_InitialContextSetupRequestIEs__value_PR_UEAggregateMaximumBitRate) {
uEAggregateMaxBitRate = new UEAggregateMaxBitRate();
if (!uEAggregateMaxBitRate->decodefromUEAggregateMaxBitRate(
if (!uEAggregateMaxBitRate->decode(
initialContextSetupRequestIEs->protocolIEs.list.array[i]
->value.choice.UEAggregateMaximumBitRate)) {
Logger::ngap().error(
......@@ -585,7 +584,7 @@ bool InitialContextSetupRequestMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
initialContextSetupRequestIEs->protocolIEs.list.array[i]
->value.present ==
Ngap_InitialContextSetupRequestIEs__value_PR_AllowedNSSAI) {
if (!allowedNssai.decodefromAllowedNSSAI(
if (!allowedNssai.decode(
&initialContextSetupRequestIEs->protocolIEs.list.array[i]
->value.choice.AllowedNSSAI)) {
Logger::ngap().error("Decoded NGAP AllowedNSSAI IE error");
......@@ -661,7 +660,7 @@ bool InitialContextSetupRequestMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
}
//------------------------------------------------------------------------------
bool InitialContextSetupRequestMsg::getOldAmfName(std::string& name) {
bool InitialContextSetupRequestMsg::getOldAmf(std::string& name) {
if (!oldAmfName) return false;
oldAmfName->getValue(name);
return true;
......@@ -669,10 +668,9 @@ bool InitialContextSetupRequestMsg::getOldAmfName(std::string& name) {
//------------------------------------------------------------------------------
bool InitialContextSetupRequestMsg::getUEAggregateMaxBitRate(
long& bit_rate_downlink, long& bit_rate_uplink) {
uint64_t& bit_rate_downlink, uint64_t& bit_rate_uplink) {
if (!uEAggregateMaxBitRate) return false;
return uEAggregateMaxBitRate->getUEAggregateMaxBitRate(
bit_rate_downlink, bit_rate_uplink);
return uEAggregateMaxBitRate->get(bit_rate_downlink, bit_rate_uplink);
}
//------------------------------------------------------------------------------
......@@ -756,7 +754,7 @@ bool InitialContextSetupRequestMsg::getPduSessionResourceSetupRequestList(
bool InitialContextSetupRequestMsg::getAllowedNssai(
std::vector<S_Nssai>& list) {
std::vector<S_NSSAI> snssaiList;
allowedNssai.getAllowedNSSAI(snssaiList);
allowedNssai.get(snssaiList);
for (std::vector<S_NSSAI>::iterator it = std::begin(snssaiList);
it < std::end(snssaiList); ++it) {
S_Nssai s_nssai = {};
......
......@@ -50,12 +50,13 @@ class InitialContextSetupRequestMsg : public NgapUEMessage {
void setRanUeNgapId(const uint32_t& id) override;
bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
void setOldAmfName(const std::string& name);
bool getOldAmfName(std::string& name);
void setOldAmf(const std::string& name);
bool getOldAmf(std::string& name);
void setUEAggregateMaxBitRate(
const long& bit_rate_downlink, const long& bit_rate_uplink);
bool getUEAggregateMaxBitRate(long& bit_rate_downlink, long& bit_rate_uplink);
const uint64_t& bit_rate_downlink, const uint64_t& bit_rate_uplink);
bool getUEAggregateMaxBitRate(
uint64_t& bit_rate_downlink, uint64_t& bit_rate_uplink);
void setCoreNetworkAssistanceInfo(
const uint16_t& ueIdentityIndexValue /*10bits*/,
......
......@@ -31,18 +31,17 @@ namespace ngap {
//------------------------------------------------------------------------------
InitialUEMessageMsg::InitialUEMessageMsg() : NgapMessage() {
initialUEMessageIEs = nullptr;
uEContextRequest = nullptr;
fivegSTmsi = nullptr;
uEContextRequest = std::nullopt;
fivegSTmsi = std::nullopt;
amfSetId = std::nullopt;
allowedNssai = std::nullopt;
NgapMessage::setMessageType(NgapMessageType::NG_SETUP_RESPONSE);
initialize();
}
//------------------------------------------------------------------------------
InitialUEMessageMsg::~InitialUEMessageMsg() {
if (uEContextRequest) delete uEContextRequest;
if (fivegSTmsi) delete fivegSTmsi;
}
InitialUEMessageMsg::~InitialUEMessageMsg() {}
//------------------------------------------------------------------------------
void InitialUEMessageMsg::initialize() {
......@@ -148,10 +147,8 @@ void InitialUEMessageMsg::setRRCEstablishmentCause(
//------------------------------------------------------------------------------
void InitialUEMessageMsg::setUeContextRequest(
const e_Ngap_UEContextRequest& ueCtxReq) {
if (!uEContextRequest) uEContextRequest = new UEContextRequest();
uEContextRequest->setUEContextRequest(ueCtxReq);
const e_Ngap_UEContextRequest& ue_ctx_req) {
uEContextRequest = std::make_optional<UEContextRequest>(ue_ctx_req);
Ngap_InitialUEMessage_IEs_t* ie = (Ngap_InitialUEMessage_IEs_t*) calloc(
1, sizeof(Ngap_InitialUEMessage_IEs_t));
......@@ -159,8 +156,7 @@ void InitialUEMessageMsg::setUeContextRequest(
ie->criticality = Ngap_Criticality_ignore;
ie->value.present = Ngap_InitialUEMessage_IEs__value_PR_UEContextRequest;
int ret = uEContextRequest->encode2UEContextRequest(
ie->value.choice.UEContextRequest);
int ret = uEContextRequest.value().encode(ie->value.choice.UEContextRequest);
if (!ret) {
Logger::ngap().error("Encode UEContextRequest IE error");
free_wrapper((void**) &ie);
......@@ -171,6 +167,28 @@ void InitialUEMessageMsg::setUeContextRequest(
if (ret != 0) Logger::ngap().error("Encode UEContextRequest IE error");
}
//------------------------------------------------------------------------------
bool InitialUEMessageMsg::getAMFSetID(uint16_t& amf_set_id) {
if (!amfSetId.has_value()) return false;
amfSetId.value().get(amf_set_id);
return true;
}
//------------------------------------------------------------------------------
bool InitialUEMessageMsg::getAMFSetID(std::string& amf_set_id) {
if (!amfSetId.has_value()) return false;
amfSetId.value().get(amf_set_id);
return true;
}
//------------------------------------------------------------------------------
bool InitialUEMessageMsg::setAMFSetID(const uint16_t& amf_set_id) {
AMFSetID tmp = {};
if (!tmp.set(amf_set_id)) return false;
amfSetId = std::optional<AMFSetID>(tmp);
return true;
}
//------------------------------------------------------------------------------
bool InitialUEMessageMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
ngapPdu = ngapMsgPdu;
......@@ -267,17 +285,18 @@ bool InitialUEMessageMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
Ngap_Criticality_ignore &&
initialUEMessageIEs->protocolIEs.list.array[i]->value.present ==
Ngap_InitialUEMessage_IEs__value_PR_UEContextRequest) {
uEContextRequest = new UEContextRequest();
if (!uEContextRequest->decodefromUEContextRequest(
initialUEMessageIEs->protocolIEs.list.array[i]
UEContextRequest tmp = {};
if (!tmp.decode(initialUEMessageIEs->protocolIEs.list.array[i]
->value.choice.UEContextRequest)) {
Logger::ngap().error("Decoded NGAP UEContextRequest IE error");
return false;
}
uEContextRequest = std::optional<UEContextRequest>(tmp);
} else {
Logger::ngap().error("Decoded NGAP UEContextRequest IE error");
return false;
}
} break;
case Ngap_ProtocolIE_ID_id_FiveG_S_TMSI: {
......@@ -285,16 +304,30 @@ bool InitialUEMessageMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
Ngap_Criticality_reject &&
initialUEMessageIEs->protocolIEs.list.array[i]->value.present ==
Ngap_InitialUEMessage_IEs__value_PR_FiveG_S_TMSI) {
fivegSTmsi = new FiveGSTmsi();
if (!fivegSTmsi->decodeFromPdu(
initialUEMessageIEs->protocolIEs.list.array[i]
FiveGSTmsi tmp = {};
if (!tmp.decodeFromPdu(initialUEMessageIEs->protocolIEs.list.array[i]
->value.choice.FiveG_S_TMSI)) {
Logger::ngap().error("Decoded NGAP FiveG_S_TMSI IE error");
return false;
}
fivegSTmsi = std::optional<FiveGSTmsi>(tmp);
}
} break;
case Ngap_ProtocolIE_ID_id_AMFSetID: {
if (initialUEMessageIEs->protocolIEs.list.array[i]->criticality ==
Ngap_Criticality_ignore &&
initialUEMessageIEs->protocolIEs.list.array[i]->value.present ==
Ngap_InitialUEMessage_IEs__value_PR_AMFSetID) {
AMFSetID tmp = {};
if (!tmp.decode(initialUEMessageIEs->protocolIEs.list.array[i]
->value.choice.AMFSetID)) {
Logger::ngap().error("Decoded NGAP AMF Set ID IE error");
return false;
}
amfSetId = std::optional<AMFSetID>(tmp);
}
} break;
default: {
Logger::ngap().warn(
"Not decoded IE %d",
......@@ -342,9 +375,9 @@ int InitialUEMessageMsg::getRRCEstablishmentCause() {
}
//------------------------------------------------------------------------------
int InitialUEMessageMsg::getUeContextRequest() {
if (uEContextRequest) {
return uEContextRequest->getUEContextRequest();
int InitialUEMessageMsg::getUeContextRequest() const {
if (uEContextRequest.has_value()) {
return uEContextRequest.value().get();
} else {
return -1;
}
......@@ -352,8 +385,8 @@ int InitialUEMessageMsg::getUeContextRequest() {
//------------------------------------------------------------------------------
bool InitialUEMessageMsg::get5GS_TMSI(std::string& _5GsTmsi) {
if (fivegSTmsi) {
fivegSTmsi->getTmsi(_5GsTmsi);
if (fivegSTmsi.has_value()) {
fivegSTmsi.value().getTmsi(_5GsTmsi);
return true;
} else
return false;
......@@ -362,11 +395,23 @@ bool InitialUEMessageMsg::get5GS_TMSI(std::string& _5GsTmsi) {
//------------------------------------------------------------------------------
bool InitialUEMessageMsg::get5GS_TMSI(
std ::string& setid, std ::string& pointer, std ::string& tmsi) {
if (fivegSTmsi) {
fivegSTmsi->get(setid, pointer, tmsi);
if (fivegSTmsi.has_value()) {
fivegSTmsi.value().get(setid, pointer, tmsi);
return true;
} else
return false;
}
//------------------------------------------------------------------------------
void InitialUEMessageMsg::setAllowedNssai(const AllowedNSSAI& allowed_nssai) {
allowedNssai = std::make_optional<AllowedNSSAI>(allowed_nssai);
}
//------------------------------------------------------------------------------
bool InitialUEMessageMsg::getAllowedNssai(AllowedNSSAI& allowed_nssai) const {
if (!allowedNssai.has_value()) return false;
allowed_nssai = allowedNssai.value();
return true;
}
} // namespace ngap
......@@ -22,13 +22,16 @@
#ifndef _INITIAL_UE_MESSAGE_H_
#define _INITIAL_UE_MESSAGE_H_
#include "AllowedNssai.hpp"
#include "FiveGSTmsi.hpp"
#include "NAS-PDU.hpp"
#include "NgapIEsStruct.hpp"
#include "NgapMessage.hpp"
#include "RRCEstablishmentCause.hpp"
#include "UEContextRequest.hpp"
#include "UserLocationInformation.hpp"
#include "NgapMessage.hpp"
#include <optional>
namespace ngap {
......@@ -59,8 +62,15 @@ class InitialUEMessageMsg : public NgapMessage {
bool get5GS_TMSI(
std ::string& setid, std ::string& pointer, std ::string& tmsi);
bool getAMFSetID(uint16_t&);
bool getAMFSetID(std::string&);
bool setAMFSetID(const uint16_t&);
void setUeContextRequest(const e_Ngap_UEContextRequest& ueCtxReq);
int getUeContextRequest();
int getUeContextRequest() const;
void setAllowedNssai(const AllowedNSSAI& allowed_nssai);
bool getAllowedNssai(AllowedNSSAI& allowed_nssai) const;
private:
Ngap_InitialUEMessage_t* initialUEMessageIEs;
......@@ -69,10 +79,10 @@ class InitialUEMessageMsg : public NgapMessage {
NAS_PDU nasPdu; // Mandatory
UserLocationInformation userLocationInformation; // Mandatory
RRCEstablishmentCause rRCEstablishmentCause; // Mandatory
FiveGSTmsi* fivegSTmsi; // 5G-S-TMSI (Optional)
// TODO: AMF Set ID (Optional)
UEContextRequest* uEContextRequest; // Optional
// TODO: Allowed NSSAI (Optional)
std::optional<FiveGSTmsi> fivegSTmsi; // 5G-S-TMSI (Optional)
std::optional<AMFSetID> amfSetId; // Optional
std::optional<UEContextRequest> uEContextRequest; // Optional
std::optional<AllowedNSSAI> allowedNssai; // Optional
// TODO: Source to Target AMF Information Reroute (Optional)
};
......
......@@ -103,7 +103,7 @@ void PduSessionResourceModifyRequestMsg::setRanPagingPriority(
const uint8_t& priority) {
if (!ranPagingPriority) ranPagingPriority = new RANPagingPriority();
ranPagingPriority->setRANPagingPriority(priority);
ranPagingPriority->set(priority);
Ngap_PDUSessionResourceModifyRequestIEs_t* ie =
(Ngap_PDUSessionResourceModifyRequestIEs_t*) calloc(
......@@ -113,8 +113,7 @@ void PduSessionResourceModifyRequestMsg::setRanPagingPriority(
ie->value.present =
Ngap_PDUSessionResourceModifyRequestIEs__value_PR_RANPagingPriority;
int ret = ranPagingPriority->encode2RANPagingPriority(
ie->value.choice.RANPagingPriority);
int ret = ranPagingPriority->encode(ie->value.choice.RANPagingPriority);
if (!ret) {
Logger::ngap().error("Encode NGAP RANPagingPriority IE error");
free_wrapper((void**) &ie);
......@@ -129,7 +128,7 @@ void PduSessionResourceModifyRequestMsg::setRanPagingPriority(
//------------------------------------------------------------------------------
int PduSessionResourceModifyRequestMsg::getRanPagingPriority() {
if (!ranPagingPriority) return -1;
return ranPagingPriority->getRANPagingPriority();
return ranPagingPriority->get();
}
//------------------------------------------------------------------------------
......@@ -289,7 +288,7 @@ bool PduSessionResourceModifyRequestMsg::decodeFromPdu(
->value.present ==
Ngap_PDUSessionResourceModifyRequestIEs__value_PR_RANPagingPriority) {
ranPagingPriority = new RANPagingPriority();
if (!ranPagingPriority->decodefromRANPagingPriority(
if (!ranPagingPriority->decode(
pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
->value.choice.RANPagingPriority)) {
Logger::ngap().error("Decoded NGAP RANPagingPriority IE error");
......
......@@ -106,7 +106,7 @@ void PduSessionResourceReleaseCommandMsg::setRanPagingPriority(
const uint8_t& priority) {
if (!ranPagingPriority) ranPagingPriority = new RANPagingPriority();
ranPagingPriority->setRANPagingPriority(priority);
ranPagingPriority->set(priority);
Ngap_PDUSessionResourceReleaseCommandIEs_t* ie =
(Ngap_PDUSessionResourceReleaseCommandIEs_t*) calloc(
......@@ -116,8 +116,7 @@ void PduSessionResourceReleaseCommandMsg::setRanPagingPriority(
ie->value.present =
Ngap_PDUSessionResourceReleaseCommandIEs__value_PR_RANPagingPriority;
int ret = ranPagingPriority->encode2RANPagingPriority(
ie->value.choice.RANPagingPriority);
int ret = ranPagingPriority->encode(ie->value.choice.RANPagingPriority);
if (!ret) {
Logger::nas_mm().warn("Encode RANPagingPriority IE error");
free_wrapper((void**) &ie);
......@@ -132,7 +131,7 @@ void PduSessionResourceReleaseCommandMsg::setRanPagingPriority(
//------------------------------------------------------------------------------
int PduSessionResourceReleaseCommandMsg::getRanPagingPriority() {
if (!ranPagingPriority) return -1;
return ranPagingPriority->getRANPagingPriority();
return ranPagingPriority->get();
}
//------------------------------------------------------------------------------
......@@ -308,7 +307,7 @@ bool PduSessionResourceReleaseCommandMsg::decodeFromPdu(
->value.present ==
Ngap_PDUSessionResourceReleaseCommandIEs__value_PR_RANPagingPriority) {
ranPagingPriority = new RANPagingPriority();
if (!ranPagingPriority->decodefromRANPagingPriority(
if (!ranPagingPriority->decode(
pduSessionResourceReleaseCommandIEs->protocolIEs.list
.array[i]
->value.choice.RANPagingPriority)) {
......
......@@ -56,8 +56,7 @@ void PduSessionResourceSetupRequestMsg::setUEAggregateMaxBitRate(
if (!uEAggregateMaxBitRate)
uEAggregateMaxBitRate = new UEAggregateMaxBitRate();
uEAggregateMaxBitRate->setUEAggregateMaxBitRate(
bit_rate_downlink, bit_rate_uplink);
uEAggregateMaxBitRate->set(bit_rate_downlink, bit_rate_uplink);
Ngap_PDUSessionResourceSetupRequestIEs_t* ie =
(Ngap_PDUSessionResourceSetupRequestIEs_t*) calloc(
......@@ -67,8 +66,8 @@ void PduSessionResourceSetupRequestMsg::setUEAggregateMaxBitRate(
ie->value.present =
Ngap_PDUSessionResourceSetupRequestIEs__value_PR_UEAggregateMaximumBitRate;
int ret = uEAggregateMaxBitRate->encode2UEAggregateMaxBitRate(
ie->value.choice.UEAggregateMaximumBitRate);
int ret =
uEAggregateMaxBitRate->encode(ie->value.choice.UEAggregateMaximumBitRate);
if (!ret) {
Logger::ngap().error("Encode NGAP UEAggregateMaxBitRate IE error");
free_wrapper((void**) &ie);
......@@ -136,7 +135,7 @@ void PduSessionResourceSetupRequestMsg::setRanPagingPriority(
const uint8_t& priority) {
if (!ranPagingPriority) ranPagingPriority = new RANPagingPriority();
ranPagingPriority->setRANPagingPriority(priority);
ranPagingPriority->set(priority);
Ngap_PDUSessionResourceSetupRequestIEs_t* ie =
(Ngap_PDUSessionResourceSetupRequestIEs_t*) calloc(
......@@ -146,8 +145,7 @@ void PduSessionResourceSetupRequestMsg::setRanPagingPriority(
ie->value.present =
Ngap_PDUSessionResourceSetupRequestIEs__value_PR_RANPagingPriority;
int ret = ranPagingPriority->encode2RANPagingPriority(
ie->value.choice.RANPagingPriority);
int ret = ranPagingPriority->encode(ie->value.choice.RANPagingPriority);
if (!ret) {
Logger::ngap().error("Encode NGAP RANPagingPriority IE error");
free_wrapper((void**) &ie);
......@@ -162,7 +160,7 @@ void PduSessionResourceSetupRequestMsg::setRanPagingPriority(
//------------------------------------------------------------------------------
int PduSessionResourceSetupRequestMsg::getRanPagingPriority() {
if (!ranPagingPriority) return -1;
return ranPagingPriority->getRANPagingPriority();
return ranPagingPriority->get();
}
//------------------------------------------------------------------------------
......@@ -354,7 +352,7 @@ bool PduSessionResourceSetupRequestMsg::decodeFromPdu(
->value.present ==
Ngap_PDUSessionResourceSetupRequestIEs__value_PR_RANPagingPriority) {
ranPagingPriority = new RANPagingPriority();
if (!ranPagingPriority->decodefromRANPagingPriority(
if (!ranPagingPriority->decode(
pduSessionResourceSetupRequestIEs->protocolIEs.list.array[i]
->value.choice.RANPagingPriority)) {
Logger::ngap().error("Decoded NGAP RANPagingPriority IE error");
......
......@@ -120,7 +120,7 @@ void RerouteNASRequest::setAllowedNssai(const std::vector<S_Nssai>& list) {
snssai.setSd(sd);
snssaiList.push_back(snssai);
}
allowedNssai->setAllowedNSSAI(snssaiList);
allowedNssai->set(snssaiList);
Ngap_RerouteNASRequest_IEs_t* ie = (Ngap_RerouteNASRequest_IEs_t*) calloc(
1, sizeof(Ngap_RerouteNASRequest_IEs_t));
......@@ -128,7 +128,7 @@ void RerouteNASRequest::setAllowedNssai(const std::vector<S_Nssai>& list) {
ie->criticality = Ngap_Criticality_reject;
ie->value.present = Ngap_RerouteNASRequest_IEs__value_PR_AllowedNSSAI;
int ret = allowedNssai->encode2AllowedNSSAI(&ie->value.choice.AllowedNSSAI);
int ret = allowedNssai->encode(&ie->value.choice.AllowedNSSAI);
if (!ret) {
Logger::ngap().error("Encode AllowedNSSAI IE error!");
free_wrapper((void**) &ie);
......@@ -144,7 +144,7 @@ bool RerouteNASRequest::getAllowedNssai(std::vector<S_Nssai>& list) {
if (!allowedNssai) return false;
std::vector<S_NSSAI> snssaiList;
allowedNssai->getAllowedNSSAI(snssaiList);
allowedNssai->get(snssaiList);
for (std::vector<S_NSSAI>::iterator it = std::begin(snssaiList);
it < std::end(snssaiList); ++it) {
S_Nssai s_nssai = {};
......@@ -295,7 +295,7 @@ bool RerouteNASRequest::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
rerouteNASRequestIEs->protocolIEs.list.array[i]->value.present ==
Ngap_RerouteNASRequest_IEs__value_PR_AllowedNSSAI) {
allowedNssai = new AllowedNSSAI();
if (!allowedNssai->decodefromAllowedNSSAI(
if (!allowedNssai->decode(
&rerouteNASRequestIEs->protocolIEs.list.array[i]
->value.choice.AllowedNSSAI)) {
Logger::ngap().error("Decoded NGAP AllowedNSSAI IE error");
......
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