From 4694a0b75fd6115fe84ae7d220a06bb4f7a5e534 Mon Sep 17 00:00:00 2001 From: Sukchan Lee Date: Tue, 25 Apr 2017 20:08:03 +0900 Subject: [PATCH] update generated files --- lib/nas/nas_decoder.c | 543 +++++++++++++++++++++++++++++++++- lib/nas/nas_encoder.c | 656 +++++++++++++++++++++++++++++++++++++++++- lib/nas/nas_ies.c | 224 ++++++++++++++- lib/nas/nas_ies.h | 20 +- lib/nas/nas_message.h | 252 +++++++++++++++- 5 files changed, 1680 insertions(+), 15 deletions(-) diff --git a/lib/nas/nas_decoder.c b/lib/nas/nas_decoder.c index d263ec360..f8fcbaa9b 100644 --- a/lib/nas/nas_decoder.c +++ b/lib/nas/nas_decoder.c @@ -26,7 +26,7 @@ /******************************************************************************* * This file had been created by gtpv2c_tlv.py script v0.1.0 * Please do not modify this file but regenerate it via script. - * Created on: 2017-04-14 18:08:22.127231 by acetcom + * Created on: 2017-04-25 20:02:55.614205 by acetcom * from 24301-d80.docx ******************************************************************************/ @@ -381,6 +381,511 @@ c_int32_t nas_decode_attach_reject(nas_message_t *message, pkbuf_t *pkbuf) return decoded; } +c_int32_t nas_decode_detach_request_from_ue(nas_message_t *message, pkbuf_t *pkbuf) +{ + nas_detach_request_from_ue_t *detach_request_from_ue = &message->emm.detach_request_from_ue; + c_int32_t decoded = 0; + c_int32_t size = 0; + + size = nas_decode_detach_type(&detach_request_from_ue->detach_type, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + decoded += size; + + size = nas_decode_eps_mobile_identity(&detach_request_from_ue->eps_mobile_identity, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + decoded += size; + + return decoded; +} + +c_int32_t nas_decode_detach_request_to_ue(nas_message_t *message, pkbuf_t *pkbuf) +{ + nas_detach_request_to_ue_t *detach_request_to_ue = &message->emm.detach_request_to_ue; + c_int32_t decoded = 0; + c_int32_t size = 0; + + size = nas_decode_detach_type(&detach_request_to_ue->detach_type, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + decoded += size; + + while(pkbuf->len > 0) + { + c_uint8_t *buffer = pkbuf->payload; + c_uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); + + size = sizeof(c_uint8_t); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, + "pkbuf_header error"); + decoded += size; + + switch(type) + { + case NAS_DETACH_REQUEST_TO_UE_EMM_CAUSE_TYPE: + size = nas_decode_emm_cause(&detach_request_to_ue->emm_cause, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + detach_request_to_ue->presencemask |= NAS_DETACH_REQUEST_TO_UE_EMM_CAUSE_PRESENT; + decoded += size; + break; + default: + d_error("Unknown type(0x%x) or not implemented\n", type); + return -1; + } + } + + return decoded; +} + +c_int32_t nas_decode_tracking_area_update_request(nas_message_t *message, pkbuf_t *pkbuf) +{ + nas_tracking_area_update_request_t *tracking_area_update_request = &message->emm.tracking_area_update_request; + c_int32_t decoded = 0; + c_int32_t size = 0; + + size = nas_decode_eps_update_type(&tracking_area_update_request->eps_update_type, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + decoded += size; + + size = nas_decode_eps_mobile_identity(&tracking_area_update_request->old_guti, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + decoded += size; + + while(pkbuf->len > 0) + { + c_uint8_t *buffer = pkbuf->payload; + c_uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); + + size = sizeof(c_uint8_t); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, + "pkbuf_header error"); + decoded += size; + + switch(type) + { + case NAS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_TYPE: + size = nas_decode_key_set_identifier(&tracking_area_update_request->non_current_native_nas_key_set_identifier, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_TYPE: + size = nas_decode_ciphering_key_sequence_number(&tracking_area_update_request->gprs_ciphering_key_sequence_number, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE: + size = nas_decode_p_tmsi_signature(&tracking_area_update_request->old_p_tmsi_signature, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_TYPE: + size = nas_decode_eps_mobile_identity(&tracking_area_update_request->additional_guti, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_TYPE: + size = nas_decode_nonce(&tracking_area_update_request->nonceue, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_TYPE: + size = nas_decode_ue_network_capability(&tracking_area_update_request->ue_network_capability, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE: + size = nas_decode_tracking_area_identity(&tracking_area_update_request->last_visited_registered_tai, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_TYPE: + size = nas_decode_drx_parameter(&tracking_area_update_request->drx_parameter, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_TYPE: + size = nas_decode_ue_radio_capability_information_update_needed(&tracking_area_update_request->ue_radio_capability_information_update_needed, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE: + size = nas_decode_eps_bearer_context_status(&tracking_area_update_request->eps_bearer_context_status, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_TYPE: + size = nas_decode_ms_network_capability(&tracking_area_update_request->ms_network_capability, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE: + size = nas_decode_location_area_identification(&tracking_area_update_request->old_location_area_identification, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_TYPE: + size = nas_decode_tmsi_status(&tracking_area_update_request->tmsi_status, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE: + size = nas_decode_mobile_station_classmark_2(&tracking_area_update_request->mobile_station_classmark_2, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE: + size = nas_decode_mobile_station_classmark_3(&tracking_area_update_request->mobile_station_classmark_3, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_TYPE: + size = nas_decode_supported_codec_list(&tracking_area_update_request->supported_codecs, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE: + size = nas_decode_additional_update_type(&tracking_area_update_request->additional_update_type, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE: + size = nas_decode_voice_domain_preference_and_ue_usage_setting(&tracking_area_update_request->voice_domain_preference_and_ue_usage_setting, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_TYPE: + size = nas_decode_guti_type(&tracking_area_update_request->old_guti_type, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_TYPE: + size = nas_decode_device_properties(&tracking_area_update_request->device_properties, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE: + size = nas_decode_ms_network_feature_support(&tracking_area_update_request->ms_network_feature_support, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE: + size = nas_decode_network_resource_identifier_container(&tracking_area_update_request->tmsi_based_nri_container, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_TYPE: + size = nas_decode_gprs_timer_2(&tracking_area_update_request->t3324_value, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_TYPE: + size = nas_decode_gprs_timer_3(&tracking_area_update_request->t3412_extended_value, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE: + size = nas_decode_extended_drx_parameters(&tracking_area_update_request->extended_drx_parameters, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_request->presencemask |= NAS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT; + decoded += size; + break; + default: + d_error("Unknown type(0x%x) or not implemented\n", type); + return -1; + } + } + + return decoded; +} + +c_int32_t nas_decode_tracking_area_update_accept(nas_message_t *message, pkbuf_t *pkbuf) +{ + nas_tracking_area_update_accept_t *tracking_area_update_accept = &message->emm.tracking_area_update_accept; + c_int32_t decoded = 0; + c_int32_t size = 0; + + size = nas_decode_eps_update_result(&tracking_area_update_accept->eps_update_result, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + decoded += size; + + while(pkbuf->len > 0) + { + c_uint8_t *buffer = pkbuf->payload; + c_uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); + + size = sizeof(c_uint8_t); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, + "pkbuf_header error"); + decoded += size; + + switch(type) + { + case NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_TYPE: + size = nas_decode_gprs_timer(&tracking_area_update_accept->t3412_value, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_TYPE: + size = nas_decode_eps_mobile_identity(&tracking_area_update_accept->guti, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_TYPE: + size = nas_decode_tracking_area_identity_list(&tracking_area_update_accept->tai_list, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_TYPE: + size = nas_decode_eps_bearer_context_status(&tracking_area_update_accept->eps_bearer_context_status, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE: + size = nas_decode_location_area_identification(&tracking_area_update_accept->location_area_identification, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_TYPE: + size = nas_decode_mobile_identity(&tracking_area_update_accept->ms_identity, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_TYPE: + size = nas_decode_emm_cause(&tracking_area_update_accept->emm_cause, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_TYPE: + size = nas_decode_gprs_timer(&tracking_area_update_accept->t3402_value, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_TYPE: + size = nas_decode_gprs_timer(&tracking_area_update_accept->t3423_value, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_TYPE: + size = nas_decode_plmn_list(&tracking_area_update_accept->equivalent_plmns, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE: + size = nas_decode_emergency_number_list(&tracking_area_update_accept->emergency_number_list, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE: + size = nas_decode_eps_network_feature_support(&tracking_area_update_accept->eps_network_feature_support, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE: + size = nas_decode_additional_update_result(&tracking_area_update_accept->additional_update_result, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_TYPE: + size = nas_decode_gprs_timer_3(&tracking_area_update_accept->t3412_extended_value, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_TYPE: + size = nas_decode_gprs_timer_2(&tracking_area_update_accept->t3324_value, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE: + size = nas_decode_extended_drx_parameters(&tracking_area_update_accept->extended_drx_parameters, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_TYPE: + size = nas_decode_header_compression_configuration_status(&tracking_area_update_accept->header_compression_configuration_status, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_accept->presencemask |= NAS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_PRESENT; + decoded += size; + break; + default: + d_error("Unknown type(0x%x) or not implemented\n", type); + return -1; + } + } + + return decoded; +} + +c_int32_t nas_decode_tracking_area_update_reject(nas_message_t *message, pkbuf_t *pkbuf) +{ + nas_tracking_area_update_reject_t *tracking_area_update_reject = &message->emm.tracking_area_update_reject; + c_int32_t decoded = 0; + c_int32_t size = 0; + + size = nas_decode_emm_cause(&tracking_area_update_reject->emm_cause, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + decoded += size; + + while(pkbuf->len > 0) + { + c_uint8_t *buffer = pkbuf->payload; + c_uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); + + size = sizeof(c_uint8_t); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, + "pkbuf_header error"); + decoded += size; + + switch(type) + { + case NAS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_TYPE: + size = nas_decode_gprs_timer_2(&tracking_area_update_reject->t3346_value, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_reject->presencemask |= NAS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_PRESENT; + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_TYPE: + size = nas_decode_extended_emm_cause(&tracking_area_update_reject->extended_emm_cause, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + tracking_area_update_reject->presencemask |= NAS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_PRESENT; + decoded += size; + break; + default: + d_error("Unknown type(0x%x) or not implemented\n", type); + return -1; + } + } + + return decoded; +} + +c_int32_t nas_decode_extended_service_request(nas_message_t *message, pkbuf_t *pkbuf) +{ + nas_extended_service_request_t *extended_service_request = &message->emm.extended_service_request; + c_int32_t decoded = 0; + c_int32_t size = 0; + + size = nas_decode_service_type(&extended_service_request->service_type, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + decoded += size; + + size = nas_decode_mobile_identity(&extended_service_request->m_tmsi, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + decoded += size; + + while(pkbuf->len > 0) + { + c_uint8_t *buffer = pkbuf->payload; + c_uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); + + size = sizeof(c_uint8_t); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, + "pkbuf_header error"); + decoded += size; + + switch(type) + { + case NAS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_TYPE: + size = nas_decode_csfb_response(&extended_service_request->csfb_response, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + extended_service_request->presencemask |= NAS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_PRESENT; + decoded += size; + break; + case NAS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE: + size = nas_decode_eps_bearer_context_status(&extended_service_request->eps_bearer_context_status, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + extended_service_request->presencemask |= NAS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT; + decoded += size; + break; + case NAS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_TYPE: + size = nas_decode_device_properties(&extended_service_request->device_properties, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + extended_service_request->presencemask |= NAS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_PRESENT; + decoded += size; + break; + default: + d_error("Unknown type(0x%x) or not implemented\n", type); + return -1; + } + } + + return decoded; +} + +c_int32_t nas_decode_service_reject(nas_message_t *message, pkbuf_t *pkbuf) +{ + nas_service_reject_t *service_reject = &message->emm.service_reject; + c_int32_t decoded = 0; + c_int32_t size = 0; + + size = nas_decode_emm_cause(&service_reject->emm_cause, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + decoded += size; + + while(pkbuf->len > 0) + { + c_uint8_t *buffer = pkbuf->payload; + c_uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); + + size = sizeof(c_uint8_t); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, + "pkbuf_header error"); + decoded += size; + + switch(type) + { + case NAS_SERVICE_REJECT_T3346_VALUE_TYPE: + size = nas_decode_gprs_timer_2(&service_reject->t3346_value, pkbuf); + d_assert(size >= 0, return -1, "decode failed"); + service_reject->presencemask |= NAS_SERVICE_REJECT_T3346_VALUE_PRESENT; + decoded += size; + break; + default: + d_error("Unknown type(0x%x) or not implemented\n", type); + return -1; + } + } + + return decoded; +} + c_int32_t nas_decode_authentication_request(nas_message_t *message, pkbuf_t *pkbuf) { nas_authentication_request_t *authentication_request = &message->emm.authentication_request; @@ -1166,6 +1671,42 @@ status_t nas_emm_decode(nas_message_t *message, pkbuf_t *pkbuf) d_assert(size >= CORE_OK, return CORE_ERROR, "decode error"); decoded += size; break; + case NAS_DETACH_REQUEST_FROM_UE: + size = nas_decode_detach_request_from_ue(message, pkbuf); + d_assert(size >= CORE_OK, return CORE_ERROR, "decode error"); + decoded += size; + break; + case NAS_DETACH_ACCEPT: + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST: + size = nas_decode_tracking_area_update_request(message, pkbuf); + d_assert(size >= CORE_OK, return CORE_ERROR, "decode error"); + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT: + size = nas_decode_tracking_area_update_accept(message, pkbuf); + d_assert(size >= CORE_OK, return CORE_ERROR, "decode error"); + decoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_COMPLETE: + break; + case NAS_TRACKING_AREA_UPDATE_REJECT: + size = nas_decode_tracking_area_update_reject(message, pkbuf); + d_assert(size >= CORE_OK, return CORE_ERROR, "decode error"); + decoded += size; + break; + case NAS_EXTENDED_SERVICE_REQUEST: + size = nas_decode_extended_service_request(message, pkbuf); + d_assert(size >= CORE_OK, return CORE_ERROR, "decode error"); + decoded += size; + break; + case NAS_SERVICE_REQUEST: + break; + case NAS_SERVICE_REJECT: + size = nas_decode_service_reject(message, pkbuf); + d_assert(size >= CORE_OK, return CORE_ERROR, "decode error"); + decoded += size; + break; case NAS_AUTHENTICATION_REQUEST: size = nas_decode_authentication_request(message, pkbuf); d_assert(size >= CORE_OK, return CORE_ERROR, "decode error"); diff --git a/lib/nas/nas_encoder.c b/lib/nas/nas_encoder.c index b40141adb..fd56db981 100644 --- a/lib/nas/nas_encoder.c +++ b/lib/nas/nas_encoder.c @@ -26,7 +26,7 @@ /******************************************************************************* * This file had been created by gtpv2c_tlv.py script v0.1.0 * Please do not modify this file but regenerate it via script. - * Created on: 2017-04-14 18:08:22.139682 by acetcom + * Created on: 2017-04-25 20:02:55.628053 by acetcom * from 24301-d80.docx ******************************************************************************/ @@ -493,6 +493,624 @@ c_int32_t nas_encode_attach_reject(pkbuf_t *pkbuf, nas_message_t *message) return encoded; } +c_int32_t nas_encode_detach_request_from_ue(pkbuf_t *pkbuf, nas_message_t *message) +{ + nas_detach_request_from_ue_t *detach_request_from_ue = &message->emm.detach_request_from_ue; + c_int32_t encoded = 0; + c_int32_t size = 0; + + size = nas_encode_detach_type(pkbuf, &detach_request_from_ue->detach_type); + d_assert(size >= 0, return -1, "encode failed"); + encoded += size; + + size = nas_encode_eps_mobile_identity(pkbuf, &detach_request_from_ue->eps_mobile_identity); + d_assert(size >= 0, return -1, "encode failed"); + encoded += size; + + return encoded; +} + +c_int32_t nas_encode_detach_request_to_ue(pkbuf_t *pkbuf, nas_message_t *message) +{ + nas_detach_request_to_ue_t *detach_request_to_ue = &message->emm.detach_request_to_ue; + c_int32_t encoded = 0; + c_int32_t size = 0; + + size = nas_encode_detach_type(pkbuf, &detach_request_to_ue->detach_type); + d_assert(size >= 0, return -1, "encode failed"); + encoded += size; + + if (detach_request_to_ue->presencemask & NAS_DETACH_REQUEST_TO_UE_EMM_CAUSE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_DETACH_REQUEST_TO_UE_EMM_CAUSE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_emm_cause(pkbuf, &detach_request_to_ue->emm_cause); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + return encoded; +} + +c_int32_t nas_encode_tracking_area_update_request(pkbuf_t *pkbuf, nas_message_t *message) +{ + nas_tracking_area_update_request_t *tracking_area_update_request = &message->emm.tracking_area_update_request; + c_int32_t encoded = 0; + c_int32_t size = 0; + + size = nas_encode_eps_update_type(pkbuf, &tracking_area_update_request->eps_update_type); + d_assert(size >= 0, return -1, "encode failed"); + encoded += size; + + size = nas_encode_eps_mobile_identity(pkbuf, &tracking_area_update_request->old_guti); + d_assert(size >= 0, return -1, "encode failed"); + encoded += size; + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_PRESENT) + { + tracking_area_update_request->non_current_native_nas_key_set_identifier.type = (NAS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_TYPE >> 4); + + size = nas_encode_key_set_identifier(pkbuf, &tracking_area_update_request->non_current_native_nas_key_set_identifier); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_PRESENT) + { + tracking_area_update_request->gprs_ciphering_key_sequence_number.type = (NAS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_TYPE >> 4); + + size = nas_encode_ciphering_key_sequence_number(pkbuf, &tracking_area_update_request->gprs_ciphering_key_sequence_number); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_p_tmsi_signature(pkbuf, &tracking_area_update_request->old_p_tmsi_signature); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_eps_mobile_identity(pkbuf, &tracking_area_update_request->additional_guti); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_nonce(pkbuf, &tracking_area_update_request->nonceue); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_ue_network_capability(pkbuf, &tracking_area_update_request->ue_network_capability); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_tracking_area_identity(pkbuf, &tracking_area_update_request->last_visited_registered_tai); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_drx_parameter(pkbuf, &tracking_area_update_request->drx_parameter); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_PRESENT) + { + tracking_area_update_request->ue_radio_capability_information_update_needed.type = (NAS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_TYPE >> 4); + + size = nas_encode_ue_radio_capability_information_update_needed(pkbuf, &tracking_area_update_request->ue_radio_capability_information_update_needed); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_eps_bearer_context_status(pkbuf, &tracking_area_update_request->eps_bearer_context_status); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_ms_network_capability(pkbuf, &tracking_area_update_request->ms_network_capability); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_location_area_identification(pkbuf, &tracking_area_update_request->old_location_area_identification); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_PRESENT) + { + tracking_area_update_request->tmsi_status.type = (NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_TYPE >> 4); + + size = nas_encode_tmsi_status(pkbuf, &tracking_area_update_request->tmsi_status); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_mobile_station_classmark_2(pkbuf, &tracking_area_update_request->mobile_station_classmark_2); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_mobile_station_classmark_3(pkbuf, &tracking_area_update_request->mobile_station_classmark_3); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_supported_codec_list(pkbuf, &tracking_area_update_request->supported_codecs); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT) + { + tracking_area_update_request->additional_update_type.type = (NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE >> 4); + + size = nas_encode_additional_update_type(pkbuf, &tracking_area_update_request->additional_update_type); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_voice_domain_preference_and_ue_usage_setting(pkbuf, &tracking_area_update_request->voice_domain_preference_and_ue_usage_setting); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_PRESENT) + { + tracking_area_update_request->old_guti_type.type = (NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_TYPE >> 4); + + size = nas_encode_guti_type(pkbuf, &tracking_area_update_request->old_guti_type); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_PRESENT) + { + tracking_area_update_request->device_properties.type = (NAS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_TYPE >> 4); + + size = nas_encode_device_properties(pkbuf, &tracking_area_update_request->device_properties); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT) + { + tracking_area_update_request->ms_network_feature_support.type = (NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE >> 4); + + size = nas_encode_ms_network_feature_support(pkbuf, &tracking_area_update_request->ms_network_feature_support); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_network_resource_identifier_container(pkbuf, &tracking_area_update_request->tmsi_based_nri_container); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_gprs_timer_2(pkbuf, &tracking_area_update_request->t3324_value); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_gprs_timer_3(pkbuf, &tracking_area_update_request->t3412_extended_value); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_request->presencemask & NAS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_extended_drx_parameters(pkbuf, &tracking_area_update_request->extended_drx_parameters); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + return encoded; +} + +c_int32_t nas_encode_tracking_area_update_accept(pkbuf_t *pkbuf, nas_message_t *message) +{ + nas_tracking_area_update_accept_t *tracking_area_update_accept = &message->emm.tracking_area_update_accept; + c_int32_t encoded = 0; + c_int32_t size = 0; + + size = nas_encode_eps_update_result(pkbuf, &tracking_area_update_accept->eps_update_result); + d_assert(size >= 0, return -1, "encode failed"); + encoded += size; + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_gprs_timer(pkbuf, &tracking_area_update_accept->t3412_value); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_eps_mobile_identity(pkbuf, &tracking_area_update_accept->guti); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_tracking_area_identity_list(pkbuf, &tracking_area_update_accept->tai_list); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_eps_bearer_context_status(pkbuf, &tracking_area_update_accept->eps_bearer_context_status); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_location_area_identification(pkbuf, &tracking_area_update_accept->location_area_identification); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_mobile_identity(pkbuf, &tracking_area_update_accept->ms_identity); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_emm_cause(pkbuf, &tracking_area_update_accept->emm_cause); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_gprs_timer(pkbuf, &tracking_area_update_accept->t3402_value); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_gprs_timer(pkbuf, &tracking_area_update_accept->t3423_value); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_plmn_list(pkbuf, &tracking_area_update_accept->equivalent_plmns); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_emergency_number_list(pkbuf, &tracking_area_update_accept->emergency_number_list); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_eps_network_feature_support(pkbuf, &tracking_area_update_accept->eps_network_feature_support); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT) + { + tracking_area_update_accept->additional_update_result.type = (NAS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE >> 4); + + size = nas_encode_additional_update_result(pkbuf, &tracking_area_update_accept->additional_update_result); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_gprs_timer_3(pkbuf, &tracking_area_update_accept->t3412_extended_value); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_gprs_timer_2(pkbuf, &tracking_area_update_accept->t3324_value); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_extended_drx_parameters(pkbuf, &tracking_area_update_accept->extended_drx_parameters); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_accept->presencemask & NAS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_header_compression_configuration_status(pkbuf, &tracking_area_update_accept->header_compression_configuration_status); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + return encoded; +} + +c_int32_t nas_encode_tracking_area_update_reject(pkbuf_t *pkbuf, nas_message_t *message) +{ + nas_tracking_area_update_reject_t *tracking_area_update_reject = &message->emm.tracking_area_update_reject; + c_int32_t encoded = 0; + c_int32_t size = 0; + + size = nas_encode_emm_cause(pkbuf, &tracking_area_update_reject->emm_cause); + d_assert(size >= 0, return -1, "encode failed"); + encoded += size; + + if (tracking_area_update_reject->presencemask & NAS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_gprs_timer_2(pkbuf, &tracking_area_update_reject->t3346_value); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (tracking_area_update_reject->presencemask & NAS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_PRESENT) + { + tracking_area_update_reject->extended_emm_cause.type = (NAS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_TYPE >> 4); + + size = nas_encode_extended_emm_cause(pkbuf, &tracking_area_update_reject->extended_emm_cause); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + return encoded; +} + +c_int32_t nas_encode_extended_service_request(pkbuf_t *pkbuf, nas_message_t *message) +{ + nas_extended_service_request_t *extended_service_request = &message->emm.extended_service_request; + c_int32_t encoded = 0; + c_int32_t size = 0; + + size = nas_encode_service_type(pkbuf, &extended_service_request->service_type); + d_assert(size >= 0, return -1, "encode failed"); + encoded += size; + + size = nas_encode_mobile_identity(pkbuf, &extended_service_request->m_tmsi); + d_assert(size >= 0, return -1, "encode failed"); + encoded += size; + + if (extended_service_request->presencemask & NAS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_PRESENT) + { + extended_service_request->csfb_response.type = (NAS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_TYPE >> 4); + + size = nas_encode_csfb_response(pkbuf, &extended_service_request->csfb_response); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (extended_service_request->presencemask & NAS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_eps_bearer_context_status(pkbuf, &extended_service_request->eps_bearer_context_status); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + if (extended_service_request->presencemask & NAS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_PRESENT) + { + extended_service_request->device_properties.type = (NAS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_TYPE >> 4); + + size = nas_encode_device_properties(pkbuf, &extended_service_request->device_properties); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + return encoded; +} + +c_int32_t nas_encode_service_reject(pkbuf_t *pkbuf, nas_message_t *message) +{ + nas_service_reject_t *service_reject = &message->emm.service_reject; + c_int32_t encoded = 0; + c_int32_t size = 0; + + size = nas_encode_emm_cause(pkbuf, &service_reject->emm_cause); + d_assert(size >= 0, return -1, "encode failed"); + encoded += size; + + if (service_reject->presencemask & NAS_SERVICE_REJECT_T3346_VALUE_PRESENT) + { + size = nas_encode_optional_type(pkbuf, NAS_SERVICE_REJECT_T3346_VALUE_TYPE); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + + size = nas_encode_gprs_timer_2(pkbuf, &service_reject->t3346_value); + d_assert(size >= 0, return encoded, "decode failed"); + encoded += size; + } + + return encoded; +} + c_int32_t nas_encode_authentication_request(pkbuf_t *pkbuf, nas_message_t *message) { nas_authentication_request_t *authentication_request = &message->emm.authentication_request; @@ -1291,6 +1909,42 @@ status_t nas_emm_encode(pkbuf_t **pkbuf, nas_message_t *message) d_assert(size >= 0, return CORE_ERROR, "decode error"); encoded += size; break; + case NAS_DETACH_REQUEST_TO_UE: + size = nas_encode_detach_request_to_ue(*pkbuf, message); + d_assert(size >= 0, return CORE_ERROR, "decode error"); + encoded += size; + break; + case NAS_DETACH_ACCEPT: + break; + case NAS_TRACKING_AREA_UPDATE_REQUEST: + size = nas_encode_tracking_area_update_request(*pkbuf, message); + d_assert(size >= 0, return CORE_ERROR, "decode error"); + encoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_ACCEPT: + size = nas_encode_tracking_area_update_accept(*pkbuf, message); + d_assert(size >= 0, return CORE_ERROR, "decode error"); + encoded += size; + break; + case NAS_TRACKING_AREA_UPDATE_COMPLETE: + break; + case NAS_TRACKING_AREA_UPDATE_REJECT: + size = nas_encode_tracking_area_update_reject(*pkbuf, message); + d_assert(size >= 0, return CORE_ERROR, "decode error"); + encoded += size; + break; + case NAS_EXTENDED_SERVICE_REQUEST: + size = nas_encode_extended_service_request(*pkbuf, message); + d_assert(size >= 0, return CORE_ERROR, "decode error"); + encoded += size; + break; + case NAS_SERVICE_REQUEST: + break; + case NAS_SERVICE_REJECT: + size = nas_encode_service_reject(*pkbuf, message); + d_assert(size >= 0, return CORE_ERROR, "decode error"); + encoded += size; + break; case NAS_AUTHENTICATION_REQUEST: size = nas_encode_authentication_request(*pkbuf, message); d_assert(size >= 0, return CORE_ERROR, "decode error"); diff --git a/lib/nas/nas_ies.c b/lib/nas/nas_ies.c index 194a7d444..271cc6685 100644 --- a/lib/nas/nas_ies.c +++ b/lib/nas/nas_ies.c @@ -26,7 +26,7 @@ /******************************************************************************* * This file had been created by gtpv2c_tlv.py script v0.1.0 * Please do not modify this file but regenerate it via script. - * Created on: 2017-04-14 18:08:22.099481 by acetcom + * Created on: 2017-04-25 20:02:55.587587 by acetcom * from 24301-d80.docx ******************************************************************************/ @@ -64,6 +64,34 @@ c_int16_t nas_encode_device_properties(pkbuf_t *pkbuf, nas_device_properties_t * return size; } +/* 9.9.2.1 EPS bearer context status + * O TLV 4 */ +c_int16_t nas_decode_eps_bearer_context_status(nas_eps_bearer_context_status_t *eps_bearer_context_status, pkbuf_t *pkbuf) +{ + c_uint16_t size = 0; + nas_eps_bearer_context_status_t *source = pkbuf->payload; + + eps_bearer_context_status->length = source->length; + size = eps_bearer_context_status->length + sizeof(eps_bearer_context_status->length); + + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(eps_bearer_context_status, pkbuf->payload - size, size); + + return size; +} + +c_int16_t nas_encode_eps_bearer_context_status(pkbuf_t *pkbuf, nas_eps_bearer_context_status_t *eps_bearer_context_status) +{ + c_uint16_t size = eps_bearer_context_status->length + sizeof(eps_bearer_context_status->length); + nas_eps_bearer_context_status_t target; + + memcpy(&target, eps_bearer_context_status, sizeof(nas_eps_bearer_context_status_t)); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(pkbuf->payload - size, &target, size); + + return size; +} + /* 9.9.2.10 Supported Codec List * O TLV 5-n */ c_int16_t nas_decode_supported_codec_list(nas_supported_codec_list_t *supported_codec_list, pkbuf_t *pkbuf) @@ -430,6 +458,54 @@ c_int16_t nas_encode_eps_network_feature_support(pkbuf_t *pkbuf, nas_eps_network return size; } +/* 9.9.3.13 EPS update result + * M V 1/2 */ +c_int16_t nas_decode_eps_update_result(nas_eps_update_result_t *eps_update_result, pkbuf_t *pkbuf) +{ + c_uint16_t size = sizeof(nas_eps_update_result_t); + + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(eps_update_result, pkbuf->payload - size, size); + + return size; +} + +c_int16_t nas_encode_eps_update_result(pkbuf_t *pkbuf, nas_eps_update_result_t *eps_update_result) +{ + c_uint16_t size = sizeof(nas_eps_update_result_t); + nas_eps_update_result_t target; + + memcpy(&target, eps_update_result, size); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(pkbuf->payload - size, &target, size); + + return size; +} + +/* 9.9.3.14 EPS update type + * M V 1/2 */ +c_int16_t nas_decode_eps_update_type(nas_eps_update_type_t *eps_update_type, pkbuf_t *pkbuf) +{ + c_uint16_t size = sizeof(nas_eps_update_type_t); + + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(eps_update_type, pkbuf->payload - size, size); + + return size; +} + +c_int16_t nas_encode_eps_update_type(pkbuf_t *pkbuf, nas_eps_update_type_t *eps_update_type) +{ + c_uint16_t size = sizeof(nas_eps_update_type_t); + nas_eps_update_type_t target; + + memcpy(&target, eps_update_type, size); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(pkbuf->payload - size, &target, size); + + return size; +} + /* 9.9.3.15 ESM message container * M LV-E 5-n */ c_int16_t nas_decode_esm_message_container(nas_esm_message_container_t *esm_message_container, pkbuf_t *pkbuf) @@ -665,25 +741,20 @@ c_int16_t nas_encode_ms_network_feature_support(pkbuf_t *pkbuf, nas_ms_network_f } /* 9.9.3.21 key set identifier - * M V 1/2 */ + * O TV 1 */ c_int16_t nas_decode_key_set_identifier(nas_key_set_identifier_t *key_set_identifier, pkbuf_t *pkbuf) { - c_uint16_t size = sizeof(nas_key_set_identifier_t); + memcpy(key_set_identifier, pkbuf->payload - 1, 1); - d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); - memcpy(key_set_identifier, pkbuf->payload - size, size); - - return size; + return 0; } c_int16_t nas_encode_key_set_identifier(pkbuf_t *pkbuf, nas_key_set_identifier_t *key_set_identifier) { c_uint16_t size = sizeof(nas_key_set_identifier_t); - nas_key_set_identifier_t target; - memcpy(&target, key_set_identifier, size); d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); - memcpy(pkbuf->payload - size, &target, size); + memcpy(pkbuf->payload - size, key_set_identifier, size); return size; } @@ -843,6 +914,30 @@ c_int16_t nas_encode_extended_emm_cause(pkbuf_t *pkbuf, nas_extended_emm_cause_t return size; } +/* 9.9.3.27 Service type + * M V 1/2 */ +c_int16_t nas_decode_service_type(nas_service_type_t *service_type, pkbuf_t *pkbuf) +{ + c_uint16_t size = sizeof(nas_service_type_t); + + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(service_type, pkbuf->payload - size, size); + + return size; +} + +c_int16_t nas_encode_service_type(pkbuf_t *pkbuf, nas_service_type_t *service_type) +{ + c_uint16_t size = sizeof(nas_service_type_t); + nas_service_type_t target; + + memcpy(&target, service_type, size); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(pkbuf->payload - size, &target, size); + + return size; +} + /* 9.9.3.29 Time zone * O TV 2 */ c_int16_t nas_decode_time_zone(nas_time_zone_t *time_zone, pkbuf_t *pkbuf) @@ -1046,6 +1141,25 @@ c_int16_t nas_encode_ue_network_capability(pkbuf_t *pkbuf, nas_ue_network_capabi return size; } +/* 9.9.3.35 UE radio capability information update needed + * O TV 1 */ +c_int16_t nas_decode_ue_radio_capability_information_update_needed(nas_ue_radio_capability_information_update_needed_t *ue_radio_capability_information_update_needed, pkbuf_t *pkbuf) +{ + memcpy(ue_radio_capability_information_update_needed, pkbuf->payload - 1, 1); + + return 0; +} + +c_int16_t nas_encode_ue_radio_capability_information_update_needed(pkbuf_t *pkbuf, nas_ue_radio_capability_information_update_needed_t *ue_radio_capability_information_update_needed) +{ + c_uint16_t size = sizeof(nas_ue_radio_capability_information_update_needed_t); + + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(pkbuf->payload - size, ue_radio_capability_information_update_needed, size); + + return size; +} + /* 9.9.3.36 UE security capability * M LV 3-6 */ c_int16_t nas_decode_ue_security_capability(nas_ue_security_capability_t *ue_security_capability, pkbuf_t *pkbuf) @@ -1205,6 +1319,44 @@ c_int16_t nas_encode_extended_drx_parameters(pkbuf_t *pkbuf, nas_extended_drx_pa return size; } +/* 9.9.3.4a Ciphering key sequence number + * O TV 1 */ +c_int16_t nas_decode_ciphering_key_sequence_number(nas_ciphering_key_sequence_number_t *ciphering_key_sequence_number, pkbuf_t *pkbuf) +{ + memcpy(ciphering_key_sequence_number, pkbuf->payload - 1, 1); + + return 0; +} + +c_int16_t nas_encode_ciphering_key_sequence_number(pkbuf_t *pkbuf, nas_ciphering_key_sequence_number_t *ciphering_key_sequence_number) +{ + c_uint16_t size = sizeof(nas_ciphering_key_sequence_number_t); + + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(pkbuf->payload - size, ciphering_key_sequence_number, size); + + return size; +} + +/* 9.9.3.5 CSFB response + * O TV 1 */ +c_int16_t nas_decode_csfb_response(nas_csfb_response_t *csfb_response, pkbuf_t *pkbuf) +{ + memcpy(csfb_response, pkbuf->payload - 1, 1); + + return 0; +} + +c_int16_t nas_encode_csfb_response(pkbuf_t *pkbuf, nas_csfb_response_t *csfb_response) +{ + c_uint16_t size = sizeof(nas_csfb_response_t); + + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(pkbuf->payload - size, csfb_response, size); + + return size; +} + /* 9.9.3.6 Daylight saving time * O TLV 3 */ c_int16_t nas_decode_daylight_saving_time(nas_daylight_saving_time_t *daylight_saving_time, pkbuf_t *pkbuf) @@ -1233,6 +1385,30 @@ c_int16_t nas_encode_daylight_saving_time(pkbuf_t *pkbuf, nas_daylight_saving_ti return size; } +/* 9.9.3.7 Detach type + * M V 1/2 */ +c_int16_t nas_decode_detach_type(nas_detach_type_t *detach_type, pkbuf_t *pkbuf) +{ + c_uint16_t size = sizeof(nas_detach_type_t); + + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(detach_type, pkbuf->payload - size, size); + + return size; +} + +c_int16_t nas_encode_detach_type(pkbuf_t *pkbuf, nas_detach_type_t *detach_type) +{ + c_uint16_t size = sizeof(nas_detach_type_t); + nas_detach_type_t target; + + memcpy(&target, detach_type, size); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(pkbuf->payload - size, &target, size); + + return size; +} + /* 9.9.3.8 DRX parameter * O TV 3 */ c_int16_t nas_decode_drx_parameter(nas_drx_parameter_t *drx_parameter, pkbuf_t *pkbuf) @@ -1626,6 +1802,34 @@ c_int16_t nas_encode_extended_protocol_configuration_options(pkbuf_t *pkbuf, nas return extended_protocol_configuration_options->len + sizeof(extended_protocol_configuration_options->len); } +/* 9.9.4.27 Header compression configuration status + * O TLV 4 */ +c_int16_t nas_decode_header_compression_configuration_status(nas_header_compression_configuration_status_t *header_compression_configuration_status, pkbuf_t *pkbuf) +{ + c_uint16_t size = 0; + nas_header_compression_configuration_status_t *source = pkbuf->payload; + + header_compression_configuration_status->length = source->length; + size = header_compression_configuration_status->length + sizeof(header_compression_configuration_status->length); + + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(header_compression_configuration_status, pkbuf->payload - size, size); + + return size; +} + +c_int16_t nas_encode_header_compression_configuration_status(pkbuf_t *pkbuf, nas_header_compression_configuration_status_t *header_compression_configuration_status) +{ + c_uint16_t size = header_compression_configuration_status->length + sizeof(header_compression_configuration_status->length); + nas_header_compression_configuration_status_t target; + + memcpy(&target, header_compression_configuration_status, sizeof(nas_header_compression_configuration_status_t)); + d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error"); + memcpy(pkbuf->payload - size, &target, size); + + return size; +} + /* 9.9.4.28 Serving PLMN rate control * O TLV 4 */ c_int16_t nas_decode_serving_plmn_rate_control(nas_serving_plmn_rate_control_t *serving_plmn_rate_control, pkbuf_t *pkbuf) diff --git a/lib/nas/nas_ies.h b/lib/nas/nas_ies.h index 6abff1c6f..25fd78e7f 100644 --- a/lib/nas/nas_ies.h +++ b/lib/nas/nas_ies.h @@ -26,7 +26,7 @@ /******************************************************************************* * This file had been created by gtpv2c_tlv.py script v0.1.0 * Please do not modify this file but regenerate it via script. - * Created on: 2017-04-14 18:08:22.095097 by acetcom + * Created on: 2017-04-25 20:02:55.583189 by acetcom * from 24301-d80.docx ******************************************************************************/ @@ -43,6 +43,7 @@ extern "C" { CORE_DECLARE(c_int16_t) nas_encode_optional_type(pkbuf_t *pkbuf, c_uint8_t type); CORE_DECLARE(c_int16_t) nas_decode_device_properties(nas_device_properties_t *device_properties, pkbuf_t *pkbuf); +CORE_DECLARE(c_int16_t) nas_decode_eps_bearer_context_status(nas_eps_bearer_context_status_t *eps_bearer_context_status, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_supported_codec_list(nas_supported_codec_list_t *supported_codec_list, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_location_area_identification(nas_location_area_identification_t *location_area_identification, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_mobile_identity(nas_mobile_identity_t *mobile_identity, pkbuf_t *pkbuf); @@ -56,6 +57,8 @@ CORE_DECLARE(c_int16_t) nas_decode_eps_attach_result(nas_eps_attach_result_t *ep CORE_DECLARE(c_int16_t) nas_decode_eps_attach_type(nas_eps_attach_type_t *eps_attach_type, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_eps_mobile_identity(nas_eps_mobile_identity_t *eps_mobile_identity, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_eps_network_feature_support(nas_eps_network_feature_support_t *eps_network_feature_support, pkbuf_t *pkbuf); +CORE_DECLARE(c_int16_t) nas_decode_eps_update_result(nas_eps_update_result_t *eps_update_result, pkbuf_t *pkbuf); +CORE_DECLARE(c_int16_t) nas_decode_eps_update_type(nas_eps_update_type_t *eps_update_type, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_esm_message_container(nas_esm_message_container_t *esm_message_container, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_gprs_timer(nas_gprs_timer_t *gprs_timer, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_gprs_timer_2(nas_gprs_timer_2_t *gprs_timer_2, pkbuf_t *pkbuf); @@ -72,6 +75,7 @@ CORE_DECLARE(c_int16_t) nas_decode_network_resource_identifier_container(nas_net CORE_DECLARE(c_int16_t) nas_decode_nonce(nas_nonce_t *nonce, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_p_tmsi_signature(nas_p_tmsi_signature_t *p_tmsi_signature, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_extended_emm_cause(nas_extended_emm_cause_t *extended_emm_cause, pkbuf_t *pkbuf); +CORE_DECLARE(c_int16_t) nas_decode_service_type(nas_service_type_t *service_type, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_time_zone(nas_time_zone_t *time_zone, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_authentication_parameter_rand(nas_authentication_parameter_rand_t *authentication_parameter_rand, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_time_zone_and_time(nas_time_zone_and_time_t *time_zone_and_time, pkbuf_t *pkbuf); @@ -79,13 +83,17 @@ CORE_DECLARE(c_int16_t) nas_decode_tmsi_status(nas_tmsi_status_t *tmsi_status, p CORE_DECLARE(c_int16_t) nas_decode_tracking_area_identity(nas_tracking_area_identity_t *tracking_area_identity, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_tracking_area_identity_list(nas_tracking_area_identity_list_t *tracking_area_identity_list, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_ue_network_capability(nas_ue_network_capability_t *ue_network_capability, pkbuf_t *pkbuf); +CORE_DECLARE(c_int16_t) nas_decode_ue_radio_capability_information_update_needed(nas_ue_radio_capability_information_update_needed_t *ue_radio_capability_information_update_needed, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_ue_security_capability(nas_ue_security_capability_t *ue_security_capability, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_emergency_number_list(nas_emergency_number_list_t *emergency_number_list, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_authentication_response_parameter(nas_authentication_response_parameter_t *authentication_response_parameter, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_voice_domain_preference_and_ue_usage_setting(nas_voice_domain_preference_and_ue_usage_setting_t *voice_domain_preference_and_ue_usage_setting, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_guti_type(nas_guti_type_t *guti_type, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_extended_drx_parameters(nas_extended_drx_parameters_t *extended_drx_parameters, pkbuf_t *pkbuf); +CORE_DECLARE(c_int16_t) nas_decode_ciphering_key_sequence_number(nas_ciphering_key_sequence_number_t *ciphering_key_sequence_number, pkbuf_t *pkbuf); +CORE_DECLARE(c_int16_t) nas_decode_csfb_response(nas_csfb_response_t *csfb_response, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_daylight_saving_time(nas_daylight_saving_time_t *daylight_saving_time, pkbuf_t *pkbuf); +CORE_DECLARE(c_int16_t) nas_decode_detach_type(nas_detach_type_t *detach_type, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_drx_parameter(nas_drx_parameter_t *drx_parameter, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_emm_cause(nas_emm_cause_t *emm_cause, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_access_point_name(nas_access_point_name_t *access_point_name, pkbuf_t *pkbuf); @@ -101,6 +109,7 @@ CORE_DECLARE(c_int16_t) nas_decode_apn_aggregate_maximum_bit_rate(nas_apn_aggreg CORE_DECLARE(c_int16_t) nas_decode_header_compression_configuration(nas_header_compression_configuration_t *header_compression_configuration, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_control_plane_only_indication(nas_control_plane_only_indication_t *control_plane_only_indication, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_extended_protocol_configuration_options(nas_extended_protocol_configuration_options_t *extended_protocol_configuration_options, pkbuf_t *pkbuf); +CORE_DECLARE(c_int16_t) nas_decode_header_compression_configuration_status(nas_header_compression_configuration_status_t *header_compression_configuration_status, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_serving_plmn_rate_control(nas_serving_plmn_rate_control_t *serving_plmn_rate_control, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_connectivity_type(nas_connectivity_type_t *connectivity_type, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_decode_eps_quality_of_service(nas_eps_quality_of_service_t *eps_quality_of_service, pkbuf_t *pkbuf); @@ -112,6 +121,7 @@ CORE_DECLARE(c_int16_t) nas_decode_packet_flow_identifier(nas_packet_flow_identi CORE_DECLARE(c_int16_t) nas_decode_pdn_address(nas_pdn_address_t *pdn_address, pkbuf_t *pkbuf); CORE_DECLARE(c_int16_t) nas_encode_device_properties(pkbuf_t *pkbuf, nas_device_properties_t *device_properties); +CORE_DECLARE(c_int16_t) nas_encode_eps_bearer_context_status(pkbuf_t *pkbuf, nas_eps_bearer_context_status_t *eps_bearer_context_status); CORE_DECLARE(c_int16_t) nas_encode_supported_codec_list(pkbuf_t *pkbuf, nas_supported_codec_list_t *supported_codec_list); CORE_DECLARE(c_int16_t) nas_encode_location_area_identification(pkbuf_t *pkbuf, nas_location_area_identification_t *location_area_identification); CORE_DECLARE(c_int16_t) nas_encode_mobile_identity(pkbuf_t *pkbuf, nas_mobile_identity_t *mobile_identity); @@ -125,6 +135,8 @@ CORE_DECLARE(c_int16_t) nas_encode_eps_attach_result(pkbuf_t *pkbuf, nas_eps_att CORE_DECLARE(c_int16_t) nas_encode_eps_attach_type(pkbuf_t *pkbuf, nas_eps_attach_type_t *eps_attach_type); CORE_DECLARE(c_int16_t) nas_encode_eps_mobile_identity(pkbuf_t *pkbuf, nas_eps_mobile_identity_t *eps_mobile_identity); CORE_DECLARE(c_int16_t) nas_encode_eps_network_feature_support(pkbuf_t *pkbuf, nas_eps_network_feature_support_t *eps_network_feature_support); +CORE_DECLARE(c_int16_t) nas_encode_eps_update_result(pkbuf_t *pkbuf, nas_eps_update_result_t *eps_update_result); +CORE_DECLARE(c_int16_t) nas_encode_eps_update_type(pkbuf_t *pkbuf, nas_eps_update_type_t *eps_update_type); CORE_DECLARE(c_int16_t) nas_encode_esm_message_container(pkbuf_t *pkbuf, nas_esm_message_container_t *esm_message_container); CORE_DECLARE(c_int16_t) nas_encode_gprs_timer(pkbuf_t *pkbuf, nas_gprs_timer_t *gprs_timer); CORE_DECLARE(c_int16_t) nas_encode_gprs_timer_2(pkbuf_t *pkbuf, nas_gprs_timer_2_t *gprs_timer_2); @@ -141,6 +153,7 @@ CORE_DECLARE(c_int16_t) nas_encode_network_resource_identifier_container(pkbuf_t CORE_DECLARE(c_int16_t) nas_encode_nonce(pkbuf_t *pkbuf, nas_nonce_t *nonce); CORE_DECLARE(c_int16_t) nas_encode_p_tmsi_signature(pkbuf_t *pkbuf, nas_p_tmsi_signature_t *p_tmsi_signature); CORE_DECLARE(c_int16_t) nas_encode_extended_emm_cause(pkbuf_t *pkbuf, nas_extended_emm_cause_t *extended_emm_cause); +CORE_DECLARE(c_int16_t) nas_encode_service_type(pkbuf_t *pkbuf, nas_service_type_t *service_type); CORE_DECLARE(c_int16_t) nas_encode_time_zone(pkbuf_t *pkbuf, nas_time_zone_t *time_zone); CORE_DECLARE(c_int16_t) nas_encode_authentication_parameter_rand(pkbuf_t *pkbuf, nas_authentication_parameter_rand_t *authentication_parameter_rand); CORE_DECLARE(c_int16_t) nas_encode_time_zone_and_time(pkbuf_t *pkbuf, nas_time_zone_and_time_t *time_zone_and_time); @@ -148,13 +161,17 @@ CORE_DECLARE(c_int16_t) nas_encode_tmsi_status(pkbuf_t *pkbuf, nas_tmsi_status_t CORE_DECLARE(c_int16_t) nas_encode_tracking_area_identity(pkbuf_t *pkbuf, nas_tracking_area_identity_t *tracking_area_identity); CORE_DECLARE(c_int16_t) nas_encode_tracking_area_identity_list(pkbuf_t *pkbuf, nas_tracking_area_identity_list_t *tracking_area_identity_list); CORE_DECLARE(c_int16_t) nas_encode_ue_network_capability(pkbuf_t *pkbuf, nas_ue_network_capability_t *ue_network_capability); +CORE_DECLARE(c_int16_t) nas_encode_ue_radio_capability_information_update_needed(pkbuf_t *pkbuf, nas_ue_radio_capability_information_update_needed_t *ue_radio_capability_information_update_needed); CORE_DECLARE(c_int16_t) nas_encode_ue_security_capability(pkbuf_t *pkbuf, nas_ue_security_capability_t *ue_security_capability); CORE_DECLARE(c_int16_t) nas_encode_emergency_number_list(pkbuf_t *pkbuf, nas_emergency_number_list_t *emergency_number_list); CORE_DECLARE(c_int16_t) nas_encode_authentication_response_parameter(pkbuf_t *pkbuf, nas_authentication_response_parameter_t *authentication_response_parameter); CORE_DECLARE(c_int16_t) nas_encode_voice_domain_preference_and_ue_usage_setting(pkbuf_t *pkbuf, nas_voice_domain_preference_and_ue_usage_setting_t *voice_domain_preference_and_ue_usage_setting); CORE_DECLARE(c_int16_t) nas_encode_guti_type(pkbuf_t *pkbuf, nas_guti_type_t *guti_type); CORE_DECLARE(c_int16_t) nas_encode_extended_drx_parameters(pkbuf_t *pkbuf, nas_extended_drx_parameters_t *extended_drx_parameters); +CORE_DECLARE(c_int16_t) nas_encode_ciphering_key_sequence_number(pkbuf_t *pkbuf, nas_ciphering_key_sequence_number_t *ciphering_key_sequence_number); +CORE_DECLARE(c_int16_t) nas_encode_csfb_response(pkbuf_t *pkbuf, nas_csfb_response_t *csfb_response); CORE_DECLARE(c_int16_t) nas_encode_daylight_saving_time(pkbuf_t *pkbuf, nas_daylight_saving_time_t *daylight_saving_time); +CORE_DECLARE(c_int16_t) nas_encode_detach_type(pkbuf_t *pkbuf, nas_detach_type_t *detach_type); CORE_DECLARE(c_int16_t) nas_encode_drx_parameter(pkbuf_t *pkbuf, nas_drx_parameter_t *drx_parameter); CORE_DECLARE(c_int16_t) nas_encode_emm_cause(pkbuf_t *pkbuf, nas_emm_cause_t *emm_cause); CORE_DECLARE(c_int16_t) nas_encode_access_point_name(pkbuf_t *pkbuf, nas_access_point_name_t *access_point_name); @@ -170,6 +187,7 @@ CORE_DECLARE(c_int16_t) nas_encode_apn_aggregate_maximum_bit_rate(pkbuf_t *pkbuf CORE_DECLARE(c_int16_t) nas_encode_header_compression_configuration(pkbuf_t *pkbuf, nas_header_compression_configuration_t *header_compression_configuration); CORE_DECLARE(c_int16_t) nas_encode_control_plane_only_indication(pkbuf_t *pkbuf, nas_control_plane_only_indication_t *control_plane_only_indication); CORE_DECLARE(c_int16_t) nas_encode_extended_protocol_configuration_options(pkbuf_t *pkbuf, nas_extended_protocol_configuration_options_t *extended_protocol_configuration_options); +CORE_DECLARE(c_int16_t) nas_encode_header_compression_configuration_status(pkbuf_t *pkbuf, nas_header_compression_configuration_status_t *header_compression_configuration_status); CORE_DECLARE(c_int16_t) nas_encode_serving_plmn_rate_control(pkbuf_t *pkbuf, nas_serving_plmn_rate_control_t *serving_plmn_rate_control); CORE_DECLARE(c_int16_t) nas_encode_connectivity_type(pkbuf_t *pkbuf, nas_connectivity_type_t *connectivity_type); CORE_DECLARE(c_int16_t) nas_encode_eps_quality_of_service(pkbuf_t *pkbuf, nas_eps_quality_of_service_t *eps_quality_of_service); diff --git a/lib/nas/nas_message.h b/lib/nas/nas_message.h index 016f1f4ee..60bf6e514 100644 --- a/lib/nas/nas_message.h +++ b/lib/nas/nas_message.h @@ -26,7 +26,7 @@ /******************************************************************************* * This file had been created by gtpv2c_tlv.py script v0.1.0 * Please do not modify this file but regenerate it via script. - * Created on: 2017-04-14 18:08:22.114973 by acetcom + * Created on: 2017-04-25 20:02:55.600467 by acetcom * from 24301-d80.docx ******************************************************************************/ @@ -81,13 +81,15 @@ ED2(c_uint8_t security_header_type:4;, #define NAS_ATTACH_ACCEPT 66 #define NAS_ATTACH_COMPLETE 67 #define NAS_ATTACH_REJECT 68 -#define NAS_DETACH_REQUEST 69 +#define NAS_DETACH_REQUEST_FROM_UE 69 +#define NAS_DETACH_REQUEST_TO_UE 69 #define NAS_DETACH_ACCEPT 70 #define NAS_TRACKING_AREA_UPDATE_REQUEST 72 #define NAS_TRACKING_AREA_UPDATE_ACCEPT 73 #define NAS_TRACKING_AREA_UPDATE_COMPLETE 74 #define NAS_TRACKING_AREA_UPDATE_REJECT 75 #define NAS_EXTENDED_SERVICE_REQUEST 76 +#define NAS_SERVICE_REQUEST 77 #define NAS_SERVICE_REJECT 78 #define NAS_GUTI_REALLOCATION_COMMAND 80 #define NAS_GUTI_REALLOCATION_COMPLETE 81 @@ -294,6 +296,245 @@ typedef struct _nas_attach_reject_t { } nas_attach_reject_t; +/******************************************************* + * DETACH REQUEST FROM UE + ******************************************************/ + +typedef struct _nas_detach_request_from_ue_t { + /* Mandatory fields */ + nas_detach_type_t detach_type; + nas_eps_mobile_identity_t eps_mobile_identity; +} nas_detach_request_from_ue_t; + + +/******************************************************* + * DETACH REQUEST TO UE + ******************************************************/ +#define NAS_DETACH_REQUEST_TO_UE_EMM_CAUSE_PRESENT (1<<0) +#define NAS_DETACH_REQUEST_TO_UE_EMM_CAUSE_TYPE 0x53 + +typedef struct _nas_detach_request_to_ue_t { + /* Mandatory fields */ + nas_detach_type_t detach_type; + + /* Optional fields */ + c_uint32_t presencemask; + nas_emm_cause_t emm_cause; +} nas_detach_request_to_ue_t; + + +/******************************************************* + * TRACKING AREA UPDATE REQUEST + ******************************************************/ +#define NAS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_PRESENT (1<<0) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_PRESENT (1<<1) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT (1<<2) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_PRESENT (1<<3) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_PRESENT (1<<4) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_PRESENT (1<<5) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT (1<<6) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_PRESENT (1<<7) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_PRESENT (1<<8) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT (1<<9) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_PRESENT (1<<10) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT (1<<11) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_PRESENT (1<<12) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT (1<<13) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT (1<<14) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_PRESENT (1<<15) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT (1<<16) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT (1<<17) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_PRESENT (1<<18) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_PRESENT (1<<19) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT (1<<20) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT (1<<21) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_PRESENT (1<<22) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_PRESENT (1<<23) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT (1<<24) +#define NAS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_TYPE 0xB0 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_TYPE 0x80 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE 0x19 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_TYPE 0x50 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_TYPE 0x55 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_TYPE 0x58 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE 0x52 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_TYPE 0x5C +#define NAS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_TYPE 0xA0 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE 0x57 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_TYPE 0x31 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE 0x13 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_TYPE 0x90 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE 0x11 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE 0x20 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_TYPE 0x40 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE 0xF0 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE 0x5D +#define NAS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_TYPE 0xE0 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_TYPE 0xD0 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE 0xC0 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE 0x10 +#define NAS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_TYPE 0x6A +#define NAS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_TYPE 0x5E +#define NAS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE 0x6E + +typedef struct _nas_tracking_area_update_request_t { + /* Mandatory fields */ + nas_eps_update_type_t eps_update_type; + nas_eps_mobile_identity_t old_guti; + + /* Optional fields */ + c_uint32_t presencemask; + nas_key_set_identifier_t non_current_native_nas_key_set_identifier; + nas_ciphering_key_sequence_number_t gprs_ciphering_key_sequence_number; + nas_p_tmsi_signature_t old_p_tmsi_signature; + nas_eps_mobile_identity_t additional_guti; + nas_nonce_t nonceue; + nas_ue_network_capability_t ue_network_capability; + nas_tracking_area_identity_t last_visited_registered_tai; + nas_drx_parameter_t drx_parameter; + nas_ue_radio_capability_information_update_needed_t ue_radio_capability_information_update_needed; + nas_eps_bearer_context_status_t eps_bearer_context_status; + nas_ms_network_capability_t ms_network_capability; + nas_location_area_identification_t old_location_area_identification; + nas_tmsi_status_t tmsi_status; + nas_mobile_station_classmark_2_t mobile_station_classmark_2; + nas_mobile_station_classmark_3_t mobile_station_classmark_3; + nas_supported_codec_list_t supported_codecs; + nas_additional_update_type_t additional_update_type; + nas_voice_domain_preference_and_ue_usage_setting_t voice_domain_preference_and_ue_usage_setting; + nas_guti_type_t old_guti_type; + nas_device_properties_t device_properties; + nas_ms_network_feature_support_t ms_network_feature_support; + nas_network_resource_identifier_container_t tmsi_based_nri_container; + nas_gprs_timer_2_t t3324_value; + nas_gprs_timer_3_t t3412_extended_value; + nas_extended_drx_parameters_t extended_drx_parameters; +} nas_tracking_area_update_request_t; + + +/******************************************************* + * TRACKING AREA UPDATE ACCEPT + ******************************************************/ +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_PRESENT (1<<0) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_PRESENT (1<<1) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_PRESENT (1<<2) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_PRESENT (1<<3) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT (1<<4) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_PRESENT (1<<5) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_PRESENT (1<<6) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_PRESENT (1<<7) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_PRESENT (1<<8) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_PRESENT (1<<9) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT (1<<10) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT (1<<11) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT (1<<12) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_PRESENT (1<<13) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_PRESENT (1<<14) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT (1<<15) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_PRESENT (1<<16) +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_TYPE 0x5A +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_TYPE 0x50 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_TYPE 0x54 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_TYPE 0x57 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE 0x13 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_TYPE 0x23 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_TYPE 0x53 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_TYPE 0x17 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_TYPE 0x59 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_TYPE 0x4A +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE 0x34 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE 0x64 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE 0xF0 +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_TYPE 0x5E +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_TYPE 0x6A +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE 0x6E +#define NAS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_TYPE 0x68 + +typedef struct _nas_tracking_area_update_accept_t { + /* Mandatory fields */ + nas_eps_update_result_t eps_update_result; + + /* Optional fields */ + c_uint32_t presencemask; + nas_gprs_timer_t t3412_value; + nas_eps_mobile_identity_t guti; + nas_tracking_area_identity_list_t tai_list; + nas_eps_bearer_context_status_t eps_bearer_context_status; + nas_location_area_identification_t location_area_identification; + nas_mobile_identity_t ms_identity; + nas_emm_cause_t emm_cause; + nas_gprs_timer_t t3402_value; + nas_gprs_timer_t t3423_value; + nas_plmn_list_t equivalent_plmns; + nas_emergency_number_list_t emergency_number_list; + nas_eps_network_feature_support_t eps_network_feature_support; + nas_additional_update_result_t additional_update_result; + nas_gprs_timer_3_t t3412_extended_value; + nas_gprs_timer_2_t t3324_value; + nas_extended_drx_parameters_t extended_drx_parameters; + nas_header_compression_configuration_status_t header_compression_configuration_status; +} nas_tracking_area_update_accept_t; + + +/******************************************************* + * TRACKING AREA UPDATE REJECT + ******************************************************/ +#define NAS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_PRESENT (1<<0) +#define NAS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_PRESENT (1<<1) +#define NAS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_TYPE 0x5F +#define NAS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_TYPE 0xA0 + +typedef struct _nas_tracking_area_update_reject_t { + /* Mandatory fields */ + nas_emm_cause_t emm_cause; + + /* Optional fields */ + c_uint32_t presencemask; + nas_gprs_timer_2_t t3346_value; + nas_extended_emm_cause_t extended_emm_cause; +} nas_tracking_area_update_reject_t; + + +/******************************************************* + * EXTENDED SERVICE REQUEST + ******************************************************/ +#define NAS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_PRESENT (1<<0) +#define NAS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT (1<<1) +#define NAS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_PRESENT (1<<2) +#define NAS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_TYPE 0xB0 +#define NAS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE 0x57 +#define NAS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_TYPE 0xD0 + +typedef struct _nas_extended_service_request_t { + /* Mandatory fields */ + nas_service_type_t service_type; + nas_mobile_identity_t m_tmsi; + + /* Optional fields */ + c_uint32_t presencemask; + nas_csfb_response_t csfb_response; + nas_eps_bearer_context_status_t eps_bearer_context_status; + nas_device_properties_t device_properties; +} nas_extended_service_request_t; + + +/******************************************************* + * SERVICE REJECT + ******************************************************/ +#define NAS_SERVICE_REJECT_T3346_VALUE_PRESENT (1<<0) +#define NAS_SERVICE_REJECT_T3346_VALUE_TYPE 0x5F + +typedef struct _nas_service_reject_t { + /* Mandatory fields */ + nas_emm_cause_t emm_cause; + nas_gprs_timer_t t3442_value; + + /* Optional fields */ + c_uint32_t presencemask; + nas_gprs_timer_2_t t3346_value; +} nas_service_reject_t; + + /******************************************************* * AUTHENTICATION REQUEST ******************************************************/ @@ -659,6 +900,13 @@ typedef struct _nas_emm_message_t { nas_attach_accept_t attach_accept; nas_attach_complete_t attach_complete; nas_attach_reject_t attach_reject; + nas_detach_request_from_ue_t detach_request_from_ue; + nas_detach_request_to_ue_t detach_request_to_ue; + nas_tracking_area_update_request_t tracking_area_update_request; + nas_tracking_area_update_accept_t tracking_area_update_accept; + nas_tracking_area_update_reject_t tracking_area_update_reject; + nas_extended_service_request_t extended_service_request; + nas_service_reject_t service_reject; nas_authentication_request_t authentication_request; nas_authentication_response_t authentication_response; nas_identity_request_t identity_request;