Merge branch 'pdu_session_resource_modify' into 'develop'

Pdu session resource modify

See merge request oai/cn5g/oai-cn5g-amf!59

src/amf-app/amf_n1.cpp

@@ -155,8 +155,8 @@ void amf_n1::handle_itti_message(itti_downlink_nas_transfer& itti_msg) {
       protected_nas);
 
   if (itti_msg.is_n2sm_set) {
+    // PDU Session Resource Release Command
     if (itti_msg.n2sm_info_type.compare("PDU_RES_REL_CMD") == 0) {
-      // PDU SESSION RESOURCE RELEASE COMMAND
       itti_pdu_session_resource_release_command* release_command =
           new itti_pdu_session_resource_release_command(
               TASK_AMF_N1, TASK_AMF_N2);
@@ -174,6 +174,46 @@ void amf_n1::handle_itti_message(itti_downlink_nas_transfer& itti_msg) {
             "Could not send ITTI message %s to task TASK_AMF_N2",
             i->get_msg_name());
       }
+      // PDU Session Resource Modify Request
+    } else if (itti_msg.n2sm_info_type.compare("PDU_RES_MOD_REQ") == 0) {
+      std::shared_ptr<itti_pdu_session_resource_modify_request>
+          itti_modify_request_msg =
+              std::make_shared<itti_pdu_session_resource_modify_request>(
+                  TASK_AMF_N1, TASK_AMF_N2);
+      itti_modify_request_msg->nas            = protected_nas;
+      itti_modify_request_msg->n2sm           = itti_msg.n2sm;
+      itti_modify_request_msg->amf_ue_ngap_id = amf_ue_ngap_id;
+      itti_modify_request_msg->ran_ue_ngap_id = ran_ue_ngap_id;
+      itti_modify_request_msg->pdu_session_id = itti_msg.pdu_session_id;
+
+      // Get NSSAI
+      std::shared_ptr<nas_context> nc = {};
+      if (!is_amf_ue_id_2_nas_context(amf_ue_ngap_id)) {
+        Logger::amf_n1().warn(
+            "No existed NAS context for UE with amf_ue_ngap_id (0x%x)",
+            amf_ue_ngap_id);
+        return;
+      }
+      nc = amf_ue_id_2_nas_context(amf_ue_ngap_id);
+
+      std::shared_ptr<pdu_session_context> psc = {};
+      if (!amf_app_inst->find_pdu_session_context(
+              nc->imsi, itti_msg.pdu_session_id, psc)) {
+        Logger::amf_n1().error(
+            "Cannot get pdu_session_context with SUPI (%s)", nc->imsi.c_str());
+        return;
+      }
+
+      itti_modify_request_msg->s_NSSAI.setSd(psc->snssai.sD);
+      itti_modify_request_msg->s_NSSAI.setSst(std::to_string(psc->snssai.sST));
+
+      int ret = itti_inst->send_msg(itti_modify_request_msg);
+      if (0 != ret) {
+        Logger::amf_n1().error(
+            "Could not send ITTI message %s to task TASK_AMF_N2",
+            itti_modify_request_msg->get_msg_name());
+      }
+
     } else {
       string ue_context_key = "app_ue_ranid_" + to_string(ran_ue_ngap_id) +
                               ":amfid_" + to_string(amf_ue_ngap_id);

src/amf-app/amf_n2.cpp

@@ -40,6 +40,7 @@
 #include "PDUSessionResourceHandoverCommandTransfer.hpp"
 #include "PduSessionResourceReleaseCommand.hpp"
 #include "PduSessionResourceSetupRequest.hpp"
+#include "PduSessionResourceModifyRequest.hpp"
 #include "UEContextReleaseCommand.hpp"
 #include "HandoverPreparationFailure.hpp"
 #include "Paging.hpp"
@@ -132,6 +133,13 @@ void amf_n2_task(void* args_p) {
             dynamic_cast<itti_pdu_session_resource_setup_request*>(msg);
         amf_n2_inst->handle_itti_message(ref(*m));
       } break;
+      case PDU_SESSION_RESOURCE_MODIFY_REQUEST: {
+        Logger::amf_n2().info(
+            "Received PDU_SESSION_RESOURCE_MODIFY_REQUEST message, handling");
+        itti_pdu_session_resource_modify_request* m =
+            dynamic_cast<itti_pdu_session_resource_modify_request*>(msg);
+        amf_n2_inst->handle_itti_message(ref(*m));
+      } break;
       case INITIAL_CONTEXT_SETUP_REQUEST: {
         Logger::amf_n2().info(
             "Encoding INITIAL CONTEXT SETUP REQUEST message, sending");
@@ -1028,6 +1036,81 @@ void amf_n2::handle_itti_message(
   free_wrapper((void**) &buffer);
 }
 
+//------------------------------------------------------------------------------
+void amf_n2::handle_itti_message(
+    itti_pdu_session_resource_modify_request& itti_msg) {
+  Logger::amf_n2().debug("Handle PDU Session Resource Modify Request ...");
+
+  if (!amf_n2_inst->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;
+  }
+
+  std::shared_ptr<ue_ngap_context> unc = {};
+  unc = ran_ue_id_2_ue_ngap_context(itti_msg.ran_ue_ngap_id);
+  if (unc.get() == nullptr) {
+    Logger::amf_n2().error(
+        "Illegal UE with ran_ue_ngap_id (0x%x)", itti_msg.ran_ue_ngap_id);
+    return;
+  }
+  std::shared_ptr<gnb_context> gc = {};
+  if (!is_assoc_id_2_gnb_context(unc.get()->gnb_assoc_id)) {
+    Logger::amf_n2().error(
+        "No existing gNG context with assoc_id (%d)", unc.get()->gnb_assoc_id);
+    return;
+  }
+  gc = assoc_id_2_gnb_context(unc.get()->gnb_assoc_id);
+  if (gc.get() == nullptr) {
+    Logger::amf_n2().error(
+        "Illegal gNB with assoc id (0x%x)", unc.get()->gnb_assoc_id);
+    return;
+  }
+
+  std::unique_ptr<PduSessionResourceModifyRequestMsg> modify_request_msg =
+      std::make_unique<PduSessionResourceModifyRequestMsg>();
+
+  modify_request_msg->setAmfUeNgapId(itti_msg.amf_ue_ngap_id);
+  modify_request_msg->setRanUeNgapId(itti_msg.ran_ue_ngap_id);
+
+  std::vector<PDUSessionResourceModifyRequestItem_t> list;
+  PDUSessionResourceModifyRequestItem_t item = {};
+  item.pduSessionId                          = itti_msg.pdu_session_id;
+
+  item.pduSessionResourceModifyRequestTransfer.buf =
+      (uint8_t*) bdata(itti_msg.n2sm);
+  item.pduSessionResourceModifyRequestTransfer.size = blength(itti_msg.n2sm);
+  item.s_nssai.sd                                   = itti_msg.s_NSSAI.getSd();
+  item.s_nssai.sst                                  = itti_msg.s_NSSAI.getSst();
+
+  uint8_t* nas_pdu = (uint8_t*) calloc(1, blength(itti_msg.nas) + 1);
+  memcpy(nas_pdu, (uint8_t*) bdata(itti_msg.nas), blength(itti_msg.nas));
+  nas_pdu[blength(itti_msg.nas)] = '\0';
+  item.pduSessionNAS_PDU         = nas_pdu;
+  item.sizeofpduSessionNAS_PDU   = blength(itti_msg.nas);
+  list.push_back(item);
+
+  modify_request_msg->setPduSessionResourceModifyRequestList(list);
+
+  size_t buffer_size = BUFFER_SIZE_512;
+  char* buffer       = (char*) calloc(1, buffer_size);
+  int encoded_size   = 0;
+
+  modify_request_msg->encode2buffer_new(buffer, encoded_size);
+#if DEBUG_IS_ON
+  Logger::amf_n2().debug("N2 SM buffer data: ");
+  for (int i = 0; i < encoded_size; i++) printf("%02x ", (char) buffer[i]);
+#endif
+  Logger::amf_n2().debug(" (%d bytes) \n", encoded_size);
+
+  bstring b = blk2bstr(buffer, encoded_size);
+  sctp_s_38412.sctp_send_msg(
+      gc.get()->sctp_assoc_id, unc.get()->sctp_stream_send, &b);
+  // free memory
+  free_wrapper((void**) &nas_pdu);
+  free_wrapper((void**) &buffer);
+}
+
 //------------------------------------------------------------------------------
 void amf_n2::handle_itti_message(
     itti_pdu_session_resource_release_command& itti_msg) {

src/amf-app/amf_n2.hpp

@@ -32,7 +32,6 @@
 #include "DownlinkRANStatusTransfer.hpp"
 #include "HandoverCommandMsg.hpp"
 #include "HandoverRequest.hpp"
-#include "PduSessionResourceReleaseCommand.hpp"
 #include "amf.hpp"
 #include "itti_msg_n2.hpp"
 #include "ngap_app.hpp"
@@ -53,11 +52,12 @@ class amf_n2 : public ngap::ngap_app {
   void handle_itti_message(itti_dl_nas_transport& dl_nas_transport);
   void handle_itti_message(itti_initial_context_setup_request& itti_msg);
   void handle_itti_message(itti_pdu_session_resource_setup_request& itti_msg);
+  void handle_itti_message(itti_pdu_session_resource_modify_request& itti_msg);
+  void handle_itti_message(itti_pdu_session_resource_release_command& itti_msg);
   void handle_itti_message(itti_ue_context_release_request& itti_msg);
   void handle_itti_message(itti_ue_context_release_complete& itti_msg);
   void handle_itti_message(itti_ue_radio_capability_indication& itti_msg);
   void handle_itti_message(itti_ue_context_release_command& itti_msg);
-  void handle_itti_message(itti_pdu_session_resource_release_command& itti_msg);
   bool handle_itti_message(itti_handover_required& itti_msg);
   void handle_itti_message(itti_handover_request_Ack& itti_msg);
   void handle_itti_message(itti_handover_notify& itti_msg);

src/itti/itti_msg.hpp

@@ -70,6 +70,7 @@ typedef enum {
   ITTI_DL_NAS_TRANSPORT,
   INITIAL_CONTEXT_SETUP_REQUEST,
   PDU_SESSION_RESOURCE_SETUP_REQUEST,
+  PDU_SESSION_RESOURCE_MODIFY_REQUEST,
   PDU_SESSION_RESOURCE_RELEASE_COMMAND,
   UE_CONTEXT_RELEASE_REQUEST,
   UE_CONTEXT_RELEASE_COMPLETE,

src/itti/msgs/itti_msg_amf_app.hpp

@@ -70,6 +70,10 @@ class itti_n1n2_message_transfer_request : public itti_msg_amf_app {
     is_n2sm_set    = false;
     is_n1sm_set    = false;
     is_ppi_set     = false;
+    supi           = {};
+    n2sm_info_type = {};
+    pdu_session_id = 0;
+    ppi            = 0;
   }
   itti_n1n2_message_transfer_request(
       const itti_n1n2_message_transfer_request& i)

src/itti/msgs/itti_msg_n2.hpp

@@ -160,6 +160,22 @@ class itti_pdu_session_resource_setup_request : public itti_msg_n2 {
   uint8_t pdu_session_id;
 };
 
+class itti_pdu_session_resource_modify_request : public itti_msg_n2 {
+ public:
+  itti_pdu_session_resource_modify_request(
+      const task_id_t origin, const task_id_t destination)
+      : itti_msg_n2(PDU_SESSION_RESOURCE_MODIFY_REQUEST, origin, destination) {}
+  itti_pdu_session_resource_modify_request(
+      const itti_pdu_session_resource_modify_request& i)
+      : itti_msg_n2(i) {}
+  bstring nas;
+  bstring n2sm;
+  uint32_t ran_ue_ngap_id;
+  long amf_ue_ngap_id;
+  uint8_t pdu_session_id;
+  S_NSSAI s_NSSAI;
+};
+
 class itti_pdu_session_resource_release_command : public itti_msg_n2 {
  public:
   itti_pdu_session_resource_release_command(

src/ngap/libngap/Ngap_PDUSessionResourceModifyItemModRes.c

@@ -53,8 +53,8 @@ asn_TYPE_member_t asn_MBR_Ngap_PDUSessionResourceModifyItemModRes_1[] = {
      0,
      0, /* No default value */
      "pDUSessionID"},
-    {ATF_POINTER,
-     2,
+    {ATF_NOFLAGS,
+     0,
      offsetof(
          struct Ngap_PDUSessionResourceModifyItemModRes,
          pDUSessionResourceModifyResponseTransfer),
@@ -80,8 +80,7 @@ asn_TYPE_member_t asn_MBR_Ngap_PDUSessionResourceModifyItemModRes_1[] = {
      0, /* No default value */
      "iE-Extensions"},
 };
-static const int asn_MAP_Ngap_PDUSessionResourceModifyItemModRes_oms_1[] = {1,
-                                                                            2};
+static const int asn_MAP_Ngap_PDUSessionResourceModifyItemModRes_oms_1[] = {2};
 static const ber_tlv_tag_t
     asn_DEF_Ngap_PDUSessionResourceModifyItemModRes_tags_1[] = {
         (ASN_TAG_CLASS_UNIVERSAL | (16 << 2))};
@@ -100,7 +99,7 @@ asn_SEQUENCE_specifics_t
         3, /* Count of tags in the map */
         asn_MAP_Ngap_PDUSessionResourceModifyItemModRes_oms_1, /* Optional
                                                                   members */
-        2,
+        1,
         0, /* Root/Additions */
         3, /* First extension addition */
 };

src/ngap/libngap/Ngap_PDUSessionResourceModifyItemModRes.h

@@ -26,7 +26,7 @@ struct Ngap_ProtocolExtensionContainer;
 /* Ngap_PDUSessionResourceModifyItemModRes */
 typedef struct Ngap_PDUSessionResourceModifyItemModRes {
   Ngap_PDUSessionID_t pDUSessionID;
-  OCTET_STRING_t* pDUSessionResourceModifyResponseTransfer; /* OPTIONAL */
+  OCTET_STRING_t pDUSessionResourceModifyResponseTransfer;
   struct Ngap_ProtocolExtensionContainer* iE_Extensions; /* OPTIONAL */
   /*
    * This type is extensible,

src/ngap/ngapIEs/NAS-PDU.cpp

@@ -55,7 +55,7 @@ bool NAS_PDU::decodefromoctetstring(Ngap_NAS_PDU_t& m_naspdu) {
 }
 
 //------------------------------------------------------------------------------
-bool NAS_PDU::getNasPdu(uint8_t*& buffer, size_t& size) {
+bool NAS_PDU::getNasPdu(uint8_t*& buffer, size_t& size) const {
   buffer = (uint8_t*) naspdubuffer;
   size   = buffersize;
   if (!naspdubuffer) return false;

src/ngap/ngapIEs/NAS-PDU.hpp

@@ -42,7 +42,7 @@ class NAS_PDU {
 
   bool encode2octetstring(Ngap_NAS_PDU_t&);
   bool decodefromoctetstring(Ngap_NAS_PDU_t&);
-  bool getNasPdu(uint8_t*& buffer, size_t& size);
+  bool getNasPdu(uint8_t*& buffer, size_t& size) const;
   void setNasPdu(uint8_t* buffer, size_t size);
 
  private:

src/ngap/ngapIEs/NgapIEsStruct.hpp

@@ -102,6 +102,20 @@ typedef struct {
   OCTET_STRING_t pduSessionResourceSetupRequestTransfer;
 } PDUSessionResourceSetupRequestItem_t;
 
+typedef struct {
+  uint8_t pduSessionId;
+  uint8_t* pduSessionNAS_PDU;
+  size_t sizeofpduSessionNAS_PDU;
+  S_Nssai s_nssai;
+  OCTET_STRING_t pduSessionResourceModifyRequestTransfer;
+} PDUSessionResourceModifyRequestItem_t;
+
+typedef struct {
+  uint8_t pduSessionId;
+  OCTET_STRING_t pduSessionResourceModifyResponseTransfer;
+  OCTET_STRING_t pduSessionResourceModifyUnsuccessfulTransfer;
+} PDUSessionResourceModifyResponseItem_t;
+
 // section 9.2.1.3 PDU Session Resource Release Command (3GPP TS 38.413 V16.0.0
 // (2019-12))
 typedef struct {

src/ngap/ngapIEs/PDUSessionResourceModifyItemModReq.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date
+ \email: contact@openairinterface.org
+ */
+
+#include "PDUSessionResourceModifyItemModReq.hpp"
+
+#include <iostream>
+using namespace std;
+
+namespace ngap {
+
+//------------------------------------------------------------------------------
+PDUSessionResourceModifyItemModReq::PDUSessionResourceModifyItemModReq() {
+  nAS_PDU = nullptr;
+}
+
+//------------------------------------------------------------------------------
+PDUSessionResourceModifyItemModReq::~PDUSessionResourceModifyItemModReq() {}
+
+//------------------------------------------------------------------------------
+void PDUSessionResourceModifyItemModReq::setPDUSessionResourceModifyItemModReq(
+    const PDUSessionID& m_pDUSessionID, const NAS_PDU& m_nAS_PDU,
+    const OCTET_STRING_t m_pDUSessionResourceModifyRequestTransfer,
+    const S_NSSAI& m_s_NSSAI) {
+  pDUSessionID     = m_pDUSessionID;
+  uint8_t* nas_buf = nullptr;
+  size_t nas_len   = 0;
+  m_nAS_PDU.getNasPdu(nas_buf, nas_len);
+  if (!nAS_PDU) nAS_PDU = new NAS_PDU();
+  nAS_PDU->setNasPdu(nas_buf, nas_len);
+  pDUSessionResourceModifyRequestTransfer =
+      m_pDUSessionResourceModifyRequestTransfer;
+  s_NSSAI->setSd(m_s_NSSAI.getSd());
+  s_NSSAI->setSst(m_s_NSSAI.getSst());
+}
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceModifyItemModReq::
+    encode2PDUSessionResourceModifyItemModReq(
+        Ngap_PDUSessionResourceModifyItemModReq_t&
+            pduSessionResourceModifyItemModReq) {
+  if (!pDUSessionID.encode2PDUSessionID(
+          pduSessionResourceModifyItemModReq.pDUSessionID))
+    return false;
+  if (nAS_PDU) {
+    pduSessionResourceModifyItemModReq.nAS_PDU =
+        (Ngap_NAS_PDU_t*) calloc(1, sizeof(Ngap_NAS_PDU_t));
+    if (!pduSessionResourceModifyItemModReq.nAS_PDU) return false;
+    if (!nAS_PDU->encode2octetstring(
+            *pduSessionResourceModifyItemModReq.nAS_PDU)) {
+      if (pduSessionResourceModifyItemModReq.nAS_PDU != nullptr)
+        free(pduSessionResourceModifyItemModReq.nAS_PDU);
+      return false;
+    }
+  }
+
+  pduSessionResourceModifyItemModReq.pDUSessionResourceModifyRequestTransfer =
+      pDUSessionResourceModifyRequestTransfer;
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceModifyItemModReq::
+    decodefromPDUSessionResourceModifyItemModReq(
+        Ngap_PDUSessionResourceModifyItemModReq_t&
+            pduSessionResourceModifyItemModReq) {
+  if (!pDUSessionID.decodefromPDUSessionID(
+          pduSessionResourceModifyItemModReq.pDUSessionID))
+    return false;
+
+  if (pduSessionResourceModifyItemModReq.nAS_PDU) {
+    nAS_PDU = new NAS_PDU();
+    if (!nAS_PDU->decodefromoctetstring(
+            *pduSessionResourceModifyItemModReq.nAS_PDU))
+      return false;
+  }
+
+  pDUSessionResourceModifyRequestTransfer =
+      pduSessionResourceModifyItemModReq
+          .pDUSessionResourceModifyRequestTransfer;
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+void PDUSessionResourceModifyItemModReq::getPDUSessionResourceModifyItemModReq(
+    PDUSessionID& m_pDUSessionID, NAS_PDU& m_nAS_PDU,
+    OCTET_STRING_t& m_pDUSessionResourceModifyRequestTransfer,
+    S_NSSAI& m_s_NSSAI) {
+  m_pDUSessionID = pDUSessionID;
+  m_nAS_PDU      = *nAS_PDU;
+  m_pDUSessionResourceModifyRequestTransfer =
+      pDUSessionResourceModifyRequestTransfer;
+  m_s_NSSAI = *s_NSSAI;
+}
+
+}  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceModifyItemModReq.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date
+ \email: contact@openairinterface.org
+ */
+
+#ifndef _PDU_SESSION_RESOURCE_MODIFY_ITEM_MOD_REQ_H_
+#define _PDU_SESSION_RESOURCE_MODIFY_ITEM_MOD_REQ_H_
+
+#include "NAS-PDU.hpp"
+#include "PDUSessionID.hpp"
+#include "S-NSSAI.hpp"
+
+extern "C" {
+#include "Ngap_PDUSessionResourceModifyItemModReq.h"
+}
+
+namespace ngap {
+
+class PDUSessionResourceModifyItemModReq {
+ public:
+  PDUSessionResourceModifyItemModReq();
+  virtual ~PDUSessionResourceModifyItemModReq();
+
+  void setPDUSessionResourceModifyItemModReq(
+      const PDUSessionID& m_pDUSessionID, const NAS_PDU& m_nAS_PDU,
+      const OCTET_STRING_t m_pDUSessionResourceModifyRequestTransfer,
+      const S_NSSAI& m_s_NSSAI);
+  void getPDUSessionResourceModifyItemModReq(
+      PDUSessionID& m_pDUSessionID, NAS_PDU& m_nAS_PDU,
+      OCTET_STRING_t& m_pDUSessionResourceModifyRequestTransfer,
+      S_NSSAI& m_s_NSSAI);
+
+  bool encode2PDUSessionResourceModifyItemModReq(
+      Ngap_PDUSessionResourceModifyItemModReq_t&
+          pduSessionResourceModifyItemModReq);
+  bool decodefromPDUSessionResourceModifyItemModReq(
+      Ngap_PDUSessionResourceModifyItemModReq_t&
+          pduSessionResourceModifyItemModReq);
+
+ private:
+  PDUSessionID pDUSessionID;
+  NAS_PDU* nAS_PDU;  // Optional
+  OCTET_STRING_t pDUSessionResourceModifyRequestTransfer;
+  S_NSSAI* s_NSSAI;  // Optional
+};
+
+}  // namespace ngap
+
+#endif

src/ngap/ngapIEs/PDUSessionResourceModifyItemModRes.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date
+ \email: contact@openairinterface.org
+ */
+
+#include "PDUSessionResourceModifyItemModRes.hpp"
+
+#include <iostream>
+using namespace std;
+
+namespace ngap {
+
+//------------------------------------------------------------------------------
+PDUSessionResourceModifyItemModRes::PDUSessionResourceModifyItemModRes() {}
+
+//------------------------------------------------------------------------------
+PDUSessionResourceModifyItemModRes::~PDUSessionResourceModifyItemModRes() {}
+
+//------------------------------------------------------------------------------
+void PDUSessionResourceModifyItemModRes::setPDUSessionResourceModifyItemModRes(
+    const PDUSessionID& m_pDUSessionID,
+    const OCTET_STRING_t m_pDUSessionResourceModifyResponseTransfer) {
+  pDUSessionID = m_pDUSessionID;
+  pDUSessionResourceModifyResponseTransfer =
+      m_pDUSessionResourceModifyResponseTransfer;
+}
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceModifyItemModRes::
+    encode2PDUSessionResourceModifyItemModRes(
+        Ngap_PDUSessionResourceModifyItemModRes_t&
+            pduSessionResourceModifyItemModReq) {
+  if (!pDUSessionID.encode2PDUSessionID(
+          pduSessionResourceModifyItemModReq.pDUSessionID))
+    return false;
+
+  pduSessionResourceModifyItemModReq.pDUSessionResourceModifyResponseTransfer =
+      pDUSessionResourceModifyResponseTransfer;
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceModifyItemModRes::
+    decodefromPDUSessionResourceModifyItemModRes(
+        Ngap_PDUSessionResourceModifyItemModRes_t&
+            pduSessionResourceModifyItemModReq) {
+  if (!pDUSessionID.decodefromPDUSessionID(
+          pduSessionResourceModifyItemModReq.pDUSessionID))
+    return false;
+
+  pDUSessionResourceModifyResponseTransfer =
+      pduSessionResourceModifyItemModReq
+          .pDUSessionResourceModifyResponseTransfer;
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+void PDUSessionResourceModifyItemModRes::getPDUSessionResourceModifyItemModRes(
+    PDUSessionID& m_pDUSessionID,
+    OCTET_STRING_t& m_pDUSessionResourceModifyResponseTransfer) {
+  m_pDUSessionID = pDUSessionID;
+  m_pDUSessionResourceModifyResponseTransfer =
+      pDUSessionResourceModifyResponseTransfer;
+}
+
+}  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceModifyItemModRes.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date
+ \email: contact@openairinterface.org
+ */
+
+#ifndef _PDU_SESSION_RESOURCE_MODIFY_ITEM_MOD_RES_H_
+#define _PDU_SESSION_RESOURCE_MODIFY_ITEM_MOD_RES_H_
+
+#include "NAS-PDU.hpp"
+#include "PDUSessionID.hpp"
+#include "S-NSSAI.hpp"
+
+extern "C" {
+#include "Ngap_PDUSessionResourceModifyItemModRes.h"
+}
+
+namespace ngap {
+
+class PDUSessionResourceModifyItemModRes {
+ public:
+  PDUSessionResourceModifyItemModRes();
+  virtual ~PDUSessionResourceModifyItemModRes();
+
+  void setPDUSessionResourceModifyItemModRes(
+      const PDUSessionID& m_pDUSessionID,
+      const OCTET_STRING_t m_pDUSessionResourceModifyResponseTransfer);
+  void getPDUSessionResourceModifyItemModRes(
+      PDUSessionID& m_pDUSessionID,
+      OCTET_STRING_t& m_pDUSessionResourceModifyResponseTransfer);
+
+  bool encode2PDUSessionResourceModifyItemModRes(
+      Ngap_PDUSessionResourceModifyItemModRes_t&
+          pduSessionResourceModifyItemModRes);
+  bool decodefromPDUSessionResourceModifyItemModRes(
+      Ngap_PDUSessionResourceModifyItemModRes_t&
+          pduSessionResourceModifyItemModRes);
+
+ private:
+  PDUSessionID pDUSessionID;
+  OCTET_STRING_t pDUSessionResourceModifyResponseTransfer;  // Optional
+};
+
+}  // namespace ngap
+
+#endif

src/ngap/ngapIEs/PDUSessionResourceModifyListModReq.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date
+ \email: contact@openairinterface.org
+ */
+
+#include "PDUSessionResourceModifyListModReq.hpp"
+
+#include <iostream>
+using namespace std;
+
+namespace ngap {
+
+//------------------------------------------------------------------------------
+PDUSessionResourceModifyListModReq::PDUSessionResourceModifyListModReq() {}
+
+//------------------------------------------------------------------------------
+PDUSessionResourceModifyListModReq::~PDUSessionResourceModifyListModReq() {}
+
+//------------------------------------------------------------------------------
+void PDUSessionResourceModifyListModReq::setPDUSessionResourceModifyListModReq(
+    const std::vector<PDUSessionResourceModifyItemModReq>&
+        m_pduSessionResourceModifyListModReq) {
+  pduSessionResourceModifyListModReq = m_pduSessionResourceModifyListModReq;
+}
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceModifyListModReq::
+    encode2PDUSessionResourceModifyListModReq(
+        Ngap_PDUSessionResourceModifyListModReq_t&
+            m_pduSessionResourceModifyListModReq) {
+  for (auto pdu : pduSessionResourceModifyListModReq) {
+    Ngap_PDUSessionResourceModifyItemModReq_t* request =
+        (Ngap_PDUSessionResourceModifyItemModReq_t*) calloc(
+            1, sizeof(Ngap_PDUSessionResourceModifyItemModReq_t));
+
+    if (!request) return false;
+    if (!pdu.encode2PDUSessionResourceModifyItemModReq(*request)) return false;
+    if (ASN_SEQUENCE_ADD(&m_pduSessionResourceModifyListModReq.list, request) !=
+        0)
+      return false;
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceModifyListModReq::
+    decodefromPDUSessionResourceModifyListModReq(
+        Ngap_PDUSessionResourceModifyListModReq_t&
+            pduSessionResourceSetupListSUReq) {
+  uint32_t numberofPDUSessions = pduSessionResourceSetupListSUReq.list.count;
+
+  for (int i = 0; i < numberofPDUSessions; i++) {
+    PDUSessionResourceModifyItemModReq pduSessionResourceModifyItemModReq = {};
+
+    if (!pduSessionResourceModifyItemModReq
+             .decodefromPDUSessionResourceModifyItemModReq(
+                 *pduSessionResourceSetupListSUReq.list.array[i]))
+      return false;
+    pduSessionResourceModifyListModReq.push_back(
+        pduSessionResourceModifyItemModReq);
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+void PDUSessionResourceModifyListModReq::getPDUSessionResourceModifyListModReq(
+    std::vector<PDUSessionResourceModifyItemModReq>&
+        m_pduSessionResourceModifyListModReq) {
+  m_pduSessionResourceModifyListModReq = pduSessionResourceModifyListModReq;
+}
+
+}  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceModifyListModReq.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date
+ \email: contact@openairinterface.org
+ */
+
+#ifndef _PDU_SESSION_RESOURCE_MODIFY_LIST_MOD_REQ_H_
+#define _PDU_SESSION_RESOURCE_MODIFY_LIST_MOD_REQ_H_
+
+#include "PDUSessionResourceModifyItemModReq.hpp"
+#include <vector>
+
+extern "C" {
+#include "Ngap_PDUSessionResourceModifyListModReq.h"
+}
+
+namespace ngap {
+
+class PDUSessionResourceModifyListModReq {
+ public:
+  PDUSessionResourceModifyListModReq();
+  virtual ~PDUSessionResourceModifyListModReq();
+
+  void setPDUSessionResourceModifyListModReq(
+      const std::vector<PDUSessionResourceModifyItemModReq>&
+          m_pduSessionResourceModifyListModReq);
+  void getPDUSessionResourceModifyListModReq(
+      std::vector<PDUSessionResourceModifyItemModReq>&
+          m_pduSessionResourceModifyListModReq);
+  bool encode2PDUSessionResourceModifyListModReq(
+      Ngap_PDUSessionResourceModifyListModReq_t&
+          m_pduSessionResourceModifyListModReq);
+  bool decodefromPDUSessionResourceModifyListModReq(
+      Ngap_PDUSessionResourceModifyListModReq_t&
+          m_pduSessionResourceModifyListModReq);
+
+ private:
+  std::vector<PDUSessionResourceModifyItemModReq>
+      pduSessionResourceModifyListModReq;
+};
+
+}  // namespace ngap
+
+#endif

src/ngap/ngapIEs/PDUSessionResourceModifyListModRes.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date
+ \email: contact@openairinterface.org
+ */
+
+#include "PDUSessionResourceModifyListModRes.hpp"
+
+#include <iostream>
+using namespace std;
+
+namespace ngap {
+
+//------------------------------------------------------------------------------
+PDUSessionResourceModifyListModRes::PDUSessionResourceModifyListModRes() {}
+
+//------------------------------------------------------------------------------
+PDUSessionResourceModifyListModRes::~PDUSessionResourceModifyListModRes() {}
+
+//------------------------------------------------------------------------------
+void PDUSessionResourceModifyListModRes::setPDUSessionResourceModifyListModRes(
+    const std::vector<PDUSessionResourceModifyItemModRes>&
+        m_pduSessionResourceModifyListModRes) {
+  pduSessionResourceModifyListModRes = m_pduSessionResourceModifyListModRes;
+}
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceModifyListModRes::
+    encode2PDUSessionResourceModifyListModRes(
+        Ngap_PDUSessionResourceModifyListModRes_t&
+            m_pduSessionResourceModifyListModRes) {
+  for (auto pdu : pduSessionResourceModifyListModRes) {
+    Ngap_PDUSessionResourceModifyItemModRes_t* request =
+        (Ngap_PDUSessionResourceModifyItemModRes_t*) calloc(
+            1, sizeof(Ngap_PDUSessionResourceModifyItemModRes_t));
+
+    if (!request) return false;
+    if (!pdu.encode2PDUSessionResourceModifyItemModRes(*request)) return false;
+    if (ASN_SEQUENCE_ADD(&m_pduSessionResourceModifyListModRes.list, request) !=
+        0)
+      return false;
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceModifyListModRes::
+    decodefromPDUSessionResourceModifyListModRes(
+        Ngap_PDUSessionResourceModifyListModRes_t&
+            pduSessionResourceSetupListSURes) {
+  uint32_t numberofPDUSessions = pduSessionResourceSetupListSURes.list.count;
+
+  for (int i = 0; i < numberofPDUSessions; i++) {
+    PDUSessionResourceModifyItemModRes pduSessionResourceModifyItemModRes = {};
+
+    if (!pduSessionResourceModifyItemModRes
+             .decodefromPDUSessionResourceModifyItemModRes(
+                 *pduSessionResourceSetupListSURes.list.array[i]))
+      return false;
+    pduSessionResourceModifyListModRes.push_back(
+        pduSessionResourceModifyItemModRes);
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+void PDUSessionResourceModifyListModRes::getPDUSessionResourceModifyListModRes(
+    std::vector<PDUSessionResourceModifyItemModRes>&
+        m_pduSessionResourceModifyListModRes) {
+  m_pduSessionResourceModifyListModRes = pduSessionResourceModifyListModRes;
+}
+
+}  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceModifyListModRes.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date
+ \email: contact@openairinterface.org
+ */
+
+#ifndef _PDU_SESSION_RESOURCE_MODIFY_LIST_MOD_RES_H_
+#define _PDU_SESSION_RESOURCE_MODIFY_LIST_MOD_RES_H_
+
+#include "PDUSessionResourceModifyItemModRes.hpp"
+#include <vector>
+
+extern "C" {
+#include "Ngap_PDUSessionResourceModifyListModRes.h"
+}
+
+namespace ngap {
+
+class PDUSessionResourceModifyListModRes {
+ public:
+  PDUSessionResourceModifyListModRes();
+  virtual ~PDUSessionResourceModifyListModRes();
+
+  void setPDUSessionResourceModifyListModRes(
+      const std::vector<PDUSessionResourceModifyItemModRes>&
+          m_pduSessionResourceModifyListModRes);
+  void getPDUSessionResourceModifyListModRes(
+      std::vector<PDUSessionResourceModifyItemModRes>&
+          m_pduSessionResourceModifyListModRes);
+  bool encode2PDUSessionResourceModifyListModRes(
+      Ngap_PDUSessionResourceModifyListModRes_t&
+          m_pduSessionResourceModifyListModRes);
+  bool decodefromPDUSessionResourceModifyListModRes(
+      Ngap_PDUSessionResourceModifyListModRes_t&
+          m_pduSessionResourceModifyListModRes);
+
+ private:
+  std::vector<PDUSessionResourceModifyItemModRes>
+      pduSessionResourceModifyListModRes;
+};
+
+}  // namespace ngap
+
+#endif

src/ngap/ngapIEs/S-NSSAI.cpp

@@ -86,10 +86,15 @@ void S_NSSAI::setSst(const std::string charSst) {
 }
 
 //------------------------------------------------------------------------------
-void S_NSSAI::getSst(std::string& charSst) {
+void S_NSSAI::getSst(std::string& charSst) const {
   charSst = to_string((int) sst);
 }
 
+//------------------------------------------------------------------------------
+std::string S_NSSAI::getSst() const {
+  return to_string((int) sst);
+}
+
 //------------------------------------------------------------------------------
 void S_NSSAI::setSd(const std::string charSd) {
   sdIsSet = true;
@@ -97,7 +102,7 @@ void S_NSSAI::setSd(const std::string charSd) {
 }
 
 //------------------------------------------------------------------------------
-bool S_NSSAI::getSd(std::string& s_nssaiSd) {
+bool S_NSSAI::getSd(std::string& s_nssaiSd) const {
   if (sdIsSet) {
     s_nssaiSd = to_string(sd);
   } else
@@ -106,6 +111,13 @@ bool S_NSSAI::getSd(std::string& s_nssaiSd) {
   return sdIsSet;
 }
 
+//------------------------------------------------------------------------------
+std::string S_NSSAI::getSd() const {
+  if (sdIsSet) {
+    return to_string(sd);
+  } else
+    return "None";
+}
 //------------------------------------------------------------------------------
 bool S_NSSAI::encode2S_NSSAI(Ngap_S_NSSAI_t* s_NSSAI) {
   if (!sSTEncode2OctetString(s_NSSAI->sST)) return false;

src/ngap/ngapIEs/S-NSSAI.hpp

@@ -48,14 +48,16 @@ class S_NSSAI {
   bool sDEncode2OctetString(Ngap_SD_t*);
   bool sDdecodefromOctetString(Ngap_SD_t*);
   void setSst(const std::string charSst);
-  void getSst(std::string& charSst);
+  void getSst(std::string& charSst) const;
+  std::string getSst() const;
   void setSd(const std::string charSd);
-  bool getSd(std::string& s_nssaiSd);
+  bool getSd(std::string& s_nssaiSd) const;
+  std::string getSd() const;
   bool encode2S_NSSAI(Ngap_S_NSSAI_t*);
   bool decodefromS_NSSAI(Ngap_S_NSSAI_t*);
 
  private:
-  uint8_t sst;  // mandotory  OCTET_STRING(SIZE(1))
+  uint8_t sst;  // mandatory  OCTET_STRING(SIZE(1))
   uint32_t sd;  // OCTET_STRING(SIZE(3))
   bool sdIsSet;
 };

src/ngap/ngapMsgs/PduSessionResourceModifyRequest.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date 2021
+ \email: contact@openairinterface.org
+ */
+
+#include "PduSessionResourceModifyRequest.hpp"
+#include "amf.hpp"
+#include "logger.hpp"
+
+extern "C" {
+#include "asn_codecs.h"
+#include "constr_TYPE.h"
+#include "constraints.h"
+#include "dynamic_memory_check.h"
+#include "per_decoder.h"
+#include "per_encoder.h"
+}
+
+#include <iostream>
+using namespace std;
+
+namespace ngap {
+
+//------------------------------------------------------------------------------
+PduSessionResourceModifyRequestMsg::PduSessionResourceModifyRequestMsg() {
+  // Set Message Type
+  pduSessionResourceModifyRequestPdu =
+      (Ngap_NGAP_PDU_t*) calloc(1, sizeof(Ngap_NGAP_PDU_t));
+
+  MessageType pdu = {};
+  pdu.setProcedureCode(Ngap_ProcedureCode_id_PDUSessionResourceModify);
+
+  pdu.setTypeOfMessage(Ngap_NGAP_PDU_PR_initiatingMessage);
+  pdu.setCriticality(Ngap_Criticality_reject);
+  pdu.setValuePresent(
+      Ngap_InitiatingMessage__value_PR_PDUSessionResourceModifyRequest);
+  pdu.encode2pdu(pduSessionResourceModifyRequestPdu);
+  pduSessionResourceModifyRequestIEs =
+      &(pduSessionResourceModifyRequestPdu->choice.initiatingMessage->value
+            .choice.PDUSessionResourceModifyRequest);
+
+  ranPagingPriority            = nullptr;
+  pduSessionResourceModifyList = nullptr;
+}
+
+//------------------------------------------------------------------------------
+PduSessionResourceModifyRequestMsg::~PduSessionResourceModifyRequestMsg() {
+  if (pduSessionResourceModifyRequestPdu)
+    free(pduSessionResourceModifyRequestPdu);
+  // TODO:
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyRequestMsg::setMessageType() {
+  if (!pduSessionResourceModifyRequestPdu)
+    pduSessionResourceModifyRequestPdu =
+        (Ngap_NGAP_PDU_t*) calloc(1, sizeof(Ngap_NGAP_PDU_t));
+
+  MessageType pdu = {};
+  pdu.setProcedureCode(Ngap_ProcedureCode_id_PDUSessionResourceModify);
+
+  pdu.setTypeOfMessage(Ngap_NGAP_PDU_PR_initiatingMessage);
+  pdu.setCriticality(Ngap_Criticality_reject);
+  pdu.setValuePresent(
+      Ngap_InitiatingMessage__value_PR_PDUSessionResourceModifyRequest);
+  pdu.encode2pdu(pduSessionResourceModifyRequestPdu);
+  pduSessionResourceModifyRequestIEs =
+      &(pduSessionResourceModifyRequestPdu->choice.initiatingMessage->value
+            .choice.PDUSessionResourceModifyRequest);
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyRequestMsg::setAmfUeNgapId(unsigned long id) {
+  amfUeNgapId.setAMF_UE_NGAP_ID(id);
+
+  Ngap_PDUSessionResourceModifyRequestIEs_t* ie =
+      (Ngap_PDUSessionResourceModifyRequestIEs_t*) calloc(
+          1, sizeof(Ngap_PDUSessionResourceModifyRequestIEs_t));
+  ie->id          = Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID;
+  ie->criticality = Ngap_Criticality_reject;
+  ie->value.present =
+      Ngap_PDUSessionResourceModifyRequestIEs__value_PR_AMF_UE_NGAP_ID;
+
+  int ret = amfUeNgapId.encode2AMF_UE_NGAP_ID(ie->value.choice.AMF_UE_NGAP_ID);
+  if (!ret) {
+    Logger::ngap().error("Encode NGAP AMF_UE_NGAP_ID IE error");
+    free_wrapper((void**) &ie);
+    return;
+  }
+
+  ret = ASN_SEQUENCE_ADD(
+      &pduSessionResourceModifyRequestIEs->protocolIEs.list, ie);
+  if (ret != 0) Logger::ngap().error("Encode NGAP AMF_UE_NGAP_ID IE error");
+  // free_wrapper((void**) &ie);
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyRequestMsg::setRanUeNgapId(
+    uint32_t ran_ue_ngap_id) {
+  ranUeNgapId.setRanUeNgapId(ran_ue_ngap_id);
+
+  Ngap_PDUSessionResourceModifyRequestIEs_t* ie =
+      (Ngap_PDUSessionResourceModifyRequestIEs_t*) calloc(
+          1, sizeof(Ngap_PDUSessionResourceModifyRequestIEs_t));
+  ie->id          = Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID;
+  ie->criticality = Ngap_Criticality_reject;
+  ie->value.present =
+      Ngap_PDUSessionResourceModifyRequestIEs__value_PR_RAN_UE_NGAP_ID;
+
+  int ret = ranUeNgapId.encode2RAN_UE_NGAP_ID(ie->value.choice.RAN_UE_NGAP_ID);
+  if (!ret) {
+    Logger::ngap().error("Encode NGAP RAN_UE_NGAP_ID IE error");
+    free_wrapper((void**) &ie);
+    return;
+  }
+
+  ret = ASN_SEQUENCE_ADD(
+      &pduSessionResourceModifyRequestIEs->protocolIEs.list, ie);
+  if (ret != 0) Logger::ngap().error("Encode NGAP RAN_UE_NGAP_ID IE error");
+  // free_wrapper((void**) &ie);
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyRequestMsg::setRanPagingPriority(
+    uint8_t priority) {
+  if (!ranPagingPriority) ranPagingPriority = new RANPagingPriority();
+
+  ranPagingPriority->setRANPagingPriority(priority);
+
+  Ngap_PDUSessionResourceModifyRequestIEs_t* ie =
+      (Ngap_PDUSessionResourceModifyRequestIEs_t*) calloc(
+          1, sizeof(Ngap_PDUSessionResourceModifyRequestIEs_t));
+  ie->id          = Ngap_ProtocolIE_ID_id_RANPagingPriority;
+  ie->criticality = Ngap_Criticality_ignore;
+  ie->value.present =
+      Ngap_PDUSessionResourceModifyRequestIEs__value_PR_RANPagingPriority;
+
+  int ret = ranPagingPriority->encode2RANPagingPriority(
+      ie->value.choice.RANPagingPriority);
+  if (!ret) {
+    Logger::ngap().error("Encode NGAP RANPagingPriority IE error");
+    free_wrapper((void**) &ie);
+    return;
+  }
+
+  ret = ASN_SEQUENCE_ADD(
+      &pduSessionResourceModifyRequestIEs->protocolIEs.list, ie);
+  if (ret != 0) Logger::ngap().error("Encode NGAP RANPagingPriority IE error");
+  // free_wrapper((void**) &ie);
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyRequestMsg::setPduSessionResourceModifyRequestList(
+    std::vector<PDUSessionResourceModifyRequestItem_t> list) {
+  if (!pduSessionResourceModifyList)
+    pduSessionResourceModifyList = new PDUSessionResourceModifyListModReq();
+
+  std::vector<PDUSessionResourceModifyItemModReq>
+      m_pduSessionResourceModifyItemModReq;
+
+  for (int i = 0; i < list.size(); i++) {
+    PDUSessionID m_pDUSessionID = {};
+    m_pDUSessionID.setPDUSessionID(list[i].pduSessionId);
+    NAS_PDU m_nAS_PDU = {};
+    if (list[i].pduSessionNAS_PDU) {
+      m_nAS_PDU.setNasPdu(
+          list[i].pduSessionNAS_PDU, list[i].sizeofpduSessionNAS_PDU);
+    }
+    S_NSSAI s_NSSAI = {};
+    s_NSSAI.setSd(list[i].s_nssai.sd);
+    s_NSSAI.setSst(list[i].s_nssai.sst);
+
+    PDUSessionResourceModifyItemModReq item = {};
+
+    item.setPDUSessionResourceModifyItemModReq(
+        m_pDUSessionID, m_nAS_PDU,
+        list[i].pduSessionResourceModifyRequestTransfer, s_NSSAI);
+    m_pduSessionResourceModifyItemModReq.push_back(item);
+  }
+
+  pduSessionResourceModifyList->setPDUSessionResourceModifyListModReq(
+      m_pduSessionResourceModifyItemModReq);
+
+  // pduSessionResourceSetupRequestList->setPDUSessionResourceSetupListSUReq(
+  //    m_pduSessionResourceSetupItemSUReq, list.size());
+
+  Ngap_PDUSessionResourceModifyRequestIEs_t* ie =
+      (Ngap_PDUSessionResourceModifyRequestIEs_t*) calloc(
+          1, sizeof(Ngap_PDUSessionResourceModifyRequestIEs_t));
+  ie->id          = Ngap_ProtocolIE_ID_id_PDUSessionResourceModifyListModReq;
+  ie->criticality = Ngap_Criticality_reject;
+  ie->value.present =
+      Ngap_PDUSessionResourceModifyRequestIEs__value_PR_PDUSessionResourceModifyListModReq;
+
+  int ret =
+      pduSessionResourceModifyList->encode2PDUSessionResourceModifyListModReq(
+          ie->value.choice.PDUSessionResourceModifyListModReq);
+  if (!ret) {
+    Logger::ngap().error(
+        "Encode NGAP PDUSessionResourceModifyListModReq IE error");
+
+    free_wrapper((void**) &ie);
+    return;
+  }
+
+  ret = ASN_SEQUENCE_ADD(
+      &pduSessionResourceModifyRequestIEs->protocolIEs.list, ie);
+  if (ret != 0)
+    Logger::ngap().error(
+        "Encode NGAP PDUSessionResourceSetupListSUReq IE error");
+  // free_wrapper((void**) &ie);
+}
+
+//------------------------------------------------------------------------------
+int PduSessionResourceModifyRequestMsg::encode2buffer(
+    uint8_t* buf, int buf_size) {
+  asn_fprint(
+      stderr, &asn_DEF_Ngap_NGAP_PDU, pduSessionResourceModifyRequestPdu);
+  asn_enc_rval_t er = aper_encode_to_buffer(
+      &asn_DEF_Ngap_NGAP_PDU, NULL, pduSessionResourceModifyRequestPdu, buf,
+      buf_size);
+  Logger::ngap().debug("er.encoded (%d)", er.encoded);
+  return er.encoded;
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyRequestMsg::encode2buffer_new(
+    char* buf, int& encoded_size) {
+  char* buffer = (char*) calloc(1, BUFFER_SIZE_1024);
+  asn_fprint(
+      stderr, &asn_DEF_Ngap_NGAP_PDU, pduSessionResourceModifyRequestPdu);
+  encoded_size = aper_encode_to_new_buffer(
+      &asn_DEF_Ngap_NGAP_PDU, NULL, pduSessionResourceModifyRequestPdu,
+      (void**) &buffer);
+
+  Logger::ngap().debug("er.encoded (%d)", encoded_size);
+  memcpy((void*) buf, (void*) buffer, encoded_size);
+  free(buffer);
+}
+
+//------------------------------------------------------------------------------
+bool PduSessionResourceModifyRequestMsg::decodefrompdu(
+    Ngap_NGAP_PDU_t* ngap_msg_pdu) {
+  pduSessionResourceModifyRequestPdu = ngap_msg_pdu;
+
+  if (pduSessionResourceModifyRequestPdu->present ==
+      Ngap_NGAP_PDU_PR_initiatingMessage) {
+    if (pduSessionResourceModifyRequestPdu->choice.initiatingMessage &&
+        pduSessionResourceModifyRequestPdu->choice.initiatingMessage
+                ->procedureCode ==
+            Ngap_ProcedureCode_id_PDUSessionResourceModify &&
+        pduSessionResourceModifyRequestPdu->choice.initiatingMessage
+                ->criticality == Ngap_Criticality_reject &&
+        pduSessionResourceModifyRequestPdu->choice.initiatingMessage->value
+                .present ==
+            Ngap_InitiatingMessage__value_PR_PDUSessionResourceModifyRequest) {
+      pduSessionResourceModifyRequestIEs =
+          &pduSessionResourceModifyRequestPdu->choice.initiatingMessage->value
+               .choice.PDUSessionResourceModifyRequest;
+    } else {
+      Logger::ngap().error(
+          "Check PDUSessionResourceModifyRequest message error!");
+
+      return false;
+    }
+  } else {
+    Logger::ngap().error("MessageType error!");
+    return false;
+  }
+  for (int i = 0;
+       i < pduSessionResourceModifyRequestIEs->protocolIEs.list.count; i++) {
+    switch (pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]->id) {
+      case Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID: {
+        if (pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                    ->criticality == Ngap_Criticality_reject &&
+            pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                    ->value.present ==
+                Ngap_PDUSessionResourceModifyRequestIEs__value_PR_AMF_UE_NGAP_ID) {
+          if (!amfUeNgapId.decodefromAMF_UE_NGAP_ID(
+                  pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                      ->value.choice.AMF_UE_NGAP_ID)) {
+            Logger::ngap().error("Decoded NGAP AMF_UE_NGAP_ID IE error");
+            return false;
+          }
+        } else {
+          Logger::ngap().error("Decoded NGAP AMF_UE_NGAP_ID IE error");
+          return false;
+        }
+      } break;
+      case Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID: {
+        if (pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                    ->criticality == Ngap_Criticality_reject &&
+            pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                    ->value.present ==
+                Ngap_PDUSessionResourceModifyRequestIEs__value_PR_RAN_UE_NGAP_ID) {
+          if (!ranUeNgapId.decodefromRAN_UE_NGAP_ID(
+                  pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                      ->value.choice.RAN_UE_NGAP_ID)) {
+            Logger::ngap().error("Decoded NGAP RAN_UE_NGAP_ID IE error");
+            return false;
+          }
+        } else {
+          Logger::ngap().error("Decoded NGAP RAN_UE_NGAP_ID IE error");
+          return false;
+        }
+      } break;
+      case Ngap_ProtocolIE_ID_id_RANPagingPriority: {
+        if (pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                    ->criticality == Ngap_Criticality_ignore &&
+            pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                    ->value.present ==
+                Ngap_PDUSessionResourceModifyRequestIEs__value_PR_RANPagingPriority) {
+          ranPagingPriority = new RANPagingPriority();
+          if (!ranPagingPriority->decodefromRANPagingPriority(
+                  pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                      ->value.choice.RANPagingPriority)) {
+            Logger::ngap().error("Decoded NGAP RANPagingPriority IE error");
+            return false;
+          }
+        } else {
+          Logger::ngap().error("Decoded NGAP RANPagingPriority IE error");
+          return false;
+        }
+      } break;
+
+      case Ngap_ProtocolIE_ID_id_PDUSessionResourceModifyListModReq: {
+        if (pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                    ->criticality == Ngap_Criticality_reject &&
+            pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
+                    ->value.present ==
+                Ngap_PDUSessionResourceModifyRequestIEs__value_PR_PDUSessionResourceModifyListModReq) {
+          pduSessionResourceModifyList =
+              new PDUSessionResourceModifyListModReq();
+          if (!pduSessionResourceModifyList
+                   ->decodefromPDUSessionResourceModifyListModReq(
+                       pduSessionResourceModifyRequestIEs->protocolIEs.list
+                           .array[i]
+                           ->value.choice.PDUSessionResourceModifyListModReq)) {
+            Logger::ngap().error(
+                "Decoded NGAP PDUSessionResourceModifyListModReq IE error");
+            return false;
+          }
+        } else {
+          Logger::ngap().error(
+              "Decoded NGAP PDUSessionResourceModifyListModReq IE error");
+
+          return false;
+        }
+      } break;
+      default: {
+        Logger::ngap().error("Decoded NGAP Message PDU error");
+
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+unsigned long PduSessionResourceModifyRequestMsg::getAmfUeNgapId() {
+  return amfUeNgapId.getAMF_UE_NGAP_ID();
+}
+
+//------------------------------------------------------------------------------
+uint32_t PduSessionResourceModifyRequestMsg::getRanUeNgapId() {
+  return ranUeNgapId.getRanUeNgapId();
+}
+
+//------------------------------------------------------------------------------
+int PduSessionResourceModifyRequestMsg::getRanPagingPriority() {
+  if (!ranPagingPriority) return -1;
+  return ranPagingPriority->getRANPagingPriority();
+}
+
+//------------------------------------------------------------------------------
+bool PduSessionResourceModifyRequestMsg::getPduSessionResourceModifyRequestList(
+    std::vector<PDUSessionResourceModifyRequestItem_t>& list) {
+  if (!pduSessionResourceModifyList) return false;
+  std::vector<PDUSessionResourceModifyItemModReq>
+      m_pduSessionResourceModifyItemModReq;
+  int num = 0;
+  pduSessionResourceModifyList->getPDUSessionResourceModifyListModReq(
+      m_pduSessionResourceModifyItemModReq);
+
+  for (int i = 0; i < m_pduSessionResourceModifyItemModReq.size(); i++) {
+    PDUSessionResourceModifyRequestItem_t request;
+
+    PDUSessionID m_pDUSessionID = {};
+    NAS_PDU m_nAS_PDU           = {};
+    S_NSSAI s_NSSAI             = {};
+
+    m_pduSessionResourceModifyItemModReq[i]
+        .getPDUSessionResourceModifyItemModReq(
+            m_pDUSessionID, m_nAS_PDU,
+            request.pduSessionResourceModifyRequestTransfer, s_NSSAI);
+
+    m_pDUSessionID.getPDUSessionID(request.pduSessionId);
+
+    m_nAS_PDU.getNasPdu(
+        request.pduSessionNAS_PDU, request.sizeofpduSessionNAS_PDU);
+    s_NSSAI.getSd(request.s_nssai.sd);
+    s_NSSAI.getSst(request.s_nssai.sst);
+    list.push_back(request);
+  }
+
+  return true;
+}
+
+}  // namespace ngap

src/ngap/ngapMsgs/PduSessionResourceModifyRequest.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date 2021
+ \email: contact@openairinterface.org
+ */
+
+#ifndef PDU_SESSION_RESOURCE_MODIFY_REQUEST_H_
+#define PDU_SESSION_RESOURCE_MODIFY_REQUEST_H_
+
+#include "AMF-UE-NGAP-ID.hpp"
+#include "MessageType.hpp"
+#include "NgapIEsStruct.hpp"
+#include "PDUSessionResourceModifyListModReq.hpp"
+#include "RAN-UE-NGAP-ID.hpp"
+#include "RANPagingPriority.hpp"
+
+extern "C" {
+#include "Ngap_InitialContextSetupRequest.h"
+#include "Ngap_PDUSessionResourceModifyRequest.h"
+#include "Ngap_NGAP-PDU.h"
+#include "Ngap_ProtocolIE-Field.h"
+}
+
+namespace ngap {
+
+class PduSessionResourceModifyRequestMsg {
+ public:
+  PduSessionResourceModifyRequestMsg();
+  virtual ~PduSessionResourceModifyRequestMsg();
+
+  void setMessageType();
+  void setAmfUeNgapId(unsigned long id);  // 40 bits
+  void setRanUeNgapId(uint32_t id);       // 32 bits
+  void setRanPagingPriority(uint8_t priority);
+  void setNasPdu(uint8_t* nas, size_t sizeofnas);
+
+  void setPduSessionResourceModifyRequestList(
+      std::vector<PDUSessionResourceModifyRequestItem_t> list);
+
+  int encode2buffer(uint8_t* buf, int buf_size);
+  void encode2buffer_new(char* buf, int& encoded_size);
+
+  bool decodefrompdu(Ngap_NGAP_PDU_t* ngap_msg_pdu);
+  unsigned long getAmfUeNgapId();
+  uint32_t getRanUeNgapId();
+  int getRanPagingPriority();
+  bool getNasPdu(uint8_t*& nas, size_t& sizeofnas);
+  bool getPduSessionResourceModifyRequestList(
+      std::vector<PDUSessionResourceModifyRequestItem_t>& list);
+
+ private:
+  Ngap_NGAP_PDU_t* pduSessionResourceModifyRequestPdu;
+  Ngap_PDUSessionResourceModifyRequest_t* pduSessionResourceModifyRequestIEs;
+
+  AMF_UE_NGAP_ID amfUeNgapId;            // Mandatory
+  RAN_UE_NGAP_ID ranUeNgapId;            // Mandatory
+  RANPagingPriority* ranPagingPriority;  // Optional
+  PDUSessionResourceModifyListModReq* pduSessionResourceModifyList;
+};
+
+}  // namespace ngap
+#endif

src/ngap/ngapMsgs/PduSessionResourceModifyResponse.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date 2021
+ \email: contact@openairinterface.org
+ */
+
+#include "PduSessionResourceModifyResponse.hpp"
+#include "amf.hpp"
+#include "logger.hpp"
+
+extern "C" {
+#include "asn_codecs.h"
+#include "constr_TYPE.h"
+#include "constraints.h"
+#include "dynamic_memory_check.h"
+#include "per_decoder.h"
+#include "per_encoder.h"
+}
+
+#include <iostream>
+using namespace std;
+
+namespace ngap {
+
+//------------------------------------------------------------------------------
+PduSessionResourceModifyResponseMsg::PduSessionResourceModifyResponseMsg() {
+  // Set Message Type
+  pduSessionResourceModifyResponsePdu =
+      (Ngap_NGAP_PDU_t*) calloc(1, sizeof(Ngap_NGAP_PDU_t));
+
+  MessageType pdu = {};
+  pdu.setProcedureCode(Ngap_ProcedureCode_id_PDUSessionResourceModify);
+
+  pdu.setTypeOfMessage(Ngap_NGAP_PDU_PR_successfulOutcome);
+  pdu.setCriticality(Ngap_Criticality_reject);
+  pdu.setValuePresent(
+      Ngap_SuccessfulOutcome__value_PR_PDUSessionResourceModifyResponse);
+  pdu.encode2pdu(pduSessionResourceModifyResponsePdu);
+  pduSessionResourceModifyResponseIEs =
+      &(pduSessionResourceModifyResponsePdu->choice.successfulOutcome->value
+            .choice.PDUSessionResourceModifyResponse);
+}
+
+//------------------------------------------------------------------------------
+PduSessionResourceModifyResponseMsg::~PduSessionResourceModifyResponseMsg() {
+  // TODO:
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyResponseMsg::setMessageType() {
+  if (!pduSessionResourceModifyResponsePdu)
+    pduSessionResourceModifyResponsePdu =
+        (Ngap_NGAP_PDU_t*) calloc(1, sizeof(Ngap_NGAP_PDU_t));
+
+  MessageType pdu = {};
+  pdu.setProcedureCode(Ngap_ProcedureCode_id_PDUSessionResourceModify);
+
+  pdu.setTypeOfMessage(Ngap_NGAP_PDU_PR_successfulOutcome);
+  pdu.setCriticality(Ngap_Criticality_reject);
+  pdu.setValuePresent(
+      Ngap_SuccessfulOutcome__value_PR_PDUSessionResourceModifyResponse);
+  pdu.encode2pdu(pduSessionResourceModifyResponsePdu);
+  pduSessionResourceModifyResponseIEs =
+      &(pduSessionResourceModifyResponsePdu->choice.successfulOutcome->value
+            .choice.PDUSessionResourceModifyResponse);
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyResponseMsg::setAmfUeNgapId(unsigned long id) {
+  amfUeNgapId.setAMF_UE_NGAP_ID(id);
+
+  Ngap_PDUSessionResourceModifyResponseIEs_t* ie =
+      (Ngap_PDUSessionResourceModifyResponseIEs_t*) calloc(
+          1, sizeof(Ngap_PDUSessionResourceModifyResponseIEs_t));
+  ie->id          = Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID;
+  ie->criticality = Ngap_Criticality_ignore;
+  ie->value.present =
+      Ngap_PDUSessionResourceModifyResponseIEs__value_PR_AMF_UE_NGAP_ID;
+
+  int ret = amfUeNgapId.encode2AMF_UE_NGAP_ID(ie->value.choice.AMF_UE_NGAP_ID);
+  if (!ret) {
+    Logger::ngap().error("Encode NGAP AMF_UE_NGAP_ID IE error");
+    free_wrapper((void**) &ie);
+    return;
+  }
+
+  ret = ASN_SEQUENCE_ADD(
+      &pduSessionResourceModifyResponseIEs->protocolIEs.list, ie);
+  if (ret != 0) Logger::ngap().error("Encode NGAP AMF_UE_NGAP_ID IE error");
+  // free_wrapper((void**) &ie);
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyResponseMsg::setRanUeNgapId(
+    uint32_t ran_ue_ngap_id) {
+  ranUeNgapId.setRanUeNgapId(ran_ue_ngap_id);
+
+  Ngap_PDUSessionResourceModifyResponseIEs_t* ie =
+      (Ngap_PDUSessionResourceModifyResponseIEs_t*) calloc(
+          1, sizeof(Ngap_PDUSessionResourceModifyResponseIEs_t));
+  ie->id          = Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID;
+  ie->criticality = Ngap_Criticality_ignore;
+  ie->value.present =
+      Ngap_PDUSessionResourceModifyResponseIEs__value_PR_RAN_UE_NGAP_ID;
+
+  int ret = ranUeNgapId.encode2RAN_UE_NGAP_ID(ie->value.choice.RAN_UE_NGAP_ID);
+  if (!ret) {
+    Logger::ngap().error("Encode NGAP RAN_UE_NGAP_ID IE error");
+    free_wrapper((void**) &ie);
+    return;
+  }
+
+  ret = ASN_SEQUENCE_ADD(
+      &pduSessionResourceModifyResponseIEs->protocolIEs.list, ie);
+  if (ret != 0) Logger::ngap().error("Encode NGAP RAN_UE_NGAP_ID IE error");
+  // free_wrapper((void**) &ie);
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyResponseMsg::
+    setPduSessionResourceModifyResponseList(
+        std::vector<PDUSessionResourceModifyResponseItem_t> list) {
+  std::vector<PDUSessionResourceModifyItemModRes>
+      m_pduSessionResourceModifyItemModRes;
+
+  for (int i = 0; i < list.size(); i++) {
+    PDUSessionID m_pDUSessionID = {};
+    m_pDUSessionID.setPDUSessionID(list[i].pduSessionId);
+
+    PDUSessionResourceModifyItemModRes item = {};
+
+    item.setPDUSessionResourceModifyItemModRes(
+        m_pDUSessionID, list[i].pduSessionResourceModifyResponseTransfer);
+    m_pduSessionResourceModifyItemModRes.push_back(item);
+  }
+
+  pduSessionResourceModifyList.setPDUSessionResourceModifyListModRes(
+      m_pduSessionResourceModifyItemModRes);
+
+  Ngap_PDUSessionResourceModifyResponseIEs_t* ie =
+      (Ngap_PDUSessionResourceModifyResponseIEs_t*) calloc(
+          1, sizeof(Ngap_PDUSessionResourceModifyResponseIEs_t));
+  ie->id          = Ngap_ProtocolIE_ID_id_PDUSessionResourceModifyListModRes;
+  ie->criticality = Ngap_Criticality_reject;
+  ie->value.present =
+      Ngap_PDUSessionResourceModifyResponseIEs__value_PR_PDUSessionResourceModifyListModRes;
+
+  int ret =
+      pduSessionResourceModifyList.encode2PDUSessionResourceModifyListModRes(
+          ie->value.choice.PDUSessionResourceModifyListModRes);
+  if (!ret) {
+    Logger::ngap().error(
+        "Encode NGAP PDUSessionResourceModifyListModRes IE error");
+
+    free_wrapper((void**) &ie);
+    return;
+  }
+
+  ret = ASN_SEQUENCE_ADD(
+      &pduSessionResourceModifyResponseIEs->protocolIEs.list, ie);
+  if (ret != 0)
+    Logger::ngap().error(
+        "Encode NGAP PDUSessionResourceSetupListSUReq IE error");
+  // free_wrapper((void**) &ie);
+}
+
+//------------------------------------------------------------------------------
+int PduSessionResourceModifyResponseMsg::encode2buffer(
+    uint8_t* buf, int buf_size) {
+  asn_fprint(
+      stderr, &asn_DEF_Ngap_NGAP_PDU, pduSessionResourceModifyResponsePdu);
+  asn_enc_rval_t er = aper_encode_to_buffer(
+      &asn_DEF_Ngap_NGAP_PDU, NULL, pduSessionResourceModifyResponsePdu, buf,
+      buf_size);
+  Logger::ngap().debug("er.encoded (%d)", er.encoded);
+  return er.encoded;
+}
+
+//------------------------------------------------------------------------------
+void PduSessionResourceModifyResponseMsg::encode2buffer_new(
+    char* buf, int& encoded_size) {
+  char* buffer = (char*) calloc(1, BUFFER_SIZE_1024);
+  asn_fprint(
+      stderr, &asn_DEF_Ngap_NGAP_PDU, pduSessionResourceModifyResponsePdu);
+  encoded_size = aper_encode_to_new_buffer(
+      &asn_DEF_Ngap_NGAP_PDU, NULL, pduSessionResourceModifyResponsePdu,
+      (void**) &buffer);
+
+  Logger::ngap().debug("er.encoded (%d)", encoded_size);
+  memcpy((void*) buf, (void*) buffer, encoded_size);
+  free(buffer);
+}
+
+//------------------------------------------------------------------------------
+bool PduSessionResourceModifyResponseMsg::decodefrompdu(
+    Ngap_NGAP_PDU_t* ngap_msg_pdu) {
+  pduSessionResourceModifyResponsePdu = ngap_msg_pdu;
+
+  if (pduSessionResourceModifyResponsePdu->present ==
+      Ngap_NGAP_PDU_PR_successfulOutcome) {
+    if (pduSessionResourceModifyResponsePdu->choice.successfulOutcome &&
+        pduSessionResourceModifyResponsePdu->choice.successfulOutcome
+                ->procedureCode ==
+            Ngap_ProcedureCode_id_PDUSessionResourceModify &&
+        pduSessionResourceModifyResponsePdu->choice.successfulOutcome
+                ->criticality == Ngap_Criticality_reject &&
+        pduSessionResourceModifyResponsePdu->choice.successfulOutcome->value
+                .present ==
+            Ngap_SuccessfulOutcome__value_PR_PDUSessionResourceModifyResponse) {
+      pduSessionResourceModifyResponseIEs =
+          &pduSessionResourceModifyResponsePdu->choice.successfulOutcome->value
+               .choice.PDUSessionResourceModifyResponse;
+    } else {
+      Logger::ngap().error(
+          "Check PDUSessionResourceModifyResponse message error!");
+
+      return false;
+    }
+  } else {
+    Logger::ngap().error("MessageType error!");
+    return false;
+  }
+
+  for (int i = 0;
+       i < pduSessionResourceModifyResponseIEs->protocolIEs.list.count; i++) {
+    switch (
+        pduSessionResourceModifyResponseIEs->protocolIEs.list.array[i]->id) {
+      case Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID: {
+        if (pduSessionResourceModifyResponseIEs->protocolIEs.list.array[i]
+                    ->criticality == Ngap_Criticality_ignore &&
+            pduSessionResourceModifyResponseIEs->protocolIEs.list.array[i]
+                    ->value.present ==
+                Ngap_PDUSessionResourceModifyResponseIEs__value_PR_AMF_UE_NGAP_ID) {
+          if (!amfUeNgapId.decodefromAMF_UE_NGAP_ID(
+                  pduSessionResourceModifyResponseIEs->protocolIEs.list
+                      .array[i]
+                      ->value.choice.AMF_UE_NGAP_ID)) {
+            Logger::ngap().error("Decoded NGAP AMF_UE_NGAP_ID IE error");
+            return false;
+          }
+        } else {
+          Logger::ngap().error("Decoded NGAP AMF_UE_NGAP_ID IE error");
+          return false;
+        }
+      } break;
+      case Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID: {
+        if (pduSessionResourceModifyResponseIEs->protocolIEs.list.array[i]
+                    ->criticality == Ngap_Criticality_reject &&
+            pduSessionResourceModifyResponseIEs->protocolIEs.list.array[i]
+                    ->value.present ==
+                Ngap_PDUSessionResourceModifyResponseIEs__value_PR_RAN_UE_NGAP_ID) {
+          if (!ranUeNgapId.decodefromRAN_UE_NGAP_ID(
+                  pduSessionResourceModifyResponseIEs->protocolIEs.list
+                      .array[i]
+                      ->value.choice.RAN_UE_NGAP_ID)) {
+            Logger::ngap().error("Decoded NGAP RAN_UE_NGAP_ID IE error");
+            return false;
+          }
+        } else {
+          Logger::ngap().error("Decoded NGAP RAN_UE_NGAP_ID IE error");
+          return false;
+        }
+      } break;
+      case Ngap_ProtocolIE_ID_id_PDUSessionResourceModifyListModRes: {
+        if (pduSessionResourceModifyResponseIEs->protocolIEs.list.array[i]
+                    ->criticality == Ngap_Criticality_ignore &&
+            pduSessionResourceModifyResponseIEs->protocolIEs.list.array[i]
+                    ->value.present ==
+                Ngap_PDUSessionResourceModifyResponseIEs__value_PR_PDUSessionResourceModifyListModRes) {
+          if (!pduSessionResourceModifyList
+                   .decodefromPDUSessionResourceModifyListModRes(
+                       pduSessionResourceModifyResponseIEs->protocolIEs.list
+                           .array[i]
+                           ->value.choice.PDUSessionResourceModifyListModRes)) {
+            Logger::ngap().error(
+                "Decoded NGAP PDUSessionResourceModifyListModRes IE error");
+            return false;
+          }
+        } else {
+          Logger::ngap().error(
+              "Decoded NGAP PDUSessionResourceModifyListModRes IE error");
+
+          return false;
+        }
+      } break;
+      default: {
+        Logger::ngap().error("Decoded NGAP Message PDU error");
+
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+unsigned long PduSessionResourceModifyResponseMsg::getAmfUeNgapId() {
+  return amfUeNgapId.getAMF_UE_NGAP_ID();
+}
+
+//------------------------------------------------------------------------------
+uint32_t PduSessionResourceModifyResponseMsg::getRanUeNgapId() {
+  return ranUeNgapId.getRanUeNgapId();
+}
+
+//------------------------------------------------------------------------------
+bool PduSessionResourceModifyResponseMsg::
+    getPduSessionResourceModifyResponseList(
+        std::vector<PDUSessionResourceModifyResponseItem_t>& list) {
+  std::vector<PDUSessionResourceModifyItemModRes>
+      m_pduSessionResourceModifyItemModRes;
+  int num = 0;
+  pduSessionResourceModifyList.getPDUSessionResourceModifyListModRes(
+      m_pduSessionResourceModifyItemModRes);
+
+  for (int i = 0; i < m_pduSessionResourceModifyItemModRes.size(); i++) {
+    PDUSessionResourceModifyResponseItem_t response;
+
+    PDUSessionID m_pDUSessionID = {};
+
+    m_pduSessionResourceModifyItemModRes[i]
+        .getPDUSessionResourceModifyItemModRes(
+            m_pDUSessionID, response.pduSessionResourceModifyResponseTransfer);
+
+    m_pDUSessionID.getPDUSessionID(response.pduSessionId);
+
+    list.push_back(response);
+  }
+
+  return true;
+}
+
+}  // namespace ngap

src/ngap/ngapMsgs/PduSessionResourceModifyResponse.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
+ */
+
+/*! \file
+ \brief
+ \author
+ \date 2021
+ \email: contact@openairinterface.org
+ */
+
+#ifndef PDU_SESSION_RESOURCE_MODIFY_RESPONSE_H_
+#define PDU_SESSION_RESOURCE_MODIFY_RESPONSE_H_
+
+#include "AMF-UE-NGAP-ID.hpp"
+#include "MessageType.hpp"
+#include "NgapIEsStruct.hpp"
+#include "PDUSessionResourceModifyListModRes.hpp"
+#include "RAN-UE-NGAP-ID.hpp"
+#include "RANPagingPriority.hpp"
+
+extern "C" {
+#include "Ngap_InitialContextSetupRequest.h"
+#include "Ngap_PDUSessionResourceModifyResponse.h"
+#include "Ngap_NGAP-PDU.h"
+#include "Ngap_ProtocolIE-Field.h"
+}
+
+namespace ngap {
+
+class PduSessionResourceModifyResponseMsg {
+ public:
+  PduSessionResourceModifyResponseMsg();
+  virtual ~PduSessionResourceModifyResponseMsg();
+
+  void setMessageType();
+  void setAmfUeNgapId(unsigned long id);  // 40 bits
+  void setRanUeNgapId(uint32_t id);       // 32 bits
+
+  void setPduSessionResourceModifyResponseList(
+      std::vector<PDUSessionResourceModifyResponseItem_t> list);
+
+  int encode2buffer(uint8_t* buf, int buf_size);
+  void encode2buffer_new(char* buf, int& encoded_size);
+
+  bool decodefrompdu(Ngap_NGAP_PDU_t* ngap_msg_pdu);
+  unsigned long getAmfUeNgapId();
+  uint32_t getRanUeNgapId();
+  bool getPduSessionResourceModifyResponseList(
+      std::vector<PDUSessionResourceModifyResponseItem_t>& list);
+
+ private:
+  Ngap_NGAP_PDU_t* pduSessionResourceModifyResponsePdu;
+  Ngap_PDUSessionResourceModifyResponse_t* pduSessionResourceModifyResponseIEs;
+
+  AMF_UE_NGAP_ID amfUeNgapId;                                       // Mandatory
+  RAN_UE_NGAP_ID ranUeNgapId;                                       // Mandatory
+  PDUSessionResourceModifyListModRes pduSessionResourceModifyList;  // Mandatory
+  // PDUSessionResourceFailedToModifyListModRes*
+  // pduSessionResourceFailedToModifyListModRes;
+};
+
+}  // namespace ngap
+#endif

src/ngap/ngap_app/ngap_message_callback.hpp

@@ -35,6 +35,7 @@
 #include "PDUSessionResourceSetupUnsuccessfulTransfer.hpp"
 #include "PduSessionResourceReleaseResponse.hpp"
 #include "PduSessionResourceSetupResponse.hpp"
+#include "PduSessionResourceModifyResponse.hpp"
 #include "amf_app.hpp"
 #include "amf_n1.hpp"
 #include "amf_n11.hpp"
@@ -284,6 +285,7 @@ int ngap_amf_handle_ue_context_release_complete(
   return 0;
 }
 
+//------------------------------------------------------------------------------
 int ngap_amf_handle_pdu_session_resource_release_response(
     const sctp_assoc_id_t assoc_id, const sctp_stream_id_t stream,
     struct Ngap_NGAP_PDU* message_p) {
@@ -466,6 +468,64 @@ int ngap_amf_handle_pdu_session_resource_setup_response(
   return 0;
 }
 
+//------------------------------------------------------------------------------
+int ngap_amf_handle_pdu_session_resource_modify_response(
+    const sctp_assoc_id_t assoc_id, const sctp_stream_id_t stream,
+    struct Ngap_NGAP_PDU* message_p) {
+  Logger::ngap().debug("Handle PDU Session Resource Modify Response");
+
+  std::unique_ptr<PduSessionResourceModifyResponseMsg> response_msg =
+      std::make_unique<PduSessionResourceModifyResponseMsg>();
+
+  if (!response_msg->decodefrompdu(message_p)) {
+    Logger::ngap().error(
+        "Decoding PduSessionResourceModifyResponseMsg message error");
+    return -1;
+  }
+
+  // Transfer pduSessionResourceModifyResponseTransfer to SMF
+  std::vector<PDUSessionResourceModifyResponseItem_t> list;
+  if (!response_msg->getPduSessionResourceModifyResponseList(list)) {
+    Logger::ngap().error(
+        "Decoding PduSessionResourceModifyResponseMsg "
+        "getPduSessionResourceModifyResponseList IE error");
+    return -1;
+  }
+
+  for (auto response_item : list) {
+    uint8_t buf[BUFFER_SIZE_512];
+    memcpy(
+        buf, response_item.pduSessionResourceModifyResponseTransfer.buf,
+        response_item.pduSessionResourceModifyResponseTransfer.size);
+    bstring n2sm = blk2bstr(
+        buf, response_item.pduSessionResourceModifyResponseTransfer.size);
+    Logger::ngap().debug(
+        "Sending ITTI PDUSessionResourceModifyResponseTransfer to "
+        "TASK_AMF_N11");
+
+    std::shared_ptr<itti_nsmf_pdusession_update_sm_context> itti_msg =
+        std::make_shared<itti_nsmf_pdusession_update_sm_context>(
+            TASK_NGAP, TASK_AMF_N11);
+    itti_msg->pdu_session_id = response_item.pduSessionId;
+    itti_msg->n2sm           = n2sm;
+    itti_msg->is_n2sm_set    = true;
+    itti_msg->n2sm_info_type = "PDU_RES_MOD_RSP";
+    itti_msg->amf_ue_ngap_id = response_msg->getAmfUeNgapId();
+    itti_msg->ran_ue_ngap_id = response_msg->getRanUeNgapId();
+
+    int ret = itti_inst->send_msg(itti_msg);
+    if (0 != ret) {
+      Logger::ngap().error(
+          "Could not send ITTI message %s to task TASK_AMF_N11",
+          itti_msg->get_msg_name());
+    }
+  }
+
+  // TODO:for PDUSessionResourceFailedToModifyListModRes
+  // TODO: process User Location Information if available
+  return 0;
+}
+
 //------------------------------------------------------------------------------
 int ngap_amf_handle_error_indication(
     const sctp_assoc_id_t assoc_id, const sctp_stream_id_t stream,
@@ -735,15 +795,6 @@ int ngap_amf_handle_path_switch_request(
   return 0;
 }
 
-//------------------------------------------------------------------------------
-int pdu_session_resource_modify(
-    const sctp_assoc_id_t assoc_id, const sctp_stream_id_t stream,
-    struct Ngap_NGAP_PDU* message_p) {
-  Logger::ngap().debug(
-      "Sending ITTI PDU Session Resource Modify to TASK_AMF_N2");
-  return 0;
-}
-
 //------------------------------------------------------------------------------
 int pdu_session_resource_modify_indication(
     const sctp_assoc_id_t assoc_id, const sctp_stream_id_t stream,
@@ -970,8 +1021,8 @@ ngap_message_decoded_callback messages_callback[][3] = {
     {paging, paging, paging},                         /*Paging*/
     {ngap_amf_handle_path_switch_request, ngap_amf_handle_path_switch_request,
      ngap_amf_handle_path_switch_request}, /*PathSwitchRequest*/
-    {pdu_session_resource_modify, pdu_session_resource_modify,
-     pdu_session_resource_modify}, /*PDUSessionResourceModify*/
+    {0, ngap_amf_handle_pdu_session_resource_modify_response,
+     0}, /*PDUSessionResourceModify*/
     {pdu_session_resource_modify_indication,
      pdu_session_resource_modify_indication,
      pdu_session_resource_modify_indication}, /*PDUSessionResourceModifyIndication*/

src/sbi/amf_server/impl/N1N2MessageCollectionDocumentApiImpl.cpp

@@ -112,6 +112,11 @@ void N1N2MessageCollectionDocumentApiImpl::n1_n2_message_transfer(
   itti_msg->is_n2sm_set = true;
   itti_msg->pdu_session_id =
       (uint8_t) n1N2MessageTransferReqData.getPduSessionId();
+  itti_msg->n2sm_info_type = n1N2MessageTransferReqData.getN2InfoContainer()
+                                 .getSmInfo()
+                                 .getN2InfoContent()
+                                 .getNgapIeType()
+                                 .get_value();
 
   // For Paging
   if (n1N2MessageTransferReqData.ppiIsSet()) {

src/sbi/amf_server/model/NgapIeType.cpp

@@ -25,11 +25,22 @@ void NgapIeType::validate() {
   // TODO: implement validation
 }
 
+std::string NgapIeType::get_value() const {
+  return value;
+}
+
+void NgapIeType::set_value(std::string v) {
+  value = v;
+}
+
 void to_json(nlohmann::json& j, const NgapIeType& o) {
   j = nlohmann::json();
+  j = o.get_value();
 }
 
-void from_json(const nlohmann::json& j, NgapIeType& o) {}
+void from_json(const nlohmann::json& j, NgapIeType& o) {
+  o.set_value(j.get<std::string>());
+}
 
 }  // namespace model
 }  // namespace amf

src/sbi/amf_server/model/NgapIeType.h

@@ -35,6 +35,8 @@ class NgapIeType {
 
   void validate();
 
+  std::string get_value() const;
+  void set_value(std::string v);
   /////////////////////////////////////////////
   /// NgapIeType members
 
@@ -42,6 +44,7 @@ class NgapIeType {
   friend void from_json(const nlohmann::json& j, NgapIeType& o);
 
  protected:
+  std::string value;
 };
 
 }  // namespace model