Code cleanup for SecurityModeCommand

src/nas/common/Ie_Const.hpp

@@ -98,6 +98,7 @@ constexpr uint8_t kIeiReleaseAssistanceIndication = 0x0F;  // F-(4 higher bits)
 
 constexpr uint8_t kIei5gmmCapability              = 0x10;
 constexpr uint8_t kIeiUeUsageSetting              = 0x18;
+constexpr uint8_t kIeiS1UeSecurityCapability      = 0x19;
 constexpr uint8_t kIeiAuthenticationParameterAutn = 0x20;
 constexpr uint8_t kIeiAuthenticationParameterRand = 0x21;
 constexpr uint8_t kIei5gsNetworkFeatureSupport    = 0x21;

src/nas/msgs/SecurityModeCommand.cpp

@@ -31,7 +31,7 @@ SecurityModeCommand::SecurityModeCommand()
     : NasMmPlainHeader(EPD_5GS_MM_MSG, SECURITY_MODE_COMMAND) {
   ie_imeisv_request                     = std::nullopt;
   ie_eps_nas_security_algorithms        = std::nullopt;
-  ie_additional_5G_security_information = std::nullopt;
+  ie_additional_5g_security_information = std::nullopt;
   ie_eap_message                        = std::nullopt;
   ie_abba                               = std::nullopt;
   ie_s1_ue_security_capability          = std::nullopt;
@@ -53,20 +53,19 @@ void SecurityModeCommand::SetNasSecurityAlgorithms(
 
 //------------------------------------------------------------------------------
 void SecurityModeCommand::SetNgKsi(uint8_t tsc, uint8_t key_set_id) {
-  ie_ngKSI.SetTypeOfSecurityContext(tsc);
-  ie_ngKSI.SetNasKeyIdentifier(key_set_id);
+  ie_ng_ksi.SetTypeOfSecurityContext(tsc);
+  ie_ng_ksi.SetNasKeyIdentifier(key_set_id);
 }
 
 //------------------------------------------------------------------------------
-void SecurityModeCommand::SetUeSecurityCapability(
-    uint8_t g_EASel, uint8_t g_IASel) {
-  ie_ue_security_capability.Set(g_EASel, g_IASel);
+void SecurityModeCommand::SetUeSecurityCapability(uint8_t ea, uint8_t ia) {
+  ie_ue_security_capability.Set(ea, ia);
 }
 
 //------------------------------------------------------------------------------
 void SecurityModeCommand::SetUeSecurityCapability(
-    uint8_t g_EASel, uint8_t g_IASel, uint8_t eea, uint8_t eia) {
-  ie_ue_security_capability.Set(g_EASel, g_IASel, eea, eia);
+    uint8_t ea, uint8_t ia, uint8_t eea, uint8_t eia) {
+  ie_ue_security_capability.Set(ea, ia, eea, eia);
 }
 
 //------------------------------------------------------------------------------
@@ -84,25 +83,24 @@ void SecurityModeCommand::SetEpsNasSecurityAlgorithms(
 //------------------------------------------------------------------------------
 void SecurityModeCommand::SetAdditional5gSecurityInformation(
     bool rinmr, bool hdp) {
-  ie_additional_5G_security_information =
+  ie_additional_5g_security_information =
       std::make_optional<Additional5gSecurityInformation>(rinmr, hdp);
 }
 
 //------------------------------------------------------------------------------
 void SecurityModeCommand::SetEapMessage(bstring eap) {
-  ie_eap_message = std::make_optional<EapMessage>(0x78, eap);
+  ie_eap_message = std::make_optional<EapMessage>(kIeiEapMessage, eap);
 }
 
 //------------------------------------------------------------------------------
 void SecurityModeCommand::SetAbba(uint8_t length, uint8_t* value) {
-  ie_abba = std::make_optional<ABBA>(0x38, length, value);
+  ie_abba = std::make_optional<ABBA>(kIeiAbba, length, value);
 }
 
 //------------------------------------------------------------------------------
-void SecurityModeCommand::SetS1UeSecurityCapability(
-    uint8_t g_EEASel, uint8_t g_EIASel) {
-  ie_s1_ue_security_capability =
-      std::make_optional<S1UeSecurityCapability>(0x19, g_EEASel, g_EIASel);
+void SecurityModeCommand::SetS1UeSecurityCapability(uint8_t eea, uint8_t eia) {
+  ie_s1_ue_security_capability = std::make_optional<S1UeSecurityCapability>(
+      kIeiS1UeSecurityCapability, eea, eia);
 }
 
 //------------------------------------------------------------------------------
@@ -126,102 +124,119 @@ int SecurityModeCommand::Encode(uint8_t* buf, int len) {
     encoded_size += size;
   } else {
     Logger::nas_mm().error(
-        "Encoding ie_selected_nas_security_algorithms error");
+        "Encoding %s error", NasSecurityAlgorithms::GetIeName().c_str());
     return KEncodeDecodeError;
   }
 
   // NAS key set identifier
-  size = ie_ngKSI.Encode(buf + encoded_size, len - encoded_size);
+  size = ie_ng_ksi.Encode(buf + encoded_size, len - encoded_size);
   if (size != KEncodeDecodeError) {
     encoded_size++;  // 1/2 octet for ngKSI, 1/2 for Spare half octet
   } else {
-    Logger::nas_mm().error("Encoding ie_ngKSI error");
+    Logger::nas_mm().error(
+        "Encoding %s error", NasKeySetIdentifier::GetIeName().c_str());
     return KEncodeDecodeError;
   }
 
   // UE security capability
   size =
       ie_ue_security_capability.Encode(buf + encoded_size, len - encoded_size);
-
   if (size != KEncodeDecodeError) {
     encoded_size += size;
   } else {
-    Logger::nas_mm().error("Encoding ie_ue_security_capability error");
+    Logger::nas_mm().error(
+        "Encoding %s error", UESecurityCapability::GetIeName().c_str());
     return KEncodeDecodeError;
   }
 
   // Optional IEs
   if (!ie_imeisv_request.has_value()) {
-    Logger::nas_mm().warn("IE ie_imeisv_request is not available");
+    Logger::nas_mm().debug(
+        "IE %s is not available", ImeisvRequest::GetIeName().c_str());
   } else {
-    if (int size = ie_imeisv_request.value().Encode(
-            buf + encoded_size, len - encoded_size)) {
+    size = ie_imeisv_request.value().Encode(
+        buf + encoded_size, len - encoded_size);
+    if (size != KEncodeDecodeError) {
       encoded_size += size;
     } else {
-      Logger::nas_mm().error("Encoding ie_imeisv_request error");
-      return 0;
+      Logger::nas_mm().error(
+          "Encoding %s error", ImeisvRequest::GetIeName().c_str());
+      return KEncodeDecodeError;
     }
   }
 
   if (!ie_eps_nas_security_algorithms.has_value()) {
-    Logger::nas_mm().warn("IE ie_eps_nas_security_algorithms is not available");
+    Logger::nas_mm().debug(
+        "IE %s is not available",
+        EpsNasSecurityAlgorithms::GetIeName().c_str());
   } else {
-    if (int size = ie_eps_nas_security_algorithms.value().Encode(
-            buf + encoded_size, len - encoded_size)) {
+    size = ie_eps_nas_security_algorithms.value().Encode(
+        buf + encoded_size, len - encoded_size);
+    if (size != KEncodeDecodeError) {
       encoded_size += size;
     } else {
-      Logger::nas_mm().error("Encoding ie_eps_nas_security_algorithms error");
-      return 0;
+      Logger::nas_mm().error(
+          "Encoding %s error", EpsNasSecurityAlgorithms::GetIeName().c_str());
+      return KEncodeDecodeError;
     }
   }
 
-  if (!ie_additional_5G_security_information.has_value()) {
-    Logger::nas_mm().warn(
-        "IE ie_additional_5G_security_information is not available");
+  if (!ie_additional_5g_security_information.has_value()) {
+    Logger::nas_mm().debug(
+        "IE %s is not available",
+        Additional5gSecurityInformation::GetIeName().c_str());
   } else {
-    if (int size = ie_additional_5G_security_information.value().Encode(
-            buf + encoded_size, len - encoded_size)) {
+    size = ie_additional_5g_security_information.value().Encode(
+        buf + encoded_size, len - encoded_size);
+    if (size != KEncodeDecodeError) {
       encoded_size += size;
     } else {
       Logger::nas_mm().error(
-          "Encoding ie_additional_5G_security_information error");
-      return 0;
+          "Encoding %s error",
+          Additional5gSecurityInformation::GetIeName().c_str());
+      return KEncodeDecodeError;
     }
   }
 
   if (!ie_eap_message.has_value()) {
-    Logger::nas_mm().warn("IE ie_eap_message is not available");
+    Logger::nas_mm().debug(
+        "IE %s is not available", EapMessage::GetIeName().c_str());
   } else {
-    if (int size = ie_eap_message.value().Encode(
-            buf + encoded_size, len - encoded_size)) {
+    size =
+        ie_eap_message.value().Encode(buf + encoded_size, len - encoded_size);
+    if (size != KEncodeDecodeError) {
       encoded_size += size;
     } else {
-      Logger::nas_mm().error("encoding ie_eap_message error");
-      return 0;
+      Logger::nas_mm().error(
+          "Encoding %s error", EapMessage::GetIeName().c_str());
+      return KEncodeDecodeError;
     }
   }
 
   if (!ie_abba.has_value()) {
-    Logger::nas_mm().warn("IE ie_abba is not available");
+    Logger::nas_mm().debug("IE %s is not available", ABBA::GetIeName().c_str());
   } else {
-    if (int size =
-            ie_abba.value().Encode(buf + encoded_size, len - encoded_size)) {
+    size = ie_abba.value().Encode(buf + encoded_size, len - encoded_size);
+    if (size != KEncodeDecodeError) {
       encoded_size += size;
     } else {
-      Logger::nas_mm().error("Encoding ie_abba error");
-      return 0;
+      Logger::nas_mm().error("Encoding %s error", ABBA::GetIeName().c_str());
+      return KEncodeDecodeError;
     }
   }
 
   if (!ie_s1_ue_security_capability.has_value()) {
-    Logger::nas_mm().warn("IE ie_s1_ue_security_capability is not available");
+    Logger::nas_mm().debug(
+        "IE %s is not available", S1UeSecurityCapability::GetIeName().c_str());
   } else {
-    if (int size = ie_s1_ue_security_capability.value().Encode(
-            buf + encoded_size, len - encoded_size)) {
+    size = ie_s1_ue_security_capability.value().Encode(
+        buf + encoded_size, len - encoded_size);
+    if (size != KEncodeDecodeError) {
       encoded_size += size;
     } else {
-      Logger::nas_mm().error("encoding ie_s1_ue_security_capability error");
-      return 0;
+      Logger::nas_mm().error(
+          "Encoding %s error", S1UeSecurityCapability::GetIeName().c_str());
+      return KEncodeDecodeError;
     }
   }
   Logger::nas_mm().debug(
@@ -251,7 +266,7 @@ int SecurityModeCommand::Decode(uint8_t* buf, int len) {
 
   // NAS key set identifier
   decoded_result =
-      ie_ngKSI.Decode(buf + decoded_size, len - decoded_size, false, false);
+      ie_ng_ksi.Decode(buf + decoded_size, len - decoded_size, false, false);
   if (decoded_result == KEncodeDecodeError) return KEncodeDecodeError;
   decoded_size++;  // 1/2 octet for ngKSI, 1/2 for Spare half octet
 
@@ -262,10 +277,14 @@ int SecurityModeCommand::Decode(uint8_t* buf, int len) {
   decoded_size += decoded_result;
 
   Logger::nas_mm().debug("Decoded_size (%d)", decoded_size);
-  uint8_t octet = *(buf + decoded_size);
+
+  // Decode other IEs
+  uint8_t octet = 0x00;
+  DECODE_U8_VALUE(buf + decoded_size, octet);
   Logger::nas_mm().debug("First option IEI (0x%x)", octet);
   bool flag = false;
   while ((octet != 0x0)) {
+    Logger::nas_mm().debug("IEI 0x%x", octet);
     switch ((octet & 0xf0) >> 4) {
       case kIeiImeisvRequest: {
         Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiImeisvRequest);
@@ -276,7 +295,7 @@ int SecurityModeCommand::Decode(uint8_t* buf, int len) {
           return decoded_result;
         decoded_size += decoded_result;
         ie_imeisv_request = std::optional<ImeisvRequest>(ie_imeisv_request_tmp);
-        octet             = *(buf + decoded_size);
+        DECODE_U8_VALUE(buf + decoded_size, octet);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;
       default: {
@@ -297,7 +316,7 @@ int SecurityModeCommand::Decode(uint8_t* buf, int len) {
         ie_eps_nas_security_algorithms =
             std::optional<EpsNasSecurityAlgorithms>(
                 ie_eps_nas_security_algorithms_tmp);
-        octet = *(buf + decoded_size);
+        DECODE_U8_VALUE(buf + decoded_size, octet);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;
 
@@ -305,16 +324,16 @@ int SecurityModeCommand::Decode(uint8_t* buf, int len) {
         Logger::nas_mm().debug(
             "decoding IEI 0x%x", kIeiAdditional5gSecurityInformation);
         Additional5gSecurityInformation
-            ie_additional_5G_security_information_tmp = {};
-        if ((decoded_result = ie_additional_5G_security_information_tmp.Decode(
+            ie_additional_5g_security_information_tmp = {};
+        if ((decoded_result = ie_additional_5g_security_information_tmp.Decode(
                  buf + decoded_size, len - decoded_size, true)) ==
             KEncodeDecodeError)
           return decoded_result;
         decoded_size += decoded_result;
-        ie_additional_5G_security_information =
+        ie_additional_5g_security_information =
             std::optional<Additional5gSecurityInformation>(
-                ie_additional_5G_security_information_tmp);
-        octet = *(buf + decoded_size);
+                ie_additional_5g_security_information_tmp);
+        DECODE_U8_VALUE(buf + decoded_size, octet);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;
 
@@ -327,12 +346,12 @@ int SecurityModeCommand::Decode(uint8_t* buf, int len) {
           return decoded_result;
         decoded_size += decoded_result;
         ie_eap_message = std::optional<EapMessage>(ie_eap_message_tmp);
-        octet          = *(buf + decoded_size);
+        DECODE_U8_VALUE(buf + decoded_size, octet);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;
 
       case kIeiAbba: {
-        Logger::nas_mm().debug("decoding IEI (0x38)");
+        Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiAbba);
         ABBA ie_abba_tmp = {};
         if ((decoded_result = ie_abba_tmp.Decode(
                  buf + decoded_size, len - decoded_size, true)) ==
@@ -340,12 +359,12 @@ int SecurityModeCommand::Decode(uint8_t* buf, int len) {
           return decoded_result;
         decoded_size += decoded_result;
         ie_abba = std::optional<ABBA>(ie_abba_tmp);
-        octet   = *(buf + decoded_size);
+        DECODE_U8_VALUE(buf + decoded_size, octet);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;
 
-      case 0x19: {
-        Logger::nas_mm().debug("decoding IEI (0x19)");
+      case kIeiS1UeSecurityCapability: {
+        Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiS1UeSecurityCapability);
         S1UeSecurityCapability ie_s1_ue_security_capability_tmp = {};
         if ((decoded_result = ie_s1_ue_security_capability_tmp.Decode(
                  buf + decoded_size, len - decoded_size, true)) ==
@@ -354,7 +373,7 @@ int SecurityModeCommand::Decode(uint8_t* buf, int len) {
         decoded_size += decoded_result;
         ie_s1_ue_security_capability = std::optional<S1UeSecurityCapability>(
             ie_s1_ue_security_capability_tmp);
-        octet = *(buf + decoded_size);
+        DECODE_U8_VALUE(buf + decoded_size, octet);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;
 

src/nas/msgs/SecurityModeCommand.hpp

@@ -42,10 +42,10 @@ class SecurityModeCommand : public NasMmPlainHeader {
   void SetNgKsi(uint8_t tsc, uint8_t key_set_id);
   // TODO: Get
 
-  void SetUeSecurityCapability(uint8_t g_EASel, uint8_t g_IASel);
+  void SetUeSecurityCapability(uint8_t ea, uint8_t ia);
   // TODO: Get
   void SetUeSecurityCapability(
-      uint8_t g_EASel, uint8_t g_IASel, uint8_t eea, uint8_t eia);
+      uint8_t ea, uint8_t ia, uint8_t eea, uint8_t eia);
   // TODO: Get
 
   void SetImeisvRequest(uint8_t value);
@@ -63,19 +63,19 @@ class SecurityModeCommand : public NasMmPlainHeader {
   void SetAbba(uint8_t length, uint8_t* value);
   // TODO: Get
 
-  void SetS1UeSecurityCapability(uint8_t g_EEASel, uint8_t g_EIASel);
+  void SetS1UeSecurityCapability(uint8_t eea, uint8_t eia);
   // TODO: Get
 
  public:
   NasSecurityAlgorithms ie_selected_nas_security_algorithms;  // Mandatory
-  NasKeySetIdentifier ie_ngKSI;                               // Mandatory
+  NasKeySetIdentifier ie_ng_ksi;                              // Mandatory
   UESecurityCapability ie_ue_security_capability;             // Mandatory
 
   std::optional<ImeisvRequest> ie_imeisv_request;  // Optional
   std::optional<EpsNasSecurityAlgorithms>
       ie_eps_nas_security_algorithms;  // Optional
   std::optional<Additional5gSecurityInformation>
-      ie_additional_5G_security_information;  // Optional
+      ie_additional_5g_security_information;  // Optional
   std::optional<EapMessage> ie_eap_message;   // Optional
   std::optional<ABBA> ie_abba;                // Optional
   std::optional<S1UeSecurityCapability>