Commit 122ef355 authored by Tien Thinh NGUYEN's avatar Tien Thinh NGUYEN

Code refactor for PduSessionResourceSetupRequest

parent 3edbfd8c
......@@ -25,19 +25,13 @@
namespace ngap {
//------------------------------------------------------------------------------
NAS_PDU::NAS_PDU() {
// buffer_ = nullptr;
// size_ = -1;
pdu_.buf = nullptr;
pdu_.size = -1;
}
NAS_PDU::NAS_PDU() {}
//------------------------------------------------------------------------------
NAS_PDU::~NAS_PDU() {}
//------------------------------------------------------------------------------
bool NAS_PDU::encode(Ngap_NAS_PDU_t& nas_pdu) {
if (!pdu_.buf) return false;
return conv::bstring_2_octet_string(pdu_bstring, nas_pdu);
}
......
......@@ -50,7 +50,6 @@ class NAS_PDU {
bool set(const NAS_PDU& nas_pdu);
private:
OCTET_STRING_t pdu_;
bstring pdu_bstring;
};
......
......@@ -29,74 +29,82 @@ namespace ngap {
//------------------------------------------------------------------------------
PDUSessionResourceSetupItemSUReq::PDUSessionResourceSetupItemSUReq() {
nAS_PDU = nullptr;
nas_pdu_ = std::nullopt;
}
//------------------------------------------------------------------------------
PDUSessionResourceSetupItemSUReq::~PDUSessionResourceSetupItemSUReq() {}
//------------------------------------------------------------------------------
void PDUSessionResourceSetupItemSUReq::setPDUSessionResourceSetupItemSUReq(
const PDUSessionID& m_pDUSessionID, NAS_PDU* m_nAS_PDU,
const S_NSSAI& m_s_NSSAI,
const OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer) {
pDUSessionID = m_pDUSessionID;
nAS_PDU = m_nAS_PDU;
s_NSSAI = m_s_NSSAI;
pDUSessionResourceSetupRequestTransfer =
m_pDUSessionResourceSetupRequestTransfer;
void PDUSessionResourceSetupItemSUReq::set(
const PDUSessionID& pdu_session_id, std::optional<NAS_PDU>& nas_pdu,
const S_NSSAI& s_nssai,
const OCTET_STRING_t& pdu_session_resource_setup_request_transfer) {
pdu_session_id_ = pdu_session_id;
nas_pdu_ = nas_pdu;
s_nssai_ = s_nssai;
pdu_session_resource_setup_request_transfer_ =
pdu_session_resource_setup_request_transfer;
}
//------------------------------------------------------------------------------
void PDUSessionResourceSetupItemSUReq::getPDUSessionResourceSetupItemSUReq(
PDUSessionID& m_pDUSessionID, NAS_PDU*& m_nAS_PDU, S_NSSAI& m_s_NSSAI,
OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer) {
m_pDUSessionID = pDUSessionID;
m_nAS_PDU = nAS_PDU;
m_s_NSSAI = s_NSSAI;
m_pDUSessionResourceSetupRequestTransfer =
pDUSessionResourceSetupRequestTransfer;
void PDUSessionResourceSetupItemSUReq::get(
PDUSessionID& pdu_session_id, std::optional<NAS_PDU>& nas_pdu,
S_NSSAI& s_nssai,
OCTET_STRING_t& pdu_session_resource_setup_request_transfer) {
pdu_session_id = pdu_session_id_;
nas_pdu = nas_pdu_;
s_nssai = s_nssai_;
pdu_session_resource_setup_request_transfer =
pdu_session_resource_setup_request_transfer_;
}
//------------------------------------------------------------------------------
bool PDUSessionResourceSetupItemSUReq::encode2PDUSessionResourceSetupItemSUReq(
Ngap_PDUSessionResourceSetupItemSUReq_t* pduSessionResourceSetupItemSUReq) {
if (!pDUSessionID.encode(pduSessionResourceSetupItemSUReq->pDUSessionID))
bool PDUSessionResourceSetupItemSUReq::encode(
Ngap_PDUSessionResourceSetupItemSUReq_t*
pdu_session_resource_setup_item_su_req) {
if (!pdu_session_id_.encode(
pdu_session_resource_setup_item_su_req->pDUSessionID))
return false;
if (nAS_PDU) {
if (nas_pdu_.has_value()) {
Ngap_NAS_PDU_t* naspdu =
(Ngap_NAS_PDU_t*) calloc(1, sizeof(Ngap_NAS_PDU_t));
if (!naspdu) return false;
if (!nAS_PDU->encode(*naspdu)) {
if (!nas_pdu_.value().encode(*naspdu)) {
free_wrapper((void**) &naspdu);
return false;
}
pduSessionResourceSetupItemSUReq->pDUSessionNAS_PDU = naspdu;
pdu_session_resource_setup_item_su_req->pDUSessionNAS_PDU = naspdu;
}
if (!s_NSSAI.encode(&pduSessionResourceSetupItemSUReq->s_NSSAI)) return false;
pduSessionResourceSetupItemSUReq->pDUSessionResourceSetupRequestTransfer =
pDUSessionResourceSetupRequestTransfer;
if (!s_nssai_.encode(&pdu_session_resource_setup_item_su_req->s_NSSAI))
return false;
pdu_session_resource_setup_item_su_req
->pDUSessionResourceSetupRequestTransfer =
pdu_session_resource_setup_request_transfer_;
return true;
}
//------------------------------------------------------------------------------
bool PDUSessionResourceSetupItemSUReq::
decodefromPDUSessionResourceSetupItemSUReq(
bool PDUSessionResourceSetupItemSUReq::decode(
Ngap_PDUSessionResourceSetupItemSUReq_t*
pduSessionResourceSetupItemSUReq) {
if (!pDUSessionID.decode(pduSessionResourceSetupItemSUReq->pDUSessionID))
pdu_session_resource_setup_item_su_req) {
if (!pdu_session_id_.decode(
pdu_session_resource_setup_item_su_req->pDUSessionID))
return false;
if (!s_nssai_.decode(&pdu_session_resource_setup_item_su_req->s_NSSAI))
return false;
if (!s_NSSAI.decode(&pduSessionResourceSetupItemSUReq->s_NSSAI)) return false;
if (pduSessionResourceSetupItemSUReq->pDUSessionNAS_PDU) {
nAS_PDU = new NAS_PDU();
if (!nAS_PDU->decode(*pduSessionResourceSetupItemSUReq->pDUSessionNAS_PDU))
if (pdu_session_resource_setup_item_su_req->pDUSessionNAS_PDU) {
NAS_PDU tmp = {};
if (!tmp.decode(*pdu_session_resource_setup_item_su_req->pDUSessionNAS_PDU))
return false;
nas_pdu_ = std::optional<NAS_PDU>(tmp);
}
pDUSessionResourceSetupRequestTransfer =
pduSessionResourceSetupItemSUReq->pDUSessionResourceSetupRequestTransfer;
pdu_session_resource_setup_request_transfer_ =
pdu_session_resource_setup_item_su_req
->pDUSessionResourceSetupRequestTransfer;
return true;
}
......
......@@ -26,6 +26,8 @@
#include "PDUSessionID.hpp"
#include "S-NSSAI.hpp"
#include <optional>
extern "C" {
#include "Ngap_PDUSessionResourceSetupItemSUReq.h"
}
......@@ -37,27 +39,25 @@ class PDUSessionResourceSetupItemSUReq {
PDUSessionResourceSetupItemSUReq();
virtual ~PDUSessionResourceSetupItemSUReq();
void setPDUSessionResourceSetupItemSUReq(
const PDUSessionID& m_pDUSessionID, NAS_PDU* m_nAS_PDU,
const S_NSSAI& m_s_NSSAI,
const OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer);
void getPDUSessionResourceSetupItemSUReq(
PDUSessionID& m_pDUSessionID, NAS_PDU*& m_nAS_PDU, S_NSSAI& m_s_NSSAI,
OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer);
void set(
const PDUSessionID& pdu_session_id, std::optional<NAS_PDU>& nas_pdu,
const S_NSSAI& s_nssai,
const OCTET_STRING_t& pdu_session_resource_setup_request_transfer);
void get(
PDUSessionID& pdu_session_id, std::optional<NAS_PDU>& nas_pdu,
S_NSSAI& s_nssai,
OCTET_STRING_t& pdu_session_resource_setup_request_transfer);
bool encode2PDUSessionResourceSetupItemSUReq(
Ngap_PDUSessionResourceSetupItemSUReq_t*
pduSessionResourceSetupItemSUReq);
bool decodefromPDUSessionResourceSetupItemSUReq(
Ngap_PDUSessionResourceSetupItemSUReq_t*
pduSessionResourceSetupItemSUReq);
bool encode(Ngap_PDUSessionResourceSetupItemSUReq_t*
pdu_session_resource_setup_item_su_req);
bool decode(Ngap_PDUSessionResourceSetupItemSUReq_t*
pdu_session_resource_setup_item_su_req);
private:
PDUSessionID pDUSessionID; // Mandatory
NAS_PDU* nAS_PDU; // Optional
S_NSSAI s_NSSAI; // Mandatory
OCTET_STRING_t pDUSessionResourceSetupRequestTransfer; // Mandatory
// TODO: UE Aggregate Maximum Bit Rate (Optional)
PDUSessionID pdu_session_id_; // Mandatory
std::optional<NAS_PDU> nas_pdu_; // Optional
S_NSSAI s_nssai_; // Mandatory
OCTET_STRING_t pdu_session_resource_setup_request_transfer_; // Mandatory
};
} // namespace ngap
......
......@@ -49,7 +49,7 @@ bool PDUSessionResourceSetupListSUReq::encode2PDUSessionResourceSetupListSUReq(
(Ngap_PDUSessionResourceSetupItemSUReq_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceSetupItemSUReq_t));
if (!request) return false;
if (!item.encode2PDUSessionResourceSetupItemSUReq(request)) return false;
if (!item.encode(request)) return false;
if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListSUReq->list, request) != 0)
return false;
}
......@@ -64,8 +64,7 @@ bool PDUSessionResourceSetupListSUReq::
pduSessionResourceSetupListSUReq) {
for (int i = 0; i < pduSessionResourceSetupListSUReq->list.count; i++) {
PDUSessionResourceSetupItemSUReq item = {};
if (!item.decodefromPDUSessionResourceSetupItemSUReq(
pduSessionResourceSetupListSUReq->list.array[i]))
if (!item.decode(pduSessionResourceSetupListSUReq->list.array[i]))
return false;
itemSUReqList.push_back(item);
}
......
......@@ -101,7 +101,7 @@ void PduSessionResourceModifyRequestMsg::setRanUeNgapId(
//------------------------------------------------------------------------------
void PduSessionResourceModifyRequestMsg::setRanPagingPriority(
const uint8_t& priority) {
const uint32_t& priority) {
if (!ranPagingPriority) ranPagingPriority = new RANPagingPriority();
ranPagingPriority->set(priority);
......
......@@ -43,7 +43,7 @@ class PduSessionResourceModifyRequestMsg : public NgapUEMessage {
void setRanUeNgapId(const uint32_t& id) override;
bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
void setRanPagingPriority(const uint8_t& priority);
void setRanPagingPriority(const uint32_t& priority);
int getRanPagingPriority();
void setNasPdu(const bstring& pdu);
......
......@@ -103,7 +103,7 @@ void PduSessionResourceReleaseCommandMsg::setRanUeNgapId(
//------------------------------------------------------------------------------
void PduSessionResourceReleaseCommandMsg::setRanPagingPriority(
const uint8_t& priority) {
const uint32_t& priority) {
RANPagingPriority tmp = {};
tmp.set(priority);
ranPagingPriority = std::optional<RANPagingPriority>(tmp);
......@@ -131,7 +131,7 @@ void PduSessionResourceReleaseCommandMsg::setRanPagingPriority(
//------------------------------------------------------------------------------
bool PduSessionResourceReleaseCommandMsg::getRanPagingPriority(
uint8_t& priority) {
uint32_t& priority) {
if (!ranPagingPriority.has_value()) return false;
priority = ranPagingPriority.value().get();
return true;
......
......@@ -43,8 +43,8 @@ class PduSessionResourceReleaseCommandMsg : public NgapUEMessage {
void setRanUeNgapId(const uint32_t& id) override;
bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
void setRanPagingPriority(const uint8_t& priority);
bool getRanPagingPriority(uint8_t& priority);
void setRanPagingPriority(const uint32_t& priority);
bool getRanPagingPriority(uint32_t& priority);
void setNasPdu(const bstring& pdu);
bool getNasPdu(bstring& pdu);
......
......@@ -34,9 +34,9 @@ namespace ngap {
PduSessionResourceSetupRequestMsg::PduSessionResourceSetupRequestMsg()
: NgapUEMessage() {
pduSessionResourceSetupRequestIEs = nullptr;
ranPagingPriority = nullptr;
nasPdu = nullptr;
uEAggregateMaxBitRate = nullptr;
ranPagingPriority = std::nullopt;
nasPdu = std::nullopt;
uEAggregateMaxBitRate = std::nullopt;
setMessageType(NgapMessageType::PDU_SESSION_RESOURCE_SETUP_REQUEST);
initialize();
......@@ -54,11 +54,10 @@ void PduSessionResourceSetupRequestMsg::initialize() {
//-----------------------------------------------------------------------------
void PduSessionResourceSetupRequestMsg::setUEAggregateMaxBitRate(
const long& bit_rate_downlink, const long& bit_rate_uplink) {
if (!uEAggregateMaxBitRate)
uEAggregateMaxBitRate = new UEAggregateMaxBitRate();
uEAggregateMaxBitRate->set(bit_rate_downlink, bit_rate_uplink);
const uint64_t& bit_rate_downlink, const uint64_t& bit_rate_uplink) {
UEAggregateMaxBitRate tmp = {};
tmp.set(bit_rate_downlink, bit_rate_uplink);
uEAggregateMaxBitRate = std::optional<UEAggregateMaxBitRate>(tmp);
Ngap_PDUSessionResourceSetupRequestIEs_t* ie =
(Ngap_PDUSessionResourceSetupRequestIEs_t*) calloc(
......@@ -68,8 +67,8 @@ void PduSessionResourceSetupRequestMsg::setUEAggregateMaxBitRate(
ie->value.present =
Ngap_PDUSessionResourceSetupRequestIEs__value_PR_UEAggregateMaximumBitRate;
int ret =
uEAggregateMaxBitRate->encode(ie->value.choice.UEAggregateMaximumBitRate);
int ret = uEAggregateMaxBitRate.value().encode(
ie->value.choice.UEAggregateMaximumBitRate);
if (!ret) {
Logger::ngap().error("Encode NGAP UEAggregateMaxBitRate IE error");
free_wrapper((void**) &ie);
......@@ -82,6 +81,12 @@ void PduSessionResourceSetupRequestMsg::setUEAggregateMaxBitRate(
Logger::ngap().error("Encode NGAP UEAggregateMaxBitRate IE error");
}
//------------------------------------------------------------------------------
bool PduSessionResourceSetupRequestMsg::getUEAggregateMaxBitRate(
uint64_t& bit_rate_downlink, uint64_t& bit_rate_uplink) const {
if (!uEAggregateMaxBitRate.has_value()) return false;
return uEAggregateMaxBitRate.value().get(bit_rate_downlink, bit_rate_uplink);
}
//------------------------------------------------------------------------------
void PduSessionResourceSetupRequestMsg::setAmfUeNgapId(
const unsigned long& id) {
......@@ -134,10 +139,10 @@ void PduSessionResourceSetupRequestMsg::setRanUeNgapId(
//------------------------------------------------------------------------------
void PduSessionResourceSetupRequestMsg::setRanPagingPriority(
const uint8_t& priority) {
if (!ranPagingPriority) ranPagingPriority = new RANPagingPriority();
ranPagingPriority->set(priority);
const uint32_t& priority) {
RANPagingPriority tmp = {};
tmp.set(priority);
ranPagingPriority = std::optional<RANPagingPriority>(tmp);
Ngap_PDUSessionResourceSetupRequestIEs_t* ie =
(Ngap_PDUSessionResourceSetupRequestIEs_t*) calloc(
......@@ -147,7 +152,8 @@ void PduSessionResourceSetupRequestMsg::setRanPagingPriority(
ie->value.present =
Ngap_PDUSessionResourceSetupRequestIEs__value_PR_RANPagingPriority;
int ret = ranPagingPriority->encode(ie->value.choice.RANPagingPriority);
int ret =
ranPagingPriority.value().encode(ie->value.choice.RANPagingPriority);
if (!ret) {
Logger::ngap().error("Encode NGAP RANPagingPriority IE error");
free_wrapper((void**) &ie);
......@@ -160,16 +166,18 @@ void PduSessionResourceSetupRequestMsg::setRanPagingPriority(
}
//------------------------------------------------------------------------------
int PduSessionResourceSetupRequestMsg::getRanPagingPriority() {
if (!ranPagingPriority) return -1;
return ranPagingPriority->get();
bool PduSessionResourceSetupRequestMsg::getRanPagingPriority(
uint32_t& ran_paging_priority) {
if (!ranPagingPriority.has_value()) return false;
ran_paging_priority = ranPagingPriority.value().get();
return true;
}
//------------------------------------------------------------------------------
void PduSessionResourceSetupRequestMsg::setNasPdu(const bstring& pdu) {
if (!nasPdu) nasPdu = new NAS_PDU();
nasPdu->set(pdu);
NAS_PDU tmp = {};
tmp.set(pdu);
nasPdu = std::optional<NAS_PDU>(tmp);
Ngap_PDUSessionResourceSetupRequestIEs_t* ie =
(Ngap_PDUSessionResourceSetupRequestIEs_t*) calloc(
......@@ -178,7 +186,7 @@ void PduSessionResourceSetupRequestMsg::setNasPdu(const bstring& pdu) {
ie->criticality = Ngap_Criticality_reject;
ie->value.present = Ngap_PDUSessionResourceSetupRequestIEs__value_PR_NAS_PDU;
int ret = nasPdu->encode(ie->value.choice.NAS_PDU);
int ret = nasPdu.value().encode(ie->value.choice.NAS_PDU);
if (!ret) {
Logger::ngap().error("Encode NGAP NAS_PDU IE error");
free_wrapper((void**) &ie);
......@@ -192,8 +200,8 @@ void PduSessionResourceSetupRequestMsg::setNasPdu(const bstring& pdu) {
//------------------------------------------------------------------------------
bool PduSessionResourceSetupRequestMsg::getNasPdu(bstring& pdu) {
if (!nasPdu) return false;
return nasPdu->get(pdu);
if (!nasPdu.has_value()) return false;
return nasPdu.value().get(pdu);
}
//------------------------------------------------------------------------------
......@@ -205,15 +213,16 @@ void PduSessionResourceSetupRequestMsg::setPduSessionResourceSetupRequestList(
PDUSessionResourceSetupItemSUReq itemSUReq = {};
PDUSessionID pDUSessionID = {};
pDUSessionID.set(list[i].pduSessionId);
NAS_PDU* m_nAS_PDU = nullptr;
std::optional<NAS_PDU> m_nAS_PDU = std::nullopt;
if (conv::check_bstring(list[i].nas_pdu)) {
m_nAS_PDU = new NAS_PDU();
m_nAS_PDU->set(list[i].nas_pdu);
NAS_PDU tmp = {};
tmp.set(list[i].nas_pdu);
m_nAS_PDU = std::optional<NAS_PDU>(tmp);
}
S_NSSAI s_NSSAI = {};
s_NSSAI.setSst(list[i].s_nssai.sst);
if (list[i].s_nssai.sd.size()) s_NSSAI.setSd(list[i].s_nssai.sd);
itemSUReq.setPDUSessionResourceSetupItemSUReq(
itemSUReq.set(
pDUSessionID, m_nAS_PDU, s_NSSAI,
list[i].pduSessionResourceSetupRequestTransfer);
itemSUReqList.push_back(itemSUReq);
......@@ -258,16 +267,16 @@ bool PduSessionResourceSetupRequestMsg::getPduSessionResourceSetupRequestList(
PDUSessionResourceSetupRequestItem_t request = {};
PDUSessionID pDUSessionID = {};
NAS_PDU* nAS_PDU = nullptr;
std::optional<NAS_PDU> nAS_PDU = std::nullopt;
S_NSSAI s_NSSAI = {};
item.getPDUSessionResourceSetupItemSUReq(
item.get(
pDUSessionID, nAS_PDU, s_NSSAI,
request.pduSessionResourceSetupRequestTransfer);
pDUSessionID.get(request.pduSessionId);
s_NSSAI.getSst(request.s_nssai.sst);
s_NSSAI.getSd(request.s_nssai.sd);
if (nAS_PDU) {
nAS_PDU->get(request.nas_pdu);
if (nAS_PDU.has_value()) {
nAS_PDU.value().get(request.nas_pdu);
}
list.push_back(request);
}
......@@ -344,13 +353,14 @@ bool PduSessionResourceSetupRequestMsg::decodeFromPdu(
pduSessionResourceSetupRequestIEs->protocolIEs.list.array[i]
->value.present ==
Ngap_PDUSessionResourceSetupRequestIEs__value_PR_RANPagingPriority) {
ranPagingPriority = new RANPagingPriority();
if (!ranPagingPriority->decode(
RANPagingPriority tmp = {};
if (!tmp.decode(
pduSessionResourceSetupRequestIEs->protocolIEs.list.array[i]
->value.choice.RANPagingPriority)) {
Logger::ngap().error("Decoded NGAP RANPagingPriority IE error");
return false;
}
ranPagingPriority = std::optional<RANPagingPriority>(tmp);
} else {
Logger::ngap().error("Decoded NGAP RANPagingPriority IE error");
return false;
......@@ -362,13 +372,14 @@ bool PduSessionResourceSetupRequestMsg::decodeFromPdu(
pduSessionResourceSetupRequestIEs->protocolIEs.list.array[i]
->value.present ==
Ngap_PDUSessionResourceSetupRequestIEs__value_PR_NAS_PDU) {
nasPdu = new NAS_PDU();
if (!nasPdu->decode(
NAS_PDU tmp = {};
if (!tmp.decode(
pduSessionResourceSetupRequestIEs->protocolIEs.list.array[i]
->value.choice.NAS_PDU)) {
Logger::ngap().error("Decoded NGAP NAS_PDU IE error");
return false;
}
nasPdu = std::optional<NAS_PDU>(tmp);
} else {
Logger::ngap().error("Decoded NGAP NAS_PDU IE error");
return false;
......@@ -396,6 +407,27 @@ bool PduSessionResourceSetupRequestMsg::decodeFromPdu(
return false;
}
} break;
// TODO:uEAggregateMaxBitRate
case Ngap_ProtocolIE_ID_id_UEAggregateMaximumBitRate: {
if (pduSessionResourceSetupRequestIEs->protocolIEs.list.array[i]
->criticality == Ngap_Criticality_ignore &&
pduSessionResourceSetupRequestIEs->protocolIEs.list.array[i]
->value.present ==
Ngap_PDUSessionResourceSetupRequestIEs__value_PR_UEAggregateMaximumBitRate) {
UEAggregateMaxBitRate tmp = {};
if (!tmp.decode(
pduSessionResourceSetupRequestIEs->protocolIEs.list.array[i]
->value.choice.UEAggregateMaximumBitRate)) {
Logger::ngap().error("Decoded NGAP UEAggregateMaxBitRate IE error");
return false;
}
uEAggregateMaxBitRate = std::optional<UEAggregateMaxBitRate>(tmp);
} else {
Logger::ngap().error("Decoded NGAP UEAggregateMaxBitRate IE error");
return false;
}
} break;
default: {
Logger::ngap().error("Decoded NGAP Message PDU error");
return false;
......
......@@ -27,6 +27,8 @@
#include "UEAggregateMaxBitRate.hpp"
#include "NgapUEMessage.hpp"
#include <optional>
extern "C" {
#include "Ngap_InitialContextSetupRequest.h"
}
......@@ -44,8 +46,8 @@ class PduSessionResourceSetupRequestMsg : public NgapUEMessage {
void setRanUeNgapId(const uint32_t& id) override;
bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
void setRanPagingPriority(const uint8_t& priority);
int getRanPagingPriority();
void setRanPagingPriority(const uint32_t& priority);
bool getRanPagingPriority(uint32_t& priority);
void setNasPdu(const bstring& pdu);
bool getNasPdu(bstring& pdu);
......@@ -56,17 +58,18 @@ class PduSessionResourceSetupRequestMsg : public NgapUEMessage {
std::vector<PDUSessionResourceSetupRequestItem_t>& list);
void setUEAggregateMaxBitRate(
const long& bit_rate_downlink, const long& bit_rate_uplink);
void 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) const;
private:
Ngap_PDUSessionResourceSetupRequest_t* pduSessionResourceSetupRequestIEs;
RANPagingPriority* ranPagingPriority; // Optional
NAS_PDU* nasPdu; // Optional
std::optional<RANPagingPriority> ranPagingPriority; // Optional
std::optional<NAS_PDU> nasPdu; // Optional
PDUSessionResourceSetupListSUReq
pduSessionResourceSetupRequestList; // Mandatory
UEAggregateMaxBitRate* uEAggregateMaxBitRate; // Optional
std::optional<UEAggregateMaxBitRate> uEAggregateMaxBitRate; // Optional
};
} // namespace ngap
......
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