/*

 * The MIT License

 *

 * Copyright (C) 2019-2023 by Sukchan Lee <acetcom@gmail.com>

 *

 * This file is part of Open5GS.

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sublicense, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

/*******************************************************************************

 * This file had been created by nas-message.py script v0.1.0

 * Please do not modify this file but regenerate it via script.

 * Created on: 2023-03-02 22:57:51.860294 by acetcom

 * from 24301-h90.docx

 ******************************************************************************/

#include "ogs-nas-eps.h"

int ogs_nas_eps_decode_attach_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_attach_accept(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_attach_complete(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_attach_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_detach_request_from_ue(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_detach_request_to_ue(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_tracking_area_update_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_tracking_area_update_accept(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_tracking_area_update_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_extended_service_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_service_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_service_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_guti_reallocation_command(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_authentication_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_authentication_response(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_identity_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_identity_response(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_authentication_failure(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_security_mode_command(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_security_mode_complete(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_security_mode_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_emm_status(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_emm_information(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_downlink_nas_transport(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_uplink_nas_transport(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_cs_service_notification(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_uplink_generic_nas_transport(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_downlink_generic_nas_transport(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_activate_default_eps_bearer_context_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_activate_default_eps_bearer_context_accept(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_activate_default_eps_bearer_context_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_activate_dedicated_eps_bearer_context_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_activate_dedicated_eps_bearer_context_accept(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_activate_dedicated_eps_bearer_context_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_modify_eps_bearer_context_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_modify_eps_bearer_context_accept(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_modify_eps_bearer_context_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_deactivate_eps_bearer_context_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_deactivate_eps_bearer_context_accept(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_pdn_connectivity_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_pdn_connectivity_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_pdn_disconnect_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_pdn_disconnect_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_bearer_resource_allocation_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_bearer_resource_allocation_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_bearer_resource_modification_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_bearer_resource_modification_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_esm_information_response(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_esm_status(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf);

int ogs_nas_eps_decode_attach_request(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf)

{

    ogs_nas_eps_attach_request_t *attach_request = &message->emm.attach_request;

    int decoded = 0;

    int size = 0;

    ogs_trace("[NAS] Decode ATTACH_REQUEST\n");

    size = ogs_nas_eps_decode_eps_attach_type(&attach_request->eps_attach_type, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_eps_attach_type() failed");

        return size;

    }

    decoded += size;

    size = ogs_nas_eps_decode_eps_mobile_identity(&attach_request->eps_mobile_identity, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed");

        return size;

    }

    decoded += size;

    size = ogs_nas_eps_decode_ue_network_capability(&attach_request->ue_network_capability, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_ue_network_capability() failed");

        return size;

    }

    decoded += size;

    size = ogs_nas_eps_decode_esm_message_container(&attach_request->esm_message_container, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_esm_message_container() failed");

        return size;

    }

    decoded += size;

    while (pkbuf->len > 0) {

        uint8_t *buffer = pkbuf->data;

        uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer);

        size = sizeof(uint8_t);

        if (ogs_pkbuf_pull(pkbuf, size) == NULL) {

           ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size);

           return OGS_ERROR;

        }

        decoded += size;

        switch (type) {

        case OGS_NAS_EPS_ATTACH_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE:

            size = ogs_nas_eps_decode_p_tmsi_signature(&attach_request->old_p_tmsi_signature, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_p_tmsi_signature() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_GUTI_TYPE:

            size = ogs_nas_eps_decode_eps_mobile_identity(&attach_request->additional_guti, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_GUTI_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE:

            size = ogs_nas_eps_decode_tracking_area_identity(&attach_request->last_visited_registered_tai, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_tracking_area_identity() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_TYPE:

            size = ogs_nas_eps_decode_drx_parameter(&attach_request->drx_parameter, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_drx_parameter() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_CAPABILITY_TYPE:

            size = ogs_nas_eps_decode_ms_network_capability(&attach_request->ms_network_capability, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_ms_network_capability() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_CAPABILITY_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE:

            size = ogs_nas_eps_decode_location_area_identification(&attach_request->old_location_area_identification, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_location_area_identification() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_TMSI_STATUS_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_tmsi_status(&attach_request->tmsi_status, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_tmsi_status() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_TMSI_STATUS_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE:

            size = ogs_nas_eps_decode_mobile_station_classmark_2(&attach_request->mobile_station_classmark_2, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_mobile_station_classmark_2() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE:

            size = ogs_nas_eps_decode_mobile_station_classmark_3(&attach_request->mobile_station_classmark_3, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_mobile_station_classmark_3() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_SUPPORTED_CODECS_TYPE:

            size = ogs_nas_eps_decode_supported_codec_list(&attach_request->supported_codecs, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_supported_codec_list() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_SUPPORTED_CODECS_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_additional_update_type(&attach_request->additional_update_type, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_additional_update_type() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE:

            size = ogs_nas_eps_decode_voice_domain_preference_and_ue_usage_setting(&attach_request->voice_domain_preference_and_ue_usage_setting, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_voice_domain_preference_and_ue_usage_setting() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_DEVICE_PROPERTIES_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_device_properties(&attach_request->device_properties, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_device_properties() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_DEVICE_PROPERTIES_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_OLD_GUTI_TYPE_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_guti_type(&attach_request->old_guti_type, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_guti_type() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_OLD_GUTI_TYPE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_ms_network_feature_support(&attach_request->ms_network_feature_support, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_ms_network_feature_support() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE:

            size = ogs_nas_eps_decode_network_resource_identifier_container(&attach_request->tmsi_based_nri_container, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_network_resource_identifier_container() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_T3324_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer_2(&attach_request->t3324_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_T3324_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_T3412_EXTENDED_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer_3(&attach_request->t3412_extended_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_T3412_EXTENDED_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE:

            size = ogs_nas_eps_decode_extended_drx_parameters(&attach_request->extended_drx_parameters, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_extended_drx_parameters() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE:

            size = ogs_nas_eps_decode_ue_additional_security_capability(&attach_request->ue_additional_security_capability, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_ue_additional_security_capability() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_UE_STATUS_TYPE:

            size = ogs_nas_eps_decode_ue_status(&attach_request->ue_status, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_ue_status() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_STATUS_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_TYPE:

            size = ogs_nas_eps_decode_additional_information_requested(&attach_request->additional_information_requested, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_additional_information_requested() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_N1_UE_NETWORK_CAPABILITY_TYPE:

            size = ogs_nas_eps_decode_n1_ue_network_capability(&attach_request->n1_ue_network_capability, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_n1_ue_network_capability() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_N1_UE_NETWORK_CAPABILITY_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_TYPE:

            size = ogs_nas_eps_decode_ue_radio_capability_id_availability(&attach_request->ue_radio_capability_id_availability, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_ue_radio_capability_id_availability() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_TYPE:

            size = ogs_nas_eps_decode_wus_assistance_information(&attach_request->requested_wus_assistance_information, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_wus_assistance_information() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_TYPE:

            size = ogs_nas_eps_decode_nb_s1_drx_parameter(&attach_request->drx_parameter_in_nb_s1_mode, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_nb_s1_drx_parameter() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_IMSI_OFFSET_TYPE:

            size = ogs_nas_eps_decode_imsi_offset(&attach_request->requested_imsi_offset, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_imsi_offset() failed");

               return size;

            }

            attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_IMSI_OFFSET_PRESENT;

            decoded += size;

            break;

        default:

            ogs_warn("Unknown type(0x%x) or not implemented\n", type);

            break;

        }

    }

    return decoded;

}

int ogs_nas_eps_decode_attach_accept(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf)

{

    ogs_nas_eps_attach_accept_t *attach_accept = &message->emm.attach_accept;

    int decoded = 0;

    int size = 0;

    ogs_trace("[NAS] Decode ATTACH_ACCEPT\n");

    size = ogs_nas_eps_decode_eps_attach_result(&attach_accept->eps_attach_result, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_eps_attach_result() failed");

        return size;

    }

    decoded += size;

    size = ogs_nas_eps_decode_gprs_timer(&attach_accept->t3412_value, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_gprs_timer() failed");

        return size;

    }

    decoded += size;

    size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_accept->tai_list, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed");

        return size;

    }

    decoded += size;

    size = ogs_nas_eps_decode_esm_message_container(&attach_accept->esm_message_container, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_esm_message_container() failed");

        return size;

    }

    decoded += size;

    while (pkbuf->len > 0) {

        uint8_t *buffer = pkbuf->data;

        uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer);

        size = sizeof(uint8_t);

        if (ogs_pkbuf_pull(pkbuf, size) == NULL) {

           ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size);

           return OGS_ERROR;

        }

        decoded += size;

        switch (type) {

        case OGS_NAS_EPS_ATTACH_ACCEPT_GUTI_TYPE:

            size = ogs_nas_eps_decode_eps_mobile_identity(&attach_accept->guti, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_GUTI_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE:

            size = ogs_nas_eps_decode_location_area_identification(&attach_accept->location_area_identification, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_location_area_identification() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_MS_IDENTITY_TYPE:

            size = ogs_nas_eps_decode_mobile_identity(&attach_accept->ms_identity, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_mobile_identity() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_MS_IDENTITY_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_EMM_CAUSE_TYPE:

            size = ogs_nas_eps_decode_emm_cause(&attach_accept->emm_cause, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_emm_cause() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EMM_CAUSE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_T3402_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer(&attach_accept->t3402_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3402_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_T3423_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer(&attach_accept->t3423_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3423_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_EQUIVALENT_PLMNS_TYPE:

            size = ogs_nas_eps_decode_plmn_list(&attach_accept->equivalent_plmns, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_plmn_list() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EQUIVALENT_PLMNS_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE:

            size = ogs_nas_eps_decode_emergency_number_list(&attach_accept->emergency_number_list, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_emergency_number_list() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE:

            size = ogs_nas_eps_decode_eps_network_feature_support(&attach_accept->eps_network_feature_support, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_eps_network_feature_support() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_additional_update_result(&attach_accept->additional_update_result, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_additional_update_result() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_T3412_EXTENDED_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer_3(&attach_accept->t3412_extended_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3412_EXTENDED_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_T3324_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer_2(&attach_accept->t3324_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3324_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE:

            size = ogs_nas_eps_decode_extended_drx_parameters(&attach_accept->extended_drx_parameters, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_extended_drx_parameters() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_DCN_ID_TYPE:

            size = ogs_nas_eps_decode_dcn_id(&attach_accept->dcn_id, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_dcn_id() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_DCN_ID_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_SMS_SERVICES_STATUS_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_sms_services_status(&attach_accept->sms_services_status, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_sms_services_status() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_SMS_SERVICES_STATUS_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_NON__NW_PROVIDED_POLICIES_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_non__nw_provided_policies(&attach_accept->non__nw_provided_policies, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_non__nw_provided_policies() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NON__NW_PROVIDED_POLICIES_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_T3448_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer_2(&attach_accept->t3448_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3448_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_NETWORK_POLICY_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_network_policy(&attach_accept->network_policy, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_network_policy() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NETWORK_POLICY_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_T3447_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer_3(&attach_accept->t3447_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3447_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_TYPE:

            size = ogs_nas_eps_decode_extended_emergency_number_list(&attach_accept->extended_emergency_number_list, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_extended_emergency_number_list() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_CIPHERING_KEY_DATA_TYPE:

            size = ogs_nas_eps_decode_ciphering_key_data(&attach_accept->ciphering_key_data, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_ciphering_key_data() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_CIPHERING_KEY_DATA_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_TYPE:

            size = ogs_nas_eps_decode_ue_radio_capability_id(&attach_accept->ue_radio_capability_id, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_ue_radio_capability_id() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication(&attach_accept->ue_radio_capability_id_deletion_indication, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_TYPE:

            size = ogs_nas_eps_decode_wus_assistance_information(&attach_accept->negotiated_wus_assistance_information, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_wus_assistance_information() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_TYPE:

            size = ogs_nas_eps_decode_nb_s1_drx_parameter(&attach_accept->negotiated_drx_parameter_in_nb_s1_mode, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_nb_s1_drx_parameter() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_IMSI_OFFSET_TYPE:

            size = ogs_nas_eps_decode_imsi_offset(&attach_accept->negotiated_imsi_offset, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_imsi_offset() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_IMSI_OFFSET_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE:

            size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_accept->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE:

            size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_accept->forbidden_tai_for_the_list_of_forbidden_tracking_areas_forregional_provision_of_service, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed");

               return size;

            }

            attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT;

            decoded += size;

            break;

        default:

            ogs_warn("Unknown type(0x%x) or not implemented\n", type);

            break;

        }

    }

    return decoded;

}

int ogs_nas_eps_decode_attach_complete(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf)

{

    ogs_nas_eps_attach_complete_t *attach_complete = &message->emm.attach_complete;

    int decoded = 0;

    int size = 0;

    ogs_trace("[NAS] Decode ATTACH_COMPLETE\n");

    size = ogs_nas_eps_decode_esm_message_container(&attach_complete->esm_message_container, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_esm_message_container() failed");

        return size;

    }

    decoded += size;

    return decoded;

}

int ogs_nas_eps_decode_attach_reject(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf)

{

    ogs_nas_eps_attach_reject_t *attach_reject = &message->emm.attach_reject;

    int decoded = 0;

    int size = 0;

    ogs_trace("[NAS] Decode ATTACH_REJECT\n");

    size = ogs_nas_eps_decode_emm_cause(&attach_reject->emm_cause, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_emm_cause() failed");

        return size;

    }

    decoded += size;

    while (pkbuf->len > 0) {

        uint8_t *buffer = pkbuf->data;

        uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer);

        size = sizeof(uint8_t);

        if (ogs_pkbuf_pull(pkbuf, size) == NULL) {

           ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size);

           return OGS_ERROR;

        }

        decoded += size;

        switch (type) {

        case OGS_NAS_EPS_ATTACH_REJECT_ESM_MESSAGE_CONTAINER_TYPE:

            size = ogs_nas_eps_decode_esm_message_container(&attach_reject->esm_message_container, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_esm_message_container() failed");

               return size;

            }

            attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_ESM_MESSAGE_CONTAINER_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REJECT_T3346_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer_2(&attach_reject->t3346_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed");

               return size;

            }

            attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_T3346_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REJECT_T3402_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer_2(&attach_reject->t3402_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed");

               return size;

            }

            attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_T3402_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REJECT_EXTENDED_EMM_CAUSE_TYPE:

            decoded--;

            ogs_assert(ogs_pkbuf_push(pkbuf, 1));

            size = ogs_nas_eps_decode_extended_emm_cause(&attach_reject->extended_emm_cause, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_extended_emm_cause() failed");

               return size;

            }

            attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_EXTENDED_EMM_CAUSE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer_3(&attach_reject->lower_bound_timer_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed");

               return size;

            }

            attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE:

            size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_reject->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed");

               return size;

            }

            attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE:

            size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_reject->forbidden_tai_for_the_list_of_forbidden_tracking_areas_forregional_provision_of_service, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed");

               return size;

            }

            attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT;

            decoded += size;

            break;

        default:

            ogs_warn("Unknown type(0x%x) or not implemented\n", type);

            break;

        }

    }

    return decoded;

}

int ogs_nas_eps_decode_detach_request_from_ue(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf)

{

    ogs_nas_eps_detach_request_from_ue_t *detach_request_from_ue = &message->emm.detach_request_from_ue;

    int decoded = 0;

    int size = 0;

    ogs_trace("[NAS] Decode DETACH_REQUEST\n");

    size = ogs_nas_eps_decode_detach_type(&detach_request_from_ue->detach_type, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_detach_type() failed");

        return size;

    }

    decoded += size;

    size = ogs_nas_eps_decode_eps_mobile_identity(&detach_request_from_ue->eps_mobile_identity, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed");

        return size;

    }

    decoded += size;

    return decoded;

}

int ogs_nas_eps_decode_detach_request_to_ue(ogs_nas_eps_message_t *message, ogs_pkbuf_t *pkbuf)

{

    ogs_nas_eps_detach_request_to_ue_t *detach_request_to_ue = &message->emm.detach_request_to_ue;

    int decoded = 0;

    int size = 0;

    ogs_trace("[NAS] Decode DETACH_REQUEST\n");

    size = ogs_nas_eps_decode_detach_type(&detach_request_to_ue->detach_type, pkbuf);

    if (size < 0) {

        ogs_error("ogs_nas_eps_decode_detach_type() failed");

        return size;

    }

    decoded += size;

    while (pkbuf->len > 0) {

        uint8_t *buffer = pkbuf->data;

        uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer);

        size = sizeof(uint8_t);

        if (ogs_pkbuf_pull(pkbuf, size) == NULL) {

           ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size);

           return OGS_ERROR;

        }

        decoded += size;

        switch (type) {

        case OGS_NAS_EPS_DETACH_REQUEST_EMM_CAUSE_TYPE:

            size = ogs_nas_eps_decode_emm_cause(&detach_request_to_ue->emm_cause, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_emm_cause() failed");

               return size;

            }

            detach_request_to_ue->presencemask |= OGS_NAS_EPS_DETACH_REQUEST_EMM_CAUSE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_DETACH_REQUEST_LOWER_BOUND_TIMER_VALUE_TYPE:

            size = ogs_nas_eps_decode_gprs_timer_3(&detach_request_to_ue->lower_bound_timer_value, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed");

               return size;

            }

            detach_request_to_ue->presencemask |= OGS_NAS_EPS_DETACH_REQUEST_LOWER_BOUND_TIMER_VALUE_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_DETACH_REQUEST_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE:

            size = ogs_nas_eps_decode_tracking_area_identity_list(&detach_request_to_ue->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed");

               return size;

            }

            detach_request_to_ue->presencemask |= OGS_NAS_EPS_DETACH_REQUEST_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT;

            decoded += size;

            break;

        case OGS_NAS_EPS_DETACH_REQUEST_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE:

            size = ogs_nas_eps_decode_tracking_area_identity_list(&detach_request_to_ue->forbidden_tai_for_the_list_of_forbidden_tracking_areas_forregional_provision_of_service, pkbuf);

            if (size < 0) {

               ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed");