raw_data/open5gs_source_code/src/udr/nudr-handler.c

/*
 * Copyright (C) 2019,2020 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 "sbi-path.h"
#include "nudr-handler.h"

bool udr_nudr_dr_handle_subscription_authentication(
        ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg)
{
    int rv;

    ogs_sbi_message_t sendmsg;
    ogs_sbi_response_t *response = NULL;
    ogs_dbi_auth_info_t auth_info;

    char k_string[OGS_KEYSTRLEN(OGS_KEY_LEN)];
    char opc_string[OGS_KEYSTRLEN(OGS_KEY_LEN)];
    char amf_string[OGS_KEYSTRLEN(OGS_AMF_LEN)];
    char sqn_string[OGS_KEYSTRLEN(OGS_SQN_LEN)];

    char sqn[OGS_SQN_LEN];
    char *supi = NULL;

    OpenAPI_authentication_subscription_t AuthenticationSubscription;
    OpenAPI_sequence_number_t SequenceNumber;
    OpenAPI_list_t *PatchItemList = NULL;
    OpenAPI_lnode_t *node = NULL;

    ogs_assert(stream);
    ogs_assert(recvmsg);

    supi = recvmsg->h.resource.component[1];
    if (!supi) {
        ogs_error("No SUPI");
        ogs_assert(true ==
            ogs_sbi_server_send_error(stream, OGS_SBI_HTTP_STATUS_BAD_REQUEST,
                recvmsg, "No SUPI", NULL, NULL));
        return false;
    }

    if (strncmp(supi,
            OGS_ID_SUPI_TYPE_IMSI, strlen(OGS_ID_SUPI_TYPE_IMSI)) != 0) {
        ogs_error("[%s] Unknown SUPI Type", supi);
        ogs_assert(true ==
            ogs_sbi_server_send_error(stream, OGS_SBI_HTTP_STATUS_FORBIDDEN,
                recvmsg, "Unknwon SUPI Type", supi, NULL));
        return false;
    }

    rv = ogs_dbi_auth_info(supi, &auth_info);
    if (rv != OGS_OK) {
        ogs_warn("[%s] Cannot find SUPI in DB", supi);
        ogs_assert(true ==
            ogs_sbi_server_send_error(stream, OGS_SBI_HTTP_STATUS_NOT_FOUND,
                recvmsg, "Cannot find SUPI Type", supi, NULL));
        return false;
    }

    SWITCH(recvmsg->h.resource.component[3])
    CASE(OGS_SBI_RESOURCE_NAME_AUTHENTICATION_SUBSCRIPTION)
        SWITCH(recvmsg->h.method)
        CASE(OGS_SBI_HTTP_METHOD_GET)
            memset(&AuthenticationSubscription, 0,
                    sizeof(AuthenticationSubscription));

            AuthenticationSubscription.authentication_method =
                OpenAPI_auth_method_5G_AKA;

            ogs_hex_to_ascii(auth_info.k, sizeof(auth_info.k),
                    k_string, sizeof(k_string));
            AuthenticationSubscription.enc_permanent_key = k_string;

            ogs_hex_to_ascii(auth_info.amf, sizeof(auth_info.amf),
                    amf_string, sizeof(amf_string));
            AuthenticationSubscription.authentication_management_field =
                    amf_string;

            if (!auth_info.use_opc)
                milenage_opc(auth_info.k, auth_info.op, auth_info.opc);

            ogs_hex_to_ascii(auth_info.opc, sizeof(auth_info.opc),
                    opc_string, sizeof(opc_string));
            AuthenticationSubscription.enc_opc_key = opc_string;

            ogs_uint64_to_buffer(auth_info.sqn, OGS_SQN_LEN, sqn);
            ogs_hex_to_ascii(sqn, sizeof(sqn), sqn_string, sizeof(sqn_string));

            memset(&SequenceNumber, 0, sizeof(SequenceNumber));
            SequenceNumber.sqn = sqn_string;
            AuthenticationSubscription.sequence_number = &SequenceNumber;

            memset(&sendmsg, 0, sizeof(sendmsg));

            ogs_assert(AuthenticationSubscription.authentication_method);
            sendmsg.AuthenticationSubscription =
                &AuthenticationSubscription;

            response = ogs_sbi_build_response(
                    &sendmsg, OGS_SBI_HTTP_STATUS_OK);
            ogs_assert(response);
            ogs_assert(true == ogs_sbi_server_send_response(stream, response));

            return true;

        CASE(OGS_SBI_HTTP_METHOD_PATCH)
            char *sqn_string = NULL;
            uint8_t sqn_ms[OGS_SQN_LEN];
            uint64_t sqn = 0;

            PatchItemList = recvmsg->PatchItemList;
            if (!PatchItemList) {
                ogs_assert(true ==
                    ogs_sbi_server_send_error(stream,
                        OGS_SBI_HTTP_STATUS_BAD_REQUEST,
                        recvmsg, "No PatchItemList Array", NULL, NULL));
                return false;
            }

            OpenAPI_list_for_each(PatchItemList, node) {
                if (node->data) {
                    OpenAPI_patch_item_t *patch_item = node->data;
                    if (OpenAPI_IsString(patch_item->value))
                        sqn_string = cJSON_GetStringValue(patch_item->value->json);
                    else
                        ogs_error("Non-string value in patch not implemented");
                }
            }

            if (!sqn_string) {
                ogs_assert(true ==
                    ogs_sbi_server_send_error(stream,
                        OGS_SBI_HTTP_STATUS_BAD_REQUEST,
                        recvmsg, "No PatchItemList", NULL, NULL));
                return false;
            }

            ogs_ascii_to_hex(sqn_string, strlen(sqn_string),
                    sqn_ms, sizeof(sqn_ms));
            sqn = ogs_buffer_to_uint64(sqn_ms, OGS_SQN_LEN);

            rv = ogs_dbi_update_sqn(supi, sqn);
            if (rv != OGS_OK) {
                ogs_fatal("[%s] Cannot update SQN", supi);
                ogs_assert(true ==
                    ogs_sbi_server_send_error(stream,
                        OGS_SBI_HTTP_STATUS_INTERNAL_SERVER_ERROR,
                        recvmsg, "Cannot update SQN", supi, NULL));
                return false;
            }

            rv = ogs_dbi_increment_sqn(supi);
            if (rv != OGS_OK) {
                ogs_fatal("[%s] Cannot increment SQN", supi);
                ogs_assert(true ==
                    ogs_sbi_server_send_error(stream,
                        OGS_SBI_HTTP_STATUS_INTERNAL_SERVER_ERROR,
                        recvmsg, "Cannot increment SQN", supi, NULL));
                return false;
            }

            memset(&sendmsg, 0, sizeof(sendmsg));

            response = ogs_sbi_build_response(
                    &sendmsg, OGS_SBI_HTTP_STATUS_NO_CONTENT);
            ogs_assert(response);
            ogs_assert(true == ogs_sbi_server_send_response(stream, response));

            return true;

        DEFAULT
            ogs_error("Invalid HTTP method [%s]", recvmsg->h.method);
            ogs_assert(true ==
                ogs_sbi_server_send_error(stream,
                    OGS_SBI_HTTP_STATUS_METHOD_NOT_ALLOWED,
                    recvmsg, "Invalid HTTP method", recvmsg->h.method,
                    NULL));
        END
        break;

    CASE(OGS_SBI_RESOURCE_NAME_AUTHENTICATION_STATUS)
        SWITCH(recvmsg->h.method)
        CASE(OGS_SBI_HTTP_METHOD_PUT)
        CASE(OGS_SBI_HTTP_METHOD_DELETE)
            OpenAPI_auth_event_t *AuthEvent = NULL;

            AuthEvent = recvmsg->AuthEvent;
            if (!AuthEvent &&
                !strcmp(recvmsg->h.method, OGS_SBI_HTTP_METHOD_PUT)) {
                ogs_error("[%s] No AuthEvent", supi);
                ogs_assert(true ==
                    ogs_sbi_server_send_error(
                        stream, OGS_SBI_HTTP_STATUS_BAD_REQUEST,
                        recvmsg, "No AuthEvent", supi, NULL));
                return false;
            }

            memset(&sendmsg, 0, sizeof(sendmsg));
            rv = ogs_dbi_increment_sqn(supi);
            if (rv != OGS_OK) {
                ogs_fatal("[%s] Cannot increment SQN", supi);
                ogs_assert(true ==
                    ogs_sbi_server_send_error(stream,
                        OGS_SBI_HTTP_STATUS_INTERNAL_SERVER_ERROR,
                        recvmsg, "Cannot increment SQN", supi, NULL));
                return false;
            }

            response = ogs_sbi_build_response(
                    &sendmsg, OGS_SBI_HTTP_STATUS_NO_CONTENT);
            ogs_assert(response);
            ogs_assert(true == ogs_sbi_server_send_response(stream, response));

            return true;

        DEFAULT
            ogs_error("Invalid HTTP method [%s]", recvmsg->h.method);
            ogs_assert(true ==
                ogs_sbi_server_send_error(stream,
                    OGS_SBI_HTTP_STATUS_METHOD_NOT_ALLOWED,
                    recvmsg, "Invalid HTTP method", recvmsg->h.method,
                    NULL));
        END
        break;

    DEFAULT
        ogs_error("Invalid resource name [%s]",
                recvmsg->h.resource.component[3]);
        ogs_assert(true ==
            ogs_sbi_server_send_error(stream,
                OGS_SBI_HTTP_STATUS_METHOD_NOT_ALLOWED,
                recvmsg, "Unknown resource name",
                recvmsg->h.resource.component[3], NULL));
    END

    return false;
}

bool udr_nudr_dr_handle_subscription_context(
        ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg)
{
    ogs_sbi_message_t sendmsg;
    ogs_sbi_response_t *response = NULL;

    char *supi = NULL;

    ogs_assert(stream);
    ogs_assert(recvmsg);

    supi = recvmsg->h.resource.component[1];
    if (!supi) {
        ogs_error("No SUPI");
        ogs_assert(true ==
            ogs_sbi_server_send_error(stream, OGS_SBI_HTTP_STATUS_BAD_REQUEST,
                recvmsg, "No SUPI", NULL, NULL));
        return false;
    }

    if (strncmp(supi,
            OGS_ID_SUPI_TYPE_IMSI, strlen(OGS_ID_SUPI_TYPE_IMSI)) != 0) {
        ogs_error("[%s] Unknown SUPI Type", supi);
        ogs_assert(true ==
            ogs_sbi_server_send_error(stream, OGS_SBI_HTTP_STATUS_FORBIDDEN,
                recvmsg, "Unknwon SUPI Type", supi, NULL));
        return false;
    }

    SWITCH(recvmsg->h.resource.component[3])
    CASE(OGS_SBI_RESOURCE_NAME_AMF_3GPP_ACCESS)
        SWITCH(recvmsg->h.method)
        CASE(OGS_SBI_HTTP_METHOD_PUT)
            OpenAPI_amf3_gpp_access_registration_t *Amf3GppAccessRegistration;

            Amf3GppAccessRegistration = recvmsg->Amf3GppAccessRegistration;
            if (!Amf3GppAccessRegistration) {
                ogs_error("[%s] No Amf3GppAccessRegistration", supi);
                ogs_assert(true ==
                    ogs_sbi_server_send_error(
                        stream, OGS_SBI_HTTP_STATUS_BAD_REQUEST,
                        recvmsg, "No Amf3GppAccessRegistration", supi, NULL));
                return false;
            }

            if (Amf3GppAccessRegistration->pei) {
                char *type = NULL, *value = NULL;
                char *pei = NULL;

                pei = ogs_strdup(Amf3GppAccessRegistration->pei);
                ogs_assert(pei);

                type = ogs_id_get_type(pei);
                ogs_assert(type);
                value = ogs_id_get_value(pei);
                ogs_assert(value);

                if (strcmp(type, "imeisv") == 0) {
                    ogs_assert(OGS_OK == ogs_dbi_update_imeisv(supi, value));
                } else {
                    ogs_fatal("Unknown Type = %s", type);
                    ogs_assert_if_reached();
                }

                ogs_free(pei);
                ogs_free(type);
                ogs_free(value);
            }

            memset(&sendmsg, 0, sizeof(sendmsg));

            response = ogs_sbi_build_response(
                    &sendmsg, OGS_SBI_HTTP_STATUS_NO_CONTENT);
            ogs_assert(response);
            ogs_assert(true == ogs_sbi_server_send_response(stream, response));

            return true;

        CASE(OGS_SBI_HTTP_METHOD_PATCH)
            OpenAPI_list_t *PatchItemList;

            PatchItemList = recvmsg->PatchItemList;
            if (!PatchItemList) {
                ogs_error("[%s] No PatchItemList", supi);
                ogs_assert(true ==
                    ogs_sbi_server_send_error(
                        stream, OGS_SBI_HTTP_STATUS_BAD_REQUEST,
                        recvmsg, "No PatchItemList", supi, NULL));
                return false;
            }

            /* TODO: parse PatchItemList */

            memset(&sendmsg, 0, sizeof(sendmsg));

            response = ogs_sbi_build_response(
                    &sendmsg, OGS_SBI_HTTP_STATUS_NO_CONTENT);
            ogs_assert(response);
            ogs_assert(true == ogs_sbi_server_send_response(stream, response));

            return true;

        DEFAULT
            ogs_error("Invalid HTTP method [%s]", recvmsg->h.method);
            ogs_assert(true ==
                ogs_sbi_server_send_error(stream,
                    OGS_SBI_HTTP_STATUS_METHOD_NOT_ALLOWED,
                    recvmsg, "Invalid HTTP method", recvmsg->h.method,
                    NULL));
        END
        break;
    CASE(OGS_SBI_RESOURCE_NAME_SMF_REGISTRATIONS)
        SWITCH(recvmsg->h.method)
        CASE(OGS_SBI_HTTP_METHOD_PUT)
            OpenAPI_smf_registration_t *SmfRegistration;

            SmfRegistration = recvmsg->SmfRegistration;
            if (!SmfRegistration) {
                ogs_error("[%s] No SmfRegistration", supi);
                ogs_assert(true ==
                    ogs_sbi_server_send_error(
                        stream, OGS_SBI_HTTP_STATUS_BAD_REQUEST,
                        recvmsg, "No SmfRegistration", supi, NULL));
                return false;
            }

            memset(&sendmsg, 0, sizeof(sendmsg));

            response = ogs_sbi_build_response(
                    &sendmsg, OGS_SBI_HTTP_STATUS_NO_CONTENT);
            ogs_assert(response);
            ogs_assert(true == ogs_sbi_server_send_response(stream, response));

            return true;

        CASE(OGS_SBI_HTTP_METHOD_DELETE)
            memset(&sendmsg, 0, sizeof(sendmsg));

            response = ogs_sbi_build_response(
                    &sendmsg, OGS_SBI_HTTP_STATUS_NO_CONTENT);
            ogs_assert(response);
            ogs_assert(true == ogs_sbi_server_send_response(stream, response));

            return true;

        DEFAULT
            ogs_error("Invalid HTTP method [%s]", recvmsg->h.method);
            ogs_assert(true ==
                ogs_sbi_server_send_error(stream,
                    OGS_SBI_HTTP_STATUS_METHOD_NOT_ALLOWED,
                    recvmsg, "Invalid HTTP method", recvmsg->h.method,
                    NULL));
        END
        break;

    DEFAULT
        ogs_error("Invalid resource name [%s]",
                recvmsg->h.resource.component[3]);
        ogs_assert(true ==
            ogs_sbi_server_send_error(stream,
                OGS_SBI_HTTP_STATUS_METHOD_NOT_ALLOWED,
                recvmsg, "Unknown resource name",
                recvmsg->h.resource.component[3], NULL));
    END

    return false;
}

