Update 5GS Tracking Area Identity

src/nas/ies/NSSAI.cpp

@@ -56,12 +56,12 @@ NSSAI::NSSAI() : Type4NasIe(), S_NSSAIs() {
 NSSAI::~NSSAI() {}
 
 //------------------------------------------------------------------------------
-void NSSAI::getValue(std::vector<struct SNSSAI_s>& nssai) {
+void NSSAI::GetValue(std::vector<struct SNSSAI_s>& nssai) const {
   nssai.assign(S_NSSAIs.begin(), S_NSSAIs.end());
 }
 
 //------------------------------------------------------------------------------
-int NSSAI::encode2Buffer(uint8_t* buf, int len) {
+int NSSAI::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
   int ie_len = GetIeLength();
 
@@ -109,7 +109,7 @@ int NSSAI::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int NSSAI::decodeFromBuffer(uint8_t* buf, int len, bool is_iei) {
+int NSSAI::Decode(uint8_t* buf, int len, bool is_iei) {
   Logger::nas_mm().debug("Decoding %s", GetIeName().c_str());
   if (len < kNssaiMinimumLength) {
     Logger::nas_mm().error(

src/nas/ies/NSSAI.hpp

@@ -40,9 +40,9 @@ class NSSAI : public Type4NasIe {
   NSSAI(uint8_t iei);
   NSSAI(uint8_t iei, const std::vector<struct SNSSAI_s>& nssai);
   ~NSSAI();
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_iei);
-  void getValue(std::vector<struct SNSSAI_s>& nssai);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_iei);
+  void GetValue(std::vector<struct SNSSAI_s>& nssai) const;
 
  private:
   std::vector<struct SNSSAI_s>

src/nas/ies/Type3NasIe.cpp

@@ -54,3 +54,29 @@ bool Type3NasIe::Validate(const int& len) const {
   }
   return true;
 }
+
+//------------------------------------------------------------------------------
+int Type3NasIe::Encode(uint8_t* buf, const int& len) {
+  if (!Validate(len)) return KEncodeDecodeError;
+
+  int encoded_size = 0;
+  uint8_t octet    = 0;
+  if (iei_.has_value()) {
+    ENCODE_U8(buf + encoded_size, iei_.value(), encoded_size);
+  }
+  return encoded_size;
+}
+
+//------------------------------------------------------------------------------
+int Type3NasIe::Decode(const uint8_t* const buf, const int& len, bool is_iei) {
+  if (!Validate(len)) return KEncodeDecodeError;
+
+  int decoded_size = 0;
+  uint8_t octet    = 0;
+
+  if (is_iei) {
+    DECODE_U8(buf + decoded_size, octet, decoded_size);
+    iei_ = std::optional<uint8_t>(octet);
+  }
+  return decoded_size;
+}

src/nas/ies/_5GSTrackingAreaIdentity.cpp

@@ -25,75 +25,70 @@
 #include "common_defs.h"
 #include "logger.hpp"
 #include "NasUtils.hpp"
+#include "Ie_Const.hpp"
 
 using namespace nas;
 
 //------------------------------------------------------------------------------
-_5GSTrackingAreaIdentity::_5GSTrackingAreaIdentity(uint8_t iei) {
-  _iei = iei;
+_5GSTrackingAreaIdentity::_5GSTrackingAreaIdentity()
+    : Type3NasIe(kIei5gsTrackingAreaIdentity) {
   mcc_ = {};
   mnc_ = {};
-  tac_ = 0x0000;
+  tac_ = 0;
+  SetIeName(k5gsTrackingAreaIdentityIeName);
 }
 
 //------------------------------------------------------------------------------
 _5GSTrackingAreaIdentity::_5GSTrackingAreaIdentity(
-    const uint8_t iei, const std::string& mcc, const std::string& mnc,
-    const uint32_t& tac) {
-  _iei = iei;
+    const std::string& mcc, const std::string& mnc, const uint32_t& tac)
+    : Type3NasIe(kIei5gsTrackingAreaIdentity) {
   mcc_ = mcc;
   mnc_ = mnc;
   tac_ = tac & 0x0fff;
-}
-
-//------------------------------------------------------------------------------
-_5GSTrackingAreaIdentity::_5GSTrackingAreaIdentity() {
-  _iei = 0;
-  mcc_ = {};
-  mnc_ = {};
-  tac_ = 0;
+  SetIeName(k5gsTrackingAreaIdentityIeName);
 }
 
 //------------------------------------------------------------------------------
 _5GSTrackingAreaIdentity::~_5GSTrackingAreaIdentity() {}
 
 //------------------------------------------------------------------------------
-void _5GSTrackingAreaIdentity::setTAC(const uint32_t& value) {
+void _5GSTrackingAreaIdentity::SetTac(const uint32_t& value) {
   tac_ = value & 0x0fff;
 }
 
 //------------------------------------------------------------------------------
-uint32_t _5GSTrackingAreaIdentity::getTAC() const {
+uint32_t _5GSTrackingAreaIdentity::GetTac() const {
   return tac_;
 }
 //------------------------------------------------------------------------------
-void _5GSTrackingAreaIdentity::getTAC(uint32_t& value) const {
+void _5GSTrackingAreaIdentity::GetTac(uint32_t& value) const {
   value = tac_;
 }
 
 //------------------------------------------------------------------------------
-void _5GSTrackingAreaIdentity::setMcc(const std::string& mcc) {
+void _5GSTrackingAreaIdentity::SetMcc(const std::string& mcc) {
   mcc_ = mcc;
 }
 
 //------------------------------------------------------------------------------
-void _5GSTrackingAreaIdentity::getMcc(std::string& mcc) const {
+void _5GSTrackingAreaIdentity::GetMcc(std::string& mcc) const {
   mcc = mcc_;
 }
 
 //------------------------------------------------------------------------------
-void _5GSTrackingAreaIdentity::setMnc(const std::string& mnc) {
+void _5GSTrackingAreaIdentity::SetMnc(const std::string& mnc) {
   mnc_ = mnc;
 }
 
 //------------------------------------------------------------------------------
-void _5GSTrackingAreaIdentity::getMnc(std::string& mnc) const {
+void _5GSTrackingAreaIdentity::GetMnc(std::string& mnc) const {
   mnc = mnc_;
 }
 
 //------------------------------------------------------------------------------
-int _5GSTrackingAreaIdentity::encode2Buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("Encoding _5GSTrackingAreaIdentity (IEI 0x%x)", _iei);
+int _5GSTrackingAreaIdentity::Encode(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
+
   if (len < k5gsTrackingAreaIdentityLength) {
     Logger::nas_mm().error(
         "Buffer length is less than the minimum length of this IE (%d octet)",
@@ -102,30 +97,35 @@ int _5GSTrackingAreaIdentity::encode2Buffer(uint8_t* buf, int len) {
   }
   int encoded_size = 0;
 
-  if (_iei) {
-    ENCODE_U8(buf + encoded_size, _iei, encoded_size);
-  }
-
+  // IEI
+  encoded_size += Type3NasIe::Encode(buf + encoded_size, len);
+  // MCC, MNC
   encoded_size += NasUtils::encodeMccMnc2Buffer(
       mcc_, mnc_, buf + encoded_size, len - encoded_size);
-
+  // TAC
   ENCODE_U24(buf + encoded_size, tac_, encoded_size);
 
   Logger::nas_mm().debug(
-      "Encoded _5GSTrackingAreaIdentity len (%d)", encoded_size);
+      "Encoded %s, len (%d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int _5GSTrackingAreaIdentity::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("Decoding _5GSTrackingAreaIdentity");
-  int decoded_size = 0;
-  if (is_option) {
-    DECODE_U8(buf + decoded_size, _iei, decoded_size);
-    Logger::nas_mm().debug(
-        "Decoding _5GSTrackingAreaIdentity IEI (0x%x)", _iei);
+int _5GSTrackingAreaIdentity::Decode(uint8_t* buf, int len, bool is_iei) {
+  Logger::nas_mm().debug("Decoding %s", GetIeName().c_str());
+
+  if (len < k5gsTrackingAreaIdentityLength) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        k5gsTrackingAreaIdentityLength);
+    return KEncodeDecodeError;
   }
+
+  int decoded_size = 0;
+
+  // IEI and Length
+  decoded_size += Type3NasIe::Decode(buf + decoded_size, len, true);
+
   decoded_size += NasUtils::decodeMccMncFromBuffer(
       mcc_, mnc_, buf + decoded_size, len - decoded_size);
 
@@ -133,6 +133,6 @@ int _5GSTrackingAreaIdentity::decodeFromBuffer(
 
   Logger::nas_mm().debug("Decoded TAC 0x%x", tac_);
   Logger::nas_mm().debug(
-      "Decoded _5GSTrackingAreaIdentity len(%d)", decoded_size);
+      "Decoded %s, len (%d)", GetIeName().c_str(), decoded_size);
   return decoded_size;
 }

src/nas/ies/_5GSTrackingAreaIdentity.hpp

@@ -22,38 +22,39 @@
 #ifndef __5GS_TRACKING_AREA_IDENTITY_H_
 #define __5GS_TRACKING_AREA_IDENTITY_H_
 
+#include "Type3NasIe.hpp"
+
 #include <stdint.h>
 #include <string>
 
 constexpr uint8_t k5gsTrackingAreaIdentityLength = 7;
+constexpr auto k5gsTrackingAreaIdentityIeName    = "5GS Tracking Area Identity";
 
 namespace nas {
 
-class _5GSTrackingAreaIdentity {
+class _5GSTrackingAreaIdentity : public Type3NasIe {
  public:
   _5GSTrackingAreaIdentity();
-  _5GSTrackingAreaIdentity(uint8_t iei);
+  _5GSTrackingAreaIdentity(uint8_t iei) = delete;
   _5GSTrackingAreaIdentity(
-      const uint8_t iei, const std::string& mcc, const std::string& mnc,
-      const uint32_t& tac);
+      const std::string& mcc, const std::string& mnc, const uint32_t& tac);
 
   ~_5GSTrackingAreaIdentity();
 
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_iei = true);
 
-  void setTAC(const uint32_t& value);
-  uint32_t getTAC() const;
-  void getTAC(uint32_t& value) const;
+  void SetTac(const uint32_t& value);
+  uint32_t GetTac() const;
+  void GetTac(uint32_t& value) const;
 
-  void setMcc(const std::string& mcc);
-  void getMcc(std::string& mcc) const;
+  void SetMcc(const std::string& mcc);
+  void GetMcc(std::string& mcc) const;
 
-  void setMnc(const std::string& mnc);
-  void getMnc(std::string& mnc) const;
+  void SetMnc(const std::string& mnc);
+  void GetMnc(std::string& mnc) const;
 
  private:
-  uint8_t _iei;
   std::string mcc_;
   std::string mnc_;
   uint32_t tac_;

src/nas/msgs/RegistrationAccept.cpp

@@ -341,8 +341,8 @@ int RegistrationAccept::encode2Buffer(uint8_t* buf, int len) {
   if (!ie_allowed_nssai) {
     Logger::nas_mm().warn("IE ie_allowed_nssai is not available");
   } else {
-    if (int size = ie_allowed_nssai->encode2Buffer(
-            buf + encoded_size, len - encoded_size)) {
+    if (int size =
+            ie_allowed_nssai->Encode(buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
       Logger::nas_mm().error("Encoding ie_allowed_nssai error");
@@ -362,7 +362,7 @@ int RegistrationAccept::encode2Buffer(uint8_t* buf, int len) {
   if (!ie_configured_nssai) {
     Logger::nas_mm().warn("IE ie_configured_nssai is not available");
   } else {
-    if (int size = ie_configured_nssai->encode2Buffer(
+    if (int size = ie_configured_nssai->Encode(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -600,8 +600,8 @@ int RegistrationAccept::encode2Buffer(uint8_t* buf, int len) {
   if (!ie_pending_nssai) {
     Logger::nas_mm().warn("IE ie_pending_nssai is not available");
   } else {
-    if (int size = ie_pending_nssai->encode2Buffer(
-            buf + encoded_size, len - encoded_size)) {
+    if (int size =
+            ie_pending_nssai->Encode(buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
       Logger::nas_mm().error("Encoding ie_pending_nssai error");
@@ -684,7 +684,7 @@ int RegistrationAccept::decodeFromBuffer(uint8_t* buf, int len) {
       case 0x15: {
         Logger::nas_mm().debug("Decoding IEI (0x15)");
         ie_allowed_nssai = new NSSAI();
-        decoded_size += ie_allowed_nssai->decodeFromBuffer(
+        decoded_size += ie_allowed_nssai->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
@@ -700,7 +700,7 @@ int RegistrationAccept::decodeFromBuffer(uint8_t* buf, int len) {
       case 0x31: {
         Logger::nas_mm().debug("Decoding IEI (0x31)");
         ie_configured_nssai = new NSSAI();
-        decoded_size += ie_configured_nssai->decodeFromBuffer(
+        decoded_size += ie_configured_nssai->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
@@ -840,7 +840,7 @@ int RegistrationAccept::decodeFromBuffer(uint8_t* buf, int len) {
       case 0x39: {
         Logger::nas_mm().debug("Decoding IEI (0x39)");
         ie_pending_nssai = new NSSAI();
-        decoded_size += ie_pending_nssai->decodeFromBuffer(
+        decoded_size += ie_pending_nssai->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);

src/nas/msgs/RegistrationRequest.cpp

@@ -250,14 +250,14 @@ bool RegistrationRequest::getUeSecurityCapability(
 //------------------------------------------------------------------------------
 void RegistrationRequest::setRequestedNSSAI(
     std::vector<struct SNSSAI_s> nssai) {
-  ie_requested_NSSAI = std::make_optional<NSSAI>(0x2F, nssai);
+  ie_requested_NSSAI = std::make_optional<NSSAI>(kIeiNSSAIRequested, nssai);
 }
 
 //------------------------------------------------------------------------------
 bool RegistrationRequest::getRequestedNssai(
     std::vector<struct SNSSAI_s>& nssai) {
   if (ie_requested_NSSAI.has_value()) {
-    ie_requested_NSSAI.value().getValue(nssai);
+    ie_requested_NSSAI.value().GetValue(nssai);
   } else {
     return false;
   }
@@ -268,7 +268,7 @@ bool RegistrationRequest::getRequestedNssai(
 void RegistrationRequest::setLastVisitedRegisteredTAI(
     const std::string& mcc, const std::string mnc, const uint32_t& tac) {
   ie_last_visited_registered_TAI =
-      std::make_optional<_5GSTrackingAreaIdentity>(0, mcc, mnc, tac);
+      std::make_optional<_5GSTrackingAreaIdentity>(mcc, mnc, tac);
 }
 
 //------------------------------------------------------------------------------
@@ -612,7 +612,7 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
   if (!ie_requested_NSSAI.has_value()) {
     Logger::nas_mm().warn("IE Requested NSSAI is not available");
   } else {
-    if ((encoded_ie_size = ie_requested_NSSAI.value().encode2Buffer(
+    if ((encoded_ie_size = ie_requested_NSSAI.value().Encode(
              buf + encoded_size, len - encoded_size)) == KEncodeDecodeError) {
       Logger::nas_mm().error("Encoding Requested NSSAI error");
       return KEncodeDecodeError;
@@ -625,7 +625,7 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
   if (!ie_last_visited_registered_TAI.has_value()) {
     Logger::nas_mm().warn("IE ie_Last_visited_registered_TAI is not available");
   } else {
-    if (int size = ie_last_visited_registered_TAI.value().encode2Buffer(
+    if (int size = ie_last_visited_registered_TAI.value().Encode(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -923,19 +923,20 @@ int RegistrationRequest::decodeFromBuffer(uint8_t* buf, int len) {
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
       } break;
-      case 0x2F: {
-        Logger::nas_mm().debug("Decoding IEI (0x2F)");
+      case kIeiNSSAIRequested: {
+        Logger::nas_mm().debug("Decoding IEI %d", kIeiNSSAIRequested);
         NSSAI ie_requested_NSSAI_tmp = {};
-        decoded_size += ie_requested_NSSAI_tmp.decodeFromBuffer(
+        decoded_size += ie_requested_NSSAI_tmp.Decode(
             buf + decoded_size, len - decoded_size, true);
-        ie_requested_NSSAI = std::optional<NSSAI>(ie_requested_NSSAI_tmp);
+        ie_requested_NSSAI = std::make_optional<NSSAI>(ie_requested_NSSAI_tmp);
         octet              = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
       } break;
-      case 0x52: {
-        Logger::nas_mm().debug("Decoding IEI(0x52)");
+      case kIei5gsTrackingAreaIdentity: {
+        Logger::nas_mm().debug(
+            "Decoding IEI 0x%x", kIei5gsTrackingAreaIdentity);
         _5GSTrackingAreaIdentity last_visited_registered_tai_tmp = {};
-        decoded_size += last_visited_registered_tai_tmp.decodeFromBuffer(
+        decoded_size += last_visited_registered_tai_tmp.Decode(
             buf + decoded_size, len - decoded_size, true);
         ie_last_visited_registered_TAI =
             std::optional<_5GSTrackingAreaIdentity>(

src/nas/msgs/RegistrationRequest.hpp

@@ -153,8 +153,8 @@ class RegistrationRequest : public NasMmPlainHeader {
   std::optional<NasKeySetIdentifier> ie_non_current_native_nas_ksi;  // Optional
   std::optional<_5GMMCapability> ie_5g_mm_capability;                // Optional
   std::optional<UESecurityCapability> ie_ue_security_capability;     // Optional
+  std::optional<NSSAI> ie_requested_NSSAI;                           // Optional
 
-  std::optional<NSSAI> ie_requested_NSSAI;  // Optional
   std::optional<_5GSTrackingAreaIdentity>
       ie_last_visited_registered_TAI;                              // Optional
   std::optional<UENetworkCapability> ie_s1_ue_network_capability;  // Optional