Code refactoring for NAS MM Header related IEs

src/amf-app/amf_app.cpp

@@ -331,7 +331,7 @@ void amf_app::handle_itti_message(
     dl->setPDUSessionId(itti_msg.pdu_session_id);
 
     uint8_t nas[BUFFER_SIZE_1024];
-    int encoded_size = dl->encode2buffer(nas, BUFFER_SIZE_1024);
+    int encoded_size = dl->encode2Buffer(nas, BUFFER_SIZE_1024);
     comUt::print_buffer("amf_app", "n1n2 transfer", nas, encoded_size);
 
     std::shared_ptr<itti_downlink_nas_transfer> dl_msg =

src/amf-app/amf_config.cpp

@@ -28,7 +28,7 @@
 #include <libconfig.h++>
 
 #include "3gpp_29.502.h"
-#include "3gpp_ts24501.hpp"
+#include "3gpp_24.501.hpp"
 #include "amf_app.hpp"
 #include "conversions.hpp"
 #include "fqdn.hpp"

src/amf-app/amf_n1.hpp

@@ -30,7 +30,7 @@
 #include <shared_mutex>
 
 #include "3gpp_29.503.h"
-#include "3gpp_ts24501.hpp"
+#include "3gpp_24.501.hpp"
 #include "AuthorizedNetworkSliceInfo.h"
 #include "Nssai.h"
 #include "RegistrationAccept.hpp"

src/amf-app/amf_sbi.cpp

@@ -27,7 +27,7 @@
 
 #include "3gpp_29.500.h"
 #include "3gpp_29.502.h"
-#include "3gpp_ts24501.hpp"
+#include "3gpp_24.501.hpp"
 #include "AmfEventReport.h"
 #include "amf.hpp"
 #include "amf_app.hpp"

src/nas/common/3gpp24.007.hpp → src/nas/common/3gpp_24.007.hpp

@@ -24,8 +24,10 @@
 
 #include <stdint.h>
 
+constexpr uint8_t kType1IeSize = 1;
+
 // Extended Protocol Discriminator (EPD)
-constexpr uint8_t kEpd5gsSessionManagementMessage  = 0b00101110;
-constexpr uint8_t kEpd5gsMobilityManagementMessage = 0b01111110;
+#define EPD_5GS_MM_MSG 0b01111110
+#define EPD_5GS_SM_MSG 0b00101110
 
 #endif

src/nas/common/3gpp_ts24501.hpp → src/nas/common/3gpp_24.501.hpp

@@ -22,16 +22,11 @@
 #ifndef _3GPP_TS_24501_H_
 #define _3GPP_TS_24501_H_
 
-#include "3gpp24.007.hpp"
+#include "3gpp_24.007.hpp"
 
 #include <string>
 #include <vector>
 
-/********** epd type **************/
-
-#define EPD_5GS_MM_MSG 0b01111110
-#define EPD_5GS_SM_MSG 0b00101110
-
 /********** security header type **************/
 
 #define PLAIN_5GS_MSG 0b0000
@@ -83,6 +78,13 @@
 #define NO_FOLLOW_ON_REQ_PENDING false
 #define FOLLOW_ON_REQ_PENDING true
 
+enum class RegistrationTypeEnum {
+  INITIAL_REGISTRATION           = 0b001,
+  MOBILITY_REGISTRATION_UPDATING = 0b010,
+  PERIODIC_REGISTRATION_UPDATING = 0b011,
+  EMERGENCY_REGISTRATION         = 0b100,
+  RESERVED                       = 0b111
+};
 #define INITIAL_REGISTRATION 0b001
 #define MOBILITY_REGISTRATION_UPDATING 0b010
 #define PERIODIC_REGISTRATION_UPDATING 0b011
@@ -187,6 +189,6 @@ static const std::vector<std::string> nas_ciphering_algorithm_list_e2str = {
 
 #define NAS_MESSAGE_MIN_LENGTH 3
 
-constexpr uint8_t KEncodeDecodeError = 0;
+constexpr int KEncodeDecodeError = -1;
 
 #endif

src/nas/ies/5GMMCapability.cpp

@@ -51,7 +51,7 @@ uint8_t _5GMMCapability::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int _5GMMCapability::encode2buffer(uint8_t* buf, int len) {
+int _5GMMCapability::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding _5GMMCapability IEI (0x%x)", m_iei);
   if (len < length) {
     Logger::nas_mm().error("Len is less than %d", length);
@@ -78,7 +78,7 @@ int _5GMMCapability::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int _5GMMCapability::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int _5GMMCapability::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   uint8_t decoded_size = 0;
 
   Logger::nas_mm().debug("Decoding _5GMMCapability IEI (0x%x)", *buf);

src/nas/ies/5GMMCapability.hpp

@@ -38,8 +38,8 @@ class _5GMMCapability {
   void setValue(uint8_t iei, uint8_t value);
   uint8_t getValue();
 
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option = true);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option = true);
 
  private:
   uint8_t m_iei;

src/nas/ies/5GSMobilityIdentity.cpp

@@ -30,7 +30,7 @@
 
 #include <math.h>
 
-#include "3gpp_ts24501.hpp"
+#include "3gpp_24.501.hpp"
 #include "conversions.hpp"
 #include "String2Value.hpp"
 #include "logger.hpp"
@@ -253,7 +253,7 @@ void _5GSMobilityIdentity::getIMEISV(IMEISV_t& imeisv) {
 }
 
 //------------------------------------------------------------------------------
-int _5GSMobilityIdentity::encode2buffer(uint8_t* buf, int len) {
+int _5GSMobilityIdentity::encode2Buffer(uint8_t* buf, int len) {
   switch (typeOfIdentity) {
     case SUCI: {
       return suci_encode2buffer(buf, len);
@@ -485,7 +485,7 @@ int _5GSMobilityIdentity::imeisv_encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int _5GSMobilityIdentity::decodefrombuffer(
+int _5GSMobilityIdentity::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding 5GSMobilityIdentity");
   int decoded_size = 0;

src/nas/ies/5GSMobilityIdentity.hpp

@@ -89,7 +89,7 @@ class _5GSMobilityIdentity {
   _5GSMobilityIdentity();
   ~_5GSMobilityIdentity();
   void setIEI(uint8_t _iei);
-  int encode2buffer(uint8_t* buf, int len);
+  int encode2Buffer(uint8_t* buf, int len);
   int suci_encode2buffer(uint8_t* buf, int len);
   int _5g_guti_encode2buffer(uint8_t* buf, int len);
   int encodeMssMnc2buffer(string mcc, string mnc, uint8_t* buf);
@@ -98,7 +98,7 @@ class _5GSMobilityIdentity {
   int _5g_s_tmsi_encode2buffer(uint8_t* buf, int len);
   int _5g_s_tmsi_decodefrombuffer(uint8_t* buf, int len);
 
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   int suci_decodefrombuffer(uint8_t* buf, int len, int length);
   int _5g_guti_decodefrombuffer(uint8_t* buf, int len);
   void set5GGUTI(

src/nas/ies/5GSRegistrationType.cpp

@@ -19,100 +19,117 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #include "5GSRegistrationType.hpp"
 
-#include "3gpp_ts24501.hpp"
+#include "3gpp_24.501.hpp"
+#include "common_defs.h"
 #include "logger.hpp"
 
 using namespace nas;
 
 //------------------------------------------------------------------------------
-_5GSRegistrationType::_5GSRegistrationType() {
-  iei      = 0;
-  is_for   = false;
-  reg_type = 0;
-}
+_5GSRegistrationType::_5GSRegistrationType()
+    : iei_(0), follow_on_req_(false), reg_type_(0) {}
 
 //------------------------------------------------------------------------------
-_5GSRegistrationType::_5GSRegistrationType(bool is_for, uint8_t type) {
-  this->is_for   = is_for;
-  this->reg_type = 0x07 & type;
-  this->iei      = 0;
+_5GSRegistrationType::_5GSRegistrationType(bool follow_on_req, uint8_t type)
+    : iei_(0) {
+  follow_on_req_ = follow_on_req;
+  reg_type_      = 0x07 & type;
 }
 
 //------------------------------------------------------------------------------
 _5GSRegistrationType::_5GSRegistrationType(
-    uint8_t iei, bool is_for, uint8_t type) {
-  this->is_for   = is_for;
-  this->reg_type = 0x07 & type;
-  this->iei      = 0x0f & iei;
+    uint8_t iei, bool follow_on_req, uint8_t type) {
+  iei_           = 0x0f & iei;
+  follow_on_req_ = follow_on_req;
+  reg_type_      = 0x07 & type;
 }
 
 //------------------------------------------------------------------------------
 _5GSRegistrationType::~_5GSRegistrationType() {}
 
 //------------------------------------------------------------------------------
-int _5GSRegistrationType::encode2buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().error("encoding 5gsregistrationtype IE");
-  if (len < 1) {
+int _5GSRegistrationType::encode2Buffer(uint8_t* buf, int len) {
+  Logger::nas_mm().error("Encoding 5gsregistrationtype IE");
+  if (len < kType1IeSize) {
     Logger::nas_mm().error(
-        "encoding 5gsregistrationtype error(len is less than one)");
-    return -1;
+        "Buffer length is less than the minimum length of this IE (%s octet)",
+        kType1IeSize);
+    return KEncodeDecodeError;
   }
+
   uint8_t octet        = 0;
-  if (is_for) octet = 0x08;
-  octet |= reg_type;
-  if (!(iei & 0x0f)) {
-    *buf = 0x0f & octet;
-    Logger::nas_mm().debug("encoded 5GSRegistrationType IE(len(1/2 octet))");
-    return 0;
+  uint8_t encoded_size = 0;
+
+  if (follow_on_req_) octet = 0b1000;
+  octet |= reg_type_;
+
+  if (!(iei_ & 0x0f)) {
+    ENCODE_U8(buf, 0x0f & octet, encoded_size);
   } else {
-    *buf = (iei << 4) | octet;
-    Logger::nas_mm().debug("encoded 5GSRegistrationType IE(len(1 octet))");
-    return 1;
+    ENCODE_U8(buf, (iei_ << 4) | octet, encoded_size);
   }
+  Logger::nas_mm().debug(
+      "Encoded 5GSRegistrationType IE (%d octet))", encoded_size);
+  return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int _5GSRegistrationType::decodefrombuffer(
+int _5GSRegistrationType::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
+  if (len < kType1IeSize) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%s octet)",
+        kType1IeSize);
+    return KEncodeDecodeError;
+  }
+
   if (is_option) {
-    return -1;
+    return KEncodeDecodeError;
   }
+
   Logger::nas_mm().debug("Decoding 5GSRegistrationType");
-  uint8_t octet = *buf;
+  uint8_t decoded_size = 0;
+  uint8_t octet        = 0;
+
+  DECODE_U8(buf, octet, decoded_size);
+
   if (octet & 0x08)
-    is_for = FOLLOW_ON_REQ_PENDING;
+    follow_on_req_ = FOLLOW_ON_REQ_PENDING;
   else
-    is_for = NO_FOLLOW_ON_REQ_PENDING;
-  reg_type = 0x07 & octet;
-  Logger::nas_mm().debug("Decoded 5GSRegistrationType len (1/2 octet)");
-  return 0;
+    follow_on_req_ = NO_FOLLOW_ON_REQ_PENDING;
+
+  reg_type_ = 0x07 & octet;
+
+  Logger::nas_mm().debug(
+      "Decoded 5GSRegistrationType IE (%d octet)", decoded_size);
+  return decoded_size;
 }
 
 //------------------------------------------------------------------------------
-void _5GSRegistrationType::setFollowOnReq(const bool is) {
-  is_for = is;
+void _5GSRegistrationType::set(
+    const bool& follow_on_req, const uint8_t& type, const uint8_t& iei) {
+  follow_on_req_ = follow_on_req;
+  reg_type_      = 0x07 & type;
+  iei_           = 0x0f & iei;
 }
-
 //------------------------------------------------------------------------------
-void _5GSRegistrationType::setRegType(const uint8_t type) {
-  reg_type = 0x07 & type;
+void _5GSRegistrationType::setFollowOnReq(const bool follow_on_req) {
+  follow_on_req_ = follow_on_req;
 }
 
 //------------------------------------------------------------------------------
 bool _5GSRegistrationType::isFollowOnReq() {
-  return is_for;
+  return follow_on_req_;
+}
+
+//------------------------------------------------------------------------------
+void _5GSRegistrationType::setRegType(const uint8_t type) {
+  reg_type_ = 0x07 & type;
 }
 
 //------------------------------------------------------------------------------
 uint8_t _5GSRegistrationType::getRegType() {
-  return reg_type;
+  return reg_type_;
 }

src/nas/ies/5GSRegistrationType.hpp

@@ -19,13 +19,6 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #ifndef _5GS_REGISTRATION_TYPE_H_
 #define _5GS_REGISTRATION_TYPE_H_
 
@@ -36,21 +29,26 @@ namespace nas {
 class _5GSRegistrationType {
  public:
   _5GSRegistrationType();
-  _5GSRegistrationType(bool is_for, uint8_t type);
-  _5GSRegistrationType(uint8_t iei, bool is_for, uint8_t type);
+  _5GSRegistrationType(bool follow_on_req, uint8_t type);
+  _5GSRegistrationType(uint8_t iei, bool follow_on_req, uint8_t type);
   ~_5GSRegistrationType();
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
-  int encode2buffer(uint8_t* buf, int len);
+
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option = false);
+  int encode2Buffer(uint8_t* buf, int len);
+
+  void set(
+      const bool& follow_on_req, const uint8_t& type, const uint8_t& iei = 0);
 
   void setFollowOnReq(const bool is);
-  void setRegType(const uint8_t type);
   bool isFollowOnReq();
+
+  void setRegType(const uint8_t type);
   uint8_t getRegType();
 
  private:
-  uint8_t iei : 4;
-  bool is_for;
-  uint8_t reg_type : 3;
+  uint8_t iei_ : 4;
+  bool follow_on_req_;
+  uint8_t reg_type_ : 3;
 };
 
 }  // namespace nas

src/nas/ies/ABBA.cpp

@@ -61,7 +61,7 @@ uint8_t ABBA::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int ABBA::encode2buffer(uint8_t* buf, int len) {
+int ABBA::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding ABBA IEI (0x%x)", _iei);
   if (len < _length) {
     Logger::nas_mm().error("len is less than %d", _length);
@@ -97,7 +97,7 @@ int ABBA::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int ABBA::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int ABBA::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Encoding ABBA IEI (0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/ABBA.hpp

@@ -40,8 +40,8 @@ class ABBA {
   ABBA(const uint8_t iei, uint8_t length, uint8_t* value);
   ~ABBA();
   // void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint8_t getValue();
 
  private:

src/nas/ies/Additional_5G_Security_Information.cpp

@@ -78,7 +78,7 @@ bool Additional_5G_Security_Information::getHDP() {
 }
 
 //------------------------------------------------------------------------------
-int Additional_5G_Security_Information::encode2buffer(uint8_t* buf, int len) {
+int Additional_5G_Security_Information::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "encoding Additional_5G_Security_Information iei(0x%x)", _iei);
   if (len < 3) {
@@ -101,7 +101,7 @@ int Additional_5G_Security_Information::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Additional_5G_Security_Information::decodefrombuffer(
+int Additional_5G_Security_Information::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   if (len < 3) {
     Logger::nas_mm().error("len is less than 3");

src/nas/ies/Additional_5G_Security_Information.hpp

@@ -39,8 +39,8 @@ class Additional_5G_Security_Information {
   Additional_5G_Security_Information(uint8_t iei);
   Additional_5G_Security_Information(const uint8_t iei, bool RINMR, bool HDP);
   ~Additional_5G_Security_Information();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setRINMR(bool value);
   void setHDP(bool value);
   bool getRINMR();

src/nas/ies/Additional_Information.cpp

@@ -64,7 +64,7 @@ uint8_t Additional_Information::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int Additional_Information::encode2buffer(uint8_t* buf, int len) {
+int Additional_Information::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding Additional_Information iei(0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("len is less than %d", length);
@@ -91,7 +91,7 @@ int Additional_Information::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Additional_Information::decodefrombuffer(
+int Additional_Information::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding Additional_Information iei(0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/Additional_Information.hpp

@@ -40,8 +40,8 @@ class Additional_Information {
   Additional_Information(const uint8_t iei, uint8_t _length, uint8_t value);
   ~Additional_Information();
   void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint8_t getValue();
 
  private:

src/nas/ies/Allowed_PDU_Session_Status.cpp

@@ -63,7 +63,7 @@ uint16_t Allowed_PDU_Session_Status::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int Allowed_PDU_Session_Status::encode2buffer(uint8_t* buf, int len) {
+int Allowed_PDU_Session_Status::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding Allowed_PDU_Session_Status iei(0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("len is less than %d", length);
@@ -90,7 +90,7 @@ int Allowed_PDU_Session_Status::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Allowed_PDU_Session_Status::decodefrombuffer(
+int Allowed_PDU_Session_Status::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding Allowed_PDU_Session_Status iei(0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/Allowed_PDU_Session_Status.hpp

@@ -40,8 +40,8 @@ class Allowed_PDU_Session_Status {
   Allowed_PDU_Session_Status(const uint8_t iei, uint16_t value);
   ~Allowed_PDU_Session_Status();
   void setValue(uint8_t iei, uint16_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint16_t getValue();
 
  private:

src/nas/ies/Authentication_Failure_Parameter.cpp

@@ -60,7 +60,7 @@ void Authentication_Failure_Parameter::getValue(bstring& auts) {
 }
 
 //------------------------------------------------------------------------------
-int Authentication_Failure_Parameter::encode2buffer(uint8_t* buf, int len) {
+int Authentication_Failure_Parameter::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "encoding Authentication_Failure_Parameter iei(0x%x)", _iei);
   if (len < length) {
@@ -86,7 +86,7 @@ int Authentication_Failure_Parameter::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Authentication_Failure_Parameter::decodefrombuffer(
+int Authentication_Failure_Parameter::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug(
       "Decoding Authentication_Failure_Parameter iei (0x%x)", *buf);

src/nas/ies/Authentication_Failure_Parameter.hpp

@@ -45,8 +45,8 @@ class Authentication_Failure_Parameter {
   Authentication_Failure_Parameter(const uint8_t iei, bstring auts);
   ~Authentication_Failure_Parameter();
   // void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void getValue(bstring& auts);
 
  private:

src/nas/ies/Authentication_Parameter_AUTN.cpp

@@ -63,7 +63,7 @@ uint8_t* Authentication_Parameter_AUTN::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int Authentication_Parameter_AUTN::encode2buffer(uint8_t* buf, int len) {
+int Authentication_Parameter_AUTN::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "Encoding Authentication_Parameter_AUTN IEI (0x%x)", _iei);
   if (len < 18) {
@@ -91,7 +91,7 @@ int Authentication_Parameter_AUTN::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Authentication_Parameter_AUTN::decodefrombuffer(
+int Authentication_Parameter_AUTN::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug(
       "Decoding Authentication_Parameter_AUTN IEI (0x%x)", *buf);

src/nas/ies/Authentication_Parameter_AUTN.hpp

@@ -40,8 +40,8 @@ class Authentication_Parameter_AUTN {
   Authentication_Parameter_AUTN(const uint8_t iei, uint8_t* value);
   ~Authentication_Parameter_AUTN();
   // void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint8_t* getValue();
 
  private:

src/nas/ies/Authentication_Parameter_RAND.cpp

@@ -59,7 +59,7 @@ uint8_t* Authentication_Parameter_RAND::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int Authentication_Parameter_RAND::encode2buffer(uint8_t* buf, int len) {
+int Authentication_Parameter_RAND::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "Encoding Authentication_Parameter_RAND IEI (0x%x)", _iei);
   if (len < 17) {
@@ -87,7 +87,7 @@ int Authentication_Parameter_RAND::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Authentication_Parameter_RAND::decodefrombuffer(
+int Authentication_Parameter_RAND::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug(
       "Decoding Authentication_Parameter_RAND IEI (0x%x)", *buf);

src/nas/ies/Authentication_Parameter_RAND.hpp

@@ -40,8 +40,8 @@ class Authentication_Parameter_RAND {
   Authentication_Parameter_RAND(const uint8_t iei, uint8_t* value);
   ~Authentication_Parameter_RAND();
   // void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint8_t* getValue();
 
  private:

src/nas/ies/Authentication_Response_Parameter.cpp

@@ -56,7 +56,7 @@ void Authentication_Response_Parameter::getValue(bstring& para) {
 }
 
 //------------------------------------------------------------------------------
-int Authentication_Response_Parameter::encode2buffer(uint8_t* buf, int len) {
+int Authentication_Response_Parameter::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "Encoding Authentication_Response_Parameter IEI 0x%x", _iei);
   if (len < 18) {
@@ -82,7 +82,7 @@ int Authentication_Response_Parameter::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Authentication_Response_Parameter::decodefrombuffer(
+int Authentication_Response_Parameter::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug(
       "Decoding Authentication_Response_Parameter IEI 0x%x", *buf);

src/nas/ies/Authentication_Response_Parameter.hpp

@@ -46,8 +46,8 @@ class Authentication_Response_Parameter {
   Authentication_Response_Parameter(const uint8_t iei, bstring para);
   ~Authentication_Response_Parameter();
   // void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void getValue(bstring& para);
 
  private:

src/nas/ies/DNN.cpp

@@ -56,7 +56,7 @@ void DNN::getValue(bstring& dnn) {
 }
 
 //------------------------------------------------------------------------------
-int DNN::encode2buffer(uint8_t* buf, int len) {
+int DNN::encode2Buffer(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);
@@ -82,7 +82,7 @@ int DNN::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int DNN::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int DNN::decodeFromBuffer(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) {

src/nas/ies/DNN.hpp

@@ -45,8 +45,8 @@ class DNN {
   DNN(const uint8_t iei, bstring dnn);
   ~DNN();
   // void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void getValue(bstring& dnn);
 
  private:

src/nas/ies/EAP_Message.cpp

@@ -56,7 +56,7 @@ void EAP_Message::getValue(bstring& eap) {
 }
 
 //------------------------------------------------------------------------------
-int EAP_Message::encode2buffer(uint8_t* buf, int len) {
+int EAP_Message::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding EAP_Message iei(0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("len is less than %d", length);
@@ -77,7 +77,7 @@ int EAP_Message::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int EAP_Message::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int EAP_Message::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding EAP_Message iei (0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/EAP_Message.hpp

@@ -46,8 +46,8 @@ class EAP_Message {
   EAP_Message(const uint8_t iei, bstring eap);
   ~EAP_Message();
   // void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void getValue(bstring& eap);
 
  private:

src/nas/ies/EPS_Bearer_Context_Status.cpp

@@ -65,7 +65,7 @@ uint16_t EPS_Bearer_Context_Status::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int EPS_Bearer_Context_Status::encode2buffer(uint8_t* buf, int len) {
+int EPS_Bearer_Context_Status::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding EPS_Bearer_Context_Status iei(0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("len is less than %d", length);
@@ -91,7 +91,7 @@ int EPS_Bearer_Context_Status::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int EPS_Bearer_Context_Status::decodefrombuffer(
+int EPS_Bearer_Context_Status::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding EPS_Bearer_Context_Status iei(0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/EPS_Bearer_Context_Status.hpp

@@ -40,8 +40,8 @@ class EPS_Bearer_Context_Status {
   EPS_Bearer_Context_Status(const uint8_t iei, uint16_t value);
   ~EPS_Bearer_Context_Status();
   void setValue(uint8_t iei, uint16_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint16_t getValue();
 
  private:

src/nas/ies/EPS_NAS_Message_Container.cpp

@@ -63,7 +63,7 @@ void EPS_NAS_Message_Container::getValue(bstring& value) {
 }
 
 //------------------------------------------------------------------------------
-int EPS_NAS_Message_Container::encode2buffer(uint8_t* buf, int len) {
+int EPS_NAS_Message_Container::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding EPS_NAS_Message_Container iei (0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("Len is less than %d", length);
@@ -90,7 +90,7 @@ int EPS_NAS_Message_Container::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int EPS_NAS_Message_Container::decodefrombuffer(
+int EPS_NAS_Message_Container::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding EPS_NAS_Message_Container iei (0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/EPS_NAS_Message_Container.hpp

@@ -44,8 +44,8 @@ class EPS_NAS_Message_Container {
   EPS_NAS_Message_Container(const uint8_t iei, bstring value);
   ~EPS_NAS_Message_Container();
   void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void getValue(bstring& value);
 
  private:

src/nas/ies/EPS_NAS_Security_Algorithms.cpp

@@ -68,7 +68,7 @@ uint8_t EPS_NAS_Security_Algorithms::getINTEGRITY_PROTECTION() {
 }
 
 //------------------------------------------------------------------------------
-int EPS_NAS_Security_Algorithms::encode2buffer(uint8_t* buf, int len) {
+int EPS_NAS_Security_Algorithms::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "encoding EPS_NAS_Security_Algorithms iei(0x%x)", _iei);
   int encoded_size = 0;
@@ -89,7 +89,7 @@ int EPS_NAS_Security_Algorithms::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int EPS_NAS_Security_Algorithms::decodefrombuffer(
+int EPS_NAS_Security_Algorithms::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding EPS_NAS_Security_Algorithms IE");
   if (len < 2) {

src/nas/ies/EPS_NAS_Security_Algorithms.hpp

@@ -43,8 +43,8 @@ class EPS_NAS_Security_Algorithms {
   void setINTEGRITY_PROTECTION(uint8_t value);
   uint8_t getCIPHERING();
   uint8_t getINTEGRITY_PROTECTION();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
 
  private:
   uint8_t _iei;

src/nas/ies/ExtendedProtocolDiscriminator.cpp

@@ -21,14 +21,15 @@
 
 #include "ExtendedProtocolDiscriminator.hpp"
 
-#include "3gpp_ts24501.hpp"
+#include "3gpp_24.501.hpp"
 #include "common_defs.h"
 #include "logger.hpp"
 
 using namespace nas;
 
 //------------------------------------------------------------------------------
-ExtendedProtocolDiscriminator::ExtendedProtocolDiscriminator() {}
+ExtendedProtocolDiscriminator::ExtendedProtocolDiscriminator(const uint8_t& epd)
+    : epd_(epd) {}
 
 //------------------------------------------------------------------------------
 ExtendedProtocolDiscriminator::~ExtendedProtocolDiscriminator() {}
@@ -49,9 +50,11 @@ uint8_t ExtendedProtocolDiscriminator::Get() const {
 }
 
 //------------------------------------------------------------------------------
-uint32_t ExtendedProtocolDiscriminator::Encode(uint8_t* buf, uint32_t len) {
-  if (len < kEdpIeSize) {
-    Logger::nas_mm().error("Buffer length is less than %d octet", kEdpIeSize);
+int ExtendedProtocolDiscriminator::Encode(uint8_t* buf, const uint32_t& len) {
+  if (len < kType1IeSize) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%s octet)",
+        kType1IeSize);
     return KEncodeDecodeError;
   }
   uint32_t encoded_size = 0;
@@ -60,10 +63,12 @@ uint32_t ExtendedProtocolDiscriminator::Encode(uint8_t* buf, uint32_t len) {
 }
 
 //------------------------------------------------------------------------------
-uint32_t ExtendedProtocolDiscriminator::Decode(
-    const uint8_t* const buf, uint32_t len) {
-  if (len < kEdpIeSize) {
-    Logger::nas_mm().error("Buffer length is less than %s octet", kEdpIeSize);
+int ExtendedProtocolDiscriminator::Decode(
+    const uint8_t* const buf, const uint32_t& len) {
+  if (len < kType1IeSize) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%s octet)",
+        kType1IeSize);
     return KEncodeDecodeError;
   }
   uint32_t decoded_size = 0;

src/nas/ies/ExtendedProtocolDiscriminator.hpp

@@ -24,21 +24,20 @@
 
 #include <stdint.h>
 
-constexpr uint8_t kEdpIeSize = 1;
-
 namespace nas {
 
 class ExtendedProtocolDiscriminator {
  public:
-  ExtendedProtocolDiscriminator();
+  ExtendedProtocolDiscriminator(){};  // TODO: = delete;
+  ExtendedProtocolDiscriminator(const uint8_t& epd);
   virtual ~ExtendedProtocolDiscriminator();
 
   void Set(const uint8_t& epd);
   void Get(uint8_t& epd) const;
   uint8_t Get() const;
 
-  uint32_t Encode(uint8_t* buf, uint32_t len);
-  uint32_t Decode(const uint8_t* const buf, uint32_t len);
+  int Encode(uint8_t* buf, const uint32_t& len);
+  int Decode(const uint8_t* const buf, const uint32_t& len);
 
  private:
   uint8_t epd_;

src/nas/ies/Extended_DRX_Parameters.cpp

@@ -73,7 +73,7 @@ uint8_t Extended_DRX_Parameters::getPaging_time() {
 }
 
 //------------------------------------------------------------------------------
-int Extended_DRX_Parameters::encode2buffer(uint8_t* buf, int len) {
+int Extended_DRX_Parameters::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding Extended_DRX_Parameters iei(0x%x)", _iei);
   if (len < 3) {
     Logger::nas_mm().error("len is less than 3");
@@ -97,7 +97,7 @@ int Extended_DRX_Parameters::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Extended_DRX_Parameters::decodefrombuffer(
+int Extended_DRX_Parameters::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding Extended_DRX_Parameters iei(0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/Extended_DRX_Parameters.hpp

@@ -40,8 +40,8 @@ class Extended_DRX_Parameters {
   Extended_DRX_Parameters(
       const uint8_t iei, uint8_t paging_time, uint8_t value);
   ~Extended_DRX_Parameters();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t value);
   uint8_t getValue();
   void setPaging_time(uint8_t value);

src/nas/ies/GPRS_Timer_2.cpp

@@ -65,7 +65,7 @@ uint8_t GPRS_Timer_2::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int GPRS_Timer_2::encode2buffer(uint8_t* buf, int len) {
+int GPRS_Timer_2::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding GPRS_Timer_2 iei(0x%x)", _iei);
   if (len < 3) {
     Logger::nas_mm().error("len is less than 3");
@@ -91,7 +91,7 @@ int GPRS_Timer_2::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int GPRS_Timer_2::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int GPRS_Timer_2::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding GPRS_Timer_2 iei(0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/GPRS_Timer_2.hpp

@@ -40,8 +40,8 @@ class GPRS_Timer_2 {
   GPRS_Timer_2(const uint8_t iei, uint8_t value);
   ~GPRS_Timer_2();
   void setIEI(uint8_t iei);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t value);
   uint8_t getValue();
 

src/nas/ies/GPRS_Timer_3.cpp

@@ -68,7 +68,7 @@ uint8_t GPRS_Timer_3::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int GPRS_Timer_3::encode2buffer(uint8_t* buf, int len) {
+int GPRS_Timer_3::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding GPRS_Timer_3 IEI (0x%x)", _iei);
   if (len < 3) {
     Logger::nas_mm().error("len is less than 3");
@@ -96,7 +96,7 @@ int GPRS_Timer_3::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int GPRS_Timer_3::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int GPRS_Timer_3::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding GPRS_Timer_3 IEI (0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/GPRS_Timer_3.hpp

@@ -39,8 +39,8 @@ class GPRS_Timer_3 {
   GPRS_Timer_3(uint8_t iei);
   GPRS_Timer_3(const uint8_t iei, uint8_t unit, uint8_t value);
   ~GPRS_Timer_3();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t unit, uint8_t value);
   uint8_t getValue();
   uint8_t getUnit();

src/nas/ies/IMEISV_Request.cpp

@@ -60,7 +60,7 @@ uint8_t IMEISV_Request::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int IMEISV_Request::encode2buffer(uint8_t* buf, int len) {
+int IMEISV_Request::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding IMEISV_Request iei (0x%x)", _iei);
   if (len < 1) {
     Logger::nas_mm().error("Len is less than 1");
@@ -82,7 +82,7 @@ int IMEISV_Request::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int IMEISV_Request::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int IMEISV_Request::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   if (len < 1) {
     Logger::nas_mm().error("Len is less than one");
     return 0;

src/nas/ies/IMEISV_Request.hpp

@@ -39,8 +39,8 @@ class IMEISV_Request {
   IMEISV_Request(uint8_t iei);
   IMEISV_Request(const uint8_t iei, uint8_t value);
   ~IMEISV_Request();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t value);
   uint8_t getValue();
 

src/nas/ies/LADN_Indication.cpp

@@ -66,7 +66,7 @@ bool LADN_Indication::getValue(std::vector<bstring>& ladn) {
 }
 
 //------------------------------------------------------------------------------
-int LADN_Indication::encode2buffer(uint8_t* buf, int len) {
+int LADN_Indication::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding LADN_Indication IEI (0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("Len is less than %d", length);
@@ -92,7 +92,7 @@ int LADN_Indication::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int LADN_Indication::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int LADN_Indication::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding LADN_Indication IEI (0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/LADN_Indication.hpp

@@ -47,8 +47,8 @@ class LADN_Indication {
   LADN_Indication(const uint8_t iei, std::vector<bstring> ladn);
   ~LADN_Indication();
   void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   bool getValue(std::vector<bstring>& ladn);
 
  private:

src/nas/ies/MA_PDU_Session_Information.cpp

@@ -64,7 +64,7 @@ uint8_t MA_PDU_Session_Information::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int MA_PDU_Session_Information::encode2buffer(uint8_t* buf, int len) {
+int MA_PDU_Session_Information::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding MA_PDU_Session_Information iei(0x%x)", _iei);
   if (len < 1) {
     Logger::nas_mm().error("len is less than 1");
@@ -84,7 +84,7 @@ int MA_PDU_Session_Information::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int MA_PDU_Session_Information::decodefrombuffer(
+int MA_PDU_Session_Information::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding MA_PDU_Session_Information iei(0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/MA_PDU_Session_Information.hpp

@@ -39,8 +39,8 @@ class MA_PDU_Session_Information {
   MA_PDU_Session_Information(uint8_t iei);
   MA_PDU_Session_Information(const uint8_t iei, uint8_t value);
   ~MA_PDU_Session_Information();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t value);
   uint8_t getValue();
 

src/nas/ies/MICO_Indication.cpp

@@ -52,7 +52,7 @@ MICO_Indication::MICO_Indication() {}
 MICO_Indication::~MICO_Indication(){};
 
 //------------------------------------------------------------------------------
-int MICO_Indication::encode2buffer(uint8_t* buf, int len) {
+int MICO_Indication::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding MICO_Indication IE iei (0x%x)", iei);
   if (len < 1) {
     Logger::nas_mm().error("Len is less than one");
@@ -75,7 +75,7 @@ int MICO_Indication::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int MICO_Indication::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int MICO_Indication::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding MICO_Indication IE");
   if (len < 1) {
     Logger::nas_mm().error("Len is less than one");

src/nas/ies/MICO_Indication.hpp

@@ -40,8 +40,8 @@ class MICO_Indication {
   MICO_Indication(bool sprti, bool raai);
   ~MICO_Indication();
 
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
 
   void setSPRTI(bool value);
   void setRAAI(bool value);

src/nas/ies/NAS_Message_Container.cpp

@@ -62,7 +62,7 @@ void NAS_Message_Container::getValue(bstring& value) {
 }
 
 //------------------------------------------------------------------------------
-int NAS_Message_Container::encode2buffer(uint8_t* buf, int len) {
+int NAS_Message_Container::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding NAS_Message_Container IEI 0x%x", _iei);
   if (len < length) {
     Logger::nas_mm().error("Len is less than %d", length);
@@ -89,7 +89,7 @@ int NAS_Message_Container::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int NAS_Message_Container::decodefrombuffer(
+int NAS_Message_Container::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding NAS_Message_Container iei (0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/NAS_Message_Container.hpp

@@ -46,8 +46,8 @@ class NAS_Message_Container {
   NAS_Message_Container(const uint8_t iei, bstring value);
   ~NAS_Message_Container();
   void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void getValue(bstring& value);
 
  private:

src/nas/ies/NAS_Security_Algorithms.cpp

@@ -68,7 +68,7 @@ uint8_t NAS_Security_Algorithms::getINTEGRITY_PROTECTION() {
 }
 
 //------------------------------------------------------------------------------
-int NAS_Security_Algorithms::encode2buffer(uint8_t* buf, int len) {
+int NAS_Security_Algorithms::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding NAS_Security_Algorithms ");
   if (len < 1) {
     Logger::nas_mm().error("len is less than one");
@@ -81,7 +81,7 @@ int NAS_Security_Algorithms::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int NAS_Security_Algorithms::decodefrombuffer(
+int NAS_Security_Algorithms::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding NAS_Security_Algorithms IE");
   if (len < 1) {

src/nas/ies/NAS_Security_Algorithms.hpp

@@ -42,8 +42,8 @@ class NAS_Security_Algorithms {
   void setINTEGRITY_PROTECTION(uint8_t value);
   uint8_t getCIPHERING();
   uint8_t getINTEGRITY_PROTECTION();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
 
  private:
   uint8_t CIPHERING;

src/nas/ies/NSSAI.cpp

@@ -62,7 +62,7 @@ void NSSAI::getValue(std::vector<struct SNSSAI_s>& nssai) {
 }
 
 //------------------------------------------------------------------------------
-int NSSAI::encode2buffer(uint8_t* buf, int len) {
+int NSSAI::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding NSSAI IEI (0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("len is less than %d", length);
@@ -117,7 +117,7 @@ int NSSAI::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int NSSAI::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int NSSAI::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding NSSAI IEI (0x%x)", *buf);
   int decoded_size = 0;
   SNSSAI_s a       = {0, 0, 0, 0};

src/nas/ies/NSSAI.hpp

@@ -43,8 +43,8 @@ class NSSAI {
   NSSAI(const uint8_t iei, std::vector<struct SNSSAI_s> nssai);
   ~NSSAI();
   void setS_NAASI(uint8_t SST);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void getValue(std::vector<struct SNSSAI_s>& nssai);
 
  private:

src/nas/ies/NSSAI_Inclusion_Mode.cpp

@@ -54,7 +54,7 @@ uint8_t NSSAI_Inclusion_Mode::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int NSSAI_Inclusion_Mode::encode2buffer(uint8_t* buf, int len) {
+int NSSAI_Inclusion_Mode::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding NSSAI_Inclusion_Mode IE iei (0x%x)", _iei);
   if (len < 1) {
     Logger::nas_mm().error("Len is less than one");
@@ -77,7 +77,7 @@ int NSSAI_Inclusion_Mode::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int NSSAI_Inclusion_Mode::decodefrombuffer(
+int NSSAI_Inclusion_Mode::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding NSSAI_Inclusion_Mode IE");
   if (len < 1) {

src/nas/ies/NSSAI_Inclusion_Mode.hpp

@@ -38,8 +38,8 @@ class NSSAI_Inclusion_Mode {
   NSSAI_Inclusion_Mode();
   NSSAI_Inclusion_Mode(const uint8_t iei, uint8_t value);
   ~NSSAI_Inclusion_Mode();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(const uint8_t value);
   uint8_t getValue();
 

src/nas/ies/NasKeySetIdentifier.cpp

@@ -19,113 +19,111 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #include "NasKeySetIdentifier.hpp"
 
+#include "3gpp_24.501.hpp"
+#include "common_defs.h"
 #include "logger.hpp"
+
 using namespace nas;
 
 //------------------------------------------------------------------------------
-NasKeySetIdentifier::NasKeySetIdentifier(
-    const uint8_t m_iei, uint8_t m_tsc, uint8_t m_key_id) {
-  iei    = m_iei;
-  tsc    = 0x01 & m_tsc;
-  key_id = 0x07 & m_key_id;
-  Logger::nas_mm().debug("Encoding NasKeySetIdentifier ...");
-}
+NasKeySetIdentifier::NasKeySetIdentifier() {}
 
 //------------------------------------------------------------------------------
-NasKeySetIdentifier::NasKeySetIdentifier(uint8_t tsc, uint8_t key_id) {
-  this->iei    = 0;
-  this->tsc    = 0x01 & tsc;
-  this->key_id = 0x07 & key_id;
-  Logger::nas_mm().debug("Encoding NasKeySetIdentifier???");
+NasKeySetIdentifier::NasKeySetIdentifier(
+    const uint8_t& iei, const uint8_t& tsc, const uint8_t& key_id) {
+  iei_    = iei;
+  tsc_    = 0x01 & tsc;
+  key_id_ = 0x07 & key_id;
 }
 
 //------------------------------------------------------------------------------
-NasKeySetIdentifier::NasKeySetIdentifier() {}
+NasKeySetIdentifier::NasKeySetIdentifier(
+    const uint8_t& tsc, const uint8_t& key_id) {
+  iei_    = 0;
+  tsc_    = 0x01 & tsc;
+  key_id_ = 0x07 & key_id;
+}
 
 //------------------------------------------------------------------------------
-NasKeySetIdentifier::~NasKeySetIdentifier(){};
+int NasKeySetIdentifier::encode2Buffer(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding NasKeySetIdentifier IE (IEI 0x%x)", iei_);
+  if (len < kType1IeSize) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%s octet)",
+        kType1IeSize);
+    return KEncodeDecodeError;
+  }
 
-//------------------------------------------------------------------------------
-int NasKeySetIdentifier::encode2buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("Encoding NasKeySetIdentifier IE IEI 0x%x", iei);
-  if (len < 1) {
-    Logger::nas_mm().error("len is less than one");
-    return -1;
-  } else {
   uint8_t octet         = 0;
-    if (!(iei & 0x0f)) {
-      octet = (0x0f) & ((tsc << 3) | key_id);
-      *buf  = octet;
-      Logger::nas_mm().debug(
-          "Encoded NasKeySetIdentifier IE (TSC 0x%x,Key_id 0x%x)", tsc, key_id);
-      return 1;
+  uint32_t encoded_size = 0;
+
+  if (!(iei_ & 0x0f)) {
+    octet = (0x0f) & ((tsc_ << 3) | key_id_);
+    ENCODE_U8(buf, octet, encoded_size);
   } else {
-      octet = (iei << 4) | (tsc << 3) | key_id;
-      *buf  = octet;
-      Logger::nas_mm().debug("Encoded NasKeySetIdentifier IE (len 1 octet)");
-      Logger::nas_mm().debug(
-          "Encoded NasKeySetIdentifier IE (TSC 0x%x, Key_id 0x%x)", tsc,
-          key_id);
-      return 1;
-    }
+    octet = (iei_ << 4) | (tsc_ << 3) | key_id_;
+    ENCODE_U8(buf, octet, encoded_size);
   }
+  Logger::nas_mm().debug(
+      "Encoded NasKeySetIdentifier IE (TSC 0x%x, Key_id 0x%x)", tsc_, key_id_);
+  return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int NasKeySetIdentifier::decodefrombuffer(
+int NasKeySetIdentifier::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option, bool is_high) {
   Logger::nas_mm().debug("Decoding NasKeySetIdentifier IE");
-  if (len < 1) {
-    Logger::nas_mm().error("len is less than one");
-    return -1;
-  } else {
-    uint8_t octet = (*buf);
+
+  if (len < kType1IeSize) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%s octet)",
+        kType1IeSize);
+    return KEncodeDecodeError;
+  }
+  uint32_t decoded_size = 0;
+  uint8_t octet         = 0;
+  DECODE_U8(buf, octet, decoded_size);
+
   if (is_option) {
-      iei = (octet & 0xf0) >> 4;
+    iei_ = (octet & 0xf0) >> 4;
   } else {
-      iei = 0;
+    iei_ = 0;
   }
+
   if (!is_high) {
-      tsc    = octet & 0x08;
-      key_id = octet & 0x07;
+    tsc_    = octet & 0x08;
+    key_id_ = octet & 0x07;
   } else {
-      tsc    = (octet & 0x80) >> 4;
-      key_id = (octet & 0x70) >> 4;
+    tsc_    = (octet & 0x80) >> 4;
+    key_id_ = (octet & 0x70) >> 4;
   }
+
   Logger::nas_mm().debug(
-        "Decoded NasKeySetIdentifier IE (TSC 0x%x, Key_id 0x%x)", tsc, key_id);
-    if (iei)
+      "Decoded NasKeySetIdentifier IE (TSC 0x%x, Key_id 0x%x)", tsc_, key_id_);
+  if (iei_)
     return 1;
   else
-      return 0;
-  }
+    return 0;  // 1/2 octet
 }
 
 //------------------------------------------------------------------------------
 void NasKeySetIdentifier::setTypeOfSecurityContext(uint8_t type) {
-  tsc = 0x01 & type;
+  tsc_ = 0x01 & type;
 }
 
 //------------------------------------------------------------------------------
 void NasKeySetIdentifier::setNasKeyIdentifier(uint8_t id) {
-  key_id = 0x07 & id;
+  key_id_ = 0x07 & id;
 }
 
 //------------------------------------------------------------------------------
 uint8_t NasKeySetIdentifier::getTypeOfSecurityContext() {
-  return tsc;
+  return tsc_;
 }
 
 //------------------------------------------------------------------------------
 uint8_t NasKeySetIdentifier::getasKeyIdentifier() {
-  return key_id;
+  return key_id_;
 }

src/nas/ies/NasKeySetIdentifier.hpp

@@ -19,15 +19,8 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#ifndef _NasKeySetIdentifier_H
-#define _NasKeySetIdentifier_H
+#ifndef _NAS_KEY_SET_IDENTIFIER_H
+#define _NAS_KEY_SET_IDENTIFIER_H
 
 #include <stdint.h>
 
@@ -36,12 +29,13 @@ namespace nas {
 class NasKeySetIdentifier {
  public:
   NasKeySetIdentifier();
-  NasKeySetIdentifier(const uint8_t iei, uint8_t tsc, uint8_t key_id);
-  NasKeySetIdentifier(uint8_t tsc, uint8_t key_id);
+  NasKeySetIdentifier(
+      const uint8_t& iei, const uint8_t& tsc, const uint8_t& key_id);
+  NasKeySetIdentifier(const uint8_t& tsc, const uint8_t& key_id);
   ~NasKeySetIdentifier();
 
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option, bool is_high);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option, bool is_high);
 
   void setTypeOfSecurityContext(uint8_t type);
   void setNasKeyIdentifier(uint8_t id);
@@ -49,9 +43,9 @@ class NasKeySetIdentifier {
   uint8_t getasKeyIdentifier();
 
  private:
-  uint8_t iei;
-  uint8_t tsc;
-  uint8_t key_id;
+  uint8_t iei_;
+  uint8_t tsc_;
+  uint8_t key_id_;
 };
 
 }  // namespace nas

src/nas/ies/NasMessageType.cpp

@@ -21,14 +21,15 @@
 
 #include "NasMessageType.hpp"
 
-#include "3gpp_ts24501.hpp"
+#include "3gpp_24.501.hpp"
 #include "common_defs.h"
 #include "logger.hpp"
 
 using namespace nas;
 
 //------------------------------------------------------------------------------
-NasMessageType::NasMessageType() {}
+NasMessageType::NasMessageType(const uint8_t& message_type)
+    : message_type_(message_type) {}
 
 //------------------------------------------------------------------------------
 NasMessageType::~NasMessageType() {}
@@ -49,10 +50,11 @@ uint8_t NasMessageType::Get() const {
 }
 
 //------------------------------------------------------------------------------
-uint32_t NasMessageType::Encode(uint8_t* buf, uint32_t len) {
-  if (len < kNasMessageTypeIeSize) {
+int NasMessageType::Encode(uint8_t* buf, const uint32_t& len) {
+  if (len < kType1IeSize) {
     Logger::nas_mm().error(
-        "Buffer length is less than %d octet", kNasMessageTypeIeSize);
+        "Buffer length is less than the minimum length of this IE (%s octet)",
+        kType1IeSize);
     return KEncodeDecodeError;
   }
   uint32_t encoded_size = 0;
@@ -61,10 +63,11 @@ uint32_t NasMessageType::Encode(uint8_t* buf, uint32_t len) {
 }
 
 //------------------------------------------------------------------------------
-uint32_t NasMessageType::Decode(const uint8_t* const buf, uint32_t len) {
-  if (len < kNasMessageTypeIeSize) {
+int NasMessageType::Decode(const uint8_t* const buf, const uint32_t& len) {
+  if (len < kType1IeSize) {
     Logger::nas_mm().error(
-        "Buffer length is less than %s octet", kNasMessageTypeIeSize);
+        "Buffer length is less than the minimum length of this IE (%s octet)",
+        kType1IeSize);
     return KEncodeDecodeError;
   }
   uint32_t decoded_size = 0;

src/nas/ies/NasMessageType.hpp

@@ -30,15 +30,16 @@ namespace nas {
 
 class NasMessageType {
  public:
-  NasMessageType();
+  NasMessageType(){};  // TODO: = delete;
+  NasMessageType(const uint8_t& message_type);
   virtual ~NasMessageType();
 
   void Set(const uint8_t& message_type);
   void Get(uint8_t& message_type) const;
   uint8_t Get() const;
 
-  uint32_t Encode(uint8_t* buf, uint32_t len);
-  uint32_t Decode(const uint8_t* const buf, uint32_t len);
+  int Encode(uint8_t* buf, const uint32_t& len);
+  int Decode(const uint8_t* const buf, const uint32_t& len);
 
  private:
   uint8_t message_type_;

src/nas/ies/Network_Slicing_Indication.cpp

@@ -74,7 +74,7 @@ bool Network_Slicing_Indication::getNSSCI() {
 }
 
 //------------------------------------------------------------------------------
-int Network_Slicing_Indication::encode2buffer(uint8_t* buf, int len) {
+int Network_Slicing_Indication::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "Encoding Network_Slicing_Indication iei (0x%x)", _iei);
   if (len < 1) {
@@ -101,7 +101,7 @@ int Network_Slicing_Indication::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Network_Slicing_Indication::decodefrombuffer(
+int Network_Slicing_Indication::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   if (len < 1) {
     Logger::nas_mm().error("Len is less than one");

src/nas/ies/Network_Slicing_Indication.hpp

@@ -39,8 +39,8 @@ class Network_Slicing_Indication {
   Network_Slicing_Indication(uint8_t iei);
   Network_Slicing_Indication(const uint8_t iei, bool dcni, bool nssci);
   ~Network_Slicing_Indication();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setDCNI(bool value);
   void setNSSCI(bool value);
   bool getDCNI();

src/nas/ies/Non_3GPP_NW_Provided_Policies.cpp

@@ -55,7 +55,7 @@ uint8_t Non_3GPP_NW_Provided_Policies::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int Non_3GPP_NW_Provided_Policies::encode2buffer(uint8_t* buf, int len) {
+int Non_3GPP_NW_Provided_Policies::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "Encoding Non_3GPP_NW_Provided_Policies IE iei(0x%x)", _iei);
   if (len < 1) {
@@ -80,7 +80,7 @@ int Non_3GPP_NW_Provided_Policies::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Non_3GPP_NW_Provided_Policies::decodefrombuffer(
+int Non_3GPP_NW_Provided_Policies::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding Non_3GPP_NW_Provided_Policies IE");
   if (len < 1) {

src/nas/ies/Non_3GPP_NW_Provided_Policies.hpp

@@ -38,8 +38,8 @@ class Non_3GPP_NW_Provided_Policies {
   Non_3GPP_NW_Provided_Policies();
   Non_3GPP_NW_Provided_Policies(const uint8_t iei, uint8_t value);
   ~Non_3GPP_NW_Provided_Policies();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(const uint8_t value);
   uint8_t getValue();
 

src/nas/ies/PDU_Session_Identity_2.cpp

@@ -64,7 +64,7 @@ uint8_t PDU_Session_Identity_2::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Identity_2::encode2buffer(uint8_t* buf, int len) {
+int PDU_Session_Identity_2::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding PDU_Session_Identity_2 iei(0x%x)", _iei);
   if (len < 2) {
     Logger::nas_mm().error("len is less than 2");
@@ -86,7 +86,7 @@ int PDU_Session_Identity_2::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Identity_2::decodefrombuffer(
+int PDU_Session_Identity_2::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding PDU_Session_Identity_2 iei(0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/PDU_Session_Identity_2.hpp

@@ -39,8 +39,8 @@ class PDU_Session_Identity_2 {
   PDU_Session_Identity_2(uint8_t iei);
   PDU_Session_Identity_2(const uint8_t iei, uint8_t value);
   ~PDU_Session_Identity_2();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t value);
   uint8_t getValue();
 

src/nas/ies/PDU_Session_Reactivation_Result.cpp

@@ -68,7 +68,7 @@ uint16_t PDU_Session_Reactivation_Result::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Reactivation_Result::encode2buffer(uint8_t* buf, int len) {
+int PDU_Session_Reactivation_Result::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "encoding PDU_Session_Reactivation_Result iei(0x%x)", _iei);
   if (len < length) {
@@ -95,7 +95,7 @@ int PDU_Session_Reactivation_Result::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Reactivation_Result::decodefrombuffer(
+int PDU_Session_Reactivation_Result::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug(
       "decoding PDU_Session_Reactivation_Result iei(0x%x)", *buf);

src/nas/ies/PDU_Session_Reactivation_Result.hpp

@@ -40,8 +40,8 @@ class PDU_Session_Reactivation_Result {
   PDU_Session_Reactivation_Result(const uint8_t iei, uint16_t value);
   ~PDU_Session_Reactivation_Result();
   void setValue(uint8_t iei, uint16_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint16_t getValue();
 
  private:

src/nas/ies/PDU_Session_Reactivation_Result_Error_Cause.cpp

@@ -76,7 +76,7 @@ uint8_t PDU_Session_Reactivation_Result_Error_Cause::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Reactivation_Result_Error_Cause::encode2buffer(
+int PDU_Session_Reactivation_Result_Error_Cause::encode2Buffer(
     uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "encoding PDU_Session_Reactivation_Result_Error_Cause iei(0x%x)", _iei);
@@ -108,7 +108,7 @@ int PDU_Session_Reactivation_Result_Error_Cause::encode2buffer(
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Reactivation_Result_Error_Cause::decodefrombuffer(
+int PDU_Session_Reactivation_Result_Error_Cause::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug(
       "decoding PDU_Session_Reactivation_Result_Error_Cause iei(0x%x)", *buf);

src/nas/ies/PDU_Session_Reactivation_Result_Error_Cause.hpp

@@ -41,8 +41,8 @@ class PDU_Session_Reactivation_Result_Error_Cause {
       const uint8_t iei, uint8_t session_id, uint8_t value);
   ~PDU_Session_Reactivation_Result_Error_Cause();
   void setValue(uint8_t session_id, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint8_t getValue();
 
  private:

src/nas/ies/PDU_Session_Status.cpp

@@ -68,7 +68,7 @@ uint16_t PDU_Session_Status::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Status::encode2buffer(uint8_t* buf, int len) {
+int PDU_Session_Status::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding PDU_Session_Status iei(0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("len is less than %d", length);
@@ -93,7 +93,7 @@ int PDU_Session_Status::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Status::decodefrombuffer(
+int PDU_Session_Status::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding PDU_Session_Status iei(0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/PDU_Session_Status.hpp

@@ -40,8 +40,8 @@ class PDU_Session_Status {
   PDU_Session_Status(const uint8_t iei, uint16_t value);
   ~PDU_Session_Status();
   void setValue(uint8_t iei, uint16_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint16_t getValue();
 
  private:

src/nas/ies/PLMN_List.cpp

@@ -93,7 +93,7 @@ uint8_t PLMN_List::getMNC_MCC3() {
 }
 
 //------------------------------------------------------------------------------
-int PLMN_List::encode2buffer(uint8_t* buf, int len) {
+int PLMN_List::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding PLMN_List iei(0x%x)", _iei);
   if (len < 5) {
     Logger::nas_mm().error("len is less than 5");
@@ -120,7 +120,7 @@ int PLMN_List::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int PLMN_List::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int PLMN_List::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding PLMN_List iei(0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/PLMN_List.hpp

@@ -43,8 +43,8 @@ class PLMN_List {
   void setMNC_MCC1(uint8_t iei, uint8_t value);
   void setMNC_MCC2(uint8_t iei, uint8_t value);
   void setMNC_MCC3(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint8_t getMNC_MCC1();
   uint8_t getMNC_MCC2();
   uint8_t getMNC_MCC3();

src/nas/ies/Payload_Container.cpp

@@ -91,7 +91,7 @@ void Payload_Container::getValue(bstring& cnt) {
 }
 
 //------------------------------------------------------------------------------
-int Payload_Container::encode2buffer(uint8_t* buf, int len) {
+int Payload_Container::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding Payload_Container iei(0x%x)", _iei);
   if (len < length) {
     // Logger::nas_mm().error("len is less than %d", length);
@@ -163,12 +163,12 @@ int Payload_Container::encode2buffer(uint8_t* buf, int len) {
 
 //------------------------------------------------------------------------------
 
-int Payload_Container::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int Payload_Container::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   return 0;
 }
 
 //------------------------------------------------------------------------------
-int Payload_Container::decodefrombuffer(
+int Payload_Container::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option, uint8_t type) {
   Logger::nas_mm().debug("Decoding Payload_Container iei (0x%x)", _iei);
   int decoded_size = 0;

src/nas/ies/Payload_Container.hpp

@@ -49,9 +49,9 @@ class Payload_Container {
       const uint8_t iei, std::vector<PayloadContainerEntry> content);
   ~Payload_Container();
   void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option, uint8_t type);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option, uint8_t type);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void getValue(std::vector<PayloadContainerEntry>& content);
   void getValue(bstring& cnt);
 

src/nas/ies/Payload_Container_Type.cpp

@@ -55,7 +55,7 @@ uint8_t Payload_Container_Type::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int Payload_Container_Type::encode2buffer(uint8_t* buf, int len) {
+int Payload_Container_Type::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding Payload_Container_Type IE iei(0x%x)", _iei);
   if (len < 1) {
     Logger::nas_mm().error("len is less than one");
@@ -78,7 +78,7 @@ int Payload_Container_Type::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Payload_Container_Type::decodefrombuffer(
+int Payload_Container_Type::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding Payload_Container_Type IE");
   if (len < 1) {

src/nas/ies/Payload_Container_Type.hpp

@@ -38,8 +38,8 @@ class Payload_Container_Type {
   Payload_Container_Type();
   Payload_Container_Type(const uint8_t iei, uint8_t value);
   ~Payload_Container_Type();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(const uint8_t value);
   uint8_t getValue();
 

src/nas/ies/Rejected_NSSAI.cpp

@@ -82,7 +82,7 @@ uint8_t Rejected_NSSAI::getSST() {
 }
 
 //------------------------------------------------------------------------------
-int Rejected_NSSAI::encode2buffer(uint8_t* buf, int len) {
+int Rejected_NSSAI::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding Rejected_NSSAI iei(0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("len is less than %d", length);
@@ -107,7 +107,7 @@ int Rejected_NSSAI::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Rejected_NSSAI::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int Rejected_NSSAI::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding Rejected_NSSAI iei(0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/Rejected_NSSAI.hpp

@@ -40,8 +40,8 @@ class Rejected_NSSAI {
   ~Rejected_NSSAI();
   void setSST(uint8_t SST);
   void setCause(uint8_t SST);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint8_t getSST();
   uint8_t getCause();
 

src/nas/ies/Release_Assistance_Indication.cpp

@@ -64,7 +64,7 @@ uint8_t Release_Assistance_Indication::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int Release_Assistance_Indication::encode2buffer(uint8_t* buf, int len) {
+int Release_Assistance_Indication::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "encoding Release_Assistance_Indication iei(0x%x)", _iei);
   if (len < 1) {
@@ -85,7 +85,7 @@ int Release_Assistance_Indication::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Release_Assistance_Indication::decodefrombuffer(
+int Release_Assistance_Indication::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug(
       "decoding Release_Assistance_Indication iei(0x%x)", *buf);

src/nas/ies/Release_Assistance_Indication.hpp

@@ -39,8 +39,8 @@ class Release_Assistance_Indication {
   Release_Assistance_Indication(uint8_t iei);
   Release_Assistance_Indication(const uint8_t iei, uint8_t value);
   ~Release_Assistance_Indication();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t value);
   uint8_t getValue();
 

src/nas/ies/Request_Type.cpp

@@ -63,7 +63,7 @@ uint8_t Request_Type::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int Request_Type::encode2buffer(uint8_t* buf, int len) {
+int Request_Type::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding Request_Type iei(0x%x)", _iei);
   if (len < 1) {
     Logger::nas_mm().error("len is less than 1");
@@ -82,7 +82,7 @@ int Request_Type::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Request_Type::decodefrombuffer(uint8_t* buf, int len, bool is_option) {
+int Request_Type::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding Request_Type iei(0x%x)", *buf);
   int decoded_size = 0;
   uint8_t octet    = 0;

src/nas/ies/Request_Type.hpp

@@ -39,8 +39,8 @@ class Request_Type {
   Request_Type(uint8_t iei);
   Request_Type(const uint8_t iei, uint8_t value);
   ~Request_Type();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t value);
   uint8_t getValue();
 

src/nas/ies/S1_UE_Security_Capability.cpp

@@ -86,7 +86,7 @@ uint8_t S1_UE_Security_Capability::getEIASel() {
 }
 
 //------------------------------------------------------------------------------
-int S1_UE_Security_Capability::encode2buffer(uint8_t* buf, int len) {
+int S1_UE_Security_Capability::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding S1_UE_Security_Capability iei(0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("len is less than %d", length);
@@ -112,7 +112,7 @@ int S1_UE_Security_Capability::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int S1_UE_Security_Capability::decodefrombuffer(
+int S1_UE_Security_Capability::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding S1_UE_Security_Capability iei(0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/S1_UE_Security_Capability.hpp

@@ -44,8 +44,8 @@ class S1_UE_Security_Capability {
   void setEIASel(uint8_t sel);
   uint8_t getEEASel();
   uint8_t getEIASel();
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
 
  private:
   uint8_t _iei;

src/nas/ies/SOR_Transparent_Container.cpp

@@ -64,7 +64,7 @@ uint8_t SOR_Transparent_Container::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int SOR_Transparent_Container::encode2buffer(uint8_t* buf, int len) {
+int SOR_Transparent_Container::encode2Buffer(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding SOR_Transparent_Container iei(0x%x)", _iei);
   if (len < 18) {
     Logger::nas_mm().error("len is less than 18");
@@ -94,7 +94,7 @@ int SOR_Transparent_Container::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int SOR_Transparent_Container::decodefrombuffer(
+int SOR_Transparent_Container::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding SOR_Transparent_Container iei(0x%x)", *buf);
   int decoded_size = 0;

src/nas/ies/SOR_Transparent_Container.hpp

@@ -40,8 +40,8 @@ class SOR_Transparent_Container {
   SOR_Transparent_Container(const uint8_t iei, uint8_t header, uint8_t* value);
   ~SOR_Transparent_Container();
   // void setValue(uint8_t iei, uint8_t value);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, bool is_option);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   uint8_t getValue();
 
  private:

src/nas/ies/S_NSSAI.cpp

@@ -172,7 +172,7 @@ std::string S_NSSAI::ToString() {
 }
 
 //------------------------------------------------------------------------------
-int S_NSSAI::encode2buffer(uint8_t* buf, int len) {
+int S_NSSAI::encode2Buffer(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);
@@ -207,7 +207,7 @@ int S_NSSAI::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int S_NSSAI::decodefrombuffer(uint8_t* buf, int len, const bool is_option) {
+int S_NSSAI::decodeFromBuffer(uint8_t* buf, int len, const bool is_option) {
   Logger::nas_mm().debug("Decoding S_NSSAI");
   int decoded_size = {0};
 

src/nas/ies/S_NSSAI.hpp

@@ -43,8 +43,8 @@ class S_NSSAI {
   S_NSSAI(std::optional<uint8_t> iei, SNSSAI_s snssai);
   ~S_NSSAI();
   // void setS_NSSAI(SNSSAI_s snssai);
-  int encode2buffer(uint8_t* buf, int len);
-  int decodefrombuffer(uint8_t* buf, int len, const bool is_option = true);
+  int encode2Buffer(uint8_t* buf, int len);
+  int decodeFromBuffer(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,

src/nas/ies/SecurityHeaderType.cpp

@@ -21,7 +21,7 @@
 
 #include "SecurityHeaderType.hpp"
 
-#include "3gpp_ts24501.hpp"
+#include "3gpp_24.501.hpp"
 #include "common_defs.h"
 #include "logger.hpp"
 
@@ -51,10 +51,11 @@ uint8_t SecurityHeaderType::Get() const {
 }
 
 //------------------------------------------------------------------------------
-uint32_t SecurityHeaderType::Encode(uint8_t* buf, uint32_t len) {
-  if (len < kSecurityHeaderIeSize) {
+int SecurityHeaderType::Encode(uint8_t* buf, const uint32_t& len) {
+  if (len < kType1IeSize) {
     Logger::nas_mm().error(
-        "Buffer length is less than %d octet", kSecurityHeaderIeSize);
+        "Buffer length is less than the minimum length of this IE (%s octet)",
+        kType1IeSize);
     return KEncodeDecodeError;
   }
   uint8_t value = (secu_header_type_ & 0x0f) | (spare_ & 0xf0);
@@ -65,13 +66,14 @@ uint32_t SecurityHeaderType::Encode(uint8_t* buf, uint32_t len) {
 }
 
 //------------------------------------------------------------------------------
-uint32_t SecurityHeaderType::Decode(const uint8_t* const buf, uint32_t len) {
-  if (len < kSecurityHeaderIeSize) {
+int SecurityHeaderType::Decode(const uint8_t* const buf, const uint32_t& len) {
+  if (len < kType1IeSize) {
     Logger::nas_mm().error(
-        "Buffer length is less than %s octet", kSecurityHeaderIeSize);
+        "Buffer length is less than the minimum length of this IE (%s octet)",
+        kType1IeSize);
     return KEncodeDecodeError;
   }
-  uint8_t value;
+  uint8_t value         = 0;
   uint32_t decoded_size = 0;
   DECODE_U8(buf, value, decoded_size);
 

src/nas/ies/SecurityHeaderType.hpp

@@ -24,8 +24,6 @@
 
 #include <stdint.h>
 
-constexpr uint8_t kSecurityHeaderIeSize = 1;
-
 namespace nas {
 
 class SecurityHeaderType {
@@ -37,8 +35,8 @@ class SecurityHeaderType {
   void Get(uint8_t& secu_header_type) const;
   uint8_t Get() const;
 
-  uint32_t Encode(uint8_t* buf, uint32_t len);
-  uint32_t Decode(const uint8_t* const buf, uint32_t len);
+  int Encode(uint8_t* buf, const uint32_t& len);
+  int Decode(const uint8_t* const buf, const uint32_t& len);
 
  private:
   uint8_t spare_ : 4;

src/nas/ies/ServiceType.cpp

@@ -42,7 +42,7 @@ ServiceType::ServiceType(uint8_t iei, uint8_t stp) {
 }
 
 //------------------------------------------------------------------------------
-int ServiceType::encode2buffer(uint8_t* buf, int len) {
+int ServiceType::encode2Buffer(uint8_t* buf, int len) {
   if (len < 1) return -1;
   int encoded_size = 0;
   if (_iei) {
@@ -58,7 +58,7 @@ int ServiceType::encode2buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int ServiceType::decodefrombuffer(
+int ServiceType::decodeFromBuffer(
     uint8_t* buf, int len, bool is_optional, bool is_high) {
   if (len < 1) return -1;
   if (is_optional) {