first version for HTTP2 support

README.txt

@@ -87,7 +87,7 @@ cd /openair-cn-cups/build/scripts
 #configure SPGWU using an example configure file (spgw_u.conf)
 cd /oai-cn5g-smf/src/test/upf/
 ./spgwu_conf.sh
-sudo spgwu -c /usr/local/etc/oai/spgw_u.conf  -o
+sudo spgwu -c /usr/local/etc/oai/spgw_u.conf
 
 
 ## Build and launch AMF client
@@ -98,4 +98,8 @@ cmake ..
 make
 ./amf-client -i 172.16.1.101
 
+#Launch AMF client with HTTP2 (-v: http version, -p: port)
+./amf-client -i 172.16.1.101 -v 2 -p 9090
+
+
 

etc/smf.conf

@@ -36,9 +36,10 @@ SMF =
         {
             # SMF binded interface for SBI interface (e.g., communication with AMF, UDM)
             INTERFACE_NAME         = "@SMF_INTERFACE_NAME_FOR_SBI@"; # STRING, interface name
-            #IPV4_ADDRESS           = "@SMF_INTERFACE_IPV4_ADDRESS_FOR_SBI@";                        # STRING, CIDR or "read" to let app read interface configured IP address
+            #IPV4_ADDRESS          = "@SMF_INTERFACE_IPV4_ADDRESS_FOR_SBI@";                        # STRING, CIDR or "read" to let app read interface configured IP address
             IPV4_ADDRESS           = "read";
             PORT                   = @SMF_INTERFACE_PORT_FOR_SBI@ #Normally we don't need this (default port 80)
+            HTTP2_PORT             = @SMF_INTERFACE_HTTP2_PORT_FOR_SBI@ 
          };
                   
        TEST_UPF : #for BUPT test only!

src/api-server/CMakeLists.txt

