Update Authentication Failure

src/nas/common/Ie_Const.hpp

@@ -110,6 +110,8 @@ constexpr uint8_t kIeiAuthenticationResponseParameter = 0x2D;
 constexpr uint8_t kIeiUeSecurityCapability = 0x2e;
 constexpr uint8_t kIeiUeNetworkCapability  = 0x17;
 
+constexpr uint8_t kIeiAuthenticationFailureParameter = 0x30;
+
 constexpr uint8_t kIeiAdditional5gSecurityInformation = 0x36;
 constexpr uint8_t kIeiAbba                            = 0x38;
 

src/nas/common/NasIeHeader.hpp

@@ -70,7 +70,7 @@
 #include "UESecurityCapability.hpp"
 #include "UeRadioCapabilityId.hpp"
 #include "UplinkDataStatus.hpp"
-#include "_5GMM_Cause.hpp"
+#include "_5gmmCause.hpp"
 #include "_5GSDeregistrationType.hpp"
 #include "_5GSTrackingAreaIdList.hpp"
 #include "_5GS_DRX_Parameters.hpp"

src/nas/ies/Authentication_Failure_Parameter.cpp

@@ -19,93 +19,112 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #include "Authentication_Failure_Parameter.hpp"
 
 #include "logger.hpp"
 using namespace nas;
 
 //------------------------------------------------------------------------------