bool udr_nudr_dr_handle_subscription_provisioned(
        ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg)
{
    int rv, status = 0;
    char *strerror = NULL;

    ogs_sbi_message_t sendmsg;
    ogs_sbi_response_t *response = NULL;
    ogs_subscription_data_t subscription_data;
    ogs_slice_data_t *slice_data = NULL;

    char *supi = NULL;

    ogs_assert(stream);
    ogs_assert(recvmsg);

    memset(&subscription_data, 0, sizeof(ogs_subscription_data_t));

    supi = recvmsg->h.resource.component[1];
    if (!supi) {
        strerror = ogs_msprintf("No SUPI");
        status = OGS_SBI_HTTP_STATUS_BAD_REQUEST;
        goto cleanup;
    }

    if (strncmp(supi,
            OGS_ID_SUPI_TYPE_IMSI, strlen(OGS_ID_SUPI_TYPE_IMSI)) != 0) {
        strerror = ogs_msprintf("[%s] Unknown SUPI Type", supi);
        status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
        goto cleanup;
    }

    rv = ogs_dbi_subscription_data(supi, &subscription_data);
    if (rv != OGS_OK) {
        strerror = ogs_msprintf("[%s] Cannot find SUPI in DB", supi);
        status = OGS_SBI_HTTP_STATUS_NOT_FOUND;
        goto cleanup;
    }

    if (!subscription_data.ambr.uplink && !subscription_data.ambr.downlink) {
        strerror = ogs_msprintf("[%s] No UE-AMBR", supi);
        status = OGS_SBI_HTTP_STATUS_NOT_FOUND;
        goto cleanup;
    }

    SWITCH(recvmsg->h.resource.component[4])
    CASE(OGS_SBI_RESOURCE_NAME_AM_DATA)
        int i;

        OpenAPI_access_and_mobility_subscription_data_t
            AccessAndMobilitySubscriptionData;
        OpenAPI_list_t *GpsiList = NULL;
        OpenAPI_ambr_rm_t SubscribedUeAmbr;

        OpenAPI_nssai_t NSSAI;
        OpenAPI_list_t *DefaultSingleNssaiList = NULL;
        OpenAPI_list_t *SingleNssaiList = NULL;
        OpenAPI_snssai_t *Snssai = NULL;

        OpenAPI_lnode_t *node = NULL;

        GpsiList = OpenAPI_list_create();
        for (i = 0; i < subscription_data.num_of_msisdn; i++) {
            char *gpsi = ogs_msprintf("%s-%s",
                    OGS_ID_GPSI_TYPE_MSISDN, subscription_data.msisdn[i].bcd);
            ogs_assert(gpsi);
            OpenAPI_list_add(GpsiList, gpsi);
        }

        SubscribedUeAmbr.uplink = ogs_sbi_bitrate_to_string(
                subscription_data.ambr.uplink, OGS_SBI_BITRATE_KBPS);
        SubscribedUeAmbr.downlink = ogs_sbi_bitrate_to_string(
                subscription_data.ambr.downlink, OGS_SBI_BITRATE_KBPS);

        memset(&NSSAI, 0, sizeof(NSSAI));
        DefaultSingleNssaiList = OpenAPI_list_create();
        for (i = 0; i < subscription_data.num_of_slice; i++) {
            slice_data = &subscription_data.slice[i];

            if (slice_data->default_indicator == false)
                continue;

            Snssai = ogs_calloc(1, sizeof(*Snssai));
            ogs_assert(Snssai);

            Snssai->sst = slice_data->s_nssai.sst;
            Snssai->sd = ogs_s_nssai_sd_to_string(slice_data->s_nssai.sd);

            OpenAPI_list_add(DefaultSingleNssaiList, Snssai);
        }
        if (DefaultSingleNssaiList->count) {
            NSSAI.default_single_nssais = DefaultSingleNssaiList;
        }

        SingleNssaiList = OpenAPI_list_create();
        for (i = 0; i < subscription_data.num_of_slice; i++) {
            slice_data = &subscription_data.slice[i];

            if (slice_data->default_indicator == true)
                continue;

            Snssai = ogs_calloc(1, sizeof(*Snssai));
            ogs_assert(Snssai);

            Snssai->sst = slice_data->s_nssai.sst;
            Snssai->sd = ogs_s_nssai_sd_to_string(slice_data->s_nssai.sd);

            OpenAPI_list_add(SingleNssaiList, Snssai);
        }

        if (DefaultSingleNssaiList->count) {
            if (SingleNssaiList->count) {
                NSSAI.single_nssais = SingleNssaiList;
            }
        } else {
            if (SingleNssaiList->count) {
                ogs_fatal("No Default S-NSSAI");
                ogs_assert_if_reached();
            }
        }

        memset(&AccessAndMobilitySubscriptionData, 0,
                sizeof(AccessAndMobilitySubscriptionData));

        if (GpsiList->count)
            AccessAndMobilitySubscriptionData.gpsis = GpsiList;

        AccessAndMobilitySubscriptionData.subscribed_ue_ambr =
            &SubscribedUeAmbr;

        if (DefaultSingleNssaiList->count)
            AccessAndMobilitySubscriptionData.nssai = &NSSAI;

        memset(&sendmsg, 0, sizeof(sendmsg));
        sendmsg.AccessAndMobilitySubscriptionData =
            &AccessAndMobilitySubscriptionData;

        response = ogs_sbi_build_response(&sendmsg, OGS_SBI_HTTP_STATUS_OK);
        ogs_assert(response);
        ogs_assert(true == ogs_sbi_server_send_response(stream, response));

        OpenAPI_list_for_each(GpsiList, node) {
            if (node->data) ogs_free(node->data);
        }
        OpenAPI_list_free(GpsiList);

        ogs_free(SubscribedUeAmbr.uplink);
        ogs_free(SubscribedUeAmbr.downlink);

        OpenAPI_list_for_each(DefaultSingleNssaiList, node) {
            OpenAPI_snssai_t *Snssai = node->data;
            if (Snssai) {
                if (Snssai->sd)
                    ogs_free(Snssai->sd);
                ogs_free(Snssai);
            }
        }
        OpenAPI_list_free(DefaultSingleNssaiList);
        OpenAPI_list_for_each(SingleNssaiList, node) {
            OpenAPI_snssai_t *Snssai = node->data;
            if (Snssai) {
                if (Snssai->sd)
                    ogs_free(Snssai->sd);
                ogs_free(Snssai);
            }
        }
        OpenAPI_list_free(SingleNssaiList);
        break;

    CASE(OGS_SBI_RESOURCE_NAME_SMF_SELECTION_SUBSCRIPTION_DATA)
        int i, j;

        OpenAPI_smf_selection_subscription_data_t SmfSelectionSubscriptionData;

        OpenAPI_list_t *SubscribedSnssaiInfoList = NULL;
        OpenAPI_map_t *SubscribedSnssaiInfoMap = NULL;
        OpenAPI_snssai_info_t *SubscribedSnssaiInfo = NULL;

        OpenAPI_list_t *DnnInfoList = NULL;
        OpenAPI_dnn_info_t *DnnInfo = NULL;

        OpenAPI_lnode_t *node = NULL, *node2 = NULL;

        memset(&SmfSelectionSubscriptionData, 0,
                sizeof(SmfSelectionSubscriptionData));

        SubscribedSnssaiInfoList = OpenAPI_list_create();
        ogs_assert(SubscribedSnssaiInfoList);

        for (i = 0; i < subscription_data.num_of_slice; i++) {
            if (i >= OGS_MAX_NUM_OF_SLICE) {
                ogs_warn("Ignore max slice count overflow [%d>=%d]",
                    subscription_data.num_of_slice, OGS_MAX_NUM_OF_SLICE);
                break;
            }
            slice_data = &subscription_data.slice[i];

            DnnInfoList = OpenAPI_list_create();
            ogs_assert(DnnInfoList);

            for (j = 0; j < slice_data->num_of_session; j++) {
                ogs_session_t *session = NULL;

                if (j >= OGS_MAX_NUM_OF_SESS) {
                    ogs_warn("Ignore max session count overflow [%d>=%d]",
                        slice_data->num_of_session, OGS_MAX_NUM_OF_SESS);
                    break;
                }

                session = &slice_data->session[j];
                ogs_assert(session);
                ogs_assert(session->name);

                DnnInfo = ogs_calloc(1, sizeof(*DnnInfo));
                ogs_assert(DnnInfo);

                DnnInfo->dnn = session->name;

                /* 0-index DNN becomes the default DNN */
                if (j == 0) {
                    DnnInfo->is_default_dnn_indicator = true;
                    DnnInfo->default_dnn_indicator = true;
                }

                OpenAPI_list_add(DnnInfoList, DnnInfo);
            }

            SubscribedSnssaiInfo = ogs_calloc(1, sizeof(*SubscribedSnssaiInfo));
            ogs_assert(SubscribedSnssaiInfo);

            if (DnnInfoList->count)
                SubscribedSnssaiInfo->dnn_infos = DnnInfoList;
            else
                OpenAPI_list_free(DnnInfoList);

            SubscribedSnssaiInfoMap = OpenAPI_map_create(
                    ogs_sbi_s_nssai_to_string(&slice_data->s_nssai),
                    SubscribedSnssaiInfo);
            ogs_assert(SubscribedSnssaiInfoMap);
            ogs_assert(SubscribedSnssaiInfoMap->key);

            OpenAPI_list_add(SubscribedSnssaiInfoList, SubscribedSnssaiInfoMap);
        }

        if (SubscribedSnssaiInfoList->count)
            SmfSelectionSubscriptionData.subscribed_snssai_infos =
                SubscribedSnssaiInfoList;
        else
            OpenAPI_list_free(SubscribedSnssaiInfoList);

        memset(&sendmsg, 0, sizeof(sendmsg));
        sendmsg.SmfSelectionSubscriptionData = &SmfSelectionSubscriptionData;

        response = ogs_sbi_build_response(&sendmsg, OGS_SBI_HTTP_STATUS_OK);
        ogs_assert(response);
        ogs_assert(true == ogs_sbi_server_send_response(stream, response));

        SubscribedSnssaiInfoList =
            SmfSelectionSubscriptionData.subscribed_snssai_infos;
        OpenAPI_list_for_each(SubscribedSnssaiInfoList, node) {
            SubscribedSnssaiInfoMap = node->data;
            if (SubscribedSnssaiInfoMap) {
                SubscribedSnssaiInfo = SubscribedSnssaiInfoMap->value;
                if (SubscribedSnssaiInfo) {
                    DnnInfoList = SubscribedSnssaiInfo->dnn_infos;
                    if (DnnInfoList) {
                        OpenAPI_list_for_each(DnnInfoList, node2) {
                            DnnInfo = node2->data;
                            if (DnnInfo) {
                                ogs_free(DnnInfo);
                            }
                        }
                        OpenAPI_list_free(DnnInfoList);
                    }
                    ogs_free(SubscribedSnssaiInfo);
                }
                if (SubscribedSnssaiInfoMap->key)
                    ogs_free(SubscribedSnssaiInfoMap->key);
                ogs_free(SubscribedSnssaiInfoMap);
            }
        }
        OpenAPI_list_free(SubscribedSnssaiInfoList);
        break;

    CASE(OGS_SBI_RESOURCE_NAME_SM_DATA)
        int i;

        OpenAPI_session_management_subscription_data_t
            SessionManagementSubscriptionData;
        OpenAPI_snssai_t singleNSSAI;
        OpenAPI_list_t *dnnConfigurationList = NULL;
        OpenAPI_map_t *dnnConfigurationMap = NULL;
        OpenAPI_dnn_configuration_t *dnnConfiguration = NULL;
        OpenAPI_pdu_session_types_t *pduSessionTypeList = NULL;
        OpenAPI_ssc_modes_t *sscModeList = NULL;
        OpenAPI_subscribed_default_qos_t *_5gQoSProfile = NULL;
        OpenAPI_ambr_t *sessionAmbr = NULL;
        OpenAPI_list_t *staticIpAddress = NULL;
        OpenAPI_ip_address_t *ipAddress = NULL;
        OpenAPI_list_t *FrameRouteList = NULL;
        OpenAPI_lnode_t *node = NULL, *node2 = NULL;

        if (!recvmsg->param.single_nssai_presence) {
            strerror = ogs_msprintf("[%s] No S_NSSAI", supi);
            status = OGS_SBI_HTTP_STATUS_BAD_REQUEST;
            goto cleanup;
        };

        ogs_assert(subscription_data.num_of_slice);
        slice_data = ogs_slice_find_by_s_nssai(
                subscription_data.slice, subscription_data.num_of_slice,
                &recvmsg->param.s_nssai);

        if (!slice_data) {
            strerror = ogs_msprintf("[%s] Cannot find S_NSSAI[SST:%d SD:0x%x]",
                    supi,
                    recvmsg->param.s_nssai.sst,
                    recvmsg->param.s_nssai.sd.v);
            status = OGS_SBI_HTTP_STATUS_BAD_REQUEST;
            goto cleanup;
        }

        singleNSSAI.sst = slice_data->s_nssai.sst;
        singleNSSAI.sd = ogs_s_nssai_sd_to_string(slice_data->s_nssai.sd);

        dnnConfigurationList = OpenAPI_list_create();

        for (i = 0; i < slice_data->num_of_session; i++) {
            ogs_session_t *session = NULL;

            if (i >= OGS_MAX_NUM_OF_SESS) {
                ogs_warn("Ignore max session count overflow [%d>=%d]",
                    slice_data->num_of_session, OGS_MAX_NUM_OF_SESS);
                break;
            }

            session = &slice_data->session[i];
            ogs_assert(session);
            ogs_assert(session->name);

            if (recvmsg->param.dnn &&
                ogs_strcasecmp(recvmsg->param.dnn, session->name) != 0)
                continue;

            if (!session->qos.index) {
                ogs_error("No 5QI");
                continue;
            }
            if (!session->qos.arp.priority_level) {
                ogs_error("No Priority Level");
                continue;
            }

            if (!session->ambr.uplink && !session->ambr.downlink) {
                ogs_error("No Session-AMBR");
                continue;
            }

            dnnConfiguration = ogs_calloc(1, sizeof(*dnnConfiguration));
            ogs_assert(dnnConfiguration);

            pduSessionTypeList = ogs_calloc(1, sizeof(*pduSessionTypeList));
            ogs_assert(pduSessionTypeList);
            pduSessionTypeList->default_session_type = session->session_type;

            pduSessionTypeList->allowed_session_types = OpenAPI_list_create();
            ogs_assert(pduSessionTypeList->allowed_session_types);
            switch (pduSessionTypeList->default_session_type) {
            case OpenAPI_pdu_session_type_IPV4:
                OpenAPI_list_add(pduSessionTypeList->allowed_session_types,
                        (void *)OpenAPI_pdu_session_type_IPV4);
                break;
            case OpenAPI_pdu_session_type_IPV6:
                OpenAPI_list_add(pduSessionTypeList->allowed_session_types,
                        (void *)OpenAPI_pdu_session_type_IPV6);
                break;
            case OpenAPI_pdu_session_type_IPV4V6:
                OpenAPI_list_add(pduSessionTypeList->allowed_session_types,
                        (void *)OpenAPI_pdu_session_type_IPV4);
                OpenAPI_list_add(pduSessionTypeList->allowed_session_types,
                        (void *)OpenAPI_pdu_session_type_IPV6);
                OpenAPI_list_add(pduSessionTypeList->allowed_session_types,
                        (void *)OpenAPI_pdu_session_type_IPV4V6);
                break;
            default:
                ogs_fatal("Unsupported PDN_TYPE[%d]",
                        pduSessionTypeList->default_session_type);
                ogs_assert_if_reached();
            }

            dnnConfiguration->pdu_session_types = pduSessionTypeList;

            sscModeList = ogs_calloc(1, sizeof(*sscModeList));
            ogs_assert(sscModeList);
            sscModeList->default_ssc_mode = OpenAPI_ssc_mode_SSC_MODE_1;

            sscModeList->allowed_ssc_modes = OpenAPI_list_create();
            ogs_assert(sscModeList->allowed_ssc_modes);
            OpenAPI_list_add(sscModeList->allowed_ssc_modes,
                    (void *)OpenAPI_ssc_mode_SSC_MODE_1);
            OpenAPI_list_add(sscModeList->allowed_ssc_modes,
                    (void *)OpenAPI_ssc_mode_SSC_MODE_2);
            OpenAPI_list_add(sscModeList->allowed_ssc_modes,
                    (void *)OpenAPI_ssc_mode_SSC_MODE_3);

            dnnConfiguration->ssc_modes = sscModeList;

            _5gQoSProfile = ogs_calloc(1, sizeof(*_5gQoSProfile));
            ogs_assert(_5gQoSProfile);
            _5gQoSProfile->_5qi = session->qos.index;
            _5gQoSProfile->is_priority_level = true;
            _5gQoSProfile->priority_level = session->qos.arp.priority_level;
            _5gQoSProfile->arp = ogs_calloc(1, sizeof(OpenAPI_arp_t));
            ogs_assert(_5gQoSProfile->arp);
            _5gQoSProfile->arp->priority_level =
                session->qos.arp.priority_level;
            if (session->qos.arp.pre_emption_capability ==
                    OGS_5GC_PRE_EMPTION_ENABLED)
                _5gQoSProfile->arp->preempt_cap =
                        OpenAPI_preemption_capability_MAY_PREEMPT;
            else if (session->qos.arp.pre_emption_capability ==
                    OGS_5GC_PRE_EMPTION_DISABLED)
                _5gQoSProfile->arp->preempt_cap =
                        OpenAPI_preemption_capability_NOT_PREEMPT;
            ogs_assert(_5gQoSProfile->arp->preempt_cap);

            if (session->qos.arp.pre_emption_vulnerability ==
                OGS_5GC_PRE_EMPTION_ENABLED)
                _5gQoSProfile->arp->preempt_vuln =
                    OpenAPI_preemption_vulnerability_PREEMPTABLE;
            else if (session->qos.arp.pre_emption_vulnerability ==
                OGS_5GC_PRE_EMPTION_DISABLED)
                _5gQoSProfile->arp->preempt_vuln =
                    OpenAPI_preemption_vulnerability_NOT_PREEMPTABLE;
            ogs_assert(_5gQoSProfile->arp->preempt_vuln);

            dnnConfiguration->_5g_qos_profile = _5gQoSProfile;

            ogs_assert(session->ambr.uplink || session->ambr.downlink);
            sessionAmbr = ogs_calloc(1, sizeof(*sessionAmbr));
            ogs_assert(sessionAmbr);
            sessionAmbr->uplink = ogs_sbi_bitrate_to_string(
                    session->ambr.uplink, OGS_SBI_BITRATE_KBPS);
            sessionAmbr->downlink = ogs_sbi_bitrate_to_string(
                    session->ambr.downlink, OGS_SBI_BITRATE_KBPS);

            dnnConfiguration->session_ambr = sessionAmbr;

            staticIpAddress = OpenAPI_list_create();
            ogs_assert(staticIpAddress);

            if (session->ue_ip.ipv4 || session->ue_ip.ipv6) {
                ipAddress = ogs_calloc(1, sizeof(*ipAddress));
                ogs_assert(ipAddress);

                if (session->ue_ip.ipv4) {
                    ipAddress->ipv4_addr =
                        ogs_ipv4_to_string(session->ue_ip.addr);
                    ogs_assert(ipAddress->ipv4_addr);
                }
                if (session->ue_ip.ipv6) {
                    ipAddress->ipv6_addr =
                        ogs_ipv6addr_to_string(session->ue_ip.addr6);
                    ogs_assert(ipAddress->ipv6_addr);
                }

                if (ipAddress->ipv4_addr || ipAddress->ipv6_addr)
                    OpenAPI_list_add(staticIpAddress, ipAddress);
                else
                    ogs_free(ipAddress);
            }

            if (staticIpAddress->count)
                dnnConfiguration->static_ip_address = staticIpAddress;
            else
                OpenAPI_list_free(staticIpAddress);

            dnnConfigurationMap = OpenAPI_map_create(
                    session->name, dnnConfiguration);
            ogs_assert(dnnConfigurationMap);
            OpenAPI_list_add(dnnConfigurationList, dnnConfigurationMap);

            if (session->ipv4_framed_routes) {
                int i;
                FrameRouteList = OpenAPI_list_create();

                for (i = 0; i < OGS_MAX_NUM_OF_FRAMED_ROUTES_IN_PDI; i++) {
                    const char *route = session->ipv4_framed_routes[i];
                    if (!route) break;
                    OpenAPI_list_add(FrameRouteList,
                                     OpenAPI_frame_route_info_create(
                                             ogs_strdup(route), NULL));
                }
                dnnConfiguration->ipv4_frame_route_list = FrameRouteList;
            }

            if (session->ipv6_framed_routes) {
                int i;
                FrameRouteList = OpenAPI_list_create();

                for (i = 0; i < OGS_MAX_NUM_OF_FRAMED_ROUTES_IN_PDI; i++) {
                    const char *route = session->ipv6_framed_routes[i];
                    if (!route) break;
                    OpenAPI_list_add(FrameRouteList,
                                     OpenAPI_frame_route_info_create(
                                             NULL, ogs_strdup(route)));
                }
                dnnConfiguration->ipv6_frame_route_list = FrameRouteList;
            }
        }

        memset(&SessionManagementSubscriptionData, 0,
                sizeof(SessionManagementSubscriptionData));
        SessionManagementSubscriptionData.single_nssai = &singleNSSAI;
        if (dnnConfigurationList->count)
            SessionManagementSubscriptionData.dnn_configurations =
                dnnConfigurationList;

        memset(&sendmsg, 0, sizeof(sendmsg));
        
        sendmsg.SessionManagementSubscriptionDataList = OpenAPI_list_create();
        ogs_assert(sendmsg.SessionManagementSubscriptionDataList);

        OpenAPI_list_add(sendmsg.SessionManagementSubscriptionDataList,
            &SessionManagementSubscriptionData);

        response = ogs_sbi_build_response(&sendmsg, OGS_SBI_HTTP_STATUS_OK);
        ogs_assert(response);
        ogs_assert(true == ogs_sbi_server_send_response(stream, response));

        OpenAPI_list_free(sendmsg.SessionManagementSubscriptionDataList);

        if (singleNSSAI.sd)
            ogs_free(singleNSSAI.sd);

        OpenAPI_list_for_each(dnnConfigurationList, node) {
            dnnConfigurationMap = node->data;
            if (dnnConfigurationMap) {
                dnnConfiguration = dnnConfigurationMap->value;
                if (dnnConfiguration) {
                    pduSessionTypeList = dnnConfiguration->pdu_session_types;
                    if (pduSessionTypeList) {
                        if (pduSessionTypeList->allowed_session_types)
                            OpenAPI_list_free(
                                    pduSessionTypeList->allowed_session_types);
                        ogs_free(pduSessionTypeList);
                    }
                    sscModeList = dnnConfiguration->ssc_modes;;
                    if (sscModeList) {
                        if (sscModeList->allowed_ssc_modes)
                            OpenAPI_list_free(sscModeList->allowed_ssc_modes);
                        ogs_free(sscModeList);
                    }
                    _5gQoSProfile = dnnConfiguration->_5g_qos_profile;
                    if (_5gQoSProfile) {
                        if (_5gQoSProfile->arp)
                            ogs_free(_5gQoSProfile->arp);
                        ogs_free(_5gQoSProfile);
                    }

                    sessionAmbr = dnnConfiguration->session_ambr;
                    if (sessionAmbr) {
                        if (sessionAmbr->uplink)
                            ogs_free(sessionAmbr->uplink);
                        if (sessionAmbr->downlink)
                            ogs_free(sessionAmbr->downlink);
                        ogs_free(sessionAmbr);
                    }

                    staticIpAddress = dnnConfiguration->static_ip_address;
                    if (staticIpAddress) {
                        OpenAPI_list_for_each(staticIpAddress, node2) {
                            if (node2->data) {
                                ipAddress = node2->data;
                                if (ipAddress) {
                                    if (ipAddress->ipv4_addr)
                                        ogs_free(ipAddress->ipv4_addr);
                                    if (ipAddress->ipv6_addr)
                                        ogs_free(ipAddress->ipv6_addr);
                                    ogs_free(ipAddress);
                                }
                            }
                        }
                        OpenAPI_list_free(staticIpAddress);
                    }

                    FrameRouteList = dnnConfiguration->ipv4_frame_route_list;
                    OpenAPI_list_for_each(FrameRouteList, node2) {
                        OpenAPI_frame_route_info_t *frame = node2->data;
                        if (frame)
                            ogs_free(frame);
                    }
                    OpenAPI_list_free(FrameRouteList);

                    FrameRouteList = dnnConfiguration->ipv6_frame_route_list;
                    OpenAPI_list_for_each(FrameRouteList, node2) {
                        OpenAPI_frame_route_info_t *frame = node2->data;
                        if (frame)
                            ogs_free(frame);
                    }
                    OpenAPI_list_free(FrameRouteList);

                    ogs_free(dnnConfiguration);
                }
                ogs_free(dnnConfigurationMap);
            }
        }

        OpenAPI_list_free(dnnConfigurationList);

        break;

    DEFAULT
        strerror = ogs_msprintf("Invalid resource name [%s]",
                recvmsg->h.resource.component[3]);
        status = OGS_SBI_HTTP_STATUS_METHOD_NOT_ALLOWED;
        goto cleanup;
    END

    ogs_subscription_data_free(&subscription_data);

    return true;

cleanup:
    ogs_assert(strerror);
    ogs_assert(status);
    ogs_error("%s", strerror);
    ogs_assert(true ==
        ogs_sbi_server_send_error(stream, status, recvmsg, strerror, NULL,
                NULL));
    ogs_free(strerror);

    ogs_subscription_data_free(&subscription_data);

    return false;
}

