Update DNN

src/nas/ies/AuthenticationResponseParameter.cpp

@@ -98,7 +98,7 @@ int AuthenticationResponseParameter::Decode(
   decoded_size += decoded_header_size;
 
   // RES or RES*
-  uint16_t ie_len = GetLengthIndicator();
+  uint8_t ie_len = GetLengthIndicator();
   decode_bstring(
       &res_or_res_star_, ie_len, (buf + decoded_size), len - decoded_size);
   decoded_size += ie_len;

src/nas/ies/DNN.cpp

@@ -19,82 +19,90 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #include "DNN.hpp"
 
 #include "logger.hpp"
 using namespace nas;
 
 //------------------------------------------------------------------------------
-DNN::DNN(uint8_t iei) : _DNN() {
-  _iei   = iei;
-  length = 0;
+DNN::DNN() : Type4NasIe(kIeiDnn), _DNN() {
+  SetLengthIndicator(1);
+  SetIeName(kDnnIeName);
 }
 
 //------------------------------------------------------------------------------
-DNN::DNN(const uint8_t iei, bstring dnn) {
-  _iei   = iei;
-  _DNN   = bstrcpy(dnn);
-  length = blength(dnn) + 2;
+DNN::DNN(bstring dnn) : Type4NasIe(kIeiDnn) {
+  _DNN = bstrcpy(dnn);
+  SetLengthIndicator(blength(dnn));
+  SetIeName(kDnnIeName);
 }
 
 //------------------------------------------------------------------------------
-DNN::DNN() : _iei(), _DNN(), length() {}
+DNN::~DNN() {}
 
 //------------------------------------------------------------------------------
-DNN::~DNN() {}
+void DNN::SetValue(const bstring& dnn) {
+  _DNN = bstrcpy(dnn);
+}
 
 //------------------------------------------------------------------------------
-void DNN::getValue(bstring& dnn) {
-  dnn = blk2bstr((uint8_t*) bdata(_DNN) + 1, blength(_DNN) - 1);
+void DNN::GetValue(bstring& dnn) const {
+  dnn = bstrcpy(_DNN);
 }
 
 //------------------------------------------------------------------------------
 int DNN::Encode(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("Encoding DNN 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) {
+    Logger::nas_mm().error("Len is less than %d", ie_len);
+    return KEncodeDecodeError;
   }
+
   int encoded_size = 0;
-  if (_iei) {
-    *(buf + encoded_size) = _iei;
-    encoded_size++;
-    *(buf + encoded_size) = (length - 2);
-    encoded_size++;
-    int size = encode_bstring(_DNN, (buf + encoded_size), len - encoded_size);
-    encoded_size += size;
-
-  } else {
-    *(buf + encoded_size) = (length - 1);
-    encoded_size++;
-    int size = encode_bstring(_DNN, (buf + encoded_size), len - encoded_size);
-    encoded_size += size;
-  }
-  Logger::nas_mm().debug("encoded DNN len: %d", encoded_size);
+  // 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;
+
+  // Value
+  int size = encode_bstring(_DNN, (buf + encoded_size), len - encoded_size);
+  encoded_size += size;
+
+  Logger::nas_mm().debug(
+      "Encoded %s, len (%d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int DNN::Decode(uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("Decoding DNN IEI (0x%x)", *buf);
-  int decoded_size = 0;
-  if (is_option) {
-    decoded_size++;
+int DNN::Decode(uint8_t* buf, int len, bool is_iei) {
+  if (len < kDnnMinimumLength) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kDnnMinimumLength);
+    return KEncodeDecodeError;
   }
-  length = *(buf + decoded_size);
-  decoded_size++;
-  decode_bstring(&_DNN, length, (buf + decoded_size), len - decoded_size);
-  decoded_size += length;
-  for (int i = 0; i < blength(_DNN); i++) {
-    Logger::nas_mm().debug("Decoded DNN value: 0x%x", (uint8_t) bdata(_DNN)[i]);
+
+  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;
+
+  // DNN
+  uint8_t ie_len = GetLengthIndicator();
+  decode_bstring(&_DNN, ie_len, (buf + decoded_size), len - decoded_size);
+  decoded_size += ie_len;
+
+  for (int i = 0; i < ie_len; i++) {
+    Logger::nas_mm().debug("Decoded value 0x%x", (uint8_t) _DNN->data[i]);
   }
-  Logger::nas_mm().debug("Decoded DNN len: %d", decoded_size);
+
+  Logger::nas_mm().debug(
+      "Decoded %s, len (%d)", GetIeName().c_str(), decoded_size);
   return decoded_size;
 }

src/nas/ies/DNN.hpp

@@ -19,39 +19,30 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #ifndef __DNN_H_
 #define __DNN_H_
-#include <stdint.h>
-
-#include <iostream>
-extern "C" {
-#include "TLVDecoder.h"
-#include "TLVEncoder.h"
-#include "bstrlib.h"
-}
+
+#include "Type4NasIe.hpp"
+
+constexpr uint8_t kDnnMinimumLength = 3;
+constexpr uint8_t kDnnMaximumLength = 102;
+constexpr auto kDnnIeName           = "DNN";
+
 namespace nas {
 
-class DNN {
+class DNN : public Type4NasIe {
  public:
   DNN();
-  DNN(uint8_t iei);
-  DNN(const uint8_t iei, bstring dnn);
+  DNN(bstring dnn);
   ~DNN();
-  // void setValue(uint8_t iei, uint8_t value);
+
   int Encode(uint8_t* buf, int len);
   int Decode(uint8_t* buf, int len, bool is_option);
-  void getValue(bstring& dnn);
+
+  void SetValue(const bstring& dnn);
+  void GetValue(bstring& dnn) const;
 
  private:
-  uint8_t _iei;
-  uint8_t length;
   bstring _DNN;
 };
 

src/nas/msgs/ULNASTransport.cpp

@@ -138,13 +138,13 @@ bool ULNASTransport::GetSNssai(SNSSAI_s& snssai) {
 
 //------------------------------------------------------------------------------
 void ULNASTransport::setDNN(bstring dnn) {
-  ie_dnn = std::make_optional<DNN>(0x25, dnn);
+  ie_dnn = std::make_optional<DNN>(dnn);
 }
 
 //------------------------------------------------------------------------------
 bool ULNASTransport::getDnn(bstring& dnn) {
   if (ie_dnn.has_value()) {
-    ie_dnn.value().getValue(dnn);
+    ie_dnn.value().GetValue(dnn);
     return true;
   } else {
     return false;