Update S_NSSAI

src/nas/ies/S_NSSAI.cpp

@@ -25,15 +25,26 @@
 #include "logger.hpp"
 using namespace nas;
 
+//------------------------------------------------------------------------------
+S_NSSAI::S_NSSAI(std::optional<uint8_t> iei) : Type4NasIe() {
+  if (iei_.has_value()) {
+    SetIei(iei.value());
+  }
+  sst_              = {0};
+  sd_               = std::nullopt;
+  mapped_hplmn_sst_ = std::nullopt;
+  mapped_hplmn_sd_  = std::nullopt;
+  SetLengthIndicator(1);  // SST
+  SetIeName(kSNssaiIeName);
+}
+
 //------------------------------------------------------------------------------
 S_NSSAI::S_NSSAI(std::optional<uint8_t> iei, SNSSAI_s snssai) {
   // IEI
-  iei_ = iei;
   if (iei_.has_value()) {
-    length = snssai.length + 1;
-  } else {
-    length = snssai.length;
+    SetIei(iei.value());
   }
+
   // SST
   sst_ = snssai.sst;
 
@@ -63,16 +74,9 @@ S_NSSAI::S_NSSAI(std::optional<uint8_t> iei, SNSSAI_s snssai) {
   } else {
     sd_ = std::nullopt;
   }
-}
 
-//------------------------------------------------------------------------------
-S_NSSAI::S_NSSAI() {
-  iei_              = std::nullopt;
-  sst_              = {0};
-  sd_               = std::nullopt;
-  mapped_hplmn_sst_ = std::nullopt;
-  mapped_hplmn_sd_  = std::nullopt;
-  length            = {0};
+  SetLengthIndicator(snssai.length);
+  SetIeName(kSNssaiIeName);
 }
 
 //------------------------------------------------------------------------------
