Update UE Security Capability

src/amf-app/amf_n1.cpp

@@ -1308,7 +1308,7 @@ void amf_n1::registration_request_handle(
     Logger::amf_n1().warn("No Optional IE UESecurityCapability available");
   } else {
     nc->ueSecurityCaplen =
-        registration_request->ie_ue_security_capability->getLength();
+        registration_request->ie_ue_security_capability->GetLengthIndicator();
   }
 
   nc->ueSecurityCapEnc = encrypt_alg;
@@ -2409,7 +2409,7 @@ bool amf_n1::start_security_mode_control_procedure(
   }
 
   if (smc->ie_ue_security_capability != NULL) {
-    smc->ie_ue_security_capability->setLength(nc->ueSecurityCaplen);
+    smc->ie_ue_security_capability->SetLengthIndicator(nc->ueSecurityCaplen);
   } else {
     Logger::amf_n1().error("UE Security Capability is missing");
   }

src/nas/common/Ie_Const.hpp

@@ -87,7 +87,8 @@ constexpr uint8_t kIeiShortNameForNetwork                    = 0x45;
 constexpr uint8_t kIeiPayloadContainerType     = 0x08;  // Should be verified
 constexpr uint8_t kIeiNetworkSlicingIndication = 0x09;  // 9-(4 higher bits)
 
-constexpr uint8_t kIei5gmmCapability = 0x10;
+constexpr uint8_t kIei5gmmCapability       = 0x10;
+constexpr uint8_t kIeiUeSecurityCapability = 0x2e;
 
 constexpr uint8_t kT3502Value = 0x16;
 

src/nas/ies/5GMMCapability.cpp

