Commit 788fddaf authored by Tien Thinh NGUYEN's avatar Tien Thinh NGUYEN

Code refactor for UERadioCapabilityInfoIndication

parent ef36a432
...@@ -878,13 +878,7 @@ void amf_n2::handle_itti_message(itti_initial_context_setup_request& itti_msg) { ...@@ -878,13 +878,7 @@ void amf_n2::handle_itti_message(itti_initial_context_setup_request& itti_msg) {
if (itti_msg.is_sr or itti_msg.is_pdu_exist) { if (itti_msg.is_sr or itti_msg.is_pdu_exist) {
// Set UE RAdio Capability if available // Set UE RAdio Capability if available
if (gc->ue_radio_cap_ind) { if (gc->ue_radio_cap_ind) {
bstring ueCapability = gc->ue_radio_cap_ind; msg->setUERadioCapability(gc->ue_radio_cap_ind);
uint8_t* uecap = (uint8_t*) calloc(1, blength(ueCapability) + 1);
uint8_t* buf_tmp = (uint8_t*) bdata(ueCapability);
if (buf_tmp != nullptr) memcpy(uecap, buf_tmp, blength(ueCapability));
uecap[blength(ueCapability)] = '\0';
msg->setUERadioCapability(uecap, (size_t) blength(ueCapability));
free(uecap);
} }
if (itti_msg.is_sr) if (itti_msg.is_sr)
......
...@@ -407,3 +407,9 @@ bool conv::check_bstring(const bstring& b_str) { ...@@ -407,3 +407,9 @@ bool conv::check_bstring(const bstring& b_str) {
return false; return false;
return true; return true;
} }
//------------------------------------------------------------------------------
bool conv::check_octet_string(const OCTET_STRING_t& octet_str) {
if (!octet_str.buf or (octet_str.size == 0)) return false;
return true;
}
...@@ -83,6 +83,8 @@ class conv { ...@@ -83,6 +83,8 @@ class conv {
// TODO: bitstring_2_int32 // TODO: bitstring_2_int32
static bool octet_string_copy( static bool octet_string_copy(
OCTET_STRING_t& destination, const OCTET_STRING_t& source); OCTET_STRING_t& destination, const OCTET_STRING_t& source);
static bool check_bstring(const bstring& b_str); static bool check_bstring(const bstring& b_str);
static bool check_octet_string(const OCTET_STRING_t& octet_str);
}; };
#endif /* FILE_CONVERSIONS_HPP_SEEN */ #endif /* FILE_CONVERSIONS_HPP_SEEN */
...@@ -21,44 +21,44 @@ ...@@ -21,44 +21,44 @@
#include "UERadioCapability.hpp" #include "UERadioCapability.hpp"
#include "conversions.hpp"
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
UERadioCapability::UERadioCapability() { UERadioCapability::UERadioCapability() {}
buffer_ = nullptr;
size_ = -1;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
UERadioCapability::~UERadioCapability() {} UERadioCapability::~UERadioCapability() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool UERadioCapability::encode(Ngap_UERadioCapability_t& ueRadioCapability) { bool UERadioCapability::encode(Ngap_UERadioCapability_t& ueRadioCapability) {
int ret = OCTET_STRING_fromBuf(&ueRadioCapability, buffer_, size_); return conv::octet_string_copy(ueRadioCapability, ue_radio_capability_);
if (ret != 0) return false;
return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool UERadioCapability::decode(Ngap_UERadioCapability_t& ueRadioCapability) { bool UERadioCapability::decode(Ngap_UERadioCapability_t& ueRadioCapability) {
buffer_ = (char*) ueRadioCapability.buf; return conv::octet_string_copy(ue_radio_capability_, ueRadioCapability);
size_ = ueRadioCapability.size; }
return true;
//------------------------------------------------------------------------------
bool UERadioCapability::set(const OCTET_STRING_t& capability) {
return conv::octet_string_copy(ue_radio_capability_, capability);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool UERadioCapability::get(uint8_t*& buffer, size_t& size) { bool UERadioCapability::get(OCTET_STRING_t& capability) {
buffer = (uint8_t*) buffer_; return conv::octet_string_copy(capability, ue_radio_capability_);
size = size_; }
if (!buffer_) return false;
if (size_ < 0) return false;
return true; //------------------------------------------------------------------------------
bool UERadioCapability::set(const bstring& capability) {
return conv::bstring_2_octet_string(capability, ue_radio_capability_);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void UERadioCapability::set(uint8_t* buffer, size_t size) { bool UERadioCapability::get(bstring& capability) {
buffer_ = (char*) buffer; return conv::octet_string_2_bstring(ue_radio_capability_, capability);
size_ = size;
} }
} // namespace ngap } // namespace ngap
...@@ -22,6 +22,8 @@ ...@@ -22,6 +22,8 @@
#ifndef _UE_RADIO_CAPABILITY_H_ #ifndef _UE_RADIO_CAPABILITY_H_
#define _UE_RADIO_CAPABILITY_H_ #define _UE_RADIO_CAPABILITY_H_
#include "bstrlib.h"
extern "C" { extern "C" {
#include "Ngap_UERadioCapability.h" #include "Ngap_UERadioCapability.h"
} }
...@@ -35,12 +37,15 @@ class UERadioCapability { ...@@ -35,12 +37,15 @@ class UERadioCapability {
bool encode(Ngap_UERadioCapability_t& ueRadioCapability); bool encode(Ngap_UERadioCapability_t& ueRadioCapability);
bool decode(Ngap_UERadioCapability_t& ueRadioCapability); bool decode(Ngap_UERadioCapability_t& ueRadioCapability);
bool get(uint8_t*& buffer, size_t& size);
void set(uint8_t* buffer, size_t size); bool set(const OCTET_STRING_t& capability);
bool get(OCTET_STRING_t& capability);
bool set(const bstring& capability);
bool get(bstring& capability);
private: private:
char* buffer_; OCTET_STRING_t ue_radio_capability_;
size_t size_;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -39,7 +39,7 @@ bool UERadioCapabilityForPaging::encode2UERadioCapabilityForPaging( ...@@ -39,7 +39,7 @@ bool UERadioCapabilityForPaging::encode2UERadioCapabilityForPaging(
ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR = ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR =
(Ngap_UERadioCapabilityForPagingOfNR_t*) calloc( (Ngap_UERadioCapabilityForPagingOfNR_t*) calloc(
1, sizeof(Ngap_UERadioCapabilityForPagingOfNR_t)); 1, sizeof(Ngap_UERadioCapabilityForPagingOfNR_t));
if (!ueRadioCapabilityForPagingOfNR->encode2UERadioCapabilityForPagingOfNR( if (!ueRadioCapabilityForPagingOfNR->encode(
ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR)) ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR))
return false; return false;
} }
...@@ -47,8 +47,7 @@ bool UERadioCapabilityForPaging::encode2UERadioCapabilityForPaging( ...@@ -47,8 +47,7 @@ bool UERadioCapabilityForPaging::encode2UERadioCapabilityForPaging(
ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA = ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA =
(Ngap_UERadioCapabilityForPagingOfEUTRA_t*) calloc( (Ngap_UERadioCapabilityForPagingOfEUTRA_t*) calloc(
1, sizeof(Ngap_UERadioCapabilityForPagingOfEUTRA_t)); 1, sizeof(Ngap_UERadioCapabilityForPagingOfEUTRA_t));
if (!ueRadioCapabilityForPagingOfEUTRA if (!ueRadioCapabilityForPagingOfEUTRA->encode(
->encode2UERadioCapabilityForPagingOfEUTRA(
ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA)) ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA))
return false; return false;
} }
...@@ -61,15 +60,13 @@ bool UERadioCapabilityForPaging::decodefromUERadioCapabilityForPaging( ...@@ -61,15 +60,13 @@ bool UERadioCapabilityForPaging::decodefromUERadioCapabilityForPaging(
Ngap_UERadioCapabilityForPaging_t* ueRadioCapabilityForPaging) { Ngap_UERadioCapabilityForPaging_t* ueRadioCapabilityForPaging) {
if (ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR) { if (ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR) {
ueRadioCapabilityForPagingOfNR = new UERadioCapabilityForPagingOfNR(); ueRadioCapabilityForPagingOfNR = new UERadioCapabilityForPagingOfNR();
if (!ueRadioCapabilityForPagingOfNR if (!ueRadioCapabilityForPagingOfNR->decode(
->decodefromUERadioCapabilityForPagingOfNR(
ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR)) ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR))
return false; return false;
} }
if (ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA) { if (ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA) {
ueRadioCapabilityForPagingOfEUTRA = new UERadioCapabilityForPagingOfEUTRA(); ueRadioCapabilityForPagingOfEUTRA = new UERadioCapabilityForPagingOfEUTRA();
if (!ueRadioCapabilityForPagingOfEUTRA if (!ueRadioCapabilityForPagingOfEUTRA->decode(
->decodefromUERadioCapabilityForPagingOfEUTRA(
ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA)) ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA))
return false; return false;
} }
......
...@@ -48,8 +48,9 @@ class UERadioCapabilityForPaging { ...@@ -48,8 +48,9 @@ class UERadioCapabilityForPaging {
UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA); UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA);
private: private:
UERadioCapabilityForPagingOfNR* ueRadioCapabilityForPagingOfNR; UERadioCapabilityForPagingOfNR* ueRadioCapabilityForPagingOfNR; // Optional
UERadioCapabilityForPagingOfEUTRA* ueRadioCapabilityForPagingOfEUTRA; UERadioCapabilityForPagingOfEUTRA*
ueRadioCapabilityForPagingOfEUTRA; // Optional
}; };
} // namespace ngap } // namespace ngap
......
...@@ -21,54 +21,50 @@ ...@@ -21,54 +21,50 @@
#include "UERadioCapabilityForPagingOfEUTRA.hpp" #include "UERadioCapabilityForPagingOfEUTRA.hpp"
#include "conversions.hpp"
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
UERadioCapabilityForPagingOfEUTRA::UERadioCapabilityForPagingOfEUTRA() { UERadioCapabilityForPagingOfEUTRA::UERadioCapabilityForPagingOfEUTRA() {}
EUTRAbuffer = NULL;
sizeofEUTRAbuffer = -1;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
UERadioCapabilityForPagingOfEUTRA::~UERadioCapabilityForPagingOfEUTRA() {} UERadioCapabilityForPagingOfEUTRA::~UERadioCapabilityForPagingOfEUTRA() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool UERadioCapabilityForPagingOfEUTRA:: bool UERadioCapabilityForPagingOfEUTRA::encode(
encode2UERadioCapabilityForPagingOfEUTRA(
Ngap_UERadioCapabilityForPagingOfEUTRA_t* Ngap_UERadioCapabilityForPagingOfEUTRA_t*
ueRadioCapabilityForPagingOfEUTRA) { ueRadioCapabilityForPagingOfEUTRA) {
int ret; return conv::octet_string_copy(
ret = OCTET_STRING_fromBuf( *ueRadioCapabilityForPagingOfEUTRA, ue_radio_capability_);
ueRadioCapabilityForPagingOfEUTRA, EUTRAbuffer, sizeofEUTRAbuffer);
if (ret != 0) return false;
return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool UERadioCapabilityForPagingOfEUTRA:: bool UERadioCapabilityForPagingOfEUTRA::decode(
decodefromUERadioCapabilityForPagingOfEUTRA(
Ngap_UERadioCapabilityForPagingOfEUTRA_t* Ngap_UERadioCapabilityForPagingOfEUTRA_t*
ueRadioCapabilityForPagingOfEUTRA) { ueRadioCapabilityForPagingOfEUTRA) {
EUTRAbuffer = (char*) ueRadioCapabilityForPagingOfEUTRA->buf; return conv::octet_string_copy(
sizeofEUTRAbuffer = ueRadioCapabilityForPagingOfEUTRA->size; ue_radio_capability_, *ueRadioCapabilityForPagingOfEUTRA);
return true; }
//------------------------------------------------------------------------------
bool UERadioCapabilityForPagingOfEUTRA::set(const OCTET_STRING_t& capability) {
return conv::octet_string_copy(ue_radio_capability_, capability);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool UERadioCapabilityForPagingOfEUTRA::getUERadioCapabilityForPagingOfEUTRA( bool UERadioCapabilityForPagingOfEUTRA::get(OCTET_STRING_t& capability) {
uint8_t*& buffer, size_t& size) { return conv::octet_string_copy(capability, ue_radio_capability_);
buffer = (uint8_t*) EUTRAbuffer; }
size = sizeofEUTRAbuffer;
if (!EUTRAbuffer) return false;
if (sizeofEUTRAbuffer < 0) return false;
return true; //------------------------------------------------------------------------------
bool UERadioCapabilityForPagingOfEUTRA::set(const bstring& capability) {
return conv::bstring_2_octet_string(capability, ue_radio_capability_);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void UERadioCapabilityForPagingOfEUTRA::setUERadioCapabilityForPagingOfEUTRA( bool UERadioCapabilityForPagingOfEUTRA::get(bstring& capability) {
uint8_t* buffer, size_t size) { return conv::octet_string_2_bstring(ue_radio_capability_, capability);
EUTRAbuffer = (char*) buffer;
sizeofEUTRAbuffer = size;
} }
} // namespace ngap } // namespace ngap
...@@ -19,8 +19,10 @@ ...@@ -19,8 +19,10 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
#ifndef _UERADIOCAPABILITYFORPAGINGOFEUTRA_H_ #ifndef _UE_RADIO_CAPABILITY_FOR_PAGING_OF_EUTRA_H_
#define _UERADIOCAPABILITYFORPAGINGOFEUTRA_H_ #define _UE_RADIO_CAPABILITY_FOR_PAGING_OF_EUTRA_H_
#include "bstrlib.h"
extern "C" { extern "C" {
#include "Ngap_UERadioCapabilityForPagingOfEUTRA.h" #include "Ngap_UERadioCapabilityForPagingOfEUTRA.h"
...@@ -33,18 +35,19 @@ class UERadioCapabilityForPagingOfEUTRA { ...@@ -33,18 +35,19 @@ class UERadioCapabilityForPagingOfEUTRA {
UERadioCapabilityForPagingOfEUTRA(); UERadioCapabilityForPagingOfEUTRA();
virtual ~UERadioCapabilityForPagingOfEUTRA(); virtual ~UERadioCapabilityForPagingOfEUTRA();
bool encode2UERadioCapabilityForPagingOfEUTRA( bool encode(Ngap_UERadioCapabilityForPagingOfEUTRA_t*
Ngap_UERadioCapabilityForPagingOfEUTRA_t*
ueRadioCapabilityForPagingOfEUTRA); ueRadioCapabilityForPagingOfEUTRA);
bool decodefromUERadioCapabilityForPagingOfEUTRA( bool decode(Ngap_UERadioCapabilityForPagingOfEUTRA_t*
Ngap_UERadioCapabilityForPagingOfEUTRA_t*
ueRadioCapabilityForPagingOfEUTRA); ueRadioCapabilityForPagingOfEUTRA);
bool getUERadioCapabilityForPagingOfEUTRA(uint8_t*& buffer, size_t& size);
void setUERadioCapabilityForPagingOfEUTRA(uint8_t* buffer, size_t size); bool set(const OCTET_STRING_t& capability);
bool get(OCTET_STRING_t& capability);
bool set(const bstring& capability);
bool get(bstring& capability);
private: private:
char* EUTRAbuffer; OCTET_STRING_t ue_radio_capability_;
size_t sizeofEUTRAbuffer;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -21,50 +21,48 @@ ...@@ -21,50 +21,48 @@
#include "UERadioCapabilityForPagingOfNR.hpp" #include "UERadioCapabilityForPagingOfNR.hpp"
#include "conversions.hpp"
namespace ngap { namespace ngap {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
UERadioCapabilityForPagingOfNR::UERadioCapabilityForPagingOfNR() { UERadioCapabilityForPagingOfNR::UERadioCapabilityForPagingOfNR() {}
nRbuffer = NULL;
sizeofnRbuffer = -1;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
UERadioCapabilityForPagingOfNR::~UERadioCapabilityForPagingOfNR() {} UERadioCapabilityForPagingOfNR::~UERadioCapabilityForPagingOfNR() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool UERadioCapabilityForPagingOfNR::encode2UERadioCapabilityForPagingOfNR( bool UERadioCapabilityForPagingOfNR::encode(
Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR) { Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR) {
int ret; return conv::octet_string_copy(
ret = OCTET_STRING_fromBuf( *ueRadioCapabilityForPagingOfNR, ue_radio_capability_);
ueRadioCapabilityForPagingOfNR, nRbuffer, sizeofnRbuffer);
if (ret != 0) return false;
return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool UERadioCapabilityForPagingOfNR::decodefromUERadioCapabilityForPagingOfNR( bool UERadioCapabilityForPagingOfNR::decode(
Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR) { Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR) {
nRbuffer = (char*) ueRadioCapabilityForPagingOfNR->buf; return conv::octet_string_copy(
sizeofnRbuffer = ueRadioCapabilityForPagingOfNR->size; ue_radio_capability_, *ueRadioCapabilityForPagingOfNR);
return true; }
//------------------------------------------------------------------------------
bool UERadioCapabilityForPagingOfNR::set(const OCTET_STRING_t& capability) {
return conv::octet_string_copy(ue_radio_capability_, capability);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool UERadioCapabilityForPagingOfNR::getUERadioCapabilityForPagingOfNR( bool UERadioCapabilityForPagingOfNR::get(OCTET_STRING_t& capability) {
uint8_t*& buffer, size_t& size) { return conv::octet_string_copy(capability, ue_radio_capability_);
buffer = (uint8_t*) nRbuffer; }
size = sizeofnRbuffer;
if (!nRbuffer) return false;
if (sizeofnRbuffer < 0) return false;
return true; //------------------------------------------------------------------------------
bool UERadioCapabilityForPagingOfNR::set(const bstring& capability) {
return conv::bstring_2_octet_string(capability, ue_radio_capability_);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void UERadioCapabilityForPagingOfNR::setUERadioCapabilityForPagingOfNR( bool UERadioCapabilityForPagingOfNR::get(bstring& capability) {
uint8_t* buffer, size_t size) { return conv::octet_string_2_bstring(ue_radio_capability_, capability);
nRbuffer = (char*) buffer;
sizeofnRbuffer = size;
} }
} // namespace ngap } // namespace ngap
...@@ -19,8 +19,10 @@ ...@@ -19,8 +19,10 @@
* contact@openairinterface.org * contact@openairinterface.org
*/ */
#ifndef _UERADIOCAPABILITYFORPAGINGOFNR_H_ #ifndef _UE_RADIO_CAPABILITY_FOR_PAGING_OF_NR_H_
#define _UERADIOCAPABILITYFORPAGINGOFNR_H_ #define _UE_RADIO_CAPABILITY_FOR_PAGING_OF_NR_H_
#include "bstrlib.h"
extern "C" { extern "C" {
#include "Ngap_UERadioCapabilityForPagingOfNR.h" #include "Ngap_UERadioCapabilityForPagingOfNR.h"
...@@ -33,16 +35,19 @@ class UERadioCapabilityForPagingOfNR { ...@@ -33,16 +35,19 @@ class UERadioCapabilityForPagingOfNR {
UERadioCapabilityForPagingOfNR(); UERadioCapabilityForPagingOfNR();
virtual ~UERadioCapabilityForPagingOfNR(); virtual ~UERadioCapabilityForPagingOfNR();
bool encode2UERadioCapabilityForPagingOfNR( bool encode(
Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR); Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR);
bool decodefromUERadioCapabilityForPagingOfNR( bool decode(
Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR); Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR);
bool getUERadioCapabilityForPagingOfNR(uint8_t*& buffer, size_t& size);
void setUERadioCapabilityForPagingOfNR(uint8_t* buffer, size_t size); bool set(const OCTET_STRING_t& capability);
bool get(OCTET_STRING_t& capability);
bool set(const bstring& capability);
bool get(bstring& capability);
private: private:
char* nRbuffer; OCTET_STRING_t ue_radio_capability_;
size_t sizeofnRbuffer;
}; };
} // namespace ngap } // namespace ngap
......
...@@ -560,9 +560,9 @@ bool InitialContextSetupRequestMsg::getNasPdu(bstring& pdu) { ...@@ -560,9 +560,9 @@ bool InitialContextSetupRequestMsg::getNasPdu(bstring& pdu) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void InitialContextSetupRequestMsg::setUERadioCapability( void InitialContextSetupRequestMsg::setUERadioCapability(
uint8_t* buffer, size_t size) { const bstring& ue_radio_capability) {
UERadioCapability tmp = {}; UERadioCapability tmp = {};
tmp.set(buffer, size); tmp.set(ue_radio_capability);
ueRadioCapability = std::optional<UERadioCapability>(tmp); ueRadioCapability = std::optional<UERadioCapability>(tmp);
Ngap_InitialContextSetupRequestIEs_t* ie = Ngap_InitialContextSetupRequestIEs_t* ie =
...@@ -587,9 +587,9 @@ void InitialContextSetupRequestMsg::setUERadioCapability( ...@@ -587,9 +587,9 @@ void InitialContextSetupRequestMsg::setUERadioCapability(
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void InitialContextSetupRequestMsg::getUERadioCapability( void InitialContextSetupRequestMsg::getUERadioCapability(
uint8_t* buffer, size_t& size) { bstring& ue_radio_capability) {
if (!ueRadioCapability.has_value()) return; if (!ueRadioCapability.has_value()) return;
ueRadioCapability.value().get(buffer, size); ueRadioCapability.value().get(ue_radio_capability);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
......
...@@ -100,8 +100,8 @@ class InitialContextSetupRequestMsg : public NgapUEMessage { ...@@ -100,8 +100,8 @@ class InitialContextSetupRequestMsg : public NgapUEMessage {
void setSecurityKey(uint8_t* key); // 256bits void setSecurityKey(uint8_t* key); // 256bits
bool getSecurityKey(uint8_t*& key); // 256bits bool getSecurityKey(uint8_t*& key); // 256bits
void setUERadioCapability(uint8_t* buf, size_t size); void setUERadioCapability(const bstring& ue_radio_capability);
void getUERadioCapability(uint8_t* buf, size_t& size); void getUERadioCapability(bstring& ue_radio_capability);
void setNasPdu(const bstring& pdu); void setNasPdu(const bstring& pdu);
bool getNasPdu(bstring& pdu); bool getNasPdu(bstring& pdu);
......
...@@ -21,6 +21,7 @@ ...@@ -21,6 +21,7 @@
#include "UERadioCapabilityInfoIndication.hpp" #include "UERadioCapabilityInfoIndication.hpp"
#include "conversions.hpp"
#include "logger.hpp" #include "logger.hpp"
extern "C" { extern "C" {
...@@ -101,7 +102,7 @@ void UeRadioCapabilityInfoIndicationMsg::setRanUeNgapId( ...@@ -101,7 +102,7 @@ void UeRadioCapabilityInfoIndicationMsg::setRanUeNgapId(
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void UeRadioCapabilityInfoIndicationMsg::setUERadioCapability( void UeRadioCapabilityInfoIndicationMsg::setUERadioCapability(
const OCTET_STRING_t& capability) { const OCTET_STRING_t& capability) {
ueRadioCapability = capability; ueRadioCapability.set(capability);
Ngap_UERadioCapabilityInfoIndicationIEs_t* ie = Ngap_UERadioCapabilityInfoIndicationIEs_t* ie =
(Ngap_UERadioCapabilityInfoIndicationIEs_t*) calloc( (Ngap_UERadioCapabilityInfoIndicationIEs_t*) calloc(
...@@ -111,16 +112,13 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapability( ...@@ -111,16 +112,13 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapability(
ie->value.present = ie->value.present =
Ngap_UERadioCapabilityInfoIndicationIEs__value_PR_UERadioCapability; Ngap_UERadioCapabilityInfoIndicationIEs__value_PR_UERadioCapability;
int ret = OCTET_STRING_fromBuf( if (!ueRadioCapability.encode(ie->value.choice.UERadioCapability)) {
&ie->value.choice.UERadioCapability, (char*) ueRadioCapability.buf,
ueRadioCapability.size);
if (!ret) {
Logger::ngap().error("Encode NGAP UERadioCapability IE error"); Logger::ngap().error("Encode NGAP UERadioCapability IE error");
free_wrapper((void**) &ie); free_wrapper((void**) &ie);
return; return;
} }
ret = ASN_SEQUENCE_ADD( int ret = ASN_SEQUENCE_ADD(
&ueRadioCapabilityInfoIndicationIEs->protocolIEs.list, ie); &ueRadioCapabilityInfoIndicationIEs->protocolIEs.list, ie);
if (ret != 0) Logger::ngap().error("Encode NGAP UERadioCapability IE error"); if (ret != 0) Logger::ngap().error("Encode NGAP UERadioCapability IE error");
} }
...@@ -128,27 +126,27 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapability( ...@@ -128,27 +126,27 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapability(
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void UeRadioCapabilityInfoIndicationMsg::getUERadioCapability( void UeRadioCapabilityInfoIndicationMsg::getUERadioCapability(
OCTET_STRING_t& capability) { OCTET_STRING_t& capability) {
capability = ueRadioCapability; ueRadioCapability.get(capability);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void UeRadioCapabilityInfoIndicationMsg::setUERadioCapabilityForPaging( void UeRadioCapabilityInfoIndicationMsg::setUERadioCapabilityForPaging(
uint8_t* nr, size_t sizeofnr, uint8_t* eutra, size_t sizeofeutra) { const OCTET_STRING_t& ue_radio_capability_for_paging_of_nr,
const OCTET_STRING_t& ue_radio_capability_for_paging_of_eutra) {
if (!ueRadioCapabilityForPaging) if (!ueRadioCapabilityForPaging)
ueRadioCapabilityForPaging = new UERadioCapabilityForPaging(); ueRadioCapabilityForPaging = new UERadioCapabilityForPaging();
UERadioCapabilityForPagingOfNR* m_ueRadioCapabilityForPagingOfNR = nullptr; UERadioCapabilityForPagingOfNR* m_ueRadioCapabilityForPagingOfNR = nullptr;
UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA = UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA =
nullptr; nullptr;
if (nr && sizeofnr > 0) { if (conv::check_octet_string(ue_radio_capability_for_paging_of_nr)) {
m_ueRadioCapabilityForPagingOfNR = new UERadioCapabilityForPagingOfNR(); m_ueRadioCapabilityForPagingOfNR = new UERadioCapabilityForPagingOfNR();
m_ueRadioCapabilityForPagingOfNR->setUERadioCapabilityForPagingOfNR( m_ueRadioCapabilityForPagingOfNR->set(ue_radio_capability_for_paging_of_nr);
nr, sizeofnr);
} }
if (eutra && sizeofeutra > 0) { if (conv::check_octet_string(ue_radio_capability_for_paging_of_eutra)) {
m_ueRadioCapabilityForPagingOfEUTRA = m_ueRadioCapabilityForPagingOfEUTRA =
new UERadioCapabilityForPagingOfEUTRA(); new UERadioCapabilityForPagingOfEUTRA();
m_ueRadioCapabilityForPagingOfEUTRA->setUERadioCapabilityForPagingOfEUTRA( m_ueRadioCapabilityForPagingOfEUTRA->set(
eutra, sizeofeutra); ue_radio_capability_for_paging_of_eutra);
} }
ueRadioCapabilityForPaging->setUERadioCapabilityForPaging( ueRadioCapabilityForPaging->setUERadioCapabilityForPaging(
m_ueRadioCapabilityForPagingOfNR, m_ueRadioCapabilityForPagingOfEUTRA); m_ueRadioCapabilityForPagingOfNR, m_ueRadioCapabilityForPagingOfEUTRA);
...@@ -177,7 +175,8 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapabilityForPaging( ...@@ -177,7 +175,8 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapabilityForPaging(
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
bool UeRadioCapabilityInfoIndicationMsg::getUERadioCapabilityForPaging( bool UeRadioCapabilityInfoIndicationMsg::getUERadioCapabilityForPaging(
uint8_t*& nr, size_t& sizeofnr, uint8_t*& eutra, size_t& sizeofeutra) { OCTET_STRING_t& ue_radio_capability_for_paging_of_nr,
OCTET_STRING_t& ue_radio_capability_for_paging_of_eutra) {
if (!ueRadioCapabilityForPaging) return false; if (!ueRadioCapabilityForPaging) return false;
UERadioCapabilityForPagingOfNR* m_ueRadioCapabilityForPagingOfNR; UERadioCapabilityForPagingOfNR* m_ueRadioCapabilityForPagingOfNR;
UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA; UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA;
...@@ -187,13 +186,13 @@ bool UeRadioCapabilityInfoIndicationMsg::getUERadioCapabilityForPaging( ...@@ -187,13 +186,13 @@ bool UeRadioCapabilityInfoIndicationMsg::getUERadioCapabilityForPaging(
return false; return false;
if (m_ueRadioCapabilityForPagingOfNR) { if (m_ueRadioCapabilityForPagingOfNR) {
if (!m_ueRadioCapabilityForPagingOfNR->getUERadioCapabilityForPagingOfNR( if (!m_ueRadioCapabilityForPagingOfNR->get(
nr, sizeofnr)) ue_radio_capability_for_paging_of_nr))
return false; return false;
} }
if (m_ueRadioCapabilityForPagingOfEUTRA) { if (m_ueRadioCapabilityForPagingOfEUTRA) {
if (!m_ueRadioCapabilityForPagingOfEUTRA if (!m_ueRadioCapabilityForPagingOfEUTRA->get(
->getUERadioCapabilityForPagingOfEUTRA(eutra, sizeofeutra)) ue_radio_capability_for_paging_of_eutra))
return false; return false;
} }
...@@ -268,9 +267,9 @@ bool UeRadioCapabilityInfoIndicationMsg::decodeFromPdu( ...@@ -268,9 +267,9 @@ bool UeRadioCapabilityInfoIndicationMsg::decodeFromPdu(
ueRadioCapabilityInfoIndicationIEs->protocolIEs.list.array[i] ueRadioCapabilityInfoIndicationIEs->protocolIEs.list.array[i]
->value.present == ->value.present ==
Ngap_UERadioCapabilityInfoIndicationIEs__value_PR_UERadioCapability) { Ngap_UERadioCapabilityInfoIndicationIEs__value_PR_UERadioCapability) {
ueRadioCapability = ueRadioCapability.set(
ueRadioCapabilityInfoIndicationIEs->protocolIEs.list.array[i] ueRadioCapabilityInfoIndicationIEs->protocolIEs.list.array[i]
->value.choice.UERadioCapability; ->value.choice.UERadioCapability);
} else { } else {
Logger::ngap().error("Decoded NGAP UERadioCapability IE error"); Logger::ngap().error("Decoded NGAP UERadioCapability IE error");
return false; return false;
......
...@@ -24,6 +24,7 @@ ...@@ -24,6 +24,7 @@
#include "UERadioCapabilityForPaging.hpp" #include "UERadioCapabilityForPaging.hpp"
#include "NgapUEMessage.hpp" #include "NgapUEMessage.hpp"
#include "UERadioCapability.hpp"
extern "C" { extern "C" {
#include "Ngap_UERadioCapabilityInfoIndication.h" #include "Ngap_UERadioCapabilityInfoIndication.h"
...@@ -49,15 +50,17 @@ class UeRadioCapabilityInfoIndicationMsg : public NgapUEMessage { ...@@ -49,15 +50,17 @@ class UeRadioCapabilityInfoIndicationMsg : public NgapUEMessage {
void getUERadioCapability(OCTET_STRING_t& capability); void getUERadioCapability(OCTET_STRING_t& capability);
void setUERadioCapabilityForPaging( void setUERadioCapabilityForPaging(
uint8_t* nr, size_t sizeofnr, uint8_t* eutra, size_t sizeofeutra); const OCTET_STRING_t& ue_radio_capability_for_paging_of_nr,
const OCTET_STRING_t& ue_radio_capability_for_paging_of_eutra);
bool getUERadioCapabilityForPaging( bool getUERadioCapabilityForPaging(
uint8_t*& nr, size_t& sizeofnr, uint8_t*& eutra, size_t& sizeofeutra); OCTET_STRING_t& ue_radio_capability_for_paging_of_nr,
OCTET_STRING_t& ue_radio_capability_for_paging_of_eutra);
private: private:
Ngap_UERadioCapabilityInfoIndication_t* ueRadioCapabilityInfoIndicationIEs; Ngap_UERadioCapabilityInfoIndication_t* ueRadioCapabilityInfoIndicationIEs;
// AMF_UE_NGAP_ID //Mandatory // AMF_UE_NGAP_ID //Mandatory
// RAN_UE_NGAP_ID //Mandatory // RAN_UE_NGAP_ID //Mandatory
OCTET_STRING_t ueRadioCapability; // Mandatory UERadioCapability ueRadioCapability; // Mandatory
UERadioCapabilityForPaging* ueRadioCapabilityForPaging; // Optional UERadioCapabilityForPaging* ueRadioCapabilityForPaging; // Optional
}; };
......
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