VoNR added but not tested!

configs/meson.build

@@ -41,7 +41,6 @@ example_conf = '''
     vonr.yaml
     slice.yaml
     srslte.yaml
-    sample.yaml
     non3gpp.yaml
 '''.split()
 

docs/_pages/about.md

@@ -16,13 +16,13 @@ Open5GS is a C-language Open Source implementation of 5GC and EPC, i.e. the core
 - Multiple PDU session
 - Handover(5GC Xn/N2 and EPC S1/X2)
 - CSFB(Circuit Switched Fall Back) and SMSoS(SMS Over SGs)
-- VoLTE(Voice over LTE) with HSS-Cx interface
 - Support ePDG Interface(SWx, S6b, S2b)
+- VoLTE(Voice over LTE) with HSS-Cx interface
+- VoNR(Voice over NR)
 
 #### Known Limitations
 ---
 
-- No VoNR(Voice over NR)
 - No Interworking with EPC
 - No NB-IoT
 - No OCS/OFCS

lib/core/ogs-3gpp-types.c

@@ -726,3 +726,279 @@ void ogs_ims_data_free(ogs_ims_data_t *ims_data)
         }
     }
 }
+
+static int flow_rx_to_gx(ogs_flow_t *rx_flow, ogs_flow_t *gx_flow)
+{
+    int len;
+    char *from_str, *to_str;
+
+    ogs_assert(rx_flow);
+    ogs_assert(gx_flow);
+
+    if (!strncmp(rx_flow->description,
+                "permit out", strlen("permit out"))) {
+        gx_flow->direction = OGS_FLOW_DOWNLINK_ONLY;
+        gx_flow->description = ogs_strdup(rx_flow->description);
+        ogs_assert(gx_flow->description);
+
+    } else if (!strncmp(rx_flow->description,
+                "permit in", strlen("permit in"))) {
+        gx_flow->direction = OGS_FLOW_UPLINK_ONLY;
+
+        /* 'permit in' should be changed
+         * 'permit out' in Gx Diameter */
+        len = strlen(rx_flow->description)+2;
+        gx_flow->description = ogs_malloc(len);
+        ogs_assert(gx_flow->description);
+        strcpy(gx_flow->description, "permit out");
+        from_str = strstr(&rx_flow->description[strlen("permit in")], "from");
+        ogs_assert(from_str);
+        to_str = strstr(&rx_flow->description[strlen("permit in")], "to");
+        ogs_assert(to_str);
+        strncat(gx_flow->description,
+            &rx_flow->description[strlen("permit in")],
+            strlen(rx_flow->description) -
+                strlen("permit in") - strlen(from_str));
+        strcat(gx_flow->description, "from");
+        strcat(gx_flow->description, &to_str[strlen("to")]);
+        strcat(gx_flow->description, " to");
+        strncat(gx_flow->description, &from_str[strlen("from")],
+                strlen(from_str) - strlen(to_str) - strlen("from") - 1);
+        ogs_assert(len == strlen(gx_flow->description)+1);
+    } else {
+        ogs_error("Invalid Flow Descripton : [%s]", rx_flow->description);
+        return OGS_ERROR;
+    }
+
+    return OGS_OK;
+}
+
+int ogs_pcc_rule_num_of_flow_equal_to_media(
+        ogs_pcc_rule_t *pcc_rule, ogs_media_component_t *media_component)
+{
+    int rv;
+    int i, j, k;
+    int matched = 0;
+    int new = 0;
+
+    ogs_assert(pcc_rule);
+    ogs_assert(media_component);
+
+    for (i = 0; i < media_component->num_of_sub; i++) {
+        ogs_media_sub_component_t *sub = &media_component->sub[i];
+
+        for (j = 0; j < sub->num_of_flow; j++) {
+            new++;
+        }
+    }
+
+    if (new == 0) {
+        /* No new flow in Media-Component */
+        return pcc_rule->num_of_flow;
+    }
+
+    for (i = 0; i < media_component->num_of_sub; i++) {
+        ogs_media_sub_component_t *sub = &media_component->sub[i];
+
+        for (j = 0; j < sub->num_of_flow &&
+                    j < OGS_MAX_NUM_OF_FLOW_IN_MEDIA_SUB_COMPONENT; j++) {
+            ogs_flow_t gx_flow;
+            ogs_flow_t *rx_flow = &sub->flow[j];
+
+            rv = flow_rx_to_gx(rx_flow, &gx_flow);
+            if (rv != OGS_OK) {
+                ogs_error("flow reformatting error");
+                return OGS_ERROR;
+            }
+
+            for (k = 0; k < pcc_rule->num_of_flow; k++) {
+                if (gx_flow.direction == pcc_rule->flow[k].direction &&
+                    !strcmp(gx_flow.description,
+                        pcc_rule->flow[k].description)) {
+                    matched++;
+                    break;
+                }
+            }
+
+            OGS_FLOW_FREE(&gx_flow);
+        }
+    }
+
+    return matched;
+}
+
+int ogs_pcc_rule_install_flow_from_media(
+        ogs_pcc_rule_t *pcc_rule, ogs_media_component_t *media_component)
+{
+    int rv;
+    int i, j;
+
+    ogs_assert(pcc_rule);
+    ogs_assert(media_component);
+
+    /* Remove Flow from PCC Rule */
+    for (i = 0; i < pcc_rule->num_of_flow; i++) {
+        OGS_FLOW_FREE(&pcc_rule->flow[i]);
+    }
+    pcc_rule->num_of_flow = 0;
+
+    for (i = 0; i < media_component->num_of_sub; i++) {
+        ogs_media_sub_component_t *sub = &media_component->sub[i];
+
+        /* Copy Flow to PCC Rule */
+        for (j = 0; j < sub->num_of_flow &&
+                    j < OGS_MAX_NUM_OF_FLOW_IN_MEDIA_SUB_COMPONENT; j++) {
+            ogs_flow_t *rx_flow = NULL;
+            ogs_flow_t *gx_flow = NULL;
+
+            if (pcc_rule->num_of_flow < OGS_MAX_NUM_OF_FLOW_IN_PCC_RULE) {
+                rx_flow = &sub->flow[j];
+                gx_flow = &pcc_rule->flow[pcc_rule->num_of_flow];
+
+                rv = flow_rx_to_gx(rx_flow, gx_flow);
+                if (rv != OGS_OK) {
+                    ogs_error("flow reformatting error");
+                    return OGS_ERROR;
+                }
+
+                pcc_rule->num_of_flow++;
+            } else {
+                ogs_error("Overflow: Number of Flow");
+                return OGS_ERROR;
+            }
+        }
+    }
+
+    return OGS_OK;
+}
+
+int ogs_pcc_rule_update_qos_from_media(
+        ogs_pcc_rule_t *pcc_rule, ogs_media_component_t *media_component)
+{
+    int rv;
+    int i, j;
+
+    ogs_assert(pcc_rule);
+    ogs_assert(media_component);
+
+    pcc_rule->qos.mbr.downlink = 0;
+    pcc_rule->qos.mbr.uplink = 0;
+    pcc_rule->qos.gbr.downlink = 0;
+    pcc_rule->qos.gbr.uplink = 0;
+
+    for (i = 0; i < media_component->num_of_sub; i++) {
+        ogs_media_sub_component_t *sub = &media_component->sub[i];
+
+        for (j = 0; j < sub->num_of_flow &&
+                    j < OGS_MAX_NUM_OF_FLOW_IN_MEDIA_SUB_COMPONENT; j++) {
+            ogs_flow_t gx_flow;
+            ogs_flow_t *rx_flow = &sub->flow[j];
+
+            rv = flow_rx_to_gx(rx_flow, &gx_flow);
+            if (rv != OGS_OK) {
+                ogs_error("flow reformatting error");
+                return OGS_ERROR;
+            }
+
+            if (gx_flow.direction == OGS_FLOW_DOWNLINK_ONLY) {
+                if (sub->flow_usage == OGS_FLOW_USAGE_RTCP) {
+                    if (media_component->rr_bandwidth &&
+                        media_component->rs_bandwidth) {
+                        pcc_rule->qos.mbr.downlink +=
+                            (media_component->rr_bandwidth +
+                            media_component->rs_bandwidth);
+                    } else if (media_component->max_requested_bandwidth_dl) {
+                        if (media_component->rr_bandwidth &&
+                            !media_component->rs_bandwidth) {
+                            pcc_rule->qos.mbr.downlink +=
+                                ogs_max(0.05 *
+                                    media_component->max_requested_bandwidth_dl,
+                                    media_component->rr_bandwidth);
+                        }
+                        if (!media_component->rr_bandwidth &&
+                            media_component->rs_bandwidth) {
+                            pcc_rule->qos.mbr.downlink +=
+                                ogs_max(0.05 *
+                                    media_component->max_requested_bandwidth_dl,
+                                    media_component->rs_bandwidth);
+                        }
+                        if (!media_component->rr_bandwidth &&
+                            !media_component->rs_bandwidth) {
+                            pcc_rule->qos.mbr.downlink +=
+                                0.05 *
+                                    media_component->max_requested_bandwidth_dl;
+                        }
+                    }
+                } else {
+                    if (gx_flow.description) {
+                        pcc_rule->qos.mbr.downlink +=
+                            media_component->max_requested_bandwidth_dl;
+                        pcc_rule->qos.gbr.downlink +=
+                            media_component->min_requested_bandwidth_dl;
+                    }
+                }
+            } else if (gx_flow.direction == OGS_FLOW_UPLINK_ONLY) {
+                if (sub->flow_usage == OGS_FLOW_USAGE_RTCP) {
+                    if (media_component->rr_bandwidth &&
+                        media_component->rs_bandwidth) {
+                        pcc_rule->qos.mbr.uplink +=
+                            (media_component->rr_bandwidth +
+                            media_component->rs_bandwidth);
+                    } else if (media_component->max_requested_bandwidth_ul) {
+                        if (media_component->rr_bandwidth &&
+                            !media_component->rs_bandwidth) {
+                            pcc_rule->qos.mbr.uplink +=
+                                ogs_max(0.05 *
+                                    media_component->max_requested_bandwidth_ul,
+                                    media_component->rr_bandwidth);
+                        }
+                        if (!media_component->rr_bandwidth &&
+                            media_component->rs_bandwidth) {
+                            pcc_rule->qos.mbr.uplink +=
+                                ogs_max(0.05 *
+                                    media_component->max_requested_bandwidth_ul,
+                                    media_component->rs_bandwidth);
+                        }
+                        if (!media_component->rr_bandwidth &&
+                            !media_component->rs_bandwidth) {
+                            pcc_rule->qos.mbr.uplink +=
+                                0.05 *
+                                    media_component->max_requested_bandwidth_ul;
+                        }
+                    }
+                } else {
+                    if (gx_flow.description) {
+                        pcc_rule->qos.mbr.uplink +=
+                            media_component->max_requested_bandwidth_ul;
+                        pcc_rule->qos.gbr.uplink +=
+                            media_component->min_requested_bandwidth_ul;
+                    }
+                }
+            } else
+                ogs_assert_if_reached();
+
+            OGS_FLOW_FREE(&gx_flow);
+        }
+    }
+
+    if (pcc_rule->qos.mbr.downlink == 0) {
+        pcc_rule->qos.mbr.downlink +=
+            media_component->max_requested_bandwidth_dl;
+        pcc_rule->qos.mbr.downlink +=
+            (media_component->rr_bandwidth + media_component->rs_bandwidth);
+    }
+
+    if (pcc_rule->qos.mbr.uplink == 0) {
+        pcc_rule->qos.mbr.uplink +=
+            media_component->max_requested_bandwidth_ul;
+        pcc_rule->qos.mbr.uplink +=
+            (media_component->rr_bandwidth + media_component->rs_bandwidth);
+    }
+
+    if (pcc_rule->qos.gbr.downlink == 0)
+        pcc_rule->qos.gbr.downlink = pcc_rule->qos.mbr.downlink;
+    if (pcc_rule->qos.gbr.uplink == 0)
+        pcc_rule->qos.gbr.uplink = pcc_rule->qos.mbr.uplink;
+
+    return OGS_OK;
+}

lib/core/ogs-3gpp-types.h

@@ -652,6 +652,25 @@ void ogs_session_data_free(ogs_session_data_t *session_data);
 
 typedef struct ogs_media_sub_component_s {
     uint32_t            flow_number;
+/*
+ * TS29.214
+ * 5.3.12 Flow-Usage AVP
+ *   NO_INFORMATION(0)
+ *   RTCP(1)
+ *   AF_SIGNALLING(2)
+ *
+ * TS29.514
+ * 5.6.3.14 Enumeration: FlowUsage
+ *   NO_INFO : 1
+ *   RTCP : 2
+ *   AF_SIGNALLING : 3
+ *
+ * EPC and 5GC have different values for FlowUsage
+ * At this point, we will use the 5GC value.
+ */
+#define OGS_FLOW_USAGE_NO_INFO          1
+#define OGS_FLOW_USAGE_RTCP             2
+#define OGS_FLOW_USAGE_AF_SIGNALLING    3
     uint32_t            flow_usage;
     ogs_flow_t          flow[OGS_MAX_NUM_OF_FLOW_IN_MEDIA_SUB_COMPONENT];
     int                 num_of_flow;
@@ -690,6 +709,13 @@ typedef struct ogs_ims_data_s {
 
 void ogs_ims_data_free(ogs_ims_data_t *ims_data);
 
+int ogs_pcc_rule_num_of_flow_equal_to_media(
+        ogs_pcc_rule_t *pcc_rule, ogs_media_component_t *media_component);
+int ogs_pcc_rule_install_flow_from_media(
+        ogs_pcc_rule_t *pcc_rule, ogs_media_component_t *media_component);
+int ogs_pcc_rule_update_qos_from_media(
+        ogs_pcc_rule_t *pcc_rule, ogs_media_component_t *media_component);
+
 #ifdef __cplusplus
 }
 #endif

lib/dbi/session.c

@@ -477,7 +477,7 @@ done:
                     ogs_error("PCC Rule Id has already been defined");
                     ogs_free(pcc_rule->id);
                 }
-                pcc_rule->id = ogs_msprintf("%d", pcc_rule_index+1);
+                pcc_rule->id = ogs_msprintf("%s-n%d", dnn, pcc_rule_index+1);
                 ogs_assert(pcc_rule->id);
 
                 pcc_rule->precedence = pcc_rule_index+1;

lib/gtp/types.c

@@ -403,7 +403,7 @@ int16_t ogs_gtp_parse_tft(ogs_gtp_tft_t *tft, ogs_tlv_octet_t *octet)
                     (unsigned char *)octet->data+size+len,
                     sizeof(tft->pf[i].content.component[j].port.low));
                 tft->pf[i].content.component[j].port.low =
-                    htobe16(tft->pf[i].content.component[j].port.low);
+                    be16toh(tft->pf[i].content.component[j].port.low);
                 len += sizeof(tft->pf[i].content.component[j].port.low);
                 break;
             case OGS_PACKET_FILTER_LOCAL_PORT_RANGE_TYPE:
@@ -415,7 +415,7 @@ int16_t ogs_gtp_parse_tft(ogs_gtp_tft_t *tft, ogs_tlv_octet_t *octet)
                     (unsigned char *)octet->data+size+len,
                     sizeof(tft->pf[i].content.component[j].port.low));
                 tft->pf[i].content.component[j].port.low =
-                    htobe16(tft->pf[i].content.component[j].port.low);
+                    be16toh(tft->pf[i].content.component[j].port.low);
                 len += sizeof(tft->pf[i].content.component[j].port.low);
 
                 ogs_assert(size+len+
@@ -425,7 +425,7 @@ int16_t ogs_gtp_parse_tft(ogs_gtp_tft_t *tft, ogs_tlv_octet_t *octet)
                     (unsigned char *)octet->data+size+len,
                     sizeof(tft->pf[i].content.component[j].port.high));
                 tft->pf[i].content.component[j].port.high =
-                    htobe16(tft->pf[i].content.component[j].port.high);
+                    be16toh(tft->pf[i].content.component[j].port.high);
                 len += sizeof(tft->pf[i].content.component[j].port.high);
                 break;
             default:

lib/nas/5gs/types.c

@@ -444,6 +444,77 @@ int ogs_nas_build_qos_flow_descriptions(
     return OGS_OK;
 }
 
+int ogs_nas_parse_qos_flow_descriptions(
+        ogs_nas_qos_flow_description_t *description,
+        ogs_nas_qos_flow_descriptions_t *descriptions)
+{
+    ogs_nas_qos_flow_description_t *first = description;
+
+    char *buffer;
+    uint16_t length, size = 0;
+    int i;
+
+    ogs_assert(description);
+    ogs_assert(descriptions);
+    ogs_assert(descriptions->length);
+    length = descriptions->length;
+    ogs_assert(descriptions->buffer);
+    buffer = descriptions->buffer;
+
+    size = 0;
+    while (size < length) {
+        memset(description, 0, sizeof(*description));
+
+        ogs_assert(size+3 <= length);
+        memcpy(description, buffer+size, 3);
+        size += 3;
+
+        for (i = 0; i < description->num_of_parameter &&
+                    i < OGS_NAS_MAX_NUM_OF_QOS_FLOW_PARAMETER; i++) {
+            ogs_assert(size+sizeof(description->param[i].identifier) <= length);
+            memcpy(&description->param[i].identifier, buffer+size,
+                    sizeof(description->param[i].identifier));
+            size += sizeof(description->param[i].identifier);
+
+            ogs_assert(size+sizeof(description->param[i].len) <= length);
+            memcpy(&description->param[i].len, buffer+size,
+                    sizeof(description->param[i].len));
+            size += sizeof(description->param[i].len);
+
+            switch(description->param[i].identifier) {
+            case OGS_NAX_QOS_FLOW_PARAMETER_ID_5QI:
+                ogs_assert(description->param[i].len == 1);
+                ogs_assert(size+description->param[i].len <= length);
+                memcpy(&description->param[i].qos_index,
+                        buffer+size, description->param[i].len);
+                size += description->param[i].len;
+                break;
+
+            case OGS_NAX_QOS_FLOW_PARAMETER_ID_GFBR_UPLINK:
+            case OGS_NAX_QOS_FLOW_PARAMETER_ID_GFBR_DOWNLINK:
+            case OGS_NAX_QOS_FLOW_PARAMETER_ID_MFBR_UPLINK:
+            case OGS_NAX_QOS_FLOW_PARAMETER_ID_MFBR_DOWNLINK:
+                ogs_assert(description->param[i].len == 3);
+                ogs_assert(size+description->param[i].len <= length);
+                memcpy(&description->param[i].br,
+                        buffer+size, description->param[i].len);
+                description->param[i].br.value =
+                    be16toh(description->param[i].br.value);
+                size += description->param[i].len;
+                break;
+            default:
+                ogs_fatal("Unknown qos_flow parameter identifier [%d]",
+                        description->param[i].identifier);
+                ogs_assert_if_reached();
+            }
+        }
+
+        description++;
+    }
+
+    return (int)(description-first);
+}
+
 int ogs_nas_build_qos_rules(ogs_nas_qos_rules_t *rules,
         ogs_nas_qos_rule_t *rule, int num_of_rule)
 {
@@ -471,7 +542,6 @@ int ogs_nas_build_qos_rules(ogs_nas_qos_rules_t *rules,
         memcpy(buffer + length, &target.identifier, sizeof(target.identifier));
         length += sizeof(target.identifier);
 
-
         ogs_assert(length + sizeof(target.length) <=
                 OGS_NAS_MAX_QOS_RULES_LEN);
 
@@ -484,6 +554,16 @@ int ogs_nas_build_qos_rules(ogs_nas_qos_rules_t *rules,
         memcpy(buffer + length, &target.flags, sizeof(target.flags));
         length += sizeof(target.flags);
 
+        if (rule->code == OGS_NAS_QOS_CODE_DELETE_EXISTING_QOS_RULE ||
+            rule->code == OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_WITHOUT_MODIFYING_PACKET_FILTERS) {
+            if (target.num_of_packet_filter != 0) {
+                ogs_fatal("Invalue QoS rule code[%d] "
+                        "and number of packet filter[%d]",
+                        rule->code, target.num_of_packet_filter);
+                ogs_assert_if_reached();
+            }
+        }
+
         for (j = 0; j < target.num_of_packet_filter &&
                     j < OGS_MAX_NUM_OF_FLOW_IN_NAS; j++) {
             ogs_assert(length + sizeof(target.pf[j].flags) <=
@@ -492,6 +572,10 @@ int ogs_nas_build_qos_rules(ogs_nas_qos_rules_t *rules,
                     sizeof(target.pf[j].flags));
             length += sizeof(target.pf[j].flags);
 
+            if (rule->code ==
+                OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_DELETE_PACKET_FILTERS)
+                continue;
+
             ogs_assert(length + sizeof(target.pf[j].content.length) <=
                     OGS_NAS_MAX_QOS_RULES_LEN);
             memcpy(buffer + length, &target.pf[j].content.length,
@@ -625,14 +709,20 @@ int ogs_nas_build_qos_rules(ogs_nas_qos_rules_t *rules,
             }
         }
 
-        ogs_assert(length + sizeof(target.precedence) <=
-                OGS_NAS_MAX_QOS_RULES_LEN);
-        memcpy(buffer + length, &target.precedence, sizeof(target.precedence));
-        length += sizeof(target.precedence);
-        ogs_assert(length + sizeof(target.flow.flags) <=
-                OGS_NAS_MAX_QOS_RULES_LEN);
-        memcpy(buffer + length, &target.flow.flags, sizeof(target.precedence));
-        length += sizeof(target.flow.flags);
+        if (rule->code != OGS_NAS_QOS_CODE_DELETE_EXISTING_QOS_RULE &&
+            rule->code != OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_DELETE_PACKET_FILTERS &&
+            rule->code != OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_WITHOUT_MODIFYING_PACKET_FILTERS) {
+            ogs_assert(length + sizeof(target.precedence) <=
+                    OGS_NAS_MAX_QOS_RULES_LEN);
+            memcpy(buffer + length, &target.precedence,
+                    sizeof(target.precedence));
+            length += sizeof(target.precedence);
+            ogs_assert(length + sizeof(target.flow.flags) <=
+                    OGS_NAS_MAX_QOS_RULES_LEN);
+            memcpy(buffer + length, &target.flow.flags,
+                    sizeof(target.flow.flags));
+            length += sizeof(target.flow.flags);
+        }
 
         /* Update QoS Rule Length */
         target.length = htobe16(
@@ -645,3 +735,206 @@ int ogs_nas_build_qos_rules(ogs_nas_qos_rules_t *rules,
 
     return OGS_OK;
 }
+
+int ogs_nas_parse_qos_rules(
+        ogs_nas_qos_rule_t *rule, ogs_nas_qos_rules_t *rules)
+{
+    ogs_nas_qos_rule_t *first = rule;
+
+    char *buffer;
+    uint16_t length, size = 0;
+    int i, j, len = 0;
+
+    ogs_assert(rule);
+    ogs_assert(rules);
+    ogs_assert(rules->length);
+    length = rules->length;
+    ogs_assert(rules->buffer);
+    buffer = rules->buffer;
+
+    size = 0;
+    while (size < length) {
+        memset(rule, 0, sizeof(*rule));
+
+        ogs_assert(size+sizeof(rule->identifier) <= length);
+        memcpy(&rule->identifier, buffer+size, sizeof(rule->identifier));
+        size += sizeof(rule->identifier);
+
+        ogs_assert(size+sizeof(rule->length) <= length);
+        memcpy(&rule->length, buffer+size, sizeof(rule->length));
+        rule->length = be16toh(rule->length);
+        size += sizeof(rule->length);
+
+        ogs_assert(size+sizeof(rule->flags) <= length);
+        memcpy(&rule->flags, buffer+size, sizeof(rule->flags));
+        size += sizeof(rule->flags);
+
+        if (rule->code == OGS_NAS_QOS_CODE_DELETE_EXISTING_QOS_RULE ||
+            rule->code == OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_WITHOUT_MODIFYING_PACKET_FILTERS) {
+            if (rule->num_of_packet_filter != 0) {
+                ogs_error("Invalue QoS rule code[%d] "
+                        "and number of packet filter[%d]",
+                        rule->code, rule->num_of_packet_filter);
+                rule->num_of_packet_filter = 0;
+            }
+        }
+
+        for (i = 0; i < rule->num_of_packet_filter &&
+                    i < OGS_MAX_NUM_OF_FLOW_IN_GTP; i++) {
+            ogs_assert(size+sizeof(rule->pf[i].flags) <= length);
+            memcpy(&rule->pf[i].flags, buffer+size, sizeof(rule->pf[i].flags));
+            size += sizeof(rule->pf[i].flags);
+
+            if (rule->code ==
+                OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_DELETE_PACKET_FILTERS)
+                continue;
+
+            ogs_assert(size+sizeof(rule->pf[i].content.length) <= length);
+            memcpy(&rule->pf[i].content.length, buffer+size,
+                    sizeof(rule->pf[i].content.length));
+            size += sizeof(rule->pf[i].content.length);
+
+            j = 0; len = 0;
+            while(len < rule->pf[i].content.length) {
+                ogs_assert(size+len+
+                    sizeof(rule->pf[i].content.component[j].type) <= length);
+                memcpy(&rule->pf[i].content.component[j].type,
+                        buffer+size+len,
+                        sizeof(rule->pf[i].content.component[j].type));
+                len += sizeof(rule->pf[i].content.component[j].type);
+                switch(rule->pf[i].content.component[j].type) {
+                case OGS_PACKET_FILTER_PROTOCOL_IDENTIFIER_NEXT_HEADER_TYPE:
+                    ogs_assert(size+len+
+                        sizeof(rule->pf[i].content.component[j].proto) <=
+                        length);
+                    memcpy(&rule->pf[i].content.component[j].proto,
+                        buffer+size+len,
+                        sizeof(rule->pf[i].content.component[j].proto));
+                    len += sizeof(rule->pf[i].content.component[j].proto);
+                    break;
+                case OGS_PACKET_FILTER_IPV4_REMOTE_ADDRESS_TYPE:
+                case OGS_PACKET_FILTER_IPV4_LOCAL_ADDRESS_TYPE:
+                    ogs_assert(size+len+
+                        sizeof(rule->pf[i].content.component[j].ipv4.addr) <=
+                        length);
+                    memcpy(&rule->pf[i].content.component[j].ipv4.addr,
+                        buffer+size+len,
+                        sizeof(rule->pf[i].content.component[j].ipv4.addr));
+                    len += sizeof(rule->pf[i].content.component[j].ipv4.addr);
+
+                    ogs_assert(size+len+
+                        sizeof(rule->pf[i].content.component[j].ipv4.mask) <=
+                        length);
+                    memcpy(&rule->pf[i].content.component[j].ipv4.mask,
+                        buffer+size+len,
+                        sizeof(rule->pf[i].content.component[j].ipv4.mask));
+                    len += sizeof(rule->pf[i].content.component[j].ipv4.mask);
+                    break;
+                case OGS_PACKET_FILTER_IPV6_LOCAL_ADDRESS_PREFIX_LENGTH_TYPE:
+                case OGS_PACKET_FILTER_IPV6_REMOTE_ADDRESS_PREFIX_LENGTH_TYPE:
+                    ogs_assert(size+len+
+                        sizeof(rule->pf[i].content.component[j].ipv6.addr) <=
+                        length);
+                    memcpy(&rule->pf[i].content.component[j].ipv6.addr,
+                        buffer+size+len,
+                        sizeof(rule->pf[i].content.component[j].ipv6.addr));
+                    len += sizeof(rule->pf[i].content.component[j].ipv6.addr);
+
+                    ogs_assert(size+len+
+                        sizeof(
+                            rule->pf[i].content.component[j].ipv6.prefixlen) <=
+                        length);
+                    memcpy(&rule->pf[i].content.component[j].ipv6.prefixlen,
+                        buffer+size+len,
+                        sizeof(
+                            rule->pf[i].content.component[j].ipv6.prefixlen));
+                    len += sizeof(
+                            rule->pf[i].content.component[j].ipv6.prefixlen);
+                    break;
+                case OGS_PACKET_FILTER_IPV6_LOCAL_ADDRESS_TYPE:
+                case OGS_PACKET_FILTER_IPV6_REMOTE_ADDRESS_TYPE:
+                    ogs_assert(size+len+
+                        sizeof(
+                            rule->pf[i].content.component[j].ipv6_mask.addr) <=
+                            length);
+                    memcpy(&rule->pf[i].content.component[j].ipv6_mask.addr,
+                        buffer+size+len,
+                        sizeof(
+                            rule->pf[i].content.component[j].ipv6_mask.addr));
+                    len += sizeof(
+                            rule->pf[i].content.component[j].ipv6_mask.addr);
+
+                    ogs_assert(size+len+
+                        sizeof(
+                            rule->pf[i].content.component[j].ipv6_mask.mask) <=
+                            length);
+                    memcpy(&rule->pf[i].content.component[j].ipv6_mask.mask,
+                        buffer+size+len,
+                        sizeof(
+                            rule->pf[i].content.component[j].ipv6_mask.mask));
+                    len += sizeof(
+                            rule->pf[i].content.component[j].ipv6_mask.mask);
+                    break;
+                case OGS_PACKET_FILTER_SINGLE_LOCAL_PORT_TYPE:
+                case OGS_PACKET_FILTER_SINGLE_REMOTE_PORT_TYPE:
+                    ogs_assert(size+len+
+                        sizeof(rule->pf[i].content.component[j].port.low) <=
+                            length);
+                    memcpy(&rule->pf[i].content.component[j].port.low,
+                        buffer+size+len,
+                        sizeof(rule->pf[i].content.component[j].port.low));
+                    rule->pf[i].content.component[j].port.low =
+                        be16toh(rule->pf[i].content.component[j].port.low);
+                    len += sizeof(rule->pf[i].content.component[j].port.low);
+                    break;
+                case OGS_PACKET_FILTER_LOCAL_PORT_RANGE_TYPE:
+                case OGS_PACKET_FILTER_REMOTE_PORT_RANGE_TYPE:
+                    ogs_assert(size+len+
+                        sizeof(rule->pf[i].content.component[j].port.low) <=
+                            length);
+                    memcpy(&rule->pf[i].content.component[j].port.low,
+                        buffer+size+len,
+                        sizeof(rule->pf[i].content.component[j].port.low));
+                    rule->pf[i].content.component[j].port.low =
+                        be16toh(rule->pf[i].content.component[j].port.low);
+                    len += sizeof(rule->pf[i].content.component[j].port.low);
+
+                    ogs_assert(size+len+
+                        sizeof(rule->pf[i].content.component[j].port.high) <=
+                            length);
+                    memcpy(&rule->pf[i].content.component[j].port.high,
+                        buffer+size+len,
+                        sizeof(rule->pf[i].content.component[j].port.high));
+                    rule->pf[i].content.component[j].port.high =
+                        be16toh(rule->pf[i].content.component[j].port.high);
+                    len += sizeof(rule->pf[i].content.component[j].port.high);
+                    break;
+                default:
+                    ogs_error("Unknown Packet Filter Type(%d)",
+                            rule->pf[i].content.component[j].type);
+                    return -1;
+                }
+                j++;
+            }
+            rule->pf[i].content.num_of_component = j;
+            size += len;
+        }
+
+        if (rule->code != OGS_NAS_QOS_CODE_DELETE_EXISTING_QOS_RULE &&
+            rule->code != OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_DELETE_PACKET_FILTERS &&
+            rule->code != OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_WITHOUT_MODIFYING_PACKET_FILTERS) {
+
+            ogs_assert(size+sizeof(rule->precedence) <= length);
+            memcpy(&rule->precedence, buffer+size, sizeof(rule->precedence));
+            size += sizeof(rule->precedence);
+
+            ogs_assert(size+sizeof(rule->flow.flags) <= length);
+            memcpy(&rule->flow.flags, buffer+size, sizeof(rule->flow.flags));
+            size += sizeof(rule->flow.flags);
+        }
+
+        rule++;
+    }
+
+    return (int)(rule-first);
+}

lib/nas/5gs/types.h

@@ -803,6 +803,10 @@ int ogs_nas_build_qos_flow_descriptions(
     ogs_nas_qos_flow_description_t *flow_description,
     int num_of_flow_description);
 
+int ogs_nas_parse_qos_flow_descriptions(
+        ogs_nas_qos_flow_description_t *description,
+        ogs_nas_qos_flow_descriptions_t *descriptions);
+
 /* 9.11.4.13 QoS rules
  * M LV-E 6-65535 */
 #define OGS_NAS_MAX_NUM_OF_QOS_RULE 8
@@ -858,6 +862,8 @@ typedef struct ogs_nas_qos_rules_s {
 
 int ogs_nas_build_qos_rules(ogs_nas_qos_rules_t *rules,
         ogs_nas_qos_rule_t *rule, int num_of_rule);
+int ogs_nas_parse_qos_rules(
+        ogs_nas_qos_rule_t *rule, ogs_nas_qos_rules_t *rules);
 
 /* 9.11.4.15 SM PDU DN request container
  * O TLV 3-255 */

lib/nas/common/types.c

@@ -443,3 +443,64 @@ void ogs_nas_bitrate_from_uint64(ogs_nas_bitrate_t *nas, uint64_t bitrate)
     }
     nas->value = bitrate;
 }
+
+uint64_t ogs_nas_bitrate_to_uint64(ogs_nas_bitrate_t *nas_bitrate)
+{
+    ogs_assert(nas_bitrate);
+
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_1K)
+        return nas_bitrate->value * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_4K)
+        return nas_bitrate->value * 4 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_16K)
+        return nas_bitrate->value * 16 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_64K)
+        return nas_bitrate->value * 64 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_256K)
+        return nas_bitrate->value * 256 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_1M)
+        return nas_bitrate->value * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_4M)
+        return nas_bitrate->value * 4 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_16M)
+        return nas_bitrate->value * 16 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_64M)
+        return nas_bitrate->value * 64 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_256M)
+        return nas_bitrate->value * 256 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_1G)
+        return nas_bitrate->value * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_4G)
+        return nas_bitrate->value * 4 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_16G)
+        return nas_bitrate->value * 16 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_64G)
+        return nas_bitrate->value * 64 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_256G)
+        return nas_bitrate->value * 256 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_1T)
+        return nas_bitrate->value * 1024 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_4T)
+        return nas_bitrate->value * 4 * 1024 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_16T)
+        return nas_bitrate->value * 16 * 1024 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_64T)
+        return nas_bitrate->value * 64 * 1024 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_256T)
+        return nas_bitrate->value * 256 * 1024 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_1P)
+        return nas_bitrate->value * 1024 * 1024 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_4P)
+        return nas_bitrate->value * 4 * 1024 * 1024 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_16P)
+        return nas_bitrate->value * 16 * 1024 * 1024 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_64P)
+        return nas_bitrate->value * 64 * 1024 * 1024 * 1024 * 1024 * 1024;
+    if (nas_bitrate->unit == OGS_NAS_BR_UNIT_256P)
+        return nas_bitrate->value * 256 * 1024 * 1024 * 1024 * 1024 * 1024;
+
+    ogs_fatal("Unknown unit [%d]", nas_bitrate->unit);
+    ogs_assert_if_reached();
+
+    return 0;
+}

lib/nas/common/types.h

@@ -941,6 +941,7 @@ typedef struct ogs_nas_bitrate_s {
 
 void ogs_nas_bitrate_from_uint64(
         ogs_nas_bitrate_t *nas_bitrate, uint64_t bitrate);
+uint64_t ogs_nas_bitrate_to_uint64(ogs_nas_bitrate_t *nas_bitrate);
 
 typedef struct ogs_nas_session_ambr_s {
     uint8_t length;

lib/pfcp/xact.h

@@ -74,17 +74,27 @@ typedef struct ogs_pfcp_xact_s {
 #define OGS_PFCP_MODIFY_DL_ONLY ((uint64_t)1<<1)
 #define OGS_PFCP_MODIFY_UL_ONLY ((uint64_t)1<<2)
 #define OGS_PFCP_MODIFY_INDIRECT ((uint64_t)1<<3)
-#define OGS_PFCP_MODIFY_CREATE ((uint64_t)1<<4)
-#define OGS_PFCP_MODIFY_REMOVE ((uint64_t)1<<5)
-#define OGS_PFCP_MODIFY_TFT_UPDATE ((uint64_t)1<<6)
-#define OGS_PFCP_MODIFY_QOS_UPDATE ((uint64_t)1<<7)
-#define OGS_PFCP_MODIFY_ACTIVATE ((uint64_t)1<<8)
-#define OGS_PFCP_MODIFY_DEACTIVATE ((uint64_t)1<<9)
-#define OGS_PFCP_MODIFY_END_MARKER ((uint64_t)1<<10)
-#define OGS_PFCP_MODIFY_ERROR_INDICATION ((uint64_t)1<<11)
-#define OGS_PFCP_MODIFY_XN_HANDOVER ((uint64_t)1<<12)
-#define OGS_PFCP_MODIFY_N2_HANDOVER ((uint64_t)1<<13)
-#define OGS_PFCP_MODIFY_HANDOVER_CANCEL ((uint64_t)1<<14)
+#define OGS_PFCP_MODIFY_UE_REQUESTED ((uint64_t)1<<4)
+#define OGS_PFCP_MODIFY_NETWORK_REQUESTED ((uint64_t)1<<5)
+#define OGS_PFCP_MODIFY_CREATE ((uint64_t)1<<6)
+#define OGS_PFCP_MODIFY_REMOVE ((uint64_t)1<<7)
+#define OGS_PFCP_MODIFY_EPC_TFT_UPDATE ((uint64_t)1<<8)
+#define OGS_PFCP_MODIFY_EPC_QOS_UPDATE ((uint64_t)1<<9)
+#define OGS_PFCP_MODIFY_TFT_NEW ((uint64_t)1<<10)
+#define OGS_PFCP_MODIFY_TFT_ADD ((uint64_t)1<<11)
+#define OGS_PFCP_MODIFY_TFT_REPLACE ((uint64_t)1<<12)
+#define OGS_PFCP_MODIFY_TFT_DELETE ((uint64_t)1<<13)
+#define OGS_PFCP_MODIFY_QOS_CREATE ((uint64_t)1<<14)
+#define OGS_PFCP_MODIFY_QOS_MODIFY ((uint64_t)1<<15)
+#define OGS_PFCP_MODIFY_QOS_DELETE ((uint64_t)1<<16)
+#define OGS_PFCP_MODIFY_ACTIVATE ((uint64_t)1<<17)
+#define OGS_PFCP_MODIFY_DEACTIVATE ((uint64_t)1<<18)
+#define OGS_PFCP_MODIFY_END_MARKER ((uint64_t)1<<19)
+#define OGS_PFCP_MODIFY_ERROR_INDICATION ((uint64_t)1<<20)
+#define OGS_PFCP_MODIFY_XN_HANDOVER ((uint64_t)1<<21)
+#define OGS_PFCP_MODIFY_N2_HANDOVER ((uint64_t)1<<22)
+#define OGS_PFCP_MODIFY_HANDOVER_CANCEL ((uint64_t)1<<23)
+
     uint64_t        modify_flags;
 
 #define OGS_PFCP_DELETE_TRIGGER_UE_REQUESTED 1

lib/sbi/conv.c

@@ -663,3 +663,161 @@ void ogs_sbi_free_nr_location(OpenAPI_nr_location_t *NrLocation)
 
     ogs_free(NrLocation);
 }
+
+OpenAPI_pcc_rule_t *ogs_sbi_build_pcc_rule(
+        ogs_pcc_rule_t *pcc_rule, int flow_presence)
+{
+    OpenAPI_pcc_rule_t *PccRule = NULL;
+    OpenAPI_list_t *FlowInformationList = NULL;
+    OpenAPI_flow_information_t *FlowInformation = NULL;
+
+    int i;
+
+    ogs_assert(pcc_rule);
+
+    PccRule = ogs_calloc(1, sizeof(*PccRule));
+    ogs_assert(PccRule);
+
+    /*
+     * At this point, only 1 QosData is used for PccRule.
+     * Therefore, QoS ID uses the same value as PCC Rule ID.
+     */
+    PccRule->pcc_rule_id = pcc_rule->id;
+
+    PccRule->ref_qos_data = OpenAPI_list_create();
+    ogs_assert(PccRule->ref_qos_data);
+
+    OpenAPI_list_add(PccRule->ref_qos_data, PccRule->pcc_rule_id);
+
+    PccRule->is_precedence = true;
+    PccRule->precedence = pcc_rule->precedence;
+
+    if (flow_presence == 1) {
+        FlowInformationList = OpenAPI_list_create();
+        ogs_assert(FlowInformationList);
+
+        for (i = 0; i < pcc_rule->num_of_flow; i++) {
+            ogs_flow_t *flow = &pcc_rule->flow[i];
+            ogs_assert(flow);
+
+            FlowInformation = ogs_calloc(1, sizeof(*FlowInformation));
+            ogs_assert(FlowInformation);
+
+            if (flow->direction == OGS_FLOW_UPLINK_ONLY)
+                FlowInformation->flow_direction =
+                    OpenAPI_flow_direction_UPLINK;
+            else if (flow->direction == OGS_FLOW_DOWNLINK_ONLY)
+                FlowInformation->flow_direction =
+                    OpenAPI_flow_direction_DOWNLINK;
+            else {
+                ogs_fatal("Unsupported direction [%d]", flow->direction);
+                ogs_assert_if_reached();
+            }
+
+            ogs_assert(flow->description);
+            FlowInformation->flow_description = flow->description;
+
+            OpenAPI_list_add(FlowInformationList, FlowInformation);
+        }
+
+        if (FlowInformationList->count)
+            PccRule->flow_infos = FlowInformationList;
+        else
+            OpenAPI_list_free(FlowInformationList);
+    }
+
+    return PccRule;
+}
+
+void ogs_sbi_free_pcc_rule(OpenAPI_pcc_rule_t *PccRule)
+{
+    OpenAPI_flow_information_t *FlowInformation = NULL;
+    OpenAPI_lnode_t *node = NULL;
+
+    ogs_assert(PccRule);
+
+    if (PccRule->ref_qos_data)
+        OpenAPI_list_free(PccRule->ref_qos_data);
+    if (PccRule->flow_infos) {
+        OpenAPI_list_for_each(PccRule->flow_infos, node) {
+            FlowInformation = node->data;
+            if (FlowInformation) ogs_free(FlowInformation);
+        }
+        OpenAPI_list_free(PccRule->flow_infos);
+    }
+    ogs_free(PccRule);
+}
+
+OpenAPI_qos_data_t *ogs_sbi_build_qos_data(ogs_pcc_rule_t *pcc_rule)
+{
+    OpenAPI_qos_data_t *QosData = NULL;
+
+    ogs_assert(pcc_rule);
+
+    QosData = ogs_calloc(1, sizeof(*QosData));
+    ogs_assert(QosData);
+
+    /*
+     * At this point, only 1 QosData is used for PccRule.
+     * Therefore, QoS ID uses the same value as PCC Rule ID.
+     */
+    QosData->qos_id = pcc_rule->id;
+
+    QosData->is__5qi = true;
+    QosData->_5qi = pcc_rule->qos.index;
+    QosData->is_priority_level = true;
+    QosData->priority_level = pcc_rule->qos.arp.priority_level;
+
+    QosData->arp = ogs_calloc(1, sizeof(OpenAPI_arp_t));
+    ogs_assert(QosData->arp);
+
+    if (pcc_rule->qos.arp.pre_emption_capability ==
+            OGS_5GC_PRE_EMPTION_ENABLED)
+        QosData->arp->preempt_cap =
+            OpenAPI_preemption_capability_MAY_PREEMPT;
+    else if (pcc_rule->qos.arp.pre_emption_capability ==
+            OGS_5GC_PRE_EMPTION_DISABLED)
+        QosData->arp->preempt_cap =
+            OpenAPI_preemption_capability_NOT_PREEMPT;
+    ogs_assert(pcc_rule->qos.arp.pre_emption_capability);
+
+    if (pcc_rule->qos.arp.pre_emption_vulnerability ==
+            OGS_5GC_PRE_EMPTION_ENABLED)
+        QosData->arp->preempt_vuln =
+            OpenAPI_preemption_vulnerability_PREEMPTABLE;
+    else if (pcc_rule->qos.arp.pre_emption_vulnerability ==
+            OGS_5GC_PRE_EMPTION_DISABLED)
+        QosData->arp->preempt_vuln =
+            OpenAPI_preemption_vulnerability_NOT_PREEMPTABLE;
+    ogs_assert(pcc_rule->qos.arp.pre_emption_vulnerability);
+    QosData->arp->priority_level = pcc_rule->qos.arp.priority_level;
+
+    if (pcc_rule->qos.mbr.uplink)
+        QosData->maxbr_ul = ogs_sbi_bitrate_to_string(
+                pcc_rule->qos.mbr.uplink, OGS_SBI_BITRATE_BPS);
+    if (pcc_rule->qos.mbr.downlink)
+        QosData->maxbr_dl = ogs_sbi_bitrate_to_string(
+                pcc_rule->qos.mbr.downlink, OGS_SBI_BITRATE_BPS);
+
+    if (pcc_rule->qos.gbr.uplink)
+        QosData->gbr_ul = ogs_sbi_bitrate_to_string(
+                pcc_rule->qos.gbr.uplink, OGS_SBI_BITRATE_BPS);
+    if (pcc_rule->qos.gbr.downlink)
+        QosData->gbr_dl = ogs_sbi_bitrate_to_string(
+                pcc_rule->qos.gbr.downlink, OGS_SBI_BITRATE_BPS);
+
+    return QosData;
+}
+
+void ogs_sbi_free_qos_data(OpenAPI_qos_data_t *QosData)
+{
+    ogs_assert(QosData);
+
+    if (QosData->arp) ogs_free(QosData->arp);
+    if (QosData->maxbr_ul) ogs_free(QosData->maxbr_ul);
+    if (QosData->maxbr_dl) ogs_free(QosData->maxbr_dl);
+    if (QosData->gbr_ul) ogs_free(QosData->gbr_ul);
+    if (QosData->gbr_dl) ogs_free(QosData->gbr_dl);
+
+    ogs_free(QosData);
+}

lib/sbi/conv.h

@@ -76,6 +76,12 @@ bool ogs_sbi_parse_nr_location(ogs_5gs_tai_t *tai, ogs_nr_cgi_t *nr_cgi,
         OpenAPI_nr_location_t *NrLocation);
 void ogs_sbi_free_nr_location(OpenAPI_nr_location_t *NrLocation);
 
+OpenAPI_pcc_rule_t *ogs_sbi_build_pcc_rule(
+        ogs_pcc_rule_t *pcc_rule, int flow_presence);
+void ogs_sbi_free_pcc_rule(OpenAPI_pcc_rule_t *PccRule);
+OpenAPI_qos_data_t *ogs_sbi_build_qos_data(ogs_pcc_rule_t *pcc_rule);
+void ogs_sbi_free_qos_data(OpenAPI_qos_data_t *QosData);
+
 #ifdef __cplusplus
 }
 #endif

lib/sbi/message.c

@@ -161,6 +161,12 @@ void ogs_sbi_message_free(ogs_sbi_message_t *message)
         OpenAPI_pcf_binding_free(message->PcfBinding);
     if (message->AppSessionContext)
         OpenAPI_app_session_context_free(message->AppSessionContext);
+    if (message->AppSessionContextUpdateDataPatch)
+        OpenAPI_app_session_context_update_data_patch_free(message->AppSessionContextUpdateDataPatch);
+    if (message->SmPolicyNotification)
+        OpenAPI_sm_policy_notification_free(message->SmPolicyNotification);
+    if (message->TerminationNotification)
+        OpenAPI_termination_notification_free(message->TerminationNotification);
 
     for (i = 0; i < message->num_of_part; i++) {
         if (message->part[i].pkbuf)
@@ -875,6 +881,18 @@ static char *build_json(ogs_sbi_message_t *message)
         item = OpenAPI_app_session_context_convertToJSON(
                 message->AppSessionContext);
         ogs_assert(item);
+    } else if (message->AppSessionContextUpdateDataPatch) {
+        item = OpenAPI_app_session_context_update_data_patch_convertToJSON(
+                message->AppSessionContextUpdateDataPatch);
+        ogs_assert(item);
+    } else if (message->SmPolicyNotification) {
+        item = OpenAPI_sm_policy_notification_convertToJSON(
+                message->SmPolicyNotification);
+        ogs_assert(item);
+    } else if (message->TerminationNotification) {
+        item = OpenAPI_termination_notification_convertToJSON(
+                message->TerminationNotification);
+        ogs_assert(item);
     }
 
     if (item) {
@@ -1608,14 +1626,30 @@ static int parse_json(ogs_sbi_message_t *message,
             SWITCH(message->h.resource.component[0])
             CASE(OGS_SBI_RESOURCE_NAME_APP_SESSIONS)
                 if (message->h.resource.component[1]) {
-                    SWITCH(message->h.method)
-                    CASE(OGS_SBI_HTTP_METHOD_DELETE)
-                        break;
-                    DEFAULT
-                        rv = OGS_ERROR;
-                        ogs_error("Unknown method [%s]", message->h.method);
-                    END
-                    break;
+                    if (message->h.resource.component[2]) {
+                        SWITCH(message->h.resource.component[2])
+                        CASE(OGS_SBI_RESOURCE_NAME_DELETE)
+                            /* Nothing */
+                            break;
+                        DEFAULT
+                            rv = OGS_ERROR;
+                            ogs_error("JSON parse error");
+                        END
+                    } else {
+                        SWITCH(message->h.method)
+                        CASE(OGS_SBI_HTTP_METHOD_PATCH)
+                            message->AppSessionContextUpdateDataPatch =
+                                OpenAPI_app_session_context_update_data_patch_parseFromJSON(item);
+                            if (!message->AppSessionContextUpdateDataPatch) {
+                                rv = OGS_ERROR;
+                                ogs_error("JSON parse error");
+                            }
+                            break;
+                        DEFAULT
+                            rv = OGS_ERROR;
+                            ogs_error("JSON parse error");
+                        END
+                    }
                 } else {
                     SWITCH(message->h.method)
                     CASE(OGS_SBI_HTTP_METHOD_POST)
@@ -1630,14 +1664,12 @@ static int parse_json(ogs_sbi_message_t *message,
                             }
                         }
                         break;
-
                     DEFAULT
                         rv = OGS_ERROR;
                         ogs_error("Unknown method [%s]", message->h.method);
                     END
-                    break;
                 }
-
+                break;
             DEFAULT
                 rv = OGS_ERROR;
                 ogs_error("Unknown resource name [%s]",
@@ -1675,10 +1707,36 @@ static int parse_json(ogs_sbi_message_t *message,
                 }
                 break;
 
+            CASE(OGS_SBI_RESOURCE_NAME_SM_POLICY_NOTIFY)
+                SWITCH(message->h.resource.component[2])
+                CASE(OGS_SBI_RESOURCE_NAME_UPDATE)
+                    message->SmPolicyNotification =
+                        OpenAPI_sm_policy_notification_parseFromJSON(item);
+                    if (!message->SmPolicyNotification) {
+                        rv = OGS_ERROR;
+                        ogs_error("JSON parse error");
+                    }
+                    break;
+                CASE(OGS_SBI_RESOURCE_NAME_TERMINATE)
+                    message->TerminationNotification =
+                        OpenAPI_termination_notification_parseFromJSON(item);
+                    if (!message->TerminationNotification) {
+                        rv = OGS_ERROR;
+                        ogs_error("JSON parse error");
+                    }
+                    break;
+
+                DEFAULT
+                    rv = OGS_ERROR;
+                    ogs_error("Unknown resource name [%s]",
+                            message->h.resource.component[2]);
+                END
+                break;
+
             DEFAULT
                 rv = OGS_ERROR;
                 ogs_error("Unknown resource name [%s]",
-                        message->h.resource.component[1]);
+                        message->h.resource.component[0]);
             END
             break;
 

lib/sbi/message.h

@@ -148,6 +148,9 @@ extern "C" {
                                                     "npcf-policyauthorization"
 #define OGS_SBI_RESOURCE_NAME_APP_SESSIONS          "app-sessions"
 #define OGS_SBI_RESOURCE_NAME_NOTIFY                "notify"
+#define OGS_SBI_SERVICE_NAME_NPCF_CALLBACK          "npcf-callback"
+#define OGS_SBI_RESOURCE_NAME_UPDATE                "update"
+#define OGS_SBI_RESOURCE_NAME_TERMINATE             "terminate"
 
 #define OGS_SBI_SERVICE_NAME_NNSSF_NSSELECTION      "nnssf-nsselection"
 #define OGS_SBI_RESOURCE_NAME_NETWORK_SLICE_INFORMATION \
@@ -397,10 +400,13 @@ typedef struct ogs_sbi_message_s {
     OpenAPI_sm_policy_decision_t *SmPolicyDecision;
     OpenAPI_sm_policy_data_t *SmPolicyData;
     OpenAPI_sm_policy_delete_data_t *SmPolicyDeleteData;
-    OpenAPI_sm_policy_notification_t *SmPolicyNotification;
     OpenAPI_authorized_network_slice_info_t *AuthorizedNetworkSliceInfo;
     OpenAPI_pcf_binding_t *PcfBinding;
     OpenAPI_app_session_context_t *AppSessionContext;
+    OpenAPI_app_session_context_update_data_patch_t
+        *AppSessionContextUpdateDataPatch;
+    OpenAPI_sm_policy_notification_t *SmPolicyNotification;
+    OpenAPI_termination_notification_t *TerminationNotification;
 
     ogs_sbi_links_t *links;
 

lib/sbi/ogs-sbi.h

@@ -68,8 +68,10 @@
 #include "model/authorized_network_slice_info.h"
 #include "model/pcf_binding.h"
 #include "model/app_session_context.h"
+#include "model/app_session_context_update_data_patch.h"
 #include "model/policy_update.h"
 #include "model/sm_policy_notification.h"
+#include "model/termination_notification.h"
 
 #include "custom/links.h"
 #include "custom/ue_authentication_ctx.h"

lib/sbi/openapi/model/acceptable_service_info.c

@@ -59,7 +59,9 @@ cJSON *OpenAPI_acceptable_service_info_convertToJSON(OpenAPI_acceptable_service_
     if (acceptable_service_info->acc_bw_med_comps) {
         OpenAPI_list_for_each(acceptable_service_info->acc_bw_med_comps, acc_bw_med_comps_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)acc_bw_med_comps_node->data;
-        cJSON *itemLocal = OpenAPI_media_component_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_media_component_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_acceptable_service_info_convertToJSON() failed [acc_bw_med_comps]");
             goto end;
@@ -103,12 +105,15 @@ OpenAPI_acceptable_service_info_t *OpenAPI_acceptable_service_info_parseFromJSON
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(acc_bw_med_comps_local_map, acc_bw_med_comps) {
         cJSON *localMapObject = acc_bw_med_comps_local_map;
-        if (!cJSON_IsObject(acc_bw_med_comps_local_map)) {
+        if (cJSON_IsObject(acc_bw_med_comps_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_media_component_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(acc_bw_med_comps_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_acceptable_service_info_parseFromJSON() failed [acc_bw_med_comps]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_media_component_parseFromJSON(localMapObject));
         OpenAPI_list_add(acc_bw_med_compsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/am_policy_data.c

@@ -59,7 +59,9 @@ cJSON *OpenAPI_am_policy_data_convertToJSON(OpenAPI_am_policy_data_t *am_policy_
     if (am_policy_data->pra_infos) {
         OpenAPI_list_for_each(am_policy_data->pra_infos, pra_infos_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pra_infos_node->data;
-        cJSON *itemLocal = OpenAPI_presence_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_presence_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_am_policy_data_convertToJSON() failed [pra_infos]");
             goto end;
@@ -105,12 +107,15 @@ OpenAPI_am_policy_data_t *OpenAPI_am_policy_data_parseFromJSON(cJSON *am_policy_
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pra_infos_local_map, pra_infos) {
         cJSON *localMapObject = pra_infos_local_map;
-        if (!cJSON_IsObject(pra_infos_local_map)) {
+        if (cJSON_IsObject(pra_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pra_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_am_policy_data_parseFromJSON() failed [pra_infos]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(pra_infosList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/app_session_context_req_data.c

@@ -223,7 +223,9 @@ cJSON *OpenAPI_app_session_context_req_data_convertToJSON(OpenAPI_app_session_co
     if (app_session_context_req_data->med_components) {
         OpenAPI_list_for_each(app_session_context_req_data->med_components, med_components_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)med_components_node->data;
-        cJSON *itemLocal = OpenAPI_media_component_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_media_component_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_app_session_context_req_data_convertToJSON() failed [med_components]");
             goto end;
@@ -508,12 +510,15 @@ OpenAPI_app_session_context_req_data_t *OpenAPI_app_session_context_req_data_par
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(med_components_local_map, med_components) {
         cJSON *localMapObject = med_components_local_map;
-        if (!cJSON_IsObject(med_components_local_map)) {
+        if (cJSON_IsObject(med_components_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_media_component_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(med_components_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_app_session_context_req_data_parseFromJSON() failed [med_components]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_media_component_parseFromJSON(localMapObject));
         OpenAPI_list_add(med_componentsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/app_session_context_update_data.c

@@ -167,7 +167,9 @@ cJSON *OpenAPI_app_session_context_update_data_convertToJSON(OpenAPI_app_session
     if (app_session_context_update_data->med_components) {
         OpenAPI_list_for_each(app_session_context_update_data->med_components, med_components_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)med_components_node->data;
-        cJSON *itemLocal = OpenAPI_media_component_rm_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_media_component_rm_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_app_session_context_update_data_convertToJSON() failed [med_components]");
             goto end;
@@ -364,12 +366,15 @@ OpenAPI_app_session_context_update_data_t *OpenAPI_app_session_context_update_da
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(med_components_local_map, med_components) {
         cJSON *localMapObject = med_components_local_map;
-        if (!cJSON_IsObject(med_components_local_map)) {
+        if (cJSON_IsObject(med_components_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_media_component_rm_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(med_components_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_app_session_context_update_data_parseFromJSON() failed [med_components]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_media_component_rm_parseFromJSON(localMapObject));
         OpenAPI_list_add(med_componentsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/area_scope.c

@@ -119,7 +119,9 @@ cJSON *OpenAPI_area_scope_convertToJSON(OpenAPI_area_scope_t *area_scope)
     if (area_scope->tac_info_per_plmn) {
         OpenAPI_list_for_each(area_scope->tac_info_per_plmn, tac_info_per_plmn_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)tac_info_per_plmn_node->data;
-        cJSON *itemLocal = OpenAPI_tac_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_tac_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_area_scope_convertToJSON() failed [tac_info_per_plmn]");
             goto end;
@@ -209,12 +211,15 @@ OpenAPI_area_scope_t *OpenAPI_area_scope_parseFromJSON(cJSON *area_scopeJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(tac_info_per_plmn_local_map, tac_info_per_plmn) {
         cJSON *localMapObject = tac_info_per_plmn_local_map;
-        if (!cJSON_IsObject(tac_info_per_plmn_local_map)) {
+        if (cJSON_IsObject(tac_info_per_plmn_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_tac_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(tac_info_per_plmn_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_area_scope_parseFromJSON() failed [tac_info_per_plmn]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_tac_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(tac_info_per_plmnList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/cag_data.c

@@ -55,7 +55,9 @@ cJSON *OpenAPI_cag_data_convertToJSON(OpenAPI_cag_data_t *cag_data)
     if (cag_data->cag_infos) {
         OpenAPI_list_for_each(cag_data->cag_infos, cag_infos_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)cag_infos_node->data;
-        cJSON *itemLocal = OpenAPI_cag_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_cag_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_cag_data_convertToJSON() failed [cag_infos]");
             goto end;
@@ -94,12 +96,15 @@ OpenAPI_cag_data_t *OpenAPI_cag_data_parseFromJSON(cJSON *cag_dataJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(cag_infos_local_map, cag_infos) {
         cJSON *localMapObject = cag_infos_local_map;
-        if (!cJSON_IsObject(cag_infos_local_map)) {
+        if (cJSON_IsObject(cag_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_cag_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(cag_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_cag_data_parseFromJSON() failed [cag_infos]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_cag_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(cag_infosList , localMapKeyPair);
     }
 

lib/sbi/openapi/model/cag_data_1.c

@@ -55,7 +55,9 @@ cJSON *OpenAPI_cag_data_1_convertToJSON(OpenAPI_cag_data_1_t *cag_data_1)
     if (cag_data_1->cag_infos) {
         OpenAPI_list_for_each(cag_data_1->cag_infos, cag_infos_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)cag_infos_node->data;
-        cJSON *itemLocal = OpenAPI_cag_info_1_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_cag_info_1_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_cag_data_1_convertToJSON() failed [cag_infos]");
             goto end;
@@ -94,12 +96,15 @@ OpenAPI_cag_data_1_t *OpenAPI_cag_data_1_parseFromJSON(cJSON *cag_data_1JSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(cag_infos_local_map, cag_infos) {
         cJSON *localMapObject = cag_infos_local_map;
-        if (!cJSON_IsObject(cag_infos_local_map)) {
+        if (cJSON_IsObject(cag_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_cag_info_1_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(cag_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_cag_data_1_parseFromJSON() failed [cag_infos]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_cag_info_1_parseFromJSON(localMapObject));
         OpenAPI_list_add(cag_infosList , localMapKeyPair);
     }
 

lib/sbi/openapi/model/eap_session.c

@@ -79,7 +79,9 @@ cJSON *OpenAPI_eap_session_convertToJSON(OpenAPI_eap_session_t *eap_session)
     if (eap_session->_links) {
         OpenAPI_list_for_each(eap_session->_links, _links_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)_links_node->data;
-        cJSON *itemLocal = OpenAPI_links_value_schema_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_links_value_schema_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_eap_session_convertToJSON() failed [_links]");
             goto end;
@@ -150,12 +152,15 @@ OpenAPI_eap_session_t *OpenAPI_eap_session_parseFromJSON(cJSON *eap_sessionJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(_links_local_map, _links) {
         cJSON *localMapObject = _links_local_map;
-        if (!cJSON_IsObject(_links_local_map)) {
+        if (cJSON_IsObject(_links_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_links_value_schema_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(_links_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_eap_session_parseFromJSON() failed [_links]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_links_value_schema_parseFromJSON(localMapObject));
         OpenAPI_list_add(_linksList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/ee_subscription.c

@@ -85,7 +85,9 @@ cJSON *OpenAPI_ee_subscription_convertToJSON(OpenAPI_ee_subscription_t *ee_subsc
     if (ee_subscription->monitoring_configurations) {
         OpenAPI_list_for_each(ee_subscription->monitoring_configurations, monitoring_configurations_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)monitoring_configurations_node->data;
-        cJSON *itemLocal = OpenAPI_monitoring_configuration_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_monitoring_configuration_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_ee_subscription_convertToJSON() failed [monitoring_configurations]");
             goto end;
@@ -196,12 +198,15 @@ OpenAPI_ee_subscription_t *OpenAPI_ee_subscription_parseFromJSON(cJSON *ee_subsc
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(monitoring_configurations_local_map, monitoring_configurations) {
         cJSON *localMapObject = monitoring_configurations_local_map;
-        if (!cJSON_IsObject(monitoring_configurations_local_map)) {
+        if (cJSON_IsObject(monitoring_configurations_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_monitoring_configuration_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(monitoring_configurations_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_ee_subscription_parseFromJSON() failed [monitoring_configurations]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_monitoring_configuration_parseFromJSON(localMapObject));
         OpenAPI_list_add(monitoring_configurationsList , localMapKeyPair);
     }
 

lib/sbi/openapi/model/eps_interworking_info.c

@@ -53,7 +53,9 @@ cJSON *OpenAPI_eps_interworking_info_convertToJSON(OpenAPI_eps_interworking_info
     if (eps_interworking_info->eps_iwk_pgws) {
         OpenAPI_list_for_each(eps_interworking_info->eps_iwk_pgws, eps_iwk_pgws_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)eps_iwk_pgws_node->data;
-        cJSON *itemLocal = OpenAPI_eps_iwk_pgw_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_eps_iwk_pgw_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_eps_interworking_info_convertToJSON() failed [eps_iwk_pgws]");
             goto end;
@@ -83,12 +85,15 @@ OpenAPI_eps_interworking_info_t *OpenAPI_eps_interworking_info_parseFromJSON(cJS
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(eps_iwk_pgws_local_map, eps_iwk_pgws) {
         cJSON *localMapObject = eps_iwk_pgws_local_map;
-        if (!cJSON_IsObject(eps_iwk_pgws_local_map)) {
+        if (cJSON_IsObject(eps_iwk_pgws_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_eps_iwk_pgw_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(eps_iwk_pgws_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_eps_interworking_info_parseFromJSON() failed [eps_iwk_pgws]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_eps_iwk_pgw_parseFromJSON(localMapObject));
         OpenAPI_list_add(eps_iwk_pgwsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/inline_response_200.c

@@ -53,7 +53,9 @@ cJSON *OpenAPI_inline_response_200_convertToJSON(OpenAPI_inline_response_200_t *
     if (inline_response_200->_links) {
         OpenAPI_list_for_each(inline_response_200->_links, _links_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)_links_node->data;
-        cJSON *itemLocal = OpenAPI_links_value_schema_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_links_value_schema_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_inline_response_200_convertToJSON() failed [_links]");
             goto end;
@@ -83,12 +85,15 @@ OpenAPI_inline_response_200_t *OpenAPI_inline_response_200_parseFromJSON(cJSON *
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(_links_local_map, _links) {
         cJSON *localMapObject = _links_local_map;
-        if (!cJSON_IsObject(_links_local_map)) {
+        if (cJSON_IsObject(_links_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_links_value_schema_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(_links_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_inline_response_200_parseFromJSON() failed [_links]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_links_value_schema_parseFromJSON(localMapObject));
         OpenAPI_list_add(_linksList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/iptv_config_data.c

@@ -112,7 +112,9 @@ cJSON *OpenAPI_iptv_config_data_convertToJSON(OpenAPI_iptv_config_data_t *iptv_c
     if (iptv_config_data->multi_acc_ctrls) {
         OpenAPI_list_for_each(iptv_config_data->multi_acc_ctrls, multi_acc_ctrls_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)multi_acc_ctrls_node->data;
-        cJSON *itemLocal = OpenAPI_multicast_access_control_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_multicast_access_control_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_iptv_config_data_convertToJSON() failed [multi_acc_ctrls]");
             goto end;
@@ -203,12 +205,15 @@ OpenAPI_iptv_config_data_t *OpenAPI_iptv_config_data_parseFromJSON(cJSON *iptv_c
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(multi_acc_ctrls_local_map, multi_acc_ctrls) {
         cJSON *localMapObject = multi_acc_ctrls_local_map;
-        if (!cJSON_IsObject(multi_acc_ctrls_local_map)) {
+        if (cJSON_IsObject(multi_acc_ctrls_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_multicast_access_control_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(multi_acc_ctrls_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_iptv_config_data_parseFromJSON() failed [multi_acc_ctrls]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_multicast_access_control_parseFromJSON(localMapObject));
         OpenAPI_list_add(multi_acc_ctrlsList , localMapKeyPair);
     }
 

lib/sbi/openapi/model/iptv_config_data_patch.c

@@ -53,7 +53,9 @@ cJSON *OpenAPI_iptv_config_data_patch_convertToJSON(OpenAPI_iptv_config_data_pat
     if (iptv_config_data_patch->multi_acc_ctrls) {
         OpenAPI_list_for_each(iptv_config_data_patch->multi_acc_ctrls, multi_acc_ctrls_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)multi_acc_ctrls_node->data;
-        cJSON *itemLocal = OpenAPI_multicast_access_control_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_multicast_access_control_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_iptv_config_data_patch_convertToJSON() failed [multi_acc_ctrls]");
             goto end;
@@ -83,12 +85,15 @@ OpenAPI_iptv_config_data_patch_t *OpenAPI_iptv_config_data_patch_parseFromJSON(c
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(multi_acc_ctrls_local_map, multi_acc_ctrls) {
         cJSON *localMapObject = multi_acc_ctrls_local_map;
-        if (!cJSON_IsObject(multi_acc_ctrls_local_map)) {
+        if (cJSON_IsObject(multi_acc_ctrls_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_multicast_access_control_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(multi_acc_ctrls_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_iptv_config_data_patch_parseFromJSON() failed [multi_acc_ctrls]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_multicast_access_control_parseFromJSON(localMapObject));
         OpenAPI_list_add(multi_acc_ctrlsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/media_component.c

@@ -310,7 +310,9 @@ cJSON *OpenAPI_media_component_convertToJSON(OpenAPI_media_component_t *media_co
     if (media_component->med_sub_comps) {
         OpenAPI_list_for_each(media_component->med_sub_comps, med_sub_comps_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)med_sub_comps_node->data;
-        cJSON *itemLocal = OpenAPI_media_sub_component_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_media_sub_component_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_media_component_convertToJSON() failed [med_sub_comps]");
             goto end;
@@ -656,12 +658,15 @@ OpenAPI_media_component_t *OpenAPI_media_component_parseFromJSON(cJSON *media_co
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(med_sub_comps_local_map, med_sub_comps) {
         cJSON *localMapObject = med_sub_comps_local_map;
-        if (!cJSON_IsObject(med_sub_comps_local_map)) {
+        if (cJSON_IsObject(med_sub_comps_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_media_sub_component_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(med_sub_comps_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_media_component_parseFromJSON() failed [med_sub_comps]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_media_sub_component_parseFromJSON(localMapObject));
         OpenAPI_list_add(med_sub_compsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/media_component_rm.c

@@ -312,7 +312,9 @@ cJSON *OpenAPI_media_component_rm_convertToJSON(OpenAPI_media_component_rm_t *me
     if (media_component_rm->med_sub_comps) {
         OpenAPI_list_for_each(media_component_rm->med_sub_comps, med_sub_comps_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)med_sub_comps_node->data;
-        cJSON *itemLocal = OpenAPI_media_sub_component_rm_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_media_sub_component_rm_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_media_component_rm_convertToJSON() failed [med_sub_comps]");
             goto end;
@@ -670,12 +672,15 @@ OpenAPI_media_component_rm_t *OpenAPI_media_component_rm_parseFromJSON(cJSON *me
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(med_sub_comps_local_map, med_sub_comps) {
         cJSON *localMapObject = med_sub_comps_local_map;
-        if (!cJSON_IsObject(med_sub_comps_local_map)) {
+        if (cJSON_IsObject(med_sub_comps_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_media_sub_component_rm_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(med_sub_comps_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_media_component_rm_parseFromJSON() failed [med_sub_comps]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_media_sub_component_rm_parseFromJSON(localMapObject));
         OpenAPI_list_add(med_sub_compsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/nf_profile.c

@@ -686,7 +686,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->udr_info_list) {
         OpenAPI_list_for_each(nf_profile->udr_info_list, udr_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)udr_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_udr_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_udr_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [udr_info_list]");
             goto end;
@@ -720,7 +722,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->udm_info_list) {
         OpenAPI_list_for_each(nf_profile->udm_info_list, udm_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)udm_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_udm_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_udm_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [udm_info_list]");
             goto end;
@@ -754,7 +758,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->ausf_info_list) {
         OpenAPI_list_for_each(nf_profile->ausf_info_list, ausf_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)ausf_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_ausf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_ausf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [ausf_info_list]");
             goto end;
@@ -788,7 +794,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->amf_info_list) {
         OpenAPI_list_for_each(nf_profile->amf_info_list, amf_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)amf_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_amf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_amf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [amf_info_list]");
             goto end;
@@ -822,7 +830,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->smf_info_list) {
         OpenAPI_list_for_each(nf_profile->smf_info_list, smf_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)smf_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_smf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_smf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [smf_info_list]");
             goto end;
@@ -856,7 +866,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->upf_info_list) {
         OpenAPI_list_for_each(nf_profile->upf_info_list, upf_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)upf_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_upf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_upf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [upf_info_list]");
             goto end;
@@ -890,7 +902,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->pcf_info_list) {
         OpenAPI_list_for_each(nf_profile->pcf_info_list, pcf_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pcf_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_pcf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_pcf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [pcf_info_list]");
             goto end;
@@ -924,7 +938,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->bsf_info_list) {
         OpenAPI_list_for_each(nf_profile->bsf_info_list, bsf_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)bsf_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_bsf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_bsf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [bsf_info_list]");
             goto end;
@@ -958,7 +974,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->chf_info_list) {
         OpenAPI_list_for_each(nf_profile->chf_info_list, chf_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)chf_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_chf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_chf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [chf_info_list]");
             goto end;
@@ -1018,7 +1036,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->udsf_info_list) {
         OpenAPI_list_for_each(nf_profile->udsf_info_list, udsf_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)udsf_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_udsf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_udsf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [udsf_info_list]");
             goto end;
@@ -1052,7 +1072,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->pcscf_info_list) {
         OpenAPI_list_for_each(nf_profile->pcscf_info_list, pcscf_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pcscf_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_pcscf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_pcscf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [pcscf_info_list]");
             goto end;
@@ -1073,7 +1095,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->hss_info_list) {
         OpenAPI_list_for_each(nf_profile->hss_info_list, hss_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)hss_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_hss_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_hss_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [hss_info_list]");
             goto end;
@@ -1141,7 +1165,9 @@ cJSON *OpenAPI_nf_profile_convertToJSON(OpenAPI_nf_profile_t *nf_profile)
     if (nf_profile->nf_service_list) {
         OpenAPI_list_for_each(nf_profile->nf_service_list, nf_service_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)nf_service_list_node->data;
-        cJSON *itemLocal = OpenAPI_nf_service_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_nf_service_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nf_profile_convertToJSON() failed [nf_service_list]");
             goto end;
@@ -1724,12 +1750,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(udr_info_list_local_map, udr_info_list) {
         cJSON *localMapObject = udr_info_list_local_map;
-        if (!cJSON_IsObject(udr_info_list_local_map)) {
+        if (cJSON_IsObject(udr_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_udr_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(udr_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [udr_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_udr_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(udr_info_listList , localMapKeyPair);
     }
     }
@@ -1754,12 +1783,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(udm_info_list_local_map, udm_info_list) {
         cJSON *localMapObject = udm_info_list_local_map;
-        if (!cJSON_IsObject(udm_info_list_local_map)) {
+        if (cJSON_IsObject(udm_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_udm_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(udm_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [udm_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_udm_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(udm_info_listList , localMapKeyPair);
     }
     }
@@ -1784,12 +1816,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(ausf_info_list_local_map, ausf_info_list) {
         cJSON *localMapObject = ausf_info_list_local_map;
-        if (!cJSON_IsObject(ausf_info_list_local_map)) {
+        if (cJSON_IsObject(ausf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_ausf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(ausf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [ausf_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_ausf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(ausf_info_listList , localMapKeyPair);
     }
     }
@@ -1814,12 +1849,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(amf_info_list_local_map, amf_info_list) {
         cJSON *localMapObject = amf_info_list_local_map;
-        if (!cJSON_IsObject(amf_info_list_local_map)) {
+        if (cJSON_IsObject(amf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_amf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(amf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [amf_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_amf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(amf_info_listList , localMapKeyPair);
     }
     }
@@ -1844,12 +1882,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(smf_info_list_local_map, smf_info_list) {
         cJSON *localMapObject = smf_info_list_local_map;
-        if (!cJSON_IsObject(smf_info_list_local_map)) {
+        if (cJSON_IsObject(smf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_smf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(smf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [smf_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_smf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(smf_info_listList , localMapKeyPair);
     }
     }
@@ -1874,12 +1915,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(upf_info_list_local_map, upf_info_list) {
         cJSON *localMapObject = upf_info_list_local_map;
-        if (!cJSON_IsObject(upf_info_list_local_map)) {
+        if (cJSON_IsObject(upf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_upf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(upf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [upf_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_upf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(upf_info_listList , localMapKeyPair);
     }
     }
@@ -1904,12 +1948,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pcf_info_list_local_map, pcf_info_list) {
         cJSON *localMapObject = pcf_info_list_local_map;
-        if (!cJSON_IsObject(pcf_info_list_local_map)) {
+        if (cJSON_IsObject(pcf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_pcf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pcf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [pcf_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_pcf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(pcf_info_listList , localMapKeyPair);
     }
     }
@@ -1934,12 +1981,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(bsf_info_list_local_map, bsf_info_list) {
         cJSON *localMapObject = bsf_info_list_local_map;
-        if (!cJSON_IsObject(bsf_info_list_local_map)) {
+        if (cJSON_IsObject(bsf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_bsf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(bsf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [bsf_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_bsf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(bsf_info_listList , localMapKeyPair);
     }
     }
@@ -1964,12 +2014,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(chf_info_list_local_map, chf_info_list) {
         cJSON *localMapObject = chf_info_list_local_map;
-        if (!cJSON_IsObject(chf_info_list_local_map)) {
+        if (cJSON_IsObject(chf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_chf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(chf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [chf_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_chf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(chf_info_listList , localMapKeyPair);
     }
     }
@@ -2008,12 +2061,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(udsf_info_list_local_map, udsf_info_list) {
         cJSON *localMapObject = udsf_info_list_local_map;
-        if (!cJSON_IsObject(udsf_info_list_local_map)) {
+        if (cJSON_IsObject(udsf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_udsf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(udsf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [udsf_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_udsf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(udsf_info_listList , localMapKeyPair);
     }
     }
@@ -2038,12 +2094,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pcscf_info_list_local_map, pcscf_info_list) {
         cJSON *localMapObject = pcscf_info_list_local_map;
-        if (!cJSON_IsObject(pcscf_info_list_local_map)) {
+        if (cJSON_IsObject(pcscf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_pcscf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pcscf_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [pcscf_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_pcscf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(pcscf_info_listList , localMapKeyPair);
     }
     }
@@ -2061,12 +2120,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(hss_info_list_local_map, hss_info_list) {
         cJSON *localMapObject = hss_info_list_local_map;
-        if (!cJSON_IsObject(hss_info_list_local_map)) {
+        if (cJSON_IsObject(hss_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_hss_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(hss_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [hss_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_hss_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(hss_info_listList , localMapKeyPair);
     }
     }
@@ -2132,12 +2194,15 @@ OpenAPI_nf_profile_t *OpenAPI_nf_profile_parseFromJSON(cJSON *nf_profileJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(nf_service_list_local_map, nf_service_list) {
         cJSON *localMapObject = nf_service_list_local_map;
-        if (!cJSON_IsObject(nf_service_list_local_map)) {
+        if (cJSON_IsObject(nf_service_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_nf_service_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(nf_service_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nf_profile_parseFromJSON() failed [nf_service_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_nf_service_parseFromJSON(localMapObject));
         OpenAPI_list_add(nf_service_listList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/nrf_info.c

@@ -269,7 +269,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_udr_info) {
         OpenAPI_list_for_each(nrf_info->served_udr_info, served_udr_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_udr_info_node->data;
-        cJSON *itemLocal = OpenAPI_udr_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_udr_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_udr_info]");
             goto end;
@@ -305,7 +307,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_udm_info) {
         OpenAPI_list_for_each(nrf_info->served_udm_info, served_udm_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_udm_info_node->data;
-        cJSON *itemLocal = OpenAPI_udm_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_udm_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_udm_info]");
             goto end;
@@ -341,7 +345,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_ausf_info) {
         OpenAPI_list_for_each(nrf_info->served_ausf_info, served_ausf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_ausf_info_node->data;
-        cJSON *itemLocal = OpenAPI_ausf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_ausf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_ausf_info]");
             goto end;
@@ -377,7 +383,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_amf_info) {
         OpenAPI_list_for_each(nrf_info->served_amf_info, served_amf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_amf_info_node->data;
-        cJSON *itemLocal = OpenAPI_amf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_amf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_amf_info]");
             goto end;
@@ -413,7 +421,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_smf_info) {
         OpenAPI_list_for_each(nrf_info->served_smf_info, served_smf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_smf_info_node->data;
-        cJSON *itemLocal = OpenAPI_smf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_smf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_smf_info]");
             goto end;
@@ -449,7 +459,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_upf_info) {
         OpenAPI_list_for_each(nrf_info->served_upf_info, served_upf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_upf_info_node->data;
-        cJSON *itemLocal = OpenAPI_upf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_upf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_upf_info]");
             goto end;
@@ -485,7 +497,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_pcf_info) {
         OpenAPI_list_for_each(nrf_info->served_pcf_info, served_pcf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_pcf_info_node->data;
-        cJSON *itemLocal = OpenAPI_pcf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_pcf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_pcf_info]");
             goto end;
@@ -521,7 +535,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_bsf_info) {
         OpenAPI_list_for_each(nrf_info->served_bsf_info, served_bsf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_bsf_info_node->data;
-        cJSON *itemLocal = OpenAPI_bsf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_bsf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_bsf_info]");
             goto end;
@@ -557,7 +573,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_chf_info) {
         OpenAPI_list_for_each(nrf_info->served_chf_info, served_chf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_chf_info_node->data;
-        cJSON *itemLocal = OpenAPI_chf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_chf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_chf_info]");
             goto end;
@@ -593,7 +611,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_nef_info) {
         OpenAPI_list_for_each(nrf_info->served_nef_info, served_nef_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_nef_info_node->data;
-        cJSON *itemLocal = OpenAPI_nef_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_nef_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_nef_info]");
             goto end;
@@ -614,7 +634,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_nwdaf_info) {
         OpenAPI_list_for_each(nrf_info->served_nwdaf_info, served_nwdaf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_nwdaf_info_node->data;
-        cJSON *itemLocal = OpenAPI_nwdaf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_nwdaf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_nwdaf_info]");
             goto end;
@@ -650,7 +672,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_gmlc_info) {
         OpenAPI_list_for_each(nrf_info->served_gmlc_info, served_gmlc_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_gmlc_info_node->data;
-        cJSON *itemLocal = OpenAPI_gmlc_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_gmlc_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_gmlc_info]");
             goto end;
@@ -671,7 +695,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_lmf_info) {
         OpenAPI_list_for_each(nrf_info->served_lmf_info, served_lmf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_lmf_info_node->data;
-        cJSON *itemLocal = OpenAPI_lmf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_lmf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_lmf_info]");
             goto end;
@@ -692,7 +718,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_nf_info) {
         OpenAPI_list_for_each(nrf_info->served_nf_info, served_nf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_nf_info_node->data;
-        cJSON *itemLocal = OpenAPI_nf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_nf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_nf_info]");
             goto end;
@@ -728,7 +756,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_udsf_info) {
         OpenAPI_list_for_each(nrf_info->served_udsf_info, served_udsf_info_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_udsf_info_node->data;
-        cJSON *itemLocal = OpenAPI_udsf_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_udsf_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_udsf_info]");
             goto end;
@@ -764,7 +794,9 @@ cJSON *OpenAPI_nrf_info_convertToJSON(OpenAPI_nrf_info_t *nrf_info)
     if (nrf_info->served_scp_info_list) {
         OpenAPI_list_for_each(nrf_info->served_scp_info_list, served_scp_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)served_scp_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_scp_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_scp_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nrf_info_convertToJSON() failed [served_scp_info_list]");
             goto end;
@@ -794,12 +826,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_udr_info_local_map, served_udr_info) {
         cJSON *localMapObject = served_udr_info_local_map;
-        if (!cJSON_IsObject(served_udr_info_local_map)) {
+        if (cJSON_IsObject(served_udr_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_udr_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_udr_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_udr_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_udr_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_udr_infoList , localMapKeyPair);
     }
     }
@@ -834,12 +869,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_udm_info_local_map, served_udm_info) {
         cJSON *localMapObject = served_udm_info_local_map;
-        if (!cJSON_IsObject(served_udm_info_local_map)) {
+        if (cJSON_IsObject(served_udm_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_udm_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_udm_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_udm_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_udm_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_udm_infoList , localMapKeyPair);
     }
     }
@@ -874,12 +912,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_ausf_info_local_map, served_ausf_info) {
         cJSON *localMapObject = served_ausf_info_local_map;
-        if (!cJSON_IsObject(served_ausf_info_local_map)) {
+        if (cJSON_IsObject(served_ausf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_ausf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_ausf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_ausf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_ausf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_ausf_infoList , localMapKeyPair);
     }
     }
@@ -914,12 +955,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_amf_info_local_map, served_amf_info) {
         cJSON *localMapObject = served_amf_info_local_map;
-        if (!cJSON_IsObject(served_amf_info_local_map)) {
+        if (cJSON_IsObject(served_amf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_amf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_amf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_amf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_amf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_amf_infoList , localMapKeyPair);
     }
     }
@@ -954,12 +998,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_smf_info_local_map, served_smf_info) {
         cJSON *localMapObject = served_smf_info_local_map;
-        if (!cJSON_IsObject(served_smf_info_local_map)) {
+        if (cJSON_IsObject(served_smf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_smf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_smf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_smf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_smf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_smf_infoList , localMapKeyPair);
     }
     }
@@ -994,12 +1041,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_upf_info_local_map, served_upf_info) {
         cJSON *localMapObject = served_upf_info_local_map;
-        if (!cJSON_IsObject(served_upf_info_local_map)) {
+        if (cJSON_IsObject(served_upf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_upf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_upf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_upf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_upf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_upf_infoList , localMapKeyPair);
     }
     }
@@ -1034,12 +1084,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_pcf_info_local_map, served_pcf_info) {
         cJSON *localMapObject = served_pcf_info_local_map;
-        if (!cJSON_IsObject(served_pcf_info_local_map)) {
+        if (cJSON_IsObject(served_pcf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_pcf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_pcf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_pcf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_pcf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_pcf_infoList , localMapKeyPair);
     }
     }
@@ -1074,12 +1127,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_bsf_info_local_map, served_bsf_info) {
         cJSON *localMapObject = served_bsf_info_local_map;
-        if (!cJSON_IsObject(served_bsf_info_local_map)) {
+        if (cJSON_IsObject(served_bsf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_bsf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_bsf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_bsf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_bsf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_bsf_infoList , localMapKeyPair);
     }
     }
@@ -1114,12 +1170,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_chf_info_local_map, served_chf_info) {
         cJSON *localMapObject = served_chf_info_local_map;
-        if (!cJSON_IsObject(served_chf_info_local_map)) {
+        if (cJSON_IsObject(served_chf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_chf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_chf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_chf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_chf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_chf_infoList , localMapKeyPair);
     }
     }
@@ -1154,12 +1213,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_nef_info_local_map, served_nef_info) {
         cJSON *localMapObject = served_nef_info_local_map;
-        if (!cJSON_IsObject(served_nef_info_local_map)) {
+        if (cJSON_IsObject(served_nef_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_nef_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_nef_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_nef_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_nef_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_nef_infoList , localMapKeyPair);
     }
     }
@@ -1177,12 +1239,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_nwdaf_info_local_map, served_nwdaf_info) {
         cJSON *localMapObject = served_nwdaf_info_local_map;
-        if (!cJSON_IsObject(served_nwdaf_info_local_map)) {
+        if (cJSON_IsObject(served_nwdaf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_nwdaf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_nwdaf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_nwdaf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_nwdaf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_nwdaf_infoList , localMapKeyPair);
     }
     }
@@ -1217,12 +1282,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_gmlc_info_local_map, served_gmlc_info) {
         cJSON *localMapObject = served_gmlc_info_local_map;
-        if (!cJSON_IsObject(served_gmlc_info_local_map)) {
+        if (cJSON_IsObject(served_gmlc_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_gmlc_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_gmlc_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_gmlc_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_gmlc_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_gmlc_infoList , localMapKeyPair);
     }
     }
@@ -1240,12 +1308,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_lmf_info_local_map, served_lmf_info) {
         cJSON *localMapObject = served_lmf_info_local_map;
-        if (!cJSON_IsObject(served_lmf_info_local_map)) {
+        if (cJSON_IsObject(served_lmf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_lmf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_lmf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_lmf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_lmf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_lmf_infoList , localMapKeyPair);
     }
     }
@@ -1263,12 +1334,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_nf_info_local_map, served_nf_info) {
         cJSON *localMapObject = served_nf_info_local_map;
-        if (!cJSON_IsObject(served_nf_info_local_map)) {
+        if (cJSON_IsObject(served_nf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_nf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_nf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_nf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_nf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_nf_infoList , localMapKeyPair);
     }
     }
@@ -1303,12 +1377,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_udsf_info_local_map, served_udsf_info) {
         cJSON *localMapObject = served_udsf_info_local_map;
-        if (!cJSON_IsObject(served_udsf_info_local_map)) {
+        if (cJSON_IsObject(served_udsf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_udsf_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_udsf_info_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_udsf_info]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_udsf_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_udsf_infoList , localMapKeyPair);
     }
     }
@@ -1343,12 +1420,15 @@ OpenAPI_nrf_info_t *OpenAPI_nrf_info_parseFromJSON(cJSON *nrf_infoJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(served_scp_info_list_local_map, served_scp_info_list) {
         cJSON *localMapObject = served_scp_info_list_local_map;
-        if (!cJSON_IsObject(served_scp_info_list_local_map)) {
+        if (cJSON_IsObject(served_scp_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_scp_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(served_scp_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nrf_info_parseFromJSON() failed [served_scp_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_scp_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(served_scp_info_listList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/nssai.c

@@ -123,7 +123,9 @@ cJSON *OpenAPI_nssai_convertToJSON(OpenAPI_nssai_t *nssai)
     if (nssai->additional_snssai_data) {
         OpenAPI_list_for_each(nssai->additional_snssai_data, additional_snssai_data_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)additional_snssai_data_node->data;
-        cJSON *itemLocal = OpenAPI_additional_snssai_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_additional_snssai_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nssai_convertToJSON() failed [additional_snssai_data]");
             goto end;
@@ -219,12 +221,15 @@ OpenAPI_nssai_t *OpenAPI_nssai_parseFromJSON(cJSON *nssaiJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(additional_snssai_data_local_map, additional_snssai_data) {
         cJSON *localMapObject = additional_snssai_data_local_map;
-        if (!cJSON_IsObject(additional_snssai_data_local_map)) {
+        if (cJSON_IsObject(additional_snssai_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_additional_snssai_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(additional_snssai_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nssai_parseFromJSON() failed [additional_snssai_data]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_additional_snssai_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(additional_snssai_dataList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/nssai_1.c

@@ -123,7 +123,9 @@ cJSON *OpenAPI_nssai_1_convertToJSON(OpenAPI_nssai_1_t *nssai_1)
     if (nssai_1->additional_snssai_data) {
         OpenAPI_list_for_each(nssai_1->additional_snssai_data, additional_snssai_data_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)additional_snssai_data_node->data;
-        cJSON *itemLocal = OpenAPI_additional_snssai_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_additional_snssai_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_nssai_1_convertToJSON() failed [additional_snssai_data]");
             goto end;
@@ -219,12 +221,15 @@ OpenAPI_nssai_1_t *OpenAPI_nssai_1_parseFromJSON(cJSON *nssai_1JSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(additional_snssai_data_local_map, additional_snssai_data) {
         cJSON *localMapObject = additional_snssai_data_local_map;
-        if (!cJSON_IsObject(additional_snssai_data_local_map)) {
+        if (cJSON_IsObject(additional_snssai_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_additional_snssai_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(additional_snssai_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_nssai_1_parseFromJSON() failed [additional_snssai_data]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_additional_snssai_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(additional_snssai_dataList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/policy_association.c

@@ -165,7 +165,9 @@ cJSON *OpenAPI_policy_association_convertToJSON(OpenAPI_policy_association_t *po
     if (policy_association->pras) {
         OpenAPI_list_for_each(policy_association->pras, pras_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pras_node->data;
-        cJSON *itemLocal = OpenAPI_presence_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_presence_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_policy_association_convertToJSON() failed [pras]");
             goto end;
@@ -266,12 +268,15 @@ OpenAPI_policy_association_t *OpenAPI_policy_association_parseFromJSON(cJSON *po
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pras_local_map, pras) {
         cJSON *localMapObject = pras_local_map;
-        if (!cJSON_IsObject(pras_local_map)) {
+        if (cJSON_IsObject(pras_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pras_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_policy_association_parseFromJSON() failed [pras]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(prasList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/policy_association_update_request.c

@@ -255,7 +255,9 @@ cJSON *OpenAPI_policy_association_update_request_convertToJSON(OpenAPI_policy_as
     if (policy_association_update_request->pra_statuses) {
         OpenAPI_list_for_each(policy_association_update_request->pra_statuses, pra_statuses_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pra_statuses_node->data;
-        cJSON *itemLocal = OpenAPI_presence_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_presence_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_policy_association_update_request_convertToJSON() failed [pra_statuses]");
             goto end;
@@ -542,12 +544,15 @@ OpenAPI_policy_association_update_request_t *OpenAPI_policy_association_update_r
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pra_statuses_local_map, pra_statuses) {
         cJSON *localMapObject = pra_statuses_local_map;
-        if (!cJSON_IsObject(pra_statuses_local_map)) {
+        if (cJSON_IsObject(pra_statuses_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pra_statuses_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_policy_association_update_request_parseFromJSON() failed [pra_statuses]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(pra_statusesList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/policy_data_change_notification.c

@@ -211,7 +211,9 @@ cJSON *OpenAPI_policy_data_change_notification_convertToJSON(OpenAPI_policy_data
     if (policy_data_change_notification->op_spec_data_map) {
         OpenAPI_list_for_each(policy_data_change_notification->op_spec_data_map, op_spec_data_map_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)op_spec_data_map_node->data;
-        cJSON *itemLocal = OpenAPI_operator_specific_data_container_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_operator_specific_data_container_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_policy_data_change_notification_convertToJSON() failed [op_spec_data_map]");
             goto end;
@@ -381,12 +383,15 @@ OpenAPI_policy_data_change_notification_t *OpenAPI_policy_data_change_notificati
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(op_spec_data_map_local_map, op_spec_data_map) {
         cJSON *localMapObject = op_spec_data_map_local_map;
-        if (!cJSON_IsObject(op_spec_data_map_local_map)) {
+        if (cJSON_IsObject(op_spec_data_map_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_operator_specific_data_container_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(op_spec_data_map_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_policy_data_change_notification_parseFromJSON() failed [op_spec_data_map]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_operator_specific_data_container_parseFromJSON(localMapObject));
         OpenAPI_list_add(op_spec_data_mapList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/policy_update.c

@@ -154,7 +154,9 @@ cJSON *OpenAPI_policy_update_convertToJSON(OpenAPI_policy_update_t *policy_updat
     if (policy_update->pras) {
         OpenAPI_list_for_each(policy_update->pras, pras_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pras_node->data;
-        cJSON *itemLocal = OpenAPI_presence_info_rm_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_presence_info_rm_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_policy_update_convertToJSON() failed [pras]");
             goto end;
@@ -254,12 +256,15 @@ OpenAPI_policy_update_t *OpenAPI_policy_update_parseFromJSON(cJSON *policy_updat
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pras_local_map, pras) {
         cJSON *localMapObject = pras_local_map;
-        if (!cJSON_IsObject(pras_local_map)) {
+        if (cJSON_IsObject(pras_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_presence_info_rm_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pras_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_policy_update_parseFromJSON() failed [pras]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_presence_info_rm_parseFromJSON(localMapObject));
         OpenAPI_list_add(prasList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/session_management_subscription_data.c

@@ -111,7 +111,9 @@ cJSON *OpenAPI_session_management_subscription_data_convertToJSON(OpenAPI_sessio
     if (session_management_subscription_data->dnn_configurations) {
         OpenAPI_list_for_each(session_management_subscription_data->dnn_configurations, dnn_configurations_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)dnn_configurations_node->data;
-        cJSON *itemLocal = OpenAPI_dnn_configuration_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_dnn_configuration_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_session_management_subscription_data_convertToJSON() failed [dnn_configurations]");
             goto end;
@@ -197,7 +199,9 @@ cJSON *OpenAPI_session_management_subscription_data_convertToJSON(OpenAPI_sessio
     if (session_management_subscription_data->expected_ue_behaviours_list) {
         OpenAPI_list_for_each(session_management_subscription_data->expected_ue_behaviours_list, expected_ue_behaviours_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)expected_ue_behaviours_list_node->data;
-        cJSON *itemLocal = OpenAPI_expected_ue_behaviour_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_expected_ue_behaviour_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_session_management_subscription_data_convertToJSON() failed [expected_ue_behaviours_list]");
             goto end;
@@ -218,7 +222,9 @@ cJSON *OpenAPI_session_management_subscription_data_convertToJSON(OpenAPI_sessio
     if (session_management_subscription_data->suggested_packet_num_dl_list) {
         OpenAPI_list_for_each(session_management_subscription_data->suggested_packet_num_dl_list, suggested_packet_num_dl_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)suggested_packet_num_dl_list_node->data;
-        cJSON *itemLocal = OpenAPI_suggested_packet_num_dl_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_suggested_packet_num_dl_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_session_management_subscription_data_convertToJSON() failed [suggested_packet_num_dl_list]");
             goto end;
@@ -264,12 +270,15 @@ OpenAPI_session_management_subscription_data_t *OpenAPI_session_management_subsc
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(dnn_configurations_local_map, dnn_configurations) {
         cJSON *localMapObject = dnn_configurations_local_map;
-        if (!cJSON_IsObject(dnn_configurations_local_map)) {
+        if (cJSON_IsObject(dnn_configurations_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_dnn_configuration_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(dnn_configurations_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_session_management_subscription_data_parseFromJSON() failed [dnn_configurations]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_dnn_configuration_parseFromJSON(localMapObject));
         OpenAPI_list_add(dnn_configurationsList , localMapKeyPair);
     }
     }
@@ -360,12 +369,15 @@ OpenAPI_session_management_subscription_data_t *OpenAPI_session_management_subsc
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(expected_ue_behaviours_list_local_map, expected_ue_behaviours_list) {
         cJSON *localMapObject = expected_ue_behaviours_list_local_map;
-        if (!cJSON_IsObject(expected_ue_behaviours_list_local_map)) {
+        if (cJSON_IsObject(expected_ue_behaviours_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_expected_ue_behaviour_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(expected_ue_behaviours_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_session_management_subscription_data_parseFromJSON() failed [expected_ue_behaviours_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_expected_ue_behaviour_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(expected_ue_behaviours_listList , localMapKeyPair);
     }
     }
@@ -383,12 +395,15 @@ OpenAPI_session_management_subscription_data_t *OpenAPI_session_management_subsc
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(suggested_packet_num_dl_list_local_map, suggested_packet_num_dl_list) {
         cJSON *localMapObject = suggested_packet_num_dl_list_local_map;
-        if (!cJSON_IsObject(suggested_packet_num_dl_list_local_map)) {
+        if (cJSON_IsObject(suggested_packet_num_dl_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_suggested_packet_num_dl_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(suggested_packet_num_dl_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_session_management_subscription_data_parseFromJSON() failed [suggested_packet_num_dl_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_suggested_packet_num_dl_parseFromJSON(localMapObject));
         OpenAPI_list_add(suggested_packet_num_dl_listList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/session_management_subscription_data_1.c

@@ -111,7 +111,9 @@ cJSON *OpenAPI_session_management_subscription_data_1_convertToJSON(OpenAPI_sess
     if (session_management_subscription_data_1->dnn_configurations) {
         OpenAPI_list_for_each(session_management_subscription_data_1->dnn_configurations, dnn_configurations_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)dnn_configurations_node->data;
-        cJSON *itemLocal = OpenAPI_dnn_configuration_1_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_dnn_configuration_1_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_session_management_subscription_data_1_convertToJSON() failed [dnn_configurations]");
             goto end;
@@ -197,7 +199,9 @@ cJSON *OpenAPI_session_management_subscription_data_1_convertToJSON(OpenAPI_sess
     if (session_management_subscription_data_1->expected_ue_behaviours_list) {
         OpenAPI_list_for_each(session_management_subscription_data_1->expected_ue_behaviours_list, expected_ue_behaviours_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)expected_ue_behaviours_list_node->data;
-        cJSON *itemLocal = OpenAPI_expected_ue_behaviour_data_1_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_expected_ue_behaviour_data_1_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_session_management_subscription_data_1_convertToJSON() failed [expected_ue_behaviours_list]");
             goto end;
@@ -218,7 +222,9 @@ cJSON *OpenAPI_session_management_subscription_data_1_convertToJSON(OpenAPI_sess
     if (session_management_subscription_data_1->suggested_packet_num_dl_list) {
         OpenAPI_list_for_each(session_management_subscription_data_1->suggested_packet_num_dl_list, suggested_packet_num_dl_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)suggested_packet_num_dl_list_node->data;
-        cJSON *itemLocal = OpenAPI_suggested_packet_num_dl_1_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_suggested_packet_num_dl_1_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_session_management_subscription_data_1_convertToJSON() failed [suggested_packet_num_dl_list]");
             goto end;
@@ -264,12 +270,15 @@ OpenAPI_session_management_subscription_data_1_t *OpenAPI_session_management_sub
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(dnn_configurations_local_map, dnn_configurations) {
         cJSON *localMapObject = dnn_configurations_local_map;
-        if (!cJSON_IsObject(dnn_configurations_local_map)) {
+        if (cJSON_IsObject(dnn_configurations_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_dnn_configuration_1_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(dnn_configurations_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_session_management_subscription_data_1_parseFromJSON() failed [dnn_configurations]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_dnn_configuration_1_parseFromJSON(localMapObject));
         OpenAPI_list_add(dnn_configurationsList , localMapKeyPair);
     }
     }
@@ -360,12 +369,15 @@ OpenAPI_session_management_subscription_data_1_t *OpenAPI_session_management_sub
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(expected_ue_behaviours_list_local_map, expected_ue_behaviours_list) {
         cJSON *localMapObject = expected_ue_behaviours_list_local_map;
-        if (!cJSON_IsObject(expected_ue_behaviours_list_local_map)) {
+        if (cJSON_IsObject(expected_ue_behaviours_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_expected_ue_behaviour_data_1_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(expected_ue_behaviours_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_session_management_subscription_data_1_parseFromJSON() failed [expected_ue_behaviours_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_expected_ue_behaviour_data_1_parseFromJSON(localMapObject));
         OpenAPI_list_add(expected_ue_behaviours_listList , localMapKeyPair);
     }
     }
@@ -383,12 +395,15 @@ OpenAPI_session_management_subscription_data_1_t *OpenAPI_session_management_sub
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(suggested_packet_num_dl_list_local_map, suggested_packet_num_dl_list) {
         cJSON *localMapObject = suggested_packet_num_dl_list_local_map;
-        if (!cJSON_IsObject(suggested_packet_num_dl_list_local_map)) {
+        if (cJSON_IsObject(suggested_packet_num_dl_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_suggested_packet_num_dl_1_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(suggested_packet_num_dl_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_session_management_subscription_data_1_parseFromJSON() failed [suggested_packet_num_dl_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_suggested_packet_num_dl_1_parseFromJSON(localMapObject));
         OpenAPI_list_add(suggested_packet_num_dl_listList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/shared_data.c

@@ -128,7 +128,9 @@ cJSON *OpenAPI_shared_data_convertToJSON(OpenAPI_shared_data_t *shared_data)
     if (shared_data->shared_dnn_configurations) {
         OpenAPI_list_for_each(shared_data->shared_dnn_configurations, shared_dnn_configurations_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)shared_dnn_configurations_node->data;
-        cJSON *itemLocal = OpenAPI_dnn_configuration_1_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_dnn_configuration_1_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_shared_data_convertToJSON() failed [shared_dnn_configurations]");
             goto end;
@@ -162,7 +164,9 @@ cJSON *OpenAPI_shared_data_convertToJSON(OpenAPI_shared_data_t *shared_data)
     if (shared_data->shared_snssai_infos) {
         OpenAPI_list_for_each(shared_data->shared_snssai_infos, shared_snssai_infos_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)shared_snssai_infos_node->data;
-        cJSON *itemLocal = OpenAPI_snssai_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_snssai_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_shared_data_convertToJSON() failed [shared_snssai_infos]");
             goto end;
@@ -183,7 +187,9 @@ cJSON *OpenAPI_shared_data_convertToJSON(OpenAPI_shared_data_t *shared_data)
     if (shared_data->shared_vn_group_datas) {
         OpenAPI_list_for_each(shared_data->shared_vn_group_datas, shared_vn_group_datas_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)shared_vn_group_datas_node->data;
-        cJSON *itemLocal = OpenAPI_vn_group_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_vn_group_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_shared_data_convertToJSON() failed [shared_vn_group_datas]");
             goto end;
@@ -245,12 +251,15 @@ OpenAPI_shared_data_t *OpenAPI_shared_data_parseFromJSON(cJSON *shared_dataJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(shared_dnn_configurations_local_map, shared_dnn_configurations) {
         cJSON *localMapObject = shared_dnn_configurations_local_map;
-        if (!cJSON_IsObject(shared_dnn_configurations_local_map)) {
+        if (cJSON_IsObject(shared_dnn_configurations_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_dnn_configuration_1_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(shared_dnn_configurations_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_shared_data_parseFromJSON() failed [shared_dnn_configurations]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_dnn_configuration_1_parseFromJSON(localMapObject));
         OpenAPI_list_add(shared_dnn_configurationsList , localMapKeyPair);
     }
     }
@@ -275,12 +284,15 @@ OpenAPI_shared_data_t *OpenAPI_shared_data_parseFromJSON(cJSON *shared_dataJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(shared_snssai_infos_local_map, shared_snssai_infos) {
         cJSON *localMapObject = shared_snssai_infos_local_map;
-        if (!cJSON_IsObject(shared_snssai_infos_local_map)) {
+        if (cJSON_IsObject(shared_snssai_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_snssai_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(shared_snssai_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_shared_data_parseFromJSON() failed [shared_snssai_infos]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_snssai_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(shared_snssai_infosList , localMapKeyPair);
     }
     }
@@ -298,12 +310,15 @@ OpenAPI_shared_data_t *OpenAPI_shared_data_parseFromJSON(cJSON *shared_dataJSON)
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(shared_vn_group_datas_local_map, shared_vn_group_datas) {
         cJSON *localMapObject = shared_vn_group_datas_local_map;
-        if (!cJSON_IsObject(shared_vn_group_datas_local_map)) {
+        if (cJSON_IsObject(shared_vn_group_datas_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_vn_group_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(shared_vn_group_datas_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_shared_data_parseFromJSON() failed [shared_vn_group_datas]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_vn_group_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(shared_vn_group_datasList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/sm_policy_data.c

@@ -71,7 +71,9 @@ cJSON *OpenAPI_sm_policy_data_convertToJSON(OpenAPI_sm_policy_data_t *sm_policy_
     if (sm_policy_data->sm_policy_snssai_data) {
         OpenAPI_list_for_each(sm_policy_data->sm_policy_snssai_data, sm_policy_snssai_data_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)sm_policy_snssai_data_node->data;
-        cJSON *itemLocal = OpenAPI_sm_policy_snssai_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_sm_policy_snssai_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_data_convertToJSON() failed [sm_policy_snssai_data]");
             goto end;
@@ -91,7 +93,9 @@ cJSON *OpenAPI_sm_policy_data_convertToJSON(OpenAPI_sm_policy_data_t *sm_policy_
     if (sm_policy_data->um_data_limits) {
         OpenAPI_list_for_each(sm_policy_data->um_data_limits, um_data_limits_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)um_data_limits_node->data;
-        cJSON *itemLocal = OpenAPI_usage_mon_data_limit_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_usage_mon_data_limit_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_data_convertToJSON() failed [um_data_limits]");
             goto end;
@@ -112,7 +116,9 @@ cJSON *OpenAPI_sm_policy_data_convertToJSON(OpenAPI_sm_policy_data_t *sm_policy_
     if (sm_policy_data->um_data) {
         OpenAPI_list_for_each(sm_policy_data->um_data, um_data_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)um_data_node->data;
-        cJSON *itemLocal = OpenAPI_usage_mon_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_usage_mon_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_data_convertToJSON() failed [um_data]");
             goto end;
@@ -152,12 +158,15 @@ OpenAPI_sm_policy_data_t *OpenAPI_sm_policy_data_parseFromJSON(cJSON *sm_policy_
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(sm_policy_snssai_data_local_map, sm_policy_snssai_data) {
         cJSON *localMapObject = sm_policy_snssai_data_local_map;
-        if (!cJSON_IsObject(sm_policy_snssai_data_local_map)) {
+        if (cJSON_IsObject(sm_policy_snssai_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_sm_policy_snssai_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(sm_policy_snssai_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_data_parseFromJSON() failed [sm_policy_snssai_data]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_sm_policy_snssai_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(sm_policy_snssai_dataList , localMapKeyPair);
     }
 
@@ -174,12 +183,15 @@ OpenAPI_sm_policy_data_t *OpenAPI_sm_policy_data_parseFromJSON(cJSON *sm_policy_
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(um_data_limits_local_map, um_data_limits) {
         cJSON *localMapObject = um_data_limits_local_map;
-        if (!cJSON_IsObject(um_data_limits_local_map)) {
+        if (cJSON_IsObject(um_data_limits_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_usage_mon_data_limit_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(um_data_limits_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_data_parseFromJSON() failed [um_data_limits]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_usage_mon_data_limit_parseFromJSON(localMapObject));
         OpenAPI_list_add(um_data_limitsList , localMapKeyPair);
     }
     }
@@ -197,12 +209,15 @@ OpenAPI_sm_policy_data_t *OpenAPI_sm_policy_data_parseFromJSON(cJSON *sm_policy_
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(um_data_local_map, um_data) {
         cJSON *localMapObject = um_data_local_map;
-        if (!cJSON_IsObject(um_data_local_map)) {
+        if (cJSON_IsObject(um_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_usage_mon_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(um_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_data_parseFromJSON() failed [um_data]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_usage_mon_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(um_dataList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/sm_policy_data_patch.c

@@ -61,7 +61,9 @@ cJSON *OpenAPI_sm_policy_data_patch_convertToJSON(OpenAPI_sm_policy_data_patch_t
     if (sm_policy_data_patch->um_data) {
         OpenAPI_list_for_each(sm_policy_data_patch->um_data, um_data_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)um_data_node->data;
-        cJSON *itemLocal = OpenAPI_usage_mon_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_usage_mon_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_data_patch_convertToJSON() failed [um_data]");
             goto end;
@@ -82,7 +84,9 @@ cJSON *OpenAPI_sm_policy_data_patch_convertToJSON(OpenAPI_sm_policy_data_patch_t
     if (sm_policy_data_patch->sm_policy_snssai_data) {
         OpenAPI_list_for_each(sm_policy_data_patch->sm_policy_snssai_data, sm_policy_snssai_data_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)sm_policy_snssai_data_node->data;
-        cJSON *itemLocal = OpenAPI_sm_policy_snssai_data_patch_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_sm_policy_snssai_data_patch_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_data_patch_convertToJSON() failed [sm_policy_snssai_data]");
             goto end;
@@ -112,12 +116,15 @@ OpenAPI_sm_policy_data_patch_t *OpenAPI_sm_policy_data_patch_parseFromJSON(cJSON
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(um_data_local_map, um_data) {
         cJSON *localMapObject = um_data_local_map;
-        if (!cJSON_IsObject(um_data_local_map)) {
+        if (cJSON_IsObject(um_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_usage_mon_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(um_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_data_patch_parseFromJSON() failed [um_data]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_usage_mon_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(um_dataList , localMapKeyPair);
     }
     }
@@ -135,12 +142,15 @@ OpenAPI_sm_policy_data_patch_t *OpenAPI_sm_policy_data_patch_parseFromJSON(cJSON
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(sm_policy_snssai_data_local_map, sm_policy_snssai_data) {
         cJSON *localMapObject = sm_policy_snssai_data_local_map;
-        if (!cJSON_IsObject(sm_policy_snssai_data_local_map)) {
+        if (cJSON_IsObject(sm_policy_snssai_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_sm_policy_snssai_data_patch_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(sm_policy_snssai_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_data_patch_parseFromJSON() failed [sm_policy_snssai_data]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_sm_policy_snssai_data_patch_parseFromJSON(localMapObject));
         OpenAPI_list_add(sm_policy_snssai_dataList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/sm_policy_decision.c

@@ -190,7 +190,9 @@ cJSON *OpenAPI_sm_policy_decision_convertToJSON(OpenAPI_sm_policy_decision_t *sm
     if (sm_policy_decision->sess_rules) {
         OpenAPI_list_for_each(sm_policy_decision->sess_rules, sess_rules_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)sess_rules_node->data;
-        cJSON *itemLocal = OpenAPI_session_rule_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_session_rule_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_decision_convertToJSON() failed [sess_rules]");
             goto end;
@@ -211,7 +213,9 @@ cJSON *OpenAPI_sm_policy_decision_convertToJSON(OpenAPI_sm_policy_decision_t *sm
     if (sm_policy_decision->pcc_rules) {
         OpenAPI_list_for_each(sm_policy_decision->pcc_rules, pcc_rules_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pcc_rules_node->data;
-        cJSON *itemLocal = OpenAPI_pcc_rule_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_pcc_rule_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_decision_convertToJSON() failed [pcc_rules]");
             goto end;
@@ -239,7 +243,9 @@ cJSON *OpenAPI_sm_policy_decision_convertToJSON(OpenAPI_sm_policy_decision_t *sm
     if (sm_policy_decision->qos_decs) {
         OpenAPI_list_for_each(sm_policy_decision->qos_decs, qos_decs_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)qos_decs_node->data;
-        cJSON *itemLocal = OpenAPI_qos_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_qos_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_decision_convertToJSON() failed [qos_decs]");
             goto end;
@@ -260,7 +266,9 @@ cJSON *OpenAPI_sm_policy_decision_convertToJSON(OpenAPI_sm_policy_decision_t *sm
     if (sm_policy_decision->chg_decs) {
         OpenAPI_list_for_each(sm_policy_decision->chg_decs, chg_decs_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)chg_decs_node->data;
-        cJSON *itemLocal = OpenAPI_charging_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_charging_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_decision_convertToJSON() failed [chg_decs]");
             goto end;
@@ -294,7 +302,9 @@ cJSON *OpenAPI_sm_policy_decision_convertToJSON(OpenAPI_sm_policy_decision_t *sm
     if (sm_policy_decision->traff_cont_decs) {
         OpenAPI_list_for_each(sm_policy_decision->traff_cont_decs, traff_cont_decs_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)traff_cont_decs_node->data;
-        cJSON *itemLocal = OpenAPI_traffic_control_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_traffic_control_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_decision_convertToJSON() failed [traff_cont_decs]");
             goto end;
@@ -315,7 +325,9 @@ cJSON *OpenAPI_sm_policy_decision_convertToJSON(OpenAPI_sm_policy_decision_t *sm
     if (sm_policy_decision->um_decs) {
         OpenAPI_list_for_each(sm_policy_decision->um_decs, um_decs_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)um_decs_node->data;
-        cJSON *itemLocal = OpenAPI_usage_monitoring_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_usage_monitoring_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_decision_convertToJSON() failed [um_decs]");
             goto end;
@@ -336,7 +348,9 @@ cJSON *OpenAPI_sm_policy_decision_convertToJSON(OpenAPI_sm_policy_decision_t *sm
     if (sm_policy_decision->qos_chars) {
         OpenAPI_list_for_each(sm_policy_decision->qos_chars, qos_chars_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)qos_chars_node->data;
-        cJSON *itemLocal = OpenAPI_qos_characteristics_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_qos_characteristics_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_decision_convertToJSON() failed [qos_chars]");
             goto end;
@@ -357,7 +371,9 @@ cJSON *OpenAPI_sm_policy_decision_convertToJSON(OpenAPI_sm_policy_decision_t *sm
     if (sm_policy_decision->qos_mon_decs) {
         OpenAPI_list_for_each(sm_policy_decision->qos_mon_decs, qos_mon_decs_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)qos_mon_decs_node->data;
-        cJSON *itemLocal = OpenAPI_qos_monitoring_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_qos_monitoring_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_decision_convertToJSON() failed [qos_mon_decs]");
             goto end;
@@ -385,7 +401,9 @@ cJSON *OpenAPI_sm_policy_decision_convertToJSON(OpenAPI_sm_policy_decision_t *sm
     if (sm_policy_decision->conds) {
         OpenAPI_list_for_each(sm_policy_decision->conds, conds_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)conds_node->data;
-        cJSON *itemLocal = OpenAPI_condition_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_condition_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_decision_convertToJSON() failed [conds]");
             goto end;
@@ -475,7 +493,9 @@ cJSON *OpenAPI_sm_policy_decision_convertToJSON(OpenAPI_sm_policy_decision_t *sm
     if (sm_policy_decision->pra_infos) {
         OpenAPI_list_for_each(sm_policy_decision->pra_infos, pra_infos_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pra_infos_node->data;
-        cJSON *itemLocal = OpenAPI_presence_info_rm_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_presence_info_rm_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_decision_convertToJSON() failed [pra_infos]");
             goto end;
@@ -593,12 +613,15 @@ OpenAPI_sm_policy_decision_t *OpenAPI_sm_policy_decision_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(sess_rules_local_map, sess_rules) {
         cJSON *localMapObject = sess_rules_local_map;
-        if (!cJSON_IsObject(sess_rules_local_map)) {
+        if (cJSON_IsObject(sess_rules_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_session_rule_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(sess_rules_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_decision_parseFromJSON() failed [sess_rules]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_session_rule_parseFromJSON(localMapObject));
         OpenAPI_list_add(sess_rulesList , localMapKeyPair);
     }
     }
@@ -616,12 +639,15 @@ OpenAPI_sm_policy_decision_t *OpenAPI_sm_policy_decision_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pcc_rules_local_map, pcc_rules) {
         cJSON *localMapObject = pcc_rules_local_map;
-        if (!cJSON_IsObject(pcc_rules_local_map)) {
+        if (cJSON_IsObject(pcc_rules_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_pcc_rule_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pcc_rules_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_decision_parseFromJSON() failed [pcc_rules]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_pcc_rule_parseFromJSON(localMapObject));
         OpenAPI_list_add(pcc_rulesList , localMapKeyPair);
     }
     }
@@ -648,12 +674,15 @@ OpenAPI_sm_policy_decision_t *OpenAPI_sm_policy_decision_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(qos_decs_local_map, qos_decs) {
         cJSON *localMapObject = qos_decs_local_map;
-        if (!cJSON_IsObject(qos_decs_local_map)) {
+        if (cJSON_IsObject(qos_decs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_qos_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(qos_decs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_decision_parseFromJSON() failed [qos_decs]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_qos_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(qos_decsList , localMapKeyPair);
     }
     }
@@ -671,12 +700,15 @@ OpenAPI_sm_policy_decision_t *OpenAPI_sm_policy_decision_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(chg_decs_local_map, chg_decs) {
         cJSON *localMapObject = chg_decs_local_map;
-        if (!cJSON_IsObject(chg_decs_local_map)) {
+        if (cJSON_IsObject(chg_decs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_charging_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(chg_decs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_decision_parseFromJSON() failed [chg_decs]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_charging_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(chg_decsList , localMapKeyPair);
     }
     }
@@ -701,12 +733,15 @@ OpenAPI_sm_policy_decision_t *OpenAPI_sm_policy_decision_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(traff_cont_decs_local_map, traff_cont_decs) {
         cJSON *localMapObject = traff_cont_decs_local_map;
-        if (!cJSON_IsObject(traff_cont_decs_local_map)) {
+        if (cJSON_IsObject(traff_cont_decs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_traffic_control_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(traff_cont_decs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_decision_parseFromJSON() failed [traff_cont_decs]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_traffic_control_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(traff_cont_decsList , localMapKeyPair);
     }
     }
@@ -724,12 +759,15 @@ OpenAPI_sm_policy_decision_t *OpenAPI_sm_policy_decision_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(um_decs_local_map, um_decs) {
         cJSON *localMapObject = um_decs_local_map;
-        if (!cJSON_IsObject(um_decs_local_map)) {
+        if (cJSON_IsObject(um_decs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_usage_monitoring_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(um_decs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_decision_parseFromJSON() failed [um_decs]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_usage_monitoring_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(um_decsList , localMapKeyPair);
     }
     }
@@ -747,12 +785,15 @@ OpenAPI_sm_policy_decision_t *OpenAPI_sm_policy_decision_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(qos_chars_local_map, qos_chars) {
         cJSON *localMapObject = qos_chars_local_map;
-        if (!cJSON_IsObject(qos_chars_local_map)) {
+        if (cJSON_IsObject(qos_chars_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_qos_characteristics_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(qos_chars_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_decision_parseFromJSON() failed [qos_chars]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_qos_characteristics_parseFromJSON(localMapObject));
         OpenAPI_list_add(qos_charsList , localMapKeyPair);
     }
     }
@@ -770,12 +811,15 @@ OpenAPI_sm_policy_decision_t *OpenAPI_sm_policy_decision_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(qos_mon_decs_local_map, qos_mon_decs) {
         cJSON *localMapObject = qos_mon_decs_local_map;
-        if (!cJSON_IsObject(qos_mon_decs_local_map)) {
+        if (cJSON_IsObject(qos_mon_decs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_qos_monitoring_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(qos_mon_decs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_decision_parseFromJSON() failed [qos_mon_decs]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_qos_monitoring_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(qos_mon_decsList , localMapKeyPair);
     }
     }
@@ -802,12 +846,15 @@ OpenAPI_sm_policy_decision_t *OpenAPI_sm_policy_decision_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(conds_local_map, conds) {
         cJSON *localMapObject = conds_local_map;
-        if (!cJSON_IsObject(conds_local_map)) {
+        if (cJSON_IsObject(conds_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_condition_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(conds_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_decision_parseFromJSON() failed [conds]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_condition_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(condsList , localMapKeyPair);
     }
     }
@@ -904,12 +951,15 @@ OpenAPI_sm_policy_decision_t *OpenAPI_sm_policy_decision_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pra_infos_local_map, pra_infos) {
         cJSON *localMapObject = pra_infos_local_map;
-        if (!cJSON_IsObject(pra_infos_local_map)) {
+        if (cJSON_IsObject(pra_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_presence_info_rm_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pra_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_decision_parseFromJSON() failed [pra_infos]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_presence_info_rm_parseFromJSON(localMapObject));
         OpenAPI_list_add(pra_infosList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/sm_policy_dnn_data.c

@@ -247,7 +247,9 @@ cJSON *OpenAPI_sm_policy_dnn_data_convertToJSON(OpenAPI_sm_policy_dnn_data_t *sm
     if (sm_policy_dnn_data->ref_um_data_limit_ids) {
         OpenAPI_list_for_each(sm_policy_dnn_data->ref_um_data_limit_ids, ref_um_data_limit_ids_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)ref_um_data_limit_ids_node->data;
-        cJSON *itemLocal = OpenAPI_limit_id_to_monitoring_key_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_limit_id_to_monitoring_key_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_dnn_data_convertToJSON() failed [ref_um_data_limit_ids]");
             goto end;
@@ -303,7 +305,9 @@ cJSON *OpenAPI_sm_policy_dnn_data_convertToJSON(OpenAPI_sm_policy_dnn_data_t *sm
     if (sm_policy_dnn_data->pra_infos) {
         OpenAPI_list_for_each(sm_policy_dnn_data->pra_infos, pra_infos_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pra_infos_node->data;
-        cJSON *itemLocal = OpenAPI_presence_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_presence_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_dnn_data_convertToJSON() failed [pra_infos]");
             goto end;
@@ -485,12 +489,15 @@ OpenAPI_sm_policy_dnn_data_t *OpenAPI_sm_policy_dnn_data_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(ref_um_data_limit_ids_local_map, ref_um_data_limit_ids) {
         cJSON *localMapObject = ref_um_data_limit_ids_local_map;
-        if (!cJSON_IsObject(ref_um_data_limit_ids_local_map)) {
+        if (cJSON_IsObject(ref_um_data_limit_ids_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_limit_id_to_monitoring_key_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(ref_um_data_limit_ids_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_dnn_data_parseFromJSON() failed [ref_um_data_limit_ids]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_limit_id_to_monitoring_key_parseFromJSON(localMapObject));
         OpenAPI_list_add(ref_um_data_limit_idsList , localMapKeyPair);
     }
     }
@@ -553,12 +560,15 @@ OpenAPI_sm_policy_dnn_data_t *OpenAPI_sm_policy_dnn_data_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pra_infos_local_map, pra_infos) {
         cJSON *localMapObject = pra_infos_local_map;
-        if (!cJSON_IsObject(pra_infos_local_map)) {
+        if (cJSON_IsObject(pra_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pra_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_dnn_data_parseFromJSON() failed [pra_infos]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(pra_infosList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/sm_policy_snssai_data.c

@@ -67,7 +67,9 @@ cJSON *OpenAPI_sm_policy_snssai_data_convertToJSON(OpenAPI_sm_policy_snssai_data
     if (sm_policy_snssai_data->sm_policy_dnn_data) {
         OpenAPI_list_for_each(sm_policy_snssai_data->sm_policy_dnn_data, sm_policy_dnn_data_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)sm_policy_dnn_data_node->data;
-        cJSON *itemLocal = OpenAPI_sm_policy_dnn_data_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_sm_policy_dnn_data_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_snssai_data_convertToJSON() failed [sm_policy_dnn_data]");
             goto end;
@@ -106,12 +108,15 @@ OpenAPI_sm_policy_snssai_data_t *OpenAPI_sm_policy_snssai_data_parseFromJSON(cJS
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(sm_policy_dnn_data_local_map, sm_policy_dnn_data) {
         cJSON *localMapObject = sm_policy_dnn_data_local_map;
-        if (!cJSON_IsObject(sm_policy_dnn_data_local_map)) {
+        if (cJSON_IsObject(sm_policy_dnn_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_sm_policy_dnn_data_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(sm_policy_dnn_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_snssai_data_parseFromJSON() failed [sm_policy_dnn_data]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_sm_policy_dnn_data_parseFromJSON(localMapObject));
         OpenAPI_list_add(sm_policy_dnn_dataList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/sm_policy_snssai_data_patch.c

@@ -67,7 +67,9 @@ cJSON *OpenAPI_sm_policy_snssai_data_patch_convertToJSON(OpenAPI_sm_policy_snssa
     if (sm_policy_snssai_data_patch->sm_policy_dnn_data) {
         OpenAPI_list_for_each(sm_policy_snssai_data_patch->sm_policy_dnn_data, sm_policy_dnn_data_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)sm_policy_dnn_data_node->data;
-        cJSON *itemLocal = OpenAPI_sm_policy_dnn_data_patch_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_sm_policy_dnn_data_patch_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_snssai_data_patch_convertToJSON() failed [sm_policy_dnn_data]");
             goto end;
@@ -106,12 +108,15 @@ OpenAPI_sm_policy_snssai_data_patch_t *OpenAPI_sm_policy_snssai_data_patch_parse
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(sm_policy_dnn_data_local_map, sm_policy_dnn_data) {
         cJSON *localMapObject = sm_policy_dnn_data_local_map;
-        if (!cJSON_IsObject(sm_policy_dnn_data_local_map)) {
+        if (cJSON_IsObject(sm_policy_dnn_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_sm_policy_dnn_data_patch_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(sm_policy_dnn_data_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_snssai_data_patch_parseFromJSON() failed [sm_policy_dnn_data]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_sm_policy_dnn_data_patch_parseFromJSON(localMapObject));
         OpenAPI_list_add(sm_policy_dnn_dataList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/sm_policy_update_context_data.c

@@ -589,7 +589,9 @@ cJSON *OpenAPI_sm_policy_update_context_data_convertToJSON(OpenAPI_sm_policy_upd
     if (sm_policy_update_context_data->rep_pra_infos) {
         OpenAPI_list_for_each(sm_policy_update_context_data->rep_pra_infos, rep_pra_infos_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)rep_pra_infos_node->data;
-        cJSON *itemLocal = OpenAPI_presence_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_presence_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_sm_policy_update_context_data_convertToJSON() failed [rep_pra_infos]");
             goto end;
@@ -1231,12 +1233,15 @@ OpenAPI_sm_policy_update_context_data_t *OpenAPI_sm_policy_update_context_data_p
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(rep_pra_infos_local_map, rep_pra_infos) {
         cJSON *localMapObject = rep_pra_infos_local_map;
-        if (!cJSON_IsObject(rep_pra_infos_local_map)) {
+        if (cJSON_IsObject(rep_pra_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(rep_pra_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_sm_policy_update_context_data_parseFromJSON() failed [rep_pra_infos]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(rep_pra_infosList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/smf_selection_data.c

@@ -73,7 +73,9 @@ cJSON *OpenAPI_smf_selection_data_convertToJSON(OpenAPI_smf_selection_data_t *sm
     if (smf_selection_data->candidates) {
         OpenAPI_list_for_each(smf_selection_data->candidates, candidates_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)candidates_node->data;
-        cJSON *itemLocal = OpenAPI_candidate_for_replacement_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_candidate_for_replacement_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_smf_selection_data_convertToJSON() failed [candidates]");
             goto end;
@@ -145,12 +147,15 @@ OpenAPI_smf_selection_data_t *OpenAPI_smf_selection_data_parseFromJSON(cJSON *sm
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(candidates_local_map, candidates) {
         cJSON *localMapObject = candidates_local_map;
-        if (!cJSON_IsObject(candidates_local_map)) {
+        if (cJSON_IsObject(candidates_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_candidate_for_replacement_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(candidates_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_smf_selection_data_parseFromJSON() failed [candidates]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_candidate_for_replacement_parseFromJSON(localMapObject));
         OpenAPI_list_add(candidatesList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/smf_selection_subscription_data.c

@@ -66,7 +66,9 @@ cJSON *OpenAPI_smf_selection_subscription_data_convertToJSON(OpenAPI_smf_selecti
     if (smf_selection_subscription_data->subscribed_snssai_infos) {
         OpenAPI_list_for_each(smf_selection_subscription_data->subscribed_snssai_infos, subscribed_snssai_infos_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)subscribed_snssai_infos_node->data;
-        cJSON *itemLocal = OpenAPI_snssai_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_snssai_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_smf_selection_subscription_data_convertToJSON() failed [subscribed_snssai_infos]");
             goto end;
@@ -112,12 +114,15 @@ OpenAPI_smf_selection_subscription_data_t *OpenAPI_smf_selection_subscription_da
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(subscribed_snssai_infos_local_map, subscribed_snssai_infos) {
         cJSON *localMapObject = subscribed_snssai_infos_local_map;
-        if (!cJSON_IsObject(subscribed_snssai_infos_local_map)) {
+        if (cJSON_IsObject(subscribed_snssai_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_snssai_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(subscribed_snssai_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_smf_selection_subscription_data_parseFromJSON() failed [subscribed_snssai_infos]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_snssai_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(subscribed_snssai_infosList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/smf_selection_subscription_data_1.c

@@ -66,7 +66,9 @@ cJSON *OpenAPI_smf_selection_subscription_data_1_convertToJSON(OpenAPI_smf_selec
     if (smf_selection_subscription_data_1->subscribed_snssai_infos) {
         OpenAPI_list_for_each(smf_selection_subscription_data_1->subscribed_snssai_infos, subscribed_snssai_infos_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)subscribed_snssai_infos_node->data;
-        cJSON *itemLocal = OpenAPI_snssai_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_snssai_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_smf_selection_subscription_data_1_convertToJSON() failed [subscribed_snssai_infos]");
             goto end;
@@ -112,12 +114,15 @@ OpenAPI_smf_selection_subscription_data_1_t *OpenAPI_smf_selection_subscription_
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(subscribed_snssai_infos_local_map, subscribed_snssai_infos) {
         cJSON *localMapObject = subscribed_snssai_infos_local_map;
-        if (!cJSON_IsObject(subscribed_snssai_infos_local_map)) {
+        if (cJSON_IsObject(subscribed_snssai_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_snssai_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(subscribed_snssai_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_smf_selection_subscription_data_1_parseFromJSON() failed [subscribed_snssai_infos]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_snssai_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(subscribed_snssai_infosList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/spatial_validity.c

@@ -52,7 +52,9 @@ cJSON *OpenAPI_spatial_validity_convertToJSON(OpenAPI_spatial_validity_t *spatia
     if (spatial_validity->presence_info_list) {
         OpenAPI_list_for_each(spatial_validity->presence_info_list, presence_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)presence_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_presence_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_presence_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_spatial_validity_convertToJSON() failed [presence_info_list]");
             goto end;
@@ -84,12 +86,15 @@ OpenAPI_spatial_validity_t *OpenAPI_spatial_validity_parseFromJSON(cJSON *spatia
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(presence_info_list_local_map, presence_info_list) {
         cJSON *localMapObject = presence_info_list_local_map;
-        if (!cJSON_IsObject(presence_info_list_local_map)) {
+        if (cJSON_IsObject(presence_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(presence_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_spatial_validity_parseFromJSON() failed [presence_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(presence_info_listList , localMapKeyPair);
     }
 

lib/sbi/openapi/model/spatial_validity_rm.c

@@ -52,7 +52,9 @@ cJSON *OpenAPI_spatial_validity_rm_convertToJSON(OpenAPI_spatial_validity_rm_t *
     if (spatial_validity_rm->presence_info_list) {
         OpenAPI_list_for_each(spatial_validity_rm->presence_info_list, presence_info_list_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)presence_info_list_node->data;
-        cJSON *itemLocal = OpenAPI_presence_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_presence_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_spatial_validity_rm_convertToJSON() failed [presence_info_list]");
             goto end;
@@ -84,12 +86,15 @@ OpenAPI_spatial_validity_rm_t *OpenAPI_spatial_validity_rm_parseFromJSON(cJSON *
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(presence_info_list_local_map, presence_info_list) {
         cJSON *localMapObject = presence_info_list_local_map;
-        if (!cJSON_IsObject(presence_info_list_local_map)) {
+        if (cJSON_IsObject(presence_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(presence_info_list_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_spatial_validity_rm_parseFromJSON() failed [presence_info_list]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(presence_info_listList , localMapKeyPair);
     }
 

lib/sbi/openapi/model/ue_context_in_smf_data.c

@@ -62,7 +62,9 @@ cJSON *OpenAPI_ue_context_in_smf_data_convertToJSON(OpenAPI_ue_context_in_smf_da
     if (ue_context_in_smf_data->pdu_sessions) {
         OpenAPI_list_for_each(ue_context_in_smf_data->pdu_sessions, pdu_sessions_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pdu_sessions_node->data;
-        cJSON *itemLocal = OpenAPI_pdu_session_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_pdu_session_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_ue_context_in_smf_data_convertToJSON() failed [pdu_sessions]");
             goto end;
@@ -125,12 +127,15 @@ OpenAPI_ue_context_in_smf_data_t *OpenAPI_ue_context_in_smf_data_parseFromJSON(c
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pdu_sessions_local_map, pdu_sessions) {
         cJSON *localMapObject = pdu_sessions_local_map;
-        if (!cJSON_IsObject(pdu_sessions_local_map)) {
+        if (cJSON_IsObject(pdu_sessions_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_pdu_session_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pdu_sessions_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_ue_context_in_smf_data_parseFromJSON() failed [pdu_sessions]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_pdu_session_parseFromJSON(localMapObject));
         OpenAPI_list_add(pdu_sessionsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/ue_context_in_smf_data_1.c

@@ -62,7 +62,9 @@ cJSON *OpenAPI_ue_context_in_smf_data_1_convertToJSON(OpenAPI_ue_context_in_smf_
     if (ue_context_in_smf_data_1->pdu_sessions) {
         OpenAPI_list_for_each(ue_context_in_smf_data_1->pdu_sessions, pdu_sessions_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pdu_sessions_node->data;
-        cJSON *itemLocal = OpenAPI_pdu_session_1_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_pdu_session_1_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_ue_context_in_smf_data_1_convertToJSON() failed [pdu_sessions]");
             goto end;
@@ -125,12 +127,15 @@ OpenAPI_ue_context_in_smf_data_1_t *OpenAPI_ue_context_in_smf_data_1_parseFromJS
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pdu_sessions_local_map, pdu_sessions) {
         cJSON *localMapObject = pdu_sessions_local_map;
-        if (!cJSON_IsObject(pdu_sessions_local_map)) {
+        if (cJSON_IsObject(pdu_sessions_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_pdu_session_1_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pdu_sessions_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_ue_context_in_smf_data_1_parseFromJSON() failed [pdu_sessions]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_pdu_session_1_parseFromJSON(localMapObject));
         OpenAPI_list_add(pdu_sessionsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/ue_policy_set.c

@@ -97,7 +97,9 @@ cJSON *OpenAPI_ue_policy_set_convertToJSON(OpenAPI_ue_policy_set_t *ue_policy_se
     if (ue_policy_set->pra_infos) {
         OpenAPI_list_for_each(ue_policy_set->pra_infos, pra_infos_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)pra_infos_node->data;
-        cJSON *itemLocal = OpenAPI_presence_info_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_presence_info_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_ue_policy_set_convertToJSON() failed [pra_infos]");
             goto end;
@@ -134,7 +136,9 @@ cJSON *OpenAPI_ue_policy_set_convertToJSON(OpenAPI_ue_policy_set_t *ue_policy_se
     if (ue_policy_set->ue_policy_sections) {
         OpenAPI_list_for_each(ue_policy_set->ue_policy_sections, ue_policy_sections_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)ue_policy_sections_node->data;
-        cJSON *itemLocal = OpenAPI_ue_policy_section_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_ue_policy_section_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_ue_policy_set_convertToJSON() failed [ue_policy_sections]");
             goto end;
@@ -171,7 +175,9 @@ cJSON *OpenAPI_ue_policy_set_convertToJSON(OpenAPI_ue_policy_set_t *ue_policy_se
     if (ue_policy_set->allowed_route_sel_descs) {
         OpenAPI_list_for_each(ue_policy_set->allowed_route_sel_descs, allowed_route_sel_descs_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)allowed_route_sel_descs_node->data;
-        cJSON *itemLocal = OpenAPI_plmn_route_selection_descriptor_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_plmn_route_selection_descriptor_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_ue_policy_set_convertToJSON() failed [allowed_route_sel_descs]");
             goto end;
@@ -238,12 +244,15 @@ OpenAPI_ue_policy_set_t *OpenAPI_ue_policy_set_parseFromJSON(cJSON *ue_policy_se
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(pra_infos_local_map, pra_infos) {
         cJSON *localMapObject = pra_infos_local_map;
-        if (!cJSON_IsObject(pra_infos_local_map)) {
+        if (cJSON_IsObject(pra_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(pra_infos_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_ue_policy_set_parseFromJSON() failed [pra_infos]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_presence_info_parseFromJSON(localMapObject));
         OpenAPI_list_add(pra_infosList , localMapKeyPair);
     }
     }
@@ -281,12 +290,15 @@ OpenAPI_ue_policy_set_t *OpenAPI_ue_policy_set_parseFromJSON(cJSON *ue_policy_se
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(ue_policy_sections_local_map, ue_policy_sections) {
         cJSON *localMapObject = ue_policy_sections_local_map;
-        if (!cJSON_IsObject(ue_policy_sections_local_map)) {
+        if (cJSON_IsObject(ue_policy_sections_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_ue_policy_section_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(ue_policy_sections_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_ue_policy_set_parseFromJSON() failed [ue_policy_sections]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_ue_policy_section_parseFromJSON(localMapObject));
         OpenAPI_list_add(ue_policy_sectionsList , localMapKeyPair);
     }
     }
@@ -324,12 +336,15 @@ OpenAPI_ue_policy_set_t *OpenAPI_ue_policy_set_parseFromJSON(cJSON *ue_policy_se
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(allowed_route_sel_descs_local_map, allowed_route_sel_descs) {
         cJSON *localMapObject = allowed_route_sel_descs_local_map;
-        if (!cJSON_IsObject(allowed_route_sel_descs_local_map)) {
+        if (cJSON_IsObject(allowed_route_sel_descs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_plmn_route_selection_descriptor_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(allowed_route_sel_descs_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_ue_policy_set_parseFromJSON() failed [allowed_route_sel_descs]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_plmn_route_selection_descriptor_parseFromJSON(localMapObject));
         OpenAPI_list_add(allowed_route_sel_descsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/ue_policy_set_patch.c

@@ -72,7 +72,9 @@ cJSON *OpenAPI_ue_policy_set_patch_convertToJSON(OpenAPI_ue_policy_set_patch_t *
     if (ue_policy_set_patch->ue_policy_sections) {
         OpenAPI_list_for_each(ue_policy_set_patch->ue_policy_sections, ue_policy_sections_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)ue_policy_sections_node->data;
-        cJSON *itemLocal = OpenAPI_ue_policy_section_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_ue_policy_section_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_ue_policy_set_patch_convertToJSON() failed [ue_policy_sections]");
             goto end;
@@ -148,12 +150,15 @@ OpenAPI_ue_policy_set_patch_t *OpenAPI_ue_policy_set_patch_parseFromJSON(cJSON *
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(ue_policy_sections_local_map, ue_policy_sections) {
         cJSON *localMapObject = ue_policy_sections_local_map;
-        if (!cJSON_IsObject(ue_policy_sections_local_map)) {
+        if (cJSON_IsObject(ue_policy_sections_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_ue_policy_section_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(ue_policy_sections_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_ue_policy_set_patch_parseFromJSON() failed [ue_policy_sections]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_ue_policy_section_parseFromJSON(localMapObject));
         OpenAPI_list_add(ue_policy_sectionsList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/usage_mon_data.c

@@ -73,7 +73,9 @@ cJSON *OpenAPI_usage_mon_data_convertToJSON(OpenAPI_usage_mon_data_t *usage_mon_
     if (usage_mon_data->scopes) {
         OpenAPI_list_for_each(usage_mon_data->scopes, scopes_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)scopes_node->data;
-        cJSON *itemLocal = OpenAPI_usage_mon_data_scope_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_usage_mon_data_scope_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_usage_mon_data_convertToJSON() failed [scopes]");
             goto end;
@@ -160,12 +162,15 @@ OpenAPI_usage_mon_data_t *OpenAPI_usage_mon_data_parseFromJSON(cJSON *usage_mon_
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(scopes_local_map, scopes) {
         cJSON *localMapObject = scopes_local_map;
-        if (!cJSON_IsObject(scopes_local_map)) {
+        if (cJSON_IsObject(scopes_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_usage_mon_data_scope_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(scopes_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_usage_mon_data_parseFromJSON() failed [scopes]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_usage_mon_data_scope_parseFromJSON(localMapObject));
         OpenAPI_list_add(scopesList , localMapKeyPair);
     }
     }

lib/sbi/openapi/model/usage_mon_data_limit.c

@@ -76,7 +76,9 @@ cJSON *OpenAPI_usage_mon_data_limit_convertToJSON(OpenAPI_usage_mon_data_limit_t
     if (usage_mon_data_limit->scopes) {
         OpenAPI_list_for_each(usage_mon_data_limit->scopes, scopes_node) {
             OpenAPI_map_t *localKeyValue = (OpenAPI_map_t*)scopes_node->data;
-        cJSON *itemLocal = OpenAPI_usage_mon_data_scope_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_usage_mon_data_scope_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_usage_mon_data_limit_convertToJSON() failed [scopes]");
             goto end;
@@ -164,12 +166,15 @@ OpenAPI_usage_mon_data_limit_t *OpenAPI_usage_mon_data_limit_parseFromJSON(cJSON
     OpenAPI_map_t *localMapKeyPair = NULL;
     cJSON_ArrayForEach(scopes_local_map, scopes) {
         cJSON *localMapObject = scopes_local_map;
-        if (!cJSON_IsObject(scopes_local_map)) {
+        if (cJSON_IsObject(scopes_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_usage_mon_data_scope_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull(scopes_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_usage_mon_data_limit_parseFromJSON() failed [scopes]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_usage_mon_data_scope_parseFromJSON(localMapObject));
         OpenAPI_list_add(scopesList , localMapKeyPair);
     }
     }

lib/sbi/support/20210629/openapi-generator/templates/model-body.mustache

@@ -505,7 +505,9 @@ cJSON *OpenAPI_{{classname}}_convertToJSON(OpenAPI_{{classname}}_t *{{classname}
                 {{/isBoolean}}
             {{/isPrimitiveType}}
             {{^isPrimitiveType}}
-        cJSON *itemLocal = OpenAPI_{{complexType}}_convertToJSON(localKeyValue->value);
+        cJSON *itemLocal = localKeyValue->value ?
+            OpenAPI_{{complexType}}_convertToJSON(localKeyValue->value) :
+            cJSON_CreateNull();
         if (itemLocal == NULL) {
             ogs_error("OpenAPI_{{classname}}_convertToJSON() failed [{{{name}}}]");
             goto end;
@@ -798,12 +800,15 @@ OpenAPI_{{classname}}_t *OpenAPI_{{classname}}_parseFromJSON(cJSON *{{classname}
                     {{/isNumeric}}
                 {{/isPrimitiveType}}
                 {{^isPrimitiveType}}
-        if (!cJSON_IsObject({{{name}}}_local_map)) {
+        if (cJSON_IsObject({{{name}}}_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(
+                localMapObject->string, OpenAPI_{{complexType}}_parseFromJSON(localMapObject));
+        } else if (cJSON_IsNull({{{name}}}_local_map)) {
+            localMapKeyPair = OpenAPI_map_create(localMapObject->string, NULL);
+        } else {
             ogs_error("OpenAPI_{{classname}}_parseFromJSON() failed [{{{name}}}]");
             goto end;
         }
-        localMapKeyPair = OpenAPI_map_create(
-            localMapObject->string, OpenAPI_{{complexType}}_parseFromJSON(localMapObject));
                 {{/isPrimitiveType}}
         OpenAPI_list_add({{{name}}}List , localMapKeyPair);
     }

lib/sbi/support/20210629/openapitools.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "node_modules/@openapitools/openapi-generator-cli/config.schema.json",
+  "spaces": 2,
+  "generator-cli": {
+    "version": "5.2.0"
+  }
+}

src/amf/context.c

@@ -1206,6 +1206,9 @@ void amf_ue_remove(amf_ue_t *amf_ue)
     /* Clear N2 Transfer */
     AMF_UE_CLEAR_N2_TRANSFER(amf_ue, pdu_session_resource_setup_request);
 
+    /* Clear 5GSM Message */
+    AMF_UE_CLEAR_5GSM_MESSAGE(amf_ue);
+
     /* Remove all session context */
     amf_sess_remove_all(amf_ue);
 
@@ -1677,6 +1680,7 @@ void amf_sess_remove(amf_sess_t *sess)
         ogs_pkbuf_free(sess->pdu_session_establishment_accept);
 
     AMF_SESS_CLEAR_N2_TRANSFER(sess, pdu_session_resource_setup_request);
+    AMF_SESS_CLEAR_N2_TRANSFER(sess, pdu_session_resource_modification_command);
     AMF_SESS_CLEAR_N2_TRANSFER(sess, path_switch_request_ack);
     AMF_SESS_CLEAR_N2_TRANSFER(sess, handover_request);
     AMF_SESS_CLEAR_N2_TRANSFER(sess, handover_command);
@@ -1827,6 +1831,33 @@ bool amf_handover_request_transfer_needed(amf_ue_t *amf_ue)
     return false;
 }
 
+bool amf_paging_ongoing(amf_ue_t *amf_ue)
+{
+    amf_sess_t *sess = NULL;
+
+    ogs_assert(amf_ue);
+
+    ogs_list_for_each(&amf_ue->sess_list, sess) {
+        if (sess->paging.ongoing == true)
+            return true;
+    }
+
+    return false;
+}
+
+bool amf_downlink_signalling_pending(amf_ue_t *amf_ue)
+{
+    amf_sess_t *sess = NULL;
+
+    ogs_assert(amf_ue);
+
+    ogs_list_for_each(&amf_ue->sess_list, sess)
+        if (sess->gsm_message.type)
+            return true;
+
+    return false;
+}
+
 int amf_find_served_tai(ogs_5gs_tai_t *nr_tai)
 {
     int i = 0, j = 0, k = 0;

src/amf/context.h

@@ -459,6 +459,7 @@ typedef struct amf_sess_s {
 
     struct {
         ogs_pkbuf_t *pdu_session_resource_setup_request;
+        ogs_pkbuf_t *pdu_session_resource_modification_command;
         ogs_pkbuf_t *path_switch_request_ack;
         ogs_pkbuf_t *handover_request;
         ogs_pkbuf_t *handover_command;
@@ -467,13 +468,13 @@ typedef struct amf_sess_s {
     do { \
         ogs_assert(__sESS); \
         ogs_assert((__sESS)->amf_ue); \
-        if (sess->transfer.__n2Type) { \
+        if ((__sESS)->transfer.__n2Type) { \
             ogs_warn("[%s:%d] N2 transfer message duplicated. Overwritten", \
-                    ((__sESS)->amf_ue)->supi, sess->psi); \
-            ogs_pkbuf_free(sess->transfer.__n2Type); \
+                    ((__sESS)->amf_ue)->supi, (__sESS)->psi); \
+            ogs_pkbuf_free((__sESS)->transfer.__n2Type); \
         } \
-        sess->transfer.__n2Type = __n2Buf; \
-        ogs_assert(sess->transfer.__n2Type); \
+        (__sESS)->transfer.__n2Type = __n2Buf; \
+        ogs_assert((__sESS)->transfer.__n2Type); \
     } while(0);
 
 #define AMF_SESS_CLEAR_N2_TRANSFER(__sESS, __n2Type) \
@@ -505,13 +506,14 @@ typedef struct amf_sess_s {
     do { \
         ogs_assert(__sESS); \
         ogs_assert(__lOCATION); \
-        ogs_assert(__uRI); \
         AMF_SESS_CLEAR_PAGING_INFO(__sESS) \
         (__sESS)->paging.ongoing = true; \
         ((__sESS)->paging.location) = ogs_strdup(__lOCATION); \
         ogs_assert((__sESS)->paging.location); \
-        ((__sESS)->paging.n1n2_failure_txf_notif_uri) = ogs_strdup(__uRI); \
-        ogs_assert((__sESS)->paging.n1n2_failure_txf_notif_uri); \
+        if (__uRI) { \
+            ((__sESS)->paging.n1n2_failure_txf_notif_uri) = ogs_strdup(__uRI); \
+            ogs_assert((__sESS)->paging.n1n2_failure_txf_notif_uri); \
+        } \
     } while(0);
 #define AMF_SESS_CLEAR_PAGING_INFO(__sESS) \
     do { \
@@ -519,9 +521,10 @@ typedef struct amf_sess_s {
             ogs_assert((__sESS)->paging.location); \
             ogs_free((__sESS)->paging.location); \
             ((__sESS)->paging.location) = NULL; \
-            ogs_assert((__sESS)->paging.n1n2_failure_txf_notif_uri); \
-            ogs_free((__sESS)->paging.n1n2_failure_txf_notif_uri); \
-            ((__sESS)->paging.n1n2_failure_txf_notif_uri) = NULL; \
+            if ((__sESS)->paging.n1n2_failure_txf_notif_uri) { \
+                ogs_free((__sESS)->paging.n1n2_failure_txf_notif_uri); \
+                ((__sESS)->paging.n1n2_failure_txf_notif_uri) = NULL; \
+            } \
             ((__sESS)->paging.ongoing) = false; \
         } \
     } while(0);
@@ -533,6 +536,52 @@ typedef struct amf_sess_s {
         } \
     } while(0);
 
+    struct {
+        uint8_t type;
+        ogs_pkbuf_t *n1buf;
+        ogs_pkbuf_t *n2buf;
+    } gsm_message;
+
+#define AMF_SESS_STORE_5GSM_MESSAGE(__sESS, __tYPE, __n1Buf, __n2Buf) \
+    do { \
+        ogs_assert(__sESS); \
+        ogs_assert((__sESS)->amf_ue); \
+        if ((__sESS)->gsm_message.n1buf) { \
+            ogs_warn("[%s:%d] N1 message duplicated. Overwritten", \
+                    ((__sESS)->amf_ue)->supi, (__sESS)->psi); \
+            ogs_pkbuf_free((__sESS)->gsm_message.n1buf); \
+        } \
+        (__sESS)->gsm_message.n1buf = __n1Buf; \
+        ogs_assert((__sESS)->gsm_message.n1buf); \
+        if ((__sESS)->gsm_message.n2buf) { \
+            ogs_warn("[%s:%d] N2 message duplicated. Overwritten", \
+                    ((__sESS)->amf_ue)->supi, (__sESS)->psi); \
+            ogs_pkbuf_free((__sESS)->gsm_message.n2buf); \
+        } \
+        (__sESS)->gsm_message.n2buf = __n2Buf; \
+        ogs_assert((__sESS)->gsm_message.n2buf); \
+        (__sESS)->gsm_message.type = __tYPE; \
+    } while(0);
+
+#define AMF_SESS_CLEAR_5GSM_MESSAGE(__sESS) \
+    do { \
+        if ((__sESS)->gsm_message.n1buf) \
+            ogs_pkbuf_free((__sESS)->gsm_message.n1buf); \
+        (__sESS)->gsm_message.n1buf = NULL; \
+        if ((__sESS)->gsm_message.n2buf) \
+            ogs_pkbuf_free((__sESS)->gsm_message.n2buf); \
+        (__sESS)->gsm_message.n2buf = NULL; \
+        (__sESS)->gsm_message.type = 0; \
+    } while(0);
+
+#define AMF_UE_CLEAR_5GSM_MESSAGE(__aMF) \
+    do { \
+        amf_sess_t *sess = NULL; \
+        ogs_list_for_each(&((__aMF)->sess_list), sess) { \
+            AMF_SESS_CLEAR_5GSM_MESSAGE(sess) \
+        } \
+    } while(0);
+
     struct {
         char *nsi_id;
         struct {
@@ -691,6 +740,13 @@ bool amf_pdu_res_setup_req_transfer_needed(amf_ue_t *amf_ue);
     (amf_handover_request_transfer_needed(__aMF) == true)
 bool amf_handover_request_transfer_needed(amf_ue_t *amf_ue);
 
+#define PAGING_ONGOING(__aMF) \
+    (amf_paging_ongoing(__aMF) == true)
+bool amf_paging_ongoing(amf_ue_t *amf_ue);
+#define DOWNLINK_SIGNALLING_PENDING(__aMF) \
+    (amf_downlink_signalling_pending(__aMF) == true)
+bool amf_downlink_signalling_pending(amf_ue_t *amf_ue);
+
 int amf_find_served_tai(ogs_5gs_tai_t *nr_tai);
 ogs_s_nssai_t *amf_find_s_nssai(
         ogs_plmn_id_t *served_plmn_id, ogs_s_nssai_t *s_nssai);

src/amf/gmm-handler.c

@@ -201,6 +201,7 @@ int gmm_handle_registration_request(amf_ue_t *amf_ue,
      */
     AMF_UE_CLEAR_PAGING_INFO(amf_ue);
     AMF_UE_CLEAR_N2_TRANSFER(amf_ue, pdu_session_resource_setup_request);
+    AMF_UE_CLEAR_5GSM_MESSAGE(amf_ue);
     CLEAR_AMF_UE_ALL_TIMERS(amf_ue);
 
     if (SECURITY_CONTEXT_IS_VALID(amf_ue)) {
@@ -1101,10 +1102,46 @@ int gmm_handle_ul_nas_transport(amf_ue_t *amf_ue,
                     sess, AMF_UPDATE_SM_CONTEXT_N1_RELEASED, &param,
                     amf_nsmf_pdusession_build_update_sm_context));
 
-            if (gsm_header->message_type ==
-                    OGS_NAS_5GS_PDU_SESSION_RELEASE_COMPLETE) {
+            switch (gsm_header->message_type) {
+            case OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMPLETE:
+            case OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMMAND_REJECT:
+                if (PAGING_ONGOING(amf_ue) == true) {
+
+                    gmm_configuration_update_command_param_t param;
+                /*
+                 * TS24.501
+                 * 5.4.4 Generic UE configuration update procedure
+                 * 5.4.4.1 General
+                 *
+                 * This procedure shall be initiated by the network to assign
+                 * a new 5G-GUTI to the UE after a successful service request
+                 * procedure invoked as a response to a paging request
+                 * from the network and before the release
+                 * of the N1 NAS signalling connection.
+                 *
+                 * If the service request procedure was triggered
+                 * due to 5GSM downlink signalling pending, the procedure
+                 * for assigning a new 5G-GUTI can be initiated by the network
+                 * after the transport of the 5GSM downlink signalling.
+                 */
+                    amf_ue_new_guti(amf_ue);
+
+                    memset(&param, 0, sizeof(param));
+                    param.acknowledgement_requested = 1;
+                    param.guti = 1;
+                    ogs_assert(OGS_OK ==
+                        nas_5gs_send_configuration_update_command(
+                            amf_ue, &param));
+
+                    AMF_UE_CLEAR_PAGING_INFO(amf_ue);
+                }
+                break;
+            case OGS_NAS_5GS_PDU_SESSION_RELEASE_COMPLETE:
                 /* Prevent to invoke SMF for this session */
                 CLEAR_SM_CONTEXT_REF(sess);
+                break;
+            default:
+                break;
             }
         }
         break;

src/amf/gmm-handler.h

@@ -53,14 +53,6 @@ int gmm_handle_security_mode_complete(amf_ue_t *amf_ue,
 int gmm_handle_ul_nas_transport(amf_ue_t *amf_ue,
         ogs_nas_5gs_ul_nas_transport_t *ul_nas_transport);
 
-#if 0
-int gmm_handle_tau_request(amf_ue_t *amf_ue,
-        ogs_nas_5gs_tracking_area_update_request_t *tau_request);
-
-int gmm_handle_extended_service_request(amf_ue_t *amf_ue,
-        ogs_nas_5gs_extended_service_request_t *extended_service_request);
-#endif
-
 #ifdef __cplusplus
 }
 #endif

src/amf/gmm-sm.c

@@ -66,6 +66,7 @@ void gmm_state_de_registered(ogs_fsm_t *s, amf_event_t *e)
     case OGS_FSM_ENTRY_SIG:
         AMF_UE_CLEAR_PAGING_INFO(amf_ue);
         AMF_UE_CLEAR_N2_TRANSFER(amf_ue, pdu_session_resource_setup_request);
+        AMF_UE_CLEAR_5GSM_MESSAGE(amf_ue);
         CLEAR_AMF_UE_ALL_TIMERS(amf_ue);
         break;
     case OGS_FSM_EXIT_SIG:
@@ -367,7 +368,8 @@ static void common_register_state(ogs_fsm_t *s, amf_event_t *e)
                 ogs_warn("[%s] Paging failed. Stop", amf_ue->supi);
 
                 ogs_list_for_each(&amf_ue->sess_list, sess) {
-                    if (sess->paging.ongoing == true) {
+                    if (sess->paging.ongoing == true &&
+                        sess->paging.n1n2_failure_txf_notif_uri != NULL) {
                         ogs_assert(true ==
                             amf_sbi_send_n1_n2_failure_notify(
                                 sess,
@@ -382,6 +384,9 @@ static void common_register_state(ogs_fsm_t *s, amf_event_t *e)
                 AMF_UE_CLEAR_N2_TRANSFER(
                         amf_ue, pdu_session_resource_setup_request);
 
+                /* Clear 5GSM Message */
+                AMF_UE_CLEAR_5GSM_MESSAGE(amf_ue);
+
                 /* Clear t3513 Timers */
                 CLEAR_AMF_UE_TIMER(amf_ue->t3513);
 
@@ -1181,6 +1186,7 @@ void gmm_state_exception(ogs_fsm_t *s, amf_event_t *e)
     case OGS_FSM_ENTRY_SIG:
         AMF_UE_CLEAR_PAGING_INFO(amf_ue);
         AMF_UE_CLEAR_N2_TRANSFER(amf_ue, pdu_session_resource_setup_request);
+        AMF_UE_CLEAR_5GSM_MESSAGE(amf_ue);
         CLEAR_AMF_UE_ALL_TIMERS(amf_ue);
 
         amf_sbi_send_release_all_sessions(

src/amf/namf-handler.c

@@ -143,23 +143,6 @@ int amf_namf_comm_handle_n1_n2_message_transfer(
         ogs_assert(n2buf);
     }
 
-    switch (n2InfoContent->ngap_ie_type) {
-    case OpenAPI_ngap_ie_type_PDU_RES_SETUP_REQ:
-    case OpenAPI_ngap_ie_type_PDU_RES_MOD_REQ:
-    case OpenAPI_ngap_ie_type_PDU_RES_REL_CMD:
-        /* N1 SM Message */
-        if (n1buf) {
-            gmmbuf = gmm_build_dl_nas_transport(sess,
-                    OGS_NAS_PAYLOAD_CONTAINER_N1_SM_INFORMATION, n1buf, 0, 0);
-            ogs_assert(gmmbuf);
-        }
-        break;
-    default:
-        ogs_error("Not implemented ngap_ie_type[%d]",
-                n2InfoContent->ngap_ie_type);
-        return OGS_ERROR;
-    }
-
     memset(&sendmsg, 0, sizeof(sendmsg));
 
     status = OGS_SBI_HTTP_STATUS_OK;
@@ -177,6 +160,12 @@ int amf_namf_comm_handle_n1_n2_message_transfer(
             return OGS_ERROR;
         }
 
+        if (n1buf) {
+            gmmbuf = gmm_build_dl_nas_transport(sess,
+                    OGS_NAS_PAYLOAD_CONTAINER_N1_SM_INFORMATION, n1buf, 0, 0);
+            ogs_assert(gmmbuf);
+        }
+
         if (gmmbuf) {
             ran_ue_t *ran_ue = NULL;
 
@@ -301,7 +290,7 @@ int amf_namf_comm_handle_n1_n2_message_transfer(
         break;
 
     case OpenAPI_ngap_ie_type_PDU_RES_MOD_REQ:
-        if (!gmmbuf) {
+        if (!n1buf) {
             ogs_error("[%s] No N1 SM Content", amf_ue->supi);
             return OGS_ERROR;
         }
@@ -311,10 +300,45 @@ int amf_namf_comm_handle_n1_n2_message_transfer(
         }
 
         if (CM_IDLE(amf_ue)) {
-            ogs_fatal("[%s] IDLE state is not implemented", amf_ue->supi);
-            ogs_assert_if_reached();
+            ogs_sbi_server_t *server = NULL;
+            ogs_sbi_header_t header;
+
+            status = OGS_SBI_HTTP_STATUS_ACCEPTED;
+            N1N2MessageTransferRspData.cause =
+                OpenAPI_n1_n2_message_transfer_cause_ATTEMPTING_TO_REACH_UE;
+
+            /* Location */
+            server = ogs_sbi_server_from_stream(stream);
+            ogs_assert(server);
+
+            memset(&header, 0, sizeof(header));
+            header.service.name = (char *)OGS_SBI_SERVICE_NAME_NAMF_COMM;
+            header.api.version = (char *)OGS_SBI_API_V1;
+            header.resource.component[0] =
+                (char *)OGS_SBI_RESOURCE_NAME_UE_CONTEXTS;
+            header.resource.component[1] = amf_ue->supi;
+            header.resource.component[2] =
+                (char *)OGS_SBI_RESOURCE_NAME_N1_N2_MESSAGES;
+            header.resource.component[3] = sess->sm_context_ref;
+
+            sendmsg.http.location = ogs_sbi_server_uri(server, &header);
+
+            /* Store Paging Info */
+            AMF_SESS_STORE_PAGING_INFO(
+                    sess, sendmsg.http.location, NULL);
+
+            /* Store 5GSM Message */
+            AMF_SESS_STORE_5GSM_MESSAGE(sess,
+                    OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMMAND,
+                    n1buf, n2buf);
+
+            ogs_assert(OGS_OK == ngap_send_paging(amf_ue));
 
         } else if (CM_CONNECTED(amf_ue)) {
+            gmmbuf = gmm_build_dl_nas_transport(sess,
+                    OGS_NAS_PAYLOAD_CONTAINER_N1_SM_INFORMATION, n1buf, 0, 0);
+            ogs_assert(gmmbuf);
+
             ngapbuf = ngap_build_pdu_session_resource_modify_request(
                     sess, gmmbuf, n2buf);
             ogs_assert(ngapbuf);
@@ -335,9 +359,10 @@ int amf_namf_comm_handle_n1_n2_message_transfer(
             return OGS_ERROR;
         }
 
+        if (n1buf)
+            ogs_pkbuf_free(n1buf);
+
         if (CM_IDLE(amf_ue)) {
-            if (gmmbuf)
-                ogs_pkbuf_free(gmmbuf);
             if (n2buf)
                 ogs_pkbuf_free(n2buf);
 

src/amf/nas-path.c

@@ -416,6 +416,37 @@ int nas_5gs_send_configuration_update_command(
     return rv;
 }
 
+int nas_send_pdu_session_modification_command(amf_sess_t *sess,
+        ogs_pkbuf_t *n1smbuf, ogs_pkbuf_t *n2smbuf)
+{
+    int rv;
+
+    amf_ue_t *amf_ue = NULL;
+
+    ogs_pkbuf_t *gmmbuf = NULL;
+    ogs_pkbuf_t *ngapbuf = NULL;
+
+    ogs_assert(sess);
+    amf_ue = sess->amf_ue;
+    ogs_assert(amf_ue);
+    ogs_assert(n1smbuf);
+    ogs_assert(n2smbuf);
+
+    gmmbuf = gmm_build_dl_nas_transport(sess,
+            OGS_NAS_PAYLOAD_CONTAINER_N1_SM_INFORMATION, n1smbuf, 0, 0);
+    ogs_expect_or_return_val(gmmbuf, OGS_ERROR);
+
+    ngapbuf = ngap_build_pdu_session_resource_modify_request(
+            sess, gmmbuf, n2smbuf);
+    ogs_expect_or_return_val(ngapbuf, OGS_ERROR);
+
+    rv = nas_5gs_send_to_gnb(amf_ue, ngapbuf);
+    ogs_expect(rv == OGS_OK);
+
+    return rv;
+}
+
+
 int nas_send_pdu_session_release_command(amf_sess_t *sess,
         ogs_pkbuf_t *n1smbuf, ogs_pkbuf_t *n2smbuf)
 {

src/amf/nas-path.h

@@ -52,6 +52,9 @@ int nas_5gs_send_security_mode_command(amf_ue_t *amf_ue);
 int nas_5gs_send_configuration_update_command(
         amf_ue_t *amf_ue, gmm_configuration_update_command_param_t *param);
 
+int nas_send_pdu_session_modification_command(amf_sess_t *sess,
+        ogs_pkbuf_t *n1smbuf, ogs_pkbuf_t *n2smbuf);
+
 int nas_send_pdu_session_release_command(amf_sess_t *sess,
         ogs_pkbuf_t *n1smbuf, ogs_pkbuf_t *n2smbuf);
 

src/amf/ngap-handler.c

@@ -759,8 +759,6 @@ void ngap_handle_initial_context_setup_response(
     uint64_t amf_ue_ngap_id;
     amf_nsmf_pdusession_sm_context_param_t param;
 
-    bool paging_ongoing = false;
-
     NGAP_SuccessfulOutcome_t *successfulOutcome = NULL;
     NGAP_InitialContextSetupResponse_t *InitialContextSetupResponse = NULL;
 
@@ -913,14 +911,60 @@ void ngap_handle_initial_context_setup_response(
         ogs_pkbuf_free(param.n2smbuf);
     }
 
-    ogs_list_for_each(&amf_ue->sess_list, sess) {
-        if (sess->paging.ongoing == true) {
-            paging_ongoing = true;
-            break;
-        }
-    }
+    /*
+     * TS24.501
+     * 5.4.4 Generic UE configuration update procedure
+     * 5.4.4.1 General
+     *
+     * This procedure shall be initiated by the network to assign
+     * a new 5G-GUTI to the UE after a successful service request
+     * procedure invoked as a response to a paging request
+     * from the network and before the release of the N1 NAS signalling
+     * connection.
+     */
+    if (DOWNLINK_SIGNALLING_PENDING(amf_ue) == true) {
+        /*
+         * TS24.501
+         * 5.4.4 Generic UE configuration update procedure
+         * 5.4.4.1 General
+         *
+         * If the service request procedure was triggered
+         * due to 5GSM downlink signalling pending, the procedure
+         * for assigning a new 5G-GUTI can be initiated by the network
+         * after the transport of the 5GSM downlink signalling.
+         */
+        ogs_list_for_each(&amf_ue->sess_list, sess) {
+            ogs_pkbuf_t *ngapbuf = NULL;
+            ogs_pkbuf_t *gmmbuf = NULL;
 
-    if (paging_ongoing == true) {
+            /* There is no Downlink Signalling Pending in this sesssion */
+            if (sess->gsm_message.type == 0) continue;
+
+            switch (sess->gsm_message.type) {
+            case OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMMAND:
+                gmmbuf = gmm_build_dl_nas_transport(sess,
+                        OGS_NAS_PAYLOAD_CONTAINER_N1_SM_INFORMATION,
+                        sess->gsm_message.n1buf, 0, 0);
+                ogs_assert(gmmbuf);
+
+                ngapbuf = ngap_build_pdu_session_resource_modify_request(
+                        sess, gmmbuf, sess->gsm_message.n2buf);
+                ogs_assert(ngapbuf);
+
+                if (nas_5gs_send_to_gnb(amf_ue, ngapbuf) != OGS_OK) {
+                    ogs_error("nas_5gs_send_to_gnb() failed");
+                }
+
+                AMF_SESS_CLEAR_5GSM_MESSAGE(sess);
+
+                break;
+            default:
+                ogs_fatal("Unknown GSM Message Type[%d]",
+                        sess->gsm_message.type);
+                ogs_assert_if_reached();
+            }
+        }
+    } else if (PAGING_ONGOING(amf_ue) == true) {
         gmm_configuration_update_command_param_t param;
 
         /*
@@ -951,9 +995,9 @@ void ngap_handle_initial_context_setup_response(
         param.guti = 1;
         ogs_assert(OGS_OK ==
             nas_5gs_send_configuration_update_command(amf_ue, &param));
-    }
 
-    AMF_UE_CLEAR_PAGING_INFO(amf_ue);
+        AMF_UE_CLEAR_PAGING_INFO(amf_ue);
+    }
 }
 
 void ngap_handle_initial_context_setup_failure(

src/amf/nsmf-handler.c

@@ -255,6 +255,43 @@ int amf_nsmf_pdusession_handle_update_sm_context(
                 }
                 break;
 
+            case OpenAPI_n2_sm_info_type_PDU_RES_MOD_REQ:
+                if (!n1smbuf) {
+                    ogs_error("[%s:%d] No N1 SM Content [%s]",
+                            amf_ue->supi, sess->psi, n1SmMsg->content_id);
+                    ogs_assert(OGS_OK ==
+                        nas_5gs_send_back_gsm_message(sess,
+                            OGS_5GMM_CAUSE_PAYLOAD_WAS_NOT_FORWARDED,
+                            AMF_NAS_BACKOFF_TIME));
+                    return OGS_ERROR;
+                }
+
+                if (!n2smbuf) {
+                    ogs_error("[%s:%d] No N2 SM Content",
+                            amf_ue->supi, sess->psi);
+                    ogs_assert(OGS_OK ==
+                        nas_5gs_send_back_gsm_message(sess,
+                            OGS_5GMM_CAUSE_PAYLOAD_WAS_NOT_FORWARDED,
+                            AMF_NAS_BACKOFF_TIME));
+                    return OGS_ERROR;
+                }
+
+                /*
+                 * NOTE : The pkbuf created in the SBI message will be removed
+                 *        from ogs_sbi_message_free(), so it must be copied.
+                 */
+                n1smbuf = ogs_pkbuf_copy(n1smbuf);
+                ogs_assert(n1smbuf);
+
+                n2smbuf = ogs_pkbuf_copy(n2smbuf);
+                ogs_assert(n2smbuf);
+
+                ogs_assert(OGS_OK ==
+                    nas_send_pdu_session_modification_command(
+                        sess, n1smbuf, n2smbuf));
+                break;
+
+
             case OpenAPI_n2_sm_info_type_PDU_RES_REL_CMD:
                 if (!n1smbuf) {
                     ogs_error("[%s:%d] No N1 SM Content [%s]",

src/pcf/context.c

@@ -25,6 +25,7 @@ int __pcf_log_domain;
 
 static OGS_POOL(pcf_ue_pool, pcf_ue_t);
 static OGS_POOL(pcf_sess_pool, pcf_sess_t);
+static OGS_POOL(pcf_app_pool, pcf_app_t);
 
 static int context_initialized = 0;
 
@@ -43,6 +44,7 @@ void pcf_context_init(void)
 
     ogs_pool_init(&pcf_ue_pool, ogs_app()->max.ue);
     ogs_pool_init(&pcf_sess_pool, ogs_app()->pool.sess);
+    ogs_pool_init(&pcf_app_pool, ogs_app()->pool.sess);
 
     ogs_list_init(&self.pcf_ue_list);
 
@@ -69,6 +71,7 @@ void pcf_context_final(void)
     ogs_assert(self.ipv6prefix_hash);
     ogs_hash_destroy(self.ipv6prefix_hash);
 
+    ogs_pool_final(&pcf_app_pool);
     ogs_pool_final(&pcf_sess_pool);
     ogs_pool_final(&pcf_ue_pool);
 
@@ -238,6 +241,8 @@ pcf_sess_t *pcf_sess_add(pcf_ue_t *pcf_ue, uint8_t psi)
     ogs_assert(sess);
     memset(sess, 0, sizeof *sess);
 
+    ogs_list_init(&sess->app_list);
+
     /* SBI Type */
     sess->sbi.type = OGS_SBI_OBJ_SESS_TYPE;
 
@@ -257,10 +262,6 @@ pcf_sess_t *pcf_sess_add(pcf_ue_t *pcf_ue, uint8_t psi)
             (int)ogs_pool_index(&pcf_sess_pool, sess));
     ogs_assert(sess->sm_policy_id);
 
-    sess->app_session_id = ogs_msprintf("%d",
-            (int)ogs_pool_index(&pcf_sess_pool, sess));
-    ogs_assert(sess->app_session_id);
-
     sess->pcf_ue = pcf_ue;
     sess->psi = psi;
 
@@ -294,12 +295,11 @@ void pcf_sess_remove(pcf_sess_t *sess)
     /* Free SBI object memory */
     ogs_sbi_object_free(&sess->sbi);
 
+    pcf_app_remove_all(sess);
+
     ogs_assert(sess->sm_policy_id);
     ogs_free(sess->sm_policy_id);
 
-    ogs_assert(sess->app_session_id);
-    ogs_free(sess->app_session_id);
-
     if (sess->binding_id)
         ogs_free(sess->binding_id);
 
@@ -410,12 +410,6 @@ pcf_sess_t *pcf_sess_find_by_sm_policy_id(char *sm_policy_id)
     return pcf_sess_find(atoll(sm_policy_id));
 }
 
-pcf_sess_t *pcf_sess_find_by_app_session_id(char *app_session_id)
-{
-    ogs_assert(app_session_id);
-    return pcf_sess_find(atoll(app_session_id));
-}
-
 pcf_sess_t *pcf_sess_find_by_psi(pcf_ue_t *pcf_ue, uint8_t psi)
 {
     pcf_sess_t *sess = NULL;
@@ -511,3 +505,70 @@ void pcf_sess_select_nf(pcf_sess_t *sess, OpenAPI_nf_type_e nf_type)
     else
         ogs_sbi_select_first_nf(&sess->sbi, nf_type, pcf_nf_state_registered);
 }
+
+pcf_app_t *pcf_app_add(pcf_sess_t *sess)
+{
+    pcf_app_t *app = NULL;
+
+    ogs_assert(sess);
+
+    ogs_pool_alloc(&pcf_app_pool, &app);
+    ogs_assert(app);
+    memset(app, 0, sizeof *app);
+
+    app->app_session_id = ogs_msprintf("%d",
+            (int)ogs_pool_index(&pcf_app_pool, app));
+    ogs_assert(app->app_session_id);
+
+    app->sess = sess;
+
+    ogs_list_add(&sess->app_list, app);
+
+    return app;
+}
+
+int pcf_app_remove(pcf_app_t *app)
+{
+    int i;
+
+    ogs_assert(app);
+    ogs_assert(app->sess);
+
+    ogs_list_remove(&app->sess->app_list, app);
+
+    for (i = 0; i < app->num_of_pcc_rule; i++) {
+        OGS_PCC_RULE_FREE(&app->pcc_rule[i]);
+    }
+
+    if (app->notif_uri)
+        ogs_free(app->notif_uri);
+    if (app->naf.client)
+        ogs_sbi_client_remove(app->naf.client);
+
+    ogs_assert(app->app_session_id);
+    ogs_free(app->app_session_id);
+
+    ogs_pool_free(&pcf_app_pool, app);
+
+    return OGS_OK;
+}
+
+void pcf_app_remove_all(pcf_sess_t *sess)
+{
+    pcf_app_t *app = NULL, *next_app = NULL;
+
+    ogs_assert(sess);
+    ogs_list_for_each_safe(&sess->app_list, next_app, app)
+        pcf_app_remove(app);
+}
+
+pcf_app_t *pcf_app_find(uint32_t index)
+{
+    return ogs_pool_find(&pcf_app_pool, index);
+}
+
+pcf_app_t *pcf_app_find_by_app_session_id(char *app_session_id)
+{
+    ogs_assert(app_session_id);
+    return pcf_app_find(atoll(app_session_id));
+}

src/pcf/context.h

@@ -122,8 +122,6 @@ struct pcf_sess_s {
         uint8_t addr6[OGS_IPV6_LEN];
     } ipv6prefix;
 
-    char *app_session_id;
-
     ogs_s_nssai_t s_nssai;
 
     /* SBI Features */
@@ -134,10 +132,28 @@ struct pcf_sess_s {
     OpenAPI_ambr_t *subscribed_sess_ambr;
     OpenAPI_subscribed_default_qos_t *subscribed_default_qos;
 
+    ogs_list_t app_list;
+
     /* Related Context */
     pcf_ue_t *pcf_ue;
 };
 
+typedef struct pcf_app_s {
+    ogs_lnode_t lnode;
+
+    char *app_session_id;
+
+    char *notif_uri;
+    struct {
+        ogs_sbi_client_t *client;
+    } naf;
+
+    ogs_pcc_rule_t pcc_rule[OGS_MAX_NUM_OF_PCC_RULE];
+    int num_of_pcc_rule;
+
+    pcf_sess_t *sess;
+} pcf_app_t;
+
 void pcf_context_init(void);
 void pcf_context_final(void);
 pcf_context_t *pcf_self(void);
@@ -159,7 +175,6 @@ bool pcf_sess_set_ipv6prefix(pcf_sess_t *sess, char *ipv6prefix);
 
 pcf_sess_t *pcf_sess_find(uint32_t index);
 pcf_sess_t *pcf_sess_find_by_sm_policy_id(char *sm_policy_id);
-pcf_sess_t *pcf_sess_find_by_app_session_id(char *app_session_id);
 pcf_sess_t *pcf_sess_find_by_psi(pcf_ue_t *pcf_ue, uint8_t psi);
 pcf_sess_t *pcf_sess_find_by_dnn(pcf_ue_t *pcf_ue, char *dnn);
 pcf_sess_t *pcf_sess_find_by_ipv4addr(char *ipv4addr_string);
@@ -172,6 +187,12 @@ pcf_sess_t *pcf_sess_cycle(pcf_sess_t *sess);
 void pcf_ue_select_nf(pcf_ue_t *pcf_ue, OpenAPI_nf_type_e nf_type);
 void pcf_sess_select_nf(pcf_sess_t *sess, OpenAPI_nf_type_e nf_type);
 
+pcf_app_t *pcf_app_add(pcf_sess_t *sess);
+int pcf_app_remove(pcf_app_t *app);
+void pcf_app_remove_all(pcf_sess_t *sess);
+pcf_app_t *pcf_app_find(uint32_t index);
+pcf_app_t *pcf_app_find_by_app_session_id(char *app_session_id);
+
 #ifdef __cplusplus
 }
 #endif

src/pcf/event.h

@@ -34,6 +34,7 @@ typedef struct ogs_sbi_subscription_s ogs_sbi_subscription_t;
 
 typedef struct pcf_ue_s pcf_ue_t;
 typedef struct pcf_sess_s pcf_sess_t;
+typedef struct pcf_app_s pcf_app_t;
 
 typedef enum {
     PCF_EVT_BASE = OGS_FSM_USER_SIG,
@@ -60,6 +61,7 @@ typedef struct pcf_event_s {
 
     pcf_ue_t *pcf_ue;
     pcf_sess_t *sess;
+    pcf_app_t *app;
 
     ogs_timer_t *timer;
 } pcf_event_t;

src/pcf/meson.build

@@ -34,6 +34,7 @@ libpcf_sources = files('''
 
     namf-build.c
     nsmf-build.c
+    naf-build.c
 
     am-sm.c
     sm-sm.c

src/pcf/naf-build.c

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2019 by Sukchan Lee <acetcom@gmail.com>
+ *
+ * This file is part of Open5GS.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "naf-build.h"
+
+ogs_sbi_request_t *pcf_naf_callback_build_policyauthorization_terminate(
+        pcf_app_t *app_session, void *data)
+{
+    ogs_sbi_message_t message;
+    ogs_sbi_request_t *request = NULL;
+    
+    ogs_assert(app_session);
+
+    memset(&message, 0, sizeof(message));
+    message.h.method = (char *)OGS_SBI_HTTP_METHOD_POST;
+    message.h.uri = ogs_mstrcatf(
+            app_session->notif_uri, "/%s", OGS_SBI_RESOURCE_NAME_TERMINATE);
+    ogs_assert(message.h.uri);
+
+    request = ogs_sbi_build_request(&message);
+    ogs_assert(request);
+
+    ogs_free(message.h.uri);
+
+    return request;
+}

src/pcf/naf-build.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2019 by Sukchan Lee <acetcom@gmail.com>
+ *
+ * This file is part of Open5GS.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef PCF_NAF_BUILD_H
+#define PCF_NAF_BUILD_H
+
+#include "context.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ogs_sbi_request_t *pcf_naf_callback_build_policyauthorization_terminate(
+        pcf_app_t *app_session, void *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PCF_NAF_BUILD_H */

src/pcf/nbsf-handler.c

@@ -24,7 +24,7 @@
 bool pcf_nbsf_management_handle_register(
     pcf_sess_t *sess, ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg)
 {
-    int i, j, rv, status = 0;
+    int i, rv, status = 0;
     char *strerror = NULL;
     pcf_ue_t *pcf_ue = NULL;
     ogs_sbi_server_t *server = NULL;
@@ -43,7 +43,7 @@ bool pcf_nbsf_management_handle_register(
 
     OpenAPI_sm_policy_decision_t SmPolicyDecision;
 
-    OpenAPI_lnode_t *node = NULL, *node2 = NULL;
+    OpenAPI_lnode_t *node = NULL;
 
     OpenAPI_list_t *SessRuleList = NULL;
     OpenAPI_map_t *SessRuleMap = NULL;
@@ -55,7 +55,6 @@ bool pcf_nbsf_management_handle_register(
     OpenAPI_list_t *PccRuleList = NULL;
     OpenAPI_map_t *PccRuleMap = NULL;
     OpenAPI_pcc_rule_t *PccRule = NULL;
-    OpenAPI_flow_information_t *FlowInformation = NULL;
 
     OpenAPI_list_t *QosDecisionList = NULL;
     OpenAPI_map_t *QosDecisionMap = NULL;
@@ -275,110 +274,26 @@ bool pcf_nbsf_management_handle_register(
     ogs_assert(QosDecisionList);
 
     for (i = 0; i < session_data.num_of_pcc_rule; i++) {
-        OpenAPI_list_t *FlowInformationList = NULL;
         ogs_pcc_rule_t *pcc_rule = &session_data.pcc_rule[i];
 
         ogs_assert(pcc_rule);
 
-        PccRule = ogs_calloc(1, sizeof(*PccRule));
-        ogs_assert(PccRule);
-        QosData = ogs_calloc(1, sizeof(*QosData));
-        ogs_assert(QosData);
-
-        /*
-         * At this point, only 1 QosData is used for PccRule.
-         * Therefore, QoS ID uses the same value as PCC Rule ID.
-         */
-        PccRule->pcc_rule_id = pcc_rule->id;
-        QosData->qos_id = pcc_rule->id;
-
-        PccRule->ref_qos_data = OpenAPI_list_create();
-        ogs_assert(PccRule->ref_qos_data);
-
-        OpenAPI_list_add(PccRule->ref_qos_data, QosData->qos_id);
-
-        PccRule->is_precedence = true;
-        PccRule->precedence = pcc_rule->precedence;
-
-        FlowInformationList = OpenAPI_list_create();
-        ogs_assert(FlowInformationList);
-
-        for (j = 0; j < pcc_rule->num_of_flow; j++) {
-            ogs_flow_t *flow = &pcc_rule->flow[j];
-            ogs_assert(flow);
-
-            FlowInformation = ogs_calloc(1, sizeof(*FlowInformation));
-            ogs_assert(FlowInformation);
-
-            if (flow->direction == OGS_FLOW_UPLINK_ONLY)
-                FlowInformation->flow_direction =
-                    OpenAPI_flow_direction_UPLINK;
-            else if (flow->direction == OGS_FLOW_DOWNLINK_ONLY)
-                FlowInformation->flow_direction =
-                    OpenAPI_flow_direction_DOWNLINK;
-            else {
-                ogs_fatal("Unsupported direction [%d]", flow->direction);
-                ogs_assert_if_reached();
-            }
-
-            ogs_assert(flow->description);
-            FlowInformation->flow_description = flow->description;
-
-            OpenAPI_list_add(FlowInformationList, FlowInformation);
+        if (!pcc_rule->num_of_flow) {
+            /* No Flow */
+            continue;
         }
 
-        if (FlowInformationList->count)
-            PccRule->flow_infos = FlowInformationList;
-        else
-            OpenAPI_list_free(FlowInformationList);
+        PccRule = ogs_sbi_build_pcc_rule(pcc_rule, 1);
+        ogs_assert(PccRule->pcc_rule_id);
 
         PccRuleMap = OpenAPI_map_create(PccRule->pcc_rule_id, PccRule);
         ogs_assert(PccRuleMap);
 
         OpenAPI_list_add(PccRuleList, PccRuleMap);
 
-        QosData->is__5qi = true;
-        QosData->_5qi = pcc_rule->qos.index;
-        QosData->is_priority_level = true;
-        QosData->priority_level = pcc_rule->qos.arp.priority_level;
-
-        QosData->arp = ogs_calloc(1, sizeof(OpenAPI_arp_t));
-        ogs_assert(QosData->arp);
-
-        if (pcc_rule->qos.arp.pre_emption_capability ==
-                OGS_5GC_PRE_EMPTION_ENABLED)
-            QosData->arp->preempt_cap =
-                OpenAPI_preemption_capability_MAY_PREEMPT;
-        else if (pcc_rule->qos.arp.pre_emption_capability ==
-                OGS_5GC_PRE_EMPTION_DISABLED)
-            QosData->arp->preempt_cap =
-                OpenAPI_preemption_capability_NOT_PREEMPT;
-        ogs_assert(pcc_rule->qos.arp.pre_emption_capability);
-
-        if (pcc_rule->qos.arp.pre_emption_vulnerability ==
-                OGS_5GC_PRE_EMPTION_ENABLED)
-            QosData->arp->preempt_vuln =
-                OpenAPI_preemption_vulnerability_PREEMPTABLE;
-        else if (pcc_rule->qos.arp.pre_emption_vulnerability ==
-                OGS_5GC_PRE_EMPTION_DISABLED)
-            QosData->arp->preempt_vuln =
-                OpenAPI_preemption_vulnerability_NOT_PREEMPTABLE;
-        ogs_assert(pcc_rule->qos.arp.pre_emption_vulnerability);
-        QosData->arp->priority_level = pcc_rule->qos.arp.priority_level;
-
-        if (pcc_rule->qos.mbr.uplink)
-            QosData->maxbr_ul = ogs_sbi_bitrate_to_string(
-                    pcc_rule->qos.mbr.uplink, OGS_SBI_BITRATE_KBPS);
-        if (pcc_rule->qos.mbr.downlink)
-            QosData->maxbr_dl = ogs_sbi_bitrate_to_string(
-                    pcc_rule->qos.mbr.downlink, OGS_SBI_BITRATE_KBPS);
-
-        if (pcc_rule->qos.gbr.uplink)
-            QosData->gbr_ul = ogs_sbi_bitrate_to_string(
-                    pcc_rule->qos.gbr.uplink, OGS_SBI_BITRATE_KBPS);
-        if (pcc_rule->qos.gbr.downlink)
-            QosData->gbr_dl = ogs_sbi_bitrate_to_string(
-                    pcc_rule->qos.gbr.downlink, OGS_SBI_BITRATE_KBPS);
+        QosData = ogs_sbi_build_qos_data(pcc_rule);
+        ogs_assert(QosData);
+        ogs_assert(QosData->qos_id);
 
         QosDecisionMap = OpenAPI_map_create(QosData->qos_id, QosData);
         ogs_assert(QosDecisionMap);
@@ -446,18 +361,8 @@ bool pcf_nbsf_management_handle_register(
         PccRuleMap = node->data;
         if (PccRuleMap) {
             PccRule = PccRuleMap->value;
-            if (PccRule) {
-                if (PccRule->ref_qos_data)
-                    OpenAPI_list_free(PccRule->ref_qos_data);
-                if (PccRule->flow_infos) {
-                    OpenAPI_list_for_each(PccRule->flow_infos, node2) {
-                        FlowInformation = node2->data;
-                        if (FlowInformation) ogs_free(FlowInformation);
-                    }
-                    OpenAPI_list_free(PccRule->flow_infos);
-                }
-                ogs_free(PccRule);
-            }
+            if (PccRule)
+                ogs_sbi_free_pcc_rule(PccRule);
             ogs_free(PccRuleMap);
         }
     }
@@ -467,15 +372,8 @@ bool pcf_nbsf_management_handle_register(
         QosDecisionMap = node->data;
         if (QosDecisionMap) {
             QosData = QosDecisionMap->value;
-            if (QosData) {
-                if (QosData->arp) ogs_free(QosData->arp);
-                if (QosData->maxbr_ul) ogs_free(QosData->maxbr_ul);
-                if (QosData->maxbr_dl) ogs_free(QosData->maxbr_dl);
-                if (QosData->gbr_ul) ogs_free(QosData->gbr_ul);
-                if (QosData->gbr_dl) ogs_free(QosData->gbr_dl);
-
-                ogs_free(QosData);
-            }
+            if (QosData)
+                ogs_sbi_free_qos_data(QosData);
             ogs_free(QosDecisionMap);
         }
     }

src/pcf/npcf-handler.c

@@ -133,7 +133,7 @@ bool pcf_npcf_am_policy_contrtol_handle_create(pcf_ue_t *pcf_ue,
     return true;
 }
 
-bool pcf_npcf_smpolicycontrtol_handle_create(pcf_sess_t *sess,
+bool pcf_npcf_smpolicycontrol_handle_create(pcf_sess_t *sess,
         ogs_sbi_stream_t *stream, ogs_sbi_message_t *message)
 {
     int status = 0;
@@ -293,12 +293,13 @@ cleanup:
     return false;
 }
 
-bool pcf_npcf_smpolicycontrtol_handle_delete(pcf_sess_t *sess,
+bool pcf_npcf_smpolicycontrol_handle_delete(pcf_sess_t *sess,
         ogs_sbi_stream_t *stream, ogs_sbi_message_t *message)
 {
     int status = 0;
     char *strerror = NULL;
     pcf_ue_t *pcf_ue = NULL;
+    pcf_app_t *app_session = NULL;
 
     OpenAPI_sm_policy_delete_data_t *SmPolicyDeleteData = NULL;
 
@@ -315,6 +316,10 @@ bool pcf_npcf_smpolicycontrtol_handle_delete(pcf_sess_t *sess,
         goto cleanup;
     }
 
+    ogs_list_for_each(&sess->app_list, app_session) {
+        pcf_sbi_send_policyauthorization_terminate_notify(app_session);
+    }
+
     ogs_assert(true ==
         pcf_sess_sbi_discover_and_send(OpenAPI_nf_type_BSF, sess, stream, NULL,
             pcf_nbsf_management_build_de_register));
@@ -335,9 +340,13 @@ cleanup:
 bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
         ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg)
 {
-    int status = 0;
+    int i, j, rv, status = 0;
     char *strerror = NULL;
     pcf_ue_t *pcf_ue = NULL;
+    pcf_app_t *app_session = NULL;
+
+    ogs_sbi_client_t *client = NULL;
+    ogs_sockaddr_t *addr = NULL;
 
     OpenAPI_app_session_context_t *AppSessionContext = NULL;
     OpenAPI_app_session_context_req_data_t *AscReqData = NULL;
@@ -349,6 +358,8 @@ bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
     ogs_sbi_message_t sendmsg;
     ogs_sbi_response_t *response = NULL;
 
+    ogs_session_data_t session_data;
+
     ogs_ims_data_t ims_data;
     ogs_media_component_t *media_component = NULL;
     ogs_media_sub_component_t *sub = NULL;
@@ -363,6 +374,16 @@ bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
 
     OpenAPI_list_t *fDescList = NULL;
 
+    OpenAPI_sm_policy_decision_t SmPolicyDecision;
+
+    OpenAPI_list_t *PccRuleList = NULL;
+    OpenAPI_map_t *PccRuleMap = NULL;
+    OpenAPI_pcc_rule_t *PccRule = NULL;
+
+    OpenAPI_list_t *QosDecisionList = NULL;
+    OpenAPI_map_t *QosDecisionMap = NULL;
+    OpenAPI_qos_data_t *QosData = NULL;
+
     OpenAPI_lnode_t *node = NULL, *node2 = NULL, *node3 = NULL;
 
     ogs_assert(sess);
@@ -370,8 +391,6 @@ bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
     ogs_assert(stream);
     ogs_assert(recvmsg);
 
-    ogs_assert(sess->app_session_id);
-
     server = ogs_sbi_server_from_stream(stream);
     ogs_assert(server);
 
@@ -412,6 +431,14 @@ bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
         goto cleanup;
     }
 
+    addr = ogs_sbi_getaddr_from_uri(AscReqData->notif_uri);
+    if (!addr) {
+        strerror = ogs_msprintf("[%s:%d] Invalid URI [%s]",
+                pcf_ue->supi, sess->psi, AscReqData->notif_uri);
+        status = OGS_SBI_HTTP_STATUS_BAD_REQUEST;
+        goto cleanup;
+    }
+
     supported_features = ogs_uint64_from_string(AscReqData->supp_feat);
     sess->policyauthorization_features &= supported_features;
 
@@ -423,8 +450,6 @@ bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
     }
 
     memset(&ims_data, 0, sizeof(ims_data));
-    media_component = &ims_data.
-        media_component[ims_data.num_of_media_component];
 
     MediaComponentList = AscReqData->med_components;
     OpenAPI_list_for_each(MediaComponentList, node) {
@@ -432,6 +457,8 @@ bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
         if (MediaComponentMap) {
             MediaComponent = MediaComponentMap->value;
             if (MediaComponent) {
+                media_component = &ims_data.
+                    media_component[ims_data.num_of_media_component];
                 media_component->media_component_number =
                     MediaComponent->med_comp_n;
                 media_component->media_type = MediaComponent->med_type;
@@ -447,12 +474,18 @@ bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
                 if (MediaComponent->mir_bw_ul)
                     media_component->min_requested_bandwidth_ul =
                         ogs_sbi_bitrate_from_string(MediaComponent->mir_bw_ul);
+                if (MediaComponent->rr_bw)
+                    media_component->rr_bandwidth =
+                        ogs_sbi_bitrate_from_string(MediaComponent->rr_bw);
+                if (MediaComponent->rs_bw)
+                    media_component->rs_bandwidth =
+                        ogs_sbi_bitrate_from_string(MediaComponent->rs_bw);
                 media_component->flow_status = MediaComponent->f_status;
 
-                sub = &media_component->sub[media_component->num_of_sub];
-
                 SubComponentList = MediaComponent->med_sub_comps;
                 OpenAPI_list_for_each(SubComponentList, node2) {
+                    sub = &media_component->sub[media_component->num_of_sub];
+
                     SubComponentMap = node2->data;
                     if (SubComponentMap) {
                         SubComponent = SubComponentMap->value;
@@ -474,22 +507,225 @@ bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
                                     sub->num_of_flow++;
                                 }
                             }
+                            media_component->num_of_sub++;
                         }
                     }
-                    media_component->num_of_sub++;
+                }
+                ims_data.num_of_media_component++;
+            }
+        }
+    }
+
+    app_session = pcf_app_add(sess);
+    ogs_assert(app_session);
+
+    if (app_session->notif_uri)
+        ogs_free(app_session->notif_uri);
+    app_session->notif_uri = ogs_strdup(AscReqData->notif_uri);
+    ogs_assert(app_session->notif_uri);
+
+    client = ogs_sbi_client_find(addr);
+    if (!client) {
+        client = ogs_sbi_client_add(addr);
+        ogs_assert(client);
+    }
+    OGS_SETUP_SBI_CLIENT(&app_session->naf, client);
+
+    ogs_freeaddrinfo(addr);
+
+    memset(&session_data, 0, sizeof(ogs_session_data_t));
+    rv = ogs_dbi_session_data(
+            pcf_ue->supi, &sess->s_nssai, sess->dnn, &session_data);
+    if (rv != OGS_OK) {
+        strerror = ogs_msprintf("[%s:%d] Cannot find SUPI in DB",
+                pcf_ue->supi, sess->psi);
+        status = OGS_SBI_HTTP_STATUS_NOT_FOUND;
+        goto cleanup;
+    }
+
+    memset(&SmPolicyDecision, 0, sizeof(SmPolicyDecision));
+
+    PccRuleList = OpenAPI_list_create();
+    ogs_assert(PccRuleList);
+
+    QosDecisionList = OpenAPI_list_create();
+    ogs_assert(QosDecisionList);
+
+    for (i = 0; i < ims_data.num_of_media_component; i++) {
+        int flow_presence = 0;
+
+        ogs_pcc_rule_t *pcc_rule = NULL;
+        ogs_pcc_rule_t *db_pcc_rule = NULL;
+        uint8_t qos_index = 0;
+        ogs_media_component_t *media_component = &ims_data.media_component[i];
+
+        switch(media_component->media_type) {
+        case OpenAPI_media_type_AUDIO:
+            qos_index = OGS_QOS_INDEX_1;
+            break;
+        case OpenAPI_media_type_VIDEO:
+            qos_index = OGS_QOS_INDEX_2;
+            break;
+        case OpenAPI_media_type_CONTROL:
+            qos_index = OGS_QOS_INDEX_5;
+            break;
+        default:
+            strerror = ogs_msprintf("[%s:%d] Not implemented : [Media-Type:%d]",
+                    pcf_ue->supi, sess->psi, media_component->media_type);
+            status = OGS_SBI_HTTP_STATUS_INTERNAL_SERVER_ERROR;
+            goto cleanup;
+        }
+
+        for (j = 0; j < session_data.num_of_pcc_rule; j++) {
+            if (session_data.pcc_rule[j].qos.index == qos_index) {
+                db_pcc_rule = &session_data.pcc_rule[j];
+                break;
+            }
+        }
+
+        if (!db_pcc_rule &&
+            (media_component->media_type == OpenAPI_media_type_CONTROL)) {
+            /*
+             * Check for default bearer for IMS signalling
+             * QCI 5 and ARP 1
+             */
+            if (session_data.session.qos.index != OGS_QOS_INDEX_5 ||
+                session_data.session.qos.arp.priority_level != 1) {
+                strerror = ogs_msprintf("[%s:%d] CHECK WEBUI : "
+                    "Even the Default Bearer(QCI:%d,ARP:%d) "
+                    "cannot support IMS signalling.",
+                    pcf_ue->supi, sess->psi,
+                    session_data.session.qos.index,
+                    session_data.session.qos.arp.priority_level);
+                status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+                goto cleanup;
+            } else {
+                continue;
+            }
+        }
+
+        if (!db_pcc_rule) {
+            strerror = ogs_msprintf("[%s:%d] CHECK WEBUI : "
+                "No PCC Rule in DB [QoS Index:%d] - "
+                "Please add PCC Rule using WEBUI",
+                pcf_ue->supi, sess->psi, qos_index);
+            status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+            goto cleanup;
+        }
+
+        for (j = 0; j < app_session->num_of_pcc_rule; j++) {
+            if (app_session->pcc_rule[j].qos.index == qos_index) {
+                pcc_rule = &app_session->pcc_rule[j];
+                break;
+            }
+        }
+
+        if (!pcc_rule) {
+            pcc_rule = &app_session->pcc_rule[app_session->num_of_pcc_rule];
+            ogs_assert(pcc_rule);
+
+            pcc_rule->id = ogs_msprintf("%s-a%s",
+                            db_pcc_rule->id, app_session->app_session_id);
+            ogs_assert(pcc_rule->id);
+
+            memcpy(&pcc_rule->qos, &db_pcc_rule->qos, sizeof(ogs_qos_t));
+
+            pcc_rule->flow_status = db_pcc_rule->flow_status;
+            pcc_rule->precedence = db_pcc_rule->precedence;
+
+            /* Install Flow */
+            flow_presence = 1;
+            rv = ogs_pcc_rule_install_flow_from_media(
+                    pcc_rule, media_component);
+            if (rv != OGS_OK) {
+                strerror = ogs_msprintf("[%s:%d] install_flow() failed",
+                    pcf_ue->supi, sess->psi);
+                status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+                goto cleanup;
+            }
+
+            app_session->num_of_pcc_rule++;
+
+        } else {
+            int count = 0;
+
+            /* Check Flow */
+            count = ogs_pcc_rule_num_of_flow_equal_to_media(
+                    pcc_rule, media_component);
+            if (count == -1) {
+                strerror = ogs_msprintf("[%s:%d] matched_flow() failed",
+                    pcf_ue->supi, sess->psi);
+                status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+                goto cleanup;
+            }
+
+            if (pcc_rule->num_of_flow != count) {
+                /* Re-install Flow */
+                flow_presence = 1;
+                rv = ogs_pcc_rule_install_flow_from_media(
+                        pcc_rule, media_component);
+                if (rv != OGS_OK) {
+                    strerror = ogs_msprintf("[%s:%d] re-install_flow() failed",
+                        pcf_ue->supi, sess->psi);
+                    status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+                    goto cleanup;
                 }
             }
         }
-        ims_data.num_of_media_component++;
+
+        /* Update QoS */
+        rv = ogs_pcc_rule_update_qos_from_media(pcc_rule, media_component);
+        if (rv != OGS_OK) {
+            strerror = ogs_msprintf("[%s:%d] update_qos() failed",
+                pcf_ue->supi, sess->psi);
+            status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+            goto cleanup;
+        }
+
+        /* if we failed to get QoS from IMS, apply WEBUI QoS */
+        if (pcc_rule->qos.mbr.downlink == 0)
+            pcc_rule->qos.mbr.downlink = db_pcc_rule->qos.mbr.downlink;
+        if (pcc_rule->qos.mbr.uplink == 0)
+            pcc_rule->qos.mbr.uplink = db_pcc_rule->qos.mbr.uplink;
+        if (pcc_rule->qos.gbr.downlink == 0)
+            pcc_rule->qos.gbr.downlink = db_pcc_rule->qos.gbr.downlink;
+        if (pcc_rule->qos.gbr.uplink == 0)
+            pcc_rule->qos.gbr.uplink = db_pcc_rule->qos.gbr.uplink;
+
+        /**************************************************************
+         * Build PCC Rule & QoS Decision
+         *************************************************************/
+        PccRule = ogs_sbi_build_pcc_rule(pcc_rule, flow_presence);
+        ogs_assert(PccRule->pcc_rule_id);
+
+        PccRuleMap = OpenAPI_map_create(PccRule->pcc_rule_id, PccRule);
+        ogs_assert(PccRuleMap);
+
+        OpenAPI_list_add(PccRuleList, PccRuleMap);
+
+        QosData = ogs_sbi_build_qos_data(pcc_rule);
+        ogs_assert(QosData);
+        ogs_assert(QosData->qos_id);
+
+        QosDecisionMap = OpenAPI_map_create(QosData->qos_id, QosData);
+        ogs_assert(QosDecisionMap);
+
+        OpenAPI_list_add(QosDecisionList, QosDecisionMap);
     }
 
+    if (PccRuleList->count)
+        SmPolicyDecision.pcc_rules = PccRuleList;
+
+    if (QosDecisionList->count)
+        SmPolicyDecision.qos_decs = QosDecisionList;
+
     memset(&sendmsg, 0, sizeof(sendmsg));
 
     memset(&header, 0, sizeof(header));
     header.service.name = (char *)OGS_SBI_SERVICE_NAME_NPCF_POLICYAUTHORIZATION;
     header.api.version = (char *)OGS_SBI_API_V1;
     header.resource.component[0] = (char *)OGS_SBI_RESOURCE_NAME_APP_SESSIONS;
-    header.resource.component[1] = (char *)sess->app_session_id;
+    header.resource.component[1] = (char *)app_session->app_session_id;
     sendmsg.http.location = ogs_sbi_server_uri(server, &header);
     ogs_assert(sendmsg.http.location);
 
@@ -501,12 +737,35 @@ bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
 
     ogs_free(sendmsg.http.location);
 
-#if 0
-    ogs_assert(true == pcf_sbi_send_smpolicycontrol_notify(sess));
-    ogs_assert(true == pcf_sbi_send_am_policy_control_notify(pcf_ue));
-#endif
+    if (PccRuleList->count || QosDecisionList->count) {
+        ogs_assert(true == pcf_sbi_send_smpolicycontrol_update_notify(
+                                sess, &SmPolicyDecision));
+    }
+
+    OpenAPI_list_for_each(PccRuleList, node) {
+        PccRuleMap = node->data;
+        if (PccRuleMap) {
+            PccRule = PccRuleMap->value;
+            if (PccRule)
+                ogs_sbi_free_pcc_rule(PccRule);
+            ogs_free(PccRuleMap);
+        }
+    }
+    OpenAPI_list_free(PccRuleList);
+
+    OpenAPI_list_for_each(QosDecisionList, node) {
+        QosDecisionMap = node->data;
+        if (QosDecisionMap) {
+            QosData = QosDecisionMap->value;
+            if (QosData)
+                ogs_sbi_free_qos_data(QosData);
+            ogs_free(QosDecisionMap);
+        }
+    }
+    OpenAPI_list_free(QosDecisionList);
 
     ogs_ims_data_free(&ims_data);
+    ogs_session_data_free(&session_data);
 
     return true;
 
@@ -518,7 +777,509 @@ cleanup:
         ogs_sbi_server_send_error(stream, status, recvmsg, strerror, NULL));
     ogs_free(strerror);
 
+    OpenAPI_list_for_each(PccRuleList, node) {
+        PccRuleMap = node->data;
+        if (PccRuleMap) {
+            PccRule = PccRuleMap->value;
+            if (PccRule)
+                ogs_sbi_free_pcc_rule(PccRule);
+            ogs_free(PccRuleMap);
+        }
+    }
+    OpenAPI_list_free(PccRuleList);
+
+    OpenAPI_list_for_each(QosDecisionList, node) {
+        QosDecisionMap = node->data;
+        if (QosDecisionMap) {
+            QosData = QosDecisionMap->value;
+            if (QosData)
+                ogs_sbi_free_qos_data(QosData);
+            ogs_free(QosDecisionMap);
+        }
+    }
+    OpenAPI_list_free(QosDecisionList);
+
     ogs_ims_data_free(&ims_data);
+    ogs_session_data_free(&session_data);
 
     return false;
 }
+
+bool pcf_npcf_policyauthorization_handle_update(
+        pcf_sess_t *sess, pcf_app_t *app_session,
+        ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg)
+{
+    int i, j, rv, status = 0;
+    char *strerror = NULL;
+    pcf_ue_t *pcf_ue = NULL;
+
+    OpenAPI_app_session_context_update_data_patch_t
+        *AppSessionContextUpdateDataPatch = NULL;
+    OpenAPI_app_session_context_update_data_t *AscUpdateData = NULL;
+
+    ogs_sbi_message_t sendmsg;
+    ogs_sbi_response_t *response = NULL;
+
+    ogs_session_data_t session_data;
+
+    ogs_ims_data_t ims_data;
+    ogs_media_component_t *media_component = NULL;
+    ogs_media_sub_component_t *sub = NULL;
+
+    OpenAPI_list_t *MediaComponentList = NULL;
+    OpenAPI_map_t *MediaComponentMap = NULL;
+    OpenAPI_media_component_rm_t *MediaComponent = NULL;
+
+    OpenAPI_list_t *SubComponentList = NULL;
+    OpenAPI_map_t *SubComponentMap = NULL;
+    OpenAPI_media_sub_component_t *SubComponent = NULL;
+
+    OpenAPI_list_t *fDescList = NULL;
+
+    OpenAPI_sm_policy_decision_t SmPolicyDecision;
+
+    OpenAPI_list_t *PccRuleList = NULL;
+    OpenAPI_map_t *PccRuleMap = NULL;
+    OpenAPI_pcc_rule_t *PccRule = NULL;
+
+    OpenAPI_list_t *QosDecisionList = NULL;
+    OpenAPI_map_t *QosDecisionMap = NULL;
+    OpenAPI_qos_data_t *QosData = NULL;
+
+    OpenAPI_lnode_t *node = NULL, *node2 = NULL, *node3 = NULL;
+
+    ogs_assert(sess);
+    pcf_ue = sess->pcf_ue;
+    ogs_assert(app_session);
+    ogs_assert(stream);
+    ogs_assert(recvmsg);
+
+    AppSessionContextUpdateDataPatch =
+        recvmsg->AppSessionContextUpdateDataPatch;
+    if (!AppSessionContextUpdateDataPatch) {
+        strerror = ogs_msprintf("[%s:%d] No AppSessionContextUpdateDataPatch",
+                pcf_ue->supi, sess->psi);
+        status = OGS_SBI_HTTP_STATUS_BAD_REQUEST;
+        goto cleanup;
+    }
+
+    AscUpdateData = AppSessionContextUpdateDataPatch->asc_req_data;
+    if (!AscUpdateData) {
+        strerror = ogs_msprintf("[%s:%d] No AscUpdateData",
+                pcf_ue->supi, sess->psi);
+        status = OGS_SBI_HTTP_STATUS_BAD_REQUEST;
+        goto cleanup;
+    }
+
+    if (!AscUpdateData->med_components) {
+        strerror = ogs_msprintf("[%s:%d] No AscUpdateData->MediaCompoenent",
+                pcf_ue->supi, sess->psi);
+        status = OGS_SBI_HTTP_STATUS_BAD_REQUEST;
+        goto cleanup;
+    }
+
+    memset(&ims_data, 0, sizeof(ims_data));
+
+    MediaComponentList = AscUpdateData->med_components;
+    OpenAPI_list_for_each(MediaComponentList, node) {
+        MediaComponentMap = node->data;
+        if (MediaComponentMap) {
+            MediaComponent = MediaComponentMap->value;
+            if (MediaComponent) {
+                media_component = &ims_data.
+                    media_component[ims_data.num_of_media_component];
+
+                media_component->media_component_number =
+                    MediaComponent->med_comp_n;
+                media_component->media_type = MediaComponent->med_type;
+                if (MediaComponent->mar_bw_dl)
+                    media_component->max_requested_bandwidth_dl =
+                        ogs_sbi_bitrate_from_string(MediaComponent->mar_bw_dl);
+                if (MediaComponent->mar_bw_ul)
+                    media_component->max_requested_bandwidth_ul =
+                        ogs_sbi_bitrate_from_string(MediaComponent->mar_bw_ul);
+                if (MediaComponent->mir_bw_dl)
+                    media_component->min_requested_bandwidth_dl =
+                        ogs_sbi_bitrate_from_string(MediaComponent->mir_bw_dl);
+                if (MediaComponent->mir_bw_ul)
+                    media_component->min_requested_bandwidth_ul =
+                        ogs_sbi_bitrate_from_string(MediaComponent->mir_bw_ul);
+                if (MediaComponent->rr_bw)
+                    media_component->rr_bandwidth =
+                        ogs_sbi_bitrate_from_string(MediaComponent->rr_bw);
+                if (MediaComponent->rs_bw)
+                    media_component->rs_bandwidth =
+                        ogs_sbi_bitrate_from_string(MediaComponent->rs_bw);
+                media_component->flow_status = MediaComponent->f_status;
+
+                SubComponentList = MediaComponent->med_sub_comps;
+                OpenAPI_list_for_each(SubComponentList, node2) {
+                    sub = &media_component->sub[media_component->num_of_sub];
+
+                    SubComponentMap = node2->data;
+                    if (SubComponentMap) {
+                        SubComponent = SubComponentMap->value;
+                        if (SubComponent) {
+                            sub->flow_number = SubComponent->f_num;
+                            sub->flow_usage = SubComponent->flow_usage;
+
+                            fDescList = SubComponent->f_descs;
+                            OpenAPI_list_for_each(fDescList, node3) {
+                                ogs_flow_t *flow = NULL;
+
+                                ogs_assert(sub->num_of_flow <
+                                    OGS_MAX_NUM_OF_FLOW_IN_MEDIA_SUB_COMPONENT);
+                                flow = &sub->flow[sub->num_of_flow];
+                                if (node3->data) {
+                                    flow->description = ogs_strdup(node3->data);
+                                    ogs_assert(flow->description);
+
+                                    sub->num_of_flow++;
+                                }
+                            }
+                            media_component->num_of_sub++;
+                        }
+                    }
+                }
+                ims_data.num_of_media_component++;
+            }
+        }
+    }
+
+    memset(&session_data, 0, sizeof(ogs_session_data_t));
+    rv = ogs_dbi_session_data(
+            pcf_ue->supi, &sess->s_nssai, sess->dnn, &session_data);
+    if (rv != OGS_OK) {
+        strerror = ogs_msprintf("[%s:%d] Cannot find SUPI in DB",
+                pcf_ue->supi, sess->psi);
+        status = OGS_SBI_HTTP_STATUS_NOT_FOUND;
+        goto cleanup;
+    }
+
+    memset(&SmPolicyDecision, 0, sizeof(SmPolicyDecision));
+
+    PccRuleList = OpenAPI_list_create();
+    ogs_assert(PccRuleList);
+
+    QosDecisionList = OpenAPI_list_create();
+    ogs_assert(QosDecisionList);
+
+    for (i = 0; i < ims_data.num_of_media_component; i++) {
+        int flow_presence = 0;
+
+        ogs_pcc_rule_t *pcc_rule = NULL;
+        ogs_pcc_rule_t *db_pcc_rule = NULL;
+        uint8_t qos_index = 0;
+        ogs_media_component_t *media_component = &ims_data.media_component[i];
+
+        switch(media_component->media_type) {
+        case OpenAPI_media_type_AUDIO:
+            qos_index = OGS_QOS_INDEX_1;
+            break;
+        case OpenAPI_media_type_VIDEO:
+            qos_index = OGS_QOS_INDEX_2;
+            break;
+        case OpenAPI_media_type_CONTROL:
+            qos_index = OGS_QOS_INDEX_5;
+            break;
+        default:
+            strerror = ogs_msprintf("[%s:%d] Not implemented : [Media-Type:%d]",
+                    pcf_ue->supi, sess->psi, media_component->media_type);
+            status = OGS_SBI_HTTP_STATUS_INTERNAL_SERVER_ERROR;
+            goto cleanup;
+        }
+
+        for (j = 0; j < session_data.num_of_pcc_rule; j++) {
+            if (session_data.pcc_rule[j].qos.index == qos_index) {
+                db_pcc_rule = &session_data.pcc_rule[j];
+                break;
+            }
+        }
+
+        if (!db_pcc_rule &&
+            (media_component->media_type == OpenAPI_media_type_CONTROL)) {
+            /*
+             * Check for default bearer for IMS signalling
+             * QCI 5 and ARP 1
+             */
+            if (session_data.session.qos.index != OGS_QOS_INDEX_5 ||
+                session_data.session.qos.arp.priority_level != 1) {
+                strerror = ogs_msprintf("[%s:%d] CHECK WEBUI : "
+                    "Even the Default Bearer(QCI:%d,ARP:%d) "
+                    "cannot support IMS signalling.",
+                    pcf_ue->supi, sess->psi,
+                    session_data.session.qos.index,
+                    session_data.session.qos.arp.priority_level);
+                status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+                goto cleanup;
+            } else {
+                continue;
+            }
+        }
+
+        if (!db_pcc_rule) {
+            strerror = ogs_msprintf("[%s:%d] CHECK WEBUI : "
+                "No PCC Rule in DB [QoS Index:%d] - "
+                "Please add PCC Rule using WEBUI",
+                pcf_ue->supi, sess->psi, qos_index);
+            status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+            goto cleanup;
+        }
+
+        for (j = 0; j < app_session->num_of_pcc_rule; j++) {
+            if (app_session->pcc_rule[j].qos.index == qos_index) {
+                pcc_rule = &app_session->pcc_rule[j];
+                break;
+            }
+        }
+
+        if (!pcc_rule) {
+            pcc_rule = &app_session->pcc_rule[app_session->num_of_pcc_rule];
+            ogs_assert(pcc_rule);
+
+            pcc_rule->id = ogs_strdup(app_session->app_session_id);
+            ogs_assert(pcc_rule->id);
+
+            memcpy(&pcc_rule->qos, &db_pcc_rule->qos, sizeof(ogs_qos_t));
+
+            pcc_rule->flow_status = db_pcc_rule->flow_status;
+            pcc_rule->precedence = db_pcc_rule->precedence;
+
+            /* Install Flow */
+            flow_presence = 1;
+            rv = ogs_pcc_rule_install_flow_from_media(
+                    pcc_rule, media_component);
+            if (rv != OGS_OK) {
+                strerror = ogs_msprintf("[%s:%d] install_flow() failed",
+                    pcf_ue->supi, sess->psi);
+                status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+                goto cleanup;
+            }
+
+            app_session->num_of_pcc_rule++;
+
+        } else {
+            int count = 0;
+
+            /* Check Flow */
+            count = ogs_pcc_rule_num_of_flow_equal_to_media(
+                    pcc_rule, media_component);
+            if (count == -1) {
+                strerror = ogs_msprintf("[%s:%d] matched_flow() failed",
+                    pcf_ue->supi, sess->psi);
+                status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+                goto cleanup;
+            }
+
+            if (pcc_rule->num_of_flow != count) {
+                /* Re-install Flow */
+                flow_presence = 1;
+                rv = ogs_pcc_rule_install_flow_from_media(
+                        pcc_rule, media_component);
+                if (rv != OGS_OK) {
+                    strerror = ogs_msprintf("[%s:%d] re-install_flow() failed",
+                        pcf_ue->supi, sess->psi);
+                    status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+                    goto cleanup;
+                }
+            }
+        }
+
+        /* Update QoS */
+        rv = ogs_pcc_rule_update_qos_from_media(pcc_rule, media_component);
+        if (rv != OGS_OK) {
+            strerror = ogs_msprintf("[%s:%d] update_qos() failed",
+                pcf_ue->supi, sess->psi);
+            status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
+            goto cleanup;
+        }
+
+        /* if we failed to get QoS from IMS, apply WEBUI QoS */
+        if (pcc_rule->qos.mbr.downlink == 0)
+            pcc_rule->qos.mbr.downlink = db_pcc_rule->qos.mbr.downlink;
+        if (pcc_rule->qos.mbr.uplink == 0)
+            pcc_rule->qos.mbr.uplink = db_pcc_rule->qos.mbr.uplink;
+        if (pcc_rule->qos.gbr.downlink == 0)
+            pcc_rule->qos.gbr.downlink = db_pcc_rule->qos.gbr.downlink;
+        if (pcc_rule->qos.gbr.uplink == 0)
+            pcc_rule->qos.gbr.uplink = db_pcc_rule->qos.gbr.uplink;
+
+        /**************************************************************
+         * Build PCC Rule & QoS Decision
+         *************************************************************/
+        PccRule = ogs_sbi_build_pcc_rule(pcc_rule, flow_presence);
+        ogs_assert(PccRule->pcc_rule_id);
+
+        PccRuleMap = OpenAPI_map_create(PccRule->pcc_rule_id, PccRule);
+        ogs_assert(PccRuleMap);
+
+        OpenAPI_list_add(PccRuleList, PccRuleMap);
+
+        QosData = ogs_sbi_build_qos_data(pcc_rule);
+        ogs_assert(QosData);
+        ogs_assert(QosData->qos_id);
+
+        QosDecisionMap = OpenAPI_map_create(QosData->qos_id, QosData);
+        ogs_assert(QosDecisionMap);
+
+        OpenAPI_list_add(QosDecisionList, QosDecisionMap);
+    }
+
+    if (PccRuleList->count)
+        SmPolicyDecision.pcc_rules = PccRuleList;
+
+    if (QosDecisionList->count)
+        SmPolicyDecision.qos_decs = QosDecisionList;
+
+    memset(&sendmsg, 0, sizeof(sendmsg));
+
+    sendmsg.AppSessionContextUpdateDataPatch =
+        recvmsg->AppSessionContextUpdateDataPatch;
+
+    response = ogs_sbi_build_response(&sendmsg, OGS_SBI_HTTP_STATUS_OK);
+    ogs_assert(response);
+    ogs_assert(true == ogs_sbi_server_send_response(stream, response));
+
+    if (PccRuleList->count || QosDecisionList->count) {
+        ogs_assert(true == pcf_sbi_send_smpolicycontrol_update_notify(
+                            sess, &SmPolicyDecision));
+    }
+
+    OpenAPI_list_for_each(PccRuleList, node) {
+        PccRuleMap = node->data;
+        if (PccRuleMap) {
+            PccRule = PccRuleMap->value;
+            if (PccRule)
+                ogs_sbi_free_pcc_rule(PccRule);
+            ogs_free(PccRuleMap);
+        }
+    }
+    OpenAPI_list_free(PccRuleList);
+
+    OpenAPI_list_for_each(QosDecisionList, node) {
+        QosDecisionMap = node->data;
+        if (QosDecisionMap) {
+            QosData = QosDecisionMap->value;
+            if (QosData)
+                ogs_sbi_free_qos_data(QosData);
+            ogs_free(QosDecisionMap);
+        }
+    }
+    OpenAPI_list_free(QosDecisionList);
+
+    ogs_ims_data_free(&ims_data);
+    ogs_session_data_free(&session_data);
+
+    return true;
+
+cleanup:
+    ogs_assert(status);
+    ogs_assert(strerror);
+    ogs_error("%s", strerror);
+    ogs_assert(true ==
+        ogs_sbi_server_send_error(stream, status, recvmsg, strerror, NULL));
+    ogs_free(strerror);
+
+    OpenAPI_list_for_each(PccRuleList, node) {
+        PccRuleMap = node->data;
+        if (PccRuleMap) {
+            PccRule = PccRuleMap->value;
+            if (PccRule)
+                ogs_sbi_free_pcc_rule(PccRule);
+            ogs_free(PccRuleMap);
+        }
+    }
+    OpenAPI_list_free(PccRuleList);
+
+    OpenAPI_list_for_each(QosDecisionList, node) {
+        QosDecisionMap = node->data;
+        if (QosDecisionMap) {
+            QosData = QosDecisionMap->value;
+            if (QosData)
+                ogs_sbi_free_qos_data(QosData);
+            ogs_free(QosDecisionMap);
+        }
+    }
+    OpenAPI_list_free(QosDecisionList);
+
+    ogs_ims_data_free(&ims_data);
+    ogs_session_data_free(&session_data);
+
+    return false;
+}
+
+bool pcf_npcf_policyauthorization_handle_delete(
+        pcf_sess_t *sess, pcf_app_t *app_session,
+        ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg)
+{
+    int i;
+
+    OpenAPI_sm_policy_decision_t SmPolicyDecision;
+
+    OpenAPI_list_t *PccRuleList = NULL;
+    OpenAPI_map_t *PccRuleMap = NULL;
+
+    OpenAPI_list_t *QosDecisionList = NULL;
+    OpenAPI_map_t *QosDecisionMap = NULL;
+
+    OpenAPI_lnode_t *node = NULL;
+
+    ogs_assert(true == ogs_sbi_send_http_status_no_content(stream));
+
+    ogs_assert(app_session);
+
+    memset(&SmPolicyDecision, 0, sizeof(SmPolicyDecision));
+
+    PccRuleList = OpenAPI_list_create();
+    ogs_assert(PccRuleList);
+
+    QosDecisionList = OpenAPI_list_create();
+    ogs_assert(QosDecisionList);
+
+    for (i = 0; i < app_session->num_of_pcc_rule; i++) {
+        ogs_pcc_rule_t *pcc_rule = &app_session->pcc_rule[i];
+
+        ogs_assert(pcc_rule);
+
+        PccRuleMap = OpenAPI_map_create(pcc_rule->id, NULL);
+        ogs_assert(PccRuleMap);
+
+        OpenAPI_list_add(PccRuleList, PccRuleMap);
+
+        QosDecisionMap = OpenAPI_map_create(pcc_rule->id, NULL);
+        ogs_assert(QosDecisionMap);
+
+        OpenAPI_list_add(QosDecisionList, QosDecisionMap);
+    }
+
+    if (PccRuleList->count)
+        SmPolicyDecision.pcc_rules = PccRuleList;
+
+    if (QosDecisionList->count)
+        SmPolicyDecision.qos_decs = QosDecisionList;
+
+    if (PccRuleList->count || QosDecisionList->count) {
+        ogs_assert(true == pcf_sbi_send_smpolicycontrol_delete_notify(
+                            sess, app_session, &SmPolicyDecision));
+    } else {
+        pcf_app_remove(app_session);
+    }
+
+    OpenAPI_list_for_each(PccRuleList, node) {
+        PccRuleMap = node->data;
+        if (PccRuleMap) {
+            ogs_free(PccRuleMap);
+        }
+    }
+    OpenAPI_list_free(PccRuleList);
+
+    OpenAPI_list_for_each(QosDecisionList, node) {
+        QosDecisionMap = node->data;
+        if (QosDecisionMap) {
+            ogs_free(QosDecisionMap);
+        }
+    }
+    OpenAPI_list_free(QosDecisionList);
+
+    return true;
+}

src/pcf/npcf-handler.h

@@ -29,13 +29,19 @@ extern "C" {
 bool pcf_npcf_am_policy_contrtol_handle_create(pcf_ue_t *pcf_ue,
         ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg);
 
-bool pcf_npcf_smpolicycontrtol_handle_create(pcf_sess_t *sess,
+bool pcf_npcf_smpolicycontrol_handle_create(pcf_sess_t *sess,
         ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg);
-bool pcf_npcf_smpolicycontrtol_handle_delete(pcf_sess_t *sess,
+bool pcf_npcf_smpolicycontrol_handle_delete(pcf_sess_t *sess,
         ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg);
 
 bool pcf_npcf_policyauthorization_handle_create(pcf_sess_t *sess,
         ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg);
+bool pcf_npcf_policyauthorization_handle_update(
+        pcf_sess_t *sess, pcf_app_t *app,
+        ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg);
+bool pcf_npcf_policyauthorization_handle_delete(
+        pcf_sess_t *sess, pcf_app_t *app,
+        ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg);
 
 #ifdef __cplusplus
 }

src/pcf/nsmf-build.c

@@ -19,27 +19,86 @@
 
 #include "nsmf-build.h"
 
-ogs_sbi_request_t *pcf_nsmf_callback_build_smpolicycontrol(
+ogs_sbi_request_t *pcf_nsmf_callback_build_smpolicycontrol_update(
         pcf_sess_t *sess, void *data)
 {
     ogs_sbi_message_t message;
+    ogs_sbi_header_t header;
     ogs_sbi_request_t *request = NULL;
+    ogs_sbi_server_t *server = NULL;
 
     OpenAPI_sm_policy_notification_t SmPolicyNotification;
+    OpenAPI_sm_policy_decision_t *SmPolicyDecision;
 
     ogs_assert(sess);
+    ogs_assert(sess->sm_policy_id);
     ogs_assert(sess->notification_uri);
 
+    server = ogs_list_first(&ogs_sbi_self()->server_list);
+    ogs_assert(server);
+
+    memset(&header, 0, sizeof(header));
+    header.service.name = (char *)OGS_SBI_SERVICE_NAME_NPCF_SMPOLICYCONTROL;
+    header.api.version = (char *)OGS_SBI_API_V1;
+    header.resource.component[0] = (char *)OGS_SBI_RESOURCE_NAME_SM_POLICIES;
+    header.resource.component[1] = sess->sm_policy_id;
+    header.resource.component[2] = (char *)OGS_SBI_RESOURCE_NAME_UPDATE;
+
     memset(&SmPolicyNotification, 0, sizeof(SmPolicyNotification));
 
+    SmPolicyNotification.resource_uri = ogs_sbi_server_uri(server, &header);
+    ogs_assert(SmPolicyNotification.resource_uri);
+
+    SmPolicyDecision = data;
+    ogs_assert(SmPolicyDecision);
+
+    SmPolicyNotification.sm_policy_decision = SmPolicyDecision;
+
     memset(&message, 0, sizeof(message));
     message.h.method = (char *)OGS_SBI_HTTP_METHOD_POST;
-    message.h.uri = sess->notification_uri;
+    message.h.uri = ogs_mstrcatf(
+            sess->notification_uri, "/%s", OGS_SBI_RESOURCE_NAME_UPDATE);
+    ogs_assert(message.h.uri);
 
     message.SmPolicyNotification = &SmPolicyNotification;
 
     request = ogs_sbi_build_request(&message);
     ogs_assert(request);
 
+    ogs_free(SmPolicyNotification.resource_uri);
+    ogs_free(message.h.uri);
+
+    return request;
+}
+
+ogs_sbi_request_t *pcf_nsmf_callback_build_smpolicycontrol_terminate(
+        pcf_sess_t *sess, void *data)
+{
+    ogs_sbi_message_t message;
+    ogs_sbi_header_t header;
+    ogs_sbi_request_t *request = NULL;
+
+    ogs_assert(sess);
+    ogs_assert(sess->sm_policy_id);
+    ogs_assert(sess->notification_uri);
+
+    memset(&header, 0, sizeof(header));
+    header.service.name = (char *)OGS_SBI_SERVICE_NAME_NPCF_SMPOLICYCONTROL;
+    header.api.version = (char *)OGS_SBI_API_V1;
+    header.resource.component[0] = (char *)OGS_SBI_RESOURCE_NAME_SM_POLICIES;
+    header.resource.component[1] = sess->sm_policy_id;
+    header.resource.component[2] = (char *)OGS_SBI_RESOURCE_NAME_UPDATE;
+
+    memset(&message, 0, sizeof(message));
+    message.h.method = (char *)OGS_SBI_HTTP_METHOD_POST;
+    message.h.uri = ogs_mstrcatf(
+            sess->notification_uri, "/%s", OGS_SBI_RESOURCE_NAME_TERMINATE);
+    ogs_assert(message.h.uri);
+
+    request = ogs_sbi_build_request(&message);
+    ogs_assert(request);
+
+    ogs_free(message.h.uri);
+
     return request;
 }

src/pcf/nsmf-build.h

@@ -26,7 +26,9 @@
 extern "C" {
 #endif
 
-ogs_sbi_request_t *pcf_nsmf_callback_build_smpolicycontrol(
+ogs_sbi_request_t *pcf_nsmf_callback_build_smpolicycontrol_update(
+        pcf_sess_t *sess, void *data);
+ogs_sbi_request_t *pcf_nsmf_callback_build_smpolicycontrol_terminate(
         pcf_sess_t *sess, void *data);
 
 #ifdef __cplusplus

src/pcf/pcf-sm.c

@@ -53,6 +53,7 @@ void pcf_state_operational(ogs_fsm_t *s, pcf_event_t *e)
 
     pcf_ue_t *pcf_ue = NULL;
     pcf_sess_t *sess = NULL;
+    pcf_app_t *app_session = NULL;
 
     pcf_sm_debug(e);
 
@@ -231,8 +232,10 @@ void pcf_state_operational(ogs_fsm_t *s, pcf_event_t *e)
                                     AppSessionContext->asc_req_data->ue_ipv6);
                     }
                 } else {
-                    sess = pcf_sess_find_by_app_session_id(
+                    app_session = pcf_app_find_by_app_session_id(
                             message.h.resource.component[1]);
+                    if (app_session)
+                        sess = app_session->sess;
                 }
                 break;
 
@@ -251,6 +254,7 @@ void pcf_state_operational(ogs_fsm_t *s, pcf_event_t *e)
             ogs_assert(OGS_FSM_STATE(&sess->sm));
 
             e->sess = sess;
+            e->app = app_session;
             e->sbi.message = &message;
             ogs_fsm_dispatch(&sess->sm, e);
             if (OGS_FSM_CHECK(&sess->sm, pcf_sm_state_exception)) {

src/pcf/sbi-path.c

@@ -240,6 +240,18 @@ static int client_notify_cb(ogs_sbi_response_t *response, void *data)
     return OGS_OK;
 }
 
+static int client_delete_notify_cb(ogs_sbi_response_t *response, void *data)
+{
+    pcf_app_t *app_session = data;
+
+    ogs_assert(app_session);
+    client_notify_cb(response, data);
+
+    pcf_app_remove(app_session);
+
+    return OGS_OK;
+}
+
 bool pcf_sbi_send_am_policy_control_notify(pcf_ue_t *pcf_ue)
 {
     ogs_sbi_request_t *request = NULL;
@@ -254,7 +266,8 @@ bool pcf_sbi_send_am_policy_control_notify(pcf_ue_t *pcf_ue)
     return ogs_sbi_client_send_request(client, client_notify_cb, request, NULL);
 }
 
-bool pcf_sbi_send_smpolicycontrol_notify(pcf_sess_t *sess)
+bool pcf_sbi_send_smpolicycontrol_update_notify(
+        pcf_sess_t *sess, OpenAPI_sm_policy_decision_t *SmPolicyDecision)
 {
     ogs_sbi_request_t *request = NULL;
     ogs_sbi_client_t *client = NULL;
@@ -263,7 +276,54 @@ bool pcf_sbi_send_smpolicycontrol_notify(pcf_sess_t *sess)
     client = sess->nsmf.client;
     ogs_assert(client);
 
-    request = pcf_nsmf_callback_build_smpolicycontrol(sess, NULL);
+    request = pcf_nsmf_callback_build_smpolicycontrol_update(
+                sess, SmPolicyDecision);
+    ogs_expect_or_return_val(request, false);
+    return ogs_sbi_client_send_request(client, client_notify_cb, request, NULL);
+}
+
+bool pcf_sbi_send_smpolicycontrol_delete_notify(
+        pcf_sess_t *sess, pcf_app_t *app_session,
+        OpenAPI_sm_policy_decision_t *SmPolicyDecision)
+{
+    ogs_sbi_request_t *request = NULL;
+    ogs_sbi_client_t *client = NULL;
+
+    ogs_assert(sess);
+    client = sess->nsmf.client;
+    ogs_assert(client);
+
+    request = pcf_nsmf_callback_build_smpolicycontrol_update(
+                sess, SmPolicyDecision);
+    ogs_expect_or_return_val(request, false);
+    return ogs_sbi_client_send_request(
+            client, client_delete_notify_cb, request, app_session);
+}
+
+bool pcf_sbi_send_smpolicycontrol_terminate_notify(pcf_sess_t *sess)
+{
+    ogs_sbi_request_t *request = NULL;
+    ogs_sbi_client_t *client = NULL;
+
+    ogs_assert(sess);
+    client = sess->nsmf.client;
+    ogs_assert(client);
+
+    request = pcf_nsmf_callback_build_smpolicycontrol_terminate(sess, NULL);
+    ogs_expect_or_return_val(request, false);
+    return ogs_sbi_client_send_request(client, client_notify_cb, request, NULL);
+}
+
+bool pcf_sbi_send_policyauthorization_terminate_notify(pcf_app_t *app)
+{
+    ogs_sbi_request_t *request = NULL;
+    ogs_sbi_client_t *client = NULL;
+
+    ogs_assert(app);
+    client = app->naf.client;
+    ogs_assert(client);
+
+    request = pcf_naf_callback_build_policyauthorization_terminate(app, NULL);
     ogs_expect_or_return_val(request, false);
     return ogs_sbi_client_send_request(client, client_notify_cb, request, NULL);
 }

src/pcf/sbi-path.h

@@ -25,6 +25,7 @@
 #include "nbsf-build.h"
 #include "namf-build.h"
 #include "nsmf-build.h"
+#include "naf-build.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -44,7 +45,14 @@ bool pcf_sess_sbi_discover_and_send(OpenAPI_nf_type_e target_nf_type,
         ogs_sbi_request_t *(*build)(pcf_sess_t *sess, void *data));
 
 bool pcf_sbi_send_am_policy_control_notify(pcf_ue_t *pcf_ue);
-bool pcf_sbi_send_smpolicycontrol_notify(pcf_sess_t *sess);
+bool pcf_sbi_send_smpolicycontrol_update_notify(
+        pcf_sess_t *sess, OpenAPI_sm_policy_decision_t *SmPolicyDecision);
+bool pcf_sbi_send_smpolicycontrol_delete_notify(
+        pcf_sess_t *sess, pcf_app_t *app_session,
+        OpenAPI_sm_policy_decision_t *SmPolicyDecision);
+bool pcf_sbi_send_smpolicycontrol_terminate_notify(pcf_sess_t *sess);
+
+bool pcf_sbi_send_policyauthorization_terminate_notify(pcf_app_t *app);
 
 #ifdef __cplusplus
 }

src/pcf/sm-sm.c

@@ -70,22 +70,22 @@ void pcf_sm_state_operational(ogs_fsm_t *s, pcf_event_t *e)
         SWITCH(message->h.service.name)
         CASE(OGS_SBI_SERVICE_NAME_NPCF_SMPOLICYCONTROL)
             if (!message->h.resource.component[1]) {
-                handled = pcf_npcf_smpolicycontrtol_handle_create(
+                handled = pcf_npcf_smpolicycontrol_handle_create(
                         sess, stream, message);
                 if (!handled) {
                     ogs_error("[%s:%d] "
-                            "pcf_npcf_smpolicycontrtol_handle_create() failed",
+                            "pcf_npcf_smpolicycontrol_handle_create() failed",
                             pcf_ue->supi, sess->psi);
                     OGS_FSM_TRAN(s, pcf_sm_state_exception);
                 }
             } else {
                 SWITCH(message->h.resource.component[2])
                 CASE(OGS_SBI_RESOURCE_NAME_DELETE)
-                    handled = pcf_npcf_smpolicycontrtol_handle_delete(
+                    handled = pcf_npcf_smpolicycontrol_handle_delete(
                             sess, stream, message);
                     if (!handled) {
                         ogs_error("[%s:%d] "
-                            "pcf_npcf_smpolicycontrtol_handle_delete() failed",
+                            "pcf_npcf_smpolicycontrol_handle_delete() failed",
                             pcf_ue->supi, sess->psi);
                         OGS_FSM_TRAN(s, pcf_sm_state_exception);
                     }
@@ -103,17 +103,46 @@ void pcf_sm_state_operational(ogs_fsm_t *s, pcf_event_t *e)
             break;
 
         CASE(OGS_SBI_SERVICE_NAME_NPCF_POLICYAUTHORIZATION)
-            if (!message->h.resource.component[1]) {
-                handled = pcf_npcf_policyauthorization_handle_create(
-                        sess, stream, message);
+            if (message->h.resource.component[1]) {
+                if (message->h.resource.component[2]) {
+                    SWITCH(message->h.resource.component[2])
+                    CASE(OGS_SBI_RESOURCE_NAME_DELETE)
+                        handled = pcf_npcf_policyauthorization_handle_delete(
+                                sess, e->app, stream, message);
+                        break;
+                    DEFAULT
+                        ogs_error("[%s:%d] Invalid resource name [%s]",
+                                pcf_ue->supi, sess->psi,
+                                message->h.resource.component[2]);
+                        ogs_assert(true ==
+                            ogs_sbi_server_send_error(stream,
+                                OGS_SBI_HTTP_STATUS_FORBIDDEN, message,
+                                "Invalid resource name", message->h.uri));
+                    END
+                } else {
+                    SWITCH(message->h.method)
+                    CASE(OGS_SBI_HTTP_METHOD_PATCH)
+                        handled = pcf_npcf_policyauthorization_handle_update(
+                                sess, e->app, stream, message);
+                        break;
+                    DEFAULT
+                        ogs_error("[%s:%d] Unknown method [%s]",
+                                pcf_ue->supi, sess->psi, message->h.method);
+                        ogs_assert(true ==
+                            ogs_sbi_server_send_error(stream,
+                                OGS_SBI_HTTP_STATUS_FORBIDDEN, message,
+                                "Invalid HTTP method", message->h.uri));
+                    END
+                }
             } else {
-                SWITCH(message->h.resource.component[2])
-                CASE(OGS_SBI_RESOURCE_NAME_DELETE)
-                    ogs_fatal("TODO");
+                SWITCH(message->h.method)
+                CASE(OGS_SBI_HTTP_METHOD_POST)
+                    handled = pcf_npcf_policyauthorization_handle_create(
+                            sess, stream, message);
                     break;
                 DEFAULT
-                    ogs_error("[%s:%d] Invalid HTTP URI [%s]",
-                            pcf_ue->supi, sess->psi, message->h.uri);
+                    ogs_error("[%s:%d] Unknown method [%s]",
+                            pcf_ue->supi, sess->psi, message->h.method);
                     ogs_assert(true ==
                         ogs_sbi_server_send_error(stream,
                             OGS_SBI_HTTP_STATUS_FORBIDDEN, message,

src/pcrf/pcrf-gx-path.c

@@ -62,12 +62,6 @@ static void pcrf_gx_raa_cb(void *data, struct msg **msg);
 
 static int encode_pcc_rule_definition(
         struct avp *avp, ogs_pcc_rule_t *pcc_rule, int flow_presence);
-static int matched_flow(ogs_pcc_rule_t *pcc_rule,
-        ogs_media_component_t *media_component);
-static int install_flow(ogs_pcc_rule_t *pcc_rule,
-        ogs_media_component_t *media_component);
-static int update_qos(ogs_pcc_rule_t *pcc_rule,
-        ogs_media_component_t *media_component);
 
 static __inline__ struct sess_state *new_state(os0_t sid)
 {
@@ -654,7 +648,6 @@ int pcrf_gx_send_rar(
 {
     int rv;
     int ret = 0, i, j;
-    int count = 0;
 
     struct msg *req = NULL;
     struct avp *avp, *avpch1;
@@ -749,10 +742,6 @@ int pcrf_gx_send_rar(
             ogs_media_component_t *media_component =
                 &rx_message->ims_data.media_component[i];
 
-            if (media_component->media_component_number == 0) {
-                continue;
-            }
-
             switch(media_component->media_type) {
             case OGS_DIAM_RX_MEDIA_TYPE_AUDIO:
                 qos_index = OGS_QOS_INDEX_1;
@@ -832,7 +821,8 @@ int pcrf_gx_send_rar(
 
                 /* Install Flow */
                 flow_presence = 1;
-                rv = install_flow(pcc_rule, media_component);
+                rv = ogs_pcc_rule_install_flow_from_media(
+                        pcc_rule, media_component);
                 if (rv != OGS_OK) {
                     rx_message->result_code =
                         OGS_DIAM_RX_DIAMETER_FILTER_RESTRICTIONS;
@@ -842,8 +832,11 @@ int pcrf_gx_send_rar(
 
                 rx_sess_data->num_of_pcc_rule++;
             } else {
+                int count = 0;
+
                 /* Check Flow */
-                count = matched_flow(pcc_rule, media_component);
+                count = ogs_pcc_rule_num_of_flow_equal_to_media(
+                        pcc_rule, media_component);
                 if (count == -1) {
                     rx_message->result_code =
                         OGS_DIAM_RX_DIAMETER_FILTER_RESTRICTIONS;
@@ -854,7 +847,8 @@ int pcrf_gx_send_rar(
                 if (pcc_rule->num_of_flow != count) {
                     /* Re-install Flow */
                     flow_presence = 1;
-                    rv = install_flow(pcc_rule, media_component);
+                    rv = ogs_pcc_rule_install_flow_from_media(
+                            pcc_rule, media_component);
                     if (rv != OGS_OK) {
                         rx_message->result_code = 
                             OGS_DIAM_RX_DIAMETER_FILTER_RESTRICTIONS;
@@ -865,7 +859,7 @@ int pcrf_gx_send_rar(
             }
 
             /* Update QoS */
-            rv = update_qos(pcc_rule, media_component);
+            rv = ogs_pcc_rule_update_qos_from_media(pcc_rule, media_component);
             if (rv != OGS_OK) {
                 rx_message->result_code =
                     OGS_DIAM_RX_DIAMETER_REQUESTED_SERVICE_NOT_AUTHORIZED;
@@ -1361,295 +1355,3 @@ static int encode_pcc_rule_definition(
     
     return OGS_OK;
 }
-
-static int flow_rx_to_gx(ogs_flow_t *rx_flow, ogs_flow_t *gx_flow)
-{
-    int len;
-    char *from_str, *to_str;
-
-    ogs_assert(rx_flow);
-    ogs_assert(gx_flow);
-
-    if (!strncmp(rx_flow->description,
-                "permit out", strlen("permit out"))) {
-        gx_flow->direction = OGS_FLOW_DOWNLINK_ONLY;
-        gx_flow->description = ogs_strdup(rx_flow->description);
-        ogs_assert(gx_flow->description);
-
-    } else if (!strncmp(rx_flow->description,
-                "permit in", strlen("permit in"))) {
-        gx_flow->direction = OGS_FLOW_UPLINK_ONLY;
-
-        /* 'permit in' should be changed
-         * 'permit out' in Gx Diameter */
-        len = strlen(rx_flow->description)+2;
-        gx_flow->description = ogs_malloc(len);
-        ogs_assert(gx_flow->description);
-        strcpy(gx_flow->description, "permit out");
-        from_str = strstr(&rx_flow->description[strlen("permit in")], "from");
-        ogs_assert(from_str);
-        to_str = strstr(&rx_flow->description[strlen("permit in")], "to");
-        ogs_assert(to_str);
-        strncat(gx_flow->description,
-            &rx_flow->description[strlen("permit in")],
-            strlen(rx_flow->description) -
-                strlen("permit in") - strlen(from_str));
-        strcat(gx_flow->description, "from");
-        strcat(gx_flow->description, &to_str[strlen("to")]);
-        strcat(gx_flow->description, " to");
-        strncat(gx_flow->description, &from_str[strlen("from")],
-                strlen(from_str) - strlen(to_str) - strlen("from") - 1);
-        ogs_assert(len == strlen(gx_flow->description)+1);
-    } else {
-        ogs_error("Invalid Flow Descripton : [%s]", rx_flow->description);
-        return OGS_ERROR;
-    }
-
-    return OGS_OK;
-}
-
-static int matched_flow(ogs_pcc_rule_t *pcc_rule,
-        ogs_media_component_t *media_component)
-{
-    int rv;
-    int i, j, k;
-    int matched = 0;
-    int new = 0;
-
-    ogs_assert(pcc_rule);
-    ogs_assert(media_component);
-
-    for (i = 0; i < media_component->num_of_sub; i++) {
-        ogs_media_sub_component_t *sub = &media_component->sub[i];
-
-        if (sub->flow_number == 0) {
-            continue;
-        }
-
-        for (j = 0; j < sub->num_of_flow; j++) {
-            new++;
-        }
-    }
-
-    if (new == 0) {
-        /* No new flow in Media-Component */
-        return pcc_rule->num_of_flow;
-    }
-
-    for (i = 0; i < media_component->num_of_sub; i++) {
-        ogs_media_sub_component_t *sub = &media_component->sub[i];
-
-        if (sub->flow_number == 0) {
-            continue;
-        }
-
-        for (j = 0; j < sub->num_of_flow &&
-                    j < OGS_MAX_NUM_OF_FLOW_IN_MEDIA_SUB_COMPONENT; j++) {
-            ogs_flow_t gx_flow;
-            ogs_flow_t *rx_flow = &sub->flow[j];
-
-            rv = flow_rx_to_gx(rx_flow, &gx_flow);
-            if (rv != OGS_OK) {
-                ogs_error("flow reformatting error");
-                return OGS_ERROR;
-            }
-
-            for (k = 0; k < pcc_rule->num_of_flow; k++) {
-                if (gx_flow.direction == pcc_rule->flow[k].direction &&
-                    !strcmp(gx_flow.description,
-                        pcc_rule->flow[k].description)) {
-                    matched++;
-                    break;
-                }
-            }
-
-            OGS_FLOW_FREE(&gx_flow);
-        }
-    }
-
-    return matched;
-}
-
-static int install_flow(ogs_pcc_rule_t *pcc_rule,
-        ogs_media_component_t *media_component)
-{
-    int rv;
-    int i, j;
-
-    ogs_assert(pcc_rule);
-    ogs_assert(media_component);
-
-    /* Remove Flow from PCC Rule */
-    for (i = 0; i < pcc_rule->num_of_flow; i++) {
-        OGS_FLOW_FREE(&pcc_rule->flow[i]);
-    }
-    pcc_rule->num_of_flow = 0;
-
-    for (i = 0; i < media_component->num_of_sub; i++) {
-        ogs_media_sub_component_t *sub = &media_component->sub[i];
-
-        if (sub->flow_number == 0) {
-            continue;
-        }
-
-        /* Copy Flow to PCC Rule */
-        for (j = 0; j < sub->num_of_flow &&
-                    j < OGS_MAX_NUM_OF_FLOW_IN_MEDIA_SUB_COMPONENT; j++) {
-            ogs_flow_t *rx_flow = NULL;
-            ogs_flow_t *gx_flow = NULL;
-
-            if (pcc_rule->num_of_flow < OGS_MAX_NUM_OF_FLOW_IN_PCC_RULE) {
-                rx_flow = &sub->flow[j];
-                gx_flow = &pcc_rule->flow[pcc_rule->num_of_flow];
-
-                rv = flow_rx_to_gx(rx_flow, gx_flow);
-                if (rv != OGS_OK) {
-                    ogs_error("flow reformatting error");
-                    return OGS_ERROR;
-                }
-
-                pcc_rule->num_of_flow++;
-            } else {
-                ogs_error("Overflow: Number of Flow");
-                return OGS_ERROR;
-            }
-        }
-    }
-
-    return OGS_OK;
-}
-
-static int update_qos(ogs_pcc_rule_t *pcc_rule,
-        ogs_media_component_t *media_component)
-{
-    int rv;
-    int i, j;
-
-    ogs_assert(pcc_rule);
-    ogs_assert(media_component);
-
-    pcc_rule->qos.mbr.downlink = 0;
-    pcc_rule->qos.mbr.uplink = 0;
-    pcc_rule->qos.gbr.downlink = 0;
-    pcc_rule->qos.gbr.uplink = 0;
-
-    for (i = 0; i < media_component->num_of_sub; i++) {
-        ogs_media_sub_component_t *sub = &media_component->sub[i];
-
-        if (sub->flow_number == 0) {
-            continue;
-        }
-
-        for (j = 0; j < sub->num_of_flow &&
-                    j < OGS_MAX_NUM_OF_FLOW_IN_MEDIA_SUB_COMPONENT; j++) {
-            ogs_flow_t gx_flow;
-            ogs_flow_t *rx_flow = &sub->flow[j];
-
-            rv = flow_rx_to_gx(rx_flow, &gx_flow);
-            if (rv != OGS_OK) {
-                ogs_error("flow reformatting error");
-                return OGS_ERROR;
-            }
-
-            if (gx_flow.direction == OGS_FLOW_DOWNLINK_ONLY) {
-                if (sub->flow_usage == OGS_DIAM_RX_FLOW_USAGE_RTCP) {
-                    if (media_component->rr_bandwidth && 
-                        media_component->rs_bandwidth) {
-                        pcc_rule->qos.mbr.downlink +=
-                            (media_component->rr_bandwidth +
-                            media_component->rs_bandwidth);
-                    } else if (media_component->max_requested_bandwidth_dl) {
-                        if (media_component->rr_bandwidth && 
-                            !media_component->rs_bandwidth) {
-                            pcc_rule->qos.mbr.downlink +=
-                                ogs_max(0.05 *
-                                    media_component->max_requested_bandwidth_dl,
-                                    media_component->rr_bandwidth);
-                        }
-                        if (!media_component->rr_bandwidth && 
-                            media_component->rs_bandwidth) {
-                            pcc_rule->qos.mbr.downlink +=
-                                ogs_max(0.05 *
-                                    media_component->max_requested_bandwidth_dl,
-                                    media_component->rs_bandwidth);
-                        }
-                        if (!media_component->rr_bandwidth && 
-                            !media_component->rs_bandwidth) {
-                            pcc_rule->qos.mbr.downlink +=
-                                0.05 *
-                                    media_component->max_requested_bandwidth_dl;
-                        }
-                    }
-                } else {
-                    if (gx_flow.description) {
-                        pcc_rule->qos.mbr.downlink +=
-                            media_component->max_requested_bandwidth_dl;
-                        pcc_rule->qos.gbr.downlink +=
-                            media_component->min_requested_bandwidth_dl;
-                    }
-                }
-            } else if (gx_flow.direction == OGS_FLOW_UPLINK_ONLY) {
-                if (sub->flow_usage == OGS_DIAM_RX_FLOW_USAGE_RTCP) {
-                    if (media_component->rr_bandwidth && 
-                        media_component->rs_bandwidth) {
-                        pcc_rule->qos.mbr.uplink +=
-                            (media_component->rr_bandwidth +
-                            media_component->rs_bandwidth);
-                    } else if (media_component->max_requested_bandwidth_ul) {
-                        if (media_component->rr_bandwidth && 
-                            !media_component->rs_bandwidth) {
-                            pcc_rule->qos.mbr.uplink +=
-                                ogs_max(0.05 *
-                                    media_component->max_requested_bandwidth_ul,
-                                    media_component->rr_bandwidth);
-                        }
-                        if (!media_component->rr_bandwidth && 
-                            media_component->rs_bandwidth) {
-                            pcc_rule->qos.mbr.uplink +=
-                                ogs_max(0.05 *
-                                    media_component->max_requested_bandwidth_ul,
-                                    media_component->rs_bandwidth);
-                        }
-                        if (!media_component->rr_bandwidth && 
-                            !media_component->rs_bandwidth) {
-                            pcc_rule->qos.mbr.uplink +=
-                                0.05 *
-                                    media_component->max_requested_bandwidth_ul;
-                        }
-                    }
-                } else {
-                    if (gx_flow.description) {
-                        pcc_rule->qos.mbr.uplink +=
-                            media_component->max_requested_bandwidth_ul;
-                        pcc_rule->qos.gbr.uplink +=
-                            media_component->min_requested_bandwidth_ul;
-                    }
-                }
-            } else
-                ogs_assert_if_reached();
-
-            OGS_FLOW_FREE(&gx_flow);
-        }
-    }
-
-    if (pcc_rule->qos.mbr.downlink == 0) {
-        pcc_rule->qos.mbr.downlink +=
-            media_component->max_requested_bandwidth_dl;
-        pcc_rule->qos.mbr.downlink +=
-            (media_component->rr_bandwidth + media_component->rs_bandwidth);
-    }
-
-    if (pcc_rule->qos.mbr.uplink == 0) {
-        pcc_rule->qos.mbr.uplink +=
-            media_component->max_requested_bandwidth_ul;
-        pcc_rule->qos.mbr.uplink +=
-            (media_component->rr_bandwidth + media_component->rs_bandwidth);
-    }
-
-    if (pcc_rule->qos.gbr.downlink == 0)
-        pcc_rule->qos.gbr.downlink = pcc_rule->qos.mbr.downlink;
-    if (pcc_rule->qos.gbr.uplink == 0)
-        pcc_rule->qos.gbr.uplink = pcc_rule->qos.mbr.uplink;
-
-    return OGS_OK;
-}

src/pcrf/pcrf-rx-path.c

@@ -273,12 +273,23 @@ static int pcrf_rx_aar_cb( struct msg **msg, struct avp *avp,
                         ogs_assert(ret == 0);
                         switch (hdr->avp_code) {
                         case OGS_DIAM_RX_AVP_CODE_FLOW_NUMBER:
-                            sub->flow_number =
-                                hdr->avp_value->i32;
+                            sub->flow_number = hdr->avp_value->i32;
                             break;
                         case OGS_DIAM_RX_AVP_CODE_FLOW_USAGE:
-                            sub->flow_usage =
-                                hdr->avp_value->i32;
+                            switch (hdr->avp_value->i32) {
+                            case OGS_DIAM_RX_FLOW_USAGE_NO_INFORMATION:
+                                sub->flow_usage = OGS_FLOW_USAGE_NO_INFO;
+                                break;
+                            case OGS_DIAM_RX_FLOW_USAGE_RTCP:
+                                sub->flow_usage = OGS_FLOW_USAGE_RTCP;
+                                break;
+                            case OGS_DIAM_RX_FLOW_USAGE_AF_SIGNALLING:
+                                sub->flow_usage = OGS_FLOW_USAGE_AF_SIGNALLING;
+                                break;
+                            default:
+                                ogs_error("Invalid flow usage = %d",
+                                    hdr->avp_value->i32);
+                            }
                             break;
                         case OGS_DIAM_RX_AVP_CODE_FLOW_DESCRIPTION:
                             ogs_assert(sub->num_of_flow <

src/smf/binding.c

@@ -115,15 +115,12 @@ void smf_bearer_binding(smf_sess_t *sess)
 
     ogs_assert(sess);
 
-    for (i = 0; i < sess->num_of_pcc_rule; i++) {
+    for (i = 0; i < sess->policy.num_of_pcc_rule; i++) {
         ogs_gtp_xact_t *xact = NULL;
         ogs_gtp_header_t h;
         ogs_pkbuf_t *pkbuf = NULL;
         smf_bearer_t *bearer = NULL;
-
-        ogs_pcc_rule_t *pcc_rule = &sess->pcc_rule[i];
-        int bearer_created = 0;
-        int qos_presence = 0;
+        ogs_pcc_rule_t *pcc_rule = &sess->policy.pcc_rule[i];
 
         ogs_assert(pcc_rule);
         if (pcc_rule->name == NULL) {
@@ -132,10 +129,13 @@ void smf_bearer_binding(smf_sess_t *sess)
         }
 
         if (pcc_rule->type == OGS_PCC_RULE_TYPE_INSTALL) {
-            ogs_pfcp_pdr_t *dl_pdr = NULL, *ul_pdr = NULL;
+            bool bearer_created = false;
+            bool qos_presence = false;
 
             bearer = smf_bearer_find_by_pcc_rule_name(sess, pcc_rule->name);
             if (!bearer) {
+                ogs_pfcp_pdr_t *dl_pdr = NULL, *ul_pdr = NULL;
+
                 if (pcc_rule->num_of_flow == 0) {
                     /* TFT is mandatory in
                      * activate dedicated EPS bearer context request */
@@ -210,7 +210,7 @@ void smf_bearer_binding(smf_sess_t *sess)
 
                 memcpy(&bearer->qos, &pcc_rule->qos, sizeof(ogs_qos_t));
 
-                bearer_created = 1;
+                bearer_created = true;
 
             } else {
                 ogs_assert(strcmp(bearer->pcc_rule.name, pcc_rule->name) == 0);
@@ -227,55 +227,46 @@ void smf_bearer_binding(smf_sess_t *sess)
                     memcpy(&bearer->qos, &pcc_rule->qos, sizeof(ogs_qos_t));
 
                     /* Update Bearer Request encodes updated QoS parameter */
-                    qos_presence = 1;
-                }
-
-                if (pcc_rule->num_of_flow == 0 && qos_presence == 0) {
-                    ogs_warn("No need to send 'Update Bearer Request'");
-                    ogs_warn("  - Both QoS and TFT are same as before");
-                    continue;
+                    qos_presence = true;
                 }
             }
 
-            dl_pdr = bearer->dl_pdr;
-            ogs_assert(dl_pdr);
-            ul_pdr = bearer->ul_pdr;
-            ogs_assert(ul_pdr);
-
-            dl_pdr->num_of_flow = 0;
-            ul_pdr->num_of_flow = 0;
-
+            /*
+             * We only use the method of adding a flow to an existing tft.
+             *
+             * EPC: OGS_GTP_TFT_CODE_ADD_PACKET_FILTERS_TO_EXISTING_TFT
+             * 5GC: OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_ADD_PACKET_FILTERS
+             */
             ogs_list_init(&bearer->pf_to_add_list);
 
             for (j = 0; j < pcc_rule->num_of_flow; j++) {
-                ogs_flow_t *flow = &pcc_rule->flow[j];
                 smf_pf_t *pf = NULL;
+                ogs_flow_t *flow = &pcc_rule->flow[j];
 
                 ogs_expect_or_return(flow);
                 ogs_expect_or_return(flow->description);
 
+                /*
+                 * To add a flow to an existing tft.
+                 * duplicated flows are not added
+                 */
                 if (smf_pf_find_by_flow(
                     bearer, flow->direction, flow->description) != NULL) {
                     continue;
                 }
 
-                if (flow->direction == OGS_FLOW_DOWNLINK_ONLY) {
-                    dl_pdr->flow_description[dl_pdr->num_of_flow++] =
-                        flow->description;
-                } else if (flow->direction == OGS_FLOW_UPLINK_ONLY) {
-                    ul_pdr->flow_description[ul_pdr->num_of_flow++] =
-                        flow->description;
-                } else {
-                    ogs_error("Flow Bidirectional is not supported[%d]",
-                            flow->direction);
-                }
-
+                /*
+                 * To add a flow to an existing tft.
+                 *
+                 * Only new flows are added to the PF list.
+                 * Then, in the PF list, there are all flows
+                 * from the beginning to the present.
+                 */
                 pf = smf_pf_add(bearer);
                 if (!pf) {
                     ogs_error("Overflow: PacketFilter in Bearer");
                     break;
                 }
-                ogs_assert(pf);
 
                 pf->direction = flow->direction;
                 pf->flow_description = ogs_strdup(flow->description);
@@ -307,45 +298,37 @@ void smf_bearer_binding(smf_sess_t *sess)
                     break;
                 }
 
+                /*
+                 * To add a flow to an existing tft.
+                 *
+                 * 'pf_to_add_list' now has the added flow.
+                 */
                 ogs_list_add(&bearer->pf_to_add_list, &pf->to_add_node);
             }
 
-            if (bearer_created == 1) {
-                /* Setup QER */
-                if (bearer->qos.mbr.downlink || bearer->qos.mbr.uplink ||
-                    bearer->qos.gbr.downlink || bearer->qos.gbr.uplink) {
-                    ogs_pfcp_qer_t *qer = NULL;
+            if (bearer_created == false &&
+                qos_presence == false &&
+                ogs_list_count(&bearer->pf_to_add_list) == 0) {
+                ogs_error("No need to send 'Update Bearer Request'");
+                ogs_error("bearer_created:%d, qos_presence:%d, rule_count:%d",
+                    bearer_created, qos_presence,
+                    ogs_list_count(&bearer->pf_to_add_list));
+                continue;
+            }
 
-                    /* Only 1 QER is used per bearer */
-                    qer = bearer->qer;
-                    if (!qer) {
-                        qer = ogs_pfcp_qer_add(&sess->pfcp);
-                        ogs_assert(qer);
-                        bearer->qer = qer;
-                    }
+            if (bearer_created == true) {
 
-                    ogs_pfcp_pdr_associate_qer(bearer->dl_pdr, qer);
-                    ogs_pfcp_pdr_associate_qer(bearer->ul_pdr, qer);
-
-                    qer->mbr.uplink = bearer->qos.mbr.uplink;
-                    qer->mbr.downlink = bearer->qos.mbr.downlink;
-                    qer->gbr.uplink = bearer->qos.gbr.uplink;
-                    qer->gbr.downlink = bearer->qos.gbr.downlink;
-                }
+                smf_bearer_tft_update(bearer);
+                smf_bearer_qos_update(bearer);
 
                 ogs_assert(OGS_OK ==
                     smf_epc_pfcp_send_bearer_modification_request(
                         bearer, OGS_PFCP_MODIFY_CREATE));
-
             } else {
                 ogs_gtp_tft_t tft;
 
                 memset(&tft, 0, sizeof tft);
-                if (pcc_rule->num_of_flow) {
-                    if (ogs_list_count(&bearer->pf_to_add_list) == 0) {
-                        ogs_error("No need to send 'Update Bearer Request'");
-                        continue;
-                    }
+                if (ogs_list_count(&bearer->pf_to_add_list) > 0) {
                     encode_traffic_flow_template(
                         &tft, bearer,
                         OGS_GTP_TFT_CODE_ADD_PACKET_FILTERS_TO_EXISTING_TFT);
@@ -358,16 +341,17 @@ void smf_bearer_binding(smf_sess_t *sess)
                 pkbuf = smf_s5c_build_update_bearer_request(
                         h.type, bearer,
                         OGS_NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED,
-                        pcc_rule->num_of_flow ? &tft : NULL, qos_presence);
+                        (ogs_list_count(&bearer->pf_to_add_list) > 0) ?
+                            &tft : NULL, qos_presence);
                 ogs_expect_or_return(pkbuf);
 
                 xact = ogs_gtp_xact_local_create(
                         sess->gnode, &h, pkbuf, bearer_timeout, bearer);
                 ogs_expect_or_return(xact);
 
-                if (pcc_rule->num_of_flow)
+                if (ogs_list_count(&bearer->pf_to_add_list) > 0)
                     xact->update_flags |= OGS_GTP_MODIFY_TFT_UPDATE;
-                if (qos_presence)
+                if (qos_presence == true)
                     xact->update_flags |= OGS_GTP_MODIFY_QOS_UPDATE;
 
                 rv = ogs_gtp_xact_commit(xact);
@@ -428,23 +412,16 @@ int smf_gtp_send_create_bearer_request(smf_bearer_t *bearer)
     return rv;
 }
 
-void smf_qos_flow_binding(smf_sess_t *sess, ogs_sbi_stream_t *stream)
+void smf_qos_flow_binding(smf_sess_t *sess)
 {
     int rv;
     int i, j;
 
     ogs_assert(sess);
 
-    for (i = 0; i < sess->num_of_pcc_rule; i++) {
-#if 0
-        ogs_gtp_header_t h;
-        ogs_pkbuf_t *pkbuf = NULL;
-#endif
+    for (i = 0; i < sess->policy.num_of_pcc_rule; i++) {
         smf_bearer_t *qos_flow = NULL;
-
-        ogs_pcc_rule_t *pcc_rule = &sess->pcc_rule[i];
-        int qos_flow_created = 0;
-        int qos_presence = 0;
+        ogs_pcc_rule_t *pcc_rule = &sess->policy.pcc_rule[i];
 
         ogs_assert(pcc_rule);
         if (pcc_rule->id == NULL) {
@@ -453,8 +430,12 @@ void smf_qos_flow_binding(smf_sess_t *sess, ogs_sbi_stream_t *stream)
         }
 
         if (pcc_rule->type == OGS_PCC_RULE_TYPE_INSTALL) {
+            smf_pf_t *pf = NULL;
             ogs_pfcp_pdr_t *dl_pdr = NULL, *ul_pdr = NULL;
 
+            bool qos_flow_created = false;
+            bool qos_presence = false;
+
             qos_flow = smf_qos_flow_find_by_pcc_rule_id(sess, pcc_rule->id);
             if (!qos_flow) {
                 if (pcc_rule->num_of_flow == 0) {
@@ -504,11 +485,9 @@ void smf_qos_flow_binding(smf_sess_t *sess, ogs_sbi_stream_t *stream)
 
                 memcpy(&qos_flow->qos, &pcc_rule->qos, sizeof(ogs_qos_t));
 
-                qos_flow_created = 1;
+                qos_flow_created = true;
 
             } else {
-                ogs_fatal("Update QoS Flow: Not implemented in 5G Core");
-                ogs_assert_if_reached();
                 ogs_assert(strcmp(qos_flow->pcc_rule.id, pcc_rule->id) == 0);
 
                 if ((pcc_rule->qos.mbr.downlink &&
@@ -523,51 +502,45 @@ void smf_qos_flow_binding(smf_sess_t *sess, ogs_sbi_stream_t *stream)
                     memcpy(&qos_flow->qos, &pcc_rule->qos, sizeof(ogs_qos_t));
 
                     /* Update Bearer Request encodes updated QoS parameter */
-                    qos_presence = 1;
-                }
-
-                if (pcc_rule->num_of_flow == 0 && qos_presence == 0) {
-                    ogs_warn("No need to send 'Session Modification Request'");
-                    ogs_warn("  - Both QoS and TFT are same as before");
-                    continue;
+                    qos_presence = true;
                 }
             }
 
-            dl_pdr = qos_flow->dl_pdr;
-            ogs_assert(dl_pdr);
-            ul_pdr = qos_flow->ul_pdr;
-            ogs_assert(ul_pdr);
-
-            dl_pdr->num_of_flow = 0;
-            ul_pdr->num_of_flow = 0;
-
+            /*
+             * We only use the method of adding a flow to an existing tft.
+             *
+             * EPC: OGS_GTP_TFT_CODE_ADD_PACKET_FILTERS_TO_EXISTING_TFT
+             * 5GC: OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_ADD_PACKET_FILTERS
+             */
             ogs_list_init(&qos_flow->pf_to_add_list);
 
             for (j = 0; j < pcc_rule->num_of_flow; j++) {
                 ogs_flow_t *flow = &pcc_rule->flow[j];
-                smf_pf_t *pf = NULL;
 
                 ogs_expect_or_return(flow);
                 ogs_expect_or_return(flow->description);
 
+                /*
+                 * To add a flow to an existing tft.
+                 * duplicated flows are not added
+                 */
                 if (smf_pf_find_by_flow(
                     qos_flow, flow->direction, flow->description) != NULL) {
                     continue;
                 }
 
-                if (flow->direction == OGS_FLOW_DOWNLINK_ONLY) {
-                    dl_pdr->flow_description[dl_pdr->num_of_flow++] =
-                        flow->description;
-                } else if (flow->direction == OGS_FLOW_UPLINK_ONLY) {
-                    ul_pdr->flow_description[ul_pdr->num_of_flow++] =
-                        flow->description;
-                } else {
-                    ogs_error("Flow Bidirectional is not supported[%d]",
-                            flow->direction);
-                }
-
+                /*
+                 * To add a flow to an existing tft.
+                 *
+                 * Only new flows are added to the PF list.
+                 * Then, in the PF list, there are all flows
+                 * from the beginning to the present.
+                 */
                 pf = smf_pf_add(qos_flow);
-                ogs_assert(pf);
+                if (!pf) {
+                    ogs_error("Overflow: PacketFilter in Bearer");
+                    break;
+                }
 
                 pf->direction = flow->direction;
                 pf->flow_description = ogs_strdup(flow->description);
@@ -599,99 +572,67 @@ void smf_qos_flow_binding(smf_sess_t *sess, ogs_sbi_stream_t *stream)
                     break;
                 }
 
+                /*
+                 * To add a flow to an existing tft.
+                 *
+                 * 'pf_to_add_list' now has the added flow.
+                 */
                 ogs_list_add(&qos_flow->pf_to_add_list, &pf->to_add_node);
             }
 
-            if (qos_flow_created == 1) {
-                /* Setup QER */
-                if (qos_flow->qos.mbr.downlink || qos_flow->qos.mbr.uplink ||
-                    qos_flow->qos.gbr.downlink || qos_flow->qos.gbr.uplink) {
-                    ogs_pfcp_qer_t *qer = NULL;
+            if (qos_flow_created == false &&
+                qos_presence == false &&
+                ogs_list_count(&qos_flow->pf_to_add_list) == 0) {
+                ogs_error("No need to send 'Session Modification Request'");
+                ogs_error("qos_flow_created:%d, qos_presence:%d, rule_count:%d",
+                    qos_flow_created, qos_presence,
+                    ogs_list_count(&qos_flow->pf_to_add_list));
+                continue;
+            }
 
-                    /* Only 1 QER is used per qos_flow */
-                    qer = qos_flow->qer;
-                    if (!qer) {
-                        qer = ogs_pfcp_qer_add(&sess->pfcp);
-                        ogs_assert(qer);
-                        qos_flow->qer = qer;
-                    }
+            if (qos_flow_created == true) {
+                smf_bearer_tft_update(qos_flow);
+                smf_bearer_qos_update(qos_flow);
 
-                    ogs_pfcp_pdr_associate_qer(qos_flow->dl_pdr, qer);
-                    ogs_pfcp_pdr_associate_qer(qos_flow->ul_pdr, qer);
+                ogs_assert(OGS_OK ==
+                    smf_5gc_pfcp_send_qos_flow_modification_request(
+                        qos_flow, NULL,
+                        OGS_PFCP_MODIFY_NETWORK_REQUESTED|
+                        OGS_PFCP_MODIFY_CREATE));
 
-                    qer->mbr.uplink = qos_flow->qos.mbr.uplink;
-                    qer->mbr.downlink = qos_flow->qos.mbr.downlink;
-                    qer->gbr.uplink = qos_flow->qos.gbr.uplink;
-                    qer->gbr.downlink = qos_flow->qos.gbr.downlink;
+            } else {
+                uint64_t pfcp_flags = 0;
+
+                pfcp_flags |= OGS_PFCP_MODIFY_NETWORK_REQUESTED;
+
+                if (ogs_list_count(&qos_flow->pf_to_add_list) > 0) {
+                    pfcp_flags |= OGS_PFCP_MODIFY_TFT_ADD;
+                    smf_bearer_tft_update(qos_flow);
+                }
+                if (qos_presence == true) {
+                    pfcp_flags |= OGS_PFCP_MODIFY_QOS_MODIFY;
+                    smf_bearer_qos_update(qos_flow);
                 }
 
                 ogs_assert(OGS_OK ==
                     smf_5gc_pfcp_send_qos_flow_modification_request(
-                        qos_flow, NULL, OGS_PFCP_MODIFY_CREATE));
-
-            } else {
-                ogs_fatal("Update Qos Flow Not Implemented");
-                ogs_assert_if_reached();
-#if 0
-                ogs_gtp_tft_t tft;
-
-                memset(&tft, 0, sizeof tft);
-                if (pcc_rule->num_of_flow)
-                    encode_traffic_flow_template(
-                        &tft, qos_flow,
-                        OGS_GTP_TFT_CODE_ADD_PACKET_FILTERS_TO_EXISTING_TFT);
-
-                memset(&h, 0, sizeof(ogs_gtp_header_t));
-                h.type = OGS_GTP_UPDATE_BEARER_REQUEST_TYPE;
-                h.teid = sess->sgw_s5c_teid;
-
-                pkbuf = smf_s5c_build_update_qos_flow_request(
-                        h.type, qos_flow,
-                        OGS_NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED,
-                        pcc_rule->num_of_flow ? &tft : NULL, qos_presence);
-                ogs_expect_or_return(pkbuf);
-
-                xact = ogs_gtp_xact_local_create(
-                        sess->gnode, &h, pkbuf, qos_flow_timeout, qos_flow);
-                ogs_expect_or_return(xact);
-
-                if (pcc_rule->num_of_flow)
-                    xact->update_flags |= OGS_GTP_MODIFY_TFT_UPDATE;
-                if (qos_presence)
-                    xact->update_flags |= OGS_GTP_MODIFY_QOS_UPDATE;
-
-                rv = ogs_gtp_xact_commit(xact);
-                ogs_expect(rv == OGS_OK);
-#endif
+                        qos_flow, NULL, pfcp_flags));
             }
         } else if (pcc_rule->type == OGS_PCC_RULE_TYPE_REMOVE) {
-            ogs_fatal("Remove Type Not Implemented");
-            ogs_assert_if_reached();
-#if 0
-            qos_flow = smf_qos_flow_find_by_name(sess, pcc_rule->name);
+            qos_flow = smf_qos_flow_find_by_pcc_rule_id(sess, pcc_rule->id);
 
             if (!qos_flow) {
-                ogs_warn("No need to send 'Delete Bearer Request'");
-                ogs_warn("  - Bearer[Name:%s] has already been removed.",
-                        pcc_rule->name);
+                ogs_warn("No need to send 'Session Modification Request'");
+                ogs_warn("  - QosFlow[Id:%s] has already been removed.",
+                        pcc_rule->id);
                 continue;
             }
 
-            memset(&h, 0, sizeof(ogs_gtp_header_t));
-            h.type = OGS_GTP_DELETE_BEARER_REQUEST_TYPE;
-            h.teid = sess->sgw_s5c_teid;
+            ogs_assert(OGS_OK ==
+                smf_5gc_pfcp_send_qos_flow_modification_request(
+                    qos_flow, NULL, 
+                    OGS_PFCP_MODIFY_NETWORK_REQUESTED|OGS_PFCP_MODIFY_REMOVE));
 
-            pkbuf = smf_s5c_build_delete_qos_flow_request(h.type, qos_flow,
-                    OGS_NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED);
-            ogs_expect_or_return(pkbuf);
-
-            xact = ogs_gtp_xact_local_create(
-                    sess->gnode, &h, pkbuf, qos_flow_timeout, qos_flow);
-            ogs_expect_or_return(xact);
-
-            rv = ogs_gtp_xact_commit(xact);
-            ogs_expect(rv == OGS_OK);
-#endif
         } else {
             ogs_error("Invalid Type[%d]", pcc_rule->type);
             ogs_assert_if_reached();

src/smf/binding.h

@@ -29,7 +29,7 @@ extern "C" {
 void smf_bearer_binding(smf_sess_t *sess);
 int smf_gtp_send_create_bearer_request(smf_bearer_t *bearer);
 
-void smf_qos_flow_binding(smf_sess_t *sess, ogs_sbi_stream_t *stream);
+void smf_qos_flow_binding(smf_sess_t *sess);
 
 #ifdef __cplusplus
 }

src/smf/context.c

@@ -1423,9 +1423,9 @@ void smf_sess_remove(smf_sess_t *sess)
 
     OGS_NAS_CLEAR_DATA(&sess->nas.ue_pco);
 
-    for (i = 0; i < sess->num_of_pcc_rule; i++)
-        OGS_PCC_RULE_FREE(&sess->pcc_rule[i]);
-    sess->num_of_pcc_rule = 0;
+    for (i = 0; i < sess->policy.num_of_pcc_rule; i++)
+        OGS_PCC_RULE_FREE(&sess->policy.pcc_rule[i]);
+    sess->policy.num_of_pcc_rule = 0;
 
     if (sess->ipv4) {
         ogs_hash_set(self.ipv4_hash, sess->ipv4->addr, OGS_IPV4_LEN, NULL);
@@ -1584,6 +1584,23 @@ smf_sess_t *smf_sess_find_by_paging_n1n2message_location(
             n1n2message_location, strlen(n1n2message_location));
 }
 
+ogs_pcc_rule_t *smf_pcc_rule_find_by_id(smf_sess_t *sess, char *pcc_rule_id)
+{
+    int i;
+
+    ogs_assert(sess);
+    ogs_assert(pcc_rule_id);
+
+    for (i = 0; i < sess->policy.num_of_pcc_rule; i++) {
+        ogs_pcc_rule_t *pcc_rule = &sess->policy.pcc_rule[i];
+        if (pcc_rule->id && strcmp(pcc_rule->id, pcc_rule_id) == 0) {
+            return pcc_rule;
+        }
+    }
+
+    return NULL;
+}
+
 smf_bearer_t *smf_qos_flow_add(smf_sess_t *sess)
 {
     smf_bearer_t *qos_flow = NULL;
@@ -2140,6 +2157,69 @@ smf_bearer_t *smf_bearer_find_by_pdr_id(
     return NULL;
 }
 
+void smf_bearer_tft_update(smf_bearer_t *bearer)
+{
+    smf_pf_t *pf = NULL;
+    ogs_pfcp_pdr_t *dl_pdr = NULL, *ul_pdr = NULL;
+
+    ogs_assert(bearer);
+
+    dl_pdr = bearer->dl_pdr;
+    ogs_assert(dl_pdr);
+    ul_pdr = bearer->ul_pdr;
+    ogs_assert(ul_pdr);
+
+    dl_pdr->num_of_flow = 0;
+    ul_pdr->num_of_flow = 0;
+
+    ogs_list_for_each(&bearer->pf_list, pf) {
+        if (pf->direction == OGS_FLOW_DOWNLINK_ONLY) {
+            dl_pdr->flow_description[dl_pdr->num_of_flow++] =
+                pf->flow_description;
+
+        } else if (pf->direction == OGS_FLOW_UPLINK_ONLY) {
+            ul_pdr->flow_description[ul_pdr->num_of_flow++] =
+                pf->flow_description;
+        } else {
+            ogs_assert_if_reached();
+            ogs_fatal("Flow Bidirectional is not supported[%d]",
+                    pf->direction);
+        }
+    }
+}
+
+void smf_bearer_qos_update(smf_bearer_t *bearer)
+{
+    smf_sess_t *sess = NULL;
+
+    ogs_pfcp_pdr_t *dl_pdr = NULL, *ul_pdr = NULL;
+    ogs_pfcp_qer_t *qer = NULL;
+
+    ogs_assert(bearer);
+    sess = bearer->sess;
+    ogs_assert(sess);
+
+    dl_pdr = bearer->dl_pdr;
+    ogs_assert(dl_pdr);
+    ul_pdr = bearer->ul_pdr;
+    ogs_assert(ul_pdr);
+
+    qer = bearer->qer;
+    if (!qer) {
+        qer = ogs_pfcp_qer_add(&sess->pfcp);
+        ogs_assert(qer);
+        bearer->qer = qer;
+    }
+
+    ogs_pfcp_pdr_associate_qer(dl_pdr, qer);
+    ogs_pfcp_pdr_associate_qer(ul_pdr, qer);
+
+    qer->mbr.uplink = bearer->qos.mbr.uplink;
+    qer->mbr.downlink = bearer->qos.mbr.downlink;
+    qer->gbr.uplink = bearer->qos.gbr.uplink;
+    qer->gbr.downlink = bearer->qos.gbr.downlink;
+}
+
 smf_bearer_t *smf_default_bearer_in_sess(smf_sess_t *sess)
 {
     ogs_assert(sess);

src/smf/context.h

@@ -137,7 +137,6 @@ ED3(uint8_t spare:2;,
     uint8_t identifier:4;)
 
     uint8_t precedence;             /* Only used in EPC */
-    uint8_t epc_precedence;         /* Only used in EPC */
 
     uint8_t *identifier_node;       /* Pool-Node for Identifier */
     uint8_t *precedence_node;       /* Pool-Node for Precedence */
@@ -150,6 +149,10 @@ ED3(uint8_t spare:2;,
 
 typedef struct smf_bearer_s {
     ogs_lnode_t     lnode;          /**< A node of list_t */
+
+    ogs_lnode_t     to_update_node;
+    ogs_lnode_t     to_delete_node;
+
     uint32_t        index;
 
     ogs_pfcp_pdr_t  *dl_pdr;
@@ -182,6 +185,9 @@ typedef struct smf_bearer_s {
     ogs_list_t      pf_list;
     ogs_list_t      pf_to_add_list;
 
+    uint8_t num_of_pf_to_delete;
+    uint8_t pf_to_delete[OGS_MAX_NUM_OF_FLOW_IN_NAS];
+
     smf_sess_t      *sess;
 } smf_bearer_t;
 
@@ -285,8 +291,10 @@ typedef struct smf_sess_s {
         ogs_nas_extended_protocol_configuration_options_t ue_pco;
     } nas; /* Saved from NAS-5GS */
 
-    ogs_pcc_rule_t  pcc_rule[OGS_MAX_NUM_OF_PCC_RULE]; /* Saved from Gx */
-    int             num_of_pcc_rule;
+    struct {
+        ogs_pcc_rule_t  pcc_rule[OGS_MAX_NUM_OF_PCC_RULE];
+        int             num_of_pcc_rule;
+    } policy; /* Saved from N7 or Gx */
 
     /* Paging */
     struct {
@@ -300,7 +308,8 @@ typedef struct smf_sess_s {
     /* State */
 #define SMF_NGAP_STATE_NONE                                     0
 #define SMF_NGAP_STATE_DELETE_TRIGGER_UE_REQUESTED              1
-#define SMF_NGAP_STATE_ERROR_INDICATION_RECEIVED_FROM_5G_AN     2
+#define SMF_NGAP_STATE_DELETE_TRIGGER_PCF_INITIATED             2
+#define SMF_NGAP_STATE_ERROR_INDICATION_RECEIVED_FROM_5G_AN     3
     struct {
         int pdu_session_resource_release;
     } ngap_state;
@@ -391,6 +400,8 @@ void smf_sess_delete_indirect_data_forwarding(smf_sess_t *sess);
 void smf_sess_create_cp_up_data_forwarding(smf_sess_t *sess);
 void smf_sess_delete_cp_up_data_forwarding(smf_sess_t *sess);
 
+ogs_pcc_rule_t *smf_pcc_rule_find_by_id(smf_sess_t *sess, char *pcc_rule_id);
+
 smf_bearer_t *smf_qos_flow_add(smf_sess_t *sess);
 smf_bearer_t *smf_qos_flow_find_by_qfi(smf_sess_t *sess, uint8_t qfi);
 smf_bearer_t *smf_qos_flow_find_by_pcc_rule_id(
@@ -408,6 +419,9 @@ smf_bearer_t *smf_bearer_find_by_pdr_id(
         smf_sess_t *sess, ogs_pfcp_pdr_id_t pdr_id);
 smf_bearer_t *smf_default_bearer_in_sess(smf_sess_t *sess);
 
+void smf_bearer_tft_update(smf_bearer_t *bearer);
+void smf_bearer_qos_update(smf_bearer_t *bearer);
+
 smf_ue_t *smf_ue_cycle(smf_ue_t *smf_ue);
 smf_sess_t *smf_sess_cycle(smf_sess_t *sess);
 smf_bearer_t *smf_qos_flow_cycle(smf_bearer_t *qos_flow);

src/smf/gsm-build.c

@@ -242,6 +242,9 @@ ogs_pkbuf_t *gsm_build_pdu_session_establishment_reject(
         pdu_session_establishment_reject =
             &message.gsm.pdu_session_establishment_reject;
 
+    ogs_assert(sess);
+    ogs_assert(gsm_cause);
+
     memset(&message, 0, sizeof(message));
     message.gsm.h.extended_protocol_discriminator =
             OGS_NAS_EXTENDED_PROTOCOL_DISCRIMINATOR_5GSM;
@@ -263,21 +266,33 @@ static void encode_qos_rule_packet_filter(
     ogs_assert(qos_rule);
     ogs_assert(qos_flow);
 
-    i = 0;
-    ogs_list_for_each(&qos_flow->pf_list, pf) {
-        ogs_assert(i < OGS_MAX_NUM_OF_FLOW_IN_NAS);
-        qos_rule->pf[i].direction = pf->direction;
-        qos_rule->pf[i].identifier = pf->identifier;
+    if (qos_rule->code == OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_DELETE_PACKET_FILTERS) {
+
+        for (i = 0; i < qos_flow->num_of_pf_to_delete; i++) {
+            qos_rule->pf[i].identifier = qos_flow->pf_to_delete[i];
+        }
+        qos_rule->num_of_packet_filter = qos_flow->num_of_pf_to_delete;
+
+    } else {
+
+        i = 0;
+        ogs_list_for_each_entry(&qos_flow->pf_to_add_list, pf, to_add_node) {
+            ogs_assert(i < OGS_MAX_NUM_OF_FLOW_IN_NAS);
+            qos_rule->pf[i].direction = pf->direction;
+            qos_rule->pf[i].identifier = pf->identifier;
+
+            ogs_pf_content_from_ipfw_rule(
+                    pf->direction, &qos_rule->pf[i].content, &pf->ipfw_rule);
+            i++;
+        }
+        qos_rule->num_of_packet_filter = i;
 
-        ogs_pf_content_from_ipfw_rule(
-                pf->direction, &qos_rule->pf[i].content, &pf->ipfw_rule);
-        i++;
     }
-    qos_rule->num_of_packet_filter = i;
 }
 
 ogs_pkbuf_t *gsm_build_qos_flow_modification_command(
-        smf_bearer_t *qos_flow, uint8_t pti)
+        smf_bearer_t *qos_flow, uint8_t pti,
+        uint8_t qos_rule_code, uint8_t qos_flow_description_code)
 {
     ogs_pkbuf_t *pkbuf = NULL;
     smf_sess_t *sess = NULL;
@@ -317,97 +332,145 @@ ogs_pkbuf_t *gsm_build_qos_flow_modification_command(
     message.gsm.h.message_type = OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMMAND;
 
     /* QoS rule */
-    memset(qos_rule, 0, sizeof(qos_rule));
-    qos_rule[0].identifier = qos_flow->qfi; /* Use QFI in Open5GS */
-    qos_rule[0].code = OGS_NAS_QOS_CODE_CREATE_NEW_QOS_RULE;
+    if (qos_rule_code) {
+        memset(qos_rule, 0, sizeof(qos_rule));
+        qos_rule[0].identifier = qos_flow->qfi; /* Use QFI in Open5GS */
+        qos_rule[0].code = qos_rule_code;
 
-    encode_qos_rule_packet_filter(&qos_rule[0], qos_flow);
+        if (qos_rule_code != OGS_NAS_QOS_CODE_DELETE_EXISTING_QOS_RULE &&
+            qos_rule_code != OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_WITHOUT_MODIFYING_PACKET_FILTERS)
+            encode_qos_rule_packet_filter(&qos_rule[0], qos_flow);
 
-    ogs_assert(dl_pdr->precedence > 0 && dl_pdr->precedence < 255);
-    qos_rule[0].precedence = dl_pdr->precedence; /* Use PCC Rule Precedence */
-    qos_rule[0].flow.segregation = 0;
-    qos_rule[0].flow.identifier = qos_flow->qfi;
+        if (qos_rule_code != OGS_NAS_QOS_CODE_DELETE_EXISTING_QOS_RULE &&
+            qos_rule_code != OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_DELETE_PACKET_FILTERS &&
+            qos_rule_code != OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_WITHOUT_MODIFYING_PACKET_FILTERS) {
+            ogs_assert(dl_pdr->precedence > 0 && dl_pdr->precedence < 255);
+            /* Use PCC Rule Precedence */
+            qos_rule[0].precedence = dl_pdr->precedence;
 
-    pdu_session_modification_command->presencemask |=
-        OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMMAND_AUTHORIZED_QOS_RULES_PRESENT;
-    rv = ogs_nas_build_qos_rules(authorized_qos_rules, qos_rule, 1);
-    ogs_expect_or_return_val(rv == OGS_OK, NULL);
-    ogs_expect_or_return_val(authorized_qos_rules->length, NULL);
+            qos_rule[0].flow.segregation = 0;
+            qos_rule[0].flow.identifier = qos_flow->qfi;
+        }
+
+        rv = ogs_nas_build_qos_rules(authorized_qos_rules, qos_rule, 1);
+        ogs_expect_or_return_val(rv == OGS_OK, NULL);
+        ogs_expect_or_return_val(authorized_qos_rules->length, NULL);
+
+        pdu_session_modification_command->presencemask |=
+            OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMMAND_AUTHORIZED_QOS_RULES_PRESENT;
+    }
 
     /* QoS flow descriptions */
-    memset(&qos_flow_description, 0, sizeof(qos_flow_description));
-    qos_flow_description[0].identifier = qos_flow->qfi;
-    qos_flow_description[0].code = OGS_NAS_CREATE_NEW_QOS_FLOW_DESCRIPTION;
-    qos_flow_description[0].E_bit = 1;
+    if (qos_flow_description_code) {
+        memset(&qos_flow_description, 0, sizeof(qos_flow_description));
+        qos_flow_description[0].identifier = qos_flow->qfi;
+        qos_flow_description[0].code = qos_flow_description_code;
 
-    num_of_param = 0;
+        num_of_param = 0;
 
-    qos_flow_description[0].param[num_of_param].identifier =
-        OGS_NAX_QOS_FLOW_PARAMETER_ID_5QI;
-    qos_flow_description[0].param[num_of_param].len =
-        sizeof(qos_flow_description[0].param[num_of_param].qos_index);
-    qos_flow_description[0].param[num_of_param].qos_index = qos_flow->qos.index;
-    num_of_param++;
+        if (qos_flow_description_code != OGS_NAS_DELETE_NEW_QOS_FLOW_DESCRIPTION) {
+            qos_flow_description[0].E_bit = 1;
 
-    if (qos_flow->qos.gbr.uplink) {
-        qos_flow_description[0].param[num_of_param].identifier =
-            OGS_NAX_QOS_FLOW_PARAMETER_ID_GFBR_UPLINK;
-        qos_flow_description[0].param[num_of_param].len =
-            sizeof(qos_flow_description[0].param[num_of_param].br);
-        ogs_nas_bitrate_from_uint64(
-                &qos_flow_description[0].param[num_of_param].br,
-                qos_flow->qos.gbr.uplink);
-        num_of_param++;
+            qos_flow_description[0].param[num_of_param].identifier =
+                OGS_NAX_QOS_FLOW_PARAMETER_ID_5QI;
+            qos_flow_description[0].param[num_of_param].len =
+                sizeof(qos_flow_description[0].param[num_of_param].qos_index);
+            qos_flow_description[0].param[num_of_param].qos_index =
+                qos_flow->qos.index;
+            num_of_param++;
+
+            if (qos_flow->qos.gbr.uplink) {
+                qos_flow_description[0].param[num_of_param].identifier =
+                    OGS_NAX_QOS_FLOW_PARAMETER_ID_GFBR_UPLINK;
+                qos_flow_description[0].param[num_of_param].len =
+                    sizeof(qos_flow_description[0].param[num_of_param].br);
+                ogs_nas_bitrate_from_uint64(
+                        &qos_flow_description[0].param[num_of_param].br,
+                        qos_flow->qos.gbr.uplink);
+                num_of_param++;
+            }
+            if (qos_flow->qos.gbr.downlink) {
+                qos_flow_description[0].param[num_of_param].identifier =
+                    OGS_NAX_QOS_FLOW_PARAMETER_ID_GFBR_DOWNLINK;
+                qos_flow_description[0].param[num_of_param].len =
+                    sizeof(qos_flow_description[0].param[num_of_param].br);
+                ogs_nas_bitrate_from_uint64(
+                        &qos_flow_description[0].param[num_of_param].br,
+                        qos_flow->qos.gbr.downlink);
+                num_of_param++;
+            }
+            if (qos_flow->qos.mbr.uplink) {
+                qos_flow_description[0].param[num_of_param].identifier =
+                    OGS_NAX_QOS_FLOW_PARAMETER_ID_MFBR_UPLINK;
+                qos_flow_description[0].param[num_of_param].len =
+                    sizeof(qos_flow_description[0].param[num_of_param].br);
+                ogs_nas_bitrate_from_uint64(
+                        &qos_flow_description[0].param[num_of_param].br,
+                        qos_flow->qos.mbr.uplink);
+                num_of_param++;
+            }
+            if (qos_flow->qos.mbr.downlink) {
+                qos_flow_description[0].param[num_of_param].identifier =
+                    OGS_NAX_QOS_FLOW_PARAMETER_ID_MFBR_DOWNLINK;
+                qos_flow_description[0].param[num_of_param].len =
+                    sizeof(qos_flow_description[0].param[num_of_param].br);
+                ogs_nas_bitrate_from_uint64(
+                        &qos_flow_description[0].param[num_of_param].br,
+                        qos_flow->qos.mbr.downlink);
+                num_of_param++;
+            }
+        }
+
+        qos_flow_description[0].num_of_parameter = num_of_param;
+
+        rv = ogs_nas_build_qos_flow_descriptions(
+                authorized_qos_flow_descriptions, qos_flow_description, 1);
+        ogs_expect_or_return_val(rv == OGS_OK, NULL);
+        ogs_expect_or_return_val(
+                authorized_qos_flow_descriptions->length, NULL);
+
+        pdu_session_modification_command->presencemask |=
+            OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMMAND_AUTHORIZED_QOS_FLOW_DESCRIPTIONS_PRESENT;
     }
-    if (qos_flow->qos.gbr.downlink) {
-        qos_flow_description[0].param[num_of_param].identifier =
-            OGS_NAX_QOS_FLOW_PARAMETER_ID_GFBR_DOWNLINK;
-        qos_flow_description[0].param[num_of_param].len =
-            sizeof(qos_flow_description[0].param[num_of_param].br);
-        ogs_nas_bitrate_from_uint64(
-                &qos_flow_description[0].param[num_of_param].br,
-                qos_flow->qos.gbr.downlink);
-        num_of_param++;
-    }
-    if (qos_flow->qos.mbr.uplink) {
-        qos_flow_description[0].param[num_of_param].identifier =
-            OGS_NAX_QOS_FLOW_PARAMETER_ID_MFBR_UPLINK;
-        qos_flow_description[0].param[num_of_param].len =
-            sizeof(qos_flow_description[0].param[num_of_param].br);
-        ogs_nas_bitrate_from_uint64(
-                &qos_flow_description[0].param[num_of_param].br,
-                qos_flow->qos.mbr.uplink);
-        num_of_param++;
-    }
-    if (qos_flow->qos.mbr.downlink) {
-        qos_flow_description[0].param[num_of_param].identifier =
-            OGS_NAX_QOS_FLOW_PARAMETER_ID_MFBR_DOWNLINK;
-        qos_flow_description[0].param[num_of_param].len =
-            sizeof(qos_flow_description[0].param[num_of_param].br);
-        ogs_nas_bitrate_from_uint64(
-                &qos_flow_description[0].param[num_of_param].br,
-                qos_flow->qos.mbr.downlink);
-        num_of_param++;
-    }
-
-    qos_flow_description[0].num_of_parameter = num_of_param;
-
-    pdu_session_modification_command->presencemask |=
-        OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMMAND_AUTHORIZED_QOS_FLOW_DESCRIPTIONS_PRESENT;
-    rv = ogs_nas_build_qos_flow_descriptions(
-            authorized_qos_flow_descriptions, qos_flow_description, 1);
-    ogs_expect_or_return_val(rv == OGS_OK, NULL);
-    ogs_expect_or_return_val(authorized_qos_flow_descriptions->length, NULL);
 
     pkbuf = ogs_nas_5gs_plain_encode(&message);
     ogs_assert(pkbuf);
 
-    ogs_free(authorized_qos_rules->buffer);
-    ogs_free(authorized_qos_flow_descriptions->buffer);
+    if (pdu_session_modification_command->presencemask &
+        OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMMAND_AUTHORIZED_QOS_RULES_PRESENT) {
+        ogs_free(authorized_qos_rules->buffer);
+    }
+    if (pdu_session_modification_command->presencemask &
+        OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMMAND_AUTHORIZED_QOS_FLOW_DESCRIPTIONS_PRESENT) {
+        ogs_free(authorized_qos_flow_descriptions->buffer);
+    }
 
     return pkbuf;
 }
 
+ogs_pkbuf_t *gsm_build_pdu_session_modification_reject(
+        smf_sess_t *sess, ogs_nas_5gsm_cause_t gsm_cause)
+{
+    ogs_nas_5gs_message_t message;
+    ogs_nas_5gs_pdu_session_modification_reject_t *
+        pdu_session_modification_reject =
+            &message.gsm.pdu_session_modification_reject;
+
+    ogs_assert(sess);
+    ogs_assert(gsm_cause);
+
+    memset(&message, 0, sizeof(message));
+    message.gsm.h.extended_protocol_discriminator =
+            OGS_NAS_EXTENDED_PROTOCOL_DISCRIMINATOR_5GSM;
+    message.gsm.h.pdu_session_identity = sess->psi;
+    message.gsm.h.procedure_transaction_identity = sess->pti;
+    message.gsm.h.message_type = OGS_NAS_5GS_PDU_SESSION_MODIFICATION_REJECT;
+
+    pdu_session_modification_reject->gsm_cause = gsm_cause;
+
+    return ogs_nas_5gs_plain_encode(&message);
+}
+
 ogs_pkbuf_t *gsm_build_pdu_session_release_command(
         smf_sess_t *sess, ogs_nas_5gsm_cause_t gsm_cause)
 {
@@ -415,6 +478,9 @@ ogs_pkbuf_t *gsm_build_pdu_session_release_command(
     ogs_nas_5gs_pdu_session_release_command_t *pdu_session_release_command =
         &message.gsm.pdu_session_release_command;
 
+    ogs_assert(sess);
+    ogs_assert(gsm_cause);
+
     memset(&message, 0, sizeof(message));
     message.gsm.h.extended_protocol_discriminator =
             OGS_NAS_EXTENDED_PROTOCOL_DISCRIMINATOR_5GSM;
@@ -434,6 +500,9 @@ ogs_pkbuf_t *gsm_build_pdu_session_release_reject(
     ogs_nas_5gs_pdu_session_release_reject_t *
         pdu_session_release_reject = &message.gsm.pdu_session_release_reject;
 
+    ogs_assert(sess);
+    ogs_assert(gsm_cause);
+
     memset(&message, 0, sizeof(message));
     message.gsm.h.extended_protocol_discriminator =
             OGS_NAS_EXTENDED_PROTOCOL_DISCRIMINATOR_5GSM;

src/smf/gsm-build.h

@@ -31,7 +31,10 @@ ogs_pkbuf_t *gsm_build_pdu_session_establishment_reject(
         smf_sess_t *sess, ogs_nas_5gsm_cause_t gsm_cause);
 
 ogs_pkbuf_t *gsm_build_qos_flow_modification_command(
-        smf_bearer_t *qos_flow, uint8_t pti);
+        smf_bearer_t *qos_flow, uint8_t pti,
+        uint8_t qos_rule_code, uint8_t qos_flow_description_code);
+ogs_pkbuf_t *gsm_build_pdu_session_modification_reject(
+        smf_sess_t *sess, ogs_nas_5gsm_cause_t gsm_cause);
 
 ogs_pkbuf_t *gsm_build_pdu_session_release_command(
         smf_sess_t *sess, ogs_nas_5gsm_cause_t gsm_cause);

src/smf/gsm-handler.c

@@ -21,6 +21,8 @@
 #include "sbi-path.h"
 #include "pfcp-path.h"
 
+#include "ipfw/ipfw2.h"
+
 #undef OGS_LOG_DOMAIN
 #define OGS_LOG_DOMAIN __gsm_log_domain
 
@@ -71,3 +73,454 @@ int gsm_handle_pdu_session_establishment_request(
 
     return OGS_OK;
 }
+
+static int reconfigure_packet_filter(
+        smf_pf_t *pf, ogs_nas_qos_rule_t *qos_rule, int i)
+{
+    int j;
+
+    ogs_assert(pf);
+    ogs_assert(qos_rule);
+
+    memset(&pf->ipfw_rule, 0, sizeof(ogs_ipfw_rule_t));
+    pf->direction = qos_rule->pf[i].direction;
+    for (j = 0; j < qos_rule->pf[i].content.num_of_component; j++) {
+        switch(qos_rule->pf[i].content.component[j].type) {
+        case OGS_PACKET_FILTER_PROTOCOL_IDENTIFIER_NEXT_HEADER_TYPE:
+            pf->ipfw_rule.proto = qos_rule->pf[i].content.component[j].proto;
+            break;
+        case OGS_PACKET_FILTER_IPV4_REMOTE_ADDRESS_TYPE:
+            pf->ipfw_rule.ipv4_dst = 1;
+            pf->ipfw_rule.ip.dst.addr[0] =
+                qos_rule->pf[i].content.component[j].ipv4.addr;
+            pf->ipfw_rule.ip.dst.mask[0] =
+                qos_rule->pf[i].content.component[j].ipv4.mask;
+            break;
+        case OGS_PACKET_FILTER_IPV4_LOCAL_ADDRESS_TYPE:
+            pf->ipfw_rule.ipv4_src = 1;
+            pf->ipfw_rule.ip.src.addr[0] =
+                qos_rule->pf[i].content.component[j].ipv4.addr;
+            pf->ipfw_rule.ip.src.mask[0] =
+                qos_rule->pf[i].content.component[j].ipv4.mask;
+            break;
+        case OGS_PACKET_FILTER_IPV6_REMOTE_ADDRESS_TYPE:
+            pf->ipfw_rule.ipv6_dst = 1;
+            memcpy(pf->ipfw_rule.ip.dst.addr,
+                qos_rule->pf[i].content.component[j].ipv6_mask.addr,
+                sizeof(pf->ipfw_rule.ip.dst.addr));
+            memcpy(pf->ipfw_rule.ip.dst.mask,
+                qos_rule->pf[i].content.component[j].ipv6_mask.mask,
+                sizeof(pf->ipfw_rule.ip.dst.mask));
+            break;
+        case OGS_PACKET_FILTER_IPV6_REMOTE_ADDRESS_PREFIX_LENGTH_TYPE:
+            pf->ipfw_rule.ipv6_dst = 1;
+            memcpy(pf->ipfw_rule.ip.dst.addr,
+                qos_rule->pf[i].content.component[j].ipv6_mask.addr,
+                sizeof(pf->ipfw_rule.ip.dst.addr));
+            n2mask((struct in6_addr *)pf->ipfw_rule.ip.dst.mask,
+                qos_rule->pf[i].content.component[j].ipv6.prefixlen);
+            break;
+        case OGS_PACKET_FILTER_IPV6_LOCAL_ADDRESS_TYPE:
+            pf->ipfw_rule.ipv6_src = 1;
+            memcpy(pf->ipfw_rule.ip.src.addr,
+                qos_rule->pf[i].content.component[j].ipv6_mask.addr,
+                sizeof(pf->ipfw_rule.ip.src.addr));
+            memcpy(pf->ipfw_rule.ip.src.mask,
+                qos_rule->pf[i].content.component[j].ipv6_mask.mask,
+                sizeof(pf->ipfw_rule.ip.src.mask));
+            break;
+        case OGS_PACKET_FILTER_IPV6_LOCAL_ADDRESS_PREFIX_LENGTH_TYPE:
+            pf->ipfw_rule.ipv6_src = 1;
+            memcpy(pf->ipfw_rule.ip.src.addr,
+                qos_rule->pf[i].content.component[j].ipv6_mask.addr,
+                sizeof(pf->ipfw_rule.ip.src.addr));
+            n2mask((struct in6_addr *)pf->ipfw_rule.ip.src.mask,
+                qos_rule->pf[i].content.component[j].ipv6.prefixlen);
+            break;
+        case OGS_PACKET_FILTER_SINGLE_LOCAL_PORT_TYPE:
+            pf->ipfw_rule.port.src.low = pf->ipfw_rule.port.src.high =
+                    qos_rule->pf[i].content.component[j].port.low;
+            break;
+        case OGS_PACKET_FILTER_SINGLE_REMOTE_PORT_TYPE:
+            pf->ipfw_rule.port.dst.low = pf->ipfw_rule.port.dst.high =
+                    qos_rule->pf[i].content.component[j].port.low;
+            break;
+        case OGS_PACKET_FILTER_LOCAL_PORT_RANGE_TYPE:
+            pf->ipfw_rule.port.src.low =
+                qos_rule->pf[i].content.component[j].port.low;
+            pf->ipfw_rule.port.src.high =
+                qos_rule->pf[i].content.component[j].port.high;
+            break;
+        case OGS_PACKET_FILTER_REMOTE_PORT_RANGE_TYPE:
+            pf->ipfw_rule.port.dst.low =
+                qos_rule->pf[i].content.component[j].port.low;
+            pf->ipfw_rule.port.dst.high =
+                qos_rule->pf[i].content.component[j].port.high;
+            break;
+        default:
+            ogs_error("Unknown Packet Filter Type(%d)",
+                    qos_rule->pf[i].content.component[j].type);
+            return OGS_ERROR;
+        }
+    }
+
+    return j;
+}
+
+#define qos_flow_find_or_add(list, node, member)        \
+    do {                                                \
+        smf_bearer_t *iter = NULL;                      \
+        bool found = false;                             \
+                                                        \
+        ogs_assert(node);                               \
+                                                        \
+        ogs_list_for_each_entry(list, iter, member) {   \
+            if (iter->qfi == node->qfi) {               \
+                found = true;                           \
+                break;                                  \
+            }                                           \
+        }                                               \
+        if (found == false) {                           \
+            ogs_list_add(list, &node->member);          \
+        }                                               \
+    } while(0);
+
+int gsm_handle_pdu_session_modification_request(
+        smf_sess_t *sess, ogs_sbi_stream_t *stream,
+        ogs_nas_5gs_pdu_session_modification_request_t *
+            pdu_session_modification_request)
+{
+    char *strerror = NULL;
+
+    int i, j;
+
+    uint64_t pfcp_flags = 0;
+    ogs_list_t update_list, delete_list;
+    smf_bearer_t *qos_flow = NULL;
+    smf_pf_t *pf = NULL;
+
+    ogs_nas_qos_rule_t qos_rule[OGS_NAS_MAX_NUM_OF_QOS_RULE];
+    ogs_nas_qos_flow_description_t
+        qos_flow_description[OGS_NAS_MAX_NUM_OF_QOS_FLOW_DESCRIPTION];
+
+    ogs_nas_qos_rules_t *requested_qos_rules =
+        &pdu_session_modification_request->requested_qos_rules;
+    ogs_nas_qos_flow_descriptions_t *requested_qos_flow_descriptions =
+        &pdu_session_modification_request->requested_qos_flow_descriptions;
+
+    smf_ue_t *smf_ue = NULL;
+    ogs_pkbuf_t *n1smbuf = NULL;
+
+    ogs_assert(sess);
+    smf_ue = sess->smf_ue;
+    ogs_assert(smf_ue);
+    ogs_assert(stream);
+    ogs_assert(pdu_session_modification_request);
+
+    ogs_list_init(&update_list);
+    ogs_list_init(&delete_list);
+
+    if (pdu_session_modification_request->presencemask &
+        OGS_NAS_5GS_PDU_SESSION_MODIFICATION_REQUEST_5GSM_CAUSE_PRESENT) {
+        /* Nothing to do */
+    }
+
+    if (pdu_session_modification_request->presencemask &
+        OGS_NAS_5GS_PDU_SESSION_MODIFICATION_REQUEST_REQUESTED_QOS_RULES_PRESENT) {
+        int num_of_rule = 0;
+
+        num_of_rule = ogs_nas_parse_qos_rules(qos_rule, requested_qos_rules);
+        ogs_assert(num_of_rule > 0);
+
+        for (i = 0; i < num_of_rule; i++) {
+            qos_flow = smf_qos_flow_find_by_qfi(
+                    sess, qos_rule[i].identifier);
+            if (!qos_flow) {
+                ogs_error("No Qos Flow");
+                continue;
+            }
+
+            ogs_list_init(&qos_flow->pf_to_add_list);
+
+            if (qos_rule[i].code == OGS_NAS_QOS_CODE_DELETE_EXISTING_QOS_RULE) {
+                smf_pf_remove_all(qos_flow);
+
+                pfcp_flags |= OGS_PFCP_MODIFY_REMOVE;
+                qos_flow_find_or_add(&delete_list, qos_flow, to_delete_node);
+            } else if (qos_rule[i].code ==
+                OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_REPLACE_PACKET_FILTERS) {
+                for (j = 0; j < qos_rule[i].num_of_packet_filter &&
+                            j < OGS_MAX_NUM_OF_FLOW_IN_NAS; j++) {
+
+                    pf = smf_pf_find_by_id(
+                            qos_flow, qos_rule[i].pf[j].identifier+1);
+                    if (pf) {
+                        ogs_assert(
+                            reconfigure_packet_filter(pf, &qos_rule[i], i) > 0);
+            /*
+             * Refer to lib/ipfw/ogs-ipfw.h
+             * Issue #338
+             *
+             * <DOWNLINK>
+             * TFT : Local <UE_IP> <UE_PORT> REMOTE <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT>
+             * -->
+             * RULE : Source <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> Destination <UE_IP> <UE_PORT>
+             *
+             * <UPLINK>
+             * TFT : Local <UE_IP> <UE_PORT> REMOTE <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT>
+             * -->
+             * RULE : Source <UE_IP> <UE_PORT> Destination <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT>
+             */
+                        if (pf->direction == OGS_FLOW_DOWNLINK_ONLY)
+                            ogs_ipfw_rule_swap(&pf->ipfw_rule);
+
+                        if (pf->flow_description)
+                            ogs_free(pf->flow_description);
+
+            /*
+             * Issue #338
+             *
+             * <DOWNLINK>
+             * RULE : Source <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> Destination <UE_IP> <UE_PORT>
+             * -->
+             * GX : permit out from <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> to <UE_IP> <UE_PORT>
+             * PFCP : permit out from <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> to <UE_IP> <UE_PORT>
+             *
+             * <UPLINK>
+             * RULE : Source <UE_IP> <UE_PORT> Destination <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT>
+             * -->
+             * GX : permit out from <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> to <UE_IP> <UE_PORT>
+             * PFCP : permit out from <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> to <UE_IP> <UE_PORT>
+             */
+                        if (pf->direction == OGS_FLOW_UPLINK_ONLY) {
+                            ogs_ipfw_rule_t tmp;
+                            ogs_ipfw_copy_and_swap(&tmp, &pf->ipfw_rule);
+                            pf->flow_description =
+                                ogs_ipfw_encode_flow_description(&tmp);
+                            ogs_assert(pf->flow_description);
+                        } else {
+                            pf->flow_description =
+                                ogs_ipfw_encode_flow_description(
+                                        &pf->ipfw_rule);
+                            ogs_assert(pf->flow_description);
+                        }
+
+                        pfcp_flags |= OGS_PFCP_MODIFY_TFT_REPLACE;
+                        qos_flow_find_or_add(
+                            &update_list, qos_flow, to_update_node);
+
+                        ogs_list_add(
+                                &qos_flow->pf_to_add_list, &pf->to_add_node);
+                    }
+                }
+            } else if (qos_rule[i].code ==
+                OGS_NAS_QOS_CODE_CREATE_NEW_QOS_RULE ||
+                        qos_rule[i].code ==
+                OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_ADD_PACKET_FILTERS) {
+
+                if (qos_rule[i].code == OGS_NAS_QOS_CODE_CREATE_NEW_QOS_RULE)
+                    smf_pf_remove_all(qos_flow);
+
+                for (j = 0; j < qos_rule[i].num_of_packet_filter &&
+                            j < OGS_MAX_NUM_OF_FLOW_IN_NAS; j++) {
+
+                    pf = smf_pf_find_by_id(
+                            qos_flow, qos_rule[i].pf[j].identifier+1);
+                    if (!pf)
+                        pf = smf_pf_add(qos_flow);
+                    ogs_assert(pf);
+
+                    ogs_assert(
+                        reconfigure_packet_filter(pf, &qos_rule[i], i) > 0);
+        /*
+         * Refer to lib/ipfw/ogs-ipfw.h
+         * Issue #338
+         *
+         * <DOWNLINK>
+         * TFT : Local <UE_IP> <UE_PORT> REMOTE <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT>
+         * -->
+         * RULE : Source <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> Destination <UE_IP> <UE_PORT>
+         *
+         * <UPLINK>
+         * TFT : Local <UE_IP> <UE_PORT> REMOTE <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT>
+         * -->
+         * RULE : Source <UE_IP> <UE_PORT> Destination <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT>
+         */
+                    if (pf->direction == OGS_FLOW_DOWNLINK_ONLY)
+                        ogs_ipfw_rule_swap(&pf->ipfw_rule);
+
+                    if (pf->flow_description)
+                        ogs_free(pf->flow_description);
+
+        /*
+         * Issue #338
+         *
+         * <DOWNLINK>
+         * RULE : Source <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> Destination <UE_IP> <UE_PORT>
+         * -->
+         * GX : permit out from <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> to <UE_IP> <UE_PORT>
+         * PFCP : permit out from <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> to <UE_IP> <UE_PORT>
+         *
+         * <UPLINK>
+         * RULE : Source <UE_IP> <UE_PORT> Destination <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT>
+         * -->
+         * GX : permit out from <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> to <UE_IP> <UE_PORT>
+         * PFCP : permit out from <P-CSCF_RTP_IP> <P-CSCF_RTP_PORT> to <UE_IP> <UE_PORT>
+         */
+                    if (pf->direction == OGS_FLOW_UPLINK_ONLY) {
+                        ogs_ipfw_rule_t tmp;
+                        ogs_ipfw_copy_and_swap(&tmp, &pf->ipfw_rule);
+                        pf->flow_description =
+                            ogs_ipfw_encode_flow_description(&tmp);
+                        ogs_assert(pf->flow_description);
+                    } else {
+                        pf->flow_description =
+                            ogs_ipfw_encode_flow_description(&pf->ipfw_rule);
+                        ogs_assert(pf->flow_description);
+                    }
+
+                    if (qos_rule[i].code ==
+                            OGS_NAS_QOS_CODE_CREATE_NEW_QOS_RULE) {
+                        pfcp_flags |= OGS_PFCP_MODIFY_TFT_NEW;
+                    } else if (qos_rule[i].code ==
+                            OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_ADD_PACKET_FILTERS) {
+                        pfcp_flags |= OGS_PFCP_MODIFY_TFT_ADD;
+                    } else
+                        ogs_assert_if_reached();
+
+                    qos_flow_find_or_add(
+                        &update_list, qos_flow, to_update_node);
+
+                    ogs_list_add(
+                            &qos_flow->pf_to_add_list, &pf->to_add_node);
+                }
+            } else if (qos_rule[i].code ==
+                OGS_NAS_QOS_CODE_MODIFY_EXISTING_QOS_RULE_AND_DELETE_PACKET_FILTERS) {
+
+                qos_flow->num_of_pf_to_delete = 0;
+                for (j = 0; j < qos_rule[i].num_of_packet_filter &&
+                            j < OGS_MAX_NUM_OF_FLOW_IN_NAS; j++) {
+
+                    pf = smf_pf_find_by_id(
+                            qos_flow, qos_rule[i].pf[j].identifier+1);
+                    if (pf) {
+                        qos_flow->pf_to_delete
+                            [qos_flow->num_of_pf_to_delete++] =
+                                qos_rule[i].pf[j].identifier;
+                        smf_pf_remove(pf);
+                    }
+                }
+
+                if (ogs_list_count(&qos_flow->pf_list)) {
+                    pfcp_flags |= OGS_PFCP_MODIFY_TFT_DELETE;
+                    qos_flow_find_or_add(
+                        &update_list, qos_flow, to_update_node);
+                } else {
+                    pfcp_flags |= OGS_PFCP_MODIFY_REMOVE;
+                    qos_flow_find_or_add(
+                        &delete_list, qos_flow, to_delete_node);
+                }
+            }
+        }
+    }
+
+    if (pdu_session_modification_request->presencemask &
+        OGS_NAS_5GS_PDU_SESSION_MODIFICATION_REQUEST_REQUESTED_QOS_FLOW_DESCRIPTIONS_PRESENT) {
+        int num_of_description = 0;
+
+        num_of_description = ogs_nas_parse_qos_flow_descriptions(
+                qos_flow_description, requested_qos_flow_descriptions);
+        ogs_assert(num_of_description > 0);
+
+        for (i = 0; i < num_of_description; i++) {
+            qos_flow = smf_qos_flow_find_by_qfi(
+                    sess, qos_flow_description[i].identifier);
+            if (!qos_flow) {
+                ogs_error("No Qos Flow");
+                continue;
+            }
+
+            for (j = 0; j < qos_flow_description[i].num_of_parameter; j++) {
+                switch(qos_flow_description[i].param[j].identifier) {
+                case OGS_NAX_QOS_FLOW_PARAMETER_ID_5QI:
+                    /* Nothing */
+                    break;
+                case OGS_NAX_QOS_FLOW_PARAMETER_ID_GFBR_UPLINK:
+                    qos_flow->qos.gbr.uplink = ogs_nas_bitrate_to_uint64(
+                            &qos_flow_description[i].param[j].br);
+                    break;
+                case OGS_NAX_QOS_FLOW_PARAMETER_ID_GFBR_DOWNLINK:
+                    qos_flow->qos.gbr.downlink = ogs_nas_bitrate_to_uint64(
+                            &qos_flow_description[i].param[j].br);
+                    break;
+                case OGS_NAX_QOS_FLOW_PARAMETER_ID_MFBR_UPLINK:
+                    qos_flow->qos.mbr.uplink = ogs_nas_bitrate_to_uint64(
+                            &qos_flow_description[i].param[j].br);
+                    break;
+                case OGS_NAX_QOS_FLOW_PARAMETER_ID_MFBR_DOWNLINK:
+                    qos_flow->qos.mbr.downlink = ogs_nas_bitrate_to_uint64(
+                            &qos_flow_description[i].param[j].br);
+                    break;
+                default:
+                    ogs_fatal("Unknown qos_flow parameter identifier [%d]",
+                            qos_flow_description[i].param[i].identifier);
+                    ogs_assert_if_reached();
+                }
+            }
+
+            pfcp_flags |= OGS_PFCP_MODIFY_QOS_MODIFY;
+            qos_flow_find_or_add(&update_list, qos_flow, to_update_node);
+        }
+    }
+
+    if ((ogs_list_count(&update_list) + ogs_list_count(&delete_list)) != 1) {
+        strerror = ogs_msprintf("[%s:%d] Invalid modification request "
+                "[update:%d,delete:%d]", smf_ue->supi, sess->psi,
+                ogs_list_count(&update_list), ogs_list_count(&delete_list));
+        ogs_assert(strerror);
+
+        ogs_error("%s", strerror);
+        n1smbuf = gsm_build_pdu_session_modification_reject(sess,
+            OGS_5GSM_CAUSE_INVALID_MANDATORY_INFORMATION);
+        ogs_assert(n1smbuf);
+
+        smf_sbi_send_sm_context_update_error(stream,
+                OGS_SBI_HTTP_STATUS_BAD_REQUEST,
+                strerror, smf_ue->supi, n1smbuf, NULL);
+        ogs_free(strerror);
+
+        return OGS_ERROR;
+    }
+
+    ogs_assert(qos_flow);
+
+    if (pfcp_flags & OGS_PFCP_MODIFY_REMOVE) {
+
+        ogs_assert(OGS_OK ==
+            smf_5gc_pfcp_send_qos_flow_modification_request(
+                qos_flow, stream,
+                OGS_PFCP_MODIFY_UE_REQUESTED|pfcp_flags));
+
+    } else if (pfcp_flags &
+                (OGS_PFCP_MODIFY_TFT_NEW|OGS_PFCP_MODIFY_TFT_ADD|
+                OGS_PFCP_MODIFY_TFT_REPLACE|OGS_PFCP_MODIFY_TFT_DELETE|
+                OGS_PFCP_MODIFY_QOS_MODIFY)) {
+
+        if (pfcp_flags &
+                (OGS_PFCP_MODIFY_TFT_NEW|OGS_PFCP_MODIFY_TFT_ADD|
+                OGS_PFCP_MODIFY_TFT_REPLACE|OGS_PFCP_MODIFY_TFT_DELETE))
+            smf_bearer_tft_update(qos_flow);
+
+        if (pfcp_flags & OGS_PFCP_MODIFY_QOS_MODIFY)
+            smf_bearer_qos_update(qos_flow);
+
+        ogs_assert(OGS_OK ==
+            smf_5gc_pfcp_send_qos_flow_modification_request(
+                qos_flow, stream, OGS_PFCP_MODIFY_UE_REQUESTED|pfcp_flags));
+    } else {
+        ogs_fatal("Unknown PFCP-Flags : [0x%llx]", (long long)pfcp_flags);
+        ogs_assert_if_reached();
+    }
+
+    return OGS_OK;
+}

src/smf/gsm-handler.h

@@ -31,6 +31,11 @@ int gsm_handle_pdu_session_establishment_request(
         ogs_nas_5gs_pdu_session_establishment_request_t *
             pdu_session_establishment_request);
 
+int gsm_handle_pdu_session_modification_request(
+        smf_sess_t *sess, ogs_sbi_stream_t *stream,
+        ogs_nas_5gs_pdu_session_modification_request_t *
+            pdu_session_modification_request);
+
 #ifdef __cplusplus
 }
 #endif

src/smf/gsm-sm.c

@@ -155,13 +155,12 @@ void smf_gsm_state_operational(ogs_fsm_t *s, smf_event_t *e)
 
         CASE(OGS_SBI_SERVICE_NAME_NPCF_SMPOLICYCONTROL)
             stream = e->sbi.data;
-            ogs_assert(stream);
-
             state = e->sbi.state;
 
             SWITCH(sbi_message->h.resource.component[0])
             CASE(OGS_SBI_RESOURCE_NAME_SM_POLICIES)
                 if (!sbi_message->h.resource.component[1]) {
+                    ogs_assert(stream);
                     if (sbi_message->res_status !=
                             OGS_SBI_HTTP_STATUS_CREATED) {
                         strerror = ogs_msprintf(
@@ -193,10 +192,11 @@ void smf_gsm_state_operational(ogs_fsm_t *s, smf_event_t *e)
                             ogs_assert(strerror);
 
                             ogs_error("%s", strerror);
-                            ogs_assert(true ==
-                                ogs_sbi_server_send_error(stream,
-                                    sbi_message->res_status,
-                                    sbi_message, strerror, NULL));
+                            if (stream)
+                                ogs_assert(true ==
+                                    ogs_sbi_server_send_error(stream,
+                                        sbi_message->res_status,
+                                        sbi_message, strerror, NULL));
                             ogs_free(strerror);
                             break;
                         }
@@ -213,10 +213,11 @@ void smf_gsm_state_operational(ogs_fsm_t *s, smf_event_t *e)
                         ogs_assert(strerror);
 
                         ogs_error("%s", strerror);
-                        ogs_assert(true ==
-                            ogs_sbi_server_send_error(stream,
-                                OGS_SBI_HTTP_STATUS_BAD_REQUEST,
-                                sbi_message, strerror, NULL));
+                        if (stream)
+                            ogs_assert(true ==
+                                ogs_sbi_server_send_error(stream,
+                                    OGS_SBI_HTTP_STATUS_BAD_REQUEST,
+                                    sbi_message, strerror, NULL));
                         ogs_free(strerror);
                     END
                 }
@@ -240,7 +241,7 @@ void smf_gsm_state_operational(ogs_fsm_t *s, smf_event_t *e)
         CASE(OGS_SBI_SERVICE_NAME_NAMF_COMM)
             SWITCH(sbi_message->h.resource.component[0])
             CASE(OGS_SBI_RESOURCE_NAME_UE_CONTEXTS)
-                smf_namf_comm_handler_n1_n2_message_transfer(
+                smf_namf_comm_handle_n1_n2_message_transfer(
                         sess, e->sbi.state, sbi_message);
                 break;
 
@@ -280,6 +281,16 @@ void smf_gsm_state_operational(ogs_fsm_t *s, smf_event_t *e)
             }
             break;
 
+        case OGS_NAS_5GS_PDU_SESSION_MODIFICATION_REQUEST:
+            rv = gsm_handle_pdu_session_modification_request(sess, stream,
+                    &nas_message->gsm.pdu_session_modification_request);
+            if (rv != OGS_OK) {
+                ogs_error("[%s:%d] Cannot handle NAS message",
+                        smf_ue->supi, sess->psi);
+                OGS_FSM_TRAN(s, smf_gsm_state_exception);
+            }
+            break;
+
         case OGS_NAS_5GS_PDU_SESSION_MODIFICATION_COMPLETE:
             ogs_assert(true == ogs_sbi_send_http_status_no_content(stream));
             break;
@@ -375,7 +386,8 @@ void smf_gsm_state_operational(ogs_fsm_t *s, smf_event_t *e)
         case OpenAPI_n2_sm_info_type_PDU_RES_REL_RSP:
             ngap_state = sess->ngap_state.pdu_session_resource_release;
 
-            if (ngap_state == SMF_NGAP_STATE_DELETE_TRIGGER_UE_REQUESTED) {
+            if (ngap_state == SMF_NGAP_STATE_DELETE_TRIGGER_UE_REQUESTED ||
+                ngap_state == SMF_NGAP_STATE_DELETE_TRIGGER_PCF_INITIATED) {
                 ogs_assert(true == ogs_sbi_send_http_status_no_content(stream));
             } else if (ngap_state ==
                     SMF_NGAP_STATE_ERROR_INDICATION_RECEIVED_FROM_5G_AN) {

src/smf/gx-handler.c

@@ -75,9 +75,9 @@ void smf_gx_handle_cca_initial_request(
         return;
     }
 
-    sess->num_of_pcc_rule = gx_message->session_data.num_of_pcc_rule;
+    sess->policy.num_of_pcc_rule = gx_message->session_data.num_of_pcc_rule;
     for (i = 0; i < gx_message->session_data.num_of_pcc_rule; i++)
-        OGS_STORE_PCC_RULE(&sess->pcc_rule[i],
+        OGS_STORE_PCC_RULE(&sess->policy.pcc_rule[i],
                 &gx_message->session_data.pcc_rule[i]);
 
     /* APN-AMBR
@@ -298,9 +298,9 @@ void smf_gx_handle_re_auth_request(
 {
     int i;
 
-    sess->num_of_pcc_rule = gx_message->session_data.num_of_pcc_rule;
+    sess->policy.num_of_pcc_rule = gx_message->session_data.num_of_pcc_rule;
     for (i = 0; i < gx_message->session_data.num_of_pcc_rule; i++)
-        OGS_STORE_PCC_RULE(&sess->pcc_rule[i],
+        OGS_STORE_PCC_RULE(&sess->policy.pcc_rule[i],
                 &gx_message->session_data.pcc_rule[i]);
 
     smf_bearer_binding(sess);

src/smf/n4-build.c

@@ -323,7 +323,10 @@ ogs_pkbuf_t *smf_n4_build_qos_flow_modification_request(
                 i++;
             }
         }
-        if (modify_flags & OGS_PFCP_MODIFY_TFT_UPDATE) {
+        if (modify_flags &
+                (OGS_PFCP_MODIFY_TFT_NEW|OGS_PFCP_MODIFY_TFT_ADD|
+                 OGS_PFCP_MODIFY_TFT_REPLACE|OGS_PFCP_MODIFY_TFT_DELETE|
+                 OGS_PFCP_MODIFY_EPC_TFT_UPDATE)) {
             ogs_pfcp_pdrbuf_init();
 
             /* Update PDR */
@@ -368,7 +371,9 @@ ogs_pkbuf_t *smf_n4_build_qos_flow_modification_request(
                 i++;
             }
         }
-        if (modify_flags & OGS_PFCP_MODIFY_QOS_UPDATE) {
+        if (modify_flags &
+                (OGS_PFCP_MODIFY_QOS_MODIFY|
+                 OGS_PFCP_MODIFY_EPC_QOS_UPDATE)) {
             /* Update QER */
             i = 0;
             if (qos_flow->qer) {
@@ -382,7 +387,11 @@ ogs_pkbuf_t *smf_n4_build_qos_flow_modification_request(
     pfcp_message.h.type = type;
     pkbuf = ogs_pfcp_build_msg(&pfcp_message);
 
-    if (modify_flags & (OGS_PFCP_MODIFY_CREATE|OGS_PFCP_MODIFY_TFT_UPDATE)) {
+    if (modify_flags &
+            (OGS_PFCP_MODIFY_CREATE|
+             OGS_PFCP_MODIFY_TFT_NEW|OGS_PFCP_MODIFY_TFT_ADD|
+             OGS_PFCP_MODIFY_TFT_REPLACE|OGS_PFCP_MODIFY_TFT_DELETE|
+             OGS_PFCP_MODIFY_EPC_TFT_UPDATE)) {
         ogs_pfcp_pdrbuf_clear();
     }