Process PDU Session Release notification from SMF

src/amf-app/amf_app.cpp

@@ -148,6 +148,13 @@ void amf_app_task(void*) {
         amf_app_inst->handle_itti_message(ref(*m));
       } break;
 
+      case SBI_PDU_SESSION_RELEASE_NOTIF: {
+        Logger::amf_app().debug("Received SBI_PDU_SESSION_RELEASE_NOTIF");
+        itti_sbi_pdu_session_release_notif* m =
+            dynamic_cast<itti_sbi_pdu_session_release_notif*>(msg);
+        amf_app_inst->handle_itti_message(ref(*m));
+      } break;
+
       case SBI_AMF_CONFIGURATION: {
         Logger::amf_app().debug("Received SBI_AMF_CONFIGURATION");
         itti_sbi_amf_configuration* m =
@@ -293,6 +300,24 @@ bool amf_app::get_pdu_sessions_context(
   return true;
 }
 
+//------------------------------------------------------------------------------
+bool amf_app::update_pdu_sessions_context(
+    const string& ue_id, const uint8_t& pdu_session_id,
+    const oai::amf::model::SmContextStatusNotification& statusNotification) {
+  if (!is_supi_2_ue_context(ue_id)) return false;
+  std::shared_ptr<ue_context> uc = {};
+  uc                             = supi_2_ue_context(ue_id);
+  // TODO: process SmContextStatusNotification
+  oai::amf::model::StatusInfo statusInfo = statusNotification.getStatusInfo();
+  oai::amf::model::ResourceStatus resourceStatus =
+      statusInfo.getResourceStatus();
+  std::string pdu_session_status = resourceStatus.getValue();
+  if (boost::iequals(pdu_session_status, "released")) {
+    if (uc->remove_pdu_sessions_context(pdu_session_id)) return true;
+  }
+  return false;
+}
+
 //------------------------------------------------------------------------------
 evsub_id_t amf_app::generate_ev_subscription_id() {
   return evsub_id_generator.get_uid();
@@ -708,6 +733,36 @@ void amf_app::handle_itti_message(itti_sbi_n1n2_message_unsubscribe& itti_msg) {
   }
 }
 
+//------------------------------------------------------------------------------
+void amf_app::handle_itti_message(
+    itti_sbi_pdu_session_release_notif& itti_msg) {
+  Logger::amf_app().info(
+      "Handle an PDU Session Release notification from SMF (HTTP version "
+      "%d)",
+      itti_msg.http_version);
+
+  // Process the request and trigger the response from AMF API Server
+  nlohmann::json response_data = {};
+  if (update_pdu_sessions_context(
+          itti_msg.ue_id, itti_msg.pdu_session_id,
+          itti_msg.smContextStatusNotification)) {
+    response_data["httpResponseCode"] = static_cast<uint32_t>(
+        http_response_codes_e::HTTP_RESPONSE_CODE_204_NO_CONTENT);
+  } else {
+    response_data["httpResponseCode"] = static_cast<uint32_t>(
+        http_response_codes_e::HTTP_RESPONSE_CODE_BAD_REQUEST);
+    oai::amf::model::ProblemDetails problem_details = {};
+    // TODO set problem_details
+    to_json(response_data["ProblemDetails"], problem_details);
+  }
+
+  // Notify to the result
+  if (itti_msg.promise_id > 0) {
+    trigger_process_response(itti_msg.promise_id, response_data);
+    return;
+  }
+}
+
 //------------------------------------------------------------------------------
 void amf_app::handle_itti_message(itti_sbi_amf_configuration& itti_msg) {
   Logger::amf_app().info(

src/amf-app/amf_app.hpp

@@ -143,6 +143,13 @@ class amf_app {
    */
   void handle_itti_message(itti_sbi_n1n2_message_unsubscribe& itti_msg);
 
+  /*
+   * Handle ITTI message (SBI PDU Session Release Notification)
+   * @param [itti_sbi_pdu_session_release_notif&]: ITTI message
+   * @return void
+   */
+  void handle_itti_message(itti_sbi_pdu_session_release_notif& itti_msg);
+
   /*
    * Handle ITTI message (SBI AMF configuration)
    * @param [itti_sbi_amf_configuration&]: ITTI message
@@ -289,6 +296,18 @@ class amf_app {
       const string& supi,
       std::vector<std::shared_ptr<pdu_session_context>>& sessions_ctx);
 
+  /*
+   * Update PDU Session Context status
+   * @param [const std::string&] ue_id: UE SUPI
+   * @param [const uint8_t&] pdu_session_id: PDU Session ID
+   * @param [const oai::amf::model::SmContextStatusNotification&]
+   * statusNotification: Notification information received from SMF
+   * @return true if success, otherwise false
+   */
+  bool update_pdu_sessions_context(
+      const string& ue_id, const uint8_t& pdu_session_id,
+      const oai::amf::model::SmContextStatusNotification& statusNotification);
+
   /*
    * Generate a TMSI value for UE
    * @param void

src/contexts/ue_context.cpp

@@ -54,10 +54,12 @@ void ue_context::add_pdu_session_context(
   pdu_sessions[session_id] = context;
 }
 
+//------------------------------------------------------------------------------
 void ue_context::copy_pdu_sessions(std::shared_ptr<ue_context>& ue_ctx) {
   pdu_sessions = ue_ctx->pdu_sessions;
 }
 
+//------------------------------------------------------------------------------
 bool ue_context::get_pdu_sessions_context(
     std::vector<std::shared_ptr<pdu_session_context>>& sessions_ctx) {
   std::shared_lock lock(m_pdu_session);
@@ -66,3 +68,10 @@ bool ue_context::get_pdu_sessions_context(
   }
   return true;
 }
+
+//------------------------------------------------------------------------------
+bool ue_context::remove_pdu_sessions_context(const uint8_t& pdu_session_id) {
+  std::shared_lock lock(m_pdu_session);
+  pdu_sessions.erase(pdu_session_id);
+  return true;
+}

src/contexts/ue_context.hpp

@@ -52,6 +52,8 @@ class ue_context {
   bool get_pdu_sessions_context(
       std::vector<std::shared_ptr<pdu_session_context>>& sessions_ctx);
 
+  bool remove_pdu_sessions_context(const uint8_t& pdu_session_id);
+
  public:
   uint32_t ran_ue_ngap_id;   // 32bits
   long amf_ue_ngap_id : 40;  // 40bits

src/itti/msgs/itti_msg_sbi.hpp

@@ -551,12 +551,16 @@ class itti_sbi_pdu_session_release_notif : public itti_sbi_msg {
       : itti_sbi_msg(SBI_PDU_SESSION_RELEASE_NOTIF, orig, dest),
         http_version(1),
         promise_id(pid),
+        ue_id(),
+        pdu_session_id(),
         smContextStatusNotification() {}
   itti_sbi_pdu_session_release_notif(
       const itti_sbi_pdu_session_release_notif& i)
       : itti_sbi_msg(i),
         http_version(1),
         promise_id(),
+        ue_id(),
+        pdu_session_id(),
         smContextStatusNotification(i.smContextStatusNotification) {}
   itti_sbi_pdu_session_release_notif(
       const itti_sbi_pdu_session_release_notif& i, const task_id_t orig,
@@ -564,6 +568,8 @@ class itti_sbi_pdu_session_release_notif : public itti_sbi_msg {
       : itti_sbi_msg(i, orig, dest),
         http_version(i.http_version),
         promise_id(i.promise_id),
+        ue_id(i.ue_id),
+        pdu_session_id(i.pdu_session_id),
         smContextStatusNotification(i.smContextStatusNotification) {}
 
   virtual ~itti_sbi_pdu_session_release_notif(){};
@@ -571,6 +577,8 @@ class itti_sbi_pdu_session_release_notif : public itti_sbi_msg {
 
   uint8_t http_version;
   uint32_t promise_id;
+  std::string ue_id;
+  uint8_t pdu_session_id;
   oai::amf::model::SmContextStatusNotification smContextStatusNotification;
 };
 

src/sbi/amf_server/AMFApiServer.cpp

@@ -22,6 +22,7 @@ void AMFApiServer::init(size_t thr) {
   m_subscriptionsCollectionDocumentApiImpl->init();
   m_subscriptionsCollectionDocumentApiImplEventExposure->init();
   m_n1MessageNotifyApiImpl->init();
+  m_statusNotifyApiImpl->init();
   Logger::amf_server().debug("Initiate AMF Server Endpoints done!");
 }
 
@@ -72,6 +73,9 @@ void AMFApiServer::start() {
   if (m_n1MessageNotifyApiImpl != nullptr)
     Logger::amf_server().debug("AMF handler for N1MessageNotifyApiImpl");
 
+  if (m_statusNotifyApiImpl != nullptr)
+    Logger::amf_server().debug("AMF handler for StatusNotifyApiImpl");
+
   m_httpEndpoint->setHandler(m_router->handler());
   m_httpEndpoint->serveThreaded();
 }

src/sbi/amf_server/AMFApiServer.hpp

@@ -20,6 +20,7 @@
 #include "SubscriptionsCollectionDocumentApiImpl.h"
 #include "SubscriptionsCollectionDocumentApiImplEventExposure.h"
 #include "N1MessageNotifyApiImpl.h"
+#include "StatusNotifyApiImpl.h"
 
 #define PISTACHE_SERVER_THREADS 2
 #define PISTACHE_SERVER_MAX_PAYLOAD 32768
@@ -75,6 +76,8 @@ class AMFApiServer {
             m_router, amf_app_inst);
     m_n1MessageNotifyApiImpl =
         std::make_shared<N1MessageNotifyApiImpl>(m_router, amf_app_inst);
+    m_statusNotifyApiImpl =
+        std::make_shared<StatusNotifyApiImpl>(m_router, amf_app_inst);
   }
 
   void init(size_t thr = 1);
@@ -111,6 +114,7 @@ class AMFApiServer {
   std::shared_ptr<SubscriptionsCollectionDocumentApiImplEventExposure>
       m_subscriptionsCollectionDocumentApiImplEventExposure;
   std::shared_ptr<N1MessageNotifyApiImpl> m_n1MessageNotifyApiImpl;
+  std::shared_ptr<StatusNotifyApiImpl> m_statusNotifyApiImpl;
 
   std::string m_address;
 };

src/sbi/amf_server/api/NFStatusNotifyApi.cpp → src/sbi/amf_server/api/StatusNotifyApi.cpp

@@ -19,7 +19,8 @@
  *      contact@openairinterface.org
  */
 
-#include "NFStatusNotifyApi.h"
+#include "StatusNotifyApi.h"
+
 #include "Helpers.h"
 #include "amf_config.hpp"
 #include "SmContextStatusNotification.h"
@@ -33,31 +34,29 @@ namespace api {
 using namespace oai::amf::helpers;
 using namespace oai::amf::model;
 
-NFStatusNotifyApi::NFStatusNotifyApi(
-    std::shared_ptr<Pistache::Rest::Router> rtr) {
+StatusNotifyApi::StatusNotifyApi(std::shared_ptr<Pistache::Rest::Router> rtr) {
   router = rtr;
 }
 
-void NFStatusNotifyApi::init() {
+void StatusNotifyApi::init() {
   setupRoutes();
 }
 
-void NFStatusNotifyApi::setupRoutes() {
+void StatusNotifyApi::setupRoutes() {
   using namespace Pistache::Rest;
 
   Routes::Post(
       *router,
       base + amf_cfg.sbi_api_version +
           "/pdu-session-release/callback/:ueContextId/:pduSessionId",
-      Routes::bind(
-          &NFStatusNotifyApi::notify_pdu_session_status_handler, this));
+      Routes::bind(&StatusNotifyApi::notify_pdu_session_status_handler, this));
 
   // Default handler, called when a route is not found
   router->addCustomHandler(
-      Routes::bind(&NFStatusNotifyApi::notify_nf_status_default_handler, this));
+      Routes::bind(&StatusNotifyApi::notify_status_default_handler, this));
 }
 
-void NFStatusNotifyApi::notify_pdu_session_status_handler(
+void StatusNotifyApi::notify_pdu_session_status_handler(
     const Pistache::Rest::Request& request,
     Pistache::Http::ResponseWriter response) {
   // Get SUPI
@@ -85,7 +84,7 @@ void NFStatusNotifyApi::notify_pdu_session_status_handler(
   }
 }
 
-void NFStatusNotifyApi::notify_nf_status_default_handler(
+void StatusNotifyApi::notify_status_default_handler(
     const Pistache::Rest::Request&, Pistache::Http::ResponseWriter response) {
   response.send(
       Pistache::Http::Code::Not_Found, "The requested method does not exist");

src/sbi/amf_server/api/NFStatusNotifyApi.h → src/sbi/amf_server/api/StatusNotifyApi.h

@@ -20,13 +20,13 @@
  */
 
 /*
- * NFStatusNotifyApi.h
+ * StatusNotifyApi.h
  *
  *
  */
 
-#ifndef NFStatusNotifyApi_H_
-#define NFStatusNotifyApi_H_
+#ifndef StatusNotifyApi_H_
+#define StatusNotifyApi_H_
 
 #include <pistache/http.h>
 #include <pistache/router.h>
@@ -39,10 +39,10 @@ namespace oai::amf::api {
 
 using namespace oai::amf::model;
 
-class NFStatusNotifyApi {
+class StatusNotifyApi {
  public:
-  NFStatusNotifyApi(std::shared_ptr<Pistache::Rest::Router>);
-  virtual ~NFStatusNotifyApi() {}
+  StatusNotifyApi(std::shared_ptr<Pistache::Rest::Router>);
+  virtual ~StatusNotifyApi() {}
   void init();
 
   const std::string base = "/namf-status-notify/";
@@ -53,7 +53,7 @@ class NFStatusNotifyApi {
   void notify_pdu_session_status_handler(
       const Pistache::Rest::Request& request,
       Pistache::Http::ResponseWriter response);
-  void notify_nf_status_default_handler(
+  void notify_status_default_handler(
       const Pistache::Rest::Request& request,
       Pistache::Http::ResponseWriter response);
 
@@ -74,4 +74,4 @@ class NFStatusNotifyApi {
 
 }  // namespace oai::amf::api
 
-#endif /* NFStatusNotifyApi_H_ */
+#endif /* StatusNotifyApi_H_ */

src/sbi/amf_server/impl/NFStatusNotifyApiImpl.cpp → src/sbi/amf_server/impl/StatusNotifyApiImpl.cpp

@@ -32,13 +32,12 @@
  *      contact@openairinterface.org
  */
 
-#include "NFStatusNotifyApiImpl.h"
-
 #include "3gpp_29.500.h"
 #include "logger.hpp"
 #include "itti_msg_sbi.hpp"
+#include "StatusNotifyApiImpl.h"
 
-itti_mw* itti_inst = nullptr;
+extern itti_mw* itti_inst;
 
 namespace oai {
 namespace amf {
@@ -46,18 +45,19 @@ namespace api {
 
 using namespace oai::amf::model;
 
-NFStatusNotifyApiImpl::NFStatusNotifyApiImpl(
+StatusNotifyApiImpl::StatusNotifyApiImpl(
     std::shared_ptr<Pistache::Rest::Router> rtr,
-    amf_application::amf_app* amf_app_inst, std::string address)
-    : NFStatusNotifyApi(rtr), m_amf_app(amf_app_inst), m_address(address) {}
+    amf_application::amf_app* amf_app_inst)
+    : StatusNotifyApi(rtr), m_amf_app(amf_app_inst) {}
 
-void NFStatusNotifyApiImpl::receive_pdu_session_status_notification(
+void StatusNotifyApiImpl::receive_pdu_session_status_notification(
     const std::string& ueContextId, const std::string& pduSessionId,
     const SmContextStatusNotification& statusNotification,
     Pistache::Http::ResponseWriter& response) {
   Logger::amf_server().debug(
       "Receive PDU Session Release notification, handling...");
 
+  uint8_t pdu_session_id = 0;
   // Generate a promise and associate this promise to the ITTI message
   uint32_t promise_id = m_amf_app->generate_promise_id();
   Logger::amf_n1().debug("Promise ID generated %d", promise_id);
@@ -74,6 +74,8 @@ void NFStatusNotifyApiImpl::receive_pdu_session_status_notification(
 
   itti_msg->http_version                = 1;
   itti_msg->promise_id                  = promise_id;
+  itti_msg->ue_id                       = ueContextId;
+  itti_msg->pdu_session_id              = pdu_session_id;
   itti_msg->smContextStatusNotification = statusNotification;
 
   int ret = itti_inst->send_msg(itti_msg);

src/sbi/amf_server/impl/NFStatusNotifyApiImpl.h → src/sbi/amf_server/impl/StatusNotifyApiImpl.h

@@ -12,7 +12,7 @@
  */
 
 /*
- * NFStatusNotifyApiImpl.h
+ * StatusNotifyApiImpl.h
  *
  *
  */
@@ -38,18 +38,17 @@
  *      contact@openairinterface.org
  */
 
-#ifndef NF_STATUS_NOTIFY_API_IMPL_H_
-#define NF_STATUS_NOTIFY_API_IMPL_H_
+#ifndef STATUS_NOTIFY_API_IMPL_H_
+#define STATUS_NOTIFY_API_IMPL_H_
 
 #include <pistache/endpoint.h>
 #include <pistache/http.h>
 #include <pistache/router.h>
 #include <memory>
 
-#include <NFStatusNotifyApi.h>
-
 #include <pistache/optional.h>
 
+#include "StatusNotifyApi.h"
 #include "ProblemDetails.h"
 #include "amf_app.hpp"
 
@@ -59,12 +58,12 @@ namespace api {
 
 using namespace oai::amf::model;
 
-class NFStatusNotifyApiImpl : public oai::amf::api::NFStatusNotifyApi {
+class StatusNotifyApiImpl : public oai::amf::api::StatusNotifyApi {
  public:
-  NFStatusNotifyApiImpl(
+  StatusNotifyApiImpl(
       std::shared_ptr<Pistache::Rest::Router>,
-      amf_application::amf_app* amf_app_inst, std::string address);
-  ~NFStatusNotifyApiImpl() {}
+      amf_application::amf_app* amf_app_inst);
+  ~StatusNotifyApiImpl() {}
 
   void receive_pdu_session_status_notification(
       const std::string& ueContextId, const std::string& pduSessionId,
@@ -73,7 +72,7 @@ class NFStatusNotifyApiImpl : public oai::amf::api::NFStatusNotifyApi {
 
  private:
   amf_application::amf_app* m_amf_app;
-  std::string m_address;
+  // std::string m_address;
 };
 
 }  // namespace api

src/sbi/amf_server/model/ResourceStatus.cpp

@@ -25,11 +25,24 @@ void ResourceStatus::validate() {
   // TODO: implement validation
 }
 
+std::string ResourceStatus::getValue() const {
+  return status;
+}
+void ResourceStatus::getValue(std::string& v) const {
+  v = status;
+}
+
+void ResourceStatus::setValue(const std::string& v) {
+  status = v;
+}
+
 void to_json(nlohmann::json& j, const ResourceStatus& o) {
   j = nlohmann::json();
 }
 
-void from_json(const nlohmann::json& j, ResourceStatus& o) {}
+void from_json(const nlohmann::json& j, ResourceStatus& o) {
+  j.get_to(o.status);
+}
 
 }  // namespace model
 }  // namespace amf

src/sbi/amf_server/model/ResourceStatus.h

@@ -34,6 +34,9 @@ class ResourceStatus {
   virtual ~ResourceStatus();
 
   void validate();
+  std::string getValue() const;
+  void getValue(std::string& value) const;
+  void setValue(const std::string& v);
 
   /////////////////////////////////////////////
   /// ResourceStatus members
@@ -42,6 +45,7 @@ class ResourceStatus {
   friend void from_json(const nlohmann::json& j, ResourceStatus& o);
 
  protected:
+  std::string status;
 };
 
 }  // namespace model