-Authentication_Failure_Parameter::Authentication_Failure_Parameter(
-    uint8_t iei) {
-  _iei   = iei;
-  length = 0;
-  value  = 0;
+Authentication_Failure_Parameter::Authentication_Failure_Parameter()
+    : Type4NasIe(kIeiAuthenticationFailureParameter), value_() {
+  SetLengthIndicator(kAuthenticationFailureParameterContentLength);
+  SetIeName(kAuthenticationFailureParameterIeName);
 }
 
 //------------------------------------------------------------------------------
 Authentication_Failure_Parameter::Authentication_Failure_Parameter(
-    const uint8_t iei, bstring auts) {
-  _iei   = iei;
-  value  = bstrcpy(auts);
-  length = blength(auts) + 2;
+    const bstring& value) {
+  value_ = bstrcpy(value);
+  SetLengthIndicator(kAuthenticationFailureParameterContentLength);
+  SetIeName(kAuthenticationFailureParameterIeName);
 }
 
 //------------------------------------------------------------------------------
-Authentication_Failure_Parameter::Authentication_Failure_Parameter()
-    : _iei(), length(), value() {}
+Authentication_Failure_Parameter::~Authentication_Failure_Parameter() {}
 
+/*
 //------------------------------------------------------------------------------
-Authentication_Failure_Parameter::~Authentication_Failure_Parameter() {}
+void Authentication_Failure_Parameter::SetValue(const uint8_t
+(&value)[kAuthenticationFailureParameterContentLength]) { for (int i = 0; i <
+kAuthenticationFailureParameterContentLength; i++) { this->value_[i] = value[i];
+          }
+}
 
 //------------------------------------------------------------------------------
-void Authentication_Failure_Parameter::getValue(bstring& auts) {
-  auts = bstrcpy(value);
+void Authentication_Failure_Parameter::GetValue(uint8_t
+(&value)[kAuthenticationFailureParameterContentLength]) const{ for (int i = 0; i
+< kAuthenticationFailureParameterContentLength; i++) { value[i] =
+this->value_[i];
+          }
+
+}
+*/
+
+//------------------------------------------------------------------------------
+void Authentication_Failure_Parameter::SetValue(const bstring& value) {
+  value_ = bstrcpy(value);
+  SetLengthIndicator(blength(value));
+}
+
+//------------------------------------------------------------------------------
+void Authentication_Failure_Parameter::GetValue(bstring& value) const {
+  value = bstrcpy(value_);
 }
 
 //------------------------------------------------------------------------------
 int Authentication_Failure_Parameter::Encode(uint8_t* buf, int len) {
-  Logger::nas_mm().debug(
-      "encoding Authentication_Failure_Parameter iei(0x%x)", _iei);
-  if (len < length) {
-    Logger::nas_mm().error("len is less than %x", 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(value, (buf + encoded_size), len - encoded_size);
-    encoded_size += size;
-    return encoded_size;
-  } else {
-    //		*(buf + encoded_size) = length - 1; encoded_size++;
-    //		*(buf + encoded_size) = _value; encoded_size++; 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
+  /* for (int i = 0; i < kAuthenticationFailureParameterContentLength; i++) {
+    ENCODE_U8(buf + encoded_size, value_[i], encoded_size);
   }
+  */
+  int size = encode_bstring(value_, (buf + encoded_size), len - encoded_size);
+  encoded_size += size;
+
   Logger::nas_mm().debug(
-      "Encoded Authentication_Failure_Parameter len (%d)", encoded_size);
+      "Encoded %s, len (%d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
 int Authentication_Failure_Parameter::Decode(
-    uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug(
-      "Decoding Authentication_Failure_Parameter iei (0x%x)", *buf);
-  int decoded_size = 0;
-  if (is_option) {
-    decoded_size++;
-  }
-  length = *(buf + decoded_size);
-  decoded_size++;
-  Logger::nas_mm().debug(
-      "Decoded IE Authentication_Failure_Parameter length (%d)", length);
-  decode_bstring(&value, length, (buf + decoded_size), len - decoded_size);
-  decoded_size += length;
-  for (int i = 0; i < length; i++) {
-    Logger::nas_mm().debug(
-        "Decoded Authentication_Failure_Parameter value (0x%x)",
-        (uint8_t) value->data[i]);
+    uint8_t* buf, int len, bool is_iei) {
+  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;
+
+  if (GetLengthIndicator() != kAuthenticationFailureParameterContentLength)
+    return KEncodeDecodeError;
+
+  // Value
+  uint8_t ie_len = GetLengthIndicator();
+  decode_bstring(&value_, 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) value_->data[i]);
   }
+
   Logger::nas_mm().debug(
-      "Decoded Authentication_Failure_Parameter len (%d)", decoded_size);
+      "Decoded %s, len (%d)", GetIeName().c_str(), decoded_size);
   return decoded_size;
 }

src/nas/ies/Authentication_Failure_Parameter.hpp

@@ -19,41 +19,47 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
+#ifndef _AUTHENTICATION_FAILURE_PARAMETER_H_
+#define _AUTHENTICATION_FAILURE_PARAMETER_H_
+
+#include "Type4NasIe.hpp"
 
-#ifndef __Authentication_Failure_Parameter_H_
-#define __Authentication_Failure_Parameter_H_
 #include <stdint.h>
 
-#include <iostream>
 extern "C" {
 #include "TLVDecoder.h"
 #include "TLVEncoder.h"
 #include "bstrlib.h"
 }
 
+constexpr uint8_t kAuthenticationFailureParameterLength = 16;
+constexpr uint8_t kAuthenticationFailureParameterContentLength =
+    kAuthenticationFailureParameterLength - 2;
+constexpr auto kAuthenticationFailureParameterIeName = "5GMM Capability";
+
 namespace nas {
 
-class Authentication_Failure_Parameter {
+class Authentication_Failure_Parameter : public Type4NasIe {
  public:
   Authentication_Failure_Parameter();
-  Authentication_Failure_Parameter(uint8_t iei);
-  Authentication_Failure_Parameter(const uint8_t iei, bstring auts);
+  Authentication_Failure_Parameter(
+      const uint8_t (&value)[kAuthenticationFailureParameterContentLength]);
+  Authentication_Failure_Parameter(const bstring& value);
   ~Authentication_Failure_Parameter();
-  // 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& auts);
+  int Decode(uint8_t* buf, int len, bool is_iei);
+
+  // void SetValue(const uint8_t
+  // (&value)[kAuthenticationFailureParameterContentLength]); void
+  // GetValue(uint8_t (&value)[kAuthenticationFailureParameterContentLength])
+  // const;
+  void SetValue(const bstring& value);
+  void GetValue(bstring& value) const;
 
  private:
-  uint8_t _iei;
-  uint8_t length;
-  bstring value;
+  // uint8_t value_[kAuthenticationFailureParameterContentLength];
+  bstring value_;
 };
 
 }  // namespace nas

src/nas/ies/Authentication_Parameter_AUTN.cpp

@@ -104,6 +104,6 @@ int Authentication_Parameter_AUTN::Decode(uint8_t* buf, int len, bool is_iei) {
         "Decoded Authentication_Parameter_AUTN value (0x%2x)", _value[j]);
   }
   Logger::nas_mm().debug(
-      "Decoded Authentication_Parameter_AUTN len (%d)", decoded_size);
+      "Decoded %s, len (%d)", GetIeName().c_str(), decoded_size);
   return decoded_size;
 }

src/nas/ies/_5GMM_Cause.cpp → src/nas/ies/_5gmmCause.cpp

@@ -18,7 +18,7 @@
  * For more information about the OpenAirInterface (OAI) Software Alliance:
  *      contact@openairinterface.org
  */
-#include "_5GMM_Cause.hpp"
+#include "_5gmmCause.hpp"
 
 #include "3gpp_24.501.hpp"
 #include "common_defs.h"
@@ -26,44 +26,44 @@
 using namespace nas;
 
 //------------------------------------------------------------------------------
