Merge branch 'test-information-engineering-university'

1. Add Paging
2. Fixed a BUG in MNC where 0 is used as the first letter
3. Fixed authentication errors
4. Fixed issue showing Amairsoft
5. fix UESecurityCapability

src/amf-app/amf_app.cpp

@@ -111,6 +111,20 @@ void amf_app_task(void*) {
         amf_app_inst->handle_itti_message(ref(*m));
       } break;
 
+      case TEST_SIGNALLING_PAGING: {
+        Logger::amf_app().debug("Received TEST_SIGNALLING_PAGING");
+        itti_test_signalling_paging* m =
+            dynamic_cast<itti_test_signalling_paging*>(msg);
+        amf_app_inst->handle_itti_message(ref(*m));
+      } break;
+
+      case TEST_SIGNALLING_NETWORK_INITIATED_DEREGISTRAATION: {
+        Logger::amf_app().debug("Received TEST_SIGNALLING_NETWORK_INITIATED_DEREGISTRAATION");
+        itti_test_signalling_network_initiated_deregistration* m =
+            dynamic_cast<itti_test_signalling_network_initiated_deregistration*>(msg);
+        amf_app_inst->handle_itti_message(ref(*m));
+      } break;
+
       case TIME_OUT:
         if (itti_msg_timeout* to = dynamic_cast<itti_msg_timeout*>(msg)) {
           switch (to->arg1_user) {
@@ -181,6 +195,35 @@ void amf_app::set_ran_amf_id_2_ue_context(
 }
 
 // ITTI handlers
+//------------------------------------------------------------------------------
+void amf_app::handle_itti_message(
+    itti_test_signalling_paging& itti_msg) {
+
+  itti_paging* paging_msg = new itti_paging(TASK_AMF_APP, TASK_AMF_N2);
+
+  paging_msg->ran_ue_ngap_id = itti_msg.ran_ue_ngap_id;
+  paging_msg->amf_ue_ngap_id = itti_msg.amf_ue_ngap_id;
+
+  std::shared_ptr<itti_paging> i =
+      std::shared_ptr<itti_paging>(paging_msg);
+  int ret = itti_inst->send_msg(i);
+  if (0 != ret) {
+    Logger::amf_app().error(
+        "Could not send ITTI message %s to task TASK_AMF_N2",
+        i->get_msg_name());
+  }
+}
+
+//------------------------------------------------------------------------------
+void amf_app::handle_itti_message(
+    itti_test_signalling_network_initiated_deregistration& itti_msg) {
+
+  amf_n1_inst->network_initiate_de_registration_handle(itti_msg.ran_ue_ngap_id, itti_msg.amf_ue_ngap_id);
+
+}
+
+
+
 //------------------------------------------------------------------------------
 void amf_app::handle_itti_message(
     itti_n1n2_message_transfer_request& itti_msg) {

src/amf-app/amf_app.hpp

@@ -55,6 +55,8 @@ class amf_app {
   // itti handlers
   void handle_itti_message(itti_nas_signalling_establishment_request& itti_msg);
   void handle_itti_message(itti_n1n2_message_transfer_request& itti_msg);
+  void handle_itti_message(itti_test_signalling_paging& itti_msg);
+  void handle_itti_message(itti_test_signalling_network_initiated_deregistration& itti_msg);
   // context management
   std::map<long, std::shared_ptr<ue_context>> amf_ue_ngap_id2ue_ctx;
   mutable std::shared_mutex m_amf_ue_ngap_id2ue_ctx;

src/amf-app/amf_n1.hpp

@@ -104,6 +104,11 @@ class amf_n1 {
   void run_initial_registration_procedure();
   void run_mobility_registration_update_procedure(
       std::shared_ptr<nas_context> nc);
+  void run_periodic_registration_update_procedure(
+    std::shared_ptr<nas_context> nc,uint16_t);
+  void run_periodic_registration_update_procedure(
+    std::shared_ptr<nas_context> nc,bstring& nas_msg);
+
   // authentication
   bool auth_vectors_generator(std::shared_ptr<nas_context>& nc);
 
@@ -159,6 +164,9 @@ class amf_n1 {
   void set_5gmm_state(std::shared_ptr<nas_context> nc, _5gmm_state_t state);
   void get_5gmm_state(std::shared_ptr<nas_context> nc, _5gmm_state_t& state);
 
+  void network_initiate_de_registration_handle(
+      uint32_t ran_ue_ngap_id, long amf_ue_ngap_id);
+
  private:  // nas message handlers
   void ue_initiate_de_registration_handle(
       uint32_t ran_ue_ngap_id, long amf_ue_ngap_id, bstring nas);

src/amf-app/amf_n11.cpp

@@ -232,6 +232,7 @@ void amf_n11::handle_itti_message(itti_smf_services_consumer& smf) {
   psc.get()->snssai.sD        = smf.snssai.sD;
   psc.get()->plmn.mcc         = smf.plmn.mcc;
   psc.get()->plmn.mnc         = smf.plmn.mnc;
+  psc.get()->plmn.tac         = smf.plmn.tac;
 
   // parse binary dnn and store
   std::string dnn = "default";

src/amf-app/amf_n2.cpp

@@ -41,6 +41,7 @@
 #include "PduSessionResourceReleaseCommand.hpp"
 #include "PduSessionResourceSetupRequest.hpp"
 #include "UEContextReleaseCommand.hpp"
+#include "Paging.hpp"
 #include "amf_app.hpp"
 #include "amf_config.hpp"
 #include "amf_n1.hpp"
@@ -50,6 +51,7 @@
 #include "itti_msg_amf_app.hpp"
 #include "logger.hpp"
 #include "sctp_server.hpp"
+#include "String2Value.hpp"
 
 extern "C" {
 #include "dynamic_memory_check.h"
@@ -177,6 +179,11 @@ void amf_n2_task(void* args_p) {
         itti_uplinkranstatsutransfer* m =
             dynamic_cast<itti_uplinkranstatsutransfer*>(msg);
         amf_n2_inst->handle_itti_message(ref(*m));
+      } break;
+       case PAGING: {
+        Logger::amf_n2().info("Received Paging message,handling");
+        itti_paging* m = dynamic_cast<itti_paging*>(msg);
+        amf_n2_inst->handle_itti_message(ref(*m));
       } break;
       default:
         Logger::amf_n2().info("No handler for msg type %d", msg->msg_type);
@@ -201,6 +208,56 @@ amf_n2::~amf_n2() {}
 // NGAP Messages Handlers
 //------------------------------------------------------------------------------
 
+//------------------------------------------------------------------------------
+void amf_n2::handle_itti_message(itti_paging& itti_msg) {
+  Logger::amf_n2().debug("Handling Paging message...");
+
+  std::shared_ptr<ue_ngap_context> unc;
+
+  if (!is_ran_ue_id_2_ue_ngap_context(itti_msg.ran_ue_ngap_id)) {
+    Logger::amf_n2().error(
+        "No UE NGAP context with ran_ue_ngap_id (%d)", itti_msg.ran_ue_ngap_id);
+    return;
+  }
+  unc = ran_ue_id_2_ue_ngap_context(itti_msg.ran_ue_ngap_id);
+  if (unc.get()->amf_ue_ngap_id != itti_msg.amf_ue_ngap_id) {
+    Logger::amf_n2().error(
+        "The requested UE (amf_ue_ngap_id: 0x%x) is not valid, existed UE "
+        "which's amf_ue_ngap_id (0x%x)",
+        itti_msg.amf_ue_ngap_id, unc.get()->amf_ue_ngap_id);
+  }
+  if (unc.get()->ng_ue_state != NGAP_UE_CONNECTED) {
+    Logger::amf_n2().error(
+        "Received NGAP UPLINK_NAS_TRANSPORT while UE in state != "
+        "NGAP_UE_CONNECTED");
+    // return;
+  }
+
+  PagingMsg Paging_test;
+  Paging_test.setMessageType();
+  Logger::amf_n2().warn(" unc.get()->s_setid (%d)",unc.get()->s_setid);
+  Logger::amf_n2().warn(" unc.get()->s_pointer (%d)",unc.get()->s_pointer);
+  Logger::amf_n2().warn(" unc.get()->s_tmsi (%d)",unc.get()->s_tmsi);
+  Paging_test.setUEPagingIdentity(unc.get()->s_setid, unc.get()->s_pointer, unc.get()->s_tmsi);
+  Logger::amf_n2().warn("==========================================");
+  std :: vector < struct Tai_s > list;
+  Tai_t tai_test;
+  tai_test.mcc = unc.get()->tai.mcc;
+  tai_test.mnc = unc.get()->tai.mnc;
+  tai_test.tac = unc.get()->tai.tac;
+
+  list.push_back(tai_test);
+  Paging_test.setTAIListForPaging(list);
+
+  uint8_t buffer[BUFFER_SIZE_512];
+  int encoded_size = Paging_test.encode2buffer(buffer, BUFFER_SIZE_512);
+  bstring b        = blk2bstr(buffer, encoded_size);
+
+  amf_n2_inst->sctp_s_38412.sctp_send_msg(unc.get()->gnb_assoc_id, unc.get()->sctp_stream_send, &b);
+
+}
+
+
 void amf_n2::handle_itti_message(itti_new_sctp_association& new_assoc) {
 }  // handled in class ngap_app
 
@@ -409,6 +466,7 @@ void amf_n2::handle_itti_message(itti_initial_ue_message& init_ue_msg) {
     if (init_ue_msg.initUeMsg->getUserLocationInfoNR(cgi, tai)) {
       itti_msg->cgi = cgi;
       itti_msg->tai = tai;
+      unc.get()->tai = tai;
     } else {
       Logger::amf_n2().error("Missing Mandatory IE UserLocationInfoNR");
       return;
@@ -435,6 +493,8 @@ void amf_n2::handle_itti_message(itti_initial_ue_message& init_ue_msg) {
       itti_msg->is_5g_s_tmsi_present = true;
       itti_msg->_5g_s_tmsi           = _5g_s_tmsi;
       Logger::amf_n2().debug("5g_s_tmsi present");
+
+      init_ue_msg.initUeMsg->get5GS_TMSI(unc.get()->s_setid, unc.get()->s_pointer, unc.get()->s_tmsi);
     }
 
     uint8_t* nas_buf;
@@ -1321,8 +1381,10 @@ bool amf_n2::verifyPlmn(vector<SupportedItem_t> list) {
         continue;
       }
       for (int k = 0; k < list[j].b_plmn_list.size(); k++) {
-        if (!(list[j].b_plmn_list[k].mcc.compare(amf_cfg.plmn_list[i].mcc)) &&
-            !(list[j].b_plmn_list[k].mnc.compare(amf_cfg.plmn_list[i].mnc))) {
+        //if (!(list[j].b_plmn_list[k].mcc.compare(amf_cfg.plmn_list[i].mcc)) &&
+        //    !(list[j].b_plmn_list[k].mnc.compare(amf_cfg.plmn_list[i].mnc))) {
+	    if((fromString<int>(list[j].b_plmn_list[k].mcc) == fromString<int>(amf_cfg.plmn_list[i].mcc)) &&
+           (fromString<int>(list[j].b_plmn_list[k].mnc) == fromString<int>(amf_cfg.plmn_list[i].mnc))) {
           return true;
         }
       }
@@ -1345,8 +1407,10 @@ std::vector<SupportedItem_t> amf_n2::get_common_plmn(
         continue;
       }
       for (int k = 0; k < list[j].b_plmn_list.size(); k++) {
-        if (!(list[j].b_plmn_list[k].mcc.compare(amf_cfg.plmn_list[i].mcc)) &&
-            !(list[j].b_plmn_list[k].mnc.compare(amf_cfg.plmn_list[i].mnc))) {
+        //if (!(list[j].b_plmn_list[k].mcc.compare(amf_cfg.plmn_list[i].mcc)) &&
+        //    !(list[j].b_plmn_list[k].mnc.compare(amf_cfg.plmn_list[i].mnc))) {
+	    if((fromString<int>(list[j].b_plmn_list[k].mcc) == fromString<int>(amf_cfg.plmn_list[i].mcc)) &&
+           (fromString<int>(list[j].b_plmn_list[k].mnc) == fromString<int>(amf_cfg.plmn_list[i].mnc))) {
           plmn_list.push_back(list[j]);
         }
       }

src/amf-app/amf_n2.hpp

@@ -60,6 +60,7 @@ class amf_n2 : public ngap::ngap_app {
   void handle_itti_message(itti_handover_request_Ack& itti_msg);
   void handle_itti_message(itti_handover_notify& itti_msg);
   void handle_itti_message(itti_uplinkranstatsutransfer& itti_msg);
+  void handle_itti_message(itti_paging& itti_msg);
 
   bool verifyPlmn(std::vector<SupportedItem_t> list);
   std::vector<SupportedItem_t> get_common_plmn(

src/contexts/nas_context.cpp

@@ -42,7 +42,9 @@ nas_context::nas_context() {
   is_common_procedure_for_security_mode_control_running = false;
   is_common_procedure_for_nas_transport_running         = false;
   auts                                                  = NULL;
-  ueSecurityCaplen = 0;
+  ueSecurityCaplen = 2;
+  ueSecurityCapEEnc = 0;
+  ueSecurityCapEInt = 0;
 }
 
 //------------------------------------------------------------------------------

src/contexts/nas_context.hpp

@@ -76,6 +76,8 @@ class nas_context {
   uint8_t ueSecurityCaplen;
   uint8_t ueSecurityCapEnc;
   uint8_t ueSecurityCapInt;
+  uint8_t ueSecurityCapEEnc;
+  uint8_t ueSecurityCapEInt;
   std::vector<nas::SNSSAI_t> requestedNssai;
   std::string serving_network;
   bstring auts;

src/contexts/ue_ngap_context.hpp

@@ -35,6 +35,8 @@
 #include "gNB_context.hpp"
 
 using namespace sctp;
+using namespace ngap;
+
 typedef enum {
   NGAP_UE_INVALID_STATE,
   NGAP_UE_WAITING_CSR,  // Context Setup Response(CSR)
@@ -56,6 +58,12 @@ class ue_ngap_context {
   bool ueContextRequest;
   uint32_t s_tmsi_5g;
 
+  std :: string s_setid = "4";
+  std :: string s_pointer = "1";
+  std :: string s_tmsi = "1";
+
+  Tai_t tai;
+
   // state management, ue status over the air
   ng_ue_state_t ng_ue_state;
 };

src/itti/itti_msg.hpp

@@ -82,6 +82,9 @@ typedef enum {
   HANDOVER_NOTIFY,
   UPLINKRANSTATUSTRANSFER,
   PDU_SESS_RES_SET_RESP,
+  TEST_SIGNALLING_PAGING,
+  TEST_SIGNALLING_NETWORK_INITIATED_DEREGISTRAATION,
+  PAGING,
   TIME_OUT,
   HEALTH_PING,
   TERMINATE,

src/itti/msgs/itti_msg_amf_app.hpp

 #ifndef _AMF_APP_ITTI_H_
 #define _AMF_APP_ITTI_H_
 
+#include "amf.hpp"
 #include "itti_msg.hpp"
 #include "NgapIEsStruct.hpp"
 #include <string>
@@ -59,4 +60,28 @@ class itti_n1n2_message_transfer_request : public itti_msg_amf_app {
   // other parameters
 };
 
+class itti_test_signalling_paging : public itti_msg_amf_app {
+ public:
+  itti_test_signalling_paging(const task_id_t origin, const task_id_t destination)
+      : itti_msg_amf_app(TEST_SIGNALLING_PAGING, origin, destination) {}
+  itti_test_signalling_paging(const itti_test_signalling_paging& i) : itti_msg_amf_app(i) {}
+
+ public:
+  uint32_t ran_ue_ngap_id;
+  long amf_ue_ngap_id;
+};
+
+class itti_test_signalling_network_initiated_deregistration : public itti_msg_amf_app {
+ public:
+  itti_test_signalling_network_initiated_deregistration(const task_id_t origin, const task_id_t destination)
+      : itti_msg_amf_app(TEST_SIGNALLING_NETWORK_INITIATED_DEREGISTRAATION, origin, destination) {}
+  itti_test_signalling_network_initiated_deregistration(const itti_test_signalling_network_initiated_deregistration& i) : itti_msg_amf_app(i) {}
+
+ public:
+  uint32_t ran_ue_ngap_id;
+  long amf_ue_ngap_id;
+};
+
+
+
 #endif

src/itti/msgs/itti_msg_n2.hpp

 #ifndef _ITTI_MSG_N2_H_
 #define _ITTI_MSG_N2_H_
 
+#include "amf.hpp"
 #include "itti_msg.hpp"
 #include "NGSetupRequest.hpp"
 #include "InitialUEMessage.hpp"
@@ -171,6 +172,18 @@ class itti_handover_required : public itti_msg_n2 {
   HandoverRequiredMsg* handvoerRequ;
 };
 
+class itti_paging : public itti_msg_n2 {
+ public:
+  itti_paging(const task_id_t origin, const task_id_t destination)
+      : itti_msg_n2(PAGING, origin, destination) {}
+  itti_paging(const itti_paging& i) : itti_msg_n2(i) {}
+
+ public:
+  uint32_t ran_ue_ngap_id;
+  long amf_ue_ngap_id;
+};
+
+
 class itti_handover_request_Ack : public itti_msg_n2 {
  public:
   itti_handover_request_Ack(const task_id_t origin, const task_id_t destination)

src/nas/ies/5GSMobilityIdentity.cpp

@@ -543,7 +543,10 @@ int _5GSMobilityIdentity::suci_decodefrombuffer(
           "MCC %s, MNC %s", std::to_string(mcc).c_str(),
           std::to_string(mnc).c_str());
       supi_format_imsi->mcc = (const string)(std::to_string(mcc));
-      supi_format_imsi->mnc = (const string)(std::to_string(mnc));
+	  if(std::to_string(mnc).size() == 1)
+      	supi_format_imsi->mnc = (const string)("0" + (const string)(std::to_string(mnc)));
+	  else
+		supi_format_imsi->mnc = (const string)(std::to_string(mnc));
       int routid            = 0;
       uint8_t digit[4];
       octet = *(buf + decoded_size);
@@ -639,6 +642,10 @@ int _5GSMobilityIdentity::_5g_guti_decodefrombuffer(uint8_t* buf, int len) {
       "MCC %s, MNC %s", std::to_string(mcc).c_str(),
       std::to_string(mnc).c_str());
   _5g_guti->mcc = (const string)(std::to_string(mcc));
+  if(std::to_string(mnc).size() == 1)
+  	_5g_guti->mnc = (const string)("0" + (const string)(std::to_string(mnc)));
+  else
+	_5g_guti->mnc = (const string)(std::to_string(mnc));
   _5g_guti->mnc = (const string)(std::to_string(mnc));
 
   _5g_guti->amf_region_id = *(buf + decoded_size);

src/nas/ies/UESecurityCapability.cpp

@@ -61,6 +61,18 @@ uint8_t UESecurityCapability::getEASel() { return _5g_EASel; }
 //------------------------------------------------------------------------------
 uint8_t UESecurityCapability::getIASel() { return _5g_IASel; }
 
+//------------------------------------------------------------------------------
+void UESecurityCapability::setEEASel(uint8_t sel) { _5g_EEASel = sel; }
+
+//------------------------------------------------------------------------------
+void UESecurityCapability::setEIASel(uint8_t sel) { _5g_EIASel = sel; }
+
+//------------------------------------------------------------------------------
+uint8_t UESecurityCapability::getEEASel() { return _5g_EEASel; }
+
+//------------------------------------------------------------------------------
+uint8_t UESecurityCapability::getEIASel() { return _5g_EIASel; }
+
 //------------------------------------------------------------------------------
 void UESecurityCapability::setLenght(uint8_t len) {
   if ((len > 0) && (len <= 4)) {
@@ -93,9 +105,9 @@ int UESecurityCapability::encode2buffer(uint8_t *buf, int len) {
     *(buf + encoded_size) = _5g_IASel;
     encoded_size++;
     if (length == 4) {
-      *(buf + encoded_size) = 0xf0;
+      *(buf + encoded_size) = _5g_EEASel;
       encoded_size++;
-      *(buf + encoded_size) = 0xf0;
+      *(buf + encoded_size) = _5g_EIASel;
       encoded_size++;
     }
 
@@ -107,9 +119,9 @@ int UESecurityCapability::encode2buffer(uint8_t *buf, int len) {
     *(buf + encoded_size) = _5g_IASel;
     encoded_size++;
     if (length == 4) {
-      *(buf + encoded_size) = 0xf0;
+      *(buf + encoded_size) = _5g_EEASel;
       encoded_size++;
-      *(buf + encoded_size) = 0xf0;
+      *(buf + encoded_size) = _5g_EIASel;
       encoded_size++;
     }
   }
@@ -132,7 +144,14 @@ int UESecurityCapability::decodefrombuffer(uint8_t *buf, int len,
   _5g_IASel = *(buf + decoded_size);
   decoded_size++;
   if (length == 4)
-    decoded_size += 2; // to do: decoding EEA EIA
+  {
+    //decoded_size += 2; // to do: decoding EEA EIA
+    _5g_EEASel = *(buf + decoded_size);
+    decoded_size++;
+    _5g_EIASel = *(buf + decoded_size);
+    decoded_size++;
+  }
+
   Logger::nas_mm().debug("UESecurityCapability EA 0x%d,IA 0x%d", _5g_EASel,
                          _5g_IASel);
   return decoded_size;

src/nas/ies/UESecurityCapability.hpp

@@ -44,6 +44,10 @@ public:
   void setIASel(uint8_t sel);
   uint8_t getEASel();
   uint8_t getIASel();
+  void setEEASel(uint8_t sel);
+  void setEIASel(uint8_t sel);
+  uint8_t getEEASel();
+  uint8_t getEIASel();
   void setLenght(uint8_t len);
   uint8_t getLenght();
   int encode2buffer(uint8_t *buf, int len);
@@ -54,6 +58,8 @@ private:
   uint8_t length;
   uint8_t _5g_EASel;
   uint8_t _5g_IASel;
+  uint8_t _5g_EEASel;
+  uint8_t _5g_EIASel;
 };
 
 } // namespace nas

src/nas/ies/_5GSDeregistrationType.cpp

@@ -83,13 +83,15 @@ void _5GSDeregistrationType::get(uint8_t& type) {
 
 //------------------------------------------------------------------------------
 int _5GSDeregistrationType::encode2buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().error("Encoding 5GSDeregistrationType IE");
+  Logger::nas_mm().debug("Encoding 5GSDeregistrationType (0x%x)",u1.b);
   if (len < 1) {
     Logger::nas_mm().error(
         "encoding 5GSDeregistrationType error(len is less than one)");
     return -1;
   }
+
   *buf = u1.b;
+  return 0;
 }
 
 //------------------------------------------------------------------------------

src/nas/msgs/DeregistrationRequest.cpp

@@ -51,6 +51,14 @@ void DeregistrationRequest::setHeader(uint8_t security_header_type) {
       EPD_5GS_MM_MSG, security_header_type,
       DEREGISTRATION_REQUEST_UE_ORIGINATING);
 }
+//------------------------------------------------------------------------------
+void DeregistrationRequest::setHeader(uint8_t security_header_type,uint8_t msg_type) {
+  plain_header = new NasMmPlainHeader();
+  plain_header->setHeader(
+      EPD_5GS_MM_MSG, security_header_type,
+      msg_type);
+}
+
 
 //------------------------------------------------------------------------------
 void DeregistrationRequest::setDeregistrationType(uint8_t dereg_type) {
@@ -161,11 +169,11 @@ int DeregistrationRequest::encode2buffer(uint8_t* buf, int len) {
     Logger::nas_mm().error("Mandatory IE missing Deregistration Type");
     return 0;
   }
-  if (!ie_ngKSI) {
+  if ((!ie_ngKSI) && (plain_header->getMessageType() == DEREGISTRATION_REQUEST_UE_ORIGINATING)) {
     Logger::nas_mm().error("Mandatory IE missing ie_ngKSI");
     return 0;
   }
-  if (!ie_5gs_mobility_id) {
+  if ((!ie_5gs_mobility_id) && (plain_header->getMessageType() == DEREGISTRATION_REQUEST_UE_ORIGINATING)) {
     Logger::nas_mm().error("Mandatory IE missing ie_5gs_mobility_id");
     return 0;
   }
@@ -173,27 +181,41 @@ int DeregistrationRequest::encode2buffer(uint8_t* buf, int len) {
   encoded_size += 3;
   if (!(ie_deregistrationtype->encode2buffer(
           buf + encoded_size, len - encoded_size))) {
-    if (!(ie_ngKSI->encode2buffer(buf + encoded_size, len - encoded_size))) {
+    if (ie_ngKSI != NULL)
+    {
+      if (ie_ngKSI->encode2buffer(buf + encoded_size, len - encoded_size)) {
+        encoded_size += 1;
+      } else {
+        Logger::nas_mm().error("Encoding IE ie_ngKSI error");
+        return 0;
+      }
+    }
+    else {
       encoded_size += 1;
-    } else {
-      Logger::nas_mm().error("Encoding IE ie_ngKSI error");
-      return 0;
     }
   } else {
     Logger::nas_mm().error("Encoding IE Deregistrationt Type error");
     return 0;
   }
-  if (int size = ie_5gs_mobility_id->encode2buffer(
-          buf + encoded_size, len - encoded_size)) {
-    encoded_size += size;
-  } else {
-    Logger::nas_mm().error("Encoding IE ie_5gs_mobility_id  error");
-    return 0;
+  if (plain_header->getMessageType() == DEREGISTRATION_REQUEST_UE_ORIGINATING)
+  {
+    if (int size = ie_5gs_mobility_id->encode2buffer(
+            buf + encoded_size, len - encoded_size)) {
+      encoded_size += size;
+    } else {
+      Logger::nas_mm().error("Encoding IE ie_5gs_mobility_id  error");
+      return 0;
+    }
   }
 
+//  *(buf + encoded_size) = 0x58;
+//  encoded_size += 1;
+//  *(buf + encoded_size) = 6;
+//  encoded_size += 1;
+
   Logger::nas_mm().debug(
       "Encoded DeregistrationRequest message len (%d)", encoded_size);
-  return 1;
+  return encoded_size;
 }
 
 //------------------------------------------------------------------------------

src/nas/msgs/DeregistrationRequest.hpp

@@ -41,6 +41,7 @@ class DeregistrationRequest {
   int encode2buffer(uint8_t* buf, int len);
   int decodefrombuffer(NasMmPlainHeader* header, uint8_t* buf, int len);
   void setHeader(uint8_t security_header_type);
+  void setHeader(uint8_t security_header_type,uint8_t msg_type);
   void setDeregistrationType(uint8_t dereg_type);
   void setDeregistrationType(_5gs_deregistration_type_t type);
   void setngKSI(uint8_t tsc, uint8_t key_set_id);

src/nas/msgs/RegistrationRequest.cpp

@@ -231,8 +231,9 @@ bool RegistrationRequest::getUeSecurityCapability(uint8_t& ea, uint8_t& ia) {
     ea = ie_ue_security_capability->getEASel();
     ia = ie_ue_security_capability->getIASel();
   } else {
-    return -1;
+    return false;
   }
+  return true;
 }
 
 //------------------------------------------------------------------------------
@@ -299,7 +300,7 @@ uint16_t RegistrationRequest::getPduSessionStatus() {
   if (ie_PDU_session_status) {
     return ie_PDU_session_status->getValue();
   } else {
-    return -1;
+    return 0;
   }
 }
 
@@ -386,9 +387,9 @@ void RegistrationRequest::setEPS_NAS_Message_Container(bstring value) {
 bool RegistrationRequest::getEpsNasMessageContainer(bstring& epsNas) {
   if (ie_eps_nas_message_container) {
     ie_eps_nas_message_container->getValue(epsNas);
-    return 0;
+    return true;
   } else {
-    return -1;
+    return false;
   }
 }
 
@@ -486,9 +487,9 @@ void RegistrationRequest::setNAS_Message_Container(bstring value) {
 bool RegistrationRequest::getNasMessageContainer(bstring& nas) {
   if (ie_nas_message_container) {
     ie_nas_message_container->getValue(nas);
-    return 0;
+    return true;
   } else {
-    return -1;
+    return false;
   }
 }
 

src/ngap/ngapIEs/FiveGSTmsi.cpp

@@ -46,6 +46,7 @@ bool FiveGSTmsi::decodefrompdu(Ngap_FiveG_S_TMSI_t pdu) {
   amfSetid.getAMFSetID(setId);
   amfPointer.getAMFPointer(pointer);
   _5g_s_tmsi = setId + pointer + std::to_string(tmsi);
+  tmsi_value = std::to_string(tmsi);
   return true;
 }
 
@@ -53,3 +54,36 @@ bool FiveGSTmsi::decodefrompdu(Ngap_FiveG_S_TMSI_t pdu) {
 void FiveGSTmsi::getValue(std::string& tmsi) {
   tmsi = _5g_s_tmsi;
 }
+
+//------------------------------------------------------------------------------
+void FiveGSTmsi::getValue(std::string& setid,std::string& pointer,std::string& tmsi)
+{
+  amfSetid.getAMFSetID(setid);
+  amfPointer.getAMFPointer(pointer);
+  tmsi = tmsi_value;
+}
+
+
+//------------------------------------------------------------------------------
+void FiveGSTmsi::setValue(std::string& setid,std::string& pointer,std::string& tmsi)
+{
+  amfSetid.setAMFSetID(setid);
+  amfPointer.setAMFPointer(pointer);
+  _5g_s_tmsi = tmsi;
+}
+
+  //------------------------------------------------------------------------------
+bool FiveGSTmsi::encode2pdu(Ngap_FiveG_S_TMSI_t* pdu)
+{
+  amfSetid.encode2bitstring(pdu->aMFSetID);
+  amfPointer.encode2bitstring(pdu->aMFPointer);
+
+  uint32_t tmsi = (uint32_t)std::stol(_5g_s_tmsi);
+  uint8_t *buf = (uint8_t *)malloc(sizeof(uint32_t));
+  *(uint32_t *)buf = htonl(tmsi);
+  pdu->fiveG_TMSI.buf = buf;
+  pdu->fiveG_TMSI.size = sizeof(uint32_t);
+
+  return true;
+}
+

src/ngap/ngapIEs/FiveGSTmsi.hpp

@@ -46,9 +46,13 @@ class FiveGSTmsi {
  public:
   bool decodefrompdu(Ngap_FiveG_S_TMSI_t pdu);
   void getValue(std::string& value);
+  void getValue(std::string& setid,std::string& pointer,std::string& tmsi);
+  void setValue(std::string& setid,std::string& pointer,std::string& tmsi);
+  bool encode2pdu(Ngap_FiveG_S_TMSI_t* pdu);
 
  private:
   std::string _5g_s_tmsi;
+  std::string tmsi_value;
 
   AMFSetID amfSetid;
   AMFPointer amfPointer;

src/ngap/ngapIEs/PlmnId.cpp

@@ -66,12 +66,23 @@ void PlmnId::getMcc(std::string& mcc) {
 
 //------------------------------------------------------------------------------
 void PlmnId::getMnc(std::string& mnc) {
-  int m_mnc = 0;
+  //int m_mnc = 0;
   if (mnc_digit1 == 0xf)
-    m_mnc = mnc_digit2 * 10 + mnc_digit3;
+  {
+   //m_mnc = mnc_digit2 * 10 + mnc_digit3;
+    mnc = to_string(mnc_digit2);
+
+    mnc += to_string(mnc_digit3);
+  }
   else
-    m_mnc = mnc_digit1 * 100 + mnc_digit2 * 10 + mnc_digit3;
-  mnc = to_string(m_mnc);
+  {
+   //m_mnc = mnc_digit1 * 100 + mnc_digit2 * 10 + mnc_digit3;
+    mnc = to_string(mnc_digit1);
+    mnc = to_string(mnc_digit2);
+    mnc += to_string(mnc_digit3);
+  }
+  //mnc = to_string(m_mnc);
+  cout<<"################ MNC "<<mnc<<endl;
 }
 
 //------------------------------------------------------------------------------

src/ngap/ngapIEs/TAIListforPaging.cpp

+#include "TAIListforPaging.hpp"
+
+extern "C" {
+#include "Ngap_TAIListForPagingItem.h"
+}
+
+#include <iostream>
+using namespace std;
+
+namespace ngap {
+
+//------------------------------------------------------------------------------
+TAIListForPaging::TAIListForPaging() {
+  tai         = NULL;
+  numOftai    = 0;
+}
+
+//------------------------------------------------------------------------------
+TAIListForPaging::~TAIListForPaging() {
+  if(!tai) delete [] tai;
+}
+
+//------------------------------------------------------------------------------
+bool TAIListForPaging::encode2TAIListForPaging(Ngap_TAIListForPaging_t* pdu) {
+  cout << "TAIListForPaging::numberOfItem  "<< numOftai << endl;
+  for (int i = 0; i < numOftai; i++) {
+    Ngap_TAIListForPagingItem_t* ta =
+        (Ngap_TAIListForPagingItem_t*) calloc(1, sizeof(Ngap_TAIListForPagingItem_t));
+    if (!tai[i].encode2TAI(&ta->tAI)) return false;
+    if (ASN_SEQUENCE_ADD(&pdu->list, ta) != 0) return false;
+  }
+  return true;
+}
+
+//------------------------------------------------------------------------------
+bool TAIListForPaging::decodefromTAIListForPaging(Ngap_TAIListForPaging_t *pdu) {
+  numOftai = pdu->list.count;
+  tai         = new TAI[numOftai];
+  for (int i = 0; i < numOftai; i++) {
+    if (!tai[i].decodefromTAI(&pdu->list.array[i]->tAI))
+      return false;
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+void TAIListForPaging::setTAIListForPaging(TAI* m_tai, int numOfItem) {
+  tai         = m_tai;
+  numOftai = numOfItem;
+}
+
+//------------------------------------------------------------------------------
+void TAIListForPaging::getTAIListForPaging(TAI*& m_tai, int& numOfItem) {
+  m_tai = tai;
+  numOfItem         = numOftai;
+}
+
+}  // namespace ngap
+

src/ngap/ngapIEs/TAIListforPaging.hpp

+#ifndef _TAILISTFORPAGING_H_
+#define _TAILISTFORPAGING_H_
+
+#include "TAI.hpp"
+
+extern "C" {
+#include "Ngap_TAIListForPaging.h"
+}
+
+namespace ngap {
+
+class TAIListForPaging {
+ public:
+  TAIListForPaging();
+  virtual ~TAIListForPaging();
+
+  void setTAIListForPaging(TAI* m_tai, int numOfItem);
+  void getTAIListForPaging(TAI*& m_tai, int& numOfItem);
+  bool encode2TAIListForPaging(Ngap_TAIListForPaging_t* pdu);
+  bool decodefromTAIListForPaging(Ngap_TAIListForPaging_t *pdu);
+
+ private:
+  TAI *tai;
+  int numOftai;
+};
+
+}  // namespace ngap
+
+
+
+#endif
+
+

src/ngap/ngapIEs/UEPagingIdentity.cpp

+#include "UEPagingIdentity.hpp"
+
+namespace ngap {
+UEPagingIdentity::UEPagingIdentity(){}
+UEPagingIdentity::~UEPagingIdentity(){}
+
+void UEPagingIdentity::setUEPagingIdentity(std::string& setid,std::string& pointer,std::string& tmsi)
+{
+  fiveGSTmsi.setValue(setid, pointer, tmsi);
+}
+void UEPagingIdentity::getUEPagingIdentity(std::string& _5g_s_tmsi)
+{
+  fiveGSTmsi.getValue(_5g_s_tmsi);
+}
+
+void UEPagingIdentity::getUEPagingIdentity(std::string& setid,std::string& pointer,std::string& tmsi)
+{
+  fiveGSTmsi.getValue(setid, pointer, tmsi);
+}
+bool UEPagingIdentity::encode2pdu(Ngap_UEPagingIdentity_t* pdu)
+{
+  pdu->present = Ngap_UEPagingIdentity_PR_fiveG_S_TMSI;
+  Ngap_FiveG_S_TMSI_t* ie = (Ngap_FiveG_S_TMSI_t *)calloc(1,sizeof(Ngap_FiveG_S_TMSI_t));
+  pdu->choice.fiveG_S_TMSI = ie;
+  if(!fiveGSTmsi.encode2pdu(pdu->choice.fiveG_S_TMSI)) return false;
+
+  return true;
+}
+bool UEPagingIdentity::decodefrompdu(Ngap_UEPagingIdentity_t pdu)
+{
+  if(pdu.present != Ngap_UEPagingIdentity_PR_fiveG_S_TMSI) return false;
+  if(!fiveGSTmsi.decodefrompdu(*pdu.choice.fiveG_S_TMSI)) return false;
+
+  return true;
+}
+}
+

src/ngap/ngapIEs/UEPagingIdentity.hpp

+#ifndef _UEPAGINGIDENTITY_H_
+#define _UEPAGINGIDENTITY_H_
+
+#include "FiveGSTmsi.hpp"
+
+extern "C" {
+#include "Ngap_UEPagingIdentity.h"
+}
+
+namespace ngap {
+
+class UEPagingIdentity {
+ public:
+  UEPagingIdentity();
+  virtual ~UEPagingIdentity();
+
+  void setUEPagingIdentity(std::string& setid,std::string& pointer,std::string& tmsi);
+  void getUEPagingIdentity(std::string& _5g_s_tmsi);
+  void getUEPagingIdentity(std::string& setid,std::string& pointer,std::string& tmsi);
+  bool encode2pdu(Ngap_UEPagingIdentity_t* pdu);
+  bool decodefrompdu(Ngap_UEPagingIdentity_t pdu);
+
+ private:
+  FiveGSTmsi fiveGSTmsi;
+};
+
+}  // namespace ngap
+
+
+
+#endif
+

src/ngap/ngapMsgs/InitialUEMessage.cpp

@@ -431,4 +431,13 @@ bool InitialUEMessageMsg::get5GS_TMSI(string& _5g_s_tmsi) {
     return false;
 }
 
+bool InitialUEMessageMsg::get5GS_TMSI(std :: string & setid,std :: string & pointer,std :: string & tmsi) {
+  if (fivegSTmsi) {
+    fivegSTmsi->getValue(setid, pointer, tmsi);
+    return true;
+  } else
+    return false;
+}
+
+
 }  // namespace ngap

src/ngap/ngapMsgs/InitialUEMessage.hpp

@@ -68,6 +68,7 @@ class InitialUEMessageMsg {
   int getRRCEstablishmentCause();
   int getUeContextRequest();
   bool get5GS_TMSI(std::string& _5g_s_tmsi);
+  bool get5GS_TMSI(std :: string & setid,std :: string & pointer,std :: string & tmsi);
 
  private:
   Ngap_NGAP_PDU_t* initialUEMessagePdu;

src/ngap/ngapMsgs/Paging.cpp

+#include "Paging.hpp"
+
+#include <iostream>
+using namespace std;
+
+namespace ngap {
+
+//------------------------------------------------------------------------------
+PagingMsg::PagingMsg() {
+  pagingPdu               = NULL;
+  pagingIEs               = NULL;
+  uePagingIdentity        = NULL;
+  taIListForPaging        = NULL;
+}
+
+//------------------------------------------------------------------------------
+PagingMsg::~PagingMsg() {
+  if(!uePagingIdentity) delete uePagingIdentity;
+  if(!taIListForPaging) delete taIListForPaging;
+}
+
+//------------------------------------------------------------------------------
+void PagingMsg::setMessageType() {
+  if (!pagingPdu)
+    pagingPdu = (Ngap_NGAP_PDU_t*) calloc(1, sizeof(Ngap_NGAP_PDU_t));
+
+  MessageType PagingTypeIE;
+  PagingTypeIE.setProcedureCode(
+      Ngap_ProcedureCode_id_Paging);
+  PagingTypeIE.setTypeOfMessage(
+      Ngap_NGAP_PDU_PR_initiatingMessage);
+  PagingTypeIE.setCriticality(Ngap_Criticality_ignore);
+  PagingTypeIE.setValuePresent(
+      Ngap_InitiatingMessage__value_PR_Paging);
+
+  if (PagingTypeIE.getProcedureCode() ==
+          Ngap_ProcedureCode_id_Paging &&
+      PagingTypeIE.getTypeOfMessage() ==
+          Ngap_NGAP_PDU_PR_initiatingMessage &&
+      PagingTypeIE.getCriticality() ==
+          Ngap_Criticality_ignore) {
+    PagingTypeIE.encode2pdu(pagingPdu);
+    pagingIEs = &(pagingPdu->choice.initiatingMessage->value
+                                .choice.Paging);
+  } else {
+    cout << "[warning] This information doesn't refer to Paging "
+            "Message!!!"
+         << endl;
+  }
+}
+
+//------------------------------------------------------------------------------
+int PagingMsg::encode2buffer(uint8_t* buf, int buf_size) {
+  asn_fprint(stderr, &asn_DEF_Ngap_NGAP_PDU, pagingPdu);
+  asn_enc_rval_t er = aper_encode_to_buffer(
+      &asn_DEF_Ngap_NGAP_PDU, NULL, pagingPdu, buf, buf_size);
+  cout << "er.encoded(" << er.encoded << ")" << endl;
+  return er.encoded;
+}
+
+//------------------------------------------------------------------------------
+bool PagingMsg::decodefrompdu(Ngap_NGAP_PDU_t* ngap_msg_pdu) {
+  pagingPdu = ngap_msg_pdu;
+
+  if (pagingPdu->present == Ngap_NGAP_PDU_PR_initiatingMessage) {
+    if (pagingPdu->choice.initiatingMessage &&
+        pagingPdu->choice.initiatingMessage->procedureCode ==
+            Ngap_ProcedureCode_id_Paging &&
+        pagingPdu->choice.initiatingMessage->criticality ==
+            Ngap_Criticality_ignore &&
+        pagingPdu->choice.initiatingMessage->value.present ==
+            Ngap_InitiatingMessage__value_PR_Paging) {
+      pagingIEs = &pagingPdu->choice.initiatingMessage
+                                 ->value.choice.Paging;
+    } else {
+      cout << "Check Paging message error!!!" << endl;
+      return false;
+    }
+  } else {
+    cout << "MessageType error!!!" << endl;
+    return false;
+  }
+  for (int i = 0; i < pagingIEs->protocolIEs.list.count; i++) {
+    switch (pagingIEs->protocolIEs.list.array[i]->id) {
+      case Ngap_ProtocolIE_ID_id_UEPagingIdentity: {
+        if (pagingIEs->protocolIEs.list.array[i]->criticality ==
+                Ngap_Criticality_ignore &&
+            pagingIEs->protocolIEs.list.array[i]->value.present ==
+                Ngap_PagingIEs__value_PR_UEPagingIdentity) {
+          uePagingIdentity = new UEPagingIdentity();
+          if (!uePagingIdentity->decodefrompdu(
+                  pagingIEs->protocolIEs.list.array[i]
+                      ->value.choice.UEPagingIdentity)) {
+            cout << "Decoded NGAP UEPagingIdentity IE error" << endl;
+            return false;
+          }
+          cout << "[Paging] Received UEPagingIdentity " << endl;
+        } else {
+          cout << "Decoded NGAP UEPagingIdentity IE error" << endl;
+          return false;
+        }
+      } break;
+      case Ngap_ProtocolIE_ID_id_TAIListForPaging: {
+        if (pagingIEs->protocolIEs.list.array[i]->criticality ==
+                Ngap_Criticality_ignore &&
+            pagingIEs->protocolIEs.list.array[i]->value.present ==
+                Ngap_PagingIEs__value_PR_TAIListForPaging) {
+          taIListForPaging = new TAIListForPaging();
+          if (!taIListForPaging->decodefromTAIListForPaging(
+                  &pagingIEs->protocolIEs.list.array[i]
+                      ->value.choice.TAIListForPaging)) {
+            cout << "Decoded NGAP TAIListForPaging IE error" << endl;
+            return false;
+          }
+          cout << "[Paging] Received TAIListForPaging " << endl;
+        } else {
+          cout << "Decoded NGAP TAIListForPaging IE error" << endl;
+          return false;
+        }
+      } break;
+      default: {
+        cout << "not decoded IE:"
+             << pagingIEs->protocolIEs.list.array[i]->id << endl;
+        return true;
+      }
+    }
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+void PagingMsg::setUEPagingIdentity(std::string SetId, std::string Pointer, std::string tmsi)
+{
+  if (!uePagingIdentity) uePagingIdentity = new UEPagingIdentity();
+  uePagingIdentity->setUEPagingIdentity(SetId,Pointer,tmsi);
+
+  Ngap_PagingIEs_t* ie = (Ngap_PagingIEs_t*) calloc(
+      1, sizeof(Ngap_PagingIEs_t));
+  ie->id            = Ngap_ProtocolIE_ID_id_UEPagingIdentity;
+  ie->criticality   = Ngap_Criticality_ignore;
+  ie->value.present = Ngap_PagingIEs__value_PR_UEPagingIdentity;
+
+  int ret = uePagingIdentity->encode2pdu(&ie->value.choice.UEPagingIdentity);
+  if (!ret) {
+    cout << "encode UEPagingIdentity IE error" << endl;
+    return;
+  }
+
+  ret = ASN_SEQUENCE_ADD(&pagingIEs->protocolIEs.list, ie);
+  if (ret != 0) cout << "encode UEPagingIdentity IE error" << endl;
+}
+void PagingMsg::getUEPagingIdentity(std::string& _5g_s_tmsi)
+{
+  uePagingIdentity->getUEPagingIdentity(_5g_s_tmsi);
+}
+void PagingMsg::getUEPagingIdentity(std::string& setid,std::string& pointer,std::string& tmsi)
+{
+  uePagingIdentity->getUEPagingIdentity(setid, pointer, tmsi);
+}
+
+//------------------------------------------------------------------------------
+void PagingMsg::setTAIListForPaging(const std::vector<struct Tai_s> list)
+{
+  if (list.size() == 0) {
+    cout << "[Warning] Setup failed, vector is empty!!!" << endl;
+    return;
+  }
+  if (!taIListForPaging) taIListForPaging = new TAIListForPaging();
+
+  TAI tai [list.size()];
+  PlmnId plmnid[list.size()];
+  TAC tac[list.size()];
+  for (int i = 0; i < list.size(); i++)
+  {
+    plmnid[i].setMccMnc(list[i].mcc, list[i].mnc);
+    tac[i].setTac(list[i].tac);
+    tai[i].setTAI(&plmnid[i], &tac[i]);
+  }
+  taIListForPaging->setTAIListForPaging(tai, list.size());
+
+  Ngap_PagingIEs_t* ie = (Ngap_PagingIEs_t*) calloc(
+      1, sizeof(Ngap_PagingIEs_t));
+  ie->id            = Ngap_ProtocolIE_ID_id_TAIListForPaging;
+  ie->criticality   = Ngap_Criticality_ignore;
+  ie->value.present = Ngap_PagingIEs__value_PR_TAIListForPaging;
+
+  int ret = taIListForPaging->encode2TAIListForPaging(&ie->value.choice.TAIListForPaging);
+  if (!ret) {
+    cout << "encode TAIListForPaging IE error" << endl;
+    return;
+  }
+
+  ret = ASN_SEQUENCE_ADD(&pagingIEs->protocolIEs.list, ie);
+  if (ret != 0) cout << "encode TAIListForPaging IE error" << endl;
+}
+void PagingMsg::getTAIListForPaging(std::vector<struct Tai_s>& list)
+{
+  if (!taIListForPaging) return ;
+  TAI* tailist;
+  int sizeoftailist;
+  taIListForPaging->getTAIListForPaging(tailist, sizeoftailist);
+
+  for (int i = 0; i < sizeoftailist; i++)
+  {
+    Tai_t tai;
+    PlmnId* plmnid;
+    TAC* tac;
+    tailist[i].getTAI(plmnid, tac);
+    plmnid->getMcc(tai.mcc);
+    plmnid->getMnc(tai.mnc);
+    tai.tac = tac->getTac();
+
+    list.push_back(tai);
+  }
+}
+
+}
\ No newline at end of file

src/ngap/ngapMsgs/Paging.hpp

+#ifndef _PAGING_H_
+#define _PAGING_H_
+
+#include "NgapIEsStruct.hpp"
+
+#include "MessageType.hpp"
+#include "UEPagingIdentity.hpp"
+#include "TAIListforPaging.hpp"
+
+extern "C" {
+#include "Ngap_NGAP-PDU.h"
+#include "Ngap_ProtocolIE-Field.h"
+#include "Ngap_Paging.h"
+}
+
+namespace ngap {
+
+class PagingMsg {
+ public:
+  PagingMsg();
+  virtual ~PagingMsg();
+
+  void setMessageType();
+  int encode2buffer(uint8_t* buf, int buf_size);
+  bool decodefrompdu(Ngap_NGAP_PDU_t* ngap_msg_pdu);
+
+  void setUEPagingIdentity(std::string SetId, std::string Pointer, std::string tmsi);
+  void getUEPagingIdentity(std::string& _5g_s_tmsi);
+  void getUEPagingIdentity(std::string& setid,std::string& pointer,std::string& tmsi);
+
+  void setTAIListForPaging(const std::vector<struct Tai_s> list);
+  void getTAIListForPaging(std::vector<struct Tai_s>& list);
+
+ private:
+  Ngap_NGAP_PDU_t* pagingPdu;
+  Ngap_Paging_t* pagingIEs;
+
+  UEPagingIdentity* uePagingIdentity;
+  TAIListForPaging* taIListForPaging;
+};
+
+}  // namespace ngap
+
+#endif
\ No newline at end of file

src/sbi/amf_server/AMFApiServer.cpp

@@ -17,6 +17,8 @@ void AMFApiServer::init(size_t thr) {
   m_nonUEN2MessagesCollectionDocumentApiImpl->init();
   m_nonUEN2MessagesSubscriptionsCollectionDocumentApiImpl->init();
   m_subscriptionsCollectionDocumentApiImpl->init();
+
+  m_testSignallingApiImpl->init();
   Logger::amf_server().debug("Initiate AMF server endpoints done!");
 }
 
@@ -53,6 +55,11 @@ void AMFApiServer::start() {
   if (m_subscriptionsCollectionDocumentApiImpl != nullptr)
     Logger::amf_server().debug(
         "AMF handler for SubscriptionsCollectionDocumentApiImpl");
+
+  if (m_testSignallingApiImpl != nullptr)
+    Logger::amf_server().debug(
+        "AMF handler for TestSignallingApiImpl");
+
   m_httpEndpoint->setHandler(m_router->handler());
   m_httpEndpoint->serve();
 }

src/sbi/amf_server/AMFApiServer.hpp

@@ -17,6 +17,8 @@
 #include "NonUEN2MessagesSubscriptionsCollectionDocumentApiImpl.h"
 #include "SubscriptionsCollectionDocumentApiImpl.h"
 
+#include "TestSignallingApiImpl.h"
+
 #define PISTACHE_SERVER_THREADS 2
 #define PISTACHE_SERVER_MAX_PAYLOAD 32768
 
@@ -59,6 +61,10 @@ class AMFApiServer {
     m_subscriptionsCollectionDocumentApiImpl =
         std::make_shared<SubscriptionsCollectionDocumentApiImpl>(
             m_router, amf_app_inst);
+
+    m_testSignallingApiImpl =
+        std::make_shared<TestSignallingApiImpl>(
+            m_router, amf_app_inst);
   }
 
   void init(size_t thr = 1);
@@ -88,4 +94,7 @@ class AMFApiServer {
       m_nonUEN2MessagesSubscriptionsCollectionDocumentApiImpl;
   std::shared_ptr<SubscriptionsCollectionDocumentApiImpl>
       m_subscriptionsCollectionDocumentApiImpl;
+
+  std::shared_ptr<TestSignallingApiImpl>
+      m_testSignallingApiImpl;
 };

src/sbi/amf_server/api/N1N2MessageCollectionDocumentApi.cpp

@@ -99,6 +99,7 @@ void N1N2MessageCollectionDocumentApi::n1_n2_message_transfer_handler(
       this->n1_n2_message_transfer(
           ueContextId, n1N2MessageTransferReqData, parts[1].body, parts[2].body,
           response);
+
   } catch (nlohmann::detail::exception& e) {
     // send a 400 error
     Logger::amf_server().error(

src/sbi/amf_server/api/TestSignallingApi.cpp

+#include "TestSignallingApi.h"
+
+namespace oai {
+namespace amf {
+namespace api {
+
+TestSignallingApi::
+    TestSignallingApi(
+        std::shared_ptr<Pistache::Rest::Router> rtr) {
+  router = rtr;
+}
+
+void TestSignallingApi::init() {
+  setupRoutes();
+}
+
+void TestSignallingApi::
+    setupRoutes() {
+  using namespace Pistache::Rest;
+
+  Routes::Post(
+      *router,
+      base + "/test-signalling/network-initiated-deregistration/:subscriptionId",
+      Routes::bind(&TestSignallingApi::test_signalling_network_initiated_deregistration_handler,this));
+  Routes::Post(
+      *router,
+      base + "/test-signalling/paging/:ueContextId",
+      Routes::bind(&TestSignallingApi::test_signalling_paging_handler,this));
+
+  // Default handler, called when a route is not found
+  router->addCustomHandler(Routes::bind(
+      &TestSignallingApi::
+          test_signalling_api_default_handler,
+      this));
+}
+
+void TestSignallingApi::
+    test_signalling_network_initiated_deregistration_handler(
+        const Pistache::Rest::Request& request,
+        Pistache::Http::ResponseWriter response) {
+  // Getting the path params
+  auto subscriptionId =
+      request.param(":subscriptionId").as<std::string>();
+
+  try {
+    this->test_signalling_network_initiated_deregistration(subscriptionId, response);
+  } catch (nlohmann::detail::exception& e) {
+    // send a 400 error
+    response.send(Pistache::Http::Code::Bad_Request, e.what());
+    return;
+  } catch (std::exception& e) {
+    // send a 500 error
+    response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+    return;
+  }
+}
+
+void TestSignallingApi::
+    test_signalling_paging_handler(
+        const Pistache::Rest::Request& request,
+        Pistache::Http::ResponseWriter response) {
+  // Getting the path params
+  auto ueContextId =
+      request.param(":ueContextId").as<std::string>();
+
+  try {
+    this->test_signalling_paging(ueContextId, response);
+  } catch (nlohmann::detail::exception& e) {
+    // send a 400 error
+    response.send(Pistache::Http::Code::Bad_Request, e.what());
+    return;
+  } catch (std::exception& e) {
+    // send a 500 error
+    response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+    return;
+  }
+}
+
+
+void TestSignallingApi::
+    test_signalling_api_default_handler(
+        const Pistache::Rest::Request&,
+        Pistache::Http::ResponseWriter response) {
+  response.send(
+      Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}  // namespace api
+}  // namespace amf
+}  // namespace oai
+

src/sbi/amf_server/api/TestSignallingApi.h

+#ifndef _TESTSIGNALLING_API_H_
+#define _TESTSIGNALLING_API_H_
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+#include <nlohmann/json.hpp>
+
+#include "ProblemDetails.h"
+#include <string>
+
+namespace oai {
+namespace amf {
+namespace api {
+
+class TestSignallingApi {
+ public:
+  TestSignallingApi(
+      std::shared_ptr<Pistache::Rest::Router>);
+  virtual ~TestSignallingApi() {}
+  void init();
+
+  const std::string base = "/namf-test/v1";
+
+ private:
+  void setupRoutes();
+
+  void test_signalling_network_initiated_deregistration_handler(
+      const Pistache::Rest::Request& request,
+      Pistache::Http::ResponseWriter response);
+  void test_signalling_paging_handler(
+      const Pistache::Rest::Request& request,
+      Pistache::Http::ResponseWriter response);
+  void test_signalling_api_default_handler(
+      const Pistache::Rest::Request& request,
+      Pistache::Http::ResponseWriter response);
+
+  std::shared_ptr<Pistache::Rest::Router> router;
+
+
+  virtual void test_signalling_network_initiated_deregistration(
+      const std::string& subscriptionId,
+      Pistache::Http::ResponseWriter& response) = 0;
+  virtual void test_signalling_paging(
+      const std::string& ueContextId,
+      Pistache::Http::ResponseWriter& response) = 0;
+};
+
+
+}  // namespace api
+}  // namespace amf
+}  // namespace oai
+
+#endif
+

src/sbi/amf_server/impl/N1N2MessageCollectionDocumentApiImpl.cpp

@@ -13,15 +13,25 @@
 
 #include "N1N2MessageCollectionDocumentApiImpl.h"
 #include "itti.hpp"
+//#include "itti_msg_n2.hpp"
 
 #include "amf_n11.hpp"
+
+//#include "amf_n2.hpp"
+//#include "Paging.hpp"
+
 #include "pdu_session_context.hpp"
 using namespace amf_application;
+using namespace ngap;
+
 
 extern void msg_str_2_msg_hex(std::string msg, bstring& b);
 extern void convert_string_2_hex(std::string& input, std::string& output);
 extern itti_mw* itti_inst;
 extern amf_n11* amf_n11_inst;
+
+//extern amf_n2* amf_n2_inst;
+
 extern void print_buffer(
     const std::string app, const std::string commit, uint8_t* buf, int len);
 
@@ -47,6 +57,7 @@ void N1N2MessageCollectionDocumentApiImpl::n1_n2_message_transfer(
       "not been implemented yet!");
 }
 
+
 void N1N2MessageCollectionDocumentApiImpl::n1_n2_message_transfer(
     const std::string& ueContextId,
     const N1N2MessageTransferReqData& n1N2MessageTransferReqData,

src/sbi/amf_server/impl/TestSignallingApiImpl.cpp

+#include "TestSignallingApiImpl.h"
+#include "itti.hpp"
+
+#include "amf_n11.hpp"
+
+#include "pdu_session_context.hpp"
+using namespace amf_application;
+//using namespace ngap;
+
+extern itti_mw* itti_inst;
+extern amf_n11* amf_n11_inst;
+
+namespace oai {
+namespace amf {
+namespace api {
+
+TestSignallingApiImpl::
+    TestSignallingApiImpl(
+        std::shared_ptr<Pistache::Rest::Router> rtr,
+        amf_application::amf_app* amf_app_inst)
+    : TestSignallingApi(rtr),
+      m_amf_app(amf_app_inst) {}
+
+void TestSignallingApiImpl::
+    test_signalling_network_initiated_deregistration(
+        const std::string& subscriptionId,
+        Pistache::Http::ResponseWriter& response) {
+  response.send(
+      Pistache::Http::Code::Ok,
+      "test_signalling_network_initiated_deregistration ok!\n");
+
+  std::string supi = subscriptionId;
+  Logger::amf_server().debug(
+      "Key for PDU Session context: SUPI (%s)", supi.c_str());
+  std::shared_ptr<pdu_session_context> psc;
+  if (amf_n11_inst->is_supi_to_pdu_ctx(supi)) {
+    psc = amf_n11_inst->supi_to_pdu_ctx(supi);
+
+    itti_test_signalling_network_initiated_deregistration* itti_msg =
+        new itti_test_signalling_network_initiated_deregistration(AMF_SERVER, TASK_AMF_APP);
+
+    itti_msg->ran_ue_ngap_id = psc.get()->ran_ue_ngap_id;
+    itti_msg->amf_ue_ngap_id = psc.get()->amf_ue_ngap_id;
+
+    std::shared_ptr<itti_test_signalling_network_initiated_deregistration> i =
+        std::shared_ptr<itti_test_signalling_network_initiated_deregistration>(itti_msg);
+    int ret = itti_inst->send_msg(i);
+    if (0 != ret) {
+      Logger::amf_server().error(
+          "Could not send ITTI message %s to task TASK_AMF_APP",
+          i->get_msg_name());
+    }
+
+  } else {
+    Logger::amf_server().error(
+        "Cannot get pdu_session_context with SUPI (%s)", supi.c_str());
+  }
+}
+
+void TestSignallingApiImpl::test_signalling_paging(
+          const std::string& ueContextId,
+          Pistache::Http::ResponseWriter& response) {
+    response.send(
+        Pistache::Http::Code::Ok,
+        "test_signalling_paging ok!\n");
+
+  std::string supi = ueContextId;
+  Logger::amf_server().debug(
+      "Key for PDU Session context: SUPI (%s)", supi.c_str());
+  std::shared_ptr<pdu_session_context> psc;
+  if (amf_n11_inst->is_supi_to_pdu_ctx(supi)) {
+    psc = amf_n11_inst->supi_to_pdu_ctx(supi);
+
+    itti_test_signalling_paging* itti_msg =
+        new itti_test_signalling_paging(AMF_SERVER, TASK_AMF_APP);
+
+    itti_msg->ran_ue_ngap_id = psc.get()->ran_ue_ngap_id;
+    itti_msg->amf_ue_ngap_id = psc.get()->amf_ue_ngap_id;
+
+    std::shared_ptr<itti_test_signalling_paging> i =
+        std::shared_ptr<itti_test_signalling_paging>(itti_msg);
+    int ret = itti_inst->send_msg(i);
+    if (0 != ret) {
+      Logger::amf_server().error(
+          "Could not send ITTI message %s to task TASK_AMF_APP",
+          i->get_msg_name());
+    }
+
+  } else {
+    Logger::amf_server().error(
+        "Cannot get pdu_session_context with SUPI (%s)", supi.c_str());
+  }
+}
+
+}  // namespace api
+}  // namespace amf
+}  // namespace oai
+

src/sbi/amf_server/impl/TestSignallingApiImpl.h

+#ifndef _TESTSIGNALLING_API_IMPL_H_
+#define _TESTSIGNALLING_API_IMPL_H_
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <TestSignallingApi.h>
+
+#include <pistache/optional.h>
+
+#include "ProblemDetails.h"
+#include <string>
+
+#include "amf_app.hpp"
+
+namespace oai {
+namespace amf {
+namespace api {
+
+class TestSignallingApiImpl
+    : public oai::amf::api::
+          TestSignallingApi {
+ public:
+  TestSignallingApiImpl(
+      std::shared_ptr<Pistache::Rest::Router>,
+      amf_application::amf_app* amf_app_inst);
+  ~TestSignallingApiImpl() {}
+
+  void test_signalling_network_initiated_deregistration(
+      const std::string& subscriptionId,
+      Pistache::Http::ResponseWriter& response);
+  void test_signalling_paging(
+          const std::string& ueContextId,
+          Pistache::Http::ResponseWriter& response);
+
+ private:
+  amf_application::amf_app* m_amf_app;
+};
+
+}  // namespace api
+}  // namespace amf
+}  // namespace oai
+
+#endif
+