@@ -50,22 +50,21 @@ _5GMMCapability::_5GMMCapability() : Type4NasIe(kIei5gmmCapability) {
 _5GMMCapability::~_5GMMCapability() {}
 
 //------------------------------------------------------------------------------
-void _5GMMCapability::setOctet3(const uint8_t iei, uint8_t octet3) {
+void _5GMMCapability::SetOctet3(const uint8_t iei, uint8_t octet3) {
   SetIei(iei);
   SetLengthIndicator(1);
   octet3_ = octet3;
 }
 
 //------------------------------------------------------------------------------
-uint8_t _5GMMCapability::getOctet3() const {
+uint8_t _5GMMCapability::GetOctet3() const {
   return octet3_;
 }
 
 //------------------------------------------------------------------------------
-int _5GMMCapability::encode2Buffer(uint8_t* buf, int len) {
+int _5GMMCapability::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
-  int ie_len =
-      iei_.has_value() ? (li_ + 2) : (li_ + 1);  // 1 for IEI, 1 for Length
+  int ie_len = GetIeLength();
 
   if (len < ie_len) {
     Logger::nas_mm().error("Len is less than %d", ie_len);
@@ -90,7 +89,7 @@ int _5GMMCapability::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int _5GMMCapability::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
+int _5GMMCapability::Decode(uint8_t* buf, int len, bool is_option) {
   if (len < k5gmmCapabilityMinimumLength) {
     Logger::nas_mm().error(
         "Buffer length is less than the minimum length of this IE (%d octet)",
@@ -109,7 +108,7 @@ int _5GMMCapability::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   // TODO: decode the rest as spare for now
   uint8_t spare = 0;
   for (int i = 0; i < (li_ - 1); i++) {
-    ENCODE_U8(buf + decoded_size, spare, decoded_size);
+    DECODE_U8(buf + decoded_size, spare, decoded_size);
   }
 
   Logger::nas_mm().debug(

src/nas/ies/5GMMCapability.hpp

@@ -39,11 +39,11 @@ class _5GMMCapability : public Type4NasIe {
   _5GMMCapability(const uint8_t iei, uint8_t octet3);
   ~_5GMMCapability();
 
-  void setOctet3(const uint8_t iei, uint8_t octet3);
-  uint8_t getOctet3() const;
+  void SetOctet3(const uint8_t iei, uint8_t octet3);
+  uint8_t GetOctet3() const;
 
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option = true);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option = true);
 
  private:
   uint8_t octet3_;  // minimum length of 3 octets

src/nas/ies/S1_UE_Security_Capability.cpp

@@ -66,22 +66,22 @@ S1_UE_Security_Capability::S1_UE_Security_Capability(
 }
 
 //------------------------------------------------------------------------------
-void S1_UE_Security_Capability::setEEASel(uint8_t sel) {
+void S1_UE_Security_Capability::SetEea(uint8_t sel) {
   _5g_EEASel = sel;
 }
 
 //------------------------------------------------------------------------------
-void S1_UE_Security_Capability::setEIASel(uint8_t sel) {
+void S1_UE_Security_Capability::SetEia(uint8_t sel) {
   _5g_EIASel = sel;
 }
 
 //------------------------------------------------------------------------------
-uint8_t S1_UE_Security_Capability::getEEASel() {
+uint8_t S1_UE_Security_Capability::GetEea() {
   return _5g_EEASel;
 }
 
 //------------------------------------------------------------------------------
-uint8_t S1_UE_Security_Capability::getEIASel() {
+uint8_t S1_UE_Security_Capability::GetEia() {
   return _5g_EIASel;
 }
 

src/nas/ies/S1_UE_Security_Capability.hpp

@@ -40,10 +40,10 @@ class S1_UE_Security_Capability {
   ~S1_UE_Security_Capability();
   S1_UE_Security_Capability(
       const uint8_t iei, uint8_t _5gg_EEASel, uint8_t _5gg_EIASel);
-  void setEEASel(uint8_t sel);
-  void setEIASel(uint8_t sel);
-  uint8_t getEEASel();
-  uint8_t getEIASel();
+  void SetEea(uint8_t sel);
+  void SetEia(uint8_t sel);
+  uint8_t GetEea();
+  uint8_t GetEia();
   int encode2Buffer(uint8_t* buf, int len);
   int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
 

src/nas/ies/Type4NasIe.cpp

@@ -50,6 +50,20 @@ void Type4NasIe::SetLengthIndicator(const uint8_t& li) {
   li_ = li;
 }
 
+//------------------------------------------------------------------------------
+void Type4NasIe::GetLengthIndicator(uint8_t& li) const {
+  li = li_;
+}
+
+//------------------------------------------------------------------------------
+uint8_t Type4NasIe::GetLengthIndicator() const {
+  return li_;
+}
+//------------------------------------------------------------------------------
+uint8_t Type4NasIe::GetIeLength() const {
+  return (iei_.has_value() ? (li_ + 2) : (li_ + 1));  // 1 for IEI, 1 for Length
+}
+
 //------------------------------------------------------------------------------
 bool Type4NasIe::Validate(const int& len) const {
   uint8_t actual_lengh =
@@ -65,7 +79,6 @@ bool Type4NasIe::Validate(const int& len) const {
 
 //------------------------------------------------------------------------------
 int Type4NasIe::Encode(uint8_t* buf, const int& len) {
-  Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
   if (!Validate(len)) return KEncodeDecodeError;
 
   int encoded_size = 0;
@@ -75,9 +88,6 @@ int Type4NasIe::Encode(uint8_t* buf, const int& len) {
   }
 
   ENCODE_U8(buf + encoded_size, li_, encoded_size);
-
-  Logger::nas_mm().debug(
-      "Encoded %s (len %d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 

src/nas/ies/Type4NasIe.hpp

@@ -35,6 +35,9 @@ class Type4NasIe : public NasIe {
 
   void SetIei(const uint8_t& iei);
   void SetLengthIndicator(const uint8_t& li);
+  void GetLengthIndicator(uint8_t& li) const;
+  uint8_t GetLengthIndicator() const;
+  uint8_t GetIeLength() const;
 
   int Encode(uint8_t* buf, const int& len) override;
   int Decode(

src/nas/ies/UENetworkCapability.cpp

@@ -57,22 +57,22 @@ UENetworkCapability::UENetworkCapability(
 }
 
 //------------------------------------------------------------------------------
-void UENetworkCapability::setEEASel(uint8_t sel) {
+void UENetworkCapability::SetEea(uint8_t sel) {
   _5g_EEASel = sel;
 }
 
 //------------------------------------------------------------------------------
-void UENetworkCapability::setEIASel(uint8_t sel) {
+void UENetworkCapability::SetEia(uint8_t sel) {
   _5g_EIASel = sel;
 }
 
 //------------------------------------------------------------------------------
-uint8_t UENetworkCapability::getEEASel() {
+uint8_t UENetworkCapability::GetEea() {
   return _5g_EEASel;
 }
 
 //------------------------------------------------------------------------------
-uint8_t UENetworkCapability::getEIASel() {
+uint8_t UENetworkCapability::GetEia() {
   return _5g_EIASel;
 }
 

src/nas/ies/UENetworkCapability.hpp

@@ -36,10 +36,10 @@ class UENetworkCapability {
   ~UENetworkCapability();
   UENetworkCapability(
       const uint8_t iei, uint8_t _5gg_EEASel, uint8_t _5gg_EIASel);
-  void setEEASel(uint8_t sel);
-  void setEIASel(uint8_t sel);
-  uint8_t getEEASel();
-  uint8_t getEIASel();
+  void SetEea(uint8_t sel);
+  void SetEia(uint8_t sel);
+  uint8_t GetEea();
+  uint8_t GetEia();
   int encode2Buffer(uint8_t* buf, int len);
   int decodeFromBuffer(uint8_t* buf, int len, bool is_option = true);
 

src/nas/ies/UESecurityCapability.cpp

@@ -28,172 +28,225 @@
 using namespace nas;
 
 //------------------------------------------------------------------------------
-UESecurityCapability::UESecurityCapability(uint8_t iei) {
-  _iei      = iei;
-  _5g_EASel = 0;
-  _5g_IASel = 0;
-  EEASel    = 0;
-  EIASel    = 0;
-  length    = 0;
+UESecurityCapability::UESecurityCapability() : Type4NasIe() {
+  _5g_ea_ = 0;
+  _5g_ia_ = 0;
+  eea_    = std::nullopt;
+  eia_    = std::nullopt;
+  SetLengthIndicator(2);
+  SetIeName(kUeSecurityCapability);
 }
 
 //------------------------------------------------------------------------------
-UESecurityCapability::UESecurityCapability() {
-  _iei      = 0;
-  _5g_EASel = 0;
-  _5g_IASel = 0;
-  EEASel    = 0;
-  EIASel    = 0;
-  length    = 0;
+UESecurityCapability::UESecurityCapability(uint8_t iei) : Type4NasIe(iei) {
+  _5g_ea_ = 0;
+  _5g_ia_ = 0;
+  eea_    = std::nullopt;
+  eia_    = std::nullopt;
+  SetLengthIndicator(2);
+  SetIeName(kUeSecurityCapability);
 }
 
 //------------------------------------------------------------------------------
-UESecurityCapability::~UESecurityCapability() {}
+UESecurityCapability::UESecurityCapability(uint8_t _5g_ea, uint8_t _5g_ia)
+    : Type4NasIe() {
+  _5g_ea_ = _5g_ea;
+  _5g_ia_ = _5g_ia;
+  eea_    = std::nullopt;
+  eia_    = std::nullopt;
+  SetLengthIndicator(2);
+  SetIeName(kUeSecurityCapability);
+}
 
 //------------------------------------------------------------------------------
 UESecurityCapability::UESecurityCapability(
-    const uint8_t iei, uint8_t _5gg_EASel, uint8_t _5gg_IASel) {
-  _iei      = iei;
-  _5g_EASel = _5gg_EASel;
-  _5g_IASel = _5gg_IASel;
-  EEASel    = 0;
-  EIASel    = 0;
-  length    = kUESecurityCapabilityMinimumLength;
+    const uint8_t iei, uint8_t _5g_ea, uint8_t _5g_ia)
+    : Type4NasIe(iei) {
+  _5g_ea_ = _5g_ea;
+  _5g_ia_ = _5g_ia;
+  eea_    = std::nullopt;
+  eia_    = std::nullopt;
+  SetLengthIndicator(2);
+  SetIeName(kUeSecurityCapability);
 }
 
 //------------------------------------------------------------------------------
 UESecurityCapability::UESecurityCapability(
-    const uint8_t iei, uint8_t _5gg_EASel, uint8_t _5gg_IASel, uint8_t _EEASel,
-    uint8_t _EIASel) {
-  _iei      = iei;
-  _5g_EASel = _5gg_EASel;
-  _5g_IASel = _5gg_IASel;
-  EEASel    = _EEASel;
-  EIASel    = _EIASel;
-  length    = kUESecurityCapabilityMaximumLength;
+    const uint8_t iei, uint8_t _5g_ea, uint8_t _5g_ia, uint8_t eea, uint8_t eia)
+    : Type4NasIe(iei) {
+  _5g_ea_ = _5g_ea;
+  _5g_ia_ = _5g_ia;
+  eea_    = std::optional<uint8_t>(eea);
+  eia_    = std::optional<uint8_t>(eia);
+  SetLengthIndicator(4);
+  SetIeName(kUeSecurityCapability);
 }
 
 //------------------------------------------------------------------------------
-void UESecurityCapability::setEASel(uint8_t sel) {
-  _5g_EASel = sel;
+UESecurityCapability::UESecurityCapability(
+    uint8_t _5g_ea, uint8_t _5g_ia, uint8_t eea, uint8_t eia)
+    : Type4NasIe() {
+  _5g_ea_ = _5g_ea;
+  _5g_ia_ = _5g_ia;
+  eea_    = std::optional<uint8_t>(eea);
+  eia_    = std::optional<uint8_t>(eia);
+  SetLengthIndicator(4);
+  SetIeName(kUeSecurityCapability);
 }
 
 //------------------------------------------------------------------------------
-void UESecurityCapability::setIASel(uint8_t sel) {
-  _5g_IASel = sel;
-}
+UESecurityCapability::~UESecurityCapability() {}
 
 //------------------------------------------------------------------------------
-void UESecurityCapability::setEEASel(uint8_t sel) {
-  EEASel = sel;
+void UESecurityCapability::SetEa(uint8_t value) {
+  _5g_ea_ = value;
 }
 
 //------------------------------------------------------------------------------
-void UESecurityCapability::setEIASel(uint8_t sel) {
-  EIASel = sel;
+uint8_t UESecurityCapability::GetEa() const {
+  return _5g_ea_;
 }
 
 //------------------------------------------------------------------------------
-uint8_t UESecurityCapability::getEASel() {
-  return _5g_EASel;
+void UESecurityCapability::SetIa(uint8_t value) {
+  _5g_ia_ = value;
 }
 
 //------------------------------------------------------------------------------
-uint8_t UESecurityCapability::getIASel() {
-  return _5g_IASel;
+uint8_t UESecurityCapability::GetIa() const {
+  return _5g_ia_;
 }
 
 //------------------------------------------------------------------------------
-uint8_t UESecurityCapability::getEEASel() {
-  return EEASel;
+void UESecurityCapability::SetEea(uint8_t value) {
+  eea_ = std::make_optional<uint8_t>(value);
 }
 
 //------------------------------------------------------------------------------
-uint8_t UESecurityCapability::getEIASel() {
-  return EIASel;
+bool UESecurityCapability::GetEea(uint8_t& value) const {
+  if (eea_.has_value()) {
+    value = eea_.value();
+    return true;
+  }
+  return false;
 }
 
 //------------------------------------------------------------------------------
-void UESecurityCapability::setLength(uint8_t len) {
-  if ((len >= kUESecurityCapabilityMinimumLength) &&
-      (len <= kUESecurityCapabilityMaximumLength)) {
-    length = len;
-  } else {
-    Logger::nas_mm().debug("Set UESecurityCapability Length fail %d", len);
-    Logger::nas_mm().debug(
-        "UESecurityCapability Length is set to the default value %d", length);
-  }
+void UESecurityCapability::SetEia(uint8_t value) {
+  eia_ = std::make_optional<uint8_t>(value);
 }
 
 //------------------------------------------------------------------------------
-uint8_t UESecurityCapability::getLength() {
-  return length;
+bool UESecurityCapability::GetEia(uint8_t& value) const {
+  if (eia_.has_value()) {
+    value = eia_.value();
+    return true;
+  }
+  return false;
 }
 
 //------------------------------------------------------------------------------
 int UESecurityCapability::encode2Buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("Encoding UESecurityCapability IEI 0x%x", _iei);
-  if (len < (length + 2)) {  // Length of the content + IEI/Len
+  Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
+  int ie_len = GetIeLength();
+
+  if (len < ie_len) {  // Length of the content + IEI/Len
     Logger::nas_mm().error(
         "Size of the buffer is not enough to store this IE (IE len %d)",
-        length + 2);
+        ie_len);
     return KEncodeDecodeError;
   }
+
   int encoded_size = 0;
-  if (_iei) {
-    ENCODE_U8(buf + encoded_size, _iei, encoded_size);
-  }
-  // Length
-  ENCODE_U8(buf + encoded_size, length, encoded_size);
+  // IEI and Length
+  encoded_size += Type4NasIe::Encode(buf + encoded_size, len);
+  /*
+   if (_iei) {
+     ENCODE_U8(buf + encoded_size, _iei, encoded_size);
+   }
+   // Length
+   ENCODE_U8(buf + encoded_size, length, encoded_size);
+   */
+
   // EA
-  ENCODE_U8(buf + encoded_size, _5g_EASel, encoded_size);
+  ENCODE_U8(buf + encoded_size, _5g_ea_, encoded_size);
   // IA
-  ENCODE_U8(buf + encoded_size, _5g_IASel, encoded_size);
+  ENCODE_U8(buf + encoded_size, _5g_ia_, encoded_size);
 
-  if (length == 4) {
+  if (eea_.has_value()) {
     // EEA
-    ENCODE_U8(buf + encoded_size, EEASel, encoded_size);
+    ENCODE_U8(buf + encoded_size, eea_.value(), encoded_size);
+  }
+  if (eia_.has_value()) {
     // EIA
-    ENCODE_U8(buf + encoded_size, EIASel, encoded_size);
+    ENCODE_U8(buf + encoded_size, eia_.value(), encoded_size);
   }
 
-  Logger::nas_mm().debug("Encoded UESecurityCapability (len %d)", encoded_size);
+  Logger::nas_mm().debug(
+      "Encoded %s, len (%d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
 int UESecurityCapability::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("Decoding UESecurityCapability");
+  Logger::nas_mm().debug("Decoding %s", GetIeName().c_str());
 
-  if (len < kUESecurityCapabilityMinimumLength) {
+  if (len < kUeSecurityCapabilityMinimumLength) {
     Logger::nas_mm().error(
         "Buffer length is less than the minimum length of this IE (%d octet)",
-        kUESecurityCapabilityMinimumLength);
+        kUeSecurityCapabilityMinimumLength);
     return KEncodeDecodeError;
   }
 
   int decoded_size = 0;
+  uint8_t octet    = 0;
+
+  // IEI and Length
+  decoded_size += Type4NasIe::Decode(buf + decoded_size, len, is_option);
+  /*
   if (is_option) {
     DECODE_U8(buf + decoded_size, _iei, decoded_size);
   }
 
   // Length
   DECODE_U8(buf + decoded_size, length, decoded_size);
+  */
   // EA
-  DECODE_U8(buf + decoded_size, _5g_EASel, decoded_size);
+  DECODE_U8(buf + decoded_size, _5g_ea_, decoded_size);
   // IA
-  DECODE_U8(buf + decoded_size, _5g_IASel, decoded_size);
+  DECODE_U8(buf + decoded_size, _5g_ia_, decoded_size);
 
-  if (length >= 4) {
+  int ie_len = GetIeLength();
+  if (ie_len >= 3) {
     // EEA
-    DECODE_U8(buf + decoded_size, EEASel, decoded_size);
+    DECODE_U8(buf + decoded_size, octet, decoded_size);
+    eea_ = std::make_optional<uint8_t>(octet);
+  }
+
+  if (ie_len >= 4) {
     // EIA
-    DECODE_U8(buf + decoded_size, EIASel, decoded_size);
-    decoded_size += (length - 4);  // TODO: Spare
+    DECODE_U8(buf + decoded_size, octet, decoded_size);
+    eia_ = std::make_optional<uint8_t>(octet);
+  }
+
+  // TODO: decode the rest as spare for now
+  uint8_t spare = 0;
+  for (int i = 0; i < (ie_len - decoded_size); i++) {
+    DECODE_U8(buf + decoded_size, spare, decoded_size);
   }
+
   Logger::nas_mm().debug(
-      "UESecurityCapability (length %d) EA 0x%x,IA 0x%x, EEA 0x%x, EIA 0x%x,",
-      length, _5g_EASel, _5g_IASel, EEASel, EIASel);
+      "Decoded %s, len (%d)", GetIeName().c_str(), decoded_size);
+
+  Logger::nas_mm().debug("EA 0x%x, IA 0x%x", _5g_ea_, _5g_ia_);
+  if (eea_.has_value()) {
+    Logger::nas_mm().debug("EEA 0x%x", eea_.value());
+  }
+
+  if (eia_.has_value()) {
+    Logger::nas_mm().debug("EIA 0x%x", eia_.value());
+  }
+
   return decoded_size;
 }

src/nas/ies/UESecurityCapability.hpp

@@ -22,45 +22,55 @@
 #ifndef _UE_SECURITY_CAPABILITY_H
 #define _UE_SECURITY_CAPABILITY_H
 
+#include "Type4NasIe.hpp"
+
 #include <stdint.h>
 
-constexpr uint8_t kUESecurityCapabilityMinimumLength = 2;
-constexpr uint8_t kUESecurityCapabilityMaximumLength = 4;
+constexpr uint8_t kUeSecurityCapabilityMinimumLength = 4;
+constexpr uint8_t kUeSecurityCapabilityMaximumLength = 10;
+constexpr auto kUeSecurityCapability                 = "UE Security Capability";
 
 namespace nas {
 
-class UESecurityCapability {
+class UESecurityCapability : public Type4NasIe {
  public:
-  UESecurityCapability(uint8_t iei);
   UESecurityCapability();
-  ~UESecurityCapability();
+  UESecurityCapability(uint8_t iei);
+  UESecurityCapability(uint8_t _5g_ea, uint8_t _5g_ia);
+  UESecurityCapability(const uint8_t iei, uint8_t _5g_ea, uint8_t _5g_ia);
   UESecurityCapability(
-      const uint8_t iei, uint8_t _5gg_EASel, uint8_t _5gg_IASel);
+      const uint8_t iei, uint8_t _5g_ea, uint8_t _5g_ia, uint8_t eea,
+      uint8_t eia);
   UESecurityCapability(
-      const uint8_t iei, uint8_t _5gg_EASel, uint8_t _5gg_IASel, uint8_t EEASel,
-      uint8_t EIASel);
-  void setEASel(uint8_t sel);
-  void setIASel(uint8_t sel);
-  uint8_t getEASel();
-  uint8_t getIASel();
+      uint8_t _5g_ea, uint8_t _5g_ia, uint8_t eea, uint8_t eia);
+  ~UESecurityCapability();
+
+  void SetEa(uint8_t value);
+  uint8_t GetEa() const;
+
+  void SetIa(uint8_t value);
+  uint8_t GetIa() const;
+
+  void SetEea(uint8_t value);
+  bool GetEea(uint8_t& value) const;
+
+  void SetEia(uint8_t value);
+  bool GetEia(uint8_t& value) const;
 
-  void setEEASel(uint8_t sel);
-  void setEIASel(uint8_t sel);
-  uint8_t getEEASel();
-  uint8_t getEIASel();
+  // void setLength(uint8_t len);
+  // uint8_t getLength();
 
-  void setLength(uint8_t len);
-  uint8_t getLength();
   int encode2Buffer(uint8_t* buf, int len);
   int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
 
  private:
-  uint8_t _iei;
-  uint8_t length;  // Length of UE security capability contents
-  uint8_t _5g_EASel;
-  uint8_t _5g_IASel;
-  uint8_t EEASel;
-  uint8_t EIASel;
+  // uint8_t _iei;
+  // uint8_t length;  // Length of UE security capability contents
+  uint8_t _5g_ea_;              // 3rd octet, Mandatory
+  uint8_t _5g_ia_;              // 4th octet, Mandatory
+  std::optional<uint8_t> eea_;  // 5th octet, Optional
+  std::optional<uint8_t> eia_;  // 6th octet, Optional
+  // Spare
 };
 
 }  // namespace nas

src/nas/ies/_5GS_Network_Feature_Support.cpp

@@ -90,8 +90,8 @@ int _5GS_Network_Feature_Support::encode2Buffer(uint8_t* buf, int len) {
   } else {
     *(buf + encoded_size) = length - 1;
     encoded_size++;
-    //		*(buf + encoded_size) = _5g_EASel; encoded_size++;
-    //		*(buf + encoded_size) = _5g_IASel; encoded_size++;
+    //		*(buf + encoded_size) = _5g_ea_; encoded_size++;
+    //		*(buf + encoded_size) = _5g_ia_; encoded_size++;
   }
   Logger::nas_mm().debug(
       "Encoded _5GS_Network_Feature_Support len (%d)", encoded_size);

src/nas/msgs/RegistrationRequest.cpp

@@ -198,7 +198,7 @@ void RegistrationRequest::set5GMMCapability(uint8_t value) {
 bool RegistrationRequest::get5GMMCapability(uint8_t& value) {
   if (ie_5g_mm_capability.has_value()) {
     value =
-        ie_5g_mm_capability.value().getOctet3();  // TODO: get multiple octets
+        ie_5g_mm_capability.value().GetOctet3();  // TODO: get multiple octets
     return true;
   } else
     return false;
@@ -213,16 +213,16 @@ void RegistrationRequest::setUESecurityCapability(
 
 //------------------------------------------------------------------------------
 void RegistrationRequest::setUESecurityCapability(
-    uint8_t g_EASel, uint8_t g_IASel, uint8_t EEASel, uint8_t EIASel) {
+    uint8_t g_EASel, uint8_t g_IASel, uint8_t eea, uint8_t eia) {
   ie_ue_security_capability = std::make_optional<UESecurityCapability>(
-      0x2E, g_EASel, g_IASel, EEASel, EIASel);
+      0x2E, g_EASel, g_IASel, eea, eia);
 }
 
 //------------------------------------------------------------------------------
 bool RegistrationRequest::getUeSecurityCapability(uint8_t& ea, uint8_t& ia) {
   if (ie_ue_security_capability.has_value()) {
-    ea = ie_ue_security_capability.value().getEASel();
-    ia = ie_ue_security_capability.value().getIASel();
+    ea = ie_ue_security_capability.value().GetEa();
+    ia = ie_ue_security_capability.value().GetIa();
     return true;
   } else {
     return false;
@@ -234,11 +234,11 @@ bool RegistrationRequest::getUeSecurityCapability(uint8_t& ea, uint8_t& ia) {
 bool RegistrationRequest::getUeSecurityCapability(
     uint8_t& ea, uint8_t& ia, uint8_t& eea, uint8_t& eia) {
   if (ie_ue_security_capability.has_value()) {
-    ea = ie_ue_security_capability.value().getEASel();
-    ia = ie_ue_security_capability.value().getIASel();
-    if (ie_ue_security_capability.value().getLength() >= 4) {
-      eea = ie_ue_security_capability.value().getEEASel();
-      eia = ie_ue_security_capability.value().getEIASel();
+    ea = ie_ue_security_capability.value().GetEa();
+    ia = ie_ue_security_capability.value().GetIa();
+    if (ie_ue_security_capability.value().GetLengthIndicator() >= 4) {
+      ie_ue_security_capability.value().GetEea(eea);
+      ie_ue_security_capability.value().GetEia(eia);
     }
     return true;
   } else {
@@ -281,8 +281,8 @@ void RegistrationRequest::setUENetworkCapability(
 //------------------------------------------------------------------------------
 bool RegistrationRequest::getS1UeNetworkCapability(uint8_t& eea, uint8_t& eia) {
   if (ie_s1_ue_network_capability.has_value()) {
-    eea = ie_s1_ue_network_capability.value().getEEASel();
-    eia = ie_s1_ue_network_capability.value().getEIASel();
+    eea = ie_s1_ue_network_capability.value().GetEea();
+    eia = ie_s1_ue_network_capability.value().GetEia();
   } else {
     return false;
   }
@@ -586,7 +586,7 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
   if (!ie_5g_mm_capability.has_value()) {
     Logger::nas_mm().warn("IE 5GMM capability is not available");
   } else {
-    if ((encoded_ie_size = ie_5g_mm_capability.value().encode2Buffer(
+    if ((encoded_ie_size = ie_5g_mm_capability.value().Encode(
              buf + encoded_size, len - encoded_size)) == KEncodeDecodeError) {
       Logger::nas_mm().error("Encoding 5GMM capability error");
       return KEncodeDecodeError;
@@ -895,10 +895,10 @@ int RegistrationRequest::decodeFromBuffer(uint8_t* buf, int len) {
       } break;
     }
     switch (octet) {
-      case 0x10: {
+      case kIei5gmmCapability: {
         Logger::nas_mm().debug("Decoding 5GMMCapability (IEI 0x10)");
         _5GMMCapability ie_5g_mm_capability_tmp = {};
-        if ((decoded_size_ie = ie_5g_mm_capability_tmp.decodeFromBuffer(
+        if ((decoded_size_ie = ie_5g_mm_capability_tmp.Decode(
                  buf + decoded_size, len - decoded_size, true)) ==
             KEncodeDecodeError) {
           return KEncodeDecodeError;

src/nas/msgs/RegistrationRequest.hpp

@@ -79,8 +79,9 @@ class RegistrationRequest : public NasMmPlainHeader {
 
   void setUESecurityCapability(uint8_t g_EASel, uint8_t g_IASel);
   void setUESecurityCapability(
-      uint8_t g_EASel, uint8_t g_IASel, uint8_t EEASel, uint8_t EIASel);
+      uint8_t g_EASel, uint8_t g_IASel, uint8_t eea, uint8_t eia);
   bool getUeSecurityCapability(uint8_t& ea, uint8_t& ia);
+  // TODO: use std::optional for optional fields eea,eia
   bool getUeSecurityCapability(
       uint8_t& ea, uint8_t& ia, uint8_t& eea, uint8_t& eia);
 

src/nas/msgs/SecurityModeCommand.cpp

@@ -72,14 +72,14 @@ void SecurityModeCommand::setngKSI(uint8_t tsc, uint8_t key_set_id) {
 //------------------------------------------------------------------------------
 void SecurityModeCommand::setUE_Security_Capability(
     uint8_t g_EASel, uint8_t g_IASel) {
-  ie_ue_security_capability = new UESecurityCapability(0x00, g_EASel, g_IASel);
+  ie_ue_security_capability = new UESecurityCapability(g_EASel, g_IASel);
 }
 
 //------------------------------------------------------------------------------
 void SecurityModeCommand::setUE_Security_Capability(
-    uint8_t g_EASel, uint8_t g_IASel, uint8_t EEASel, uint8_t EIASel) {
+    uint8_t g_EASel, uint8_t g_IASel, uint8_t eea, uint8_t eia) {
   ie_ue_security_capability =
-      new UESecurityCapability(0x00, g_EASel, g_IASel, EEASel, EIASel);
+      new UESecurityCapability(g_EASel, g_IASel, eea, eia);
 }
 
 //------------------------------------------------------------------------------

src/nas/msgs/SecurityModeCommand.hpp

@@ -44,7 +44,7 @@ class SecurityModeCommand {
   void setngKSI(uint8_t tsc, uint8_t key_set_id);
   void setUE_Security_Capability(uint8_t g_EASel, uint8_t g_IASel);
   void setUE_Security_Capability(
-      uint8_t g_EASel, uint8_t g_IASel, uint8_t EEASel, uint8_t EIASel);
+      uint8_t g_EASel, uint8_t g_IASel, uint8_t eea, uint8_t eia);
   void setIMEISV_Request(uint8_t value);
   void setEPS_NAS_Security_Algorithms(uint8_t ciphering, uint8_t integrity);
   void setAdditional_5G_Security_Information(bool rinmr, bool hdp);