Merge branch 'fix_multiple_pdu_udr' into fix_mcc_mnc_00_udr

src/common/3gpp_24.501.h

@@ -32,6 +32,7 @@
 #include <netinet/in.h>
 
 #ifdef __cplusplus
+#include <nlohmann/json.hpp>
 extern "C" {
 #endif
 
@@ -338,10 +339,16 @@ typedef struct pdu_session_type_s {
     return (p == pdu_session_type);
   }
   //------------------------------------------------------------------------------
-  const std::string& toString() const {
+  const std::string& to_string() const {
     return pdu_session_type_e2str.at(pdu_session_type);
   }
 
+  nlohmann::json to_json() const {
+    nlohmann::json json_data = {};
+    json_data                = to_string();
+    return json_data;
+  }
+
 } pdu_session_type_t;
 
 //-------------------------------------

src/common/3gpp_29.503.h

@@ -24,6 +24,7 @@
 
 #include "smf.h"
 #include "3gpp_29.571.h"
+#include <nlohmann/json.hpp>
 
 enum ssc_mode_e {
   SSC_MODE_1 = 1,
@@ -31,7 +32,7 @@ enum ssc_mode_e {
   SSC_MODE_3 = 3,
 };
 static const std::vector<std::string> ssc_mode_e2str = {
-    "Error", "SSC_MODE_1", "SSC_MODE_2", "SSC_MODE_3"};
+    "SSC_MODE_ERROR", "SSC_MODE_1", "SSC_MODE_2", "SSC_MODE_3"};
 
 typedef struct ssc_mode_s {
   uint8_t ssc_mode;
@@ -58,16 +59,48 @@ typedef struct ssc_mode_s {
 
   virtual ~ssc_mode_s(){};
 
+  const std::string& to_string() const { return ssc_mode_e2str.at(ssc_mode); }
+
+  nlohmann::json to_json() const {
+    nlohmann::json json_data = to_string();
+    return json_data;
+  }
 } ssc_mode_t;
 
 typedef struct pdu_session_types_s {
   pdu_session_type_t default_session_type;
   std::vector<pdu_session_type_t> allowed_session_types;
+
+  nlohmann::json to_json() const {
+    nlohmann::json json_data       = {};
+    json_data["pdu_session_types"] = default_session_type.to_string();
+    if (allowed_session_types.size() > 0) {
+      json_data["allowed_session_types"] = nlohmann::json::array();
+    }
+    for (const auto& a : allowed_session_types) {
+      nlohmann::json json_item = a.to_string();
+      json_data["allowed_session_types"].push_back(json_item);
+    }
+    return json_data;
+  }
 } pdu_session_types_t;
 
 typedef struct ssc_modes_s {
   ssc_mode_t default_ssc_mode;
   std::vector<ssc_mode_t> allowed_ssc_modes;
+
+  nlohmann::json to_json() const {
+    nlohmann::json json_data      = {};
+    json_data["default_ssc_mode"] = default_ssc_mode.to_string();
+    if (allowed_ssc_modes.size() > 0) {
+      json_data["allowed_ssc_modes"] = nlohmann::json::array();
+    }
+    for (const auto& a : allowed_ssc_modes) {
+      nlohmann::json json_item = a.to_string();
+      json_data["allowed_ssc_modes"].push_back(json_item);
+    }
+    return json_data;
+  }
 } ssc_modes_t;
 
 enum ip_address_type_value_e {
@@ -76,6 +109,10 @@ enum ip_address_type_value_e {
   IP_ADDRESS_TYPE_IPV6_PREFIX  = 2
 };
 
+static const std::vector<std::string> ip_address_type_value_e2str = {
+    "IP_ADDRESS_TYPE_IPV4_ADDRESS", "IP_ADDRESS_TYPE_IPV6_ADDRESS",
+    "IP_ADDRESS_TYPE_IPV6_PREFIX"};
+
 typedef struct ipv6_prefix_s {
   struct in6_addr prefix;
   uint8_t prefix_len;
@@ -189,6 +226,15 @@ typedef struct ip_address_s {
     }
     return std::string("Unknown IP Address Type");
   }
+
+  nlohmann::json to_json() const {
+    nlohmann::json json_data = {};
+    json_data["ip_address_type"] =
+        ip_address_type_value_e2str.at(ip_address_type);
+    json_data["addr"] = to_string();
+    return json_data;
+  }
+
 } ip_address_t;
 
 typedef struct dnn_configuration_s {
@@ -197,6 +243,24 @@ typedef struct dnn_configuration_s {
   session_ambr_t session_ambr;
   subscribed_default_qos_t _5g_qos_profile;
   std::vector<ip_address_t> static_ip_addresses;
+
+  nlohmann::json to_json() const {
+    nlohmann::json json_data       = {};
+    json_data["pdu_session_types"] = pdu_session_types.to_json();
+    json_data["ssc_modes"]         = ssc_modes.to_json();
+    json_data["session_ambr"]      = session_ambr.to_json();
+    json_data["_5g_qos_profile"]   = _5g_qos_profile.to_json();
+
+    if (static_ip_addresses.size() > 0) {
+      json_data["static_ip_addresses"] = nlohmann::json::array();
+    }
+    for (const auto& a : static_ip_addresses) {
+      nlohmann::json json_item = a.to_string();
+      json_data["static_ip_addresses"].push_back(json_item);
+    }
+
+    return json_data;
+  }
 } dnn_configuration_t;
 
 #endif

src/common/3gpp_29.571.h

@@ -25,6 +25,13 @@
 typedef struct session_ambr_s {
   std::string uplink;
   std::string downlink;
+
+  nlohmann::json to_json() const {
+    nlohmann::json json_data = {};
+    json_data["uplink"]      = uplink;
+    json_data["downlink"]    = downlink;
+    return json_data;
+  }
 } session_ambr_t;
 
 enum preemtion_capability_e { NOT_PREEMPT = 1, MAY_PREEMPT = 2 };
@@ -37,6 +44,14 @@ typedef struct arp_5gc_s {
   uint8_t priority_level;  // (integer 1-15)
   std::string preempt_cap;
   std::string preempt_vuln;  // NOT_PREEMPTABLE, PREEMPTABLE
+
+  nlohmann::json to_json() const {
+    nlohmann::json json_data    = {};
+    json_data["priority_level"] = priority_level;
+    json_data["preempt_cap"]    = preempt_cap;
+    json_data["preempt_vuln"]   = preempt_vuln;
+    return json_data;
+  }
 } arp_5gc_t;
 
 // see section 5.4.4.1@TS 29.571
@@ -44,6 +59,14 @@ typedef struct subscribed_default_qos_s {
   uint8_t _5qi;
   arp_5gc_t arp;
   uint8_t priority_level;  // 1-127
+
+  nlohmann::json to_json() const {
+    nlohmann::json json_data    = {};
+    json_data["_5qi"]           = _5qi;
+    json_data["arp"]            = arp.to_json();
+    json_data["priority_level"] = priority_level;
+    return json_data;
+  }
 } subscribed_default_qos_t;
 
 enum reflective_qos_attribute_e { RQOS = 1, NO_RQOS = 2 };
@@ -54,6 +77,12 @@ static const std::vector<std::string> reflective_qos_attribute_e2str = {
 typedef struct gNB_id_s {
   uint8_t bit_length;
   std::string gNB_value;
+  nlohmann::json to_json() const {
+    nlohmann::json json_data = {};
+    json_data["bit_length"]  = bit_length;
+    json_data["gNB_value"]   = gNB_value;
+    return json_data;
+  }
 } gNB_id_t;  // 22bits to 32bits
 
 typedef struct global_ran_node_id_s {
@@ -61,6 +90,7 @@ typedef struct global_ran_node_id_s {
   //    n3IwfId:
   gNB_id_t gNbId;
   //        ngeNbId:
+
 } global_ran_node_id_t;
 
 #endif

src/smf_app/smf_config.cpp

@@ -1085,7 +1085,7 @@ void smf_config::display() {
        it++) {
     Logger::smf_app().info(
         "    DNN..........: %s (%s)", it->second.dnn.c_str(),
-        it->second.pdu_session_type.toString().c_str());
+        it->second.pdu_session_type.to_string().c_str());
 
     if ((it->second.pdu_session_type.pdu_session_type ==
          pdu_session_type_e::PDU_SESSION_TYPE_E_IPV4) or

src/smf_app/smf_context.cpp

@@ -379,7 +379,7 @@ std::string smf_pdu_session::toString() const {
     s.append("\tDNN:\t\t\t").append(dnn).append("\n");
     s.append("\tS-NSSAI:\t\t\t").append(snssai.toString()).append("\n");
     s.append("\tPDN type:\t\t")
-        .append(pdu_session_type.toString())
+        .append(pdu_session_type.to_string())
         .append("\n");
   }
   if (ipv4)
@@ -4427,7 +4427,7 @@ void smf_context::handle_flexcn_event(
         }
       }
       cj["pdu_session_type"] =
-          sp->pdu_session_type.toString();  // PDU Session Type
+          sp->pdu_session_type.to_string();  // PDU Session Type
       // NSSAI
       cj["snssai"]["sst"] = sp->get_snssai().sst;
       cj["snssai"]["sd"]  = std::to_string(sp->get_snssai().sd);
@@ -4554,7 +4554,7 @@ void smf_context::handle_pdusesest(
         }
       }
       ev_notif.set_pdu_session_type(
-          sp->pdu_session_type.toString());  // PDU Session Type
+          sp->pdu_session_type.to_string());  // PDU Session Type
       ev_notif.set_sst(sp->get_snssai().sst);
       ev_notif.set_sd(std::to_string(sp->get_snssai().sd));
       ev_notif.set_dnn(sp->get_dnn());

src/smf_app/smf_n1.cpp

@@ -166,7 +166,7 @@ bool smf_n1::create_n1_pdu_session_establishment_accept(
   // PDUAddress
   paa_t paa = sm_context_res.get_paa();
   Logger::smf_n1().debug(
-      "PDU Session Type %s", paa.pdu_session_type.toString().c_str());
+      "PDU Session Type %s", paa.pdu_session_type.to_string().c_str());
   sm_msg->pdu_session_establishment_accept.pduaddress.pdu_session_type_value =
       static_cast<uint8_t>(paa.pdu_session_type.pdu_session_type);
   if (paa.pdu_session_type.pdu_session_type == PDU_SESSION_TYPE_E_IPV4) {

src/smf_app/smf_n7.hpp

@@ -94,7 +94,7 @@ struct policy_association {
     context.setSupi("imsi-" + supi);
     oai::smf_server::model::PduSessionType pdu_session_type_model;
     // hacky
-    from_json(pdu_session_type.toString(), pdu_session_type_model);
+    from_json(pdu_session_type.to_string(), pdu_session_type_model);
     context.setPduSessionType(pdu_session_type_model);
     context.setDnn(dnn);
     context.setSliceInfo(snssai_model);

src/smf_app/smf_sbi.cpp

@@ -936,136 +936,141 @@ bool smf_sbi::get_sm_data(
 
     // Verify DNN configurations
     if (jsonData.find("dnnConfigurations") == jsonData.end()) return false;
+    Logger::smf_sbi().debug(
+        "DNN Configurations %s", jsonData["dnnConfigurations"].dump().c_str());
 
     // Retrieve SessionManagementSubscription and store in the context
     for (nlohmann::json::iterator it = jsonData["dnnConfigurations"].begin();
          it != jsonData["dnnConfigurations"].end(); ++it) {
       Logger::smf_sbi().debug("DNN %s", it.key().c_str());
-      if (it.key().compare(dnn) != 0) break;
-
-      try {
-        std::shared_ptr<dnn_configuration_t> dnn_configuration =
-            std::make_shared<dnn_configuration_t>();
-        // PDU Session Type (Mandatory)
-        std::string default_session_type =
-            it.value()["pduSessionTypes"]["defaultSessionType"];
-        Logger::smf_sbi().debug(
-            "Default session type %s", default_session_type.c_str());
-        pdu_session_type_t pdu_session_type(default_session_type);
-        dnn_configuration->pdu_session_types.default_session_type =
-            pdu_session_type;
-
-        // SSC_Mode (Mandatory)
-        std::string default_ssc_mode = it.value()["sscModes"]["defaultSscMode"];
-        Logger::smf_sbi().debug(
-            "Default SSC Mode %s", default_ssc_mode.c_str());
-        ssc_mode_t ssc_mode(default_ssc_mode);
-        dnn_configuration->ssc_modes.default_ssc_mode = ssc_mode;
-
-        // 5gQosProfile (Optional)
-        if (it.value().find("5gQosProfile") != it.value().end()) {
-          dnn_configuration->_5g_qos_profile._5qi =
-              it.value()["5gQosProfile"]["5qi"];
-          dnn_configuration->_5g_qos_profile.arp.priority_level =
-              it.value()["5gQosProfile"]["arp"]["priorityLevel"];
-          dnn_configuration->_5g_qos_profile.arp.preempt_cap =
-              it.value()["5gQosProfile"]["arp"]["preemptCap"];
-          dnn_configuration->_5g_qos_profile.arp.preempt_vuln =
-              it.value()["5gQosProfile"]["arp"]["preemptVuln"];
-          // Optinal
-          if (it.value()["5gQosProfile"].find("") !=
-              it.value()["5gQosProfile"].end()) {
-            dnn_configuration->_5g_qos_profile.priority_level =
-                it.value()["5gQosProfile"]["5QiPriorityLevel"];
-          }
-        }
-
-        // session_ambr (Optional)
-        if (it.value().find("sessionAmbr") != it.value().end()) {
-          dnn_configuration->session_ambr.uplink =
-              it.value()["sessionAmbr"]["uplink"];
-          dnn_configuration->session_ambr.downlink =
-              it.value()["sessionAmbr"]["downlink"];
+      if (it.key().compare(dnn) == 0) {
+        // Get DNN configuration
+        try {
+          std::shared_ptr<dnn_configuration_t> dnn_configuration =
+              std::make_shared<dnn_configuration_t>();
+          // PDU Session Type (Mandatory)
+          std::string default_session_type =
+              it.value()["pduSessionTypes"]["defaultSessionType"];
           Logger::smf_sbi().debug(
-              "Session AMBR Uplink %s, Downlink %s",
-              dnn_configuration->session_ambr.uplink.c_str(),
-              dnn_configuration->session_ambr.downlink.c_str());
-        }
-
-        // Static IP Addresses (Optional)
-        if (it.value().find("staticIpAddress") != it.value().end()) {
-          for (const auto& ip_addr : it.value()["staticIpAddress"]) {
-            if (ip_addr.find("ipv4Addr") != ip_addr.end()) {
-              struct in_addr ue_ipv4_addr = {};
-              std::string ue_ip_str = ip_addr["ipv4Addr"].get<std::string>();
-              // ip_addr.at("ipv4Addr").get_to(ue_ip_str);
-              IPV4_STR_ADDR_TO_INADDR(
-                  util::trim(ue_ip_str).c_str(), ue_ipv4_addr,
-                  "BAD IPv4 ADDRESS FORMAT FOR UE IP ADDR !");
-              ip_address_t ue_ip = {};
-              ue_ip              = ue_ipv4_addr;
-              dnn_configuration->static_ip_addresses.push_back(ue_ip);
-            } else if (ip_addr.find("ipv6Addr") != ip_addr.end()) {
-              unsigned char buf_in6_addr[sizeof(struct in6_addr)];
-              struct in6_addr ue_ipv6_addr;
-              std::string ue_ip_str = ip_addr["ipv6Addr"].get<std::string>();
-
-              if (inet_pton(
-                      AF_INET6, util::trim(ue_ip_str).c_str(), buf_in6_addr) ==
-                  1) {
-                memcpy(&ue_ipv6_addr, buf_in6_addr, sizeof(struct in6_addr));
-              } else {
-                Logger::smf_app().error(
-                    "Bad UE IPv6 Addr %s", ue_ip_str.c_str());
-                throw("Bad UE IPv6 Addr %s", ue_ip_str.c_str());
-              }
+              "Default session type %s", default_session_type.c_str());
+          pdu_session_type_t pdu_session_type(default_session_type);
+          dnn_configuration->pdu_session_types.default_session_type =
+              pdu_session_type;
+
+          // SSC_Mode (Mandatory)
+          std::string default_ssc_mode =
+              it.value()["sscModes"]["defaultSscMode"];
+          Logger::smf_sbi().debug(
+              "Default SSC Mode %s", default_ssc_mode.c_str());
+          ssc_mode_t ssc_mode(default_ssc_mode);
+          dnn_configuration->ssc_modes.default_ssc_mode = ssc_mode;
+
+          // 5gQosProfile (Optional)
+          if (it.value().find("5gQosProfile") != it.value().end()) {
+            dnn_configuration->_5g_qos_profile._5qi =
+                it.value()["5gQosProfile"]["5qi"];
+            dnn_configuration->_5g_qos_profile.arp.priority_level =
+                it.value()["5gQosProfile"]["arp"]["priorityLevel"];
+            dnn_configuration->_5g_qos_profile.arp.preempt_cap =
+                it.value()["5gQosProfile"]["arp"]["preemptCap"];
+            dnn_configuration->_5g_qos_profile.arp.preempt_vuln =
+                it.value()["5gQosProfile"]["arp"]["preemptVuln"];
+            // Optinal
+            if (it.value()["5gQosProfile"].find("") !=
+                it.value()["5gQosProfile"].end()) {
+              dnn_configuration->_5g_qos_profile.priority_level =
+                  it.value()["5gQosProfile"]["5QiPriorityLevel"];
+            }
+          }
 
-              ip_address_t ue_ip = {};
-              ue_ip              = ue_ipv6_addr;
-              dnn_configuration->static_ip_addresses.push_back(ue_ip);
-            } else if (ip_addr.find("ipv6Prefix") != ip_addr.end()) {
-              unsigned char buf_in6_addr[sizeof(struct in6_addr)];
-              struct in6_addr ipv6_prefix;
-              std::string prefix_str = ip_addr["ipv6Prefix"].get<std::string>();
-              std::vector<std::string> words = {};
-              boost::split(
-                  words, prefix_str, boost::is_any_of("/"),
-                  boost::token_compress_on);
-              if (words.size() != 2) {
-                Logger::smf_app().error(
-                    "Bad value for UE IPv6 Prefix %s", prefix_str.c_str());
-                return RETURNerror;
-              }
+          // session_ambr (Optional)
+          if (it.value().find("sessionAmbr") != it.value().end()) {
+            dnn_configuration->session_ambr.uplink =
+                it.value()["sessionAmbr"]["uplink"];
+            dnn_configuration->session_ambr.downlink =
+                it.value()["sessionAmbr"]["downlink"];
+            Logger::smf_sbi().debug(
+                "Session AMBR Uplink %s, Downlink %s",
+                dnn_configuration->session_ambr.uplink.c_str(),
+                dnn_configuration->session_ambr.downlink.c_str());
+          }
 
-              if (inet_pton(
-                      AF_INET6, util::trim(words.at(0)).c_str(),
-                      buf_in6_addr) == 1) {
-                memcpy(&ipv6_prefix, buf_in6_addr, sizeof(struct in6_addr));
-              } else {
-                Logger::smf_app().error(
-                    "Bad UE IPv6 Addr %s", words.at(0).c_str());
-                throw("Bad UE IPv6 Addr %s", words.at(0).c_str());
+          // Static IP Addresses (Optional)
+          if (it.value().find("staticIpAddress") != it.value().end()) {
+            for (const auto& ip_addr : it.value()["staticIpAddress"]) {
+              if (ip_addr.find("ipv4Addr") != ip_addr.end()) {
+                struct in_addr ue_ipv4_addr = {};
+                std::string ue_ip_str = ip_addr["ipv4Addr"].get<std::string>();
+                // ip_addr.at("ipv4Addr").get_to(ue_ip_str);
+                IPV4_STR_ADDR_TO_INADDR(
+                    util::trim(ue_ip_str).c_str(), ue_ipv4_addr,
+                    "BAD IPv4 ADDRESS FORMAT FOR UE IP ADDR !");
+                ip_address_t ue_ip = {};
+                ue_ip              = ue_ipv4_addr;
+                dnn_configuration->static_ip_addresses.push_back(ue_ip);
+              } else if (ip_addr.find("ipv6Addr") != ip_addr.end()) {
+                unsigned char buf_in6_addr[sizeof(struct in6_addr)];
+                struct in6_addr ue_ipv6_addr;
+                std::string ue_ip_str = ip_addr["ipv6Addr"].get<std::string>();
+
+                if (inet_pton(
+                        AF_INET6, util::trim(ue_ip_str).c_str(),
+                        buf_in6_addr) == 1) {
+                  memcpy(&ue_ipv6_addr, buf_in6_addr, sizeof(struct in6_addr));
+                } else {
+                  Logger::smf_app().error(
+                      "Bad UE IPv6 Addr %s", ue_ip_str.c_str());
+                  ue_ipv6_addr = in6addr_any;
+                }
+
+                ip_address_t ue_ip = {};
+                ue_ip              = ue_ipv6_addr;
+                dnn_configuration->static_ip_addresses.push_back(ue_ip);
+              } else if (ip_addr.find("ipv6Prefix") != ip_addr.end()) {
+                unsigned char buf_in6_addr[sizeof(struct in6_addr)];
+                struct in6_addr ipv6_prefix;
+                std::string prefix_str =
+                    ip_addr["ipv6Prefix"].get<std::string>();
+                std::vector<std::string> words = {};
+                boost::split(
+                    words, prefix_str, boost::is_any_of("/"),
+                    boost::token_compress_on);
+                if (words.size() != 2) {
+                  Logger::smf_app().error(
+                      "Bad value for UE IPv6 Prefix %s", prefix_str.c_str());
+                  return RETURNerror;
+                }
+
+                if (inet_pton(
+                        AF_INET6, util::trim(words.at(0)).c_str(),
+                        buf_in6_addr) == 1) {
+                  memcpy(&ipv6_prefix, buf_in6_addr, sizeof(struct in6_addr));
+                } else {
+                  Logger::smf_app().error(
+                      "Bad UE IPv6 Addr %s", words.at(0).c_str());
+                  ipv6_prefix = in6addr_any;
+                }
+
+                ip_address_t ue_ip           = {};
+                ipv6_prefix_t ue_ipv6_prefix = {};
+                ue_ipv6_prefix.prefix_len = std::stoi(util::trim(words.at(1)));
+                ue_ipv6_prefix.prefix     = ipv6_prefix;
+                ue_ip                     = ue_ipv6_prefix;
+                dnn_configuration->static_ip_addresses.push_back(ue_ip);
               }
-
-              ip_address_t ue_ip           = {};
-              ipv6_prefix_t ue_ipv6_prefix = {};
-              ue_ipv6_prefix.prefix_len    = std::stoi(util::trim(words.at(1)));
-              ue_ipv6_prefix.prefix        = ipv6_prefix;
-              ue_ip                        = ue_ipv6_prefix;
-              dnn_configuration->static_ip_addresses.push_back(ue_ip);
             }
           }
-        }
 
-        subscription->insert_dnn_configuration(it.key(), dnn_configuration);
-        return true;
-      } catch (nlohmann::json::exception& e) {
-        Logger::smf_sbi().warn(
-            "Exception message %s, exception id %d ", e.what(), e.id);
-        return false;
-      } catch (std::exception& e) {
-        Logger::smf_sbi().warn("Exception message %s", e.what());
-        return false;
+          subscription->insert_dnn_configuration(it.key(), dnn_configuration);
+          return true;
+        } catch (nlohmann::json::exception& e) {
+          Logger::smf_sbi().warn(
+              "Exception message %s, exception id %d ", e.what(), e.id);
+          return false;
+        } catch (std::exception& e) {
+          Logger::smf_sbi().warn("Exception message %s", e.what());
+          return false;
+        }
       }
     }
     return true;