Update UplinkDataStatus and UENetworkCapability

src/amf-app/amf_n1.cpp

@@ -1414,9 +1414,10 @@ void amf_n1::registration_request_handle(
 
     case MOBILITY_REGISTRATION_UPDATING: {
       Logger::amf_n1().debug("Handling Mobility Registration Update...");
+      uint16_t uplink_data_status = 0;
+      registration_request->getUplinkDataStatus(uplink_data_status);
       run_mobility_registration_update_procedure(
-          nc, registration_request->getUplinkDataStatus(),
-          registration_request->getPduSessionStatus());
+          nc, uplink_data_status, registration_request->getPduSessionStatus());
     } break;
 
     case PERIODIC_REGISTRATION_UPDATING: {

src/nas/ies/UENetworkCapability.hpp

@@ -53,6 +53,7 @@ class UENetworkCapability {
   // TODO: uint8_t octet_7;
   // TODO: uint8_t octet_8;
   // TODO: uint8_t octet_9;
+  // TODO: spare octet 10-15
 };
 
 }  // namespace nas

src/nas/ies/UplinkDataStatus.cpp

@@ -19,15 +19,10 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #include "UplinkDataStatus.hpp"
 
+#include "3gpp_24.501.hpp"
+#include "common_defs.h"
 #include "logger.hpp"
 using namespace nas;
 
@@ -39,10 +34,10 @@ UplinkDataStatus::UplinkDataStatus(uint8_t iei) {
 }
 
 //------------------------------------------------------------------------------