-cmake_minimum_required (VERSION 3.2)
-
-project(smf-api-server)
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -pg -g3" )
-
-
-include_directories(model)
-include_directories(api)
-include_directories(impl)
-
-file(GLOB SRCS
-    ${CMAKE_CURRENT_SOURCE_DIR}/api/*.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/impl/*.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/model/*.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp
-)
-
-add_executable(${PROJECT_NAME} ${SRCS} )
-target_link_libraries(${PROJECT_NAME} pistache pthread)

src/api-server/api/IndividualSMContextApi.cpp

@@ -43,7 +43,7 @@
 
 #include "logger.hpp"
 #include "Helpers.h"
-#include "simple_parser.hpp"
+#include "mime_parser.hpp"
 
 namespace oai {
 namespace smf_server {
@@ -103,7 +103,6 @@ void IndividualSMContextApi::release_sm_context_handler(
     response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
     return;
   }
-
 }
 
 void IndividualSMContextApi::retrieve_sm_context_handler(
@@ -141,7 +140,7 @@ void IndividualSMContextApi::update_sm_context_handler(
   SmContextUpdateMessage smContextUpdateMessage = { };
 
   //simple parser
-  simple_parser sp = { };
+  mime_parser sp = { };
   sp.parse(request.body());
 
   std::vector<mime_part> parts = { };

src/api-server/api/SMContextsCollectionApi.cpp

@@ -43,11 +43,7 @@
 
 #include "logger.hpp"
 #include "Helpers.h"
-#include "simple_parser.hpp"
-
-extern "C" {
-#include "dynamic_memory_check.h"
-}
+#include "mime_parser.hpp"
 
 namespace oai {
 namespace smf_server {
@@ -90,7 +86,7 @@ void SMContextsCollectionApi::post_sm_contexts_handler(
   SmContextCreateData smContextCreateData = { };
 
   //simple parser
-  simple_parser sp = { };
+  mime_parser sp = { };
   sp.parse(request.body());
 
   std::vector<mime_part> parts = { };
@@ -99,7 +95,7 @@ void SMContextsCollectionApi::post_sm_contexts_handler(
   Logger::smf_api_server().debug("Number of MIME parts %d", size);
   //at least 2 parts for Json data and N1 (+ N2)
   if (size < 2) {
-    response.send(Pistache::Http::Code::Bad_Request, "");
+    response.send(Pistache::Http::Code::Bad_Request);
     return;
   }
 
@@ -107,14 +103,16 @@ void SMContextsCollectionApi::post_sm_contexts_handler(
   try {
     nlohmann::json::parse(parts[0].body.c_str()).get_to(smContextCreateData);
     smContextMessage.setJsonData(smContextCreateData);
+    //must include N1 NAS msg
     if (parts[1].content_type.compare("application/vnd.3gpp.5gnas") == 0) {
       smContextMessage.setBinaryDataN1SmMessage(parts[1].body);
-    } else if (parts[1].content_type.compare("application/vnd.3gpp.ngap")
-        == 0) {
-      smContextMessage.setBinaryDataN2SmInformation(parts[1].body);
+    } else {
+      response.send(Pistache::Http::Code::Bad_Request);
+      return;
     }
 
     this->post_sm_contexts(smContextMessage, response);
+
   } catch (nlohmann::detail::exception &e) {
     //send a 400 error
     Logger::smf_api_server().warn("Can not parse the json data (error: %s)!",

src/api-server/impl/IndividualSMContextApiImpl.cpp

@@ -32,6 +32,8 @@
  */
 
 #include "IndividualSMContextApiImpl.h"
+#include <nghttp2/asio_http2_server.h>
+#include "mime_parser.hpp"
 
 namespace oai {
 namespace smf_server {
@@ -56,18 +58,35 @@ void IndividualSMContextApiImpl::release_sm_context(
   //TODO: to be updated as update_sm_context_handler
   Logger::smf_api_server().info("release_sm_context...");
 
+  boost::shared_ptr<boost::promise<smf::pdu_session_release_sm_context_response> > p =
+      boost::make_shared<
+          boost::promise<smf::pdu_session_release_sm_context_response> >();
+  boost::shared_future<smf::pdu_session_release_sm_context_response> f;
+  f = p->get_future();
+
+  //Generate ID for this promise (to be used in SMF-APP)
+  uint32_t promise_id = generate_promise_id();
+  Logger::smf_api_server().debug("Promise ID generated %d", promise_id);
+  m_smf_app->add_promise(promise_id, p);
+
   //handle Nsmf_PDUSession_UpdateSMContext Request
   Logger::smf_api_server().info(
       "Received a PDUSession_ReleaseSMContext Request: PDU Session Release request from AMF.");
   std::shared_ptr<itti_n11_release_sm_context_request> itti_msg =
       std::make_shared<itti_n11_release_sm_context_request>(TASK_SMF_N11,
-                                                           TASK_SMF_APP,
-                                                           response,
-                                                          smContextRef);
+                                                            TASK_SMF_APP,
+                                                            promise_id,
+                                                            smContextRef);
 
   itti_msg->scid = smContextRef;
+  itti_msg->http_version = 1;
   m_smf_app->handle_pdu_session_release_sm_context_request(itti_msg);
 
+  //wait for the result from APP and send reply to AMF
+  smf::pdu_session_release_sm_context_response sm_context_response = f.get();
+  Logger::smf_api_server().debug("Got result for promise ID %d", promise_id);
+
+  response.send(Pistache::Http::Code(sm_context_response.get_http_code()));
 }
 
 void IndividualSMContextApiImpl::retrieve_sm_context(
@@ -96,7 +115,7 @@ void IndividualSMContextApiImpl::update_sm_context(
     //N2 SM (for Session establishment)
     std::string n2_sm_information = smContextUpdateMessage
         .getBinaryDataN2SmInformation();
-    Logger::smf_api_server().debug("smContextMessage, n2 sm information %s",
+    Logger::smf_api_server().debug("N2 SM Information %s",
                                    n2_sm_information.c_str());
     std::string n2_sm_info_type = smContextUpdateData.getN2SmInfoType();
     sm_context_req_msg.set_n2_sm_information(n2_sm_information);
@@ -106,8 +125,7 @@ void IndividualSMContextApiImpl::update_sm_context(
     //N1 SM (for session modification)
     std::string n1_sm_message =
         smContextUpdateMessage.getBinaryDataN1SmMessage();
-    Logger::smf_api_server().debug("smContextMessage, n1 sm message %s",
-                                   n1_sm_message.c_str());
+    Logger::smf_api_server().debug("N1 SM message %s", n1_sm_message.c_str());
     sm_context_req_msg.set_n1_sm_message(n1_sm_message);
   }
   //Step 2. TODO: initialize necessary values for sm context req from smContextUpdateData
@@ -135,7 +153,6 @@ void IndividualSMContextApiImpl::update_sm_context(
   //TODO: Existing PDU session, step 3, SUPI, DNN, S-NSSAIs, SM Context ID, AMF ID, Request Type, N1 SM Container (PDU Session Establishment Request), User location, Access Type, RAT Type, PEI
   //step 15. (SM Context ID -> SCID, N2 SM, Request Type)(Initial Request)
   //TODO: verify why Request Type is not define in smContextUpdateData
-
   /* AMF-initiated with a release indication to request the release of the PDU Session  (step 3.d, section 4.3.4.2@3GPP TS 23.502)*/
   if (smContextUpdateData.releaseIsSet()) {
     sm_context_req_msg.set_release(smContextUpdateData.isRelease());
@@ -146,18 +163,72 @@ void IndividualSMContextApiImpl::update_sm_context(
   //step 1.e (AN initiated modification): SM Context ID, N2 SM information (QFI, User location Information and an indication that the QoS Flow is released)
   //step 7a, SM Context ID, N2 SM information, UE location information
   //Step 11, SM Context ID, N1 SM (PDU Session Modification Command ACK), User location
+  boost::shared_ptr<boost::promise<smf::pdu_session_update_sm_context_response> > p =
+      boost::make_shared<
+          boost::promise<smf::pdu_session_update_sm_context_response> >();
+  boost::shared_future<smf::pdu_session_update_sm_context_response> f;
+  f = p->get_future();
+
+  //Generate ID for this promise (to be used in SMF-APP)
+  uint32_t promise_id = generate_promise_id();
+  Logger::smf_api_server().debug("Promise ID generated %d", promise_id);
+  m_smf_app->add_promise(promise_id, p);
+
   //Step 3. Handle the itti_n11_update_sm_context_request message in smf_app
   std::shared_ptr<itti_n11_update_sm_context_request> itti_msg =
       std::make_shared<itti_n11_update_sm_context_request>(TASK_SMF_N11,
                                                            TASK_SMF_APP,
-                                                           response,
+                                                           promise_id,
                                                            smContextRef);
   itti_msg->req = sm_context_req_msg;
-  itti_msg->scid = smContextRef;
+  itti_msg->http_version = 1;
   m_smf_app->handle_pdu_session_update_sm_context_request(itti_msg);
 
-}
+  //wait for the result from APP and send reply to AMF
+  smf::pdu_session_update_sm_context_response sm_context_response = f.get();
+  Logger::smf_api_server().debug("Got result for promise ID %d", promise_id);
+
+  nlohmann::json json_data = { };
+  mime_parser parser = { };
+  std::string body = { };
+
+  sm_context_response.get_json_data(json_data);
+  Logger::smf_api_server().debug("Json data %s", json_data.dump().c_str());
+
+  if (sm_context_response.n1_sm_msg_is_set()
+      and sm_context_response.n2_sm_info_is_set()) {
+    parser.create_multipart_related_content(
+        body, json_data.dump(), CURL_MIME_BOUNDARY,
+        sm_context_response.get_n1_sm_message(),
+        sm_context_response.get_n2_sm_information());
+    response.headers().add<Pistache::Http::Header::ContentType>(
+        Pistache::Http::Mime::MediaType(
+            "multipart/related; boundary=" + std::string(CURL_MIME_BOUNDARY)));
+  } else if (sm_context_response.n1_sm_msg_is_set()) {
+    parser.create_multipart_related_content(
+        body, json_data.dump(), CURL_MIME_BOUNDARY,
+        sm_context_response.get_n1_sm_message(),
+        multipart_related_content_part_e::NAS);
+    response.headers().add<Pistache::Http::Header::ContentType>(
+        Pistache::Http::Mime::MediaType(
+            "multipart/related; boundary=" + std::string(CURL_MIME_BOUNDARY)));
+  } else if (sm_context_response.n2_sm_info_is_set()) {
+    parser.create_multipart_related_content(
+        body, json_data.dump(), CURL_MIME_BOUNDARY,
+        sm_context_response.get_n2_sm_information(),
+        multipart_related_content_part_e::NGAP);
+    response.headers().add<Pistache::Http::Header::ContentType>(
+        Pistache::Http::Mime::MediaType(
+            "multipart/related; boundary=" + std::string(CURL_MIME_BOUNDARY)));
+  } else {
+    response.headers().add<Pistache::Http::Header::ContentType>(
+        Pistache::Http::Mime::MediaType("application/json"));
+    body = json_data.dump().c_str();
+  }
 
+  response.send(Pistache::Http::Code(sm_context_response.get_http_code()),
+                body);
+}
 }
 }
 }

src/api-server/impl/IndividualSMContextApiImpl.h

@@ -87,6 +87,11 @@ class IndividualSMContextApiImpl :
  private:
   smf::smf_app *m_smf_app;
   std::string m_address;
+ protected:
+  static uint64_t generate_promise_id() {
+    return util::uint_uid_generator<uint64_t>::get_instance().get_uid();
+  }
+
 };
 
 }

src/api-server/impl/SMContextsCollectionApiImpl.cpp

@@ -36,6 +36,7 @@
 #include "smf_msg.hpp"
 #include "itti_msg_n11.hpp"
 #include "3gpp_29.502.h"
+#include <nghttp2/asio_http2_server.h>
 
 namespace oai {
 namespace smf_server {
@@ -49,9 +50,7 @@ SMContextsCollectionApiImpl::SMContextsCollectionApiImpl(
     :
     SMContextsCollectionApi(rtr),
     m_smf_app(smf_app_inst),
-    m_address(address)
-
-{
+    m_address(address) {
 }
 
 void SMContextsCollectionApiImpl::post_sm_contexts(
@@ -66,8 +65,7 @@ void SMContextsCollectionApiImpl::post_sm_contexts(
 
   SmContextCreateData smContextCreateData = smContextMessage.getJsonData();
   std::string n1_sm_msg = smContextMessage.getBinaryDataN1SmMessage();
-  Logger::smf_api_server().debug("smContextMessage, N1 SM message: %s",
-                                 n1_sm_msg.c_str());
+  Logger::smf_api_server().debug("N1 SM message: %s", n1_sm_msg.c_str());
 
   //Step 2. Create a pdu_session_create_sm_context_request message and store the necessary information
   Logger::smf_api_server().debug(
@@ -87,38 +85,36 @@ void SMContextsCollectionApiImpl::post_sm_contexts(
   smf_string_to_supi(&supi, supi_str.c_str());
   sm_context_req_msg.set_supi(supi);
   sm_context_req_msg.set_supi_prefix(supi_prefix);
-  Logger::smf_api_server().debug(
-      "SmContextCreateData, SUPI %s, SUPI Prefix %s, IMSI %s",
-      smContextCreateData.getSupi().c_str(), supi_prefix.c_str(),
-      supi_str.c_str());
+  Logger::smf_api_server().debug("SUPI %s, SUPI Prefix %s, IMSI %s",
+                                 smContextCreateData.getSupi().c_str(),
+                                 supi_prefix.c_str(), supi_str.c_str());
 
   //dnn
-  Logger::smf_api_server().debug("SmContextCreateData, DNN %s",
+  Logger::smf_api_server().debug("DNN %s",
                                  smContextCreateData.getDnn().c_str());
   sm_context_req_msg.set_dnn(smContextCreateData.getDnn().c_str());
 
   //S-Nssai
   Logger::smf_api_server().debug(
-      "SmContextCreateData, S-NSSAI SST %d, SD %s",
-      smContextCreateData.getSNssai().getSst(),
+      "S-NSSAI SST %d, SD %s", smContextCreateData.getSNssai().getSst(),
       smContextCreateData.getSNssai().getSd().c_str());
   snssai_t snssai(smContextCreateData.getSNssai().getSst(),
                   smContextCreateData.getSNssai().getSd());
   sm_context_req_msg.set_snssai(snssai);
 
   //PDU session ID
-  Logger::smf_api_server().debug("SmContextCreateData, PDU Session ID %d",
+  Logger::smf_api_server().debug("PDU Session ID %d",
                                  smContextCreateData.getPduSessionId());
   sm_context_req_msg.set_pdu_session_id(smContextCreateData.getPduSessionId());
 
   //AMF ID (ServingNFId)
-  Logger::smf_api_server().debug("SmContextCreateDatea, ServingNfId %s",
+  Logger::smf_api_server().debug("ServingNfId %s",
                                  smContextCreateData.getServingNfId().c_str());
   sm_context_req_msg.set_serving_nf_id(
       smContextCreateData.getServingNfId().c_str());  //TODO: should be verified that AMF ID is stored in GUAMI or ServingNfId
 
   //Request Type
-  Logger::smf_api_server().debug("SmContextCreateData, RequestType %s",
+  Logger::smf_api_server().debug("RequestType %s",
                                  smContextCreateData.getRequestType().c_str());
   sm_context_req_msg.set_request_type(smContextCreateData.getRequestType());
   //PCF ID
@@ -136,7 +132,7 @@ void SMContextsCollectionApiImpl::post_sm_contexts(
   //PCFId
 
   // DNN Selection Mode
-  Logger::smf_api_server().debug("SmContextCreateData, SelMode %s",
+  Logger::smf_api_server().debug("SelMode %s",
                                  smContextCreateData.getSelMode().c_str());
   sm_context_req_msg.set_dnn_selection_mode(
       smContextCreateData.getSelMode().c_str());
@@ -152,16 +148,40 @@ void SMContextsCollectionApiImpl::post_sm_contexts(
   //SM PDU DN request container (Optional)
   //Extended protocol configuration options (Optional) e.g, FOR DHCP
 
+  boost::shared_ptr<boost::promise<smf::pdu_session_create_sm_context_response> > p =
+      boost::make_shared<
+          boost::promise<smf::pdu_session_create_sm_context_response> >();
+  boost::shared_future<smf::pdu_session_create_sm_context_response> f;
+  f = p->get_future();
+
+  //Generate ID for this promise (to be used in SMF-APP)
+  uint32_t promise_id = generate_promise_id();
+  Logger::smf_api_server().debug("Promise ID generated %d", promise_id);
+  m_smf_app->add_promise(promise_id, p);
+
   //Step 3. Handle the pdu_session_create_sm_context_request message in smf_app
   std::shared_ptr<itti_n11_create_sm_context_request> itti_msg =
       std::make_shared<itti_n11_create_sm_context_request>(TASK_SMF_N11,
                                                            TASK_SMF_APP,
-                                                           response);
+                                                           promise_id);
   itti_msg->req = sm_context_req_msg;
+  itti_msg->http_version = 1;
   m_smf_app->handle_pdu_session_create_sm_context_request(itti_msg);
 
+  //wait for the result from APP and send reply to AMF
+  smf::pdu_session_create_sm_context_response sm_context_response = f.get();
+  Logger::smf_api_server().debug("Got result for promise ID %d", promise_id);
+
+  nlohmann::json json_data = { };
+  sm_context_response.get_json_data(json_data);
+  if (!json_data.empty()) {
+    response.headers().add<Pistache::Http::Header::ContentType>(
+        Pistache::Http::Mime::MediaType("application/json"));
+    response.send(Pistache::Http::Code(sm_context_response.get_http_code()), json_data.dump().c_str());
+  } else {
+    response.send(Pistache::Http::Code(sm_context_response.get_http_code()));
+  }
 }
-
 }
 }
 }

src/api-server/impl/SMContextsCollectionApiImpl.h

@@ -73,6 +73,11 @@ class SMContextsCollectionApiImpl :
  private:
   smf::smf_app *m_smf_app;
   std::string m_address;
+ protected:
+  static uint64_t generate_promise_id() {
+    return util::uint_uid_generator<uint64_t>::get_instance().get_uid();
+  }
+
 };
 
 }

src/api-server/model/SmContextUpdateData.cpp

@@ -659,17 +659,6 @@ void SmContextUpdateData::setN2SmInfoType(std::string const& value)
     m_N2SmInfoTypeIsSet = true;
 }
 
-/*
-N2SmInfoType SmContextUpdateData::getN2SmInfoType() const
-{
-    return m_N2SmInfoType;
-}
-void SmContextUpdateData::setN2SmInfoType(N2SmInfoType const& value)
-{
-    m_N2SmInfoType = value;
-    m_N2SmInfoTypeIsSet = true;
-}
-*/
 bool SmContextUpdateData::n2SmInfoTypeIsSet() const
 {
     return m_N2SmInfoTypeIsSet;

src/api-server/smf-api-server.cpp

@@ -30,6 +30,7 @@
  *      contact@openairinterface.org
  */
 
+#include "smf-api-server.h"
 #include "pistache/endpoint.h"
 #include "pistache/http.h"
 #include "pistache/router.h"
@@ -39,7 +40,6 @@
 #include <unistd.h>
 #endif
 
-#include "smf-api-server.h"
 #define PISTACHE_SERVER_MAX_PAYLOAD 32768
 
 #ifdef __linux__
@@ -92,19 +92,3 @@ void SMFApiServer::start() {
 void SMFApiServer::shutdown() {
   m_httpEndpoint->shutdown();
 }
-
-/*
- int main() {
- #ifdef __linux__
- std::vector<int> sigs{SIGQUIT, SIGINT, SIGTERM, SIGHUP};
- setUpUnixSignals(sigs);
- #endif
-
- Pistache::Address addr(Pistache::Ipv4::any(), Pistache::Port(8080));
- SMFApiServer smfApiServer(addr);
- smfApiServer.init(2);
- smfApiServer.start();
- smfApiServer.shutdown();
-
- }
- */

src/api-server/smf-api-server.h

@@ -31,6 +31,9 @@
  *      contact@openairinterface.org
  */
 
+#ifndef FILE_SMF_API_SERVER_SEEN
+#define FILE_SMF_API_SERVER_SEEN
+
 #include "pistache/endpoint.h"
 #include "pistache/http.h"
 #include "pistache/router.h"
@@ -63,7 +66,6 @@ class SMFApiServer {
     m_smContextsCollectionApiImpl =
         std::make_shared<SMContextsCollectionApiImpl>(m_router, smf_app_inst,
                                                       m_address);
-
   }
   void init(size_t thr = 1);
   void start();
@@ -77,6 +79,6 @@ class SMFApiServer {
   std::shared_ptr<PDUSessionsCollectionApiImpl> m_pduSessionsCollectionApiImpl;
   std::shared_ptr<SMContextsCollectionApiImpl> m_smContextsCollectionApiImpl;
   std::string m_address;
-
 };
 
+#endif

src/api-server/smf-http2-server.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#ifndef FILE_SMF_HTTP2_SERVER_SEEN
+#define FILE_SMF_HTTP2_SERVER_SEEN
+
+#include "smf_app.hpp"
+#include <nghttp2/asio_http2_server.h>
+#include "SmContextUpdateMessage.h"
+#include "SmContextMessage.h"
+#include "SmContextReleaseData.h"
+#include "uint_generator.hpp"
+#include "smf.h"
+
+using namespace nghttp2::asio_http2;
+using namespace nghttp2::asio_http2::server;
+using namespace oai::smf_server::model;
+
+class smf_http2_server {
+ public:
+  smf_http2_server(std::string addr, uint32_t port, smf::smf_app *smf_app_inst)
+      :
+      m_address(addr),
+      m_port(port),
+      server(),
+      m_smf_app(smf_app_inst) {
+  }
+  void start();
+  void init(size_t thr) {
+  }
+  void create_sm_contexts_handler(const SmContextMessage &smContextMessage,
+                                  const response &response);
+  void update_sm_context_handler(
+      const std::string &smf_ref,
+      const SmContextUpdateMessage &smContextUpdateMessage,
+      const response &response);
+
+  void release_sm_context_handler(
+      const std::string &smf_ref,
+      const SmContextReleaseData &smContextReleaseData,
+      const response &response);
+
+ private:
+  util::uint_generator<uint32_t> m_promise_id_generator;
+  std::string m_address;
+  uint32_t m_port;
+  http2 server;
+  smf::smf_app *m_smf_app;
+
+ protected:
+  static uint64_t generate_promise_id() {
+    return util::uint_uid_generator<uint64_t>::get_instance().get_uid();
+  }
+};
+
+#endif

src/common/utils/simple_parser.hpp → src/common/3gpp_29.500.h

@@ -19,30 +19,40 @@
  *      contact@openairinterface.org
  */
 
-/*! \file simple_parser.hpp
- \brief
- \author
- \company Eurecom
- \email:
- */
-#ifndef FILE_SIMPLE_PARSER_HPP_SEEN
-#define FILE_SIMPLE_PARSER_HPP_SEEN
-# include <string>
-#include <map>
-#include <vector>
+#ifndef FILE_3GPP_29_500_SMF_SEEN
+#define FILE_3GPP_29_500_SMF_SEEN
 
-typedef struct mime_part {
-  std::string content_type;
-  std::string body;
-} mime_part;
+enum http_status_code_e {
+  HTTP_STATUS_CODE_100_CONTINUE = 100,