Update Encode/Decode msg

src/amf-app/amf_app.cpp

@@ -356,7 +356,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->Encode(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_n2.cpp

@@ -295,7 +295,7 @@ void amf_n2::handle_itti_message(itti_paging& itti_msg) {
   paging_msg.setTAIListForPaging(list);
 
   uint8_t buffer[BUFFER_SIZE_512];
-  int encoded_size = paging_msg.encode2Buffer(buffer, BUFFER_SIZE_512);
+  int encoded_size = paging_msg.Encode(buffer, BUFFER_SIZE_512);
   bstring b        = blk2bstr(buffer, encoded_size);
 
   amf_n2_inst->sctp_s_38412.sctp_send_msg(
@@ -385,8 +385,7 @@ void amf_n2::handle_itti_message(
     uint8_t* buffer = (uint8_t*) calloc(1, BUFFER_SIZE_1024);
     NGSetupFailureMsg ngSetupFailure;
     ngSetupFailure.set(Ngap_CauseRadioNetwork_unspecified, Ngap_TimeToWait_v5s);
-    int encoded =
-        ngSetupFailure.encode2Buffer((uint8_t*) buffer, BUFFER_SIZE_1024);
+    int encoded = ngSetupFailure.Encode((uint8_t*) buffer, BUFFER_SIZE_1024);
 
     if (encoded < 1) {
       Logger::amf_n2().error("Encode NG Setup Failure message error!");
@@ -442,7 +441,7 @@ void amf_n2::handle_itti_message(
   }
 
   ngSetupResp.setPlmnSupportList(plmn_list);
-  int encoded = ngSetupResp.encode2Buffer((uint8_t*) buffer, BUFFER_SIZE_1024);
+  int encoded = ngSetupResp.Encode((uint8_t*) buffer, BUFFER_SIZE_1024);
 
   if (encoded < 1) {
     Logger::amf_n2().error("Encode NG Setup Response message error!");
@@ -522,7 +521,7 @@ void amf_n2::handle_itti_message(itti_ng_reset& itti_msg) {
   }
 
   uint8_t buffer[BUFFER_SIZE_512];
-  int encoded_size = ng_reset_ack->encode2Buffer(buffer, BUFFER_SIZE_512);
+  int encoded_size = ng_reset_ack->Encode(buffer, BUFFER_SIZE_512);
 
   bstring b = blk2bstr(buffer, encoded_size);
   sctp_s_38412.sctp_send_msg(gc->sctp_assoc_id, itti_msg.stream, &b);
@@ -674,7 +673,7 @@ void amf_n2::handle_itti_message(itti_initial_ue_message& init_ue_msg) {
         "Store InitialUEMessage for Reroute NAS (if necessary)");
     uint8_t* initial_ue_msg_buf = (uint8_t*) calloc(1, BUFFER_SIZE_1024);
     int encoded_size            = 0;
-    init_ue_msg.initUeMsg->encode2Buffer(initial_ue_msg_buf, encoded_size);
+    init_ue_msg.initUeMsg->Encode(initial_ue_msg_buf, encoded_size);
 
     if (encoded_size > 0) {
       Logger::amf_n2().debug("Encoded InitialUEMessage size %d", encoded_size);
@@ -800,7 +799,7 @@ void amf_n2::handle_itti_message(itti_dl_nas_transport& dl_nas_transport) {
   ngap_msg->setNasPdu(dl_nas_transport.nas);
 
   uint8_t buffer[BUFFER_SIZE_1024];
-  int encoded_size = ngap_msg->encode2Buffer(buffer, BUFFER_SIZE_1024);
+  int encoded_size = ngap_msg->Encode(buffer, BUFFER_SIZE_1024);
   bstring b        = blk2bstr(buffer, encoded_size);
   sctp_s_38412.sctp_send_msg(gc->sctp_assoc_id, unc->sctp_stream_send, &b);
   bdestroy_wrapper(&b);
@@ -937,7 +936,7 @@ void amf_n2::handle_itti_message(itti_initial_context_setup_request& itti_msg) {
   }
 
   uint8_t buffer[BUFFER_SIZE_2048];
-  int encoded_size = msg->encode2Buffer(buffer, BUFFER_SIZE_2048);
+  int encoded_size = msg->Encode(buffer, BUFFER_SIZE_2048);
   bstring b        = blk2bstr(buffer, encoded_size);
   sctp_s_38412.sctp_send_msg(gc->sctp_assoc_id, unc->sctp_stream_send, &b);
   bdestroy_wrapper(&b);
@@ -1150,7 +1149,7 @@ void amf_n2::handle_itti_message(itti_ue_context_release_request& itti_msg) {
   ueCtxRelCmd->setCauseRadioNetwork(cause);
 
   uint8_t buffer[BUFFER_SIZE_512];
-  int encoded_size = ueCtxRelCmd->encode2Buffer(buffer, BUFFER_SIZE_512);
+  int encoded_size = ueCtxRelCmd->Encode(buffer, BUFFER_SIZE_512);
   bstring b        = blk2bstr(buffer, encoded_size);
 
   sctp_s_38412.sctp_send_msg(itti_msg.assoc_id, itti_msg.stream, &b);
@@ -1192,7 +1191,7 @@ void amf_n2::handle_itti_message(itti_ue_context_release_command& itti_msg) {
   }
 
   uint8_t buffer[BUFFER_SIZE_256];
-  int encoded_size = ueCtxRelCmd->encode2Buffer(buffer, BUFFER_SIZE_256);
+  int encoded_size = ueCtxRelCmd->Encode(buffer, BUFFER_SIZE_256);
 
   bstring b = blk2bstr(buffer, encoded_size);
   sctp_s_38412.sctp_send_msg(gc->sctp_assoc_id, unc->sctp_stream_send, &b);
@@ -1682,7 +1681,7 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) {
   handover_request->setPduSessionResourceSetupList(list);
 
   uint8_t buffer[BUFFER_SIZE_4096];
-  int encoded_size = handover_request->encode2Buffer(buffer, BUFFER_SIZE_4096);
+  int encoded_size = handover_request->Encode(buffer, BUFFER_SIZE_4096);
   bstring b        = blk2bstr(buffer, encoded_size);
   std::shared_ptr<gnb_context> gc_target = {};
   gc_target                              = gnb_id_2_gnb_context(gnb_id_value);
@@ -1843,7 +1842,7 @@ void amf_n2::handle_itti_message(itti_handover_request_Ack& itti_msg) {
   handovercommand->setTargetToSource_TransparentContainer(targetTosource);
 
   uint8_t buffer[BUFFER_SIZE_1024];
-  int encoded_size = handovercommand->encode2Buffer(buffer, BUFFER_SIZE_1024);
+  int encoded_size = handovercommand->Encode(buffer, BUFFER_SIZE_1024);
   bstring b        = blk2bstr(buffer, encoded_size);
   sctp_s_38412.sctp_send_msg(unc->gnb_assoc_id, 0, &b);
   bdestroy_wrapper(&b);
@@ -1980,9 +1979,8 @@ void amf_n2::handle_itti_message(itti_handover_notify& itti_msg) {
       Ngap_CauseRadioNetwork_successful_handover);
 
   uint8_t buffer[BUFFER_SIZE_1024];
-  int encoded_size =
-      ueContextReleaseCommand->encode2Buffer(buffer, BUFFER_SIZE_1024);
-  bstring b = blk2bstr(buffer, encoded_size);
+  int encoded_size = ueContextReleaseCommand->Encode(buffer, BUFFER_SIZE_1024);
+  bstring b        = blk2bstr(buffer, encoded_size);
 
   sctp_s_38412.sctp_send_msg(unc->gnb_assoc_id, 0, &b);
   bdestroy_wrapper(&b);
@@ -2060,9 +2058,8 @@ void amf_n2::handle_itti_message(itti_uplink_ran_status_transfer& itti_msg) {
   dl_ran_status_transfer->setRANStatusTransfer_TransparentContainer(
       amf_drb_id, amf_ul_pdcp, amf_hfn_ul_pdcp, amf_dl_pdcp, amf_hfn_dl_pdcp);
   uint8_t buffer[BUFFER_SIZE_1024];
-  int encode_size =
-      dl_ran_status_transfer->encode2Buffer(buffer, BUFFER_SIZE_1024);
-  bstring b = blk2bstr(buffer, encode_size);
+  int encode_size = dl_ran_status_transfer->Encode(buffer, BUFFER_SIZE_1024);
+  bstring b       = blk2bstr(buffer, encode_size);
   sctp_s_38412.sctp_send_msg(unc->target_gnb_assoc_id, 0, &b);
   bdestroy_wrapper(&b);
 }
@@ -2100,9 +2097,8 @@ void amf_n2::handle_itti_message(itti_rereoute_nas& itti_msg) {
   // TODO: AllowedNSSAI (Optional)
 
   uint8_t buffer[BUFFER_SIZE_2048];
-  int encoded_size =
-      reroute_nas_request.encode2Buffer(buffer, BUFFER_SIZE_2048);
-  bstring b = blk2bstr(buffer, encoded_size);
+  int encoded_size = reroute_nas_request.Encode(buffer, BUFFER_SIZE_2048);
+  bstring b        = blk2bstr(buffer, encoded_size);
 
   amf_n2_inst->sctp_s_38412.sctp_send_msg(
       unc->gnb_assoc_id, unc->sctp_stream_send, &b);
@@ -2122,7 +2118,7 @@ void amf_n2::send_handover_preparation_failure(
 
   uint8_t buffer[BUFFER_SIZE_1024];
   int encoded_size =
-      ho_preparation_failure_msg->encode2Buffer(buffer, BUFFER_SIZE_1024);
+      ho_preparation_failure_msg->Encode(buffer, BUFFER_SIZE_1024);
   bstring b = blk2bstr(buffer, encoded_size);
 
   sctp_s_38412.sctp_send_msg(gnb_assoc_id, 0, &b);

src/nas/ies/ABBA.cpp

@@ -61,7 +61,7 @@ uint8_t ABBA::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int ABBA::encode2Buffer(uint8_t* buf, int len) {
+int ABBA::Encode(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::Decode(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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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::Decode(
     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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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,8 +91,7 @@ int Additional_Information::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Additional_Information::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int Additional_Information::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding Additional_Information iei(0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   uint8_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::Encode(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::Decode(
     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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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::Decode(
     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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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::Decode(
     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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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::Decode(
     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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding DNN IEI (0x%x)", _iei);
   if (len < length) {
     Logger::nas_mm().error("len is less than %d", length);
@@ -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::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding DNN IEI (0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   void getValue(bstring& dnn);
 
  private:

src/nas/ies/EAP_Message.cpp

@@ -51,7 +51,7 @@ void EAP_Message::getValue(bstring& eap) {
 }
 
 //------------------------------------------------------------------------------
-int EAP_Message::encode2Buffer(uint8_t* buf, int len) {
+int EAP_Message::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding EAP_Message");
   if ((len < kEapMessageMinimumLength) or (len < length + 3)) {
     Logger::nas_mm().error(
@@ -70,7 +70,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::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding EAP_Message");
 
   if (len < kEapMessageMinimumLength) {

src/nas/ies/EAP_Message.hpp

@@ -41,8 +41,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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   void getValue(bstring& eap);
 
  private:

src/nas/ies/EPS_Bearer_Context_Status.cpp

@@ -60,7 +60,7 @@ uint16_t EPS_Bearer_Context_Status::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int EPS_Bearer_Context_Status::encode2Buffer(uint8_t* buf, int len) {
+int EPS_Bearer_Context_Status::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding EPS_Bearer_Context_Status");
   if (len < kEpsBearerContextStatusLength) {
     Logger::nas_mm().error(
@@ -84,8 +84,7 @@ int EPS_Bearer_Context_Status::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int EPS_Bearer_Context_Status::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int EPS_Bearer_Context_Status::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding EPS_Bearer_Context_Status");
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/EPS_Bearer_Context_Status.hpp

@@ -35,8 +35,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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   uint16_t getValue();
 
  private:

src/nas/ies/EPS_NAS_Message_Container.cpp

@@ -21,83 +21,85 @@
 
 #include "EPS_NAS_Message_Container.hpp"
 
+#include "Ie_Const.hpp"
 #include "3gpp_24.501.hpp"
 #include "common_defs.h"
 #include "logger.hpp"
 using namespace nas;
 
 //------------------------------------------------------------------------------
-EPS_NAS_Message_Container::EPS_NAS_Message_Container(uint8_t iei) : _value() {
-  _iei   = iei;
-  length = 0;
+EPS_NAS_Message_Container::EPS_NAS_Message_Container()
+    : Type6NasIe(kIeiEpsNasMessageContainer), _value() {
+  SetIeName(kEpsNasMessageContainerIeName);
 }
 
 //------------------------------------------------------------------------------
-EPS_NAS_Message_Container::EPS_NAS_Message_Container(
-    const uint8_t iei, bstring value) {
-  _iei   = iei;
+EPS_NAS_Message_Container::EPS_NAS_Message_Container(bstring value)
+    : Type6NasIe(kIeiEpsNasMessageContainer) {
   _value = bstrcpy(value);
-  length = blength(value) + 3;  // 1 for IEI, 2 for length
+  SetIeName(kEpsNasMessageContainerIeName);
+  SetLengthIndicator(blength(_value));
 }
 
-//------------------------------------------------------------------------------
-EPS_NAS_Message_Container::EPS_NAS_Message_Container()
-    : _iei(), length(), _value() {}
-
 //------------------------------------------------------------------------------
 EPS_NAS_Message_Container::~EPS_NAS_Message_Container() {}
 
 //------------------------------------------------------------------------------
-void EPS_NAS_Message_Container::setValue(uint8_t iei) {
-  _iei = iei;
-}
-
-//------------------------------------------------------------------------------
-void EPS_NAS_Message_Container::getValue(bstring& value) {
+void EPS_NAS_Message_Container::getValue(bstring& value) const {
   value = bstrcpy(_value);
 }
 
 //------------------------------------------------------------------------------
-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 + 3)) {
+int EPS_NAS_Message_Container::Encode(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
+
+  int ie_len = GetIeLength();
+
+  if (len < ie_len) {  // Length of the content + IEI/Len
     Logger::nas_mm().error(
-        "Buffer length is less than the length of this IE (%d octet)",
-        length + 3);
+        "Size of the buffer is not enough to store this IE (IE len %d)",
+        ie_len);
     return KEncodeDecodeError;
   }
 
   int encoded_size = 0;
-  if (_iei) {
-    ENCODE_U8(buf + encoded_size, _iei, encoded_size);
-  }
 
-  ENCODE_U16(buf + encoded_size, length, encoded_size);
+  // IEI and Length (later)
+  int len_pos = 0;
+  int encoded_header_size =
+      Type6NasIe::Encode(buf + encoded_size, len, len_pos);
+  if (encoded_header_size == KEncodeDecodeError) return KEncodeDecodeError;
+  encoded_size += encoded_header_size;
 
   int size = encode_bstring(_value, (buf + encoded_size), len - encoded_size);
   encoded_size += size;
 
+  // Encode length
+  int encoded_len_ie = 0;
+  ENCODE_U16(buf + len_pos, encoded_size - GetHeaderLength(), encoded_len_ie);
+
   Logger::nas_mm().debug(
-      "Encoded EPS_NAS_Message_Container (len %d)", encoded_size);
+      "Encoded %s, len (%d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int EPS_NAS_Message_Container::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int EPS_NAS_Message_Container::Decode(uint8_t* buf, int len, bool is_iei) {
   Logger::nas_mm().debug("Decoding EPS_NAS_Message_Container");
   int decoded_size = 0;
-  int result       = 0;
-  if (is_option) {
-    decoded_size++;
-  }
-  length = 0;
-  DECODE_U16(buf + decoded_size, length, decoded_size);
-  result =
-      decode_bstring(&_value, length, (buf + decoded_size), len - decoded_size);
-  decoded_size += length;
-  if (result == length) {
-    for (int i = 0; i < length; i++) {
+
+  // IEI and Length
+  uint16_t ie_len         = 0;
+  int decoded_header_size = Type6NasIe::Decode(buf + decoded_size, len, is_iei);
+  if (decoded_header_size == KEncodeDecodeError) return KEncodeDecodeError;
+  decoded_size += decoded_header_size;
+  ie_len = GetLengthIndicator();
+
+  int result =
+      decode_bstring(&_value, ie_len, (buf + decoded_size), len - decoded_size);
+  decoded_size += ie_len;
+  if (result == ie_len) {
+    for (int i = 0; i < ie_len; i++) {
       Logger::nas_mm().debug(
           "Decoded EPS_NAS_Message_Container value 0x%x",
           (uint8_t) _value->data[i]);
@@ -105,6 +107,6 @@ int EPS_NAS_Message_Container::decodeFromBuffer(
   }
 
   Logger::nas_mm().debug(
-      "Decoded EPS_NAS_Message_Container (Length %d)", decoded_size);
+      "Decoded EPS_NAS_Message_Container (len %d)", decoded_size);
   return decoded_size;
 }

src/nas/ies/EPS_NAS_Message_Container.hpp

@@ -19,33 +19,35 @@
  *      contact@openairinterface.org
  */
 
-#ifndef _EPS_NAS_Message_Container_H_
-#define _EPS_NAS_Message_Container_H_
+#ifndef _EPS_NAS_MESSAGE_CONTAINER_H_
+#define _EPS_NAS_MESSAGE_CONTAINER_H_
 
+#include "Type6NasIe.hpp"
 #include <stdint.h>
-#include <iostream>
 
 extern "C" {
 #include "TLVDecoder.h"
 #include "TLVEncoder.h"
 #include "bstrlib.h"
 }
+
+constexpr auto kEpsNasMessageContainerIeName = "EPS NAS Message Container";
+
 namespace nas {
 
-class EPS_NAS_Message_Container {
+class EPS_NAS_Message_Container : Type6NasIe {
  public:
   EPS_NAS_Message_Container();
-  EPS_NAS_Message_Container(uint8_t iei);
-  EPS_NAS_Message_Container(const uint8_t iei, bstring value);
+  EPS_NAS_Message_Container(bstring value);
   ~EPS_NAS_Message_Container();
-  void setValue(uint8_t iei);
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
-  void getValue(bstring& value);
+
+  // TODO: SetValue(const bstring& value)
+  void getValue(bstring& value) const;
+
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_iei);
 
  private:
-  uint8_t _iei;
-  uint16_t length;
   bstring _value;
 };
 

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::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "encoding EPS_NAS_Security_Algorithms iei(0x%x)", _iei);
   int encoded_size = 0;
@@ -89,8 +89,7 @@ int EPS_NAS_Security_Algorithms::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int EPS_NAS_Security_Algorithms::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int EPS_NAS_Security_Algorithms::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding EPS_NAS_Security_Algorithms IE");
   if (len < 2) {
     Logger::nas_mm().error("len is less than 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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
 
  private:
   uint8_t _iei;

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::Encode(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,8 +97,7 @@ int Extended_DRX_Parameters::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Extended_DRX_Parameters::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int Extended_DRX_Parameters::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding Extended_DRX_Parameters iei(0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

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 Encode(uint8_t* buf, int len);
+  int Decode(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

@@ -62,7 +62,7 @@ uint8_t GPRS_Timer_2::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int GPRS_Timer_2::encode2Buffer(uint8_t* buf, int len) {
+int GPRS_Timer_2::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding GPRS_Timer_2");
   if (len < kGprsTimer2Length) {
     Logger::nas_mm().error(
@@ -88,7 +88,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::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding GPRS_Timer_2");
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/GPRS_Timer_2.hpp

@@ -34,8 +34,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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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::Decode(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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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::Decode(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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t value);
   uint8_t getValue();
 

src/nas/ies/LADN_Indication.cpp

@@ -60,7 +60,7 @@ void LADN_Indication::getValue(std::vector<bstring>& ladn) {
 }
 
 //------------------------------------------------------------------------------
-int LADN_Indication::encode2Buffer(uint8_t* buf, int len) {
+int LADN_Indication::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding LADN_Indication (IEI 0x%x)", _iei);
 
   if ((len < length + 3) or (len < kLadnIndicationMinimumLength)) {
@@ -86,7 +86,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::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding LADN_Indication");
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/LADN_Indication.hpp

@@ -45,8 +45,8 @@ class LADN_Indication {
   LADN_Indication(const uint8_t iei, std::vector<bstring> ladn);
   ~LADN_Indication();
   void setValue(uint8_t iei);
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   void 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::Encode(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,8 +84,7 @@ int MA_PDU_Session_Information::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int MA_PDU_Session_Information::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int MA_PDU_Session_Information::Decode(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;
   uint8_t octet    = 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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t value);
   uint8_t getValue();
 

src/nas/ies/NAS_Message_Container.cpp

@@ -57,7 +57,7 @@ void NAS_Message_Container::getValue(bstring& value) {
 }
 
 //------------------------------------------------------------------------------
-int NAS_Message_Container::encode2Buffer(uint8_t* buf, int len) {
+int NAS_Message_Container::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding NAS_Message_Container IEI");
   if (len < kNasMessageContainerMinimumLength) {
     Logger::nas_mm().error(
@@ -82,8 +82,7 @@ int NAS_Message_Container::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int NAS_Message_Container::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int NAS_Message_Container::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding NAS_Message_Container");
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/NAS_Message_Container.hpp

@@ -41,8 +41,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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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,8 +81,7 @@ int NAS_Security_Algorithms::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int NAS_Security_Algorithms::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int NAS_Security_Algorithms::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding NAS_Security_Algorithms IE");
   if (len < 1) {
     Logger::nas_mm().error("len is less than one");

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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
 
  private:
   uint8_t CIPHERING;

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::Encode(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,8 +77,7 @@ int NSSAI_Inclusion_Mode::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int NSSAI_Inclusion_Mode::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int NSSAI_Inclusion_Mode::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding NSSAI_Inclusion_Mode IE");
   if (len < 1) {
     Logger::nas_mm().error("Len is less than one");

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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   void setValue(const uint8_t value);
   uint8_t getValue();
 

src/nas/ies/NasKeySetIdentifier.cpp

@@ -74,7 +74,7 @@ void NasKeySetIdentifier::GetValue() {
 
 /*
 //------------------------------------------------------------------------------
-int NasKeySetIdentifier::encode2Buffer(uint8_t* buf, const int& len) {
+int NasKeySetIdentifier::Encode(uint8_t* buf, const int& len) {
   Logger::nas_mm().debug("Encoding NasKeySetIdentifier IE");
   if (len < kType1IeSize) {
     Logger::nas_mm().error(
@@ -91,7 +91,7 @@ int NasKeySetIdentifier::encode2Buffer(uint8_t* buf, const int& len) {
 }
 
 //------------------------------------------------------------------------------
-int NasKeySetIdentifier::decodeFromBuffer(
+int NasKeySetIdentifier::Decode(
     uint8_t* buf, const int& len, bool is_option, bool is_high) {
   Logger::nas_mm().debug("Decoding NasKeySetIdentifier IE");
 

src/nas/ies/NetworkSlicingIndication.cpp

@@ -70,7 +70,7 @@ bool NetworkSlicingIndication::getNSSCI() {
 }
 
 //------------------------------------------------------------------------------
-int NetworkSlicingIndication::encode2Buffer(uint8_t* buf, int len) {
+int NetworkSlicingIndication::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding Network Slicing Indication");
 
   if (len < kNetworkSlicingIndicationLength) {
@@ -99,8 +99,7 @@ int NetworkSlicingIndication::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int NetworkSlicingIndication::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int NetworkSlicingIndication::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding Network Slicing Indication");
 
   if (len < kNetworkSlicingIndicationLength) {

src/nas/ies/NetworkSlicingIndication.hpp

@@ -35,8 +35,8 @@ class NetworkSlicingIndication {
   NetworkSlicingIndication(const uint8_t iei, bool dcni, bool nssci);
   ~NetworkSlicingIndication();
 
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
 
   void setDCNI(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::Encode(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::Decode(
     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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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,8 +86,7 @@ int PDU_Session_Identity_2::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Identity_2::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int PDU_Session_Identity_2::Decode(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;
   if (is_option) {

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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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::Decode(
     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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   uint16_t getValue();
 
  private:

src/nas/ies/PDU_Session_Reactivation_Result_Error_Cause.cpp

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

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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   uint8_t getValue();
 
  private:

src/nas/ies/PLMN_List.cpp

@@ -61,7 +61,7 @@ void PLMN_List::getPLMNList(std::vector<nas_plmn_t>& list) {
 }
 
 //------------------------------------------------------------------------------
-int PLMN_List::encode2Buffer(uint8_t* buf, int len) {
+int PLMN_List::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding PLMN_List");
 
   if (len < length) {
@@ -86,7 +86,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::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding PLMN_List");
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/PLMN_List.hpp

@@ -37,8 +37,8 @@ class PLMN_List {
   PLMN_List(uint8_t iei);
   ~PLMN_List();
 
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
 
   void set(uint8_t iei, const std::vector<nas_plmn_t>& list);
   void getPLMNList(std::vector<nas_plmn_t>& list);

src/nas/ies/Payload_Container.cpp

@@ -92,7 +92,7 @@ bool Payload_Container::getValue(bstring& cnt) {
 }
 
 //------------------------------------------------------------------------------
-int Payload_Container::encode2Buffer(uint8_t* buf, int len, uint8_t type) {
+int Payload_Container::Encode(uint8_t* buf, int len, uint8_t type) {
   Logger::nas_mm().debug("Encoding Payload_Container");
 
   if ((len < kPayloadContainerMinimumLength) or (len < length + 3)) {
@@ -153,7 +153,7 @@ int Payload_Container::encode2Buffer(uint8_t* buf, int len, uint8_t type) {
 }
 
 //------------------------------------------------------------------------------
-int Payload_Container::decodeFromBuffer(
+int Payload_Container::Decode(
     uint8_t* buf, int len, bool is_option, uint8_t type) {
   Logger::nas_mm().debug("Decoding Payload_Container");
 

src/nas/ies/Payload_Container.hpp

@@ -46,8 +46,8 @@ 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, uint8_t type);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option, uint8_t type);
+  int Encode(uint8_t* buf, int len, uint8_t type);
+  int Decode(uint8_t* buf, int len, bool is_option, uint8_t type);
   bool getValue(std::vector<PayloadContainerEntry>& content);
   bool getValue(bstring& cnt);
 

src/nas/ies/Payload_Container_Type.cpp

@@ -50,7 +50,7 @@ uint8_t Payload_Container_Type::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int Payload_Container_Type::encode2Buffer(uint8_t* buf, int len) {
+int Payload_Container_Type::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding Payload_Container_Type IE");
 
   if (len < kPayloadContainerTypeLength) {
@@ -74,8 +74,7 @@ int Payload_Container_Type::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int Payload_Container_Type::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int Payload_Container_Type::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding Payload_Container_Type IE");
 
   if (len < kPayloadContainerTypeLength) {

src/nas/ies/Payload_Container_Type.hpp

@@ -33,8 +33,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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   void setValue(const uint8_t value);
   uint8_t getValue();
 

src/nas/ies/Rejected_NSSAI.cpp

@@ -56,7 +56,7 @@ void Rejected_NSSAI::getRejectedSNSSAIs(std::vector<Rejected_SNSSAI>& nssais) {
 }
 //------------------------------------------------------------------------------
 
-int Rejected_NSSAI::encode2Buffer(uint8_t* buf, int len) {
+int Rejected_NSSAI::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding Rejected_NSSAI");
   uint8_t ie_len = 0;
   if (_iei) {
@@ -98,7 +98,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::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding Rejected_NSSAI");
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/Rejected_NSSAI.hpp

@@ -34,8 +34,8 @@ class Rejected_NSSAI {
   Rejected_NSSAI();
   Rejected_NSSAI(uint8_t iei);
   ~Rejected_NSSAI();
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   void setRejectedSNSSAIs(const std::vector<Rejected_SNSSAI>& nssais);
   void getRejectedSNSSAIs(std::vector<Rejected_SNSSAI>& nssais);
 

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::Encode(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::Decode(
     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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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::Decode(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 Encode(uint8_t* buf, int len);
+  int Decode(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::GetEia() {
 }
 
 //------------------------------------------------------------------------------
-int S1_UE_Security_Capability::encode2Buffer(uint8_t* buf, int len) {
+int S1_UE_Security_Capability::Encode(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,8 +112,7 @@ int S1_UE_Security_Capability::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int S1_UE_Security_Capability::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int S1_UE_Security_Capability::Decode(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;
   if (is_option) {

src/nas/ies/S1_UE_Security_Capability.hpp

@@ -44,8 +44,8 @@ class S1_UE_Security_Capability {
   void SetEia(uint8_t sel);
   uint8_t GetEea();
   uint8_t GetEia();
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+  int Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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,8 +94,7 @@ int SOR_Transparent_Container::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int SOR_Transparent_Container::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int SOR_Transparent_Container::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding SOR_Transparent_Container iei(0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

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 Encode(uint8_t* buf, int len);
+  int Decode(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::Encode(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::Decode(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

@@ -42,8 +42,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 Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, const bool is_option = true);
 
   void getValue(SNSSAI_t& snssai);
   void SetSNSSAI(

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::Encode(uint8_t* buf, int len) {
   if (len < 1) return -1;
   int encoded_size = 0;
   if (_iei) {
@@ -58,8 +58,7 @@ int ServiceType::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int ServiceType::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_optional, bool is_high) {
+int ServiceType::Decode(uint8_t* buf, int len, bool is_optional, bool is_high) {
   if (len < 1) return -1;
   if (is_optional) {
     _iei = *buf;

src/nas/ies/ServiceType.hpp

@@ -40,8 +40,8 @@ class ServiceType {
   ServiceType(uint8_t iei, uint8_t stp);
 
  public:
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* nuf, int len, bool is_optional, bool is_high);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* nuf, int len, bool is_optional, bool is_high);
   uint8_t getValue();
 
  private:

src/nas/ies/StandardL3NasIe.cpp

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the
+ * License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#include "StandardL3NasIe.hpp"
+
+#include "3gpp_24.501.hpp"
+#include "common_defs.h"
+#include "logger.hpp"
+
+using namespace nas;
+//------------------------------------------------------------------------------
+StandardL3NasIe::StandardL3NasIe() : NasIe() {
+  iei_ = std::nullopt;
+}
+
+//------------------------------------------------------------------------------
+StandardL3NasIe::StandardL3NasIe(const uint8_t& iei) : NasIe() {
+  iei_ = std::optional<uint8_t>(iei);
+}
+
+//------------------------------------------------------------------------------
+StandardL3NasIe::~StandardL3NasIe() {}
+
+//------------------------------------------------------------------------------
+void StandardL3NasIe::SetIei(const uint8_t& iei) {
+  iei_ = std::optional<uint8_t>(iei);
+}
+
+//------------------------------------------------------------------------------
+bool StandardL3NasIe::Validate(const int& len) const {
+  int ie_len = GetIeLength();  // Length of the content + IEI/Len
+  if (len < ie_len) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the length of this IE (%d octet(s))",
+        ie_len);
+    return false;
+  }
+  return true;
+}

src/nas/ies/StandardL3NasIe.hpp

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the
+ * License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#ifndef _STANDARD_L3_NAS_IE_H_
+#define _STANDARD_L3_NAS_IE_H_
+#include "NasIe.hpp"
+
+namespace nas {
+
+class StandardL3NasIe : public NasIe {
+ public:
+  StandardL3NasIe();
+  StandardL3NasIe(const uint8_t& iei);
+  virtual ~StandardL3NasIe();
+
+  bool Validate(const int& len) const override;
+  void SetIei(const uint8_t& iei);
+  virtual uint8_t GetIeLength() const = 0;
+
+ protected:
+  std::optional<uint8_t> iei_;  // IEI (Optional)
+};
+
+}  // namespace nas
+
+#endif

src/nas/ies/UE_Radio_Capability_ID.cpp

@@ -64,7 +64,7 @@ uint8_t UE_Radio_Capability_ID::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int UE_Radio_Capability_ID::encode2Buffer(uint8_t* buf, int len) {
+int UE_Radio_Capability_ID::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("encoding UE_Radio_Capability_ID iei(0x%x)", _iei);
   if (len < 3) {
     Logger::nas_mm().error("len is less than 3");
@@ -88,8 +88,7 @@ int UE_Radio_Capability_ID::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int UE_Radio_Capability_ID::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int UE_Radio_Capability_ID::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding UE_Radio_Capability_ID iei(0x%x)", *buf);
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/UE_Radio_Capability_ID.hpp

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

src/nas/ies/_5GMM_Cause.cpp

@@ -56,7 +56,7 @@ void _5GMM_Cause::set(uint8_t iei, uint8_t value) {
   _value = value;
 }
 //------------------------------------------------------------------------------
-int _5GMM_Cause::encode2Buffer(uint8_t* buf, int len) {
+int _5GMM_Cause::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding _5GMM_Cause IE ");
 
   int encoded_size = 0;
@@ -77,7 +77,7 @@ int _5GMM_Cause::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int _5GMM_Cause::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
+int _5GMM_Cause::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("decoding _5GMM_Cause IE");
   int decoded_size = 0;
   if (is_option) {

src/nas/ies/_5GMM_Cause.hpp

@@ -76,8 +76,8 @@ class _5GMM_Cause {
   _5GMM_Cause();
   _5GMM_Cause(uint8_t _iei, uint8_t value);
   ~_5GMM_Cause();
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   void set(uint8_t _iei, uint8_t value);
   void setValue(uint8_t value);
   uint8_t getValue();

src/nas/ies/_5GSDeregistrationType.cpp

@@ -83,7 +83,7 @@ void _5GSDeregistrationType::get(uint8_t& type) {
 }
 
 //------------------------------------------------------------------------------
-int _5GSDeregistrationType::encode2Buffer(uint8_t* buf, int len) {
+int _5GSDeregistrationType::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().error("Encoding 5GSDeregistrationType IE");
   if (len < 1) {
     Logger::nas_mm().error(
@@ -95,7 +95,7 @@ int _5GSDeregistrationType::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int _5GSDeregistrationType::decodeFromBuffer(uint8_t* buf, int len) {
+int _5GSDeregistrationType::Decode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Decoding 5GSDeregistrationType");
   u1.b = *buf;
 

src/nas/ies/_5GSDeregistrationType.hpp

@@ -45,8 +45,8 @@ class _5GSDeregistrationType {
   _5GSDeregistrationType(uint8_t type);
   _5GSDeregistrationType(_5gs_deregistration_type_t type);
   ~_5GSDeregistrationType();
-  int decodeFromBuffer(uint8_t* buf, int len);
-  int encode2Buffer(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len);
+  int Encode(uint8_t* buf, int len);
 
   void set(_5gs_deregistration_type_t type);
   void get(_5gs_deregistration_type_t& type);

src/nas/ies/_5GSTrackingAreaIdList.cpp

@@ -35,7 +35,7 @@ _5GSTrackingAreaIdList::_5GSTrackingAreaIdList(
 }
 
 //------------------------------------------------------------------------------
-int _5GSTrackingAreaIdList::encode2Buffer(uint8_t* buf, int len) {
+int _5GSTrackingAreaIdList::Encode(uint8_t* buf, int len) {
   int encoded_size = 0;
   int len_pos      = 0;
   if (m_iei) {

src/nas/ies/_5GSTrackingAreaIdList.hpp

@@ -34,7 +34,7 @@ namespace nas {
 class _5GSTrackingAreaIdList {
  public:
   _5GSTrackingAreaIdList(uint8_t iei, std::vector<p_tai_t> tai_list);
-  int encode2Buffer(uint8_t* buf, int len);
+  int Encode(uint8_t* buf, int len);
 
  private:
   uint8_t m_iei;

src/nas/ies/_5GS_Identity_Type.cpp

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

src/nas/ies/_5GS_Identity_Type.hpp

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

src/nas/ies/_5GS_Network_Feature_Support.cpp

@@ -70,7 +70,7 @@ uint8_t _5GS_Network_Feature_Support::getValue() {
 }
 
 //------------------------------------------------------------------------------
-int _5GS_Network_Feature_Support::encode2Buffer(uint8_t* buf, int len) {
+int _5GS_Network_Feature_Support::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug(
       "Encoding _5GS_Network_Feature_Support IEI (0x%x)", _iei);
   if (len < length) {
@@ -99,7 +99,7 @@ int _5GS_Network_Feature_Support::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int _5GS_Network_Feature_Support::decodeFromBuffer(
+int _5GS_Network_Feature_Support::Decode(
     uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug(
       "Decoding _5GS_Network_Feature_Support IEI (0x%x)", *buf);

src/nas/ies/_5GS_Network_Feature_Support.hpp

@@ -42,8 +42,8 @@ class _5GS_Network_Feature_Support {
       const uint8_t iei, uint8_t value, uint8_t value2);
   void setValue(uint8_t value);
   uint8_t getValue();
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
 
  private:
   uint8_t _iei;

src/nas/ies/_5GS_Registration_Result.cpp

@@ -91,7 +91,7 @@ void _5GS_Registration_Result::set(
 }
 
 //------------------------------------------------------------------------------
-int _5GS_Registration_Result::encode2Buffer(uint8_t* buf, int len) {
+int _5GS_Registration_Result::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding _5GS_Registration_Result");
   uint8_t ie_len = 0;
   if (_iei) {
@@ -129,8 +129,7 @@ int _5GS_Registration_Result::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int _5GS_Registration_Result::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
+int _5GS_Registration_Result::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding _5GS_Registration_Result");
 
   if (len < k5gsRegistrationResultLength) {

src/nas/ies/_5GS_Registration_Result.hpp

@@ -35,8 +35,8 @@ class _5GS_Registration_Result {
   _5GS_Registration_Result(
       const uint8_t iei, bool emergency, bool nssaa, bool sms, uint8_t value);
   ~_5GS_Registration_Result();
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
   void setValue(uint8_t value);
   uint8_t getValue();
   void set(

src/nas/ies/_5GS_Update_Type.cpp

@@ -102,7 +102,7 @@ bool _5GS_Update_Type::getSMS() {
 }
 
 //------------------------------------------------------------------------------
-int _5GS_Update_Type::encode2Buffer(uint8_t* buf, int len) {
+int _5GS_Update_Type::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding _5GS_Update_Type");
   if (len < k5gsUpdateTypeLength) {
     Logger::nas_mm().error(
@@ -126,7 +126,7 @@ int _5GS_Update_Type::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int _5GS_Update_Type::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
+int _5GS_Update_Type::Decode(uint8_t* buf, int len, bool is_option) {
   Logger::nas_mm().debug("Decoding _5GS_Update_Type");
 
   int decoded_size = 0;

src/nas/ies/_5GS_Update_Type.hpp

@@ -43,8 +43,8 @@ class _5GS_Update_Type {
   uint8_t get_5GS_PNB_CIoT();
   bool getNG_RAN();
   bool getSMS();
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_option);
 
  private:
   uint8_t _iei;

src/nas/msgs/AuthenticationFailure.cpp

@@ -79,20 +79,20 @@ bool AuthenticationFailure::getAutsInAuthFailPara(bstring& auts) {
 }
 
 //------------------------------------------------------------------------------
-int AuthenticationFailure::encode2Buffer(uint8_t* buf, int len) {
+int AuthenticationFailure::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding AuthenticationFailure message");
   int encoded_size = 0;
   if (!plain_header) {
     Logger::nas_mm().error("Mandatory IE missing Header");
     return 0;
   }
-  if (!(plain_header->encode2Buffer(buf, len))) return 0;
+  if (!(plain_header->Encode(buf, len))) return 0;
   encoded_size += 3;
   if (!ie_5gmm_cause) {
     Logger::nas_mm().warn("IE ie_5gmm_cause is not available");
   } else {
-    if (int size = ie_5gmm_cause->encode2Buffer(
-            buf + encoded_size, len - encoded_size)) {
+    if (int size =
+            ie_5gmm_cause->Encode(buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
       Logger::nas_mm().error("Encoding ie_5gmm_cause error");
@@ -102,7 +102,7 @@ int AuthenticationFailure::encode2Buffer(uint8_t* buf, int len) {
     Logger::nas_mm().warn(
         "IE ie_authentication_failure_parameter is not available");
   } else {
-    if (int size = ie_authentication_failure_parameter->encode2Buffer(
+    if (int size = ie_authentication_failure_parameter->Encode(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -118,14 +118,14 @@ int AuthenticationFailure::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int AuthenticationFailure::decodeFromBuffer(
+int AuthenticationFailure::Decode(
     NasMmPlainHeader* header, uint8_t* buf, int len) {
   Logger::nas_mm().debug("Decoding AuthenticationFailure message");
   int decoded_size = 3;
   plain_header     = header;
   ie_5gmm_cause    = new _5GMM_Cause();
-  decoded_size += ie_5gmm_cause->decodeFromBuffer(
-      buf + decoded_size, len - decoded_size, false);
+  decoded_size +=
+      ie_5gmm_cause->Decode(buf + decoded_size, len - decoded_size, false);
   Logger::nas_mm().debug("Decoded_size (%d)", decoded_size);
   uint8_t octet = *(buf + decoded_size);
   Logger::nas_mm().debug("First option IEI (0x%x)", octet);
@@ -135,7 +135,7 @@ int AuthenticationFailure::decodeFromBuffer(
         Logger::nas_mm().debug("Decoding IEI (0x30)");
         ie_authentication_failure_parameter =
             new Authentication_Failure_Parameter();
-        decoded_size += ie_authentication_failure_parameter->decodeFromBuffer(
+        decoded_size += ie_authentication_failure_parameter->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);

src/nas/msgs/AuthenticationFailure.hpp

@@ -37,8 +37,8 @@ class AuthenticationFailure {
  public:
   AuthenticationFailure();
   ~AuthenticationFailure();
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(NasMmPlainHeader* header, uint8_t* buf, int len);
+  int Encode(uint8_t* buf, int len);
+  int Decode(NasMmPlainHeader* header, uint8_t* buf, int len);
   void setHeader(uint8_t security_header_type);
   void set_5GMM_Cause(uint8_t value);
   void setAuthentication_Failure_Parameter(bstring auts);

src/nas/msgs/AuthenticationReject.cpp

@@ -55,20 +55,20 @@ void AuthenticationReject::setEAP_Message(bstring eap) {
 }
 
 //------------------------------------------------------------------------------
-int AuthenticationReject::encode2Buffer(uint8_t* buf, int len) {
+int AuthenticationReject::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding AuthenticationReject message");
   int encoded_size = 0;
   if (!plain_header) {
     Logger::nas_mm().error("Mandatory IE missing Header");
     return 0;
   }
-  if (!(plain_header->encode2Buffer(buf, len))) return 0;
+  if (!(plain_header->Encode(buf, len))) return 0;
   encoded_size += 3;
   if (!ie_eap_message) {
     Logger::nas_mm().warn("IE ie_eap_message is not available");
   } else {
-    if (int size = ie_eap_message->encode2Buffer(
-            buf + encoded_size, len - encoded_size)) {
+    if (int size =
+            ie_eap_message->Encode(buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
       Logger::nas_mm().error("Encoding ie_eap_message error");
@@ -81,7 +81,7 @@ int AuthenticationReject::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int AuthenticationReject::decodeFromBuffer(
+int AuthenticationReject::Decode(
     NasMmPlainHeader* header, uint8_t* buf, int len) {
   Logger::nas_mm().debug("Decoding AuthenticationReject message");
   int decoded_size = 3;
@@ -94,7 +94,7 @@ int AuthenticationReject::decodeFromBuffer(
       case 0x78: {
         Logger::nas_mm().debug("Decoding IEI (0x78)");
         ie_eap_message = new EAP_Message();
-        decoded_size += ie_eap_message->decodeFromBuffer(
+        decoded_size += ie_eap_message->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);

src/nas/msgs/AuthenticationReject.hpp

@@ -37,8 +37,8 @@ class AuthenticationReject {
  public:
   AuthenticationReject();
   ~AuthenticationReject();
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(NasMmPlainHeader* header, uint8_t* buf, int len);
+  int Encode(uint8_t* buf, int len);
+  int Decode(NasMmPlainHeader* header, uint8_t* buf, int len);
   void setHeader(uint8_t security_header_type);
   void setEAP_Message(bstring eap);
 

src/nas/msgs/AuthenticationRequest.cpp

@@ -81,14 +81,14 @@ void AuthenticationRequest::setEAP_Message(bstring eap) {
 }
 
 //------------------------------------------------------------------------------
-int AuthenticationRequest::encode2Buffer(uint8_t* buf, int len) {
+int AuthenticationRequest::Encode(uint8_t* buf, int len) {
   Logger::nas_mm().debug("Encoding AuthenticationRequest message");
   int encoded_size = 0;
   if (!plain_header) {
     Logger::nas_mm().error("Mandatory IE missing Header");
     return 0;
   }
-  if (!(plain_header->encode2Buffer(buf, len))) return 0;
+  if (!(plain_header->Encode(buf, len))) return 0;
   encoded_size += 3;
   if (!ie_ngKSI) {
     Logger::nas_mm().warn("IE ie_ngKSI is not available");
@@ -106,7 +106,7 @@ int AuthenticationRequest::encode2Buffer(uint8_t* buf, int len) {
   if (!ie_abba) {
     Logger::nas_mm().warn("IE ie_abba is not available");
   } else {
-    int size = ie_abba->encode2Buffer(buf + encoded_size, len - encoded_size);
+    int size = ie_abba->Encode(buf + encoded_size, len - encoded_size);
     if (size != 0) {
       Logger::nas_mm().debug(
           "0x%x, 0x%x, 0x%x", (buf + encoded_size)[0], (buf + encoded_size)[1],
@@ -121,7 +121,7 @@ int AuthenticationRequest::encode2Buffer(uint8_t* buf, int len) {
     Logger::nas_mm().warn(
         "IE ie_authentication_parameter_rand is not available");
   } else {
-    int size = ie_authentication_parameter_rand->encode2Buffer(
+    int size = ie_authentication_parameter_rand->Encode(
         buf + encoded_size, len - encoded_size);
     if (size != 0) {
       encoded_size += size;
@@ -134,7 +134,7 @@ int AuthenticationRequest::encode2Buffer(uint8_t* buf, int len) {
     Logger::nas_mm().warn(
         "IE ie_authentication_parameter_autn is not available");
   } else {
-    int size = ie_authentication_parameter_autn->encode2Buffer(
+    int size = ie_authentication_parameter_autn->Encode(
         buf + encoded_size, len - encoded_size);
     if (size != 0) {
       encoded_size += size;
@@ -146,8 +146,7 @@ int AuthenticationRequest::encode2Buffer(uint8_t* buf, int len) {
   if (!ie_eap_message) {
     Logger::nas_mm().warn("IE ie_eap_message is not available");
   } else {
-    int size =
-        ie_eap_message->encode2Buffer(buf + encoded_size, len - encoded_size);
+    int size = ie_eap_message->Encode(buf + encoded_size, len - encoded_size);
     if (size != 0) {
       encoded_size += size;
     } else {
@@ -162,7 +161,7 @@ int AuthenticationRequest::encode2Buffer(uint8_t* buf, int len) {
 }
 
 //------------------------------------------------------------------------------
-int AuthenticationRequest::decodeFromBuffer(
+int AuthenticationRequest::Decode(
     NasMmPlainHeader* header, uint8_t* buf, int len) {
   Logger::nas_mm().debug("Decoding RegistrationReject message");
   int decoded_size = 3;
@@ -174,7 +173,7 @@ int AuthenticationRequest::decodeFromBuffer(
   decoded_size++;  // 1/2 octet from ie_ngKSI, 1/2 from Spare half octet
   ie_abba = new ABBA();
   decoded_size +=
-      ie_abba->decodeFromBuffer(buf + decoded_size, len - decoded_size, false);
+      ie_abba->Decode(buf + decoded_size, len - decoded_size, false);
   Logger::nas_mm().debug("Decoded_size %d", decoded_size);
   uint8_t octet = *(buf + decoded_size);
   Logger::nas_mm().debug("First option IEI 0x%x", octet);
@@ -183,14 +182,14 @@ int AuthenticationRequest::decodeFromBuffer(
       case 0x21: {
         Logger::nas_mm().debug("Decoding IEI(0x21)");
         ie_authentication_parameter_rand = new Authentication_Parameter_RAND();
-        decoded_size += ie_authentication_parameter_rand->decodeFromBuffer(
+        decoded_size += ie_authentication_parameter_rand->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
       } break;
       case 0x20: {
         ie_authentication_parameter_autn = new Authentication_Parameter_AUTN();
-        decoded_size += ie_authentication_parameter_autn->decodeFromBuffer(
+        decoded_size += ie_authentication_parameter_autn->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
@@ -198,7 +197,7 @@ int AuthenticationRequest::decodeFromBuffer(
       case 0x78: {
         Logger::nas_mm().debug("Decoding IEI 0x78");
         ie_eap_message = new EAP_Message();
-        decoded_size += ie_eap_message->decodeFromBuffer(
+        decoded_size += ie_eap_message->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);

src/nas/msgs/AuthenticationRequest.hpp

@@ -37,8 +37,8 @@ class AuthenticationRequest {
  public:
   AuthenticationRequest();
   ~AuthenticationRequest();
-  int encode2Buffer(uint8_t* buf, int len);
-  int decodeFromBuffer(NasMmPlainHeader* header, uint8_t* buf, int len);
+  int Encode(uint8_t* buf, int len);
+  int Decode(NasMmPlainHeader* header, uint8_t* buf, int len);
   void setHeader(uint8_t security_header_type);
   void setngKSI(uint8_t tsc, uint8_t key_set_id);
   void setEAP_Message(bstring eap);