-UplinkDataStatus::UplinkDataStatus(const uint8_t iei, uint16_t value) {
+UplinkDataStatus::UplinkDataStatus(const uint8_t& iei, const uint16_t& value) {
   _iei   = iei;
   _value = value;
-  length = 4;
+  length = 2;
 }
 
 //------------------------------------------------------------------------------
@@ -68,43 +63,37 @@ uint16_t UplinkDataStatus::getValue() {
 
 //------------------------------------------------------------------------------
 int UplinkDataStatus::encode2Buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("encoding UplinkDataStatus iei(0x%x)", _iei);
-  if (len < length) {
-    Logger::nas_mm().error("len is less than %d", length);
-    return 0;
+  Logger::nas_mm().debug("Encoding UplinkDataStatus IEI (0x%x)", _iei);
+  if (len < kUplinkDataStatusMinimumLength) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kUplinkDataStatusMinimumLength);
+    return KEncodeDecodeError;
   }
+
   int encoded_size = 0;
   if (_iei) {
-    *(buf + encoded_size) = _iei;
-    encoded_size++;
-    *(buf + encoded_size) = length - 2;
-    encoded_size++;
-    *(buf + encoded_size) = (_value & 0xff00) >> 8;
-    encoded_size++;
-    *(buf + encoded_size) = _value & 0x00ff;
-    encoded_size++;
-  } else {
-    //		*(buf + encoded_size) = length - 1; encoded_size++;
-    //		*(buf + encoded_size) = _value; encoded_size++; encoded_size++;
+    ENCODE_U8(buf + encoded_size, _iei, encoded_size);
   }
-  Logger::nas_mm().debug("encoded UplinkDataStatus len(%d)", encoded_size);
+
+  ENCODE_U8(buf + encoded_size, length, encoded_size);
+  ENCODE_U16(buf + encoded_size, _value, encoded_size);
+
+  Logger::nas_mm().debug("Encoded UplinkDataStatus, size (%d)", encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
 int UplinkDataStatus::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("decoding UplinkDataStatus iei(0x%x)", *buf);
+  Logger::nas_mm().debug("Decoding UplinkDataStatus");
   int decoded_size = 0;
   if (is_option) {
-    decoded_size++;
+    DECODE_U8(buf + decoded_size, _iei, decoded_size);
   }
-  length = *(buf + decoded_size);
-  decoded_size++;
-  _value = *(buf + decoded_size) << 8;
-  decoded_size++;
-  _value |= *(buf + decoded_size);
-  decoded_size++;
-  Logger::nas_mm().debug("decoded UplinkDataStatus value(0x%4x)", _value);
-  Logger::nas_mm().debug("decoded UplinkDataStatus len(%d)", decoded_size);
+  DECODE_U8(buf + decoded_size, length, decoded_size);
+  DECODE_U16(buf + decoded_size, _value, decoded_size);
+
+  Logger::nas_mm().debug(
+      "Decoded UplinkDataStatus value 0x%x, len %d", _value, decoded_size);
   return decoded_size;
 }

src/nas/ies/UplinkDataStatus.hpp

@@ -19,25 +19,21 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #ifndef __UplinkDataStatus_H_
 #define __UplinkDataStatus_H_
 
 #include <stdint.h>
 
+constexpr uint8_t kUplinkDataStatusMinimumLength = 4;
+constexpr uint8_t kUplinkDataStatusMaximumLength = 34;
+
 namespace nas {
 
 class UplinkDataStatus {
  public:
   UplinkDataStatus();
   UplinkDataStatus(uint8_t);
-  UplinkDataStatus(const uint8_t iei, uint16_t value);
+  UplinkDataStatus(const uint8_t& iei, const uint16_t& value);
   ~UplinkDataStatus();
   void setValue(uint8_t iei, uint16_t value);
   int encode2Buffer(uint8_t* buf, int len);
@@ -48,6 +44,7 @@ class UplinkDataStatus {
   uint8_t _iei;
   uint8_t length;
   uint16_t _value;
+  // TODO: spare
 };
 
 }  // namespace nas

src/nas/msgs/RegistrationRequest.cpp

@@ -34,9 +34,9 @@ RegistrationRequest::RegistrationRequest()
   ie_5g_mm_capability            = std::nullopt;
   ie_ue_security_capability      = std::nullopt;
   ie_requested_NSSAI             = std::nullopt;
-  ie_s1_ue_network_capability    = nullptr;
-  ie_uplink_data_status          = nullptr;
-  ie_last_visited_registered_TAI = nullptr;
+  ie_s1_ue_network_capability    = std::nullopt;
+  ie_uplink_data_status          = std::nullopt;
+  ie_last_visited_registered_TAI = std::nullopt;
   ie_PDU_session_status          = nullptr;
   ie_MICO_indicationl            = nullptr;
   ie_ue_status                   = nullptr;
@@ -271,22 +271,22 @@ bool RegistrationRequest::getRequestedNssai(
 //------------------------------------------------------------------------------
 void RegistrationRequest::setLast_Visited_Registered_TAI(
     const std::string& mcc, const std::string mnc, const uint32_t& tac) {
-  // TODO: ie_last_visited_registered_TAI =
-  //   new _5GSTrackingAreaIdentity(mcc, mnc, tac);
+  ie_last_visited_registered_TAI =
+      std::make_optional<_5GSTrackingAreaIdentity>(0, mcc, mnc, tac);
 }
 
 //------------------------------------------------------------------------------
 void RegistrationRequest::setUENetworkCapability(
     uint8_t g_EEASel, uint8_t g_EIASel) {
   ie_s1_ue_network_capability =
-      new UENetworkCapability(0x17, g_EEASel, g_EIASel);
+      std::make_optional<UENetworkCapability>(0x17, g_EEASel, g_EIASel);
 }
 
 //------------------------------------------------------------------------------
 bool RegistrationRequest::getS1UeNetworkCapability(uint8_t& eea, uint8_t& eia) {
-  if (ie_s1_ue_network_capability) {
-    eea = ie_s1_ue_network_capability->getEEASel();
-    eia = ie_s1_ue_network_capability->getEIASel();
+  if (ie_s1_ue_network_capability.has_value()) {
+    eea = ie_s1_ue_network_capability.value().getEEASel();
+    eia = ie_s1_ue_network_capability.value().getEIASel();
   } else {
     return false;
   }
@@ -294,16 +294,17 @@ bool RegistrationRequest::getS1UeNetworkCapability(uint8_t& eea, uint8_t& eia) {
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::setUplink_data_status(uint16_t value) {
-  ie_uplink_data_status = new UplinkDataStatus(0x40, value);
+void RegistrationRequest::setUplink_data_status(const uint16_t& value) {
+  ie_uplink_data_status = std::make_optional<UplinkDataStatus>(0x40, value);
 }
 
 //------------------------------------------------------------------------------
-uint16_t RegistrationRequest::getUplinkDataStatus() {
-  if (ie_uplink_data_status) {
-    return ie_uplink_data_status->getValue();
+bool RegistrationRequest::getUplinkDataStatus(uint16_t& value) {
+  if (ie_uplink_data_status.has_value()) {
+    value = ie_uplink_data_status.value().getValue();
+    return true;
   } else {
-    return 0;
+    return false;
   }
 }
 
@@ -622,10 +623,10 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
   }
 
   // Last visited registered TAI
-  if (!ie_last_visited_registered_TAI) {
+  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->encode2Buffer(
+    if (int size = ie_last_visited_registered_TAI.value().encode2Buffer(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -635,10 +636,10 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
   }
 
   // S1 UE network capability
-  if (!ie_s1_ue_network_capability) {
+  if (!ie_s1_ue_network_capability.has_value()) {
     Logger::nas_mm().warn("IE ie_s1_ue_network_capability is not available");
   } else {
-    if (int size = ie_s1_ue_network_capability->encode2Buffer(
+    if (int size = ie_s1_ue_network_capability.value().encode2Buffer(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -646,10 +647,10 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
       return 0;
     }
   }
-  if (!ie_uplink_data_status) {
+  if (!ie_uplink_data_status.has_value()) {
     Logger::nas_mm().warn("IE ie_uplink_data_status is not available");
   } else {
-    if (int size = ie_uplink_data_status->encode2Buffer(
+    if (int size = ie_uplink_data_status.value().encode2Buffer(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -927,25 +928,32 @@ int RegistrationRequest::decodeFromBuffer(uint8_t* buf, int len) {
       } break;
       case 0x52: {
         Logger::nas_mm().debug("Decoding IEI(0x52)");
-        ie_last_visited_registered_TAI = new _5GSTrackingAreaIdentity();
-        decoded_size += ie_last_visited_registered_TAI->decodeFromBuffer(
+        _5GSTrackingAreaIdentity last_visited_registered_tai_tmp = {};
+        decoded_size += last_visited_registered_tai_tmp.decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
+        ie_last_visited_registered_TAI =
+            std::optional<_5GSTrackingAreaIdentity>(
+                last_visited_registered_tai_tmp);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
       } break;
       case 0x17: {
         Logger::nas_mm().debug("Decoding IEI (0x17)");
-        ie_s1_ue_network_capability = new UENetworkCapability();
-        decoded_size += ie_s1_ue_network_capability->decodeFromBuffer(
+        UENetworkCapability ie_s1_ue_network_capability_tmp = {};
+        decoded_size += ie_s1_ue_network_capability_tmp.decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
+        ie_s1_ue_network_capability =
+            std::optional<UENetworkCapability>(ie_s1_ue_network_capability_tmp);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
       } break;
       case 0x40: {
         Logger::nas_mm().debug("Decoding IEI(0x40)");
-        ie_uplink_data_status = new UplinkDataStatus();
-        decoded_size += ie_uplink_data_status->decodeFromBuffer(
+        UplinkDataStatus ie_uplink_data_status_tmp = {};
+        decoded_size += ie_uplink_data_status_tmp.decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
+        ie_uplink_data_status =
+            std::optional<UplinkDataStatus>(ie_uplink_data_status_tmp);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
 

src/nas/msgs/RegistrationRequest.hpp

@@ -91,8 +91,8 @@ class RegistrationRequest : public NasMmPlainHeader {
   void setUENetworkCapability(uint8_t g_EEASel, uint8_t g_EIASel);
   bool getS1UeNetworkCapability(uint8_t& eea, uint8_t& eia);
 
-  void setUplink_data_status(uint16_t value);
-  uint16_t getUplinkDataStatus();
+  void setUplink_data_status(const uint16_t& value);
+  bool getUplinkDataStatus(uint16_t& value);
 
   void setLast_Visited_Registered_TAI(
       const std::string& mcc, const std::string mnc, const uint32_t& tac);
@@ -156,10 +156,11 @@ class RegistrationRequest : public NasMmPlainHeader {
   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<_5GSTrackingAreaIdentity>
+      ie_last_visited_registered_TAI;                              // Optional
+  std::optional<UENetworkCapability> ie_s1_ue_network_capability;  // Optional
+  std::optional<UplinkDataStatus> ie_uplink_data_status;           // Optional
 
-  _5GSTrackingAreaIdentity* ie_last_visited_registered_TAI;   // Optional
-  UENetworkCapability* ie_s1_ue_network_capability;           // Optional
-  UplinkDataStatus* ie_uplink_data_status;                    // Optional
   PDU_Session_Status* ie_PDU_session_status;                  // Optional
   MICO_Indication* ie_MICO_indicationl;                       // Optional
   UE_Status* ie_ue_status;                                    // Optional