-_5GMM_Cause::_5GMM_Cause(uint8_t iei) : Type3NasIe(iei) {
+_5gmmCause::_5gmmCause(uint8_t iei) : Type3NasIe(iei) {
   value_ = 0;
   SetIeName(k5gmmCauseIeName);
 }
 
 //------------------------------------------------------------------------------
-_5GMM_Cause::_5GMM_Cause() : Type3NasIe() {
+_5gmmCause::_5gmmCause() : Type3NasIe() {
   value_ = 0;
   SetIeName(k5gmmCauseIeName);
 }
 
 //------------------------------------------------------------------------------
-_5GMM_Cause::_5GMM_Cause(uint8_t iei, uint8_t value) : Type3NasIe(iei) {
+_5gmmCause::_5gmmCause(uint8_t iei, uint8_t value) : Type3NasIe(iei) {
   value_ = value;
   SetIeName(k5gmmCauseIeName);
 }
 
 //------------------------------------------------------------------------------
-_5GMM_Cause::~_5GMM_Cause(){};
+_5gmmCause::~_5gmmCause(){};
 
 //------------------------------------------------------------------------------
-void _5GMM_Cause::SetValue(uint8_t value) {
+void _5gmmCause::SetValue(uint8_t value) {
   value_ = value;
 }
 
 //------------------------------------------------------------------------------
-uint8_t _5GMM_Cause::GetValue() const {
+uint8_t _5gmmCause::GetValue() const {
   return value_;
 }
 
 //------------------------------------------------------------------------------
-void _5GMM_Cause::Set(uint8_t iei, uint8_t value) {
+void _5gmmCause::Set(uint8_t iei, uint8_t value) {
   SetIei(iei);
   value_ = value;
 }
 
 //------------------------------------------------------------------------------
-int _5GMM_Cause::Encode(uint8_t* buf, int len) {
+int _5gmmCause::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
 
   if (len < k5gmmCauseMaximumLength) {
@@ -85,7 +85,7 @@ int _5GMM_Cause::Encode(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int _5GMM_Cause::Decode(uint8_t* buf, int len, bool is_iei) {
+int _5gmmCause::Decode(uint8_t* buf, int len, bool is_iei) {
   Logger::nas_mm().debug("Decoding %s", GetIeName().c_str());
 
   if (len < k5gmmCauseMinimumLength) {

src/nas/ies/_5GMM_Cause.hpp → src/nas/ies/_5gmmCause.hpp

@@ -74,12 +74,12 @@ constexpr auto k5gmmCauseIeName = "5GMM Cause";
 
 namespace nas {
 
-class _5GMM_Cause : public Type3NasIe {
+class _5gmmCause : public Type3NasIe {
  public:
-  _5GMM_Cause();
-  _5GMM_Cause(uint8_t iei);
-  _5GMM_Cause(uint8_t _iei, uint8_t value);
-  ~_5GMM_Cause();
+  _5gmmCause();
+  _5gmmCause(uint8_t iei);
+  _5gmmCause(uint8_t _iei, uint8_t value);
+  ~_5gmmCause();
 
   int Encode(uint8_t* buf, int len);
   int Decode(uint8_t* buf, int len, bool is_iei);

src/nas/msgs/AuthenticationFailure.cpp

@@ -50,15 +50,34 @@ uint8_t AuthenticationFailure::get5GMmCause() {
   return ie_5gmm_cause.GetValue();
 }
 
+/*
+//------------------------------------------------------------------------------
+void AuthenticationFailure::setAuthentication_Failure_Parameter(
+    const uint8_t (&value)[kAuthenticationFailureParameterContentLength]) {
+  ie_authentication_failure_parameter =
+      std::make_optional<Authentication_Failure_Parameter>(value);
+}
+bool AuthenticationFailure::getAutsInAuthFailPara(uint8_t
+(&value)[kAuthenticationFailureParameterContentLength]) const{ if
+(ie_authentication_failure_parameter.has_value()) {
+    ie_authentication_failure_parameter.value().GetValue(value);
+    return true;
+  } else {
+    return false;
+  }
+}
+*/
+
 //------------------------------------------------------------------------------
 void AuthenticationFailure::setAuthentication_Failure_Parameter(
-    const bstring& auts) {
+    const bstring& value) {
   ie_authentication_failure_parameter =
-      std::make_optional<Authentication_Failure_Parameter>(0x30, auts);
+      std::make_optional<Authentication_Failure_Parameter>(value);
 }
-bool AuthenticationFailure::getAutsInAuthFailPara(bstring& auts) {
+
+bool AuthenticationFailure::getAutsInAuthFailPara(bstring& value) const {
   if (ie_authentication_failure_parameter.has_value()) {
-    ie_authentication_failure_parameter.value().getValue(auts);
+    ie_authentication_failure_parameter.value().GetValue(value);
     return true;
   } else {
     return false;

src/nas/msgs/AuthenticationFailure.hpp

@@ -39,11 +39,16 @@ class AuthenticationFailure : public NasMmPlainHeader {
   void Set5gmmCause(uint8_t value);
   uint8_t get5GMmCause();
 
-  void setAuthentication_Failure_Parameter(const bstring& auts);
-  bool getAutsInAuthFailPara(bstring& auts);
+  //  void setAuthentication_Failure_Parameter(const uint8_t
+  //  (&value)[kAuthenticationFailureParameterContentLength]); bool
+  //  getAutsInAuthFailPara(uint8_t
+  //  (&value)[kAuthenticationFailureParameterContentLength]) const;
+
+  void setAuthentication_Failure_Parameter(const bstring& value);
+  bool getAutsInAuthFailPara(bstring& value) const;
 
  public:
-  _5GMM_Cause ie_5gmm_cause;  // Mandatory
+  _5gmmCause ie_5gmm_cause;  // Mandatory
   std::optional<Authentication_Failure_Parameter>
       ie_authentication_failure_parameter;  // Optional
 };

src/nas/msgs/DLNASTransport.cpp

@@ -74,7 +74,7 @@ void DLNASTransport::SetAdditionalInformation(const bstring& value) {
 
 //------------------------------------------------------------------------------
 void DLNASTransport::Set5gmmCause(uint8_t value) {
-  ie_5gmm_cause = std::make_optional<_5GMM_Cause>(0x58, value);
+  ie_5gmm_cause = std::make_optional<_5gmmCause>(0x58, value);
 }
 
 //------------------------------------------------------------------------------
@@ -238,13 +238,13 @@ int DLNASTransport::Decode(uint8_t* buf, int len) {
       } break;
       case kIei5gmmCause: {
         Logger::nas_mm().debug("Decoding IEI (0x58)");
-        _5GMM_Cause ie_5gmm_cause_tmp = {};
+        _5gmmCause ie_5gmm_cause_tmp = {};
         if ((decoded_result = ie_5gmm_cause_tmp.Decode(
                  buf + decoded_size, len - decoded_size, true)) ==
             KEncodeDecodeError)
           return decoded_result;
         decoded_size += decoded_result;
-        ie_5gmm_cause = std::optional<_5GMM_Cause>(ie_5gmm_cause_tmp);
+        ie_5gmm_cause = std::optional<_5gmmCause>(ie_5gmm_cause_tmp);
         octet         = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;

src/nas/msgs/DLNASTransport.hpp

@@ -58,7 +58,7 @@ class DLNASTransport : public NasMmPlainHeader {
   Payload_Container ie_payload_container;                          // Mandatory
   std::optional<PduSessionIdentity2> ie_pdu_session_identity_2;    // Optional
   std::optional<AdditionalInformation> ie_additional_information;  // Optional
-  std::optional<_5GMM_Cause> ie_5gmm_cause;                        // Optional
+  std::optional<_5gmmCause> ie_5gmm_cause;                         // Optional
   std::optional<GprsTimer3> ie_back_off_timer_value;               // Optional
 };
 

src/nas/msgs/RegistrationReject.hpp

@@ -52,7 +52,7 @@ class RegistrationReject : public NasMmPlainHeader {
   // TODO: Get
 
  public:
-  _5GMM_Cause ie_5gmm_cause;                        // Mandatory
+  _5gmmCause ie_5gmm_cause;                         // Mandatory
   std::optional<GprsTimer2> ie_T3346_value;         // Optional
   std::optional<GprsTimer2> ie_T3502_value;         // Optional
   std::optional<EapMessage> ie_eap_message;         // Optional

src/nas/msgs/SecurityModeReject.cpp

@@ -52,7 +52,7 @@ void SecurityModeReject::SetHeader(uint8_t security_header_type) {
 
 //------------------------------------------------------------------------------
 void SecurityModeReject::Set5gmmCause(uint8_t value) {
-  ie_5gmm_cause = new _5GMM_Cause(0x00, value);
+  ie_5gmm_cause = new _5gmmCause(0x00, value);
 }
 
 //------------------------------------------------------------------------------
@@ -86,7 +86,7 @@ int SecurityModeReject::Decode(
   Logger::nas_mm().debug("decoding SecurityModeReject message");
   int decoded_size = 3;
   plain_header     = header;
-  ie_5gmm_cause    = new _5GMM_Cause();
+  ie_5gmm_cause    = new _5gmmCause();
   decoded_size +=
       ie_5gmm_cause->Decode(buf + decoded_size, len - decoded_size, false);
   Logger::nas_mm().debug("decoded_size(%d)", decoded_size);

src/nas/msgs/SecurityModeReject.hpp

@@ -44,7 +44,7 @@ class SecurityModeReject {
 
  public:
   NasMmPlainHeader* plain_header;
-  _5GMM_Cause* ie_5gmm_cause;
+  _5gmmCause* ie_5gmm_cause;
 };
 
 }  // namespace nas