Update PDU Session Reactivation Result Error Cause

src/nas/common/Ie_Const.hpp

@@ -122,6 +122,7 @@ constexpr uint8_t kIeiRejectedNssaiRr        = 0x69;
 
 constexpr uint8_t kIeiEpsNasMessageContainer                 = 0x70;
 constexpr uint8_t kIeiNasMessageContainer                    = 0x71;
+constexpr uint8_t kIeiPduSessionReactivationResultErrorCause = 0x72;
 constexpr uint8_t kIeiLadnIndication                         = 0x74;
 constexpr uint8_t kIeiLadnInformation                        = 0x79;
 constexpr uint8_t kIei5gGuti                                 = 0x77;

src/nas/ies/PDU_Session_Reactivation_Result_Error_Cause.cpp

@@ -19,116 +19,133 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #include "PDU_Session_Reactivation_Result_Error_Cause.hpp"
 
+#include "3gpp_24.501.hpp"
+#include "common_defs.h"
+#include "Ie_Const.hpp"
 #include "logger.hpp"
 using namespace nas;
 
 //------------------------------------------------------------------------------
 PDU_Session_Reactivation_Result_Error_Cause::
-    PDU_Session_Reactivation_Result_Error_Cause(uint8_t iei) {
-  _iei       = iei;
-  _value     = 0;
-  SESSION_ID = 0;
-  length     = 0;
+    PDU_Session_Reactivation_Result_Error_Cause()
+    : Type6NasIe(kIeiPduSessionReactivationResultErrorCause),
+      pdu_session_id_cause_value_pair() {
+  std::pair<uint8_t, uint8_t> value = std::make_pair<uint8_t, uint8_t>(0, 0);
+  pdu_session_id_cause_value_pair.push_back(value);
+  SetLengthIndicator(
+      2);  // Minimum length with 1 pair (PDU Session ID, Cause Value)
+  SetIeName(kPduSessionReactivationResultErrorCauseIeName);
 }
 
 //------------------------------------------------------------------------------
 PDU_Session_Reactivation_Result_Error_Cause::
     PDU_Session_Reactivation_Result_Error_Cause(
-        const uint8_t iei, uint8_t session_id, uint8_t value) {
-  _iei       = iei;
-  _value     = value;
-  SESSION_ID = session_id;
-  length     = 5;
+        uint8_t session_id, uint8_t cause)
+    : Type6NasIe(kIeiPduSessionReactivationResultErrorCause) {
+  std::pair<uint8_t, uint8_t> value = std::make_pair(session_id, cause);
+  pdu_session_id_cause_value_pair.push_back(value);
+  SetLengthIndicator(
+      2);  // Minimum length with 1 pair (PDU Session ID, Cause Value)
+  SetIeName(kPduSessionReactivationResultErrorCauseIeName);
 }
 
 //------------------------------------------------------------------------------
 PDU_Session_Reactivation_Result_Error_Cause::
-    PDU_Session_Reactivation_Result_Error_Cause() {
-  _iei       = 0;
-  _value     = 0;
-  SESSION_ID = 0;
-  length     = 0;
-}
+    ~PDU_Session_Reactivation_Result_Error_Cause() {}
 
 //------------------------------------------------------------------------------
-PDU_Session_Reactivation_Result_Error_Cause::
-    ~PDU_Session_Reactivation_Result_Error_Cause() {}
+void PDU_Session_Reactivation_Result_Error_Cause::setValue(
+    uint8_t session_id, uint8_t cause) {
+  std::pair<uint8_t, uint8_t> value = std::make_pair(session_id, cause);
+  pdu_session_id_cause_value_pair.clear();
+  pdu_session_id_cause_value_pair.push_back(value);
+}
 
 //------------------------------------------------------------------------------
 void PDU_Session_Reactivation_Result_Error_Cause::setValue(
-    uint8_t session_id, uint8_t value) {
-  SESSION_ID = session_id;
-  _value     = value;
+    const std::vector<std::pair<uint8_t, uint8_t>>& value) {
+  if (value.size() > 0) pdu_session_id_cause_value_pair = value;
+  SetLengthIndicator(value.size() * 2);
 }
 
 //------------------------------------------------------------------------------
-uint8_t PDU_Session_Reactivation_Result_Error_Cause::getValue() {
-  return _value;
+std::pair<uint8_t, uint8_t>
+PDU_Session_Reactivation_Result_Error_Cause::getValue() const {
+  if (pdu_session_id_cause_value_pair.size() > 0) {
+    return pdu_session_id_cause_value_pair[0];
+  }
+  return std::pair<uint8_t, uint8_t>(0, 0);
 }
 
 //------------------------------------------------------------------------------
 int PDU_Session_Reactivation_Result_Error_Cause::Encode(uint8_t* buf, int len) {
-  Logger::nas_mm().debug(
-      "encoding PDU_Session_Reactivation_Result_Error_Cause iei(0x%x)", _iei);
-  if (len < length) {
-    Logger::nas_mm().error("len is less than %d", length);
-    return 0;
+  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)",
+        ie_len);
+    return KEncodeDecodeError;
   }
+
   int encoded_size = 0;
-  if (_iei) {
-    *(buf + encoded_size) = _iei;
-    encoded_size++;
-    *(buf + encoded_size) = (length - 3) & 0x00ff;
-    encoded_size++;
-    *(buf + encoded_size) = ((length - 3) & 0xff00) >> 8;
-    encoded_size++;
-    *(buf + encoded_size) = SESSION_ID;
-    encoded_size++;
-    *(buf + encoded_size) = _value;
-    encoded_size++;
-
-  } else {
-    //		*(buf + encoded_size) = length - 1; encoded_size++;
-    //		*(buf + encoded_size) = _value; encoded_size++; encoded_size++;
+  // IEI and Length (later)
+  int len_pos = 0;
+  int encoded_header_size =
+      Type6NasIe::Encode(buf + encoded_size, len, len_pos);
+  if (encoded_header_size == KEncodeDecodeError) return KEncodeDecodeError;
+  encoded_size += encoded_header_size;
+
+  // PDU Session ID/Cause Value
+  for (const auto& i : pdu_session_id_cause_value_pair) {
+    ENCODE_U8(buf + encoded_size, i.first, encoded_size);
+    ENCODE_U8(buf + encoded_size, i.second, encoded_size);
   }
+
+  // Encode length
+  int encoded_len_ie = 0;
+  ENCODE_U16(buf + len_pos, encoded_size - GetHeaderLength(), encoded_len_ie);
+
   Logger::nas_mm().debug(
-      "encoded PDU_Session_Reactivation_Result_Error_Cause len(%d)",
-      encoded_size);
+      "Encoded %s, len (%d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
 int PDU_Session_Reactivation_Result_Error_Cause::Decode(
-    uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug(
-      "decoding PDU_Session_Reactivation_Result_Error_Cause iei(0x%x)", *buf);
+    uint8_t* buf, int len, bool is_iei) {
+  Logger::nas_mm().debug("Decoding EPS_NAS_Message_Container");
   int decoded_size = 0;
-  if (is_option) {
-    decoded_size++;
+
+  // IEI and Length
+  uint16_t ie_len         = 0;
+  int decoded_header_size = Type6NasIe::Decode(buf + decoded_size, len, is_iei);
+  if (decoded_header_size == KEncodeDecodeError) return KEncodeDecodeError;
+  decoded_size += decoded_header_size;
+  ie_len = GetLengthIndicator();
+
+  // Decode PDU Session ID/Cause Value
+  pdu_session_id_cause_value_pair.clear();
+  while (decoded_size < ie_len - 2) {
+    uint8_t pdu_session_id = {};
+    uint8_t cause_value    = {};
+    DECODE_U8(buf + decoded_size, pdu_session_id, decoded_size);
+    DECODE_U8(buf + decoded_size, cause_value, decoded_size);
+    std::pair<uint8_t, uint8_t> value =
+        std::make_pair(pdu_session_id, cause_value);
+    pdu_session_id_cause_value_pair.push_back(value);
   }
-  _value = 0x00;
-  length |= *(buf + decoded_size);
-  decoded_size++;
-  length |= (*(buf + decoded_size)) << 8;
-  decoded_size++;
-  SESSION_ID = *(buf + decoded_size);
-  decoded_size++;
-  _value = *(buf + decoded_size);
-  decoded_size++;
+
+  for (const auto& i : pdu_session_id_cause_value_pair) {
     Logger::nas_mm().debug(
-      "decoded PDU_Session_Reactivation_Result_Error_Cause value(0x%x)",
-      _value);
+        "PDU Session ID 0x%x, Cause Value", i.first, i.second);
+  }
+
   Logger::nas_mm().debug(
-      "decoded PDU_Session_Reactivation_Result_Error_Cause len(%d)",
-      decoded_size);
+      "Decoded EPS_NAS_Message_Container (len %d)", decoded_size);
   return decoded_size;
 }

src/nas/ies/PDU_Session_Reactivation_Result_Error_Cause.hpp

@@ -19,37 +19,38 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#ifndef __PDU_Session_Reactivation_Result_Error_Cause_H_
-#define __PDU_Session_Reactivation_Result_Error_Cause_H_
+#ifndef _PDU_SESSION_REACTIVATION_RESULT_ERROR_CAUSE_H_
+#define _PDU_SESSION_REACTIVATION_RESULT_ERROR_CAUSE_H_
 
+#include "Type6NasIe.hpp"
 #include <stdint.h>
+#include <vector>
+
+constexpr uint8_t kPduSessionReactivationResultErrorCauseMinimumLength  = 5;
+constexpr uint32_t kPduSessionReactivationResultErrorCauseMaximumLength = 515;
+constexpr auto kPduSessionReactivationResultErrorCauseIeName =
+    "PDU Session Reactivation Result Error Cause";
 
 namespace nas {
 
-class PDU_Session_Reactivation_Result_Error_Cause {
+class PDU_Session_Reactivation_Result_Error_Cause : Type6NasIe {
  public:
   PDU_Session_Reactivation_Result_Error_Cause();
-  PDU_Session_Reactivation_Result_Error_Cause(uint8_t iei);
   PDU_Session_Reactivation_Result_Error_Cause(
-      const uint8_t iei, uint8_t session_id, uint8_t value);
+      uint8_t session_id, uint8_t value);
   ~PDU_Session_Reactivation_Result_Error_Cause();
-  void setValue(uint8_t session_id, uint8_t value);
+
+  void setValue(uint8_t session_id, uint8_t cause);
+  std::pair<uint8_t, uint8_t> getValue() const;
+
+  void setValue(const std::vector<std::pair<uint8_t, uint8_t>>& value);
+  void getValue(std::vector<std::pair<uint8_t, uint8_t>>& value) const;
+
   int Encode(uint8_t* buf, int len);
   int Decode(uint8_t* buf, int len, bool is_option);
-  uint8_t getValue();
 
  private:
-  uint8_t _iei;
-  uint16_t length;
-  uint8_t SESSION_ID;
-  uint8_t _value;
+  std::vector<std::pair<uint8_t, uint8_t>> pdu_session_id_cause_value_pair;
 };
 
 }  // namespace nas

src/nas/msgs/RegistrationAccept.cpp

@@ -185,7 +185,7 @@ void RegistrationAccept::setPDU_session_reactivation_result_error_cause(
     uint8_t session_id, uint8_t value) {
   ie_pdu_session_reactivation_result_error_cause =
       std::make_optional<PDU_Session_Reactivation_Result_Error_Cause>(
-          0x72, session_id, value);
+          session_id, value);
 }
 
 //------------------------------------------------------------------------------