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

Code refactor for Handover Required

parent 73f7219d
...@@ -1485,20 +1485,23 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) { ...@@ -1485,20 +1485,23 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) {
"Handover Required, Choice of Cause %d, Cause %ld", "Handover Required, Choice of Cause %d, Cause %ld",
(int) itti_msg.handoverReq->getChoiceOfCause(), (int) itti_msg.handoverReq->getChoiceOfCause(),
itti_msg.handoverReq->getCauseValue()); itti_msg.handoverReq->getCauseValue());
Logger::amf_n2().debug( long direct_forward_path_availability = {};
"Handover Required, DirectForwardingPathAvailability %d", if (itti_msg.handoverReq->getDirectForwardingPathAvailability(
itti_msg.handoverReq->getDirectForwardingPathAvailability()); direct_forward_path_availability))
Logger::amf_n2().debug(
"Handover Required, DirectForwardingPathAvailability %ld",
direct_forward_path_availability);
unc->gnb_assoc_id = itti_msg.assoc_id; unc->gnb_assoc_id = itti_msg.assoc_id;
unc->ncc++; unc->ncc++;
unc->ng_ue_state = NGAP_UE_HANDOVER; unc->ng_ue_state = NGAP_UE_HANDOVER;
GlobalgNBId TargetGlobalgNBId = {}; GlobalgNBId target_global_gnb_id = {};
TAI tai = {}; TAI tai = {};
itti_msg.handoverReq->getTargetID(TargetGlobalgNBId, tai); itti_msg.handoverReq->getTargetID(target_global_gnb_id, tai);
ngap::PlmnId plmn = {}; ngap::PlmnId plmn = {};
GNB_ID gnbid = {}; GNB_ID gnbid = {};
TargetGlobalgNBId.get(plmn, gnbid); target_global_gnb_id.get(plmn, gnbid);
std::string mcc = {}; std::string mcc = {};
std::string mnc = {}; std::string mnc = {};
plmn.getMcc(mcc); plmn.getMcc(mcc);
...@@ -1511,16 +1514,16 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) { ...@@ -1511,16 +1514,16 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) {
"gNBId 0x%x)", "gNBId 0x%x)",
mcc.c_str(), mnc.c_str(), gnb_id_value); mcc.c_str(), mnc.c_str(), gnb_id_value);
string mccSelectTAI = {}; string mcc_select_tai = {};
string mncSelectTAI = {}; string mnc_select_tai = {};
uint32_t tac = {}; uint32_t tac = {};
tai.getTAI(mccSelectTAI, mncSelectTAI, tac); tai.getTAI(mcc_select_tai, mnc_select_tai, tac);
Logger::amf_n2().debug( Logger::amf_n2().debug(
"Handover Required: Target ID selected TAI PLMN (MCC %s, MNC %s, TAC %x)", "Handover Required: Target ID selected TAI PLMN (MCC %s, MNC %s, TAC %x)",
mccSelectTAI.c_str(), mncSelectTAI.c_str(), tac); mcc_select_tai.c_str(), mnc_select_tai.c_str(), tac);
OCTET_STRING_t sourceTotarget = OCTET_STRING_t source_to_target =
itti_msg.handoverReq->getSourceToTarget_TransparentContainer(); itti_msg.handoverReq->getSourceToTarget_TransparentContainer();
// TODO: T-AMF selection, for now use the same AMF // TODO: T-AMF selection, for now use the same AMF
...@@ -1538,26 +1541,26 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) { ...@@ -1538,26 +1541,26 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) {
handover_request->setUESecurityCapabilities( handover_request->setUESecurityCapabilities(
0xe000, 0xe000, 0xe000, 0xe000); // TODO: remove hardcoded values 0xe000, 0xe000, 0xe000, 0xe000); // TODO: remove hardcoded values
handover_request->setSourceToTarget_TransparentContainer(sourceTotarget); handover_request->setSourceToTarget_TransparentContainer(source_to_target);
// Allowed NSSAI // Allowed NSSAI
std::vector<S_NSSAI> Allowed_Nssai; std::vector<S_NSSAI> allowed_nssai;
for (int i = 0; i < amf_cfg.plmn_list.size(); i++) { for (int i = 0; i < amf_cfg.plmn_list.size(); i++) {
for (int j = 0; j < amf_cfg.plmn_list[i].slice_list.size(); j++) { for (int j = 0; j < amf_cfg.plmn_list[i].slice_list.size(); j++) {
S_Nssai s_tmp; S_Nssai s_tmp;
S_NSSAI s_nssai = {}; S_NSSAI s_nssai = {};
s_nssai.setSst(amf_cfg.plmn_list[i].slice_list[j].sst); s_nssai.setSst(amf_cfg.plmn_list[i].slice_list[j].sst);
s_nssai.setSd(amf_cfg.plmn_list[i].slice_list[j].sd); s_nssai.setSd(amf_cfg.plmn_list[i].slice_list[j].sd);
Allowed_Nssai.push_back(s_nssai); allowed_nssai.push_back(s_nssai);
} }
} }
handover_request->setAllowedNSSAI(Allowed_Nssai); handover_request->setAllowedNSSAI(allowed_nssai);
// GUAMI, PLMN // GUAMI, PLMN
ngap::PlmnId m_plmnId = {}; ngap::PlmnId plmn_id = {};
m_plmnId.set(amf_cfg.guami.mcc, amf_cfg.guami.mnc); plmn_id.set(amf_cfg.guami.mcc, amf_cfg.guami.mnc);
handover_request->setMobilityRestrictionList(m_plmnId); handover_request->setMobilityRestrictionList(plmn_id);
handover_request->setGUAMI( handover_request->setGUAMI(
amf_cfg.guami.mcc, amf_cfg.guami.mnc, amf_cfg.guami.regionID, amf_cfg.guami.mcc, amf_cfg.guami.mnc, amf_cfg.guami.regionID,
amf_cfg.guami.AmfSetID, amf_cfg.guami.AmfPointer); amf_cfg.guami.AmfSetID, amf_cfg.guami.AmfPointer);
...@@ -1599,23 +1602,24 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) { ...@@ -1599,23 +1602,24 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) {
"Decoding PDU Session Resource List IE error or IE missing"); "Decoding PDU Session Resource List IE error or IE missing");
} }
std::vector<PDUSessionResourceItemHORqd> itemHORqdList; std::vector<PDUSessionResourceItem> item_ho_required_list;
pDUSessionResourceListHORqd.getPDUSessionResourceListHORqd(itemHORqdList); pDUSessionResourceListHORqd.get(item_ho_required_list);
std::map<uint8_t, boost::shared_future<std::string>> curl_responses; std::map<uint8_t, boost::shared_future<std::string>> curl_responses;
// Send PDUSessionUpdateSMContextRequest to SMF for all PDU sessions included // Send PDUSessionUpdateSMContextRequest to SMF for all PDU sessions included
// in HO Required message // in HO Required message
for (auto& item : itemHORqdList) { for (auto& item : item_ho_required_list) {
PDUSessionID pDUSessionID = {}; PDUSessionID pdu_session_id = {};
OCTET_STRING_t handoverRequiredTransfer = {}; OCTET_STRING_t handover_required_transfer = {};
item.getPDUSessionResourceItemHORqd(pDUSessionID, handoverRequiredTransfer); item.get(pdu_session_id, handover_required_transfer);
uint8_t pduSessionIDValue = 0; uint8_t pdu_session_id_value = 0;
pDUSessionID.get(pduSessionIDValue); pdu_session_id.get(pdu_session_id_value);
Logger::ngap().debug("PDU Session ID %d", pduSessionIDValue); Logger::ngap().debug("PDU Session ID %d", pdu_session_id_value);
std::shared_ptr<pdu_session_context> psc = {}; std::shared_ptr<pdu_session_context> psc = {};
if (amf_app_inst->find_pdu_session_context(supi, pduSessionIDValue, psc)) { if (amf_app_inst->find_pdu_session_context(
supi, pdu_session_id_value, psc)) {
// Generate a promise and associate this promise to the curl handle // Generate a promise and associate this promise to the curl handle
uint32_t promise_id = amf_app_inst->generate_promise_id(); uint32_t promise_id = amf_app_inst->generate_promise_id();
Logger::amf_n2().debug("Promise ID generated %d", promise_id); Logger::amf_n2().debug("Promise ID generated %d", promise_id);
...@@ -1634,9 +1638,9 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) { ...@@ -1634,9 +1638,9 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) {
std::make_shared<itti_nsmf_pdusession_update_sm_context>( std::make_shared<itti_nsmf_pdusession_update_sm_context>(
TASK_NGAP, TASK_AMF_SBI); TASK_NGAP, TASK_AMF_SBI);
itti_msg->pdu_session_id = pduSessionIDValue; itti_msg->pdu_session_id = pdu_session_id_value;
itti_msg->n2sm = itti_msg->n2sm = blk2bstr(
blk2bstr(handoverRequiredTransfer.buf, handoverRequiredTransfer.size); handover_required_transfer.buf, handover_required_transfer.size);
itti_msg->is_n2sm_set = true; itti_msg->is_n2sm_set = true;
itti_msg->n2sm_info_type = "HANDOVER_REQUIRED"; itti_msg->n2sm_info_type = "HANDOVER_REQUIRED";
itti_msg->ho_state = "PREPARING"; itti_msg->ho_state = "PREPARING";
...@@ -1839,20 +1843,20 @@ void amf_n2::handle_itti_message(itti_handover_request_Ack& itti_msg) { ...@@ -1839,20 +1843,20 @@ void amf_n2::handle_itti_message(itti_handover_request_Ack& itti_msg) {
"Got result for PDU Session ID %d", curl_responses.begin()->first); "Got result for PDU Session ID %d", curl_responses.begin()->first);
if (n2_sm.size() > 0) { if (n2_sm.size() > 0) {
result = result && true; result = result && true;
uint8_t pduSessionIDValue = curl_responses.begin()->first; uint8_t pdu_session_id_value = curl_responses.begin()->first;
unsigned int data_len = n2_sm.length(); unsigned int data_len = n2_sm.length();
PDUSessionID pDUSessionID = {}; PDUSessionID pdu_session_id = {};
OCTET_STRING_t handoverCommandTransfer = {}; OCTET_STRING_t handoverCommandTransfer = {};
pDUSessionID.set(pduSessionIDValue); pdu_session_id.set(pdu_session_id_value);
OCTET_STRING_fromBuf( OCTET_STRING_fromBuf(
&handoverCommandTransfer, n2_sm.c_str(), n2_sm.length()); &handoverCommandTransfer, n2_sm.c_str(), n2_sm.length());
handoverItem.set(pDUSessionID, handoverCommandTransfer); handoverItem.set(pdu_session_id, handoverCommandTransfer);
handoverItemList.push_back(handoverItem); handoverItemList.push_back(handoverItem);
handoverList.set(handoverItemList); handoverList.set(handoverItemList);
std::shared_ptr<pdu_session_context> psc = {}; std::shared_ptr<pdu_session_context> psc = {};
if (amf_app_inst->find_pdu_session_context( if (amf_app_inst->find_pdu_session_context(
supi, pduSessionIDValue, psc)) { supi, pdu_session_id_value, psc)) {
psc->is_ho_accepted = true; psc->is_ho_accepted = true;
} }
} else { } else {
......
...@@ -75,6 +75,18 @@ bool PDUSessionResourceItem::decode( ...@@ -75,6 +75,18 @@ bool PDUSessionResourceItem::decode(
item->pDUSessionID, item->pDUSessionResourceSetupResponseTransfer); item->pDUSessionID, item->pDUSessionResourceSetupResponseTransfer);
} }
//------------------------------------------------------------------------------
bool PDUSessionResourceItem::encode(
Ngap_PDUSessionResourceItemHORqd_t* item) const {
return encode(item->pDUSessionID, item->handoverRequiredTransfer);
}
//------------------------------------------------------------------------------
bool PDUSessionResourceItem::decode(
const Ngap_PDUSessionResourceItemHORqd_t* const item) {
return decode(item->pDUSessionID, item->handoverRequiredTransfer);
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceItem::encode( bool PDUSessionResourceItem::encode(
Ngap_PDUSessionResourceHandoverItem_t* item) const { Ngap_PDUSessionResourceHandoverItem_t* item) const {
......
...@@ -30,6 +30,7 @@ extern "C" { ...@@ -30,6 +30,7 @@ extern "C" {
#include "Ngap_PDUSessionResourceHandoverItem.h" #include "Ngap_PDUSessionResourceHandoverItem.h"
#include "Ngap_PDUSessionResourceAdmittedItem.h" #include "Ngap_PDUSessionResourceAdmittedItem.h"
#include "Ngap_PDUSessionResourceFailedToSetupItemHOAck.h" #include "Ngap_PDUSessionResourceFailedToSetupItemHOAck.h"
#include "Ngap_PDUSessionResourceItemHORqd.h"
} }
namespace ngap { namespace ngap {
...@@ -100,14 +101,15 @@ class PDUSessionResourceItem { ...@@ -100,14 +101,15 @@ class PDUSessionResourceItem {
// TODO: PDU Session Resource Item // TODO: PDU Session Resource Item
// HANDOVER REQUIRED // HANDOVER REQUIRED
// TODO: PDU Session Resource Item // PDU Session Resource Item
bool encode(Ngap_PDUSessionResourceItemHORqd_t* item) const;
bool decode(const Ngap_PDUSessionResourceItemHORqd_t* const item);
// HANDOVER COMMAND // HANDOVER COMMAND
// TODO: PDU Session Resource Handover Item // PDU Session Resource Handover Item
bool encode(Ngap_PDUSessionResourceHandoverItem_t* item) const; bool encode(Ngap_PDUSessionResourceHandoverItem_t* item) const;
bool decode(const Ngap_PDUSessionResourceHandoverItem_t* const item); bool decode(const Ngap_PDUSessionResourceHandoverItem_t* const item);
// PDU Session Resource to Release Item
// TODO: PDU Session Resource to Release Item
bool encode(Ngap_PDUSessionResourceToReleaseItemHOCmd_t* item) const; bool encode(Ngap_PDUSessionResourceToReleaseItemHOCmd_t* item) const;
bool decode(const Ngap_PDUSessionResourceToReleaseItemHOCmd_t* const item); bool decode(const Ngap_PDUSessionResourceToReleaseItemHOCmd_t* const item);
......
...@@ -30,42 +30,39 @@ PDUSessionResourceListHORqd::PDUSessionResourceListHORqd() {} ...@@ -30,42 +30,39 @@ PDUSessionResourceListHORqd::PDUSessionResourceListHORqd() {}
PDUSessionResourceListHORqd::~PDUSessionResourceListHORqd() {} PDUSessionResourceListHORqd::~PDUSessionResourceListHORqd() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceListHORqd::setPDUSessionResourceListHORqd( void PDUSessionResourceListHORqd::set(
const std::vector<PDUSessionResourceItemHORqd>& list) { const std::vector<PDUSessionResourceItem>& list) {
itemHORqdList = list; item_list_ = list;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceListHORqd::getPDUSessionResourceListHORqd( void PDUSessionResourceListHORqd::get(
std::vector<PDUSessionResourceItemHORqd>& list) { std::vector<PDUSessionResourceItem>& list) {
list = itemHORqdList; list = item_list_;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceListHORqd::encode2PDUSessionResourceListHORqd( bool PDUSessionResourceListHORqd::encode(
Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd) { Ngap_PDUSessionResourceListHORqd_t* list) {
for (auto& item : itemHORqdList) { for (auto& item : item_list_) {
Ngap_PDUSessionResourceItemHORqd_t* itemHORqd = Ngap_PDUSessionResourceItemHORqd_t* itemHORqd =
(Ngap_PDUSessionResourceItemHORqd_t*) calloc( (Ngap_PDUSessionResourceItemHORqd_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceItemHORqd_t)); 1, sizeof(Ngap_PDUSessionResourceItemHORqd_t));
if (!itemHORqd) return false; if (!itemHORqd) return false;
if (!item.encode2PDUSessionResourceItemHORqd(itemHORqd)) return false; if (!item.encode(itemHORqd)) return false;
if (ASN_SEQUENCE_ADD(&pduSessionResourceListHORQqd->list, itemHORqd) != 0) if (ASN_SEQUENCE_ADD(&list->list, itemHORqd) != 0) return false;
return false;
} }
return true; return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceListHORqd::decodefromPDUSessionResourceListHORqd( bool PDUSessionResourceListHORqd::decode(
Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd) { Ngap_PDUSessionResourceListHORqd_t* list) {
for (int i = 0; i < pduSessionResourceListHORQqd->list.count; i++) { for (int i = 0; i < list->list.count; i++) {
PDUSessionResourceItemHORqd item = {}; PDUSessionResourceItem item = {};
if (!item.decodefromPDUSessionResourceItemHORqd( if (!item.decode(list->list.array[i])) return false;
pduSessionResourceListHORQqd->list.array[i])) item_list_.push_back(item);
return false;
itemHORqdList.push_back(item);
} }
return true; return true;
......
...@@ -22,7 +22,7 @@ ...@@ -22,7 +22,7 @@
#ifndef _PDU_SESSION_RESOURCE_LIST_HO_RQD_H_ #ifndef _PDU_SESSION_RESOURCE_LIST_HO_RQD_H_
#define _PDU_SESSION_RESOURCE_LIST_HO_RQD_H_ #define _PDU_SESSION_RESOURCE_LIST_HO_RQD_H_
#include "PDUSessionResourceItemHORqd.hpp" #include "PDUSessionResourceItem.hpp"
#include <vector> #include <vector>
extern "C" { extern "C" {
...@@ -36,18 +36,14 @@ class PDUSessionResourceListHORqd { ...@@ -36,18 +36,14 @@ class PDUSessionResourceListHORqd {
PDUSessionResourceListHORqd(); PDUSessionResourceListHORqd();
virtual ~PDUSessionResourceListHORqd(); virtual ~PDUSessionResourceListHORqd();
void setPDUSessionResourceListHORqd( void set(const std::vector<PDUSessionResourceItem>& list);
const std::vector<PDUSessionResourceItemHORqd>& list); void get(std::vector<PDUSessionResourceItem>& list);
void getPDUSessionResourceListHORqd(
std::vector<PDUSessionResourceItemHORqd>& list);
bool encode2PDUSessionResourceListHORqd( bool encode(Ngap_PDUSessionResourceListHORqd_t* list);
Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd); bool decode(Ngap_PDUSessionResourceListHORqd_t* list);
bool decodefromPDUSessionResourceListHORqd(
Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd);
private: private:
std::vector<PDUSessionResourceItemHORqd> itemHORqdList; std::vector<PDUSessionResourceItem> item_list_;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -67,8 +67,8 @@ class HandoverRequestAck : public NgapUEMessage { ...@@ -67,8 +67,8 @@ class HandoverRequestAck : public NgapUEMessage {
PDUSessionResourceAdmittedList pduSessionResourceAdmittedList; // Mandatory PDUSessionResourceAdmittedList pduSessionResourceAdmittedList; // Mandatory
std::optional<PDUSessionResourceFailedToSetupListHOAck> std::optional<PDUSessionResourceFailedToSetupListHOAck>
PDUSessionResourceFailedToSetupList; PDUSessionResourceFailedToSetupList;
OCTET_STRING_t TargetToSource_TransparentContainer; // Mandatory OCTET_STRING_t TargetToSource_TransparentContainer; // TODO: Mandatory
Ngap_CriticalityDiagnostics_t* CriticalityDiagnostics; // Optional Ngap_CriticalityDiagnostics_t* CriticalityDiagnostics; // TODO: Optional
}; };
} // namespace ngap } // namespace ngap
......
...@@ -30,7 +30,7 @@ namespace ngap { ...@@ -30,7 +30,7 @@ namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
HandoverRequiredMsg::HandoverRequiredMsg() : NgapUEMessage() { HandoverRequiredMsg::HandoverRequiredMsg() : NgapUEMessage() {
directForwardingPathAvailability = nullptr; directForwardingPathAvailability = std::nullopt;
handoverRequiredIEs = nullptr; handoverRequiredIEs = nullptr;
setMessageType(NgapMessageType::HANDOVER_REQUIRED); setMessageType(NgapMessageType::HANDOVER_REQUIRED);
...@@ -129,11 +129,11 @@ bool HandoverRequiredMsg::getPDUSessionResourceList( ...@@ -129,11 +129,11 @@ bool HandoverRequiredMsg::getPDUSessionResourceList(
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
long HandoverRequiredMsg::getDirectForwardingPathAvailability() { bool HandoverRequiredMsg::getDirectForwardingPathAvailability(
if (directForwardingPathAvailability) long& value) const {
return *directForwardingPathAvailability; if (directForwardingPathAvailability.has_value()) return false;
else value = directForwardingPathAvailability.value();
return 0; return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -237,10 +237,9 @@ bool HandoverRequiredMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) { ...@@ -237,10 +237,9 @@ bool HandoverRequiredMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
handoverRequiredIEs->protocolIEs.list.array[i]->value.present == handoverRequiredIEs->protocolIEs.list.array[i]->value.present ==
Ngap_HandoverRequiredIEs__value_PR_DirectForwardingPathAvailability) { Ngap_HandoverRequiredIEs__value_PR_DirectForwardingPathAvailability) {
directForwardingPathAvailability = directForwardingPathAvailability =
new Ngap_DirectForwardingPathAvailability_t(); std::optional<Ngap_DirectForwardingPathAvailability_t>(
*directForwardingPathAvailability = handoverRequiredIEs->protocolIEs.list.array[i]
handoverRequiredIEs->protocolIEs.list.array[i] ->value.choice.DirectForwardingPathAvailability);
->value.choice.DirectForwardingPathAvailability;
} else { } else {
Logger::ngap().error( Logger::ngap().error(
"Decoded NGAP DirectForwardingPathAvailability IE error"); "Decoded NGAP DirectForwardingPathAvailability IE error");
...@@ -252,7 +251,7 @@ bool HandoverRequiredMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) { ...@@ -252,7 +251,7 @@ bool HandoverRequiredMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
Ngap_Criticality_reject && Ngap_Criticality_reject &&
handoverRequiredIEs->protocolIEs.list.array[i]->value.present == handoverRequiredIEs->protocolIEs.list.array[i]->value.present ==
Ngap_HandoverRequiredIEs__value_PR_PDUSessionResourceListHORqd) { Ngap_HandoverRequiredIEs__value_PR_PDUSessionResourceListHORqd) {
if (!pDUSessionResourceList.decodefromPDUSessionResourceListHORqd( if (!pDUSessionResourceList.decode(
&handoverRequiredIEs->protocolIEs.list.array[i] &handoverRequiredIEs->protocolIEs.list.array[i]
->value.choice.PDUSessionResourceListHORqd)) { ->value.choice.PDUSessionResourceListHORqd)) {
Logger::ngap().error( Logger::ngap().error(
......
...@@ -28,6 +28,8 @@ ...@@ -28,6 +28,8 @@
#include "GlobalgNBId.hpp" #include "GlobalgNBId.hpp"
#include "TAI.hpp" #include "TAI.hpp"
#include <optional>
extern "C" { extern "C" {
#include "Ngap_HandoverRequired.h" #include "Ngap_HandoverRequired.h"
#include "Ngap_TargetID.h" #include "Ngap_TargetID.h"
...@@ -47,17 +49,23 @@ class HandoverRequiredMsg : public NgapUEMessage { ...@@ -47,17 +49,23 @@ class HandoverRequiredMsg : public NgapUEMessage {
bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override; bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
Ngap_HandoverType_t getHandoverType(); Ngap_HandoverType_t getHandoverType();
// TODO Setter
Ngap_Cause_PR getChoiceOfCause(); Ngap_Cause_PR getChoiceOfCause();
long getCauseValue(); long getCauseValue();
// TODO Setter
bool getTargetID(GlobalgNBId& gnbId, TAI& tai); bool getTargetID(GlobalgNBId& gnbId, TAI& tai);
// TODO Setter
long getDirectForwardingPathAvailability(); bool getDirectForwardingPathAvailability(long& value) const;
// TODO: Setter
bool getPDUSessionResourceList(PDUSessionResourceListHORqd& list); bool getPDUSessionResourceList(PDUSessionResourceListHORqd& list);
// TODO Setter
OCTET_STRING_t getSourceToTarget_TransparentContainer(); OCTET_STRING_t getSourceToTarget_TransparentContainer();
// TODO Setter
private: private:
Ngap_HandoverRequired_t* handoverRequiredIEs; Ngap_HandoverRequired_t* handoverRequiredIEs;
...@@ -66,7 +74,7 @@ class HandoverRequiredMsg : public NgapUEMessage { ...@@ -66,7 +74,7 @@ class HandoverRequiredMsg : public NgapUEMessage {
Ngap_HandoverType_t handoverType; // Mandatory Ngap_HandoverType_t handoverType; // Mandatory
Cause cause; // Mandatory Cause cause; // Mandatory
Ngap_TargetID_t targetID; // Mandatory Ngap_TargetID_t targetID; // Mandatory
Ngap_DirectForwardingPathAvailability_t* std::optional<Ngap_DirectForwardingPathAvailability_t>
directForwardingPathAvailability; // Optional directForwardingPathAvailability; // Optional
PDUSessionResourceListHORqd pDUSessionResourceList; // Mandatory PDUSessionResourceListHORqd pDUSessionResourceList; // Mandatory
Ngap_SourceToTarget_TransparentContainer_t Ngap_SourceToTarget_TransparentContainer_t
......
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