bool udr_nudr_dr_handle_policy_data(
        ogs_sbi_stream_t *stream, ogs_sbi_message_t *recvmsg)
{
    int rv, i, status = 0;
    char *strerror = NULL;

    ogs_sbi_message_t sendmsg;
    ogs_sbi_response_t *response = NULL;

    ogs_subscription_data_t subscription_data;
    ogs_slice_data_t *slice_data = NULL;

    ogs_assert(stream);
    ogs_assert(recvmsg);

    memset(&subscription_data, 0, sizeof(ogs_subscription_data_t));

    SWITCH(recvmsg->h.resource.component[1])
    CASE(OGS_SBI_RESOURCE_NAME_UES)
        char *supi = recvmsg->h.resource.component[2];

        if (!supi) {
            strerror = ogs_msprintf("No SUPI");
            status = OGS_SBI_HTTP_STATUS_BAD_REQUEST;
            goto cleanup;
        }

        if (strncmp(supi,
                OGS_ID_SUPI_TYPE_IMSI, strlen(OGS_ID_SUPI_TYPE_IMSI)) != 0) {
            strerror = ogs_msprintf("[%s] Unknown SUPI Type", supi);
            status = OGS_SBI_HTTP_STATUS_FORBIDDEN;
            goto cleanup;
        }

        SWITCH(recvmsg->h.method)
        CASE(OGS_SBI_HTTP_METHOD_GET)
            OpenAPI_lnode_t *node = NULL, *node2 = NULL;

            rv = ogs_dbi_subscription_data(supi, &subscription_data);
            if (rv != OGS_OK) {
                strerror = ogs_msprintf("[%s] Cannot find SUPI in DB", supi);
                status = OGS_SBI_HTTP_STATUS_NOT_FOUND;
                goto cleanup;
            }

            SWITCH(recvmsg->h.resource.component[3])
            CASE(OGS_SBI_RESOURCE_NAME_AM_DATA)
                OpenAPI_am_policy_data_t AmPolicyData;

                memset(&AmPolicyData, 0, sizeof(AmPolicyData));

                memset(&sendmsg, 0, sizeof(sendmsg));
                sendmsg.AmPolicyData = &AmPolicyData;

                response = ogs_sbi_build_response(
                        &sendmsg, OGS_SBI_HTTP_STATUS_OK);
                ogs_assert(response);
                ogs_assert(true ==
                        ogs_sbi_server_send_response(stream, response));

                break;

            CASE(OGS_SBI_RESOURCE_NAME_SM_DATA)
                OpenAPI_sm_policy_data_t SmPolicyData;

                OpenAPI_list_t *SmPolicySnssaiDataList = NULL;
                OpenAPI_map_t *SmPolicySnssaiDataMap = NULL;
                OpenAPI_sm_policy_snssai_data_t *SmPolicySnssaiData = NULL;

                OpenAPI_snssai_t *sNSSAI = NULL;

                OpenAPI_list_t *SmPolicyDnnDataList = NULL;
                OpenAPI_map_t *SmPolicyDnnDataMap = NULL;
                OpenAPI_sm_policy_dnn_data_t *SmPolicyDnnData = NULL;

                if (!recvmsg->param.snssai_presence) {
                    strerror = ogs_msprintf("[%s] No S_NSSAI", supi);
                    status = OGS_SBI_HTTP_STATUS_BAD_REQUEST;
                    goto cleanup;
                }

                ogs_assert(subscription_data.num_of_slice);
                slice_data = ogs_slice_find_by_s_nssai(
                        subscription_data.slice, subscription_data.num_of_slice,
                        &recvmsg->param.s_nssai);

                if (!slice_data) {
                    strerror = ogs_msprintf(
                            "[%s] Cannot find S_NSSAI[SST:%d SD:0x%x]",
                            supi,
                            recvmsg->param.s_nssai.sst,
                            recvmsg->param.s_nssai.sd.v);
                    status = OGS_SBI_HTTP_STATUS_BAD_REQUEST;
                    goto cleanup;
                }

                sNSSAI = ogs_calloc(1, sizeof(*sNSSAI));
                ogs_assert(sNSSAI);
                sNSSAI->sst = slice_data->s_nssai.sst;
                sNSSAI->sd = ogs_s_nssai_sd_to_string(slice_data->s_nssai.sd);

                SmPolicyDnnDataList = OpenAPI_list_create();
                ogs_assert(SmPolicyDnnDataList);

                slice_data = &subscription_data.slice[0];

                for (i = 0; i < slice_data->num_of_session; i++) {
                    ogs_session_t *session = NULL;

                    if (i >= OGS_MAX_NUM_OF_SESS) {
                        ogs_warn("Ignore max session count overflow [%d>=%d]",
                            slice_data->num_of_session, OGS_MAX_NUM_OF_SESS);
                        break;
                    }

                    session = &slice_data->session[i];
                    ogs_assert(session);
                    ogs_assert(session->name);

                    if (recvmsg->param.dnn &&
                        ogs_strcasecmp(recvmsg->param.dnn, session->name) != 0)
                        continue;

                    SmPolicyDnnData = ogs_calloc(1, sizeof(*SmPolicyDnnData));
                    ogs_assert(SmPolicyDnnData);

                    SmPolicyDnnData->dnn = session->name;

                    SmPolicyDnnDataMap = OpenAPI_map_create(
                            session->name, SmPolicyDnnData);
                    ogs_assert(SmPolicyDnnDataMap);

                    OpenAPI_list_add(SmPolicyDnnDataList, SmPolicyDnnDataMap);
                }

                SmPolicySnssaiData = ogs_calloc(1, sizeof(*SmPolicySnssaiData));
                ogs_assert(SmPolicySnssaiData);

                SmPolicySnssaiData->snssai = sNSSAI;
                if (SmPolicyDnnDataList->count)
                    SmPolicySnssaiData->sm_policy_dnn_data =
                        SmPolicyDnnDataList;
                else
                    OpenAPI_list_free(SmPolicyDnnDataList);

                SmPolicySnssaiDataMap = OpenAPI_map_create(
                        ogs_sbi_s_nssai_to_string(&recvmsg->param.s_nssai),
                        SmPolicySnssaiData);
                ogs_assert(SmPolicySnssaiDataMap);
                ogs_assert(SmPolicySnssaiDataMap->key);

                SmPolicySnssaiDataList = OpenAPI_list_create();
                ogs_assert(SmPolicySnssaiDataList);

                OpenAPI_list_add(SmPolicySnssaiDataList, SmPolicySnssaiDataMap);

                memset(&SmPolicyData, 0, sizeof(SmPolicyData));

                if (SmPolicySnssaiDataList->count)
                    SmPolicyData.sm_policy_snssai_data = SmPolicySnssaiDataList;
                else
                    OpenAPI_list_free(SmPolicySnssaiDataList);

                memset(&sendmsg, 0, sizeof(sendmsg));
                sendmsg.SmPolicyData = &SmPolicyData;

                response = ogs_sbi_build_response(
                        &sendmsg, OGS_SBI_HTTP_STATUS_OK);
                ogs_assert(response);
                ogs_assert(true ==
                        ogs_sbi_server_send_response(stream, response));

                SmPolicySnssaiDataList = SmPolicyData.sm_policy_snssai_data;
                OpenAPI_list_for_each(SmPolicySnssaiDataList, node) {
                    SmPolicySnssaiDataMap = node->data;
                    if (SmPolicySnssaiDataMap) {
                        SmPolicySnssaiData = SmPolicySnssaiDataMap->value;
                        if (SmPolicySnssaiData) {
                            sNSSAI = SmPolicySnssaiData->snssai;
                            if (sNSSAI) {
                                if (sNSSAI->sd) ogs_free(sNSSAI->sd);
                                ogs_free(sNSSAI);
                            }
                            SmPolicyDnnDataList =
                                SmPolicySnssaiData->sm_policy_dnn_data;
                            if (SmPolicyDnnDataList) {
                                OpenAPI_list_for_each(
                                        SmPolicyDnnDataList, node2) {
                                    SmPolicyDnnDataMap = node2->data;
                                    if (SmPolicyDnnDataMap) {
                                        SmPolicyDnnData =
                                            SmPolicyDnnDataMap->value;
                                        if (SmPolicyDnnData) {
                                            ogs_free(SmPolicyDnnData);
                                        }
                                        ogs_free(SmPolicyDnnDataMap);
                                    }
                                }
                                OpenAPI_list_free(SmPolicyDnnDataList);
                            }
                            ogs_free(SmPolicySnssaiData);
                        }
                        if (SmPolicySnssaiDataMap->key)
                            ogs_free(SmPolicySnssaiDataMap->key);
                        ogs_free(SmPolicySnssaiDataMap);
                    }
                }
                OpenAPI_list_free(SmPolicySnssaiDataList);

                break;

            DEFAULT
                strerror = ogs_msprintf("Invalid resource name [%s]",
                        recvmsg->h.resource.component[3]);
                status = OGS_SBI_HTTP_STATUS_METHOD_NOT_ALLOWED;
                goto cleanup;
            END

            break;

        DEFAULT
            strerror = ogs_msprintf("Invalid HTTP method [%s]",
                    recvmsg->h.method);
            status = OGS_SBI_HTTP_STATUS_METHOD_NOT_ALLOWED;
            goto cleanup;
        END

        break;

    DEFAULT
        strerror = ogs_msprintf("Invalid resource name [%s]",
                recvmsg->h.resource.component[1]);
        status = OGS_SBI_HTTP_STATUS_METHOD_NOT_ALLOWED;
        goto cleanup;
    END

    ogs_subscription_data_free(&subscription_data);

    return true;

cleanup:
    ogs_assert(strerror);
    ogs_assert(status);
    ogs_error("%s", strerror);
    ogs_assert(true ==
        ogs_sbi_server_send_error(stream, status, recvmsg, strerror,
                NULL, NULL));
    ogs_free(strerror);

    ogs_subscription_data_free(&subscription_data);

    return false;
}