Commit 41822e76 authored by Tien-Thinh Nguyen's avatar Tien-Thinh Nguyen

Merge branch 'ngap_cleanup' into 'develop'

Code cleanup for NGAP messages

See merge request oai/cn5g/oai-cn5g-amf!119
parents 4d752f46 8aeef1a2
...@@ -27,6 +27,7 @@ ...@@ -27,6 +27,7 @@
*/ */
#include "amf_module_from_config.hpp" #include "amf_module_from_config.hpp"
#include "common_defs.h"
#include <iostream> #include <iostream>
#include <string> #include <string>
...@@ -58,7 +59,7 @@ int amf_modules::load(const std::string& config_file) { ...@@ -58,7 +59,7 @@ int amf_modules::load(const std::string& config_file) {
const Setting& modules = root[MODULES_CONFIG_STRING_AMF_MODULES]; const Setting& modules = root[MODULES_CONFIG_STRING_AMF_MODULES];
} catch (const SettingNotFoundException& nfex) { } catch (const SettingNotFoundException& nfex) {
Logger::amf_app().error("%s : %s", nfex.what(), nfex.getPath()); Logger::amf_app().error("%s : %s", nfex.what(), nfex.getPath());
return -1; return RETURNerror;
} }
const Setting& modules = root[MODULES_CONFIG_STRING_AMF_MODULES]; const Setting& modules = root[MODULES_CONFIG_STRING_AMF_MODULES];
const Setting& msg = modules[MODULES_CONFIG_STRING_AMF_MODULES_NGAP_MESSAGE]; const Setting& msg = modules[MODULES_CONFIG_STRING_AMF_MODULES_NGAP_MESSAGE];
......
This diff is collapsed.
...@@ -22,6 +22,7 @@ ...@@ -22,6 +22,7 @@
include_directories(${SRC_TOP_DIR}/common) include_directories(${SRC_TOP_DIR}/common)
include_directories(${SRC_TOP_DIR}/utils/) include_directories(${SRC_TOP_DIR}/utils/)
include_directories(${SRC_TOP_DIR}/utils/bstr) include_directories(${SRC_TOP_DIR}/utils/bstr)
include_directories(${SRC_TOP_DIR}/ngap/libngap)
include_directories(${SRC_TOP_DIR}/../build/ext/spdlog/include) include_directories(${SRC_TOP_DIR}/../build/ext/spdlog/include)
include_directories(${SRC_TOP_DIR}/common/unicode) include_directories(${SRC_TOP_DIR}/common/unicode)
file(GLOB COMMON_SRC ${SRC_TOP_DIR}/common/conversions.cpp) file(GLOB COMMON_SRC ${SRC_TOP_DIR}/common/conversions.cpp)
......
...@@ -32,10 +32,6 @@ ...@@ -32,10 +32,6 @@
#include <arpa/inet.h> #include <arpa/inet.h>
#include <stdint.h> #include <stdint.h>
#define RETURNclear (int) 2
#define RETURNerror (int) 1
#define RETURNok (int) 0
typedef enum { typedef enum {
/* Fatal errors - received message should not be processed */ /* Fatal errors - received message should not be processed */
TLV_MAC_MISMATCH = -14, TLV_MAC_MISMATCH = -14,
...@@ -52,12 +48,18 @@ typedef enum { ...@@ -52,12 +48,18 @@ typedef enum {
// RETURNerror = -1, // RETURNerror = -1,
// RETURNok = 0, // RETURNok = 0,
TLV_ERROR_OK = RETURNok, TLV_ERROR_OK = 0,
/* Defines error code limit below which received message should be discarded /* Defines error code limit below which received message should be discarded
* because it cannot be further processed */ * because it cannot be further processed */
TLV_FATAL_ERROR = TLV_VALUE_DOESNT_MATCH TLV_FATAL_ERROR = TLV_VALUE_DOESNT_MATCH
} error_code_e; } error_code_e;
typedef enum {
RETURNerror = -1,
RETURNok = 0,
} status_code_e;
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
#define DECODE_U8(bUFFER, vALUE, sIZE) \ #define DECODE_U8(bUFFER, vALUE, sIZE) \
vALUE = *(uint8_t*) (bUFFER); \ vALUE = *(uint8_t*) (bUFFER); \
......
...@@ -251,3 +251,14 @@ void conv::msg_str_2_msg_hex(std::string msg, bstring& b) { ...@@ -251,3 +251,14 @@ void conv::msg_str_2_msg_hex(std::string msg, bstring& b) {
conv::ascii_to_hex(msg_hex, (const char*) data); conv::ascii_to_hex(msg_hex, (const char*) data);
b = blk2bstr(msg_hex, (msg_len / 2)); b = blk2bstr(msg_hex, (msg_len / 2));
} }
//------------------------------------------------------------------------------
void conv::octet_string_2_bstring(
const OCTET_STRING_t& octet_str, bstring& b_str) {
b_str = blk2bstr(octet_str.buf, octet_str.size);
}
//------------------------------------------------------------------------------
void conv::bstring_2_octet_string(bstring& b_str, OCTET_STRING_t& octet_str) {
OCTET_STRING_fromBuf(&octet_str, (char*) bdata(b_str), blength(b_str));
}
...@@ -39,6 +39,7 @@ ...@@ -39,6 +39,7 @@
extern "C" { extern "C" {
#include "dynamic_memory_check.h" #include "dynamic_memory_check.h"
#include "OCTET_STRING.h"
} }
/* Used to format an uint32_t containing an ipv4 address */ /* Used to format an uint32_t containing an ipv4 address */
...@@ -70,5 +71,7 @@ class conv { ...@@ -70,5 +71,7 @@ class conv {
static unsigned char* format_string_as_hex(std::string str); static unsigned char* format_string_as_hex(std::string str);
static void convert_string_2_hex( static void convert_string_2_hex(
std::string& input_str, std::string& output_str); std::string& input_str, std::string& output_str);
void octet_string_2_bstring(const OCTET_STRING_t& octet_str, bstring& b_str);
void bstring_2_octet_string(bstring& b_str, OCTET_STRING_t& octet_str);
}; };
#endif /* FILE_CONVERSIONS_HPP_SEEN */ #endif /* FILE_CONVERSIONS_HPP_SEEN */
...@@ -46,7 +46,6 @@ typedef enum { ...@@ -46,7 +46,6 @@ typedef enum {
} ng_ue_state_t; } ng_ue_state_t;
class ue_ngap_context { class ue_ngap_context {
public:
public: public:
ue_ngap_context() { ue_ngap_context() {
ran_ue_ngap_id = 0; ran_ue_ngap_id = 0;
......
#NGAP Library - CODEOWNERS
Keliang DU, BUPT
Niuxiansheng Niu, BUPT
Tien Thinh NGUYEN, Eurecom
...@@ -69,7 +69,6 @@ bool AmfName::encode2AmfName(Ngap_AMFName_t* amfNameIe) { ...@@ -69,7 +69,6 @@ bool AmfName::encode2AmfName(Ngap_AMFName_t* amfNameIe) {
if (amfname) if (amfname)
if (OCTET_STRING_fromBuf(amfNameIe, amfname, strlen(amfname)) < 0) if (OCTET_STRING_fromBuf(amfNameIe, amfname, strlen(amfname)) < 0)
return false; return false;
return true; return true;
} }
......
...@@ -48,6 +48,11 @@ void AMFPointer::setAMFPointer(const std::string charPointer) { ...@@ -48,6 +48,11 @@ void AMFPointer::setAMFPointer(const std::string charPointer) {
pointer = fromString<int>(charPointer); pointer = fromString<int>(charPointer);
} }
//------------------------------------------------------------------------------
void AMFPointer::setAMFPointer(const uint8_t& p) {
pointer = p;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void AMFPointer::getAMFPointer(std::string& charPointer) { void AMFPointer::getAMFPointer(std::string& charPointer) {
charPointer = to_string(pointer); charPointer = to_string(pointer);
......
...@@ -44,6 +44,7 @@ class AMFPointer { ...@@ -44,6 +44,7 @@ class AMFPointer {
void setAMFPointer(const std::string); void setAMFPointer(const std::string);
void getAMFPointer(std::string&); void getAMFPointer(std::string&);
void setAMFPointer(const uint8_t&);
bool encode2bitstring(Ngap_AMFPointer_t&); bool encode2bitstring(Ngap_AMFPointer_t&);
bool decodefrombitstring(Ngap_AMFPointer_t&); bool decodefrombitstring(Ngap_AMFPointer_t&);
......
...@@ -48,6 +48,11 @@ void AMFRegionID::setAMFRegionID(const std::string charid) { ...@@ -48,6 +48,11 @@ void AMFRegionID::setAMFRegionID(const std::string charid) {
regionid = fromString<int>(charid); regionid = fromString<int>(charid);
} }
//------------------------------------------------------------------------------
void AMFRegionID::setAMFRegionID(const uint8_t& id) {
regionid = id;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void AMFRegionID::getAMFRegionID(std::string& charid) { void AMFRegionID::getAMFRegionID(std::string& charid) {
charid = to_string(regionid); charid = to_string(regionid);
......
...@@ -45,6 +45,8 @@ class AMFRegionID { ...@@ -45,6 +45,8 @@ class AMFRegionID {
void setAMFRegionID(const std::string); void setAMFRegionID(const std::string);
void getAMFRegionID(std::string&); void getAMFRegionID(std::string&);
void setAMFRegionID(const uint8_t&);
bool encode2bitstring(Ngap_AMFRegionID_t&); bool encode2bitstring(Ngap_AMFRegionID_t&);
bool decodefrombitstring(Ngap_AMFRegionID_t&); bool decodefrombitstring(Ngap_AMFRegionID_t&);
......
...@@ -19,69 +19,61 @@ ...@@ -19,69 +19,61 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "AMFSetID.hpp" #include "AMFSetID.hpp"
#include <iostream>
#include "String2Value.hpp" #include "String2Value.hpp"
using namespace std;
#include <string>
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
AMFSetID::AMFSetID() { AMFSetID::AMFSetID() {
setid = 0; setId = 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
AMFSetID::~AMFSetID() {} AMFSetID::~AMFSetID() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void AMFSetID::setAMFSetID(const std::string charid) { void AMFSetID::setAMFSetID(const std::string& charid) {
setid = fromString<uint16_t>(charid); setId = fromString<uint16_t>(charid);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void AMFSetID::setAMFSetID(const uint16_t set_id) { void AMFSetID::setAMFSetID(const uint16_t& set_id) {
setid = set_id; setId = set_id;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void AMFSetID::getAMFSetID(std::string& charid) { void AMFSetID::getAMFSetID(std::string& charid) {
charid = to_string(setid); charid = std::to_string(setId);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool AMFSetID::encode2bitstring(Ngap_AMFSetID_t& amfsetid) { bool AMFSetID::encode2bitstring(Ngap_AMFSetID_t& amfSetId) {
amfsetid.size = 2; amfSetId.size = 2;
uint8_t* buffer = (uint8_t*) calloc(1, sizeof(uint16_t)); uint8_t* buffer = (uint8_t*) calloc(1, sizeof(uint16_t));
if (!buffer) return false; if (!buffer) return false;
//*(uint16_t *)buffer = setid & 0x3ff; //*(uint16_t *)buffer = setId & 0x3ff;
buffer[0] = ((setid & 0x03fc) >> 2); buffer[0] = ((setId & 0x03fc) >> 2);
buffer[1] = ((setid & 0x0003) << 6); buffer[1] = ((setId & 0x0003) << 6);
amfsetid.buf = buffer; amfSetId.buf = buffer;
amfsetid.bits_unused = 6; amfSetId.bits_unused = 6;
return true; return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool AMFSetID::decodefrombitstring(Ngap_AMFSetID_t& amfsetid) { bool AMFSetID::decodefrombitstring(Ngap_AMFSetID_t& amfSetId) {
if (!amfsetid.buf) return false; if (!amfSetId.buf) return false;
for (int i = 0; i < amfsetid.size; i++) { for (int i = 0; i < amfSetId.size; i++) {
printf("%x ", amfsetid.buf[i]); printf("%x ", amfSetId.buf[i]);
} }
printf("\n"); printf("\n");
uint16_t temp = 0; uint16_t temp = 0;
temp |= amfsetid.buf[0] << 8; temp |= amfSetId.buf[0] << 8;
temp |= amfsetid.buf[1]; temp |= amfSetId.buf[1];
setid = (temp & 0xffc0) >> 6; // 1111 1111 11 00 0000 setId = (temp & 0xffc0) >> 6; // 1111 1111 11 00 0000
return true; return true;
} }
......
...@@ -18,16 +18,8 @@ ...@@ -18,16 +18,8 @@
* For more information about the OpenAirInterface (OAI) Software Alliance: * For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org * contact@openairinterface.org
*/ */
#ifndef _AMF_SET_ID_H_
/*! \file #define _AMF_SET_ID_H_
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _AMFSETID_H_
#define _AMFSETID_H_
#include <string> #include <string>
...@@ -42,15 +34,15 @@ class AMFSetID { ...@@ -42,15 +34,15 @@ class AMFSetID {
AMFSetID(); AMFSetID();
virtual ~AMFSetID(); virtual ~AMFSetID();
void setAMFSetID(const std::string); void setAMFSetID(const std::string&);
void setAMFSetID(const uint16_t set_id); void setAMFSetID(const uint16_t& set_id);
void getAMFSetID(std::string&); void getAMFSetID(std::string&);
bool encode2bitstring(Ngap_AMFSetID_t&); bool encode2bitstring(Ngap_AMFSetID_t&);
bool decodefrombitstring(Ngap_AMFSetID_t&); bool decodefrombitstring(Ngap_AMFSetID_t&);
private: private:
uint16_t setid; uint16_t setId;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,58 +19,37 @@ ...@@ -19,58 +19,37 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "AllowedNssai.hpp" #include "AllowedNssai.hpp"
extern "C" { extern "C" {
#include "Ngap_AllowedNSSAI-Item.h" #include "Ngap_AllowedNSSAI-Item.h"
// #include "Ngap_SliceSupportItem.h"
} }
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
AllowedNSSAI::AllowedNSSAI() { AllowedNSSAI::AllowedNSSAI() {}
snssai = nullptr;
numofSnssai = 0;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
AllowedNSSAI::~AllowedNSSAI() {} AllowedNSSAI::~AllowedNSSAI() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void AllowedNSSAI::setAllowedNSSAI(S_NSSAI* m_snssai, int m_numofsnssai) { void AllowedNSSAI::setAllowedNSSAI(const std::vector<S_NSSAI>& list) {
snssai = m_snssai; allowedSnssaiList = list;
numofSnssai = m_numofsnssai;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool AllowedNSSAI::getAllowedNSSAI(S_NSSAI*& m_snssai, int& m_numofsnssai) { void AllowedNSSAI::getAllowedNSSAI(std::vector<S_NSSAI>& list) {
m_snssai = snssai; list = allowedSnssaiList;
m_numofsnssai = numofSnssai;
if (!snssai) return false;
if (!numofSnssai) return false;
return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool AllowedNSSAI::encode2AllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList) { bool AllowedNSSAI::encode2AllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList) {
for (int i = 0; i < numofSnssai; i++) { for (std::vector<S_NSSAI>::iterator it = std::begin(allowedSnssaiList);
it < std::end(allowedSnssaiList); ++it) {
Ngap_AllowedNSSAI_Item_t* allowednssaiitem = Ngap_AllowedNSSAI_Item_t* allowednssaiitem =
(Ngap_AllowedNSSAI_Item_t*) calloc(1, sizeof(Ngap_AllowedNSSAI_Item_t)); (Ngap_AllowedNSSAI_Item_t*) calloc(1, sizeof(Ngap_AllowedNSSAI_Item_t));
if (!allowednssaiitem) return false; if (!allowednssaiitem) return false;
if (!snssai[i].encode2S_NSSAI(&allowednssaiitem->s_NSSAI)) return false; if (!it->encode2S_NSSAI(&allowednssaiitem->s_NSSAI)) return false;
if (ASN_SEQUENCE_ADD(&allowedNssaiList->list, allowednssaiitem) != 0) if (ASN_SEQUENCE_ADD(&allowedNssaiList->list, allowednssaiitem) != 0)
return false; return false;
} }
...@@ -80,11 +59,11 @@ bool AllowedNSSAI::encode2AllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList) { ...@@ -80,11 +59,11 @@ bool AllowedNSSAI::encode2AllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool AllowedNSSAI::decodefromAllowedNSSAI( bool AllowedNSSAI::decodefromAllowedNSSAI(
Ngap_AllowedNSSAI_t* allowedNssaiList) { Ngap_AllowedNSSAI_t* allowedNssaiList) {
numofSnssai = allowedNssaiList->list.count; for (int i = 0; i < allowedNssaiList->list.count; i++) {
snssai = new S_NSSAI[numofSnssai](); S_NSSAI snssai = {};
for (int i = 0; i < numofSnssai; i++) { if (!snssai.decodefromS_NSSAI(&allowedNssaiList->list.array[i]->s_NSSAI))
if (!snssai[i].decodefromS_NSSAI(&allowedNssaiList->list.array[i]->s_NSSAI))
return false; return false;
allowedSnssaiList.push_back(snssai);
} }
return true; return true;
} }
......
...@@ -19,17 +19,11 @@ ...@@ -19,17 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _ALLOWED_NSSAI_H_
\brief #define _ALLOWED_NSSAI_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _ALLOWEDNSSAI_H_
#define _ALLOWEDNSSAI_H_
#include "S-NSSAI.hpp" #include "S-NSSAI.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_AllowedNSSAI.h" #include "Ngap_AllowedNSSAI.h"
...@@ -42,14 +36,14 @@ class AllowedNSSAI { ...@@ -42,14 +36,14 @@ class AllowedNSSAI {
AllowedNSSAI(); AllowedNSSAI();
virtual ~AllowedNSSAI(); virtual ~AllowedNSSAI();
void setAllowedNSSAI(S_NSSAI* m_snssai, int m_numofsnssai); void setAllowedNSSAI(const std::vector<S_NSSAI>& list);
bool getAllowedNSSAI(S_NSSAI*& m_snssai, int& m_numofsnssai); void getAllowedNSSAI(std::vector<S_NSSAI>& list);
bool encode2AllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList); bool encode2AllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList);
bool decodefromAllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList); bool decodefromAllowedNSSAI(Ngap_AllowedNSSAI_t* allowedNssaiList);
private: private:
S_NSSAI* snssai; std::vector<S_NSSAI> allowedSnssaiList;
int numofSnssai;
}; };
} // namespace ngap } // namespace ngap
#endif #endif
...@@ -21,7 +21,7 @@ ...@@ -21,7 +21,7 @@
/*! \file /*! \file
\brief \brief
\author Keliang DU, BUPT \author
\date 2020 \date 2020
\email: contact@openairinterface.org \email: contact@openairinterface.org
*/ */
...@@ -42,42 +42,36 @@ using namespace std; ...@@ -42,42 +42,36 @@ using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
BroadcastPLMNItem::BroadcastPLMNItem() { BroadcastPLMNItem::BroadcastPLMNItem() {}
plmn = nullptr;
snssai = nullptr;
numOfSnssai = 0;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
BroadcastPLMNItem::~BroadcastPLMNItem() {} BroadcastPLMNItem::~BroadcastPLMNItem() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BroadcastPLMNItem::setPlmnSliceSupportList( void BroadcastPLMNItem::setPlmnSliceSupportList(
PlmnId* m_plmn, S_NSSAI* m_snssai, int num) { const PlmnId& m_plmn, const std::vector<S_NSSAI>& sliceList) {
plmn = m_plmn; plmn = m_plmn;
snssai = m_snssai; supportedSliceList = sliceList;
numOfSnssai = num;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BroadcastPLMNItem::getPlmnSliceSupportList( void BroadcastPLMNItem::getPlmnSliceSupportList(
PlmnId*& m_plmn, S_NSSAI*& m_snssai, int& snssainum) { PlmnId& m_plmn, std::vector<S_NSSAI>& sliceList) {
m_plmn = plmn; m_plmn = plmn;
m_snssai = snssai; sliceList = supportedSliceList;
snssainum = numOfSnssai;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool BroadcastPLMNItem::encode2BroadcastPLMNItem( bool BroadcastPLMNItem::encode2BroadcastPLMNItem(
Ngap_BroadcastPLMNItem_t* plmnItem) { Ngap_BroadcastPLMNItem_t* plmnItem) {
if (!plmn) return false; if (!plmn.encode2octetstring(plmnItem->pLMNIdentity)) return false;
if (!snssai) return false;
if (!plmn->encode2octetstring(plmnItem->pLMNIdentity)) return false; for (std::vector<S_NSSAI>::iterator it = std::begin(supportedSliceList);
for (int i = 0; i < numOfSnssai; i++) { it < std::end(supportedSliceList); ++it) {
Ngap_SliceSupportItem_t* slice = Ngap_SliceSupportItem_t* slice =
(Ngap_SliceSupportItem_t*) calloc(1, sizeof(Ngap_SliceSupportItem_t)); (Ngap_SliceSupportItem_t*) calloc(1, sizeof(Ngap_SliceSupportItem_t));
if (!slice) return false; if (!slice) return false;
if (!snssai[i].encode2S_NSSAI(&slice->s_NSSAI)) return false; if (!it->encode2S_NSSAI(&slice->s_NSSAI)) return false;
if (ASN_SEQUENCE_ADD(&plmnItem->tAISliceSupportList.list, slice) != 0) if (ASN_SEQUENCE_ADD(&plmnItem->tAISliceSupportList.list, slice) != 0)
return false; return false;
} }
...@@ -87,14 +81,13 @@ bool BroadcastPLMNItem::encode2BroadcastPLMNItem( ...@@ -87,14 +81,13 @@ bool BroadcastPLMNItem::encode2BroadcastPLMNItem(
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool BroadcastPLMNItem::decodefromBroadcastPLMNItem( bool BroadcastPLMNItem::decodefromBroadcastPLMNItem(
Ngap_BroadcastPLMNItem_t* pdu) { Ngap_BroadcastPLMNItem_t* pdu) {
if (plmn == nullptr) plmn = new PlmnId(); if (!plmn.decodefromoctetstring(pdu->pLMNIdentity)) return false;
if (!plmn->decodefromoctetstring(pdu->pLMNIdentity)) return false; for (int i = 0; i < pdu->tAISliceSupportList.list.count; i++) {
numOfSnssai = pdu->tAISliceSupportList.list.count; S_NSSAI snssai = {};
if (snssai == nullptr) snssai = new S_NSSAI[numOfSnssai](); if (!snssai.decodefromS_NSSAI(
for (int i = 0; i < numOfSnssai; i++) {
if (!snssai[i].decodefromS_NSSAI(
&pdu->tAISliceSupportList.list.array[i]->s_NSSAI)) &pdu->tAISliceSupportList.list.array[i]->s_NSSAI))
return false; return false;
supportedSliceList.push_back(snssai);
} }
return true; return true;
} }
......
...@@ -31,6 +31,7 @@ ...@@ -31,6 +31,7 @@
#include "PlmnId.hpp" #include "PlmnId.hpp"
#include "S-NSSAI.hpp" #include "S-NSSAI.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_BroadcastPLMNItem.h" #include "Ngap_BroadcastPLMNItem.h"
...@@ -43,16 +44,17 @@ class BroadcastPLMNItem { ...@@ -43,16 +44,17 @@ class BroadcastPLMNItem {
BroadcastPLMNItem(); BroadcastPLMNItem();
virtual ~BroadcastPLMNItem(); virtual ~BroadcastPLMNItem();
void setPlmnSliceSupportList(PlmnId* m_plmn, S_NSSAI* snssai, int num); void setPlmnSliceSupportList(
void getPlmnSliceSupportList( const PlmnId& m_plmn, const std::vector<S_NSSAI>& sliceList);
PlmnId*& m_plmn, S_NSSAI*& m_snssai, int& snssainum); void getPlmnSliceSupportList(PlmnId& m_plmn, std::vector<S_NSSAI>& sliceList);
bool encode2BroadcastPLMNItem(Ngap_BroadcastPLMNItem_t*); bool encode2BroadcastPLMNItem(Ngap_BroadcastPLMNItem_t*);
bool decodefromBroadcastPLMNItem(Ngap_BroadcastPLMNItem_t* pdu); bool decodefromBroadcastPLMNItem(Ngap_BroadcastPLMNItem_t* pdu);
private: private:
PlmnId* plmn; PlmnId plmn; // Mandatory
S_NSSAI* snssai; std::vector<S_NSSAI> supportedSliceList; // TAI Slice Support List
int numOfSnssai; // (Mandatory)
}; };
} // namespace ngap } // namespace ngap
#endif #endif
...@@ -27,9 +27,8 @@ extern "C" { ...@@ -27,9 +27,8 @@ extern "C" {
namespace ngap { namespace ngap {
class COUNTValueForPDCP_SN18 { class COUNTValueForPDCP_SN18 {
private: private:
/* data */ long pdcp; // Mandatory (18 bits)
long pdcp; long hfn_pdcp; // Mandatory (14 bits)
long hfn_pdcp;
public: public:
COUNTValueForPDCP_SN18(/* args */); COUNTValueForPDCP_SN18(/* args */);
......
...@@ -39,12 +39,8 @@ namespace ngap { ...@@ -39,12 +39,8 @@ namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
CoreNetworkAssistanceInfo::CoreNetworkAssistanceInfo() { CoreNetworkAssistanceInfo::CoreNetworkAssistanceInfo() {
ueIdentityIndexValue = nullptr; pagingDRX = nullptr;
pagingDRX = nullptr; micoModeInd = nullptr;
periodicRegUpdateTimer = nullptr;
micoModeInd = nullptr;
tai = nullptr;
numoftai = 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -52,52 +48,58 @@ CoreNetworkAssistanceInfo::~CoreNetworkAssistanceInfo() {} ...@@ -52,52 +48,58 @@ CoreNetworkAssistanceInfo::~CoreNetworkAssistanceInfo() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void CoreNetworkAssistanceInfo::setCoreNetworkAssistanceInfo( void CoreNetworkAssistanceInfo::setCoreNetworkAssistanceInfo(
UEIdentityIndexValue* m_ueIdentityIndexValue, DefaultPagingDRX* m_pagingDRX, const UEIdentityIndexValue& m_ueIdentityIndexValue,
PeriodicRegistrationUpdateTimer* m_periodicRegUpdateTimer, DefaultPagingDRX* m_pagingDRX,
bool m_micoModeInd, TAI* m_tai, int m_numoftai) { const PeriodicRegistrationUpdateTimer& m_periodicRegUpdateTimer,
const bool& m_micoModeInd, const std::vector<TAI>& m_tai) {
ueIdentityIndexValue = m_ueIdentityIndexValue; ueIdentityIndexValue = m_ueIdentityIndexValue;
pagingDRX = m_pagingDRX; pagingDRX = m_pagingDRX;
periodicRegUpdateTimer = m_periodicRegUpdateTimer; periodicRegUpdateTimer = m_periodicRegUpdateTimer;
if (m_micoModeInd) micoModeInd = new MICOModeIndication(); if (m_micoModeInd) {
tai = m_tai; micoModeInd = new MICOModeIndication();
numoftai = m_numoftai; }
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void CoreNetworkAssistanceInfo::setCoreNetworkAssistanceInfo( void CoreNetworkAssistanceInfo::getCoreNetworkAssistanceInfo(
UEIdentityIndexValue* m_ueIdentityIndexValue, UEIdentityIndexValue& m_ueIdentityIndexValue,
PeriodicRegistrationUpdateTimer* m_periodicRegUpdateTimer, DefaultPagingDRX*& m_pagingDRX,
bool m_micoModeInd, TAI* m_tai, int m_numoftai) { PeriodicRegistrationUpdateTimer& m_periodicRegUpdateTimer,
ueIdentityIndexValue = m_ueIdentityIndexValue; bool& m_micoModeInd, std::vector<TAI>& m_tai) {
periodicRegUpdateTimer = m_periodicRegUpdateTimer; m_ueIdentityIndexValue = ueIdentityIndexValue;
if (m_micoModeInd) micoModeInd = new MICOModeIndication(); m_pagingDRX = pagingDRX;
tai = m_tai; m_periodicRegUpdateTimer = periodicRegUpdateTimer;
numoftai = m_numoftai; if (micoModeInd)
m_micoModeInd = true;
else
m_micoModeInd = false;
m_tai = taiList;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool CoreNetworkAssistanceInfo::encode2CoreNetworkAssistanceInfo( bool CoreNetworkAssistanceInfo::encode2CoreNetworkAssistanceInfo(
Ngap_CoreNetworkAssistanceInformation_t* coreNetworkAssistanceInformation) { Ngap_CoreNetworkAssistanceInformation_t* coreNetworkAssistanceInformation) {
if (!ueIdentityIndexValue) return false; if (!ueIdentityIndexValue.encode2UEIdentityIndexValue(
if (!ueIdentityIndexValue->encode2UEIdentityIndexValue(
&coreNetworkAssistanceInformation->uEIdentityIndexValue)) &coreNetworkAssistanceInformation->uEIdentityIndexValue))
return false; return false;
if (!periodicRegUpdateTimer) return false;
if (!periodicRegUpdateTimer->encode2PeriodicRegistrationUpdateTimer( if (!periodicRegUpdateTimer.encode2PeriodicRegistrationUpdateTimer(
&coreNetworkAssistanceInformation->periodicRegistrationUpdateTimer)) &coreNetworkAssistanceInformation->periodicRegistrationUpdateTimer))
return false; return false;
if (!tai) return false;
for (int i = 0; i < numoftai; i++) { for (std::vector<TAI>::iterator it = std::begin(taiList);
it < std::end(taiList); ++it) {
Ngap_TAIListForInactiveItem_t* taiListForInactiveItem = Ngap_TAIListForInactiveItem_t* taiListForInactiveItem =
(Ngap_TAIListForInactiveItem_t*) calloc( (Ngap_TAIListForInactiveItem_t*) calloc(
1, sizeof(Ngap_TAIListForInactiveItem_t)); 1, sizeof(Ngap_TAIListForInactiveItem_t));
if (!taiListForInactiveItem) return false; if (!taiListForInactiveItem) return false;
if (!tai[i].encode2TAI(&taiListForInactiveItem->tAI)) return false; if (!it->encode2TAI(&taiListForInactiveItem->tAI)) return false;
if (ASN_SEQUENCE_ADD( if (ASN_SEQUENCE_ADD(
&coreNetworkAssistanceInformation->tAIListForInactive.list, &coreNetworkAssistanceInformation->tAIListForInactive.list,
taiListForInactiveItem) != 0) taiListForInactiveItem) != 0)
return false; return false;
} }
if (pagingDRX) { if (pagingDRX) {
Ngap_PagingDRX_t* pagingdrx = Ngap_PagingDRX_t* pagingdrx =
(Ngap_PagingDRX_t*) calloc(1, sizeof(Ngap_PagingDRX_t)); (Ngap_PagingDRX_t*) calloc(1, sizeof(Ngap_PagingDRX_t));
...@@ -105,6 +107,7 @@ bool CoreNetworkAssistanceInfo::encode2CoreNetworkAssistanceInfo( ...@@ -105,6 +107,7 @@ bool CoreNetworkAssistanceInfo::encode2CoreNetworkAssistanceInfo(
if (!pagingDRX->encode2DefaultPagingDRX(*pagingdrx)) return false; if (!pagingDRX->encode2DefaultPagingDRX(*pagingdrx)) return false;
coreNetworkAssistanceInformation->uESpecificDRX = pagingdrx; coreNetworkAssistanceInformation->uESpecificDRX = pagingdrx;
} }
if (micoModeInd) { if (micoModeInd) {
Ngap_MICOModeIndication_t* micomodeindication = Ngap_MICOModeIndication_t* micomodeindication =
(Ngap_MICOModeIndication_t*) calloc( (Ngap_MICOModeIndication_t*) calloc(
...@@ -121,30 +124,32 @@ bool CoreNetworkAssistanceInfo::encode2CoreNetworkAssistanceInfo( ...@@ -121,30 +124,32 @@ bool CoreNetworkAssistanceInfo::encode2CoreNetworkAssistanceInfo(
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool CoreNetworkAssistanceInfo::decodefromCoreNetworkAssistanceInfo( bool CoreNetworkAssistanceInfo::decodefromCoreNetworkAssistanceInfo(
Ngap_CoreNetworkAssistanceInformation_t* coreNetworkAssistanceInformation) { Ngap_CoreNetworkAssistanceInformation_t* coreNetworkAssistanceInformation) {
if (ueIdentityIndexValue == nullptr) if (!ueIdentityIndexValue.decodefromUEIdentityIndexValue(
ueIdentityIndexValue = new UEIdentityIndexValue();
if (periodicRegUpdateTimer == nullptr)
periodicRegUpdateTimer = new PeriodicRegistrationUpdateTimer();
if (!ueIdentityIndexValue->decodefromUEIdentityIndexValue(
&coreNetworkAssistanceInformation->uEIdentityIndexValue)) &coreNetworkAssistanceInformation->uEIdentityIndexValue))
return false; return false;
if (!periodicRegUpdateTimer->decodefromPeriodicRegistrationUpdateTimer(
if (!periodicRegUpdateTimer.decodefromPeriodicRegistrationUpdateTimer(
&coreNetworkAssistanceInformation->periodicRegistrationUpdateTimer)) &coreNetworkAssistanceInformation->periodicRegistrationUpdateTimer))
return false; return false;
numoftai = coreNetworkAssistanceInformation->tAIListForInactive.list.count;
if (tai == nullptr) tai = new TAI[numoftai](); for (int i = 0;
for (int i = 0; i < numoftai; i++) { i < coreNetworkAssistanceInformation->tAIListForInactive.list.count;
if (!tai[i].decodefromTAI( i++) {
TAI tai_item = {};
if (!tai_item.decodefromTAI(
&coreNetworkAssistanceInformation->tAIListForInactive.list.array[i] &coreNetworkAssistanceInformation->tAIListForInactive.list.array[i]
->tAI)) ->tAI))
return false; return false;
taiList.push_back(tai_item);
} }
if (coreNetworkAssistanceInformation->uESpecificDRX) { if (coreNetworkAssistanceInformation->uESpecificDRX) {
if (pagingDRX == nullptr) pagingDRX = new DefaultPagingDRX(); if (pagingDRX == nullptr) pagingDRX = new DefaultPagingDRX();
if (!pagingDRX->decodefromDefaultPagingDRX( if (!pagingDRX->decodefromDefaultPagingDRX(
*(coreNetworkAssistanceInformation->uESpecificDRX))) *(coreNetworkAssistanceInformation->uESpecificDRX)))
return false; return false;
} }
if (coreNetworkAssistanceInformation->mICOModeIndication) { if (coreNetworkAssistanceInformation->mICOModeIndication) {
if (micoModeInd == nullptr) micoModeInd = new MICOModeIndication(); if (micoModeInd == nullptr) micoModeInd = new MICOModeIndication();
if (!micoModeInd->decodefromMICOModeIndication( if (!micoModeInd->decodefromMICOModeIndication(
...@@ -155,20 +160,4 @@ bool CoreNetworkAssistanceInfo::decodefromCoreNetworkAssistanceInfo( ...@@ -155,20 +160,4 @@ bool CoreNetworkAssistanceInfo::decodefromCoreNetworkAssistanceInfo(
return true; return true;
} }
//------------------------------------------------------------------------------
void CoreNetworkAssistanceInfo::getCoreNetworkAssistanceInfo(
UEIdentityIndexValue*& m_ueIdentityIndexValue,
DefaultPagingDRX*& m_pagingDRX,
PeriodicRegistrationUpdateTimer*& m_periodicRegUpdateTimer,
bool& m_micoModeInd, TAI*& m_tai, int& m_numoftai) {
m_ueIdentityIndexValue = ueIdentityIndexValue;
m_pagingDRX = pagingDRX;
m_periodicRegUpdateTimer = periodicRegUpdateTimer;
if (micoModeInd)
m_micoModeInd = true;
else
m_micoModeInd = false;
m_tai = tai;
m_numoftai = numoftai;
}
} // namespace ngap } // namespace ngap
...@@ -47,19 +47,16 @@ class CoreNetworkAssistanceInfo { ...@@ -47,19 +47,16 @@ class CoreNetworkAssistanceInfo {
virtual ~CoreNetworkAssistanceInfo(); virtual ~CoreNetworkAssistanceInfo();
void setCoreNetworkAssistanceInfo( void setCoreNetworkAssistanceInfo(
UEIdentityIndexValue* m_ueIdentityIndexValue, const UEIdentityIndexValue& m_ueIdentityIndexValue,
DefaultPagingDRX* m_pagingDRX, DefaultPagingDRX* m_pagingDRX,
PeriodicRegistrationUpdateTimer* m_periodicRegUpdateTimer, const PeriodicRegistrationUpdateTimer& m_periodicRegUpdateTimer,
bool m_micoModeInd, TAI* m_tai, int m_numoftai); const bool& m_micoModeInd, const std::vector<TAI>& m_tai);
void setCoreNetworkAssistanceInfo(
UEIdentityIndexValue* m_ueIdentityIndexValue,
PeriodicRegistrationUpdateTimer* m_periodicRegUpdateTimer,
bool m_micoModeInd, TAI* m_tai, int m_numoftai);
void getCoreNetworkAssistanceInfo( void getCoreNetworkAssistanceInfo(
UEIdentityIndexValue*& m_ueIdentityIndexValue, UEIdentityIndexValue& m_ueIdentityIndexValue,
DefaultPagingDRX*& m_pagingDRX, DefaultPagingDRX*& m_pagingDRX,
PeriodicRegistrationUpdateTimer*& m_periodicRegUpdateTimer, PeriodicRegistrationUpdateTimer& m_periodicRegUpdateTimer,
bool& m_micoModeInd, TAI*& m_tai, int& m_numoftai); bool& m_micoModeInd, std::vector<TAI>& m_tai);
bool encode2CoreNetworkAssistanceInfo(Ngap_CoreNetworkAssistanceInformation_t* bool encode2CoreNetworkAssistanceInfo(Ngap_CoreNetworkAssistanceInformation_t*
coreNetworkAssistanceInformation); coreNetworkAssistanceInformation);
...@@ -68,12 +65,13 @@ class CoreNetworkAssistanceInfo { ...@@ -68,12 +65,13 @@ class CoreNetworkAssistanceInfo {
coreNetworkAssistanceInformation); coreNetworkAssistanceInformation);
private: private:
UEIdentityIndexValue* ueIdentityIndexValue; UEIdentityIndexValue ueIdentityIndexValue; // Mandatory
DefaultPagingDRX* pagingDRX; DefaultPagingDRX* pagingDRX; // UE Specific DRX, Optional
PeriodicRegistrationUpdateTimer* periodicRegUpdateTimer; PeriodicRegistrationUpdateTimer periodicRegUpdateTimer; // Mandatory
MICOModeIndication* micoModeInd; MICOModeIndication* micoModeInd; // Optional
TAI* tai; std::vector<TAI> taiList; // Mandatory
int numoftai; // int numoftai;
// TODO: Expected UE Behaviour (Optional)
}; };
} // namespace ngap } // namespace ngap
......
...@@ -66,8 +66,9 @@ void FiveGSTmsi::getValue( ...@@ -66,8 +66,9 @@ void FiveGSTmsi::getValue(
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void FiveGSTmsi::setValue( void FiveGSTmsi::setValue(
std::string& setid, std::string& pointer, std::string& tmsi) { const std::string& setId, const std::string& pointer,
amfSetid.setAMFSetID(setid); const std::string& tmsi) {
amfSetid.setAMFSetID(setId);
amfPointer.setAMFPointer(pointer); amfPointer.setAMFPointer(pointer);
_5g_s_tmsi = tmsi; _5g_s_tmsi = tmsi;
} }
......
...@@ -47,8 +47,10 @@ class FiveGSTmsi { ...@@ -47,8 +47,10 @@ class FiveGSTmsi {
public: public:
bool decodefrompdu(Ngap_FiveG_S_TMSI_t pdu); bool decodefrompdu(Ngap_FiveG_S_TMSI_t pdu);
void getValue(std::string& value); void getValue(std::string& value);
void getValue(std::string& setid, std::string& pointer, std::string& tmsi); void getValue(std::string& setId, std::string& pointer, std::string& tmsi);
void setValue(std::string& setid, std::string& pointer, std::string& tmsi); void setValue(
const std::string& setId, const std::string& pointer,
const std::string& tmsi);
bool encode2pdu(Ngap_FiveG_S_TMSI_t* pdu); bool encode2pdu(Ngap_FiveG_S_TMSI_t* pdu);
private: private:
......
...@@ -34,57 +34,79 @@ using namespace std; ...@@ -34,57 +34,79 @@ using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
GUAMI::GUAMI() { GUAMI::GUAMI() {}
plmnId = NULL;
aMFRegionID = NULL;
aMFSetID = NULL;
aMFPointer = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
GUAMI::~GUAMI() {} GUAMI::~GUAMI() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void GUAMI::setGUAMI( void GUAMI::setGUAMI(
PlmnId* m_plmnId, AMFRegionID* m_aMFRegionID, AMFSetID* m_aMFSetID, const PlmnId& m_plmnId, const AMFRegionID& m_aMFRegionID,
AMFPointer* m_aMFPointer) { const AMFSetID& m_aMFSetID, const AMFPointer& m_aMFPointer) {
plmnId = m_plmnId; plmnId = m_plmnId;
aMFRegionID = m_aMFRegionID; aMFRegionID = m_aMFRegionID;
aMFSetID = m_aMFSetID; aMFSetID = m_aMFSetID;
aMFPointer = m_aMFPointer; aMFPointer = m_aMFPointer;
} }
//------------------------------------------------------------------------------
void GUAMI::setGUAMI(
const std::string& mcc, const std::string& mnc, const uint8_t& regionId,
const uint16_t& setId, const uint8_t& pointer) {
plmnId.setMccMnc(mcc, mnc);
aMFRegionID.setAMFRegionID(regionId);
aMFSetID.setAMFSetID(setId);
aMFPointer.setAMFPointer(pointer);
}
//------------------------------------------------------------------------------
void GUAMI::setGUAMI(
const std::string& mcc, const std::string& mnc, const std::string& regionId,
const std::string& setId, const std::string& pointer) {
plmnId.setMccMnc(mcc, mnc);
aMFRegionID.setAMFRegionID(regionId);
aMFSetID.setAMFSetID(setId);
aMFPointer.setAMFPointer(pointer);
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool GUAMI::encode2GUAMI(Ngap_GUAMI_t* guami) { bool GUAMI::encode2GUAMI(Ngap_GUAMI_t* guami) {
if (!plmnId->encode2octetstring(guami->pLMNIdentity)) return false; if (!plmnId.encode2octetstring(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;
return true; return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool GUAMI::decodefromGUAMI(Ngap_GUAMI_t* pdu) { bool GUAMI::decodefromGUAMI(Ngap_GUAMI_t* pdu) {
if (plmnId == nullptr) plmnId = new PlmnId(); if (!plmnId.decodefromoctetstring(pdu->pLMNIdentity)) return false;
if (aMFRegionID == nullptr) aMFRegionID = new AMFRegionID(); if (!aMFRegionID.decodefrombitstring(pdu->aMFRegionID)) return false;
if (aMFSetID == nullptr) aMFSetID = new AMFSetID(); if (!aMFSetID.decodefrombitstring(pdu->aMFSetID)) return false;
if (aMFPointer == nullptr) aMFPointer = new AMFPointer(); if (!aMFPointer.decodefrombitstring(pdu->aMFPointer)) return false;
if (!plmnId->decodefromoctetstring(pdu->pLMNIdentity)) return false;
if (!aMFRegionID->decodefrombitstring(pdu->aMFRegionID)) return false;
if (!aMFSetID->decodefrombitstring(pdu->aMFSetID)) return false;
if (!aMFPointer->decodefrombitstring(pdu->aMFPointer)) return false;
return true; return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void GUAMI::getGUAMI( void GUAMI::getGUAMI(
PlmnId*& m_plmnId, AMFRegionID*& m_aMFRegionID, AMFSetID*& m_aMFSetID, PlmnId& m_plmnId, AMFRegionID& m_aMFRegionID, AMFSetID& m_aMFSetID,
AMFPointer*& m_aMFPointer) { AMFPointer& m_aMFPointer) {
m_plmnId = plmnId; m_plmnId = plmnId;
m_aMFRegionID = aMFRegionID; m_aMFRegionID = aMFRegionID;
m_aMFSetID = aMFSetID; m_aMFSetID = aMFSetID;
m_aMFPointer = aMFPointer; m_aMFPointer = aMFPointer;
} }
void GUAMI::getGUAMI(
std::string& mcc, std::string& mnc, std::string& regionId,
std::string& setId, std::string& pointer) {
plmnId.getMcc(mcc);
plmnId.getMnc(mnc);
aMFRegionID.getAMFRegionID(regionId);
aMFSetID.getAMFSetID(setId);
aMFPointer.getAMFPointer(pointer);
}
} // namespace ngap } // namespace ngap
...@@ -46,20 +46,32 @@ class GUAMI { ...@@ -46,20 +46,32 @@ class GUAMI {
virtual ~GUAMI(); virtual ~GUAMI();
void setGUAMI( void setGUAMI(
PlmnId* m_plmnId, AMFRegionID* m_aMFRegionID, AMFSetID* m_aMFSetID, const PlmnId& m_plmnId, const AMFRegionID& m_aMFRegionID,
AMFPointer* m_aMFPointer); const AMFSetID& m_aMFSetID, const AMFPointer& m_aMFPointer);
void setGUAMI(
const std::string& mcc, const std::string& mnc, const uint8_t& regionId,
const uint16_t& setId, const uint8_t& pointer);
void setGUAMI(
const std::string& mcc, const std::string& mnc,
const std::string& regionId, const std::string& setId,
const std::string& pointer);
void getGUAMI(
PlmnId& m_plmnId, AMFRegionID& m_aMFRegionID, AMFSetID& m_aMFSetID,
AMFPointer& m_aMFPointer);
void getGUAMI( void getGUAMI(
PlmnId*& m_plmnId, AMFRegionID*& m_aMFRegionID, AMFSetID*& m_aMFSetID, std::string& mcc, std::string& mnc, std::string& regionId,
AMFPointer*& m_aMFPointer); std::string& setId, std::string& pointer);
bool encode2GUAMI(Ngap_GUAMI_t* guami); bool encode2GUAMI(Ngap_GUAMI_t* guami);
bool decodefromGUAMI(Ngap_GUAMI_t* pdu); bool decodefromGUAMI(Ngap_GUAMI_t* pdu);
private: private:
PlmnId* plmnId; PlmnId plmnId; // Mandatory
AMFRegionID* aMFRegionID; AMFRegionID aMFRegionID; // Mandatory
AMFSetID* aMFSetID; AMFSetID aMFSetID; // Mandatory
AMFPointer* aMFPointer; AMFPointer aMFPointer; // Mandatory
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,31 +19,20 @@ ...@@ -19,31 +19,20 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "GlobalRanNodeId.hpp" #include "GlobalRanNodeId.hpp"
#include "logger.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
GlobalRanNodeId::GlobalRanNodeId() { GlobalRanNodeId::GlobalRanNodeId() {}
globalgNBId = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
GlobalRanNodeId::~GlobalRanNodeId() {} GlobalRanNodeId::~GlobalRanNodeId() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void GlobalRanNodeId::setChoiceOfRanNodeId( void GlobalRanNodeId::setChoiceOfRanNodeId(
Ngap_GlobalRANNodeID_PR m_idPresent) { const Ngap_GlobalRANNodeID_PR& m_idPresent) {
idPresent = m_idPresent; idPresent = m_idPresent;
} }
...@@ -53,13 +42,13 @@ Ngap_GlobalRANNodeID_PR GlobalRanNodeId::getChoiceOfRanNodeId() { ...@@ -53,13 +42,13 @@ Ngap_GlobalRANNodeID_PR GlobalRanNodeId::getChoiceOfRanNodeId() {
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void GlobalRanNodeId::setGlobalgNBID(GlobalgNBId* m_globalgNBId) { void GlobalRanNodeId::setGlobalgNBID(const GlobalgNBId& m_globalgNBId) {
globalgNBId = m_globalgNBId; globalgNBId = m_globalgNBId;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void GlobalRanNodeId::getGlobalgNBID(GlobalgNBId*& ptr) { void GlobalRanNodeId::getGlobalgNBID(GlobalgNBId& id) {
ptr = globalgNBId; id = globalgNBId;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -72,7 +61,7 @@ bool GlobalRanNodeId::encode2GlobalRANNodeID( ...@@ -72,7 +61,7 @@ bool GlobalRanNodeId::encode2GlobalRANNodeID(
Ngap_GlobalGNB_ID_t* globalGNB_ID = Ngap_GlobalGNB_ID_t* globalGNB_ID =
(Ngap_GlobalGNB_ID_t*) calloc(1, sizeof(struct Ngap_GlobalGNB_ID)); (Ngap_GlobalGNB_ID_t*) calloc(1, sizeof(struct Ngap_GlobalGNB_ID));
if (!globalGNB_ID) return false; if (!globalGNB_ID) return false;
if (!globalgNBId->encode2GlobalgNBId(globalGNB_ID)) return false; if (!globalgNBId.encode2GlobalgNBId(globalGNB_ID)) return false;
globalRANNodeID->choice.globalGNB_ID = globalGNB_ID; globalRANNodeID->choice.globalGNB_ID = globalGNB_ID;
break; break;
} }
...@@ -83,7 +72,7 @@ bool GlobalRanNodeId::encode2GlobalRANNodeID( ...@@ -83,7 +72,7 @@ bool GlobalRanNodeId::encode2GlobalRANNodeID(
break; break;
} }
default: default:
cout << "[Warning] GlobalRanNodeId Present encode error!" << endl; Logger::ngap().warn("GlobalRanNodeId Present encode error!");
return false; return false;
} }
return true; return true;
...@@ -95,22 +84,21 @@ bool GlobalRanNodeId::decodefromGlobalRANNodeID( ...@@ -95,22 +84,21 @@ bool GlobalRanNodeId::decodefromGlobalRANNodeID(
idPresent = globalRANNodeID->present; idPresent = globalRANNodeID->present;
switch (idPresent) { switch (idPresent) {
case Ngap_GlobalRANNodeID_PR_globalGNB_ID: { case Ngap_GlobalRANNodeID_PR_globalGNB_ID: {
globalgNBId = new GlobalgNBId(); if (!globalgNBId.decodefromGlobalgNBId(
if (!globalgNBId->decodefromGlobalgNBId(
globalRANNodeID->choice.globalGNB_ID)) globalRANNodeID->choice.globalGNB_ID))
return false; return false;
break; break;
} }
case Ngap_GlobalRANNodeID_PR_globalNgENB_ID: { case Ngap_GlobalRANNodeID_PR_globalNgENB_ID: {
cout << "[Warning] GlobalRANNodeID Present is globalNgENB!" << endl; Logger::ngap().warn("GlobalRANNodeID Present is globalNgENB!");
break; break;
} }
case Ngap_GlobalRANNodeID_PR_globalN3IWF_ID: { case Ngap_GlobalRANNodeID_PR_globalN3IWF_ID: {
cout << "[Warning] GlobalRanNodeId Present is globalN3IWF!" << endl; Logger::ngap().warn("GlobalRANNodeID Present is globalN3IWF!");
break; break;
} }
default: default:
cout << "[Warning] GlobalRanNodeId Present decode error!" << endl; Logger::ngap().warn("GlobalRanNodeId Present decode error!");
return false; return false;
} }
return true; return true;
......
...@@ -19,15 +19,8 @@ ...@@ -19,15 +19,8 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _GLOBAL_RAN_NODE_ID_H_
\brief #define _GLOBAL_RAN_NODE_ID_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _GLOBALRANNODEID_H_
#define _GLOBALRANNODEID_H_
extern "C" { extern "C" {
#include "Ngap_GlobalRANNodeID.h" #include "Ngap_GlobalRANNodeID.h"
...@@ -42,15 +35,17 @@ class GlobalRanNodeId { ...@@ -42,15 +35,17 @@ class GlobalRanNodeId {
GlobalRanNodeId(); GlobalRanNodeId();
virtual ~GlobalRanNodeId(); virtual ~GlobalRanNodeId();
void setChoiceOfRanNodeId(Ngap_GlobalRANNodeID_PR m_idPresent); void setChoiceOfRanNodeId(const Ngap_GlobalRANNodeID_PR& m_idPresent);
void setGlobalgNBID(GlobalgNBId*); Ngap_GlobalRANNodeID_PR getChoiceOfRanNodeId();
void setGlobalgNBID(const GlobalgNBId&);
void getGlobalgNBID(GlobalgNBId&);
bool encode2GlobalRANNodeID(Ngap_GlobalRANNodeID_t*); bool encode2GlobalRANNodeID(Ngap_GlobalRANNodeID_t*);
bool decodefromGlobalRANNodeID(Ngap_GlobalRANNodeID_t*); bool decodefromGlobalRANNodeID(Ngap_GlobalRANNodeID_t*);
Ngap_GlobalRANNodeID_PR getChoiceOfRanNodeId();
void getGlobalgNBID(GlobalgNBId*&);
private: private:
GlobalgNBId* globalgNBId; GlobalgNBId globalgNBId; // Mandatory
Ngap_GlobalRANNodeID_PR idPresent; Ngap_GlobalRANNodeID_PR idPresent;
}; };
......
...@@ -19,56 +19,41 @@ ...@@ -19,56 +19,41 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "GlobalgNBId.hpp" #include "GlobalgNBId.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
GlobalgNBId::GlobalgNBId() { GlobalgNBId::GlobalgNBId() {}
plmnId = NULL;
gNB_ID = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
GlobalgNBId::~GlobalgNBId() {} GlobalgNBId::~GlobalgNBId() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void GlobalgNBId::setGlobalgNBId(PlmnId* plmn, GNB_ID* gnbid) { void GlobalgNBId::setGlobalgNBId(const PlmnId& plmn, const GNB_ID& gnbid) {
plmnId = plmn; plmnId = plmn;
gNB_ID = gnbid; gNB_ID = gnbid;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool GlobalgNBId::encode2GlobalgNBId(Ngap_GlobalGNB_ID_t* globalgnbid) { bool GlobalgNBId::encode2GlobalgNBId(Ngap_GlobalGNB_ID_t* globalgnbid) {
if (!plmnId->encode2octetstring(globalgnbid->pLMNIdentity)) return false; if (!plmnId.encode2octetstring(globalgnbid->pLMNIdentity)) return false;
if (!gNB_ID->encode2bitstring(globalgnbid->gNB_ID)) return false; if (!gNB_ID.encode2bitstring(globalgnbid->gNB_ID)) return false;
return true; return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool GlobalgNBId::decodefromGlobalgNBId(Ngap_GlobalGNB_ID_t* globalgnbid) { bool GlobalgNBId::decodefromGlobalgNBId(Ngap_GlobalGNB_ID_t* globalgnbid) {
if (plmnId == nullptr) plmnId = new PlmnId(); if (!plmnId.decodefromoctetstring(globalgnbid->pLMNIdentity)) return false;
if (gNB_ID == nullptr) gNB_ID = new GNB_ID(); if (!gNB_ID.decodefrombitstring(globalgnbid->gNB_ID)) return false;
if (!plmnId->decodefromoctetstring(globalgnbid->pLMNIdentity)) return false;
if (!gNB_ID->decodefrombitstring(globalgnbid->gNB_ID)) return false;
return true; return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void GlobalgNBId::getGlobalgNBId(PlmnId*& plmn, GNB_ID*& gnbid) { void GlobalgNBId::getGlobalgNBId(PlmnId& plmn, GNB_ID& gnbid) {
if (plmnId) plmn = plmnId; plmn = plmnId;
if (gNB_ID) gnbid = gNB_ID; gnbid = gNB_ID;
} }
} // namespace ngap } // namespace ngap
...@@ -19,15 +19,8 @@ ...@@ -19,15 +19,8 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _GLOBAL_GNB_ID_H
\brief #define _GLOBAL_GNB_ID_H
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _GlobalgNBId_H
#define _GlobalgNBId_H
#include "GNB-ID.hpp" #include "GNB-ID.hpp"
#include "PlmnId.hpp" #include "PlmnId.hpp"
...@@ -45,12 +38,13 @@ class GlobalgNBId { ...@@ -45,12 +38,13 @@ class GlobalgNBId {
bool encode2GlobalgNBId(Ngap_GlobalGNB_ID_t*); bool encode2GlobalgNBId(Ngap_GlobalGNB_ID_t*);
bool decodefromGlobalgNBId(Ngap_GlobalGNB_ID_t*); bool decodefromGlobalgNBId(Ngap_GlobalGNB_ID_t*);
void setGlobalgNBId(PlmnId* plmn, GNB_ID* gnbid);
void getGlobalgNBId(PlmnId*& plmn, GNB_ID*& gnbid); void setGlobalgNBId(const PlmnId& plmn, const GNB_ID& gnbid);
void getGlobalgNBId(PlmnId& plmn, GNB_ID& gnbid);
private: private:
PlmnId* plmnId; PlmnId plmnId; // Mandatory
GNB_ID* gNB_ID; GNB_ID gNB_ID; // Mandatory
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,13 +19,6 @@ ...@@ -19,13 +19,6 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _MICOMODEINDICATION_H_ #ifndef _MICOMODEINDICATION_H_
#define _MICOMODEINDICATION_H_ #define _MICOMODEINDICATION_H_
...@@ -46,8 +39,6 @@ class MICOModeIndication { ...@@ -46,8 +39,6 @@ class MICOModeIndication {
bool encode2MICOModeIndication(Ngap_MICOModeIndication_t* micoModeIndication); bool encode2MICOModeIndication(Ngap_MICOModeIndication_t* micoModeIndication);
bool decodefromMICOModeIndication( bool decodefromMICOModeIndication(
Ngap_MICOModeIndication_t* micoModeIndication); Ngap_MICOModeIndication_t* micoModeIndication);
// private:
// uint16_t indexLength10;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -48,6 +48,13 @@ MessageType::MessageType() { ...@@ -48,6 +48,13 @@ MessageType::MessageType() {
criticality = Ngap_Criticality_reject; criticality = Ngap_Criticality_reject;
} }
MessageType::MessageType(
Ngap_ProcedureCode_t m_procedureCode, Ngap_NGAP_PDU_PR m_typeOfMessage) {
criticality = Ngap_Criticality_reject;
procedureCode = m_procedureCode;
typeOfMessage = m_typeOfMessage;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
MessageType::~MessageType() {} MessageType::~MessageType() {}
......
...@@ -43,6 +43,8 @@ namespace ngap { ...@@ -43,6 +43,8 @@ namespace ngap {
class MessageType { class MessageType {
public: public:
MessageType(); MessageType();
MessageType(
Ngap_ProcedureCode_t m_procedureCode, Ngap_NGAP_PDU_PR m_typeOfMessage);
virtual ~MessageType(); virtual ~MessageType();
int encode2pdu(Ngap_NGAP_PDU_t*&); int encode2pdu(Ngap_NGAP_PDU_t*&);
......
...@@ -32,19 +32,24 @@ ...@@ -32,19 +32,24 @@
using namespace std; using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
MobilityRestrictionList::MobilityRestrictionList() { MobilityRestrictionList::MobilityRestrictionList() {}
Servingplmn = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
MobilityRestrictionList::~MobilityRestrictionList() {} MobilityRestrictionList::~MobilityRestrictionList() {}
//------------------------------------------------------------------------------
void MobilityRestrictionList::setMobilityRestrictionList(const PlmnId& sPLMN) {
servingPLMN = sPLMN;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void MobilityRestrictionList::setMobilityRestrictionList(PlmnId* servingplmn) { void MobilityRestrictionList::getMobilityRestrictionList(PlmnId& sPLMN) {
Servingplmn = servingplmn; sPLMN = servingPLMN;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool MobilityRestrictionList::encodeMobilityRestrictionList( bool MobilityRestrictionList::encodeMobilityRestrictionList(
Ngap_MobilityRestrictionList_t* mobilityrestrictionlist) { Ngap_MobilityRestrictionList_t* mobilityrestrictionlist) {
if (!Servingplmn->encode2octetstring(mobilityrestrictionlist->servingPLMN)) { if (!servingPLMN.encode2octetstring(mobilityrestrictionlist->servingPLMN)) {
return false; return false;
} }
return true; return true;
......
...@@ -25,8 +25,8 @@ ...@@ -25,8 +25,8 @@
\date 2020 \date 2020
\email: contact@openairinterface.org \email: contact@openairinterface.org
*/ */
#ifndef _MOBILITYRESTRICETIONLIST_H_ #ifndef _MOBILITY_RESTRICTION_LIST_H_
#define _MOBILITYRESTRICETIONLIST_H_ #define _MOBILITYRESTRICTION_LIST_H_
#include "PlmnId.hpp" #include "PlmnId.hpp"
extern "C" { extern "C" {
...@@ -37,12 +37,22 @@ class MobilityRestrictionList { ...@@ -37,12 +37,22 @@ class MobilityRestrictionList {
public: public:
MobilityRestrictionList(); MobilityRestrictionList();
virtual ~MobilityRestrictionList(); virtual ~MobilityRestrictionList();
void setMobilityRestrictionList(PlmnId* servingplmn);
void setMobilityRestrictionList(const PlmnId& sPlmn);
void getMobilityRestrictionList(PlmnId& sPlmn);
bool encodeMobilityRestrictionList( bool encodeMobilityRestrictionList(
Ngap_MobilityRestrictionList_t* mobilityrestrictionlist); Ngap_MobilityRestrictionList_t* mobilityrestrictionlist);
private: private:
PlmnId* Servingplmn; PlmnId servingPLMN; // Mandatory
// TODO: Equivalent PLMNs (optional)
// TODO: RAT Restrictions (optional)
// TODO: Forbidden Area Information (optional)
// TODO: Service Area Information (optional)
// TODO: Last E-UTRAN PLMN Identity (optional)
// TODO: Core Network Type Restriction for Serving PLMN (optional)
// TODO: Core Network Type Restriction for Equivalent PLMNs (optional)
}; };
} // namespace ngap } // namespace ngap
#endif #endif
...@@ -34,41 +34,56 @@ using namespace std; ...@@ -34,41 +34,56 @@ using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
NR_CGI::NR_CGI() { NR_CGI::NR_CGI() {}
plmnId = NULL;
nRCellIdentity = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
NR_CGI::~NR_CGI() {} NR_CGI::~NR_CGI() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void NR_CGI::setNR_CGI(PlmnId* m_plmnId, NRCellIdentity* m_nRCellIdentity) { void NR_CGI::setNR_CGI(
const PlmnId& m_plmnId, const NRCellIdentity& m_nRCellIdentity) {
plmnId = m_plmnId; plmnId = m_plmnId;
nRCellIdentity = m_nRCellIdentity; nRCellIdentity = m_nRCellIdentity;
} }
//------------------------------------------------------------------------------
void NR_CGI::setNR_CGI(
const std::string& mcc, const std::string& mnc,
const unsigned long& nrcellidentity) {
plmnId.setMccMnc(mcc, mnc);
nRCellIdentity.setNRCellIdentity(nrcellidentity);
}
//------------------------------------------------------------------------------
void NR_CGI::setNR_CGI(const struct NrCgi_s& cig) {
plmnId.setMccMnc(cig.mcc, cig.mnc);
nRCellIdentity.setNRCellIdentity(cig.nrCellID);
}
//------------------------------------------------------------------------------
void NR_CGI::getNR_CGI(struct NrCgi_s& cig) {
plmnId.getMcc(cig.mcc);
plmnId.getMnc(cig.mnc);
cig.nrCellID = nRCellIdentity.getNRCellIdentity();
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
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.encode2octetstring(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;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool NR_CGI::decodefromNR_CGI(Ngap_NR_CGI_t* nr_cgi) { bool NR_CGI::decodefromNR_CGI(Ngap_NR_CGI_t* nr_cgi) {
if (plmnId == nullptr) plmnId = new PlmnId(); if (!plmnId.decodefromoctetstring(nr_cgi->pLMNIdentity)) return false;
if (nRCellIdentity == nullptr) nRCellIdentity = new NRCellIdentity(); if (!nRCellIdentity.decodefrombitstring(nr_cgi->nRCellIdentity)) return false;
if (!plmnId->decodefromoctetstring(nr_cgi->pLMNIdentity)) return false;
if (!nRCellIdentity->decodefrombitstring(nr_cgi->nRCellIdentity))
return false;
return true; return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void NR_CGI::getNR_CGI(PlmnId*& m_plmnId, NRCellIdentity*& m_nRCellIdentity) { void NR_CGI::getNR_CGI(PlmnId& m_plmnId, NRCellIdentity& m_nRCellIdentity) {
m_plmnId = plmnId; m_plmnId = plmnId;
m_nRCellIdentity = nRCellIdentity; m_nRCellIdentity = nRCellIdentity;
} }
......
...@@ -31,6 +31,7 @@ ...@@ -31,6 +31,7 @@
#include "NRCellIdentity.hpp" #include "NRCellIdentity.hpp"
#include "PlmnId.hpp" #include "PlmnId.hpp"
#include "NgapIEsStruct.hpp"
extern "C" { extern "C" {
#include "Ngap_NR-CGI.h" #include "Ngap_NR-CGI.h"
...@@ -43,14 +44,20 @@ class NR_CGI { ...@@ -43,14 +44,20 @@ class NR_CGI {
NR_CGI(); NR_CGI();
virtual ~NR_CGI(); virtual ~NR_CGI();
void setNR_CGI(PlmnId*, NRCellIdentity*); void setNR_CGI(const PlmnId&, const NRCellIdentity&);
void getNR_CGI(PlmnId&, NRCellIdentity&);
void setNR_CGI(
const std::string& mcc, const std::string& mnc,
const unsigned long& nrcellidentity);
void setNR_CGI(const struct NrCgi_s& cig);
void getNR_CGI(struct NrCgi_s& cig);
bool encode2NR_CGI(Ngap_NR_CGI_t*); bool encode2NR_CGI(Ngap_NR_CGI_t*);
bool decodefromNR_CGI(Ngap_NR_CGI_t*); bool decodefromNR_CGI(Ngap_NR_CGI_t*);
void getNR_CGI(PlmnId*&, NRCellIdentity*&);
private: private:
PlmnId* plmnId; PlmnId plmnId; // Mandatory
NRCellIdentity* nRCellIdentity; NRCellIdentity nRCellIdentity; // Mandatory
}; };
} // namespace ngap } // namespace ngap
......
...@@ -42,6 +42,7 @@ class NRCellIdentity { ...@@ -42,6 +42,7 @@ class NRCellIdentity {
bool encode2bitstring(Ngap_NRCellIdentity_t& nRCellIdentity); bool encode2bitstring(Ngap_NRCellIdentity_t& nRCellIdentity);
bool decodefrombitstring(Ngap_NRCellIdentity_t& nRCellIdentity); bool decodefrombitstring(Ngap_NRCellIdentity_t& nRCellIdentity);
unsigned long getNRCellIdentity(); unsigned long getNRCellIdentity();
void setNRCellIdentity(unsigned long m_nrcellidentity); void setNRCellIdentity(unsigned long m_nrcellidentity);
......
...@@ -21,48 +21,50 @@ ...@@ -21,48 +21,50 @@
#include "PDUSessionResourceAdmittedItem.hpp" #include "PDUSessionResourceAdmittedItem.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
PDUSessionResourceAdmittedItem::PDUSessionResourceAdmittedItem() {
pDUSessionID = NULL; //------------------------------------------------------------------------------
} PDUSessionResourceAdmittedItem::PDUSessionResourceAdmittedItem() {}
//------------------------------------------------------------------------------
PDUSessionResourceAdmittedItem::~PDUSessionResourceAdmittedItem() {} PDUSessionResourceAdmittedItem::~PDUSessionResourceAdmittedItem() {}
//------------------------------------------------------------------------------
void PDUSessionResourceAdmittedItem::setPDUSessionResourceAdmittedItem( void PDUSessionResourceAdmittedItem::setPDUSessionResourceAdmittedItem(
PDUSessionID* m_pDUSessionID, OCTET_STRING_t m_handoverrequestAcktransfer) { const PDUSessionID& m_pDUSessionID,
const OCTET_STRING_t& m_handoverRequestAckTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
handoverrequestAcktransfer = m_handoverrequestAcktransfer; handoverRequestAckTransfer = m_handoverRequestAckTransfer;
}
//------------------------------------------------------------------------------
void PDUSessionResourceAdmittedItem::getPDUSessionResourceAdmittedItem(
PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_handoverRequestAckTransfer) {
m_pDUSessionID = pDUSessionID;
m_handoverRequestAckTransfer = handoverRequestAckTransfer;
} }
//------------------------------------------------------------------------------
bool PDUSessionResourceAdmittedItem::encode2PDUSessionResourceAdmittedItem( bool PDUSessionResourceAdmittedItem::encode2PDUSessionResourceAdmittedItem(
Ngap_PDUSessionResourceAdmittedItem_t* pdUSessionResourceAdmittedItem) { Ngap_PDUSessionResourceAdmittedItem_t* pdUSessionResourceAdmittedItem) {
if (!pDUSessionID) return false; if (!pDUSessionID.encode2PDUSessionID(
if (!pDUSessionID->encode2PDUSessionID(
pdUSessionResourceAdmittedItem->pDUSessionID)) pdUSessionResourceAdmittedItem->pDUSessionID))
return false; return false;
pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer = pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer =
handoverrequestAcktransfer; handoverRequestAckTransfer;
return true; return true;
} }
//------------------------------------------------------------------------------
bool PDUSessionResourceAdmittedItem::decodefromPDUSessionResourceAdmittedItem( bool PDUSessionResourceAdmittedItem::decodefromPDUSessionResourceAdmittedItem(
Ngap_PDUSessionResourceAdmittedItem_t* pdUSessionResourceAdmittedItem) { Ngap_PDUSessionResourceAdmittedItem_t* pdUSessionResourceAdmittedItem) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID(); if (!pDUSessionID.decodefromPDUSessionID(
if (!pDUSessionID->decodefromPDUSessionID(
pdUSessionResourceAdmittedItem->pDUSessionID)) pdUSessionResourceAdmittedItem->pDUSessionID))
return false; return false;
handoverrequestAcktransfer = handoverRequestAckTransfer =
pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer; pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer;
return true; return true;
} }
void PDUSessionResourceAdmittedItem::getPDUSessionResourceAdmittedItem(
PDUSessionID*& m_pDUSessionID,
OCTET_STRING_t& m_handoverrequestAcktransfer) {
m_pDUSessionID = pDUSessionID;
m_handoverrequestAcktransfer = handoverrequestAcktransfer;
}
} // namespace ngap } // namespace ngap
...@@ -36,11 +36,11 @@ class PDUSessionResourceAdmittedItem { ...@@ -36,11 +36,11 @@ class PDUSessionResourceAdmittedItem {
virtual ~PDUSessionResourceAdmittedItem(); virtual ~PDUSessionResourceAdmittedItem();
void setPDUSessionResourceAdmittedItem( void setPDUSessionResourceAdmittedItem(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_handoverrequestAcktransfer); const OCTET_STRING_t& m_handoverRequestAckTransfer);
void getPDUSessionResourceAdmittedItem( void getPDUSessionResourceAdmittedItem(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_handoverrequestAcktransfer); OCTET_STRING_t& m_handoverRequestAckTransfer);
bool encode2PDUSessionResourceAdmittedItem( bool encode2PDUSessionResourceAdmittedItem(
Ngap_PDUSessionResourceAdmittedItem_t* pdUSessionResourceAdmittedItem); Ngap_PDUSessionResourceAdmittedItem_t* pdUSessionResourceAdmittedItem);
...@@ -48,8 +48,8 @@ class PDUSessionResourceAdmittedItem { ...@@ -48,8 +48,8 @@ class PDUSessionResourceAdmittedItem {
Ngap_PDUSessionResourceAdmittedItem_t* pdUSessionResourceAdmittedItem); Ngap_PDUSessionResourceAdmittedItem_t* pdUSessionResourceAdmittedItem);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID; // Mandatory
OCTET_STRING_t handoverrequestAcktransfer; OCTET_STRING_t handoverRequestAckTransfer; // Mandatory
}; };
} // namespace ngap } // namespace ngap
......
...@@ -21,56 +21,54 @@ ...@@ -21,56 +21,54 @@
#include "PDUSessionResourceAdmittedList.hpp" #include "PDUSessionResourceAdmittedList.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
PDUSessionResourceAdmittedList::PDUSessionResourceAdmittedList() {
pduSessionResourceAdmittedItem = NULL; //------------------------------------------------------------------------------
numofSessionResourceAdmittedItem = 0; PDUSessionResourceAdmittedList::PDUSessionResourceAdmittedList() {}
}
//------------------------------------------------------------------------------
PDUSessionResourceAdmittedList::~PDUSessionResourceAdmittedList() {} PDUSessionResourceAdmittedList::~PDUSessionResourceAdmittedList() {}
//------------------------------------------------------------------------------
void PDUSessionResourceAdmittedList::setPDUSessionResourceAdmittedList( void PDUSessionResourceAdmittedList::setPDUSessionResourceAdmittedList(
PDUSessionResourceAdmittedItem* m_pduSessionResourceAdmittedItem, int num) { const std::vector<PDUSessionResourceAdmittedItem>& list) {
pduSessionResourceAdmittedItem = m_pduSessionResourceAdmittedItem; admittedItemList = list;
numofSessionResourceAdmittedItem = num; }
//------------------------------------------------------------------------------
void PDUSessionResourceAdmittedList::getPDUSessionResourceAdmittedList(
std::vector<PDUSessionResourceAdmittedItem>& item) {
item = admittedItemList;
} }
//------------------------------------------------------------------------------
bool PDUSessionResourceAdmittedList::encode2PDUSessionResourceAdmittedList( bool PDUSessionResourceAdmittedList::encode2PDUSessionResourceAdmittedList(
Ngap_PDUSessionResourceAdmittedList_t* pduSessionResourceAdmittedList) { Ngap_PDUSessionResourceAdmittedList_t* pduSessionResourceAdmittedList) {
for (int i = 0; i < numofSessionResourceAdmittedItem; i++) { for (auto& item : admittedItemList) {
Ngap_PDUSessionResourceAdmittedItem_t* response = Ngap_PDUSessionResourceAdmittedItem_t* response =
(Ngap_PDUSessionResourceAdmittedItem_t*) calloc( (Ngap_PDUSessionResourceAdmittedItem_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceAdmittedItem_t)); 1, sizeof(Ngap_PDUSessionResourceAdmittedItem_t));
if (!response) return false; if (!response) return false;
if (!pduSessionResourceAdmittedItem[i] if (!item.encode2PDUSessionResourceAdmittedItem(response)) return false;
.encode2PDUSessionResourceAdmittedItem(response))
return false;
if (ASN_SEQUENCE_ADD(&pduSessionResourceAdmittedList->list, response) != 0) if (ASN_SEQUENCE_ADD(&pduSessionResourceAdmittedList->list, response) != 0)
return false; return false;
} }
return true; return true;
} }
//------------------------------------------------------------------------------
bool PDUSessionResourceAdmittedList::decodefromPDUSessionResourceAdmittedList( bool PDUSessionResourceAdmittedList::decodefromPDUSessionResourceAdmittedList(
Ngap_PDUSessionResourceAdmittedList_t* pduSessionResourceAdmittedList) { Ngap_PDUSessionResourceAdmittedList_t* pduSessionResourceAdmittedList) {
numofSessionResourceAdmittedItem = pduSessionResourceAdmittedList->list.count; for (int i = 0; i < pduSessionResourceAdmittedList->list.count; i++) {
pduSessionResourceAdmittedItem = PDUSessionResourceAdmittedItem item = {};
new PDUSessionResourceAdmittedItem[numofSessionResourceAdmittedItem](); if (!item.decodefromPDUSessionResourceAdmittedItem(
for (int i = 0; i < numofSessionResourceAdmittedItem; i++) { pduSessionResourceAdmittedList->list.array[i]))
if (!pduSessionResourceAdmittedItem[i]
.decodefromPDUSessionResourceAdmittedItem(
pduSessionResourceAdmittedList->list.array[i]))
return false; return false;
admittedItemList.push_back(item);
} }
return true; return true;
} }
void PDUSessionResourceAdmittedList::getPDUSessionResourceAdmittedList(
PDUSessionResourceAdmittedItem*& m_pduSessionResourceAdmittedItem,
int& num) {
m_pduSessionResourceAdmittedItem = pduSessionResourceAdmittedItem;
num = numofSessionResourceAdmittedItem;
}
} // namespace ngap } // namespace ngap
...@@ -36,11 +36,9 @@ class PDUSessionResourceAdmittedList { ...@@ -36,11 +36,9 @@ class PDUSessionResourceAdmittedList {
virtual ~PDUSessionResourceAdmittedList(); virtual ~PDUSessionResourceAdmittedList();
void setPDUSessionResourceAdmittedList( void setPDUSessionResourceAdmittedList(
PDUSessionResourceAdmittedItem* m_pduSessionResourceAdmittedItem, const std::vector<PDUSessionResourceAdmittedItem>& list);
int num);
void getPDUSessionResourceAdmittedList( void getPDUSessionResourceAdmittedList(
PDUSessionResourceAdmittedItem*& m_pduSessionResourceAdmittedItem, std::vector<PDUSessionResourceAdmittedItem>& list);
int& num);
bool encode2PDUSessionResourceAdmittedList( bool encode2PDUSessionResourceAdmittedList(
Ngap_PDUSessionResourceAdmittedList_t* pduSessionResourceAdmittedList); Ngap_PDUSessionResourceAdmittedList_t* pduSessionResourceAdmittedList);
...@@ -48,8 +46,7 @@ class PDUSessionResourceAdmittedList { ...@@ -48,8 +46,7 @@ class PDUSessionResourceAdmittedList {
Ngap_PDUSessionResourceAdmittedList_t* pduSessionResourceAdmittedList); Ngap_PDUSessionResourceAdmittedList_t* pduSessionResourceAdmittedList);
private: private:
PDUSessionResourceAdmittedItem* pduSessionResourceAdmittedItem; std::vector<PDUSessionResourceAdmittedItem> admittedItemList;
int numofSessionResourceAdmittedItem;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,25 +19,13 @@ ...@@ -19,25 +19,13 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceFailedToSetupItemCxtFail.hpp" #include "PDUSessionResourceFailedToSetupItemCxtFail.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupItemCxtFail:: PDUSessionResourceFailedToSetupItemCxtFail::
PDUSessionResourceFailedToSetupItemCxtFail() { PDUSessionResourceFailedToSetupItemCxtFail() {}
pDUSessionID = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupItemCxtFail:: PDUSessionResourceFailedToSetupItemCxtFail::
...@@ -46,20 +34,29 @@ PDUSessionResourceFailedToSetupItemCxtFail:: ...@@ -46,20 +34,29 @@ PDUSessionResourceFailedToSetupItemCxtFail::
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupItemCxtFail:: void PDUSessionResourceFailedToSetupItemCxtFail::
setPDUSessionResourceFailedToSetupItemCxtFail( setPDUSessionResourceFailedToSetupItemCxtFail(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceSetupUnsuccessfulTransfer) { const OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
pDUSessionResourceSetupUnsuccessfulTransfer = pDUSessionResourceSetupUnsuccessfulTransfer =
m_pDUSessionResourceSetupUnsuccessfulTransfer; m_pDUSessionResourceSetupUnsuccessfulTransfer;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupItemCxtFail::
getPDUSessionResourceFailedToSetupItemCxtFail(
PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
m_pDUSessionID = pDUSessionID;
pDUSessionResourceSetupUnsuccessfulTransfer =
pDUSessionResourceSetupUnsuccessfulTransfer;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceFailedToSetupItemCxtFail:: bool PDUSessionResourceFailedToSetupItemCxtFail::
encode2PDUSessionResourceFailedToSetupItemCxtFail( encode2PDUSessionResourceFailedToSetupItemCxtFail(
Ngap_PDUSessionResourceFailedToSetupItemCxtFail_t* Ngap_PDUSessionResourceFailedToSetupItemCxtFail_t*
pduSessionResourceFailedToSetupItemCxtFail) { pduSessionResourceFailedToSetupItemCxtFail) {
if (!pDUSessionID) return false; if (!pDUSessionID.encode2PDUSessionID(
if (!pDUSessionID->encode2PDUSessionID(
pduSessionResourceFailedToSetupItemCxtFail->pDUSessionID)) pduSessionResourceFailedToSetupItemCxtFail->pDUSessionID))
return false; return false;
pduSessionResourceFailedToSetupItemCxtFail pduSessionResourceFailedToSetupItemCxtFail
...@@ -74,8 +71,7 @@ bool PDUSessionResourceFailedToSetupItemCxtFail:: ...@@ -74,8 +71,7 @@ bool PDUSessionResourceFailedToSetupItemCxtFail::
decodefromPDUSessionResourceFailedToSetupItemCxtFail( decodefromPDUSessionResourceFailedToSetupItemCxtFail(
Ngap_PDUSessionResourceFailedToSetupItemCxtFail_t* Ngap_PDUSessionResourceFailedToSetupItemCxtFail_t*
pduSessionResourceFailedToSetupItemCxtFail) { pduSessionResourceFailedToSetupItemCxtFail) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID(); if (!pDUSessionID.decodefromPDUSessionID(
if (!pDUSessionID->decodefromPDUSessionID(
pduSessionResourceFailedToSetupItemCxtFail->pDUSessionID)) pduSessionResourceFailedToSetupItemCxtFail->pDUSessionID))
return false; return false;
pDUSessionResourceSetupUnsuccessfulTransfer = pDUSessionResourceSetupUnsuccessfulTransfer =
...@@ -85,14 +81,4 @@ bool PDUSessionResourceFailedToSetupItemCxtFail:: ...@@ -85,14 +81,4 @@ bool PDUSessionResourceFailedToSetupItemCxtFail::
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupItemCxtFail::
getPDUSessionResourceFailedToSetupItemCxtFail(
PDUSessionID*& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
m_pDUSessionID = pDUSessionID;
pDUSessionResourceSetupUnsuccessfulTransfer =
pDUSessionResourceSetupUnsuccessfulTransfer;
}
} // namespace ngap } // namespace ngap
...@@ -43,10 +43,10 @@ class PDUSessionResourceFailedToSetupItemCxtFail { ...@@ -43,10 +43,10 @@ class PDUSessionResourceFailedToSetupItemCxtFail {
virtual ~PDUSessionResourceFailedToSetupItemCxtFail(); virtual ~PDUSessionResourceFailedToSetupItemCxtFail();
void setPDUSessionResourceFailedToSetupItemCxtFail( void setPDUSessionResourceFailedToSetupItemCxtFail(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceSetupUnsuccessfulTransfer); const OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer);
void getPDUSessionResourceFailedToSetupItemCxtFail( void getPDUSessionResourceFailedToSetupItemCxtFail(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer); OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer);
bool encode2PDUSessionResourceFailedToSetupItemCxtFail( bool encode2PDUSessionResourceFailedToSetupItemCxtFail(
...@@ -57,7 +57,7 @@ class PDUSessionResourceFailedToSetupItemCxtFail { ...@@ -57,7 +57,7 @@ class PDUSessionResourceFailedToSetupItemCxtFail {
pduSessionResourceFailedToSetupItemCxtFail); pduSessionResourceFailedToSetupItemCxtFail);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID; // Mandatory
OCTET_STRING_t pDUSessionResourceSetupUnsuccessfulTransfer; OCTET_STRING_t pDUSessionResourceSetupUnsuccessfulTransfer;
}; };
......
...@@ -35,9 +35,7 @@ namespace ngap { ...@@ -35,9 +35,7 @@ namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupItemCxtRes:: PDUSessionResourceFailedToSetupItemCxtRes::
PDUSessionResourceFailedToSetupItemCxtRes() { PDUSessionResourceFailedToSetupItemCxtRes() {}
pDUSessionID = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupItemCxtRes:: PDUSessionResourceFailedToSetupItemCxtRes::
...@@ -46,20 +44,29 @@ PDUSessionResourceFailedToSetupItemCxtRes:: ...@@ -46,20 +44,29 @@ PDUSessionResourceFailedToSetupItemCxtRes::
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupItemCxtRes:: void PDUSessionResourceFailedToSetupItemCxtRes::
setPDUSessionResourceFailedToSetupItemCxtRes( setPDUSessionResourceFailedToSetupItemCxtRes(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceSetupUnsuccessfulTransfer) { const OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
pDUSessionResourceSetupUnsuccessfulTransfer = pDUSessionResourceSetupUnsuccessfulTransfer =
m_pDUSessionResourceSetupUnsuccessfulTransfer; m_pDUSessionResourceSetupUnsuccessfulTransfer;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupItemCxtRes::
getPDUSessionResourceFailedToSetupItemCxtRes(
PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
m_pDUSessionID = pDUSessionID;
pDUSessionResourceSetupUnsuccessfulTransfer =
pDUSessionResourceSetupUnsuccessfulTransfer;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceFailedToSetupItemCxtRes:: bool PDUSessionResourceFailedToSetupItemCxtRes::
encode2PDUSessionResourceFailedToSetupItemCxtRes( encode2PDUSessionResourceFailedToSetupItemCxtRes(
Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t* Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*
pduSessionResourceFailedToSetupItemCxtRes) { pduSessionResourceFailedToSetupItemCxtRes) {
if (!pDUSessionID) return false; if (!pDUSessionID.encode2PDUSessionID(
if (!pDUSessionID->encode2PDUSessionID(
pduSessionResourceFailedToSetupItemCxtRes->pDUSessionID)) pduSessionResourceFailedToSetupItemCxtRes->pDUSessionID))
return false; return false;
pduSessionResourceFailedToSetupItemCxtRes pduSessionResourceFailedToSetupItemCxtRes
...@@ -74,8 +81,7 @@ bool PDUSessionResourceFailedToSetupItemCxtRes:: ...@@ -74,8 +81,7 @@ bool PDUSessionResourceFailedToSetupItemCxtRes::
decodefromPDUSessionResourceFailedToSetupItemCxtRes( decodefromPDUSessionResourceFailedToSetupItemCxtRes(
Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t* Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*
pduSessionResourceFailedToSetupItemCxtRes) { pduSessionResourceFailedToSetupItemCxtRes) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID(); if (!pDUSessionID.decodefromPDUSessionID(
if (!pDUSessionID->decodefromPDUSessionID(
pduSessionResourceFailedToSetupItemCxtRes->pDUSessionID)) pduSessionResourceFailedToSetupItemCxtRes->pDUSessionID))
return false; return false;
pDUSessionResourceSetupUnsuccessfulTransfer = pDUSessionResourceSetupUnsuccessfulTransfer =
...@@ -85,14 +91,4 @@ bool PDUSessionResourceFailedToSetupItemCxtRes:: ...@@ -85,14 +91,4 @@ bool PDUSessionResourceFailedToSetupItemCxtRes::
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupItemCxtRes::
getPDUSessionResourceFailedToSetupItemCxtRes(
PDUSessionID*& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
m_pDUSessionID = pDUSessionID;
pDUSessionResourceSetupUnsuccessfulTransfer =
pDUSessionResourceSetupUnsuccessfulTransfer;
}
} // namespace ngap } // namespace ngap
...@@ -19,15 +19,8 @@ ...@@ -19,15 +19,8 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_FAILED_TO_SETUP_ITEM_CXT_RES_H_
\brief #define _PDU_SESSION_RESOURCE_FAILED_TO_SETUP_ITEM_CXT_RES_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCEFAILEDTOSETUPITEMCXTRES_H_
#define _PDUSESSIONRESOURCEFAILEDTOSETUPITEMCXTRES_H_
#include "PDUSessionID.hpp" #include "PDUSessionID.hpp"
...@@ -43,10 +36,10 @@ class PDUSessionResourceFailedToSetupItemCxtRes { ...@@ -43,10 +36,10 @@ class PDUSessionResourceFailedToSetupItemCxtRes {
virtual ~PDUSessionResourceFailedToSetupItemCxtRes(); virtual ~PDUSessionResourceFailedToSetupItemCxtRes();
void setPDUSessionResourceFailedToSetupItemCxtRes( void setPDUSessionResourceFailedToSetupItemCxtRes(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceSetupUnsuccessfulTransfer); const OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer);
void getPDUSessionResourceFailedToSetupItemCxtRes( void getPDUSessionResourceFailedToSetupItemCxtRes(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer); OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer);
bool encode2PDUSessionResourceFailedToSetupItemCxtRes( bool encode2PDUSessionResourceFailedToSetupItemCxtRes(
...@@ -57,8 +50,8 @@ class PDUSessionResourceFailedToSetupItemCxtRes { ...@@ -57,8 +50,8 @@ class PDUSessionResourceFailedToSetupItemCxtRes {
pduSessionResourceFailedToSetupItemCxtRes); pduSessionResourceFailedToSetupItemCxtRes);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID; // Mandatory
OCTET_STRING_t pDUSessionResourceSetupUnsuccessfulTransfer; OCTET_STRING_t pDUSessionResourceSetupUnsuccessfulTransfer; // Mandatory
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,25 +19,13 @@ ...@@ -19,25 +19,13 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceFailedToSetupItemSURes.hpp" #include "PDUSessionResourceFailedToSetupItemSURes.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupItemSURes:: PDUSessionResourceFailedToSetupItemSURes::
PDUSessionResourceFailedToSetupItemSURes() { PDUSessionResourceFailedToSetupItemSURes() {}
pDUSessionID = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupItemSURes:: PDUSessionResourceFailedToSetupItemSURes::
...@@ -46,20 +34,29 @@ PDUSessionResourceFailedToSetupItemSURes:: ...@@ -46,20 +34,29 @@ PDUSessionResourceFailedToSetupItemSURes::
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupItemSURes:: void PDUSessionResourceFailedToSetupItemSURes::
setPDUSessionResourceFailedToSetupItemSURes( setPDUSessionResourceFailedToSetupItemSURes(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceSetupUnsuccessfulTransfer) { const OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
pDUSessionResourceSetupUnsuccessfulTransfer = pDUSessionResourceSetupUnsuccessfulTransfer =
m_pDUSessionResourceSetupUnsuccessfulTransfer; m_pDUSessionResourceSetupUnsuccessfulTransfer;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupItemSURes::
getPDUSessionResourceFailedToSetupItemSURes(
PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
m_pDUSessionID = pDUSessionID;
m_pDUSessionResourceSetupUnsuccessfulTransfer =
pDUSessionResourceSetupUnsuccessfulTransfer;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceFailedToSetupItemSURes:: bool PDUSessionResourceFailedToSetupItemSURes::
encode2PDUSessionResourceFailedToSetupItemSURes( encode2PDUSessionResourceFailedToSetupItemSURes(
Ngap_PDUSessionResourceFailedToSetupItemSURes_t* Ngap_PDUSessionResourceFailedToSetupItemSURes_t*
pduSessionResourceFailedToSetupItemSURes) { pduSessionResourceFailedToSetupItemSURes) {
if (!pDUSessionID) return false; if (!pDUSessionID.encode2PDUSessionID(
if (!pDUSessionID->encode2PDUSessionID(
pduSessionResourceFailedToSetupItemSURes->pDUSessionID)) pduSessionResourceFailedToSetupItemSURes->pDUSessionID))
return false; return false;
pduSessionResourceFailedToSetupItemSURes pduSessionResourceFailedToSetupItemSURes
...@@ -74,8 +71,7 @@ bool PDUSessionResourceFailedToSetupItemSURes:: ...@@ -74,8 +71,7 @@ bool PDUSessionResourceFailedToSetupItemSURes::
decodefromPDUSessionResourceFailedToSetupItemSURes( decodefromPDUSessionResourceFailedToSetupItemSURes(
Ngap_PDUSessionResourceFailedToSetupItemSURes_t* Ngap_PDUSessionResourceFailedToSetupItemSURes_t*
pduSessionResourceFailedToSetupItemSURes) { pduSessionResourceFailedToSetupItemSURes) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID(); if (!pDUSessionID.decodefromPDUSessionID(
if (!pDUSessionID->decodefromPDUSessionID(
pduSessionResourceFailedToSetupItemSURes->pDUSessionID)) pduSessionResourceFailedToSetupItemSURes->pDUSessionID))
return false; return false;
pDUSessionResourceSetupUnsuccessfulTransfer = pDUSessionResourceSetupUnsuccessfulTransfer =
...@@ -85,14 +81,4 @@ bool PDUSessionResourceFailedToSetupItemSURes:: ...@@ -85,14 +81,4 @@ bool PDUSessionResourceFailedToSetupItemSURes::
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupItemSURes::
getPDUSessionResourceFailedToSetupItemSURes(
PDUSessionID*& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
m_pDUSessionID = pDUSessionID;
m_pDUSessionResourceSetupUnsuccessfulTransfer =
pDUSessionResourceSetupUnsuccessfulTransfer;
}
} // namespace ngap } // namespace ngap
...@@ -19,15 +19,8 @@ ...@@ -19,15 +19,8 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_FAILED_TO_SETUP_ITEM_SU_RES_H_
\brief #define _PDU_SESSION_RESOURCE_FAILED_TO_SETUP_ITEM_SU_RES_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCEFAILEDTOSETUPITEMSURES_H_
#define _PDUSESSIONRESOURCEFAILEDTOSETUPITEMSURES_H_
#include "PDUSessionID.hpp" #include "PDUSessionID.hpp"
...@@ -43,10 +36,10 @@ class PDUSessionResourceFailedToSetupItemSURes { ...@@ -43,10 +36,10 @@ class PDUSessionResourceFailedToSetupItemSURes {
virtual ~PDUSessionResourceFailedToSetupItemSURes(); virtual ~PDUSessionResourceFailedToSetupItemSURes();
void setPDUSessionResourceFailedToSetupItemSURes( void setPDUSessionResourceFailedToSetupItemSURes(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceSetupUnsuccessfulTransfer); const OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer);
void getPDUSessionResourceFailedToSetupItemSURes( void getPDUSessionResourceFailedToSetupItemSURes(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer); OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer);
bool encode2PDUSessionResourceFailedToSetupItemSURes( bool encode2PDUSessionResourceFailedToSetupItemSURes(
...@@ -57,7 +50,7 @@ class PDUSessionResourceFailedToSetupItemSURes { ...@@ -57,7 +50,7 @@ class PDUSessionResourceFailedToSetupItemSURes {
pduSessionResourceFailedToSetupItemSURes); pduSessionResourceFailedToSetupItemSURes);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID;
OCTET_STRING_t pDUSessionResourceSetupUnsuccessfulTransfer; OCTET_STRING_t pDUSessionResourceSetupUnsuccessfulTransfer;
}; };
......
...@@ -19,26 +19,13 @@ ...@@ -19,26 +19,13 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceFailedToSetupListCxtFail.hpp" #include "PDUSessionResourceFailedToSetupListCxtFail.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupListCxtFail:: PDUSessionResourceFailedToSetupListCxtFail::
PDUSessionResourceFailedToSetupListCxtFail() { PDUSessionResourceFailedToSetupListCxtFail() {}
pduSessionResourceFailedToSetupItemCxtFail = NULL;
numofpduSessionResourceFailedToSetupItemCxtFail = 0;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupListCxtFail:: PDUSessionResourceFailedToSetupListCxtFail::
...@@ -47,12 +34,15 @@ PDUSessionResourceFailedToSetupListCxtFail:: ...@@ -47,12 +34,15 @@ PDUSessionResourceFailedToSetupListCxtFail::
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupListCxtFail:: void PDUSessionResourceFailedToSetupListCxtFail::
setPDUSessionResourceFailedToSetupListCxtFail( setPDUSessionResourceFailedToSetupListCxtFail(
PDUSessionResourceFailedToSetupItemCxtFail* const std::vector<PDUSessionResourceFailedToSetupItemCxtFail>& list) {
m_pduSessionResourceFailedToSetupItemCxtFail, itemList = list;
int num) { }
pduSessionResourceFailedToSetupItemCxtFail =
m_pduSessionResourceFailedToSetupItemCxtFail; //------------------------------------------------------------------------------
numofpduSessionResourceFailedToSetupItemCxtFail = num; void PDUSessionResourceFailedToSetupListCxtFail::
getPDUSessionResourceFailedToSetupListCxtFail(
std::vector<PDUSessionResourceFailedToSetupItemCxtFail>& list) {
list = itemList;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -60,14 +50,14 @@ bool PDUSessionResourceFailedToSetupListCxtFail:: ...@@ -60,14 +50,14 @@ bool PDUSessionResourceFailedToSetupListCxtFail::
encode2PDUSessionResourceFailedToSetupListCxtFail( encode2PDUSessionResourceFailedToSetupListCxtFail(
Ngap_PDUSessionResourceFailedToSetupListCxtFail_t* Ngap_PDUSessionResourceFailedToSetupListCxtFail_t*
pduSessionResourceFailedToSetupListCxtFail) { pduSessionResourceFailedToSetupListCxtFail) {
for (int i = 0; i < numofpduSessionResourceFailedToSetupItemCxtFail; i++) { for (std::vector<PDUSessionResourceFailedToSetupItemCxtFail>::iterator it =
std::begin(itemList);
it < std::end(itemList); ++it) {
Ngap_PDUSessionResourceFailedToSetupItemCxtFail_t* failedToFailure = Ngap_PDUSessionResourceFailedToSetupItemCxtFail_t* failedToFailure =
(Ngap_PDUSessionResourceFailedToSetupItemCxtFail_t*) calloc( (Ngap_PDUSessionResourceFailedToSetupItemCxtFail_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceFailedToSetupItemCxtFail_t)); 1, sizeof(Ngap_PDUSessionResourceFailedToSetupItemCxtFail_t));
if (!failedToFailure) return false; if (!failedToFailure) return false;
if (!pduSessionResourceFailedToSetupItemCxtFail[i] if (!it->encode2PDUSessionResourceFailedToSetupItemCxtFail(failedToFailure))
.encode2PDUSessionResourceFailedToSetupItemCxtFail(
failedToFailure))
return false; return false;
if (ASN_SEQUENCE_ADD( if (ASN_SEQUENCE_ADD(
&pduSessionResourceFailedToSetupListCxtFail->list, &pduSessionResourceFailedToSetupListCxtFail->list,
...@@ -83,30 +73,18 @@ bool PDUSessionResourceFailedToSetupListCxtFail:: ...@@ -83,30 +73,18 @@ bool PDUSessionResourceFailedToSetupListCxtFail::
decodefromPDUSessionResourceFailedToSetupListCxtFail( decodefromPDUSessionResourceFailedToSetupListCxtFail(
Ngap_PDUSessionResourceFailedToSetupListCxtFail_t* Ngap_PDUSessionResourceFailedToSetupListCxtFail_t*
pduSessionResourceFailedToSetupListCxtFail) { pduSessionResourceFailedToSetupListCxtFail) {
numofpduSessionResourceFailedToSetupItemCxtFail = itemList.reserve(pduSessionResourceFailedToSetupListCxtFail->list.count);
pduSessionResourceFailedToSetupListCxtFail->list.count;
pduSessionResourceFailedToSetupItemCxtFail = for (int i = 0; i < pduSessionResourceFailedToSetupListCxtFail->list.count;
new PDUSessionResourceFailedToSetupItemCxtFail i++) {
[numofpduSessionResourceFailedToSetupItemCxtFail](); PDUSessionResourceFailedToSetupItemCxtFail itemCxtFail = {};
for (int i = 0; i < numofpduSessionResourceFailedToSetupItemCxtFail; i++) { if (!itemCxtFail.decodefromPDUSessionResourceFailedToSetupItemCxtFail(
if (!pduSessionResourceFailedToSetupItemCxtFail[i] pduSessionResourceFailedToSetupListCxtFail->list.array[i]))
.decodefromPDUSessionResourceFailedToSetupItemCxtFail(
pduSessionResourceFailedToSetupListCxtFail->list.array[i]))
return false; return false;
itemList.push_back(itemCxtFail);
} }
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupListCxtFail::
getPDUSessionResourceFailedToSetupListCxtFail(
PDUSessionResourceFailedToSetupItemCxtFail*&
m_pduSessionResourceFailedToSetupItemCxtFail,
int& num) {
m_pduSessionResourceFailedToSetupItemCxtFail =
pduSessionResourceFailedToSetupItemCxtFail;
num = numofpduSessionResourceFailedToSetupItemCxtFail;
}
} // namespace ngap } // namespace ngap
...@@ -19,17 +19,11 @@ ...@@ -19,17 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_FAILED_TO_SETUP_LIST_CXT_FAIL_H_
\brief #define _PDU_SESSION_RESOURCE_FAILED_TO_SETUP_LIST_CXT_FAIL_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCEFAILEDTOSETUPLISTCXTFAIL_H_
#define _PDUSESSIONRESOURCEFAILEDTOSETUPLISTCXTFAIL_H_
#include "PDUSessionResourceFailedToSetupItemCxtFail.hpp" #include "PDUSessionResourceFailedToSetupItemCxtFail.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceFailedToSetupListCxtFail.h" #include "Ngap_PDUSessionResourceFailedToSetupListCxtFail.h"
...@@ -43,13 +37,9 @@ class PDUSessionResourceFailedToSetupListCxtFail { ...@@ -43,13 +37,9 @@ class PDUSessionResourceFailedToSetupListCxtFail {
virtual ~PDUSessionResourceFailedToSetupListCxtFail(); virtual ~PDUSessionResourceFailedToSetupListCxtFail();
void setPDUSessionResourceFailedToSetupListCxtFail( void setPDUSessionResourceFailedToSetupListCxtFail(
PDUSessionResourceFailedToSetupItemCxtFail* const std::vector<PDUSessionResourceFailedToSetupItemCxtFail>& list);
m_pduSessionResourceFailedToSetupItemCxtFail,
int num);
void getPDUSessionResourceFailedToSetupListCxtFail( void getPDUSessionResourceFailedToSetupListCxtFail(
PDUSessionResourceFailedToSetupItemCxtFail*& std::vector<PDUSessionResourceFailedToSetupItemCxtFail>& list);
m_pduSessionResourceFailedToSetupItemCxtFail,
int& num);
bool encode2PDUSessionResourceFailedToSetupListCxtFail( bool encode2PDUSessionResourceFailedToSetupListCxtFail(
Ngap_PDUSessionResourceFailedToSetupListCxtFail_t* Ngap_PDUSessionResourceFailedToSetupListCxtFail_t*
...@@ -59,9 +49,7 @@ class PDUSessionResourceFailedToSetupListCxtFail { ...@@ -59,9 +49,7 @@ class PDUSessionResourceFailedToSetupListCxtFail {
pduSessionResourceFailedToSetupListCxtFail); pduSessionResourceFailedToSetupListCxtFail);
private: private:
PDUSessionResourceFailedToSetupItemCxtFail* std::vector<PDUSessionResourceFailedToSetupItemCxtFail> itemList;
pduSessionResourceFailedToSetupItemCxtFail;
int numofpduSessionResourceFailedToSetupItemCxtFail;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -35,10 +35,7 @@ namespace ngap { ...@@ -35,10 +35,7 @@ namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupListCxtRes:: PDUSessionResourceFailedToSetupListCxtRes::
PDUSessionResourceFailedToSetupListCxtRes() { PDUSessionResourceFailedToSetupListCxtRes() {}
pduSessionResourceFailedToSetupItemCxtRes = NULL;
numofpduSessionResourceFailedToSetupItemCxtRes = 0;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupListCxtRes:: PDUSessionResourceFailedToSetupListCxtRes::
...@@ -47,12 +44,15 @@ PDUSessionResourceFailedToSetupListCxtRes:: ...@@ -47,12 +44,15 @@ PDUSessionResourceFailedToSetupListCxtRes::
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupListCxtRes:: void PDUSessionResourceFailedToSetupListCxtRes::
setPDUSessionResourceFailedToSetupListCxtRes( setPDUSessionResourceFailedToSetupListCxtRes(
PDUSessionResourceFailedToSetupItemCxtRes* const std::vector<PDUSessionResourceFailedToSetupItemCxtRes>& list) {
m_pduSessionResourceFailedToSetupItemCxtRes, itemList = list;
int num) { }
pduSessionResourceFailedToSetupItemCxtRes =
m_pduSessionResourceFailedToSetupItemCxtRes; //------------------------------------------------------------------------------
numofpduSessionResourceFailedToSetupItemCxtRes = num; void PDUSessionResourceFailedToSetupListCxtRes::
getPDUSessionResourceFailedToSetupListCxtRes(
std::vector<PDUSessionResourceFailedToSetupItemCxtRes>& list) {
list = itemList;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -60,14 +60,15 @@ bool PDUSessionResourceFailedToSetupListCxtRes:: ...@@ -60,14 +60,15 @@ bool PDUSessionResourceFailedToSetupListCxtRes::
encode2PDUSessionResourceFailedToSetupListCxtRes( encode2PDUSessionResourceFailedToSetupListCxtRes(
Ngap_PDUSessionResourceFailedToSetupListCxtRes_t* Ngap_PDUSessionResourceFailedToSetupListCxtRes_t*
pduSessionResourceFailedToSetupListCxtRes) { pduSessionResourceFailedToSetupListCxtRes) {
for (int i = 0; i < numofpduSessionResourceFailedToSetupItemCxtRes; i++) { for (std::vector<PDUSessionResourceFailedToSetupItemCxtRes>::iterator it =
std::begin(itemList);
it < std::end(itemList); ++it) {
Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t* failedToResponse = Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t* failedToResponse =
(Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*) calloc( (Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t)); 1, sizeof(Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t));
if (!failedToResponse) return false; if (!failedToResponse) return false;
if (!pduSessionResourceFailedToSetupItemCxtRes[i]
.encode2PDUSessionResourceFailedToSetupItemCxtRes( if (!it->encode2PDUSessionResourceFailedToSetupItemCxtRes(failedToResponse))
failedToResponse))
return false; return false;
if (ASN_SEQUENCE_ADD( if (ASN_SEQUENCE_ADD(
&pduSessionResourceFailedToSetupListCxtRes->list, &pduSessionResourceFailedToSetupListCxtRes->list,
...@@ -83,30 +84,17 @@ bool PDUSessionResourceFailedToSetupListCxtRes:: ...@@ -83,30 +84,17 @@ bool PDUSessionResourceFailedToSetupListCxtRes::
decodefromPDUSessionResourceFailedToSetupListCxtRes( decodefromPDUSessionResourceFailedToSetupListCxtRes(
Ngap_PDUSessionResourceFailedToSetupListCxtRes_t* Ngap_PDUSessionResourceFailedToSetupListCxtRes_t*
pduSessionResourceFailedToSetupListCxtRes) { pduSessionResourceFailedToSetupListCxtRes) {
numofpduSessionResourceFailedToSetupItemCxtRes = itemList.reserve(pduSessionResourceFailedToSetupListCxtRes->list.count);
pduSessionResourceFailedToSetupListCxtRes->list.count; for (int i = 0; i < pduSessionResourceFailedToSetupListCxtRes->list.count;
pduSessionResourceFailedToSetupItemCxtRes = i++) {
new PDUSessionResourceFailedToSetupItemCxtRes PDUSessionResourceFailedToSetupItemCxtRes item = {};
[numofpduSessionResourceFailedToSetupItemCxtRes](); if (!item.decodefromPDUSessionResourceFailedToSetupItemCxtRes(
for (int i = 0; i < numofpduSessionResourceFailedToSetupItemCxtRes; i++) { pduSessionResourceFailedToSetupListCxtRes->list.array[i]))
if (!pduSessionResourceFailedToSetupItemCxtRes[i]
.decodefromPDUSessionResourceFailedToSetupItemCxtRes(
pduSessionResourceFailedToSetupListCxtRes->list.array[i]))
return false; return false;
itemList.push_back(item);
} }
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupListCxtRes::
getPDUSessionResourceFailedToSetupListCxtRes(
PDUSessionResourceFailedToSetupItemCxtRes*&
m_pduSessionResourceFailedToSetupItemCxtRes,
int& num) {
m_pduSessionResourceFailedToSetupItemCxtRes =
pduSessionResourceFailedToSetupItemCxtRes;
num = numofpduSessionResourceFailedToSetupItemCxtRes;
}
} // namespace ngap } // namespace ngap
...@@ -19,17 +19,11 @@ ...@@ -19,17 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_FAILED_TO_SETUP_LIST_CXT_RES_H_
\brief #define _PDU_SESSION_RESOURCE_FAILED_TO_SETUP_LIST_CXT_RES_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCEFAILEDTOSETUPLISTCXTRES_H_
#define _PDUSESSIONRESOURCEFAILEDTOSETUPLISTCXTRES_H_
#include "PDUSessionResourceFailedToSetupItemCxtRes.hpp" #include "PDUSessionResourceFailedToSetupItemCxtRes.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceFailedToSetupListCxtRes.h" #include "Ngap_PDUSessionResourceFailedToSetupListCxtRes.h"
...@@ -43,13 +37,9 @@ class PDUSessionResourceFailedToSetupListCxtRes { ...@@ -43,13 +37,9 @@ class PDUSessionResourceFailedToSetupListCxtRes {
virtual ~PDUSessionResourceFailedToSetupListCxtRes(); virtual ~PDUSessionResourceFailedToSetupListCxtRes();
void setPDUSessionResourceFailedToSetupListCxtRes( void setPDUSessionResourceFailedToSetupListCxtRes(
PDUSessionResourceFailedToSetupItemCxtRes* const std::vector<PDUSessionResourceFailedToSetupItemCxtRes>& list);
m_pduSessionResourceFailedToSetupItemCxtRes,
int num);
void getPDUSessionResourceFailedToSetupListCxtRes( void getPDUSessionResourceFailedToSetupListCxtRes(
PDUSessionResourceFailedToSetupItemCxtRes*& std::vector<PDUSessionResourceFailedToSetupItemCxtRes>& list);
m_pduSessionResourceFailedToSetupItemCxtRes,
int& num);
bool encode2PDUSessionResourceFailedToSetupListCxtRes( bool encode2PDUSessionResourceFailedToSetupListCxtRes(
Ngap_PDUSessionResourceFailedToSetupListCxtRes_t* Ngap_PDUSessionResourceFailedToSetupListCxtRes_t*
...@@ -59,9 +49,7 @@ class PDUSessionResourceFailedToSetupListCxtRes { ...@@ -59,9 +49,7 @@ class PDUSessionResourceFailedToSetupListCxtRes {
pduSessionResourceFailedToSetupListCxtRes); pduSessionResourceFailedToSetupListCxtRes);
private: private:
PDUSessionResourceFailedToSetupItemCxtRes* std::vector<PDUSessionResourceFailedToSetupItemCxtRes> itemList;
pduSessionResourceFailedToSetupItemCxtRes;
int numofpduSessionResourceFailedToSetupItemCxtRes;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,26 +19,13 @@ ...@@ -19,26 +19,13 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceFailedToSetupListSURes.hpp" #include "PDUSessionResourceFailedToSetupListSURes.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupListSURes:: PDUSessionResourceFailedToSetupListSURes::
PDUSessionResourceFailedToSetupListSURes() { PDUSessionResourceFailedToSetupListSURes() {}
pduSessionResourceFailedToSetupItemSURes = NULL;
numofpduSessionResourceFailedToSetupItemSURes = 0;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceFailedToSetupListSURes:: PDUSessionResourceFailedToSetupListSURes::
...@@ -47,26 +34,27 @@ PDUSessionResourceFailedToSetupListSURes:: ...@@ -47,26 +34,27 @@ PDUSessionResourceFailedToSetupListSURes::
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupListSURes:: void PDUSessionResourceFailedToSetupListSURes::
setPDUSessionResourceFailedToSetupListSURes( setPDUSessionResourceFailedToSetupListSURes(
PDUSessionResourceFailedToSetupItemSURes* const std::vector<PDUSessionResourceFailedToSetupItemSURes>& list) {
m_pduSessionResourceFailedToSetupItemSURes, itemSUResList = list;
int num) {
pduSessionResourceFailedToSetupItemSURes =
m_pduSessionResourceFailedToSetupItemSURes;
numofpduSessionResourceFailedToSetupItemSURes = num;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupListSURes::
getPDUSessionResourceFailedToSetupListSURes(
std::vector<PDUSessionResourceFailedToSetupItemSURes>& list) {
list = itemSUResList;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceFailedToSetupListSURes:: bool PDUSessionResourceFailedToSetupListSURes::
encode2PDUSessionResourceFailedToSetupListSURes( encode2PDUSessionResourceFailedToSetupListSURes(
Ngap_PDUSessionResourceFailedToSetupListSURes_t* Ngap_PDUSessionResourceFailedToSetupListSURes_t*
pduSessionResourceFailedToSetupListSURes) { pduSessionResourceFailedToSetupListSURes) {
for (int i = 0; i < numofpduSessionResourceFailedToSetupItemSURes; i++) { for (auto& item : itemSUResList) {
Ngap_PDUSessionResourceFailedToSetupItemSURes_t* failedToResponse = Ngap_PDUSessionResourceFailedToSetupItemSURes_t* failedToResponse =
(Ngap_PDUSessionResourceFailedToSetupItemSURes_t*) calloc( (Ngap_PDUSessionResourceFailedToSetupItemSURes_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceFailedToSetupItemSURes_t)); 1, sizeof(Ngap_PDUSessionResourceFailedToSetupItemSURes_t));
if (!failedToResponse) return false; if (!failedToResponse) return false;
if (!pduSessionResourceFailedToSetupItemSURes[i] if (!item.encode2PDUSessionResourceFailedToSetupItemSURes(failedToResponse))
.encode2PDUSessionResourceFailedToSetupItemSURes(failedToResponse))
return false; return false;
if (ASN_SEQUENCE_ADD( if (ASN_SEQUENCE_ADD(
&pduSessionResourceFailedToSetupListSURes->list, &pduSessionResourceFailedToSetupListSURes->list,
...@@ -82,30 +70,16 @@ bool PDUSessionResourceFailedToSetupListSURes:: ...@@ -82,30 +70,16 @@ bool PDUSessionResourceFailedToSetupListSURes::
decodefromPDUSessionResourceFailedToSetupListSURes( decodefromPDUSessionResourceFailedToSetupListSURes(
Ngap_PDUSessionResourceFailedToSetupListSURes_t* Ngap_PDUSessionResourceFailedToSetupListSURes_t*
pduSessionResourceFailedToSetupListSURes) { pduSessionResourceFailedToSetupListSURes) {
numofpduSessionResourceFailedToSetupItemSURes = for (int i = 0; i < pduSessionResourceFailedToSetupListSURes->list.count;
pduSessionResourceFailedToSetupListSURes->list.count; i++) {
pduSessionResourceFailedToSetupItemSURes = PDUSessionResourceFailedToSetupItemSURes item = {};
new PDUSessionResourceFailedToSetupItemSURes if (!item.decodefromPDUSessionResourceFailedToSetupItemSURes(
[numofpduSessionResourceFailedToSetupItemSURes](); pduSessionResourceFailedToSetupListSURes->list.array[i]))
for (int i = 0; i < numofpduSessionResourceFailedToSetupItemSURes; i++) {
if (!pduSessionResourceFailedToSetupItemSURes[i]
.decodefromPDUSessionResourceFailedToSetupItemSURes(
pduSessionResourceFailedToSetupListSURes->list.array[i]))
return false; return false;
itemSUResList.push_back(item);
} }
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceFailedToSetupListSURes::
getPDUSessionResourceFailedToSetupListSURes(
PDUSessionResourceFailedToSetupItemSURes*&
m_pduSessionResourceFailedToSetupItemSURes,
int& num) {
m_pduSessionResourceFailedToSetupItemSURes =
pduSessionResourceFailedToSetupItemSURes;
num = numofpduSessionResourceFailedToSetupItemSURes;
}
} // namespace ngap } // namespace ngap
...@@ -19,17 +19,11 @@ ...@@ -19,17 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_FAILED_TO_SETUP_LIST_SU_RES_H_
\brief #define _PDU_SESSION_RESOURCE_FAILED_TO_SETUP_LIST_SU_RES_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCEFAILEDTOSETUPLISTSURES_H_
#define _PDUSESSIONRESOURCEFAILEDTOSETUPLISTSURES_H_
#include "PDUSessionResourceFailedToSetupItemSURes.hpp" #include "PDUSessionResourceFailedToSetupItemSURes.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceFailedToSetupListSURes.h" #include "Ngap_PDUSessionResourceFailedToSetupListSURes.h"
...@@ -43,13 +37,9 @@ class PDUSessionResourceFailedToSetupListSURes { ...@@ -43,13 +37,9 @@ class PDUSessionResourceFailedToSetupListSURes {
virtual ~PDUSessionResourceFailedToSetupListSURes(); virtual ~PDUSessionResourceFailedToSetupListSURes();
void setPDUSessionResourceFailedToSetupListSURes( void setPDUSessionResourceFailedToSetupListSURes(
PDUSessionResourceFailedToSetupItemSURes* const std::vector<PDUSessionResourceFailedToSetupItemSURes>& item);
m_pduSessionResourceFailedToSetupItemSURes,
int num);
void getPDUSessionResourceFailedToSetupListSURes( void getPDUSessionResourceFailedToSetupListSURes(
PDUSessionResourceFailedToSetupItemSURes*& std::vector<PDUSessionResourceFailedToSetupItemSURes>& item);
m_pduSessionResourceFailedToSetupItemSURes,
int& num);
bool encode2PDUSessionResourceFailedToSetupListSURes( bool encode2PDUSessionResourceFailedToSetupListSURes(
Ngap_PDUSessionResourceFailedToSetupListSURes_t* Ngap_PDUSessionResourceFailedToSetupListSURes_t*
...@@ -59,9 +49,7 @@ class PDUSessionResourceFailedToSetupListSURes { ...@@ -59,9 +49,7 @@ class PDUSessionResourceFailedToSetupListSURes {
pduSessionResourceFailedToSetupListSURes); pduSessionResourceFailedToSetupListSURes);
private: private:
PDUSessionResourceFailedToSetupItemSURes* std::vector<PDUSessionResourceFailedToSetupItemSURes> itemSUResList;
pduSessionResourceFailedToSetupItemSURes;
int numofpduSessionResourceFailedToSetupItemSURes;
}; };
} // namespace ngap } // namespace ngap
......
/*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.1 (the "License"); you may not use this
* file except in compliance with the License. You may obtain a copy of the
* License at
*
* http://www.openairinterface.org/?page_id=698
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org
*/
#include "PDUSessionResourceHandoverItem.hpp"
namespace ngap {
//------------------------------------------------------------------------------
PDUSessionResourceHandoverItem::PDUSessionResourceHandoverItem() {}
//------------------------------------------------------------------------------
PDUSessionResourceHandoverItem::~PDUSessionResourceHandoverItem() {}
//------------------------------------------------------------------------------
void PDUSessionResourceHandoverItem::setPDUSessionResourceHandoverItem(
const PDUSessionID& sessionID, const OCTET_STRING_t& commandTransfer) {
pDUSessionID = sessionID;
handoverCommandTransfer = commandTransfer;
}
//------------------------------------------------------------------------------
void PDUSessionResourceHandoverItem::getPDUSessionResourceHandoverItem(
PDUSessionID& sessionID, OCTET_STRING_t& commandTransfer) {
sessionID = pDUSessionID;
commandTransfer = handoverCommandTransfer;
}
//------------------------------------------------------------------------------
bool PDUSessionResourceHandoverItem::encode(
Ngap_PDUSessionResourceHandoverItem_t& item) {
if (!pDUSessionID.encode2PDUSessionID(item.pDUSessionID)) return false;
item.handoverCommandTransfer = handoverCommandTransfer;
return true;
}
//------------------------------------------------------------------------------
bool PDUSessionResourceHandoverItem::decode(
const Ngap_PDUSessionResourceHandoverItem_t& item) {
if (!pDUSessionID.decodefromPDUSessionID(item.pDUSessionID)) return false;
handoverCommandTransfer = item.handoverCommandTransfer;
return true;
}
} // namespace ngap
/*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.1 (the "License"); you may not use this
* file except in compliance with the License. You may obtain a copy of the
* License at
*
* http://www.openairinterface.org/?page_id=698
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org
*/
#ifndef _PDU_SESSION_RESOURCE_HANDOVER_ITEM_H_
#define _PDU_SESSION_RESOURCE_HANDOVER_ITEM_H_
#include "PDUSessionID.hpp"
extern "C" {
#include "Ngap_PDUSessionResourceHandoverItem.h"
}
namespace ngap {
class PDUSessionResourceHandoverItem {
public:
PDUSessionResourceHandoverItem();
virtual ~PDUSessionResourceHandoverItem();
void setPDUSessionResourceHandoverItem(
const PDUSessionID& sessionID, const OCTET_STRING_t& commandTransfer);
void getPDUSessionResourceHandoverItem(
PDUSessionID& sessionID, OCTET_STRING_t& commandTransfer);
bool encode(Ngap_PDUSessionResourceHandoverItem_t& item);
bool decode(const Ngap_PDUSessionResourceHandoverItem_t& item);
private:
PDUSessionID pDUSessionID; // Mandatory
OCTET_STRING_t handoverCommandTransfer; // Mandatory
};
} // namespace ngap
#endif
/*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.1 (the "License"); you may not use this
* file except in compliance with the License. You may obtain a copy of the
* License at
*
* http://www.openairinterface.org/?page_id=698
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org
*/
#include "PDUSessionResourceHandoverList.hpp"
namespace ngap {
//------------------------------------------------------------------------------
PDUSessionResourceHandoverList::PDUSessionResourceHandoverList() {}
//------------------------------------------------------------------------------
PDUSessionResourceHandoverList::~PDUSessionResourceHandoverList() {}
//------------------------------------------------------------------------------
void PDUSessionResourceHandoverList::setPDUSessionResourceHandoverList(
const std::vector<PDUSessionResourceHandoverItem>& list) {
handoverItemList = list;
}
//------------------------------------------------------------------------------
void PDUSessionResourceHandoverList::getPDUSessionResourceHandoverList(
std::vector<PDUSessionResourceHandoverItem>& list) {
list = handoverItemList;
}
//------------------------------------------------------------------------------
bool PDUSessionResourceHandoverList::encode(
Ngap_PDUSessionResourceHandoverList_t& pduSessionResourceHandoverList) {
for (auto& item : handoverItemList) {
Ngap_PDUSessionResourceHandoverItem_t* handoverItem =
(Ngap_PDUSessionResourceHandoverItem_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceHandoverItem_t));
if (!handoverItem) return false;
if (!item.encode(*handoverItem)) return false;
if (ASN_SEQUENCE_ADD(&pduSessionResourceHandoverList.list, handoverItem) !=
0)
return false;
}
return true;
}
//------------------------------------------------------------------------------
bool PDUSessionResourceHandoverList::decode(
const Ngap_PDUSessionResourceHandoverList_t&
pduSessionResourceHandoverList) {
for (int i = 0; i < pduSessionResourceHandoverList.list.count; i++) {
PDUSessionResourceHandoverItem item = {};
if (!item.decode(*pduSessionResourceHandoverList.list.array[i]))
return false;
handoverItemList.push_back(item);
}
return true;
}
} // namespace ngap
/*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.1 (the "License"); you may not use this
* file except in compliance with the License. You may obtain a copy of the
* License at
*
* http://www.openairinterface.org/?page_id=698
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org
*/
#ifndef _PDU_SESSION_RESOURCE_HANDOVER_LIST_H_
#define _PDU_SESSION_RESOURCE_HANDOVER_LIST_H_
#include "PDUSessionResourceHandoverItem.hpp"
#include "vector"
extern "C" {
#include "Ngap_PDUSessionResourceHandoverList.h"
}
namespace ngap {
class PDUSessionResourceHandoverList {
public:
PDUSessionResourceHandoverList();
virtual ~PDUSessionResourceHandoverList();
void setPDUSessionResourceHandoverList(
const std::vector<PDUSessionResourceHandoverItem>& list);
void getPDUSessionResourceHandoverList(
std::vector<PDUSessionResourceHandoverItem>& list);
bool encode(
Ngap_PDUSessionResourceHandoverList_t& pduSessionResourceHandoverList);
bool decode(const Ngap_PDUSessionResourceHandoverList_t&
pduSessionResourceHandoverList);
private:
std::vector<PDUSessionResourceHandoverItem> handoverItemList;
};
} // namespace ngap
#endif
...@@ -19,54 +19,53 @@ ...@@ -19,54 +19,53 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author niuxiansheng-niu, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceItemHORqd.hpp" #include "PDUSessionResourceItemHORqd.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
PDUSessionResourceItemHORqd::PDUSessionResourceItemHORqd() {
pDUSessionID = NULL; //------------------------------------------------------------------------------
} PDUSessionResourceItemHORqd::PDUSessionResourceItemHORqd() {}
//------------------------------------------------------------------------------
PDUSessionResourceItemHORqd::~PDUSessionResourceItemHORqd() {} PDUSessionResourceItemHORqd::~PDUSessionResourceItemHORqd() {}
//------------------------------------------------------------------------------
void PDUSessionResourceItemHORqd::setPDUSessionResourceItemHORqd( void PDUSessionResourceItemHORqd::setPDUSessionResourceItemHORqd(
PDUSessionID* m_pDUSessionID, OCTET_STRING_t m_handoverrequiredtransfer) { const PDUSessionID& m_pDUSessionID,
const OCTET_STRING_t& m_handoverRequiredTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
handoverrequiredtransfer = m_handoverrequiredtransfer; handoverRequiredTransfer = m_handoverRequiredTransfer;
}
//------------------------------------------------------------------------------
void PDUSessionResourceItemHORqd::getPDUSessionResourceItemHORqd(
PDUSessionID& m_pDUSessionID, OCTET_STRING_t& m_handoverRequiredTransfer) {
m_pDUSessionID = pDUSessionID;
m_handoverRequiredTransfer = handoverRequiredTransfer;
} }
//------------------------------------------------------------------------------
bool PDUSessionResourceItemHORqd::encode2PDUSessionResourceItemHORqd( bool PDUSessionResourceItemHORqd::encode2PDUSessionResourceItemHORqd(
Ngap_PDUSessionResourceItemHORqd_t* pdUSessionResourceItemHORqd) { Ngap_PDUSessionResourceItemHORqd_t* pdUSessionResourceItemHORqd) {
if (!pDUSessionID) return false; if (!pDUSessionID.encode2PDUSessionID(
if (!pDUSessionID->encode2PDUSessionID(
pdUSessionResourceItemHORqd->pDUSessionID)) pdUSessionResourceItemHORqd->pDUSessionID))
return false; return false;
pdUSessionResourceItemHORqd->handoverRequiredTransfer = pdUSessionResourceItemHORqd->handoverRequiredTransfer =
handoverrequiredtransfer; handoverRequiredTransfer;
return true; return true;
} }
//------------------------------------------------------------------------------
bool PDUSessionResourceItemHORqd::decodefromPDUSessionResourceItemHORqd( bool PDUSessionResourceItemHORqd::decodefromPDUSessionResourceItemHORqd(
Ngap_PDUSessionResourceItemHORqd_t* pdUSessionResourceItemHORqd) { Ngap_PDUSessionResourceItemHORqd_t* pdUSessionResourceItemHORqd) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID(); if (!pDUSessionID.decodefromPDUSessionID(
if (!pDUSessionID->decodefromPDUSessionID(
pdUSessionResourceItemHORqd->pDUSessionID)) pdUSessionResourceItemHORqd->pDUSessionID))
return false; return false;
handoverrequiredtransfer = handoverRequiredTransfer =
pdUSessionResourceItemHORqd->handoverRequiredTransfer; pdUSessionResourceItemHORqd->handoverRequiredTransfer;
return true; return true;
} }
void PDUSessionResourceItemHORqd::getPDUSessionResourceItemHORqd(
PDUSessionID*& m_pDUSessionID, OCTET_STRING_t& m_handoverrequiredtransfer) {
m_pDUSessionID = pDUSessionID;
m_handoverrequiredtransfer = handoverrequiredtransfer;
}
} // namespace ngap } // namespace ngap
...@@ -19,17 +19,11 @@ ...@@ -19,17 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_ITEM_HO_RQD_H_
\brief #define _PDU_SESSION_RESOURCE_ITEM_HO_RQD_H_
\author niuxiansheng-niu, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCEITEMHORQD_H_
#define _PDUSESSIONRESOURCEITEMHQRQD_H_
#include "PDUSessionID.hpp" #include "PDUSessionID.hpp"
#include "PDUSessionResourceHandoverRequestAckTransfer.hpp"
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceItemHORqd.h" #include "Ngap_PDUSessionResourceItemHORqd.h"
} }
...@@ -42,10 +36,10 @@ class PDUSessionResourceItemHORqd { ...@@ -42,10 +36,10 @@ class PDUSessionResourceItemHORqd {
virtual ~PDUSessionResourceItemHORqd(); virtual ~PDUSessionResourceItemHORqd();
void setPDUSessionResourceItemHORqd( void setPDUSessionResourceItemHORqd(
PDUSessionID* m_pDUSessionID, OCTET_STRING_t m_handoverrequiredtransfer); const PDUSessionID& m_pDUSessionID,
const OCTET_STRING_t& m_handoverRequiredTransfer);
void getPDUSessionResourceItemHORqd( void getPDUSessionResourceItemHORqd(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID, OCTET_STRING_t& m_handoverRequiredTransfer);
OCTET_STRING_t& m_handoverrequiredtransfer);
bool encode2PDUSessionResourceItemHORqd( bool encode2PDUSessionResourceItemHORqd(
Ngap_PDUSessionResourceItemHORqd_t* pdUSessionResourceItemHORqd); Ngap_PDUSessionResourceItemHORqd_t* pdUSessionResourceItemHORqd);
...@@ -53,8 +47,8 @@ class PDUSessionResourceItemHORqd { ...@@ -53,8 +47,8 @@ class PDUSessionResourceItemHORqd {
Ngap_PDUSessionResourceItemHORqd_t* pdUSessionResourceItemHORqd); Ngap_PDUSessionResourceItemHORqd_t* pdUSessionResourceItemHORqd);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID; // Mandatory
OCTET_STRING_t handoverrequiredtransfer; OCTET_STRING_t handoverRequiredTransfer; // Mandatory
}; };
} // namespace ngap } // namespace ngap
......
...@@ -21,56 +21,53 @@ ...@@ -21,56 +21,53 @@
#include "PDUSessionResourceListHORqd.hpp" #include "PDUSessionResourceListHORqd.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
PDUSessionResourceListHORqd::PDUSessionResourceListHORqd() {
pduSessionResourceItemHORqd = NULL; //------------------------------------------------------------------------------
numofpduSessionResourceItemHORqd = 0; PDUSessionResourceListHORqd::PDUSessionResourceListHORqd() {}
}
//------------------------------------------------------------------------------
PDUSessionResourceListHORqd::~PDUSessionResourceListHORqd() {} PDUSessionResourceListHORqd::~PDUSessionResourceListHORqd() {}
//------------------------------------------------------------------------------
void PDUSessionResourceListHORqd::setPDUSessionResourceListHORqd( void PDUSessionResourceListHORqd::setPDUSessionResourceListHORqd(
PDUSessionResourceItemHORqd* m_pduSessionResourceItemHORqd, int num) { const std::vector<PDUSessionResourceItemHORqd>& list) {
pduSessionResourceItemHORqd = m_pduSessionResourceItemHORqd; itemHORqdList = list;
numofpduSessionResourceItemHORqd = num; }
//------------------------------------------------------------------------------
void PDUSessionResourceListHORqd::getPDUSessionResourceListHORqd(
std::vector<PDUSessionResourceItemHORqd>& list) {
list = itemHORqdList;
} }
//------------------------------------------------------------------------------
bool PDUSessionResourceListHORqd::encode2PDUSessionResourceListHORqd( bool PDUSessionResourceListHORqd::encode2PDUSessionResourceListHORqd(
Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd) { Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd) {
for (int i = 0; i < numofpduSessionResourceItemHORqd; i++) { for (auto& item : itemHORqdList) {
Ngap_PDUSessionResourceItemHORqd_t* response = Ngap_PDUSessionResourceItemHORqd_t* itemHORqd =
(Ngap_PDUSessionResourceItemHORqd_t*) calloc( (Ngap_PDUSessionResourceItemHORqd_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceItemHORqd_t)); 1, sizeof(Ngap_PDUSessionResourceItemHORqd_t));
if (!response) return false; if (!itemHORqd) return false;
if (!pduSessionResourceItemHORqd[i].encode2PDUSessionResourceItemHORqd( if (!item.encode2PDUSessionResourceItemHORqd(itemHORqd)) return false;
response)) if (ASN_SEQUENCE_ADD(&pduSessionResourceListHORQqd->list, itemHORqd) != 0)
return false;
if (ASN_SEQUENCE_ADD(&pduSessionResourceListHORQqd->list, response) != 0)
return false; return false;
} }
return true; return true;
} }
//------------------------------------------------------------------------------
bool PDUSessionResourceListHORqd::decodefromPDUSessionResourceListHORqd( bool PDUSessionResourceListHORqd::decodefromPDUSessionResourceListHORqd(
Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd) { Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd) {
numofpduSessionResourceItemHORqd = pduSessionResourceListHORQqd->list.count; for (int i = 0; i < pduSessionResourceListHORQqd->list.count; i++) {
pduSessionResourceItemHORqd = PDUSessionResourceItemHORqd item = {};
new PDUSessionResourceItemHORqd[numofpduSessionResourceItemHORqd](); if (!item.decodefromPDUSessionResourceItemHORqd(
for (int i = 0; i < numofpduSessionResourceItemHORqd; i++) {
if (!pduSessionResourceItemHORqd[i].decodefromPDUSessionResourceItemHORqd(
pduSessionResourceListHORQqd->list.array[i])) pduSessionResourceListHORQqd->list.array[i]))
return false; return false;
itemHORqdList.push_back(item);
} }
return true; return true;
} }
void PDUSessionResourceListHORqd::getPDUSessionResourceListHORqd(
PDUSessionResourceItemHORqd*& m_pduSessionResourceItemHORqd, int& num) {
if (pduSessionResourceItemHORqd) {
m_pduSessionResourceItemHORqd = pduSessionResourceItemHORqd;
num = numofpduSessionResourceItemHORqd;
}
}
} // namespace ngap } // namespace ngap
...@@ -19,10 +19,11 @@ ...@@ -19,10 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
#ifndef _PDUSESSIONRESOURCELISTHORqd_H_ #ifndef _PDU_SESSION_RESOURCE_LIST_HO_RQD_H_
#define _PDUSESSIONRESOURCELISTHORqd_H_ #define _PDU_SESSION_RESOURCE_LIST_HO_RQD_H_
#include "PDUSessionResourceItemHORqd.hpp" #include "PDUSessionResourceItemHORqd.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceListHORqd.h" #include "Ngap_PDUSessionResourceListHORqd.h"
...@@ -36,9 +37,9 @@ class PDUSessionResourceListHORqd { ...@@ -36,9 +37,9 @@ class PDUSessionResourceListHORqd {
virtual ~PDUSessionResourceListHORqd(); virtual ~PDUSessionResourceListHORqd();
void setPDUSessionResourceListHORqd( void setPDUSessionResourceListHORqd(
PDUSessionResourceItemHORqd* m_pduSessionResourceItemHORqd, int num); const std::vector<PDUSessionResourceItemHORqd>& list);
void getPDUSessionResourceListHORqd( void getPDUSessionResourceListHORqd(
PDUSessionResourceItemHORqd*& m_pduSessionResourceItemHORqd, int& num); std::vector<PDUSessionResourceItemHORqd>& list);
bool encode2PDUSessionResourceListHORqd( bool encode2PDUSessionResourceListHORqd(
Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd); Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd);
...@@ -46,8 +47,7 @@ class PDUSessionResourceListHORqd { ...@@ -46,8 +47,7 @@ class PDUSessionResourceListHORqd {
Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd); Ngap_PDUSessionResourceListHORqd_t* pduSessionResourceListHORQqd);
private: private:
PDUSessionResourceItemHORqd* pduSessionResourceItemHORqd; std::vector<PDUSessionResourceItemHORqd> itemHORqdList;
int numofpduSessionResourceItemHORqd;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,18 +19,8 @@ ...@@ -19,18 +19,8 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author
\date
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceModifyItemModReq.hpp" #include "PDUSessionResourceModifyItemModReq.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -45,7 +35,7 @@ PDUSessionResourceModifyItemModReq::~PDUSessionResourceModifyItemModReq() {} ...@@ -45,7 +35,7 @@ PDUSessionResourceModifyItemModReq::~PDUSessionResourceModifyItemModReq() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceModifyItemModReq::setPDUSessionResourceModifyItemModReq( void PDUSessionResourceModifyItemModReq::setPDUSessionResourceModifyItemModReq(
const PDUSessionID& m_pDUSessionID, const NAS_PDU& m_nAS_PDU, const PDUSessionID& m_pDUSessionID, const NAS_PDU& m_nAS_PDU,
const OCTET_STRING_t m_pDUSessionResourceModifyRequestTransfer, const OCTET_STRING_t& m_pDUSessionResourceModifyRequestTransfer,
const S_NSSAI& m_s_NSSAI) { const S_NSSAI& m_s_NSSAI) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
uint8_t* nas_buf = nullptr; uint8_t* nas_buf = nullptr;
......
...@@ -19,13 +19,6 @@ ...@@ -19,13 +19,6 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author
\date
\email: contact@openairinterface.org
*/
#ifndef _PDU_SESSION_RESOURCE_MODIFY_ITEM_MOD_REQ_H_ #ifndef _PDU_SESSION_RESOURCE_MODIFY_ITEM_MOD_REQ_H_
#define _PDU_SESSION_RESOURCE_MODIFY_ITEM_MOD_REQ_H_ #define _PDU_SESSION_RESOURCE_MODIFY_ITEM_MOD_REQ_H_
...@@ -46,7 +39,7 @@ class PDUSessionResourceModifyItemModReq { ...@@ -46,7 +39,7 @@ class PDUSessionResourceModifyItemModReq {
void setPDUSessionResourceModifyItemModReq( void setPDUSessionResourceModifyItemModReq(
const PDUSessionID& m_pDUSessionID, const NAS_PDU& m_nAS_PDU, const PDUSessionID& m_pDUSessionID, const NAS_PDU& m_nAS_PDU,
const OCTET_STRING_t m_pDUSessionResourceModifyRequestTransfer, const OCTET_STRING_t& m_pDUSessionResourceModifyRequestTransfer,
const S_NSSAI& m_s_NSSAI); const S_NSSAI& m_s_NSSAI);
void getPDUSessionResourceModifyItemModReq( void getPDUSessionResourceModifyItemModReq(
PDUSessionID& m_pDUSessionID, NAS_PDU& m_nAS_PDU, PDUSessionID& m_pDUSessionID, NAS_PDU& m_nAS_PDU,
...@@ -61,10 +54,10 @@ class PDUSessionResourceModifyItemModReq { ...@@ -61,10 +54,10 @@ class PDUSessionResourceModifyItemModReq {
pduSessionResourceModifyItemModReq); pduSessionResourceModifyItemModReq);
private: private:
PDUSessionID pDUSessionID; PDUSessionID pDUSessionID; // Mandatory
NAS_PDU* nAS_PDU; // Optional NAS_PDU* nAS_PDU; // Optional
OCTET_STRING_t pDUSessionResourceModifyRequestTransfer; OCTET_STRING_t pDUSessionResourceModifyRequestTransfer; // Mandatory
S_NSSAI* s_NSSAI; // Optional S_NSSAI* s_NSSAI; // Optional
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,21 +19,12 @@ ...@@ -19,21 +19,12 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU (BUPT), Tien-Thinh NGUYEN (EURECOM)
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceReleasedItemRelRes.hpp" #include "PDUSessionResourceReleasedItemRelRes.hpp"
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceReleasedItemRelRes::PDUSessionResourceReleasedItemRelRes() { PDUSessionResourceReleasedItemRelRes::PDUSessionResourceReleasedItemRelRes() {}
pDUSessionID = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceReleasedItemRelRes::~PDUSessionResourceReleasedItemRelRes() {} PDUSessionResourceReleasedItemRelRes::~PDUSessionResourceReleasedItemRelRes() {}
...@@ -41,8 +32,8 @@ PDUSessionResourceReleasedItemRelRes::~PDUSessionResourceReleasedItemRelRes() {} ...@@ -41,8 +32,8 @@ PDUSessionResourceReleasedItemRelRes::~PDUSessionResourceReleasedItemRelRes() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceReleasedItemRelRes:: void PDUSessionResourceReleasedItemRelRes::
setPDUSessionResourceReleasedItemRelRes( setPDUSessionResourceReleasedItemRelRes(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceReleaseResponseTransfer) { const OCTET_STRING_t& m_pDUSessionResourceReleaseResponseTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
pDUSessionResourceReleaseResponseTransfer = pDUSessionResourceReleaseResponseTransfer =
m_pDUSessionResourceReleaseResponseTransfer; m_pDUSessionResourceReleaseResponseTransfer;
...@@ -51,7 +42,7 @@ void PDUSessionResourceReleasedItemRelRes:: ...@@ -51,7 +42,7 @@ void PDUSessionResourceReleasedItemRelRes::
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceReleasedItemRelRes:: void PDUSessionResourceReleasedItemRelRes::
getPDUSessionResourceReleasedItemRelRes( getPDUSessionResourceReleasedItemRelRes(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceReleaseResponseTransfer) { OCTET_STRING_t& m_pDUSessionResourceReleaseResponseTransfer) {
m_pDUSessionID = pDUSessionID; m_pDUSessionID = pDUSessionID;
m_pDUSessionResourceReleaseResponseTransfer = m_pDUSessionResourceReleaseResponseTransfer =
...@@ -63,7 +54,7 @@ bool PDUSessionResourceReleasedItemRelRes:: ...@@ -63,7 +54,7 @@ bool PDUSessionResourceReleasedItemRelRes::
encode2PDUSessionResourceReleasedItemRelRes( encode2PDUSessionResourceReleasedItemRelRes(
Ngap_PDUSessionResourceReleasedItemRelRes_t* Ngap_PDUSessionResourceReleasedItemRelRes_t*
pduSessionResourceReleasedItemRelRes) { pduSessionResourceReleasedItemRelRes) {
if (!pDUSessionID->encode2PDUSessionID( if (!pDUSessionID.encode2PDUSessionID(
pduSessionResourceReleasedItemRelRes->pDUSessionID)) pduSessionResourceReleasedItemRelRes->pDUSessionID))
return false; return false;
...@@ -79,8 +70,7 @@ bool PDUSessionResourceReleasedItemRelRes:: ...@@ -79,8 +70,7 @@ bool PDUSessionResourceReleasedItemRelRes::
decodefromPDUSessionResourceReleasedItemRelRes( decodefromPDUSessionResourceReleasedItemRelRes(
Ngap_PDUSessionResourceReleasedItemRelRes_t* Ngap_PDUSessionResourceReleasedItemRelRes_t*
pduSessionResourceReleasedItemRelRes) { pduSessionResourceReleasedItemRelRes) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID(); pDUSessionID.setPDUSessionID(
pDUSessionID->setPDUSessionID(
pduSessionResourceReleasedItemRelRes->pDUSessionID); pduSessionResourceReleasedItemRelRes->pDUSessionID);
pDUSessionResourceReleaseResponseTransfer = pDUSessionResourceReleaseResponseTransfer =
pduSessionResourceReleasedItemRelRes pduSessionResourceReleasedItemRelRes
......
...@@ -19,13 +19,6 @@ ...@@ -19,13 +19,6 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU (BUPT), Tien-Thinh NGUYEN (EURECOM)
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDU_SESSION_RESOURCE_RELEASED_ITEM_REL_RES_H_ #ifndef _PDU_SESSION_RESOURCE_RELEASED_ITEM_REL_RES_H_
#define _PDU_SESSION_RESOURCE_RELEASED_ITEM_REL_RES_H_ #define _PDU_SESSION_RESOURCE_RELEASED_ITEM_REL_RES_H_
...@@ -43,11 +36,11 @@ class PDUSessionResourceReleasedItemRelRes { ...@@ -43,11 +36,11 @@ class PDUSessionResourceReleasedItemRelRes {
virtual ~PDUSessionResourceReleasedItemRelRes(); virtual ~PDUSessionResourceReleasedItemRelRes();
void setPDUSessionResourceReleasedItemRelRes( void setPDUSessionResourceReleasedItemRelRes(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceReleaseResponseTransfer); const OCTET_STRING_t& m_pDUSessionResourceReleaseResponseTransfer);
void getPDUSessionResourceReleasedItemRelRes( void getPDUSessionResourceReleasedItemRelRes(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceReleaseResponseTransfer); OCTET_STRING_t& m_pDUSessionResourceReleaseResponseTransfer);
bool encode2PDUSessionResourceReleasedItemRelRes( bool encode2PDUSessionResourceReleasedItemRelRes(
...@@ -58,9 +51,8 @@ class PDUSessionResourceReleasedItemRelRes { ...@@ -58,9 +51,8 @@ class PDUSessionResourceReleasedItemRelRes {
pduSessionResourceReleasedItemRelRes); pduSessionResourceReleasedItemRelRes);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID;
OCTET_STRING_t pDUSessionResourceReleaseResponseTransfer; OCTET_STRING_t pDUSessionResourceReleaseResponseTransfer;
// ProtocolExtensionContainer (OPTIONAL)
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,22 +19,12 @@ ...@@ -19,22 +19,12 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU (BUPT), Tien-Thinh NGUYEN (EURECOM)
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceReleasedListRelRes.hpp" #include "PDUSessionResourceReleasedListRelRes.hpp"
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceReleasedListRelRes::PDUSessionResourceReleasedListRelRes() { PDUSessionResourceReleasedListRelRes::PDUSessionResourceReleasedListRelRes() {}
pduSessionResourceReleasedItemRelRes = NULL;
maxnoofPDUSessions = 0;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceReleasedListRelRes::~PDUSessionResourceReleasedListRelRes() {} PDUSessionResourceReleasedListRelRes::~PDUSessionResourceReleasedListRelRes() {}
...@@ -42,21 +32,15 @@ PDUSessionResourceReleasedListRelRes::~PDUSessionResourceReleasedListRelRes() {} ...@@ -42,21 +32,15 @@ PDUSessionResourceReleasedListRelRes::~PDUSessionResourceReleasedListRelRes() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceReleasedListRelRes:: void PDUSessionResourceReleasedListRelRes::
setPDUSessionResourceReleasedListRelRes( setPDUSessionResourceReleasedListRelRes(
PDUSessionResourceReleasedItemRelRes* const std::vector<PDUSessionResourceReleasedItemRelRes>& list) {
m_pduSessionResourceReleasedItemRelRes, itemRelResList = list;
int num) {
pduSessionResourceReleasedItemRelRes = m_pduSessionResourceReleasedItemRelRes;
maxnoofPDUSessions = num;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceReleasedListRelRes:: void PDUSessionResourceReleasedListRelRes::
getPDUSessionResourceReleasedListRelRes( getPDUSessionResourceReleasedListRelRes(
PDUSessionResourceReleasedItemRelRes*& std::vector<PDUSessionResourceReleasedItemRelRes>& list) {
m_pduSessionResourceReleasedItemRelRes, list = itemRelResList;
int& num) {
m_pduSessionResourceReleasedItemRelRes = pduSessionResourceReleasedItemRelRes;
num = maxnoofPDUSessions;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -64,14 +48,12 @@ bool PDUSessionResourceReleasedListRelRes:: ...@@ -64,14 +48,12 @@ bool PDUSessionResourceReleasedListRelRes::
encode2PDUSessionResourceReleasedListRelRes( encode2PDUSessionResourceReleasedListRelRes(
Ngap_PDUSessionResourceReleasedListRelRes_t* Ngap_PDUSessionResourceReleasedListRelRes_t*
pduSessionResourceReleasedListRelRes) { pduSessionResourceReleasedListRelRes) {
for (int i = 0; i < maxnoofPDUSessions; i++) { for (auto& item : itemRelResList) {
Ngap_PDUSessionResourceReleasedItemRelRes_t* rel = Ngap_PDUSessionResourceReleasedItemRelRes_t* rel =
(Ngap_PDUSessionResourceReleasedItemRelRes_t*) calloc( (Ngap_PDUSessionResourceReleasedItemRelRes_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceReleasedItemRelRes_t)); 1, sizeof(Ngap_PDUSessionResourceReleasedItemRelRes_t));
if (!rel) return false; if (!rel) return false;
if (!pduSessionResourceReleasedItemRelRes[i] if (!item.encode2PDUSessionResourceReleasedItemRelRes(rel)) return false;
.encode2PDUSessionResourceReleasedItemRelRes(rel))
return false;
if (ASN_SEQUENCE_ADD(&pduSessionResourceReleasedListRelRes->list, rel) != 0) if (ASN_SEQUENCE_ADD(&pduSessionResourceReleasedListRelRes->list, rel) != 0)
return false; return false;
} }
...@@ -83,14 +65,12 @@ bool PDUSessionResourceReleasedListRelRes:: ...@@ -83,14 +65,12 @@ bool PDUSessionResourceReleasedListRelRes::
decodefromPDUSessionResourceReleasedListRelRes( decodefromPDUSessionResourceReleasedListRelRes(
Ngap_PDUSessionResourceReleasedListRelRes_t* Ngap_PDUSessionResourceReleasedListRelRes_t*
pduSessionResourceReleasedListRelRes) { pduSessionResourceReleasedListRelRes) {
maxnoofPDUSessions = pduSessionResourceReleasedListRelRes->list.count; for (int i = 0; i < pduSessionResourceReleasedListRelRes->list.count; i++) {
pduSessionResourceReleasedItemRelRes = PDUSessionResourceReleasedItemRelRes item = {};
new PDUSessionResourceReleasedItemRelRes[maxnoofPDUSessions](); if (!item.decodefromPDUSessionResourceReleasedItemRelRes(
for (int i = 0; i < maxnoofPDUSessions; i++) { pduSessionResourceReleasedListRelRes->list.array[i]))
if (!pduSessionResourceReleasedItemRelRes[i]
.decodefromPDUSessionResourceReleasedItemRelRes(
pduSessionResourceReleasedListRelRes->list.array[i]))
return false; return false;
itemRelResList.push_back(item);
} }
return true; return true;
} }
......
...@@ -19,17 +19,11 @@ ...@@ -19,17 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU (BUPT), Tien-Thinh NGUYEN (EURECOM)
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDU_SESSION_RESOURCE_RELEASED_LIST_REL_RES_H_ #ifndef _PDU_SESSION_RESOURCE_RELEASED_LIST_REL_RES_H_
#define _PDU_SESSION_RESOURCE_RELEASED_LIST_REL_RES_H_ #define _PDU_SESSION_RESOURCE_RELEASED_LIST_REL_RES_H_
#include "PDUSessionResourceReleasedItemRelRes.hpp" #include "PDUSessionResourceReleasedItemRelRes.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceReleasedItemRelRes.h" #include "Ngap_PDUSessionResourceReleasedItemRelRes.h"
...@@ -44,14 +38,10 @@ class PDUSessionResourceReleasedListRelRes { ...@@ -44,14 +38,10 @@ class PDUSessionResourceReleasedListRelRes {
virtual ~PDUSessionResourceReleasedListRelRes(); virtual ~PDUSessionResourceReleasedListRelRes();
void setPDUSessionResourceReleasedListRelRes( void setPDUSessionResourceReleasedListRelRes(
PDUSessionResourceReleasedItemRelRes* const std::vector<PDUSessionResourceReleasedItemRelRes>& list);
m_pduSessionResourceReleasedItemRelRes,
int num);
void getPDUSessionResourceReleasedListRelRes( void getPDUSessionResourceReleasedListRelRes(
PDUSessionResourceReleasedItemRelRes*& std::vector<PDUSessionResourceReleasedItemRelRes>& list);
m_pduSessionResourceReleasedItemRelRes,
int& num);
bool encode2PDUSessionResourceReleasedListRelRes( bool encode2PDUSessionResourceReleasedListRelRes(
Ngap_PDUSessionResourceReleasedListRelRes_t* Ngap_PDUSessionResourceReleasedListRelRes_t*
...@@ -62,8 +52,7 @@ class PDUSessionResourceReleasedListRelRes { ...@@ -62,8 +52,7 @@ class PDUSessionResourceReleasedListRelRes {
pduSessionResourceReleasedListRelRes); pduSessionResourceReleasedListRelRes);
private: private:
PDUSessionResourceReleasedItemRelRes* pduSessionResourceReleasedItemRelRes; std::vector<PDUSessionResourceReleasedItemRelRes> itemRelResList;
int maxnoofPDUSessions;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,29 +19,18 @@ ...@@ -19,29 +19,18 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceSetupItemCxtReq.hpp" #include "PDUSessionResourceSetupItemCxtReq.hpp"
//#include "dynamic_memory_check.h" #include "logger.hpp"
extern "C" { extern "C" {
#include "dynamic_memory_check.h" #include "dynamic_memory_check.h"
} }
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupItemCxtReq::PDUSessionResourceSetupItemCxtReq() { PDUSessionResourceSetupItemCxtReq::PDUSessionResourceSetupItemCxtReq() {
pDUSessionID = NULL; nAS_PDU = nullptr;
nAS_PDU = NULL;
s_NSSAI = NULL;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -49,8 +38,9 @@ PDUSessionResourceSetupItemCxtReq::~PDUSessionResourceSetupItemCxtReq() {} ...@@ -49,8 +38,9 @@ PDUSessionResourceSetupItemCxtReq::~PDUSessionResourceSetupItemCxtReq() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceSetupItemCxtReq::setPDUSessionResourceSetupItemCxtReq( void PDUSessionResourceSetupItemCxtReq::setPDUSessionResourceSetupItemCxtReq(
PDUSessionID* m_pDUSessionID, NAS_PDU* m_nAS_PDU, S_NSSAI* m_s_NSSAI, const PDUSessionID& m_pDUSessionID, NAS_PDU*& m_nAS_PDU,
OCTET_STRING_t m_pDUSessionResourceSetupRequestTransfer) { const S_NSSAI& m_s_NSSAI,
const OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
nAS_PDU = m_nAS_PDU; nAS_PDU = m_nAS_PDU;
s_NSSAI = m_s_NSSAI; s_NSSAI = m_s_NSSAI;
...@@ -58,18 +48,27 @@ void PDUSessionResourceSetupItemCxtReq::setPDUSessionResourceSetupItemCxtReq( ...@@ -58,18 +48,27 @@ void PDUSessionResourceSetupItemCxtReq::setPDUSessionResourceSetupItemCxtReq(
m_pDUSessionResourceSetupRequestTransfer; m_pDUSessionResourceSetupRequestTransfer;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupItemCxtReq::getPDUSessionResourceSetupItemCxtReq(
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;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceSetupItemCxtReq:: bool PDUSessionResourceSetupItemCxtReq::
encode2PDUSessionResourceSetupItemCxtReq( encode2PDUSessionResourceSetupItemCxtReq(
Ngap_PDUSessionResourceSetupItemCxtReq_t* Ngap_PDUSessionResourceSetupItemCxtReq_t*
pduSessionResourceSetupItemCxtReq) { pduSessionResourceSetupItemCxtReq) {
cout << "encode2pdu pdusession_id" << endl; if (!pDUSessionID.encode2PDUSessionID(
if (!pDUSessionID->encode2PDUSessionID(
pduSessionResourceSetupItemCxtReq->pDUSessionID)) pduSessionResourceSetupItemCxtReq->pDUSessionID))
return false; return false;
cout << "encode2pdu pdusession_id over" << endl;
if (nAS_PDU) { if (nAS_PDU) {
cout << "encode2pdu nas-pdu" << endl;
Ngap_NAS_PDU_t* naspdu = Ngap_NAS_PDU_t* naspdu =
(Ngap_NAS_PDU_t*) calloc(1, sizeof(Ngap_NAS_PDU_t)); (Ngap_NAS_PDU_t*) calloc(1, sizeof(Ngap_NAS_PDU_t));
if (!naspdu) return false; if (!naspdu) return false;
...@@ -78,12 +77,10 @@ bool PDUSessionResourceSetupItemCxtReq:: ...@@ -78,12 +77,10 @@ bool PDUSessionResourceSetupItemCxtReq::
return false; return false;
} }
pduSessionResourceSetupItemCxtReq->nAS_PDU = naspdu; pduSessionResourceSetupItemCxtReq->nAS_PDU = naspdu;
cout << "encode2pdu nas-pdu over" << endl;
} }
cout << "encode2pdu nssai" << endl;
if (!s_NSSAI->encode2S_NSSAI(&pduSessionResourceSetupItemCxtReq->s_NSSAI)) if (!s_NSSAI.encode2S_NSSAI(&pduSessionResourceSetupItemCxtReq->s_NSSAI))
return false; return false;
cout << "encode2pdu nssai over" << endl;
pduSessionResourceSetupItemCxtReq->pDUSessionResourceSetupRequestTransfer = pduSessionResourceSetupItemCxtReq->pDUSessionResourceSetupRequestTransfer =
pDUSessionResourceSetupRequestTransfer; pDUSessionResourceSetupRequestTransfer;
...@@ -95,13 +92,10 @@ bool PDUSessionResourceSetupItemCxtReq:: ...@@ -95,13 +92,10 @@ bool PDUSessionResourceSetupItemCxtReq::
decodefromPDUSessionResourceSetupItemCxtReq( decodefromPDUSessionResourceSetupItemCxtReq(
Ngap_PDUSessionResourceSetupItemCxtReq_t* Ngap_PDUSessionResourceSetupItemCxtReq_t*
pduSessionResourceSetupItemCxtReq) { pduSessionResourceSetupItemCxtReq) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID(); if (!pDUSessionID.decodefromPDUSessionID(
if (s_NSSAI == nullptr) s_NSSAI = new S_NSSAI();
if (!pDUSessionID->decodefromPDUSessionID(
pduSessionResourceSetupItemCxtReq->pDUSessionID)) pduSessionResourceSetupItemCxtReq->pDUSessionID))
return false; return false;
if (!s_NSSAI->decodefromS_NSSAI( if (!s_NSSAI.decodefromS_NSSAI(&(pduSessionResourceSetupItemCxtReq->s_NSSAI)))
&(pduSessionResourceSetupItemCxtReq->s_NSSAI)))
return false; return false;
if (pduSessionResourceSetupItemCxtReq->nAS_PDU) { if (pduSessionResourceSetupItemCxtReq->nAS_PDU) {
...@@ -117,15 +111,4 @@ bool PDUSessionResourceSetupItemCxtReq:: ...@@ -117,15 +111,4 @@ bool PDUSessionResourceSetupItemCxtReq::
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupItemCxtReq::getPDUSessionResourceSetupItemCxtReq(
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;
}
} // namespace ngap } // namespace ngap
...@@ -19,20 +19,13 @@ ...@@ -19,20 +19,13 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_SETUP_ITEM_CXT_REQ_H_
\brief #define _PDU_SESSION_RESOURCE_SETUP_ITEM_CXT_REQ_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCESETUPITEMCXTREQ_H_
#define _PDUSESSIONRESOURCESETUPITEMCXTREQ_H_
#include "NAS-PDU.hpp" #include "NAS-PDU.hpp"
#include "PDUSessionID.hpp" #include "PDUSessionID.hpp"
#include "S-NSSAI.hpp" #include "S-NSSAI.hpp"
//#include "PDUSessionResourceSetupRequestTransfer.hpp" #include <vector>
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceSetupItemCxtReq.h" #include "Ngap_PDUSessionResourceSetupItemCxtReq.h"
...@@ -46,10 +39,11 @@ class PDUSessionResourceSetupItemCxtReq { ...@@ -46,10 +39,11 @@ class PDUSessionResourceSetupItemCxtReq {
virtual ~PDUSessionResourceSetupItemCxtReq(); virtual ~PDUSessionResourceSetupItemCxtReq();
void setPDUSessionResourceSetupItemCxtReq( void setPDUSessionResourceSetupItemCxtReq(
PDUSessionID* m_pDUSessionID, NAS_PDU* m_nAS_PDU, S_NSSAI* m_s_NSSAI, const PDUSessionID& m_pDUSessionID, NAS_PDU*& m_nAS_PDU,
OCTET_STRING_t m_pDUSessionResourceSetupRequestTransfer); const S_NSSAI& m_s_NSSAI,
const OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer);
void getPDUSessionResourceSetupItemCxtReq( void getPDUSessionResourceSetupItemCxtReq(
PDUSessionID*& m_pDUSessionID, NAS_PDU*& m_nAS_PDU, S_NSSAI*& m_s_NSSAI, PDUSessionID& m_pDUSessionID, NAS_PDU*& m_nAS_PDU, S_NSSAI& m_s_NSSAI,
OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer); OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer);
bool encode2PDUSessionResourceSetupItemCxtReq( bool encode2PDUSessionResourceSetupItemCxtReq(
...@@ -60,12 +54,10 @@ class PDUSessionResourceSetupItemCxtReq { ...@@ -60,12 +54,10 @@ class PDUSessionResourceSetupItemCxtReq {
pduSessionResourceSetupItemCxtReq); pduSessionResourceSetupItemCxtReq);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID; // Mandatory
NAS_PDU* nAS_PDU; /* OPTIONAL */ NAS_PDU* nAS_PDU; // Optional
S_NSSAI* s_NSSAI; S_NSSAI s_NSSAI; // Mandatory
// PduSessionResourceSetupRequestTransferIE OCTET_STRING_t pDUSessionResourceSetupRequestTransfer; // Mandatory
// *pduSessionResourceSetupRequestTransfer;
OCTET_STRING_t pDUSessionResourceSetupRequestTransfer;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,44 +19,40 @@ ...@@ -19,44 +19,40 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceSetupItemCxtRes.hpp" #include "PDUSessionResourceSetupItemCxtRes.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupItemCxtRes::PDUSessionResourceSetupItemCxtRes() { PDUSessionResourceSetupItemCxtRes::PDUSessionResourceSetupItemCxtRes() {}
pDUSessionID = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupItemCxtRes::~PDUSessionResourceSetupItemCxtRes() {} PDUSessionResourceSetupItemCxtRes::~PDUSessionResourceSetupItemCxtRes() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceSetupItemCxtRes::setPDUSessionResourceSetupItemCxtRes( void PDUSessionResourceSetupItemCxtRes::setPDUSessionResourceSetupItemCxtRes(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceSetupResponseTransfer) { const OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
pDUSessionResourceSetupResponseTransfer = pDUSessionResourceSetupResponseTransfer =
m_pDUSessionResourceSetupResponseTransfer; m_pDUSessionResourceSetupResponseTransfer;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupItemCxtRes::getPDUSessionResourceSetupItemCxtRes(
PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer) {
m_pDUSessionID = pDUSessionID;
m_pDUSessionResourceSetupResponseTransfer =
pDUSessionResourceSetupResponseTransfer;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceSetupItemCxtRes:: bool PDUSessionResourceSetupItemCxtRes::
encode2PDUSessionResourceSetupItemCxtRes( encode2PDUSessionResourceSetupItemCxtRes(
Ngap_PDUSessionResourceSetupItemCxtRes_t* Ngap_PDUSessionResourceSetupItemCxtRes_t*
pduSessionResourceSetupItemCxtRes) { pduSessionResourceSetupItemCxtRes) {
if (!pDUSessionID) return false; if (!pDUSessionID.encode2PDUSessionID(
if (!pDUSessionID->encode2PDUSessionID(
pduSessionResourceSetupItemCxtRes->pDUSessionID)) pduSessionResourceSetupItemCxtRes->pDUSessionID))
return false; return false;
pduSessionResourceSetupItemCxtRes->pDUSessionResourceSetupResponseTransfer = pduSessionResourceSetupItemCxtRes->pDUSessionResourceSetupResponseTransfer =
...@@ -70,8 +66,7 @@ bool PDUSessionResourceSetupItemCxtRes:: ...@@ -70,8 +66,7 @@ bool PDUSessionResourceSetupItemCxtRes::
decodefromPDUSessionResourceSetupItemCxtRes( decodefromPDUSessionResourceSetupItemCxtRes(
Ngap_PDUSessionResourceSetupItemCxtRes_t* Ngap_PDUSessionResourceSetupItemCxtRes_t*
pduSessionResourceSetupItemCxtRes) { pduSessionResourceSetupItemCxtRes) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID(); if (!pDUSessionID.decodefromPDUSessionID(
if (!pDUSessionID->decodefromPDUSessionID(
pduSessionResourceSetupItemCxtRes->pDUSessionID)) pduSessionResourceSetupItemCxtRes->pDUSessionID))
return false; return false;
pDUSessionResourceSetupResponseTransfer = pDUSessionResourceSetupResponseTransfer =
...@@ -81,13 +76,4 @@ bool PDUSessionResourceSetupItemCxtRes:: ...@@ -81,13 +76,4 @@ bool PDUSessionResourceSetupItemCxtRes::
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupItemCxtRes::getPDUSessionResourceSetupItemCxtRes(
PDUSessionID*& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer) {
m_pDUSessionID = pDUSessionID;
m_pDUSessionResourceSetupResponseTransfer =
pDUSessionResourceSetupResponseTransfer;
}
} // namespace ngap } // namespace ngap
...@@ -19,15 +19,8 @@ ...@@ -19,15 +19,8 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_SETUP_ITEM_CXT_RES_H_
\brief #define _PDU_SESSION_RESOURCE_SETUP_ITEM_CXT_RES_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCESETUPITEMCXTRES_H_
#define _PDUSESSIONRESOURCESETUPITEMCXTRES_H_
#include "PDUSessionID.hpp" #include "PDUSessionID.hpp"
...@@ -43,10 +36,10 @@ class PDUSessionResourceSetupItemCxtRes { ...@@ -43,10 +36,10 @@ class PDUSessionResourceSetupItemCxtRes {
virtual ~PDUSessionResourceSetupItemCxtRes(); virtual ~PDUSessionResourceSetupItemCxtRes();
void setPDUSessionResourceSetupItemCxtRes( void setPDUSessionResourceSetupItemCxtRes(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceSetupResponseTransfer); const OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer);
void getPDUSessionResourceSetupItemCxtRes( void getPDUSessionResourceSetupItemCxtRes(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer); OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer);
bool encode2PDUSessionResourceSetupItemCxtRes( bool encode2PDUSessionResourceSetupItemCxtRes(
...@@ -57,8 +50,8 @@ class PDUSessionResourceSetupItemCxtRes { ...@@ -57,8 +50,8 @@ class PDUSessionResourceSetupItemCxtRes {
pduSessionResourceSetupItemCxtRes); pduSessionResourceSetupItemCxtRes);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID; // Mandatory
OCTET_STRING_t pDUSessionResourceSetupResponseTransfer; OCTET_STRING_t pDUSessionResourceSetupResponseTransfer; // Mandatory
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,28 +19,17 @@ ...@@ -19,28 +19,17 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceSetupItemSUReq.hpp" #include "PDUSessionResourceSetupItemSUReq.hpp"
extern "C" { extern "C" {
#include "dynamic_memory_check.h" #include "dynamic_memory_check.h"
} }
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupItemSUReq::PDUSessionResourceSetupItemSUReq() { PDUSessionResourceSetupItemSUReq::PDUSessionResourceSetupItemSUReq() {
pDUSessionID = NULL; nAS_PDU = nullptr;
nAS_PDU = NULL;
s_NSSAI = NULL;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -48,8 +37,9 @@ PDUSessionResourceSetupItemSUReq::~PDUSessionResourceSetupItemSUReq() {} ...@@ -48,8 +37,9 @@ PDUSessionResourceSetupItemSUReq::~PDUSessionResourceSetupItemSUReq() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceSetupItemSUReq::setPDUSessionResourceSetupItemSUReq( void PDUSessionResourceSetupItemSUReq::setPDUSessionResourceSetupItemSUReq(
PDUSessionID* m_pDUSessionID, NAS_PDU* m_nAS_PDU, S_NSSAI* m_s_NSSAI, const PDUSessionID& m_pDUSessionID, NAS_PDU* m_nAS_PDU,
OCTET_STRING_t m_pDUSessionResourceSetupRequestTransfer) { const S_NSSAI& m_s_NSSAI,
const OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
nAS_PDU = m_nAS_PDU; nAS_PDU = m_nAS_PDU;
s_NSSAI = m_s_NSSAI; s_NSSAI = m_s_NSSAI;
...@@ -57,10 +47,21 @@ void PDUSessionResourceSetupItemSUReq::setPDUSessionResourceSetupItemSUReq( ...@@ -57,10 +47,21 @@ void PDUSessionResourceSetupItemSUReq::setPDUSessionResourceSetupItemSUReq(
m_pDUSessionResourceSetupRequestTransfer; m_pDUSessionResourceSetupRequestTransfer;
} }
//------------------------------------------------------------------------------
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;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceSetupItemSUReq::encode2PDUSessionResourceSetupItemSUReq( bool PDUSessionResourceSetupItemSUReq::encode2PDUSessionResourceSetupItemSUReq(
Ngap_PDUSessionResourceSetupItemSUReq_t* pduSessionResourceSetupItemSUReq) { Ngap_PDUSessionResourceSetupItemSUReq_t* pduSessionResourceSetupItemSUReq) {
if (!pDUSessionID->encode2PDUSessionID( if (!pDUSessionID.encode2PDUSessionID(
pduSessionResourceSetupItemSUReq->pDUSessionID)) pduSessionResourceSetupItemSUReq->pDUSessionID))
return false; return false;
if (nAS_PDU) { if (nAS_PDU) {
...@@ -73,7 +74,7 @@ bool PDUSessionResourceSetupItemSUReq::encode2PDUSessionResourceSetupItemSUReq( ...@@ -73,7 +74,7 @@ bool PDUSessionResourceSetupItemSUReq::encode2PDUSessionResourceSetupItemSUReq(
} }
pduSessionResourceSetupItemSUReq->pDUSessionNAS_PDU = naspdu; pduSessionResourceSetupItemSUReq->pDUSessionNAS_PDU = naspdu;
} }
if (!s_NSSAI->encode2S_NSSAI(&pduSessionResourceSetupItemSUReq->s_NSSAI)) if (!s_NSSAI.encode2S_NSSAI(&pduSessionResourceSetupItemSUReq->s_NSSAI))
return false; return false;
pduSessionResourceSetupItemSUReq->pDUSessionResourceSetupRequestTransfer = pduSessionResourceSetupItemSUReq->pDUSessionResourceSetupRequestTransfer =
pDUSessionResourceSetupRequestTransfer; pDUSessionResourceSetupRequestTransfer;
...@@ -86,12 +87,10 @@ bool PDUSessionResourceSetupItemSUReq:: ...@@ -86,12 +87,10 @@ bool PDUSessionResourceSetupItemSUReq::
decodefromPDUSessionResourceSetupItemSUReq( decodefromPDUSessionResourceSetupItemSUReq(
Ngap_PDUSessionResourceSetupItemSUReq_t* Ngap_PDUSessionResourceSetupItemSUReq_t*
pduSessionResourceSetupItemSUReq) { pduSessionResourceSetupItemSUReq) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID(); if (!pDUSessionID.decodefromPDUSessionID(
s_NSSAI = new S_NSSAI();
if (!pDUSessionID->decodefromPDUSessionID(
pduSessionResourceSetupItemSUReq->pDUSessionID)) pduSessionResourceSetupItemSUReq->pDUSessionID))
return false; return false;
if (!s_NSSAI->decodefromS_NSSAI(&pduSessionResourceSetupItemSUReq->s_NSSAI)) if (!s_NSSAI.decodefromS_NSSAI(&pduSessionResourceSetupItemSUReq->s_NSSAI))
return false; return false;
if (pduSessionResourceSetupItemSUReq->pDUSessionNAS_PDU) { if (pduSessionResourceSetupItemSUReq->pDUSessionNAS_PDU) {
...@@ -107,15 +106,4 @@ bool PDUSessionResourceSetupItemSUReq:: ...@@ -107,15 +106,4 @@ bool PDUSessionResourceSetupItemSUReq::
return true; return true;
} }
//------------------------------------------------------------------------------
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;
}
} // namespace ngap } // namespace ngap
...@@ -19,20 +19,12 @@ ...@@ -19,20 +19,12 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_SETUP_ITEM_SU_REQ_H_
\brief #define _PDU_SESSION_RESOURCE_SETUP_ITEM_SU_REQ_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCESETUPITEMSUREQ_H_
#define _PDUSESSIONRESOURCESETUPITEMSUREQ_H_
#include "NAS-PDU.hpp" #include "NAS-PDU.hpp"
#include "PDUSessionID.hpp" #include "PDUSessionID.hpp"
#include "S-NSSAI.hpp" #include "S-NSSAI.hpp"
//#include "PDUSessionResourceSetupRequestTransfer.hpp"
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceSetupItemSUReq.h" #include "Ngap_PDUSessionResourceSetupItemSUReq.h"
...@@ -46,10 +38,11 @@ class PDUSessionResourceSetupItemSUReq { ...@@ -46,10 +38,11 @@ class PDUSessionResourceSetupItemSUReq {
virtual ~PDUSessionResourceSetupItemSUReq(); virtual ~PDUSessionResourceSetupItemSUReq();
void setPDUSessionResourceSetupItemSUReq( void setPDUSessionResourceSetupItemSUReq(
PDUSessionID* m_pDUSessionID, NAS_PDU* m_nAS_PDU, S_NSSAI* m_s_NSSAI, const PDUSessionID& m_pDUSessionID, NAS_PDU* m_nAS_PDU,
OCTET_STRING_t m_pDUSessionResourceSetupRequestTransfer); const S_NSSAI& m_s_NSSAI,
const OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer);
void getPDUSessionResourceSetupItemSUReq( void getPDUSessionResourceSetupItemSUReq(
PDUSessionID*& m_pDUSessionID, NAS_PDU*& m_nAS_PDU, S_NSSAI*& m_s_NSSAI, PDUSessionID& m_pDUSessionID, NAS_PDU*& m_nAS_PDU, S_NSSAI& m_s_NSSAI,
OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer); OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer);
bool encode2PDUSessionResourceSetupItemSUReq( bool encode2PDUSessionResourceSetupItemSUReq(
...@@ -60,12 +53,11 @@ class PDUSessionResourceSetupItemSUReq { ...@@ -60,12 +53,11 @@ class PDUSessionResourceSetupItemSUReq {
pduSessionResourceSetupItemSUReq); pduSessionResourceSetupItemSUReq);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID; // Mandatory
NAS_PDU* nAS_PDU; /* OPTIONAL */ NAS_PDU* nAS_PDU; // Optional
S_NSSAI* s_NSSAI; S_NSSAI s_NSSAI; // Mandatory
// PduSessionResourceSetupRequestTransferIE OCTET_STRING_t pDUSessionResourceSetupRequestTransfer; // Mandatory
// *pduSessionResourceSetupRequestTransfer; // TODO: UE Aggregate Maximum Bit Rate (Optional)
OCTET_STRING_t pDUSessionResourceSetupRequestTransfer;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,42 +19,38 @@ ...@@ -19,42 +19,38 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceSetupItemSURes.hpp" #include "PDUSessionResourceSetupItemSURes.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupItemSURes::PDUSessionResourceSetupItemSURes() { PDUSessionResourceSetupItemSURes::PDUSessionResourceSetupItemSURes() {}
pDUSessionID = NULL;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupItemSURes::~PDUSessionResourceSetupItemSURes() {} PDUSessionResourceSetupItemSURes::~PDUSessionResourceSetupItemSURes() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceSetupItemSURes::setPDUSessionResourceSetupItemSURes( void PDUSessionResourceSetupItemSURes::setPDUSessionResourceSetupItemSURes(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceSetupResponseTransfer) { const OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
pDUSessionResourceSetupResponseTransfer = pDUSessionResourceSetupResponseTransfer =
m_pDUSessionResourceSetupResponseTransfer; m_pDUSessionResourceSetupResponseTransfer;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupItemSURes::getPDUSessionResourceSetupItemSURes(
PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer) {
m_pDUSessionID = pDUSessionID;
m_pDUSessionResourceSetupResponseTransfer =
pDUSessionResourceSetupResponseTransfer;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceSetupItemSURes::encode2PDUSessionResourceSetupItemSURes( bool PDUSessionResourceSetupItemSURes::encode2PDUSessionResourceSetupItemSURes(
Ngap_PDUSessionResourceSetupItemSURes_t* pduSessionResourceSetupItemSURes) { Ngap_PDUSessionResourceSetupItemSURes_t* pduSessionResourceSetupItemSURes) {
if (!pDUSessionID) return false; if (!pDUSessionID.encode2PDUSessionID(
if (!pDUSessionID->encode2PDUSessionID(
pduSessionResourceSetupItemSURes->pDUSessionID)) pduSessionResourceSetupItemSURes->pDUSessionID))
return false; return false;
pduSessionResourceSetupItemSURes->pDUSessionResourceSetupResponseTransfer = pduSessionResourceSetupItemSURes->pDUSessionResourceSetupResponseTransfer =
...@@ -68,8 +64,7 @@ bool PDUSessionResourceSetupItemSURes:: ...@@ -68,8 +64,7 @@ bool PDUSessionResourceSetupItemSURes::
decodefromPDUSessionResourceSetupItemSURes( decodefromPDUSessionResourceSetupItemSURes(
Ngap_PDUSessionResourceSetupItemSURes_t* Ngap_PDUSessionResourceSetupItemSURes_t*
pduSessionResourceSetupItemSURes) { pduSessionResourceSetupItemSURes) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID(); if (!pDUSessionID.decodefromPDUSessionID(
if (!pDUSessionID->decodefromPDUSessionID(
pduSessionResourceSetupItemSURes->pDUSessionID)) pduSessionResourceSetupItemSURes->pDUSessionID))
return false; return false;
pDUSessionResourceSetupResponseTransfer = pDUSessionResourceSetupResponseTransfer =
...@@ -78,13 +73,4 @@ bool PDUSessionResourceSetupItemSURes:: ...@@ -78,13 +73,4 @@ bool PDUSessionResourceSetupItemSURes::
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupItemSURes::getPDUSessionResourceSetupItemSURes(
PDUSessionID*& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer) {
m_pDUSessionID = pDUSessionID;
m_pDUSessionResourceSetupResponseTransfer =
pDUSessionResourceSetupResponseTransfer;
}
} // namespace ngap } // namespace ngap
...@@ -19,15 +19,8 @@ ...@@ -19,15 +19,8 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_SETUP_ITEM_SU_RES_H_
\brief #define _PDU_SESSION_RESOURCE_SETUP_ITEM_SU_RES_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCESETUPITEMSURES_H_
#define _PDUSESSIONRESOURCESETUPITEMSURES_H_
#include "PDUSessionID.hpp" #include "PDUSessionID.hpp"
...@@ -43,10 +36,10 @@ class PDUSessionResourceSetupItemSURes { ...@@ -43,10 +36,10 @@ class PDUSessionResourceSetupItemSURes {
virtual ~PDUSessionResourceSetupItemSURes(); virtual ~PDUSessionResourceSetupItemSURes();
void setPDUSessionResourceSetupItemSURes( void setPDUSessionResourceSetupItemSURes(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceSetupResponseTransfer); const OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer);
void getPDUSessionResourceSetupItemSURes( void getPDUSessionResourceSetupItemSURes(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer); OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer);
bool encode2PDUSessionResourceSetupItemSURes( bool encode2PDUSessionResourceSetupItemSURes(
...@@ -57,8 +50,8 @@ class PDUSessionResourceSetupItemSURes { ...@@ -57,8 +50,8 @@ class PDUSessionResourceSetupItemSURes {
pduSessionResourceSetupItemSURes); pduSessionResourceSetupItemSURes);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID; // Mandatory
OCTET_STRING_t pDUSessionResourceSetupResponseTransfer; OCTET_STRING_t pDUSessionResourceSetupResponseTransfer; // Mandatory
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,51 +19,39 @@ ...@@ -19,51 +19,39 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceSetupListCxtReq.hpp" #include "PDUSessionResourceSetupListCxtReq.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupListCxtReq::PDUSessionResourceSetupListCxtReq() { PDUSessionResourceSetupListCxtReq::PDUSessionResourceSetupListCxtReq() {}
pduSessionResourceSetupItemCxtReq = NULL;
numofpduSessionResourceSetupItemCxtReq = 0;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupListCxtReq::~PDUSessionResourceSetupListCxtReq() {} PDUSessionResourceSetupListCxtReq::~PDUSessionResourceSetupListCxtReq() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceSetupListCxtReq::setPDUSessionResourceSetupListCxtReq( void PDUSessionResourceSetupListCxtReq::setPDUSessionResourceSetupListCxtReq(
PDUSessionResourceSetupItemCxtReq* m_pduSessionResourceSetupItemCxtReq, const std::vector<PDUSessionResourceSetupItemCxtReq>& itemList) {
int num) { pduSessionResourceSetupItemCxtReqList = itemList;
pduSessionResourceSetupItemCxtReq = m_pduSessionResourceSetupItemCxtReq;
numofpduSessionResourceSetupItemCxtReq = num;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupListCxtReq::getPDUSessionResourceSetupListCxtReq(
std::vector<PDUSessionResourceSetupItemCxtReq>& itemList) {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceSetupListCxtReq:: bool PDUSessionResourceSetupListCxtReq::
encode2PDUSessionResourceSetupListCxtReq( encode2PDUSessionResourceSetupListCxtReq(
Ngap_PDUSessionResourceSetupListCxtReq_t* Ngap_PDUSessionResourceSetupListCxtReq_t*
pduSessionResourceSetupListCxtReq) { pduSessionResourceSetupListCxtReq) {
for (int i = 0; i < numofpduSessionResourceSetupItemCxtReq; i++) { for (std::vector<PDUSessionResourceSetupItemCxtReq>::iterator it =
cout << "encoding items" << endl; std::begin(pduSessionResourceSetupItemCxtReqList);
it < std::end(pduSessionResourceSetupItemCxtReqList); ++it) {
Ngap_PDUSessionResourceSetupItemCxtReq_t* request = Ngap_PDUSessionResourceSetupItemCxtReq_t* request =
(Ngap_PDUSessionResourceSetupItemCxtReq_t*) calloc( (Ngap_PDUSessionResourceSetupItemCxtReq_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceSetupItemCxtReq_t)); 1, sizeof(Ngap_PDUSessionResourceSetupItemCxtReq_t));
if (!request) return false; if (!request) return false;
if (!pduSessionResourceSetupItemCxtReq[i] if (!it->encode2PDUSessionResourceSetupItemCxtReq(request)) return false;
.encode2PDUSessionResourceSetupItemCxtReq(request))
return false;
if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListCxtReq->list, request) != if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListCxtReq->list, request) !=
0) 0)
return false; return false;
...@@ -77,26 +65,18 @@ bool PDUSessionResourceSetupListCxtReq:: ...@@ -77,26 +65,18 @@ bool PDUSessionResourceSetupListCxtReq::
decodefromPDUSessionResourceSetupListCxtReq( decodefromPDUSessionResourceSetupListCxtReq(
Ngap_PDUSessionResourceSetupListCxtReq_t* Ngap_PDUSessionResourceSetupListCxtReq_t*
pduSessionResourceSetupListCxtReq) { pduSessionResourceSetupListCxtReq) {
numofpduSessionResourceSetupItemCxtReq = pduSessionResourceSetupItemCxtReqList.reserve(
pduSessionResourceSetupListCxtReq->list.count; pduSessionResourceSetupListCxtReq->list.count);
pduSessionResourceSetupItemCxtReq = new PDUSessionResourceSetupItemCxtReq
[numofpduSessionResourceSetupItemCxtReq](); for (int i = 0; i < pduSessionResourceSetupListCxtReq->list.count; i++) {
for (int i = 0; i < numofpduSessionResourceSetupItemCxtReq; i++) { PDUSessionResourceSetupItemCxtReq item = {};
if (!pduSessionResourceSetupItemCxtReq[i] if (!item.decodefromPDUSessionResourceSetupItemCxtReq(
.decodefromPDUSessionResourceSetupItemCxtReq( pduSessionResourceSetupListCxtReq->list.array[i]))
pduSessionResourceSetupListCxtReq->list.array[i]))
return false; return false;
pduSessionResourceSetupItemCxtReqList.push_back(item);
} }
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupListCxtReq::getPDUSessionResourceSetupListCxtReq(
PDUSessionResourceSetupItemCxtReq*& m_pduSessionResourceSetupItemCxtReq,
int& num) {
m_pduSessionResourceSetupItemCxtReq = pduSessionResourceSetupItemCxtReq;
num = numofpduSessionResourceSetupItemCxtReq;
}
} // namespace ngap } // namespace ngap
...@@ -19,17 +19,11 @@ ...@@ -19,17 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_SETUP_LIST_CXT_REQ_H_
\brief #define _PDU_SESSION_RESOURCE_SETUP_LIST_CXT_REQ_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCESETUPLISTCXTREQ_H_
#define _PDUSESSIONRESOURCESETUPLISTCXTREQ_H_
#include "PDUSessionResourceSetupItemCxtReq.hpp" #include "PDUSessionResourceSetupItemCxtReq.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceSetupListCxtReq.h" #include "Ngap_PDUSessionResourceSetupListCxtReq.h"
...@@ -43,11 +37,9 @@ class PDUSessionResourceSetupListCxtReq { ...@@ -43,11 +37,9 @@ class PDUSessionResourceSetupListCxtReq {
virtual ~PDUSessionResourceSetupListCxtReq(); virtual ~PDUSessionResourceSetupListCxtReq();
void setPDUSessionResourceSetupListCxtReq( void setPDUSessionResourceSetupListCxtReq(
PDUSessionResourceSetupItemCxtReq* m_pduSessionResourceSetupItemCxtReq, const std::vector<PDUSessionResourceSetupItemCxtReq>& itemList);
int num);
void getPDUSessionResourceSetupListCxtReq( void getPDUSessionResourceSetupListCxtReq(
PDUSessionResourceSetupItemCxtReq*& m_pduSessionResourceSetupItemCxtReq, std::vector<PDUSessionResourceSetupItemCxtReq>& itemList);
int& num);
bool encode2PDUSessionResourceSetupListCxtReq( bool encode2PDUSessionResourceSetupListCxtReq(
Ngap_PDUSessionResourceSetupListCxtReq_t* Ngap_PDUSessionResourceSetupListCxtReq_t*
...@@ -57,8 +49,8 @@ class PDUSessionResourceSetupListCxtReq { ...@@ -57,8 +49,8 @@ class PDUSessionResourceSetupListCxtReq {
pduSessionResourceSetupListCxtReq); pduSessionResourceSetupListCxtReq);
private: private:
PDUSessionResourceSetupItemCxtReq* pduSessionResourceSetupItemCxtReq; std::vector<PDUSessionResourceSetupItemCxtReq>
int numofpduSessionResourceSetupItemCxtReq; pduSessionResourceSetupItemCxtReqList;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -28,26 +28,24 @@ ...@@ -28,26 +28,24 @@
#include "PDUSessionResourceSetupListCxtRes.hpp" #include "PDUSessionResourceSetupListCxtRes.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupListCxtRes::PDUSessionResourceSetupListCxtRes() { PDUSessionResourceSetupListCxtRes::PDUSessionResourceSetupListCxtRes() {}
pduSessionResourceSetupItemCxtRes = NULL;
numofpduSessionResourceSetupItemCxtRes = 0;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupListCxtRes::~PDUSessionResourceSetupListCxtRes() {} PDUSessionResourceSetupListCxtRes::~PDUSessionResourceSetupListCxtRes() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceSetupListCxtRes::setPDUSessionResourceSetupListCxtRes( void PDUSessionResourceSetupListCxtRes::setPDUSessionResourceSetupListCxtRes(
PDUSessionResourceSetupItemCxtRes* m_pduSessionResourceSetupItemCxtRes, const std::vector<PDUSessionResourceSetupItemCxtRes>& list) {
int num) { itemList = list;
pduSessionResourceSetupItemCxtRes = m_pduSessionResourceSetupItemCxtRes; }
numofpduSessionResourceSetupItemCxtRes = num;
//------------------------------------------------------------------------------
void PDUSessionResourceSetupListCxtRes::getPDUSessionResourceSetupListCxtRes(
std::vector<PDUSessionResourceSetupItemCxtRes>& list) {
list = itemList;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -55,14 +53,14 @@ bool PDUSessionResourceSetupListCxtRes:: ...@@ -55,14 +53,14 @@ bool PDUSessionResourceSetupListCxtRes::
encode2PDUSessionResourceSetupListCxtRes( encode2PDUSessionResourceSetupListCxtRes(
Ngap_PDUSessionResourceSetupListCxtRes_t* Ngap_PDUSessionResourceSetupListCxtRes_t*
pduSessionResourceSetupListCxtRes) { pduSessionResourceSetupListCxtRes) {
for (int i = 0; i < numofpduSessionResourceSetupItemCxtRes; i++) { for (std::vector<PDUSessionResourceSetupItemCxtRes>::iterator it =
std::begin(itemList);
it < std::end(itemList); ++it) {
Ngap_PDUSessionResourceSetupItemCxtRes_t* response = Ngap_PDUSessionResourceSetupItemCxtRes_t* response =
(Ngap_PDUSessionResourceSetupItemCxtRes_t*) calloc( (Ngap_PDUSessionResourceSetupItemCxtRes_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceSetupItemCxtRes_t)); 1, sizeof(Ngap_PDUSessionResourceSetupItemCxtRes_t));
if (!response) return false; if (!response) return false;
if (!pduSessionResourceSetupItemCxtRes[i] if (!it->encode2PDUSessionResourceSetupItemCxtRes(response)) return false;
.encode2PDUSessionResourceSetupItemCxtRes(response))
return false;
if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListCxtRes->list, response) != if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListCxtRes->list, response) !=
0) 0)
return false; return false;
...@@ -76,26 +74,16 @@ bool PDUSessionResourceSetupListCxtRes:: ...@@ -76,26 +74,16 @@ bool PDUSessionResourceSetupListCxtRes::
decodefromPDUSessionResourceSetupListCxtRes( decodefromPDUSessionResourceSetupListCxtRes(
Ngap_PDUSessionResourceSetupListCxtRes_t* Ngap_PDUSessionResourceSetupListCxtRes_t*
pduSessionResourceSetupListCxtRes) { pduSessionResourceSetupListCxtRes) {
numofpduSessionResourceSetupItemCxtRes = itemList.reserve(pduSessionResourceSetupListCxtRes->list.count);
pduSessionResourceSetupListCxtRes->list.count; for (int i = 0; i < pduSessionResourceSetupListCxtRes->list.count; i++) {
pduSessionResourceSetupItemCxtRes = new PDUSessionResourceSetupItemCxtRes PDUSessionResourceSetupItemCxtRes item = {};
[numofpduSessionResourceSetupItemCxtRes](); if (!item.decodefromPDUSessionResourceSetupItemCxtRes(
for (int i = 0; i < numofpduSessionResourceSetupItemCxtRes; i++) { pduSessionResourceSetupListCxtRes->list.array[i]))
if (!pduSessionResourceSetupItemCxtRes[i]
.decodefromPDUSessionResourceSetupItemCxtRes(
pduSessionResourceSetupListCxtRes->list.array[i]))
return false; return false;
itemList.push_back(item);
} }
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupListCxtRes::getPDUSessionResourceSetupListCxtRes(
PDUSessionResourceSetupItemCxtRes*& m_pduSessionResourceSetupItemCxtRes,
int& num) {
m_pduSessionResourceSetupItemCxtRes = pduSessionResourceSetupItemCxtRes;
num = numofpduSessionResourceSetupItemCxtRes;
}
} // namespace ngap } // namespace ngap
...@@ -19,17 +19,11 @@ ...@@ -19,17 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_SETUP_LIST_CXT_RES_H_
\brief #define _PDU_SESSION_RESOURCE_SETUP_LIST_CXT_RES_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCESETUPLISTCXTRES_H_
#define _PDUSESSIONRESOURCESETUPLISTCXTRES_H_
#include "PDUSessionResourceSetupItemCxtRes.hpp" #include "PDUSessionResourceSetupItemCxtRes.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceSetupListCxtRes.h" #include "Ngap_PDUSessionResourceSetupListCxtRes.h"
...@@ -43,11 +37,9 @@ class PDUSessionResourceSetupListCxtRes { ...@@ -43,11 +37,9 @@ class PDUSessionResourceSetupListCxtRes {
virtual ~PDUSessionResourceSetupListCxtRes(); virtual ~PDUSessionResourceSetupListCxtRes();
void setPDUSessionResourceSetupListCxtRes( void setPDUSessionResourceSetupListCxtRes(
PDUSessionResourceSetupItemCxtRes* m_pduSessionResourceSetupItemCxtRes, const std::vector<PDUSessionResourceSetupItemCxtRes>& list);
int num);
void getPDUSessionResourceSetupListCxtRes( void getPDUSessionResourceSetupListCxtRes(
PDUSessionResourceSetupItemCxtRes*& m_pduSessionResourceSetupItemCxtRes, std::vector<PDUSessionResourceSetupItemCxtRes>& list);
int& num);
bool encode2PDUSessionResourceSetupListCxtRes( bool encode2PDUSessionResourceSetupListCxtRes(
Ngap_PDUSessionResourceSetupListCxtRes_t* Ngap_PDUSessionResourceSetupListCxtRes_t*
...@@ -57,8 +49,7 @@ class PDUSessionResourceSetupListCxtRes { ...@@ -57,8 +49,7 @@ class PDUSessionResourceSetupListCxtRes {
pduSessionResourceSetupListCxtRes); pduSessionResourceSetupListCxtRes);
private: private:
PDUSessionResourceSetupItemCxtRes* pduSessionResourceSetupItemCxtRes; std::vector<PDUSessionResourceSetupItemCxtRes> itemList;
int numofpduSessionResourceSetupItemCxtRes;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,48 +19,37 @@ ...@@ -19,48 +19,37 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceSetupListSUReq.hpp" #include "PDUSessionResourceSetupListSUReq.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupListSUReq::PDUSessionResourceSetupListSUReq() { PDUSessionResourceSetupListSUReq::PDUSessionResourceSetupListSUReq() {}
pduSessionResourceSetupItemSUReq = NULL;
numofpduSessionResourceSetupItemSUReq = 0;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupListSUReq::~PDUSessionResourceSetupListSUReq() {} PDUSessionResourceSetupListSUReq::~PDUSessionResourceSetupListSUReq() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceSetupListSUReq::setPDUSessionResourceSetupListSUReq( void PDUSessionResourceSetupListSUReq::setPDUSessionResourceSetupListSUReq(
PDUSessionResourceSetupItemSUReq* m_pduSessionResourceSetupItemSUReq, const std::vector<PDUSessionResourceSetupItemSUReq>& list) {
int num) { itemSUReqList = list;
pduSessionResourceSetupItemSUReq = m_pduSessionResourceSetupItemSUReq; }
numofpduSessionResourceSetupItemSUReq = num;
//------------------------------------------------------------------------------
void PDUSessionResourceSetupListSUReq::getPDUSessionResourceSetupListSUReq(
std::vector<PDUSessionResourceSetupItemSUReq>& list) {
list = itemSUReqList;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceSetupListSUReq::encode2PDUSessionResourceSetupListSUReq( bool PDUSessionResourceSetupListSUReq::encode2PDUSessionResourceSetupListSUReq(
Ngap_PDUSessionResourceSetupListSUReq_t* pduSessionResourceSetupListSUReq) { Ngap_PDUSessionResourceSetupListSUReq_t* pduSessionResourceSetupListSUReq) {
for (int i = 0; i < numofpduSessionResourceSetupItemSUReq; i++) { for (auto& item : itemSUReqList) {
Ngap_PDUSessionResourceSetupItemSUReq_t* request = Ngap_PDUSessionResourceSetupItemSUReq_t* request =
(Ngap_PDUSessionResourceSetupItemSUReq_t*) calloc( (Ngap_PDUSessionResourceSetupItemSUReq_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceSetupItemSUReq_t)); 1, sizeof(Ngap_PDUSessionResourceSetupItemSUReq_t));
if (!request) return false; if (!request) return false;
if (!pduSessionResourceSetupItemSUReq[i] if (!item.encode2PDUSessionResourceSetupItemSUReq(request)) return false;
.encode2PDUSessionResourceSetupItemSUReq(request))
return false;
if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListSUReq->list, request) != 0) if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListSUReq->list, request) != 0)
return false; return false;
} }
...@@ -73,26 +62,15 @@ bool PDUSessionResourceSetupListSUReq:: ...@@ -73,26 +62,15 @@ bool PDUSessionResourceSetupListSUReq::
decodefromPDUSessionResourceSetupListSUReq( decodefromPDUSessionResourceSetupListSUReq(
Ngap_PDUSessionResourceSetupListSUReq_t* Ngap_PDUSessionResourceSetupListSUReq_t*
pduSessionResourceSetupListSUReq) { pduSessionResourceSetupListSUReq) {
numofpduSessionResourceSetupItemSUReq = for (int i = 0; i < pduSessionResourceSetupListSUReq->list.count; i++) {
pduSessionResourceSetupListSUReq->list.count; PDUSessionResourceSetupItemSUReq item = {};
pduSessionResourceSetupItemSUReq = new PDUSessionResourceSetupItemSUReq if (!item.decodefromPDUSessionResourceSetupItemSUReq(
[numofpduSessionResourceSetupItemSUReq](); pduSessionResourceSetupListSUReq->list.array[i]))
for (int i = 0; i < numofpduSessionResourceSetupItemSUReq; i++) {
if (!pduSessionResourceSetupItemSUReq[i]
.decodefromPDUSessionResourceSetupItemSUReq(
pduSessionResourceSetupListSUReq->list.array[i]))
return false; return false;
itemSUReqList.push_back(item);
} }
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupListSUReq::getPDUSessionResourceSetupListSUReq(
PDUSessionResourceSetupItemSUReq*& m_pduSessionResourceSetupItemSUReq,
int& num) {
m_pduSessionResourceSetupItemSUReq = pduSessionResourceSetupItemSUReq;
num = numofpduSessionResourceSetupItemSUReq;
}
} // namespace ngap } // namespace ngap
...@@ -19,17 +19,11 @@ ...@@ -19,17 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_SETUP_LIST_SU_REQ_H_
\brief #define _PDU_SESSION_RESOURCE_SETUP_LIST_SU_REQ_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCESETUPLISTSUREQ_H_
#define _PDUSESSIONRESOURCESETUPLISTSUREQ_H_
#include "PDUSessionResourceSetupItemSUReq.hpp" #include "PDUSessionResourceSetupItemSUReq.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceSetupListSUReq.h" #include "Ngap_PDUSessionResourceSetupListSUReq.h"
...@@ -43,11 +37,9 @@ class PDUSessionResourceSetupListSUReq { ...@@ -43,11 +37,9 @@ class PDUSessionResourceSetupListSUReq {
virtual ~PDUSessionResourceSetupListSUReq(); virtual ~PDUSessionResourceSetupListSUReq();
void setPDUSessionResourceSetupListSUReq( void setPDUSessionResourceSetupListSUReq(
PDUSessionResourceSetupItemSUReq* m_pduSessionResourceSetupItemSUReq, const std::vector<PDUSessionResourceSetupItemSUReq>& itemSUReqList);
int num);
void getPDUSessionResourceSetupListSUReq( void getPDUSessionResourceSetupListSUReq(
PDUSessionResourceSetupItemSUReq*& m_pduSessionResourceSetupItemSUReq, std::vector<PDUSessionResourceSetupItemSUReq>& list);
int& num);
bool encode2PDUSessionResourceSetupListSUReq( bool encode2PDUSessionResourceSetupListSUReq(
Ngap_PDUSessionResourceSetupListSUReq_t* Ngap_PDUSessionResourceSetupListSUReq_t*
...@@ -57,8 +49,7 @@ class PDUSessionResourceSetupListSUReq { ...@@ -57,8 +49,7 @@ class PDUSessionResourceSetupListSUReq {
pduSessionResourceSetupListSUReq); pduSessionResourceSetupListSUReq);
private: private:
PDUSessionResourceSetupItemSUReq* pduSessionResourceSetupItemSUReq; std::vector<PDUSessionResourceSetupItemSUReq> itemSUReqList;
int numofpduSessionResourceSetupItemSUReq;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,48 +19,37 @@ ...@@ -19,48 +19,37 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceSetupListSURes.hpp" #include "PDUSessionResourceSetupListSURes.hpp"
#include <iostream>
using namespace std;
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupListSURes::PDUSessionResourceSetupListSURes() { PDUSessionResourceSetupListSURes::PDUSessionResourceSetupListSURes() {}
pduSessionResourceSetupItemSURes = NULL;
numofpduSessionResourceSetupItemSURes = 0;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceSetupListSURes::~PDUSessionResourceSetupListSURes() {} PDUSessionResourceSetupListSURes::~PDUSessionResourceSetupListSURes() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceSetupListSURes::setPDUSessionResourceSetupListSURes( void PDUSessionResourceSetupListSURes::setPDUSessionResourceSetupListSURes(
PDUSessionResourceSetupItemSURes* m_pduSessionResourceSetupItemSURes, const std::vector<PDUSessionResourceSetupItemSURes>& list) {
int num) { itemSUResList = list;
pduSessionResourceSetupItemSURes = m_pduSessionResourceSetupItemSURes; }
numofpduSessionResourceSetupItemSURes = num;
//------------------------------------------------------------------------------
void PDUSessionResourceSetupListSURes::getPDUSessionResourceSetupListSURes(
std::vector<PDUSessionResourceSetupItemSURes>& list) {
list = itemSUResList;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool PDUSessionResourceSetupListSURes::encode2PDUSessionResourceSetupListSURes( bool PDUSessionResourceSetupListSURes::encode2PDUSessionResourceSetupListSURes(
Ngap_PDUSessionResourceSetupListSURes_t* pduSessionResourceSetupListSURes) { Ngap_PDUSessionResourceSetupListSURes_t* pduSessionResourceSetupListSURes) {
for (int i = 0; i < numofpduSessionResourceSetupItemSURes; i++) { for (auto& item : itemSUResList) {
Ngap_PDUSessionResourceSetupItemSURes_t* response = Ngap_PDUSessionResourceSetupItemSURes_t* response =
(Ngap_PDUSessionResourceSetupItemSURes_t*) calloc( (Ngap_PDUSessionResourceSetupItemSURes_t*) calloc(
1, sizeof(Ngap_PDUSessionResourceSetupItemSURes_t)); 1, sizeof(Ngap_PDUSessionResourceSetupItemSURes_t));
if (!response) return false; if (!response) return false;
if (!pduSessionResourceSetupItemSURes[i] if (!item.encode2PDUSessionResourceSetupItemSURes(response)) return false;
.encode2PDUSessionResourceSetupItemSURes(response))
return false;
if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListSURes->list, response) != if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListSURes->list, response) !=
0) 0)
return false; return false;
...@@ -74,26 +63,15 @@ bool PDUSessionResourceSetupListSURes:: ...@@ -74,26 +63,15 @@ bool PDUSessionResourceSetupListSURes::
decodefromPDUSessionResourceSetupListSURes( decodefromPDUSessionResourceSetupListSURes(
Ngap_PDUSessionResourceSetupListSURes_t* Ngap_PDUSessionResourceSetupListSURes_t*
pduSessionResourceSetupListSURes) { pduSessionResourceSetupListSURes) {
numofpduSessionResourceSetupItemSURes = for (int i = 0; i < pduSessionResourceSetupListSURes->list.count; i++) {
pduSessionResourceSetupListSURes->list.count; PDUSessionResourceSetupItemSURes item = {};
pduSessionResourceSetupItemSURes = new PDUSessionResourceSetupItemSURes if (!item.decodefromPDUSessionResourceSetupItemSURes(
[numofpduSessionResourceSetupItemSURes](); pduSessionResourceSetupListSURes->list.array[i]))
for (int i = 0; i < numofpduSessionResourceSetupItemSURes; i++) {
if (!pduSessionResourceSetupItemSURes[i]
.decodefromPDUSessionResourceSetupItemSURes(
pduSessionResourceSetupListSURes->list.array[i]))
return false; return false;
itemSUResList.push_back(item);
} }
return true; return true;
} }
//------------------------------------------------------------------------------
void PDUSessionResourceSetupListSURes::getPDUSessionResourceSetupListSURes(
PDUSessionResourceSetupItemSURes*& m_pduSessionResourceSetupItemSURes,
int& num) {
m_pduSessionResourceSetupItemSURes = pduSessionResourceSetupItemSURes;
num = numofpduSessionResourceSetupItemSURes;
}
} // namespace ngap } // namespace ngap
...@@ -19,17 +19,11 @@ ...@@ -19,17 +19,11 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file #ifndef _PDU_SESSION_RESOURCE_SETUP_LIST_SU_RES_H_
\brief #define _PDU_SESSION_RESOURCE_SETUP_LIST_SU_RES_H_
\author Keliang DU, BUPT
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDUSESSIONRESOURCESETUPLISTSURES_H_
#define _PDUSESSIONRESOURCESETUPLISTSURES_H_
#include "PDUSessionResourceSetupItemSURes.hpp" #include "PDUSessionResourceSetupItemSURes.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_PDUSessionResourceSetupListSURes.h" #include "Ngap_PDUSessionResourceSetupListSURes.h"
...@@ -43,11 +37,9 @@ class PDUSessionResourceSetupListSURes { ...@@ -43,11 +37,9 @@ class PDUSessionResourceSetupListSURes {
virtual ~PDUSessionResourceSetupListSURes(); virtual ~PDUSessionResourceSetupListSURes();
void setPDUSessionResourceSetupListSURes( void setPDUSessionResourceSetupListSURes(
PDUSessionResourceSetupItemSURes* m_pduSessionResourceSetupItemSURes, const std::vector<PDUSessionResourceSetupItemSURes>& list);
int num);
void getPDUSessionResourceSetupListSURes( void getPDUSessionResourceSetupListSURes(
PDUSessionResourceSetupItemSURes*& m_pduSessionResourceSetupItemSURes, std::vector<PDUSessionResourceSetupItemSURes>& list);
int& num);
bool encode2PDUSessionResourceSetupListSURes( bool encode2PDUSessionResourceSetupListSURes(
Ngap_PDUSessionResourceSetupListSURes_t* Ngap_PDUSessionResourceSetupListSURes_t*
...@@ -57,8 +49,7 @@ class PDUSessionResourceSetupListSURes { ...@@ -57,8 +49,7 @@ class PDUSessionResourceSetupListSURes {
pduSessionResourceSetupListSURes); pduSessionResourceSetupListSURes);
private: private:
PDUSessionResourceSetupItemSURes* pduSessionResourceSetupItemSURes; std::vector<PDUSessionResourceSetupItemSURes> itemSUResList;
int numofpduSessionResourceSetupItemSURes;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -19,20 +19,12 @@ ...@@ -19,20 +19,12 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU (BUPT), Tien-Thinh NGUYEN (EURECOM)
\date 2020
\email: contact@openairinterface.org
*/
#include "PDUSessionResourceToReleaseItemRelCmd.hpp" #include "PDUSessionResourceToReleaseItemRelCmd.hpp"
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
PDUSessionResourceToReleaseItemRelCmd::PDUSessionResourceToReleaseItemRelCmd() { PDUSessionResourceToReleaseItemRelCmd::PDUSessionResourceToReleaseItemRelCmd() {
pDUSessionID = NULL;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
...@@ -42,8 +34,8 @@ PDUSessionResourceToReleaseItemRelCmd:: ...@@ -42,8 +34,8 @@ PDUSessionResourceToReleaseItemRelCmd::
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceToReleaseItemRelCmd:: void PDUSessionResourceToReleaseItemRelCmd::
setPDUSessionResourceToReleaseItemRelCmd( setPDUSessionResourceToReleaseItemRelCmd(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceReleaseCommandTransfer) { const OCTET_STRING_t& m_pDUSessionResourceReleaseCommandTransfer) {
pDUSessionID = m_pDUSessionID; pDUSessionID = m_pDUSessionID;
pDUSessionResourceReleaseCommandTransfer = pDUSessionResourceReleaseCommandTransfer =
m_pDUSessionResourceReleaseCommandTransfer; m_pDUSessionResourceReleaseCommandTransfer;
...@@ -52,7 +44,7 @@ void PDUSessionResourceToReleaseItemRelCmd:: ...@@ -52,7 +44,7 @@ void PDUSessionResourceToReleaseItemRelCmd::
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void PDUSessionResourceToReleaseItemRelCmd:: void PDUSessionResourceToReleaseItemRelCmd::
getPDUSessionResourceToReleaseItemRelCmd( getPDUSessionResourceToReleaseItemRelCmd(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceReleaseCommandTransfer) { OCTET_STRING_t& m_pDUSessionResourceReleaseCommandTransfer) {
m_pDUSessionID = pDUSessionID; m_pDUSessionID = pDUSessionID;
m_pDUSessionResourceReleaseCommandTransfer = m_pDUSessionResourceReleaseCommandTransfer =
...@@ -64,7 +56,7 @@ bool PDUSessionResourceToReleaseItemRelCmd:: ...@@ -64,7 +56,7 @@ bool PDUSessionResourceToReleaseItemRelCmd::
encode2PDUSessionResourceToReleaseItemRelCmd( encode2PDUSessionResourceToReleaseItemRelCmd(
Ngap_PDUSessionResourceToReleaseItemRelCmd_t* Ngap_PDUSessionResourceToReleaseItemRelCmd_t*
pduSessionResourceToReleaseItemRelCmd) { pduSessionResourceToReleaseItemRelCmd) {
if (!pDUSessionID->encode2PDUSessionID( if (!pDUSessionID.encode2PDUSessionID(
pduSessionResourceToReleaseItemRelCmd->pDUSessionID)) pduSessionResourceToReleaseItemRelCmd->pDUSessionID))
return false; return false;
...@@ -80,8 +72,6 @@ bool PDUSessionResourceToReleaseItemRelCmd:: ...@@ -80,8 +72,6 @@ bool PDUSessionResourceToReleaseItemRelCmd::
decodefromPDUSessionResourceToReleaseItemRelCmd( decodefromPDUSessionResourceToReleaseItemRelCmd(
Ngap_PDUSessionResourceToReleaseItemRelCmd_t* Ngap_PDUSessionResourceToReleaseItemRelCmd_t*
pduSessionResourceToReleaseItemRelCmd) { pduSessionResourceToReleaseItemRelCmd) {
if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID();
pDUSessionResourceReleaseCommandTransfer = pDUSessionResourceReleaseCommandTransfer =
pduSessionResourceToReleaseItemRelCmd pduSessionResourceToReleaseItemRelCmd
->pDUSessionResourceReleaseCommandTransfer; ->pDUSessionResourceReleaseCommandTransfer;
......
...@@ -19,13 +19,6 @@ ...@@ -19,13 +19,6 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
/*! \file
\brief
\author Keliang DU (BUPT), Tien-Thinh NGUYEN (EURECOM)
\date 2020
\email: contact@openairinterface.org
*/
#ifndef _PDU_SESSION_RESOURCE_TO_RELEASE_ITEM_REL_CMD_H_ #ifndef _PDU_SESSION_RESOURCE_TO_RELEASE_ITEM_REL_CMD_H_
#define _PDU_SESSION_RESOURCE_TO_RELEASE_ITEM_REL_CMD_H_ #define _PDU_SESSION_RESOURCE_TO_RELEASE_ITEM_REL_CMD_H_
...@@ -43,10 +36,10 @@ class PDUSessionResourceToReleaseItemRelCmd { ...@@ -43,10 +36,10 @@ class PDUSessionResourceToReleaseItemRelCmd {
virtual ~PDUSessionResourceToReleaseItemRelCmd(); virtual ~PDUSessionResourceToReleaseItemRelCmd();
void setPDUSessionResourceToReleaseItemRelCmd( void setPDUSessionResourceToReleaseItemRelCmd(
PDUSessionID* m_pDUSessionID, const PDUSessionID& m_pDUSessionID,
OCTET_STRING_t m_pDUSessionResourceReleaseCommandTransfer); const OCTET_STRING_t& m_pDUSessionResourceReleaseCommandTransfer);
void getPDUSessionResourceToReleaseItemRelCmd( void getPDUSessionResourceToReleaseItemRelCmd(
PDUSessionID*& m_pDUSessionID, PDUSessionID& m_pDUSessionID,
OCTET_STRING_t& m_pDUSessionResourceReleaseCommandTransfer); OCTET_STRING_t& m_pDUSessionResourceReleaseCommandTransfer);
bool encode2PDUSessionResourceToReleaseItemRelCmd( bool encode2PDUSessionResourceToReleaseItemRelCmd(
...@@ -57,9 +50,8 @@ class PDUSessionResourceToReleaseItemRelCmd { ...@@ -57,9 +50,8 @@ class PDUSessionResourceToReleaseItemRelCmd {
pduSessionResourceToReleaseItemRelCmd); pduSessionResourceToReleaseItemRelCmd);
private: private:
PDUSessionID* pDUSessionID; PDUSessionID pDUSessionID; // Mandatory
OCTET_STRING_t pDUSessionResourceReleaseCommandTransfer; OCTET_STRING_t pDUSessionResourceReleaseCommandTransfer; // Mandatory
// ProtocolExtensionContainer (OPTIONAL)
}; };
} // namespace ngap } // namespace ngap
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
...@@ -30,6 +30,7 @@ ...@@ -30,6 +30,7 @@
#define _PLMNSUPPORTLIST_H_ #define _PLMNSUPPORTLIST_H_
#include "PLMNSupportItem.hpp" #include "PLMNSupportItem.hpp"
#include <vector>
extern "C" { extern "C" {
#include "Ngap_PLMNSupportList.h" #include "Ngap_PLMNSupportList.h"
...@@ -44,14 +45,14 @@ class PLMNSupportList { ...@@ -44,14 +45,14 @@ class PLMNSupportList {
bool encode2PLMNSupportList(Ngap_PLMNSupportList_t*); bool encode2PLMNSupportList(Ngap_PLMNSupportList_t*);
bool decodefromPLMNSupportList(Ngap_PLMNSupportList_t*); bool decodefromPLMNSupportList(Ngap_PLMNSupportList_t*);
void addPLMNSupportItems(
PLMNSupportItem* m_plmnsupportItemItem, int numOfItem); void addPLMNSupportItems(const std::vector<PLMNSupportItem>& items);
void getPLMNSupportItems( void getPLMNSupportItems(std::vector<PLMNSupportItem>& items);
PLMNSupportItem*& m_plmnsupportItemItem, int& numOfItem);
void addPLMNSupportItem(const PLMNSupportItem& item);
private: private:
PLMNSupportItem* plmnsupportItemItem; std::vector<PLMNSupportItem> plmnSupportItems;
int numberOfplmnsupportItemItem;
}; };
} // namespace ngap } // namespace ngap
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
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