acouzens
/
open5gs
1
0
Fork 1
Code Issues Pull Requests 1 Projects Releases Wiki Activity

update generated files

This commit is contained in:
Sukchan Lee 2017-04-25 20:08:03 +09:00
parent 0aa5660479
commit 4694a0b75f
5 changed files with 1680 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

543
lib/nas/nas_decoder.c
View File

@ -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");

656
lib/nas/nas_encoder.c
View File

@ -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");

224
lib/nas/nas_ies.c
View File

@ -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)

20
lib/nas/nas_ies.h
View File

@ -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);

252
lib/nas/nas_message.h
View File

@ -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;