@@ -119,11 +123,10 @@ void S_NSSAI::SetSNSSAI(
     std::optional<int8_t> mapped_hplmn_sst,
     std::optional<int32_t> mapped_hplmn_sd) {
   // IEI
-  iei_ = iei;
   if (iei_.has_value()) {
-    length += 1;
+    SetIei(iei.value());
   }
-
+  uint8_t length = 0;
   // SST
   sst_ = sst;
   length += SST_LENGTH;
@@ -145,11 +148,8 @@ void S_NSSAI::SetSNSSAI(
   if (mapped_hplmn_sd_.has_value()) {
     length += SD_LENGTH;
   }
-}
 
-//------------------------------------------------------------------------------
-uint8_t S_NSSAI::GetLength() {
-  return length;
+  SetLengthIndicator(length);
 }
 
 //------------------------------------------------------------------------------
@@ -173,19 +173,19 @@ std::string S_NSSAI::ToString() {
 
 //------------------------------------------------------------------------------
 int S_NSSAI::Encode(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("Encoding S-NSSAI");
-  if (len < length) {
-    Logger::nas_mm().error("len is less than %d", length);
-    return 0;
-  }
-  int encoded_size = 0;
+  Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
+  int ie_len = GetIeLength();
 
-  // IEI
-  if (iei_.has_value())
-    ENCODE_U8(buf + encoded_size, iei_.value(), encoded_size);
+  if (len < ie_len) {
+    Logger::nas_mm().error("Len is less than %d", ie_len);
+    return KEncodeDecodeError;
+  }
 
-  // LENGTH
-  ENCODE_U8(buf + encoded_size, length - 2, encoded_size);
+  int encoded_size = 0;
+  // IEI and Length
+  int encoded_header_size = Type4NasIe::Encode(buf + encoded_size, len);
+  if (encoded_header_size == KEncodeDecodeError) return KEncodeDecodeError;
+  encoded_size += encoded_header_size;
 
   // SST
   ENCODE_U8(buf + encoded_size, sst_, encoded_size);
@@ -202,27 +202,30 @@ int S_NSSAI::Encode(uint8_t* buf, int len) {
   if (mapped_hplmn_sd_.has_value())
     ENCODE_U24(buf + encoded_size, mapped_hplmn_sd_.value(), encoded_size);
 
-  Logger::nas_mm().debug("Encoded S-NSSAI len (%d)", encoded_size);
+  Logger::nas_mm().debug(
+      "Encoded %s, len (%d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int S_NSSAI::Decode(uint8_t* buf, int len, const bool is_option) {
-  Logger::nas_mm().debug("Decoding S_NSSAI");
-  int decoded_size = {0};
-
-  if (is_option) {
-    uint8_t iei_value = {0};
-    DECODE_U8(buf + decoded_size, iei_value, decoded_size);
-    iei_ = std::optional<uint8_t>{iei_value};
-    Logger::nas_mm().debug("IEI (0x%x)", iei_value);
-  } else {
-    iei_ = std::nullopt;
+int S_NSSAI::Decode(uint8_t* buf, int len, const bool is_iei) {
+  if (len < kSNssaiMinimumLength) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kSNssaiMinimumLength);
+    return KEncodeDecodeError;
   }
 
-  DECODE_U8(buf + decoded_size, length, decoded_size);
+  uint8_t decoded_size = 0;
+  uint8_t octet        = 0;
+  Logger::nas_mm().debug("Decoding %s", GetIeName().c_str());
+
+  // IEI and Length
+  int decoded_header_size = Type4NasIe::Decode(buf + decoded_size, len, is_iei);
+  if (decoded_header_size == KEncodeDecodeError) return KEncodeDecodeError;
+  decoded_size += decoded_header_size;
 
-  switch (length) {
+  switch (GetLengthIndicator()) {
     case 1: {
       DECODE_U8(buf + decoded_size, sst_, decoded_size);
       sd_               = std::nullopt;
@@ -274,6 +277,7 @@ int S_NSSAI::Decode(uint8_t* buf, int len, const bool is_option) {
   }
 
   Logger::nas_mm().debug("Decoded S-NSSAI %s", ToString().c_str());
-  Logger::nas_mm().debug("Decoded S-NSSAI len (%d)", decoded_size);
+  Logger::nas_mm().debug(
+      "Decoded %s, len (%d)", GetIeName().c_str(), decoded_size);
   return decoded_size;
 }

src/nas/ies/S_NSSAI.hpp

@@ -19,43 +19,40 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#ifndef __S_NSSAI_H_
-#define __S_NSSAI_H_
+#ifndef _S_NSSAI_NAS_H_
+#define _S_NSSAI_NAS_H_
 
-#include <stdint.h>
+#include "Type4NasIe.hpp"
+#include "struct.hpp"
 
-#include "NasIeHeader.hpp"
-#include <optional>
+constexpr uint8_t kSNssaiMinimumLength = 3;
+constexpr uint8_t kSNssaiMaximumLength = 10;
+constexpr auto kSNssaiIeName           = "S-NSSAI";
 
 namespace nas {
 
-class S_NSSAI {
+class S_NSSAI : public Type4NasIe {
  public:
-  S_NSSAI();
+  S_NSSAI(std::optional<uint8_t> iei);
   S_NSSAI(std::optional<uint8_t> iei, SNSSAI_s snssai);
   ~S_NSSAI();
+
   // void SetSNssai(SNSSAI_s snssai);
   int Encode(uint8_t* buf, int len);
   int Decode(uint8_t* buf, int len, const bool is_option = true);
 
   void getValue(SNSSAI_t& snssai);
+
   void SetSNSSAI(
       std::optional<int8_t> iei, uint8_t sst, std::optional<int32_t> sd,
       std::optional<int8_t> mapped_hplmn_sst,
       std::optional<int32_t> mapped_hplmn_sd);
+
   uint8_t GetLength();
+
   std::string ToString();
 
  private:
-  std::optional<int8_t> iei_;
-  uint8_t length;
   uint8_t sst_;
   std::optional<int32_t> sd_;
   std::optional<int8_t> mapped_hplmn_sst_;

src/nas/msgs/ULNASTransport.cpp

@@ -424,7 +424,8 @@ int ULNASTransport::Decode(NasMmPlainHeader* header, uint8_t* buf, int len) {
       } break;
       case 0x22: {
         Logger::nas_mm().debug("Decoding IEI (0x22)");
-        S_NSSAI ie_s_nssai_tmp = {};
+        auto s_nssai_ie = std::optional<uint8_t>(kIeiSNssai);
+        S_NSSAI ie_s_nssai_tmp(s_nssai_ie);
         if ((decoded_result = ie_s_nssai_tmp.Decode(
                  buf + decoded_size, len - decoded_size, kIeIsOptional)) ==
             KEncodeDecodeError)