forked from acouzens/open5gs
Merge branch 'master' of https://github.com/acetcom/cellwire
This commit is contained in:
Brandon
commit
0fe39f5194
|
|
@ -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-26 14:51:04.156252 by acetcom
|
||||
* Created on: 2017-04-26 16:05:18.070520 by acetcom
|
||||
* from 24301-d80.docx
|
||||
******************************************************************************/
|
||||
|
||||
|
|
@ -1584,6 +1584,486 @@ c_int32_t nas_decode_activate_default_eps_bearer_context_reject(nas_message_t *m
|
|||
return decoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_decode_activate_dedicated_eps_bearer_context_request(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_activate_dedicated_eps_bearer_context_request_t *activate_dedicated_eps_bearer_context_request = &message->esm.activate_dedicated_eps_bearer_context_request;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_decode_linked_eps_bearer_identity(&activate_dedicated_eps_bearer_context_request->linked_eps_bearer_identity, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
decoded += size;
|
||||
|
||||
size = nas_decode_eps_quality_of_service(&activate_dedicated_eps_bearer_context_request->eps_qos, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
decoded += size;
|
||||
|
||||
size = nas_decode_traffic_flow_template(&activate_dedicated_eps_bearer_context_request->tft, 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_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_TRANSACTION_IDENTIFIER_TYPE:
|
||||
size = nas_decode_transaction_identifier(&activate_dedicated_eps_bearer_context_request->transaction_identifier, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_request->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_TRANSACTION_IDENTIFIER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_QOS_TYPE:
|
||||
size = nas_decode_quality_of_service(&activate_dedicated_eps_bearer_context_request->negotiated_qos, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_request->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_QOS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_TYPE:
|
||||
size = nas_decode_llc_service_access_point_identifier(&activate_dedicated_eps_bearer_context_request->negotiated_llc_sapi, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_request->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_TYPE:
|
||||
size = nas_decode_radio_priority(&activate_dedicated_eps_bearer_context_request->radio_priority, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_request->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_TYPE:
|
||||
size = nas_decode_packet_flow_identifier(&activate_dedicated_eps_bearer_context_request->packet_flow_identifier, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_request->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&activate_dedicated_eps_bearer_context_request->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_request->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_TYPE:
|
||||
size = nas_decode_wlan_offload_acceptability(&activate_dedicated_eps_bearer_context_request->wlan_offload_indication, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_request->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&activate_dedicated_eps_bearer_context_request->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_request->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&activate_dedicated_eps_bearer_context_request->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_request->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_activate_dedicated_eps_bearer_context_accept(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_activate_dedicated_eps_bearer_context_accept_t *activate_dedicated_eps_bearer_context_accept = &message->esm.activate_dedicated_eps_bearer_context_accept;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
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_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&activate_dedicated_eps_bearer_context_accept->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_accept->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&activate_dedicated_eps_bearer_context_accept->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_accept->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&activate_dedicated_eps_bearer_context_accept->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_accept->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_activate_dedicated_eps_bearer_context_reject(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_activate_dedicated_eps_bearer_context_reject_t *activate_dedicated_eps_bearer_context_reject = &message->esm.activate_dedicated_eps_bearer_context_reject;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_decode_esm_cause(&activate_dedicated_eps_bearer_context_reject->esm_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_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&activate_dedicated_eps_bearer_context_reject->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_reject->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&activate_dedicated_eps_bearer_context_reject->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_reject->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&activate_dedicated_eps_bearer_context_reject->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
activate_dedicated_eps_bearer_context_reject->presencemask |= NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_modify_eps_bearer_context_request(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_modify_eps_bearer_context_request_t *modify_eps_bearer_context_request = &message->esm.modify_eps_bearer_context_request;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
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_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_EPS_QOS_TYPE:
|
||||
size = nas_decode_eps_quality_of_service(&modify_eps_bearer_context_request->new_eps_qos, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_EPS_QOS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_TFT_TYPE:
|
||||
size = nas_decode_traffic_flow_template(&modify_eps_bearer_context_request->tft, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_TFT_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_QOS_TYPE:
|
||||
size = nas_decode_quality_of_service(&modify_eps_bearer_context_request->new_qos, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_QOS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_TYPE:
|
||||
size = nas_decode_llc_service_access_point_identifier(&modify_eps_bearer_context_request->negotiated_llc_sapi, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_TYPE:
|
||||
size = nas_decode_radio_priority(&modify_eps_bearer_context_request->radio_priority, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_TYPE:
|
||||
size = nas_decode_packet_flow_identifier(&modify_eps_bearer_context_request->packet_flow_identifier, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_APN_AMBR_TYPE:
|
||||
size = nas_decode_apn_aggregate_maximum_bit_rate(&modify_eps_bearer_context_request->apn_ambr, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_APN_AMBR_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&modify_eps_bearer_context_request->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_TYPE:
|
||||
size = nas_decode_wlan_offload_acceptability(&modify_eps_bearer_context_request->wlan_offload_indication, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&modify_eps_bearer_context_request->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_HEADER_COMPRESSION_CONFIGURATION_TYPE:
|
||||
size = nas_decode_header_compression_configuration(&modify_eps_bearer_context_request->header_compression_configuration, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_HEADER_COMPRESSION_CONFIGURATION_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&modify_eps_bearer_context_request->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_request->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_modify_eps_bearer_context_accept(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_modify_eps_bearer_context_accept_t *modify_eps_bearer_context_accept = &message->esm.modify_eps_bearer_context_accept;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
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_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&modify_eps_bearer_context_accept->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_accept->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&modify_eps_bearer_context_accept->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_accept->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&modify_eps_bearer_context_accept->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_accept->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_modify_eps_bearer_context_reject(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_modify_eps_bearer_context_reject_t *modify_eps_bearer_context_reject = &message->esm.modify_eps_bearer_context_reject;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_decode_esm_cause(&modify_eps_bearer_context_reject->esm_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_MODIFY_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&modify_eps_bearer_context_reject->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_reject->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&modify_eps_bearer_context_reject->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_reject->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&modify_eps_bearer_context_reject->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
modify_eps_bearer_context_reject->presencemask |= NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_deactivate_eps_bearer_context_request(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_deactivate_eps_bearer_context_request_t *deactivate_eps_bearer_context_request = &message->esm.deactivate_eps_bearer_context_request;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_decode_esm_cause(&deactivate_eps_bearer_context_request->esm_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_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&deactivate_eps_bearer_context_request->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
deactivate_eps_bearer_context_request->presencemask |= NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_T3396_VALUE_TYPE:
|
||||
size = nas_decode_gprs_timer_3(&deactivate_eps_bearer_context_request->t3396_value, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
deactivate_eps_bearer_context_request->presencemask |= NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_T3396_VALUE_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_TYPE:
|
||||
size = nas_decode_wlan_offload_acceptability(&deactivate_eps_bearer_context_request->wlan_offload_indication, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
deactivate_eps_bearer_context_request->presencemask |= NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&deactivate_eps_bearer_context_request->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
deactivate_eps_bearer_context_request->presencemask |= NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&deactivate_eps_bearer_context_request->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
deactivate_eps_bearer_context_request->presencemask |= NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_deactivate_eps_bearer_context_accept(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_deactivate_eps_bearer_context_accept_t *deactivate_eps_bearer_context_accept = &message->esm.deactivate_eps_bearer_context_accept;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
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_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&deactivate_eps_bearer_context_accept->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
deactivate_eps_bearer_context_accept->presencemask |= NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&deactivate_eps_bearer_context_accept->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
deactivate_eps_bearer_context_accept->presencemask |= NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_pdn_connectivity_request(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_pdn_connectivity_request_t *pdn_connectivity_request = &message->esm.pdn_connectivity_request;
|
||||
|
|
@ -1804,6 +2284,268 @@ c_int32_t nas_decode_pdn_disconnect_reject(nas_message_t *message, pkbuf_t *pkbu
|
|||
return decoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_decode_bearer_resource_allocation_request(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_bearer_resource_allocation_request_t *bearer_resource_allocation_request = &message->esm.bearer_resource_allocation_request;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_decode_linked_eps_bearer_identity(&bearer_resource_allocation_request->linked_eps_bearer_identity, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
decoded += size;
|
||||
|
||||
size = nas_decode_traffic_flow_aggregate_description(&bearer_resource_allocation_request->traffic_flow_aggregate, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
decoded += size;
|
||||
|
||||
size = nas_decode_eps_quality_of_service(&bearer_resource_allocation_request->required_traffic_flow_qos, 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_BEARER_RESOURCE_ALLOCATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&bearer_resource_allocation_request->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_allocation_request->presencemask |= NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_DEVICE_PROPERTIES_TYPE:
|
||||
size = nas_decode_device_properties(&bearer_resource_allocation_request->device_properties, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_allocation_request->presencemask |= NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_DEVICE_PROPERTIES_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&bearer_resource_allocation_request->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_allocation_request->presencemask |= NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&bearer_resource_allocation_request->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_allocation_request->presencemask |= NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_bearer_resource_allocation_reject(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_bearer_resource_allocation_reject_t *bearer_resource_allocation_reject = &message->esm.bearer_resource_allocation_reject;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_decode_esm_cause(&bearer_resource_allocation_reject->esm_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_BEARER_RESOURCE_ALLOCATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&bearer_resource_allocation_reject->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_allocation_reject->presencemask |= NAS_BEARER_RESOURCE_ALLOCATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REJECT_BACK_OFF_TIMER_VALUE_TYPE:
|
||||
size = nas_decode_gprs_timer_3(&bearer_resource_allocation_reject->back_off_timer_value, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_allocation_reject->presencemask |= NAS_BEARER_RESOURCE_ALLOCATION_REJECT_BACK_OFF_TIMER_VALUE_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REJECT_RE_ATTEMPT_INDICATOR_TYPE:
|
||||
size = nas_decode_re_attempt_indicator(&bearer_resource_allocation_reject->re_attempt_indicator, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_allocation_reject->presencemask |= NAS_BEARER_RESOURCE_ALLOCATION_REJECT_RE_ATTEMPT_INDICATOR_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REJECT_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&bearer_resource_allocation_reject->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_allocation_reject->presencemask |= NAS_BEARER_RESOURCE_ALLOCATION_REJECT_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&bearer_resource_allocation_reject->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_allocation_reject->presencemask |= NAS_BEARER_RESOURCE_ALLOCATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_bearer_resource_modification_request(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_bearer_resource_modification_request_t *bearer_resource_modification_request = &message->esm.bearer_resource_modification_request;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_decode_linked_eps_bearer_identity(&bearer_resource_modification_request->eps_bearer_identity_for_packet_filter, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
decoded += size;
|
||||
|
||||
size = nas_decode_traffic_flow_aggregate_description(&bearer_resource_modification_request->traffic_flow_aggregate, 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_BEARER_RESOURCE_MODIFICATION_REQUEST_REQUIRED_TRAFFIC_FLOW_QOS_TYPE:
|
||||
size = nas_decode_eps_quality_of_service(&bearer_resource_modification_request->required_traffic_flow_qos, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_request->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_REQUIRED_TRAFFIC_FLOW_QOS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_ESM_CAUSE_TYPE:
|
||||
size = nas_decode_esm_cause(&bearer_resource_modification_request->esm_cause, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_request->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_ESM_CAUSE_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&bearer_resource_modification_request->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_request->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_DEVICE_PROPERTIES_TYPE:
|
||||
size = nas_decode_device_properties(&bearer_resource_modification_request->device_properties, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_request->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_DEVICE_PROPERTIES_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&bearer_resource_modification_request->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_request->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_HEADER_COMPRESSION_CONFIGURATION_TYPE:
|
||||
size = nas_decode_header_compression_configuration(&bearer_resource_modification_request->header_compression_configuration, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_request->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_HEADER_COMPRESSION_CONFIGURATION_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&bearer_resource_modification_request->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_request->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_bearer_resource_modification_reject(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_bearer_resource_modification_reject_t *bearer_resource_modification_reject = &message->esm.bearer_resource_modification_reject;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_decode_esm_cause(&bearer_resource_modification_reject->esm_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_BEARER_RESOURCE_MODIFICATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_protocol_configuration_options(&bearer_resource_modification_reject->protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_reject->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REJECT_BACK_OFF_TIMER_VALUE_TYPE:
|
||||
size = nas_decode_gprs_timer_3(&bearer_resource_modification_reject->back_off_timer_value, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_reject->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REJECT_BACK_OFF_TIMER_VALUE_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REJECT_RE_ATTEMPT_INDICATOR_TYPE:
|
||||
size = nas_decode_re_attempt_indicator(&bearer_resource_modification_reject->re_attempt_indicator, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_reject->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REJECT_RE_ATTEMPT_INDICATOR_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REJECT_NBIFOM_CONTAINER_TYPE:
|
||||
size = nas_decode_nbifom_container(&bearer_resource_modification_reject->nbifom_container, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_reject->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REJECT_NBIFOM_CONTAINER_PRESENT;
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE:
|
||||
size = nas_decode_extended_protocol_configuration_options(&bearer_resource_modification_reject->extended_protocol_configuration_options, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
bearer_resource_modification_reject->presencemask |= NAS_BEARER_RESOURCE_MODIFICATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_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_esm_information_response(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_esm_information_response_t *esm_information_response = &message->esm.esm_information_response;
|
||||
|
|
@ -1849,6 +2591,19 @@ c_int32_t nas_decode_esm_information_response(nas_message_t *message, pkbuf_t *p
|
|||
return decoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_decode_esm_status(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
nas_esm_status_t *esm_status = &message->esm.esm_status;
|
||||
c_int32_t decoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_decode_esm_cause(&esm_status->esm_cause, pkbuf);
|
||||
d_assert(size >= 0, return -1, "decode failed");
|
||||
decoded += size;
|
||||
|
||||
return decoded;
|
||||
}
|
||||
|
||||
status_t nas_emm_decode(nas_message_t *message, pkbuf_t *pkbuf)
|
||||
{
|
||||
status_t rv = CORE_ERROR;
|
||||
|
|
@ -2065,6 +2820,46 @@ status_t nas_esm_decode(nas_message_t *message, pkbuf_t *pkbuf)
|
|||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST:
|
||||
size = nas_decode_activate_dedicated_eps_bearer_context_request(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT:
|
||||
size = nas_decode_activate_dedicated_eps_bearer_context_accept(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT:
|
||||
size = nas_decode_activate_dedicated_eps_bearer_context_reject(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST:
|
||||
size = nas_decode_modify_eps_bearer_context_request(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT:
|
||||
size = nas_decode_modify_eps_bearer_context_accept(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT:
|
||||
size = nas_decode_modify_eps_bearer_context_reject(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST:
|
||||
size = nas_decode_deactivate_eps_bearer_context_request(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT:
|
||||
size = nas_decode_deactivate_eps_bearer_context_accept(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_PDN_CONNECTIVITY_REQUEST:
|
||||
size = nas_decode_pdn_connectivity_request(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
|
|
@ -2085,6 +2880,26 @@ status_t nas_esm_decode(nas_message_t *message, pkbuf_t *pkbuf)
|
|||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REQUEST:
|
||||
size = nas_decode_bearer_resource_allocation_request(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REJECT:
|
||||
size = nas_decode_bearer_resource_allocation_reject(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REQUEST:
|
||||
size = nas_decode_bearer_resource_modification_request(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REJECT:
|
||||
size = nas_decode_bearer_resource_modification_reject(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ESM_INFORMATION_REQUEST:
|
||||
break;
|
||||
case NAS_ESM_INFORMATION_RESPONSE:
|
||||
|
|
@ -2092,6 +2907,11 @@ status_t nas_esm_decode(nas_message_t *message, pkbuf_t *pkbuf)
|
|||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
case NAS_ESM_STATUS:
|
||||
size = nas_decode_esm_status(message, pkbuf);
|
||||
d_assert(size >= CORE_OK, return CORE_ERROR, "decode error");
|
||||
decoded += size;
|
||||
break;
|
||||
default:
|
||||
d_error("Unknown message type (0x%x) or not implemented",
|
||||
message->esm.h.message_type);
|
||||
|
|
|
|||
|
|
@ -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-26 14:51:04.184245 by acetcom
|
||||
* Created on: 2017-04-26 16:05:18.104109 by acetcom
|
||||
* from 24301-d80.docx
|
||||
******************************************************************************/
|
||||
|
||||
|
|
@ -1781,6 +1781,532 @@ c_int32_t nas_encode_activate_default_eps_bearer_context_reject(pkbuf_t *pkbuf,
|
|||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_activate_dedicated_eps_bearer_context_request(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_activate_dedicated_eps_bearer_context_request_t *activate_dedicated_eps_bearer_context_request = &message->esm.activate_dedicated_eps_bearer_context_request;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_encode_linked_eps_bearer_identity(pkbuf, &activate_dedicated_eps_bearer_context_request->linked_eps_bearer_identity);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_eps_quality_of_service(pkbuf, &activate_dedicated_eps_bearer_context_request->eps_qos);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_traffic_flow_template(pkbuf, &activate_dedicated_eps_bearer_context_request->tft);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_request->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_TRANSACTION_IDENTIFIER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_TRANSACTION_IDENTIFIER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_transaction_identifier(pkbuf, &activate_dedicated_eps_bearer_context_request->transaction_identifier);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_request->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_QOS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_QOS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_quality_of_service(pkbuf, &activate_dedicated_eps_bearer_context_request->negotiated_qos);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_request->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_llc_service_access_point_identifier(pkbuf, &activate_dedicated_eps_bearer_context_request->negotiated_llc_sapi);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_request->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_PRESENT)
|
||||
{
|
||||
activate_dedicated_eps_bearer_context_request->radio_priority.type = (NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_TYPE >> 4);
|
||||
|
||||
size = nas_encode_radio_priority(pkbuf, &activate_dedicated_eps_bearer_context_request->radio_priority);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_request->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_packet_flow_identifier(pkbuf, &activate_dedicated_eps_bearer_context_request->packet_flow_identifier);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_request->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &activate_dedicated_eps_bearer_context_request->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_request->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_PRESENT)
|
||||
{
|
||||
activate_dedicated_eps_bearer_context_request->wlan_offload_indication.type = (NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_TYPE >> 4);
|
||||
|
||||
size = nas_encode_wlan_offload_acceptability(pkbuf, &activate_dedicated_eps_bearer_context_request->wlan_offload_indication);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_request->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &activate_dedicated_eps_bearer_context_request->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_request->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &activate_dedicated_eps_bearer_context_request->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_activate_dedicated_eps_bearer_context_accept(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_activate_dedicated_eps_bearer_context_accept_t *activate_dedicated_eps_bearer_context_accept = &message->esm.activate_dedicated_eps_bearer_context_accept;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_accept->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &activate_dedicated_eps_bearer_context_accept->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_accept->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &activate_dedicated_eps_bearer_context_accept->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_accept->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &activate_dedicated_eps_bearer_context_accept->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_activate_dedicated_eps_bearer_context_reject(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_activate_dedicated_eps_bearer_context_reject_t *activate_dedicated_eps_bearer_context_reject = &message->esm.activate_dedicated_eps_bearer_context_reject;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_encode_esm_cause(pkbuf, &activate_dedicated_eps_bearer_context_reject->esm_cause);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_reject->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &activate_dedicated_eps_bearer_context_reject->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_reject->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &activate_dedicated_eps_bearer_context_reject->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (activate_dedicated_eps_bearer_context_reject->presencemask & NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &activate_dedicated_eps_bearer_context_reject->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_modify_eps_bearer_context_request(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_modify_eps_bearer_context_request_t *modify_eps_bearer_context_request = &message->esm.modify_eps_bearer_context_request;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_EPS_QOS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_EPS_QOS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_eps_quality_of_service(pkbuf, &modify_eps_bearer_context_request->new_eps_qos);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_TFT_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_TFT_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_traffic_flow_template(pkbuf, &modify_eps_bearer_context_request->tft);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_QOS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_QOS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_quality_of_service(pkbuf, &modify_eps_bearer_context_request->new_qos);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_llc_service_access_point_identifier(pkbuf, &modify_eps_bearer_context_request->negotiated_llc_sapi);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_PRESENT)
|
||||
{
|
||||
modify_eps_bearer_context_request->radio_priority.type = (NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_TYPE >> 4);
|
||||
|
||||
size = nas_encode_radio_priority(pkbuf, &modify_eps_bearer_context_request->radio_priority);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_packet_flow_identifier(pkbuf, &modify_eps_bearer_context_request->packet_flow_identifier);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_APN_AMBR_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_APN_AMBR_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_apn_aggregate_maximum_bit_rate(pkbuf, &modify_eps_bearer_context_request->apn_ambr);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &modify_eps_bearer_context_request->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_PRESENT)
|
||||
{
|
||||
modify_eps_bearer_context_request->wlan_offload_indication.type = (NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_TYPE >> 4);
|
||||
|
||||
size = nas_encode_wlan_offload_acceptability(pkbuf, &modify_eps_bearer_context_request->wlan_offload_indication);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &modify_eps_bearer_context_request->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_HEADER_COMPRESSION_CONFIGURATION_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_HEADER_COMPRESSION_CONFIGURATION_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_header_compression_configuration(pkbuf, &modify_eps_bearer_context_request->header_compression_configuration);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_request->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &modify_eps_bearer_context_request->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_modify_eps_bearer_context_accept(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_modify_eps_bearer_context_accept_t *modify_eps_bearer_context_accept = &message->esm.modify_eps_bearer_context_accept;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
if (modify_eps_bearer_context_accept->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &modify_eps_bearer_context_accept->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_accept->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &modify_eps_bearer_context_accept->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_accept->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &modify_eps_bearer_context_accept->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_modify_eps_bearer_context_reject(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_modify_eps_bearer_context_reject_t *modify_eps_bearer_context_reject = &message->esm.modify_eps_bearer_context_reject;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_encode_esm_cause(pkbuf, &modify_eps_bearer_context_reject->esm_cause);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
if (modify_eps_bearer_context_reject->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &modify_eps_bearer_context_reject->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_reject->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &modify_eps_bearer_context_reject->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (modify_eps_bearer_context_reject->presencemask & NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &modify_eps_bearer_context_reject->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_deactivate_eps_bearer_context_request(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_deactivate_eps_bearer_context_request_t *deactivate_eps_bearer_context_request = &message->esm.deactivate_eps_bearer_context_request;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_encode_esm_cause(pkbuf, &deactivate_eps_bearer_context_request->esm_cause);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
if (deactivate_eps_bearer_context_request->presencemask & NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &deactivate_eps_bearer_context_request->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (deactivate_eps_bearer_context_request->presencemask & NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_T3396_VALUE_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_T3396_VALUE_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_gprs_timer_3(pkbuf, &deactivate_eps_bearer_context_request->t3396_value);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (deactivate_eps_bearer_context_request->presencemask & NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_PRESENT)
|
||||
{
|
||||
deactivate_eps_bearer_context_request->wlan_offload_indication.type = (NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_TYPE >> 4);
|
||||
|
||||
size = nas_encode_wlan_offload_acceptability(pkbuf, &deactivate_eps_bearer_context_request->wlan_offload_indication);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (deactivate_eps_bearer_context_request->presencemask & NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &deactivate_eps_bearer_context_request->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (deactivate_eps_bearer_context_request->presencemask & NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &deactivate_eps_bearer_context_request->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_deactivate_eps_bearer_context_accept(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_deactivate_eps_bearer_context_accept_t *deactivate_eps_bearer_context_accept = &message->esm.deactivate_eps_bearer_context_accept;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
if (deactivate_eps_bearer_context_accept->presencemask & NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &deactivate_eps_bearer_context_accept->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (deactivate_eps_bearer_context_accept->presencemask & NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &deactivate_eps_bearer_context_accept->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_pdn_connectivity_request(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_pdn_connectivity_request_t *pdn_connectivity_request = &message->esm.pdn_connectivity_request;
|
||||
|
|
@ -2005,6 +2531,297 @@ c_int32_t nas_encode_pdn_disconnect_reject(pkbuf_t *pkbuf, nas_message_t *messag
|
|||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_bearer_resource_allocation_request(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_bearer_resource_allocation_request_t *bearer_resource_allocation_request = &message->esm.bearer_resource_allocation_request;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_encode_linked_eps_bearer_identity(pkbuf, &bearer_resource_allocation_request->linked_eps_bearer_identity);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_traffic_flow_aggregate_description(pkbuf, &bearer_resource_allocation_request->traffic_flow_aggregate);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_eps_quality_of_service(pkbuf, &bearer_resource_allocation_request->required_traffic_flow_qos);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
if (bearer_resource_allocation_request->presencemask & NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &bearer_resource_allocation_request->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_allocation_request->presencemask & NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_DEVICE_PROPERTIES_PRESENT)
|
||||
{
|
||||
bearer_resource_allocation_request->device_properties.type = (NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_DEVICE_PROPERTIES_TYPE >> 4);
|
||||
|
||||
size = nas_encode_device_properties(pkbuf, &bearer_resource_allocation_request->device_properties);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_allocation_request->presencemask & NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &bearer_resource_allocation_request->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_allocation_request->presencemask & NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &bearer_resource_allocation_request->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_bearer_resource_allocation_reject(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_bearer_resource_allocation_reject_t *bearer_resource_allocation_reject = &message->esm.bearer_resource_allocation_reject;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_encode_esm_cause(pkbuf, &bearer_resource_allocation_reject->esm_cause);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
if (bearer_resource_allocation_reject->presencemask & NAS_BEARER_RESOURCE_ALLOCATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_ALLOCATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &bearer_resource_allocation_reject->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_allocation_reject->presencemask & NAS_BEARER_RESOURCE_ALLOCATION_REJECT_BACK_OFF_TIMER_VALUE_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_ALLOCATION_REJECT_BACK_OFF_TIMER_VALUE_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_gprs_timer_3(pkbuf, &bearer_resource_allocation_reject->back_off_timer_value);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_allocation_reject->presencemask & NAS_BEARER_RESOURCE_ALLOCATION_REJECT_RE_ATTEMPT_INDICATOR_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_ALLOCATION_REJECT_RE_ATTEMPT_INDICATOR_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_re_attempt_indicator(pkbuf, &bearer_resource_allocation_reject->re_attempt_indicator);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_allocation_reject->presencemask & NAS_BEARER_RESOURCE_ALLOCATION_REJECT_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_ALLOCATION_REJECT_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &bearer_resource_allocation_reject->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_allocation_reject->presencemask & NAS_BEARER_RESOURCE_ALLOCATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_ALLOCATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &bearer_resource_allocation_reject->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_bearer_resource_modification_request(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_bearer_resource_modification_request_t *bearer_resource_modification_request = &message->esm.bearer_resource_modification_request;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_encode_linked_eps_bearer_identity(pkbuf, &bearer_resource_modification_request->eps_bearer_identity_for_packet_filter);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_traffic_flow_aggregate_description(pkbuf, &bearer_resource_modification_request->traffic_flow_aggregate);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
if (bearer_resource_modification_request->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_REQUIRED_TRAFFIC_FLOW_QOS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_REQUIRED_TRAFFIC_FLOW_QOS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_eps_quality_of_service(pkbuf, &bearer_resource_modification_request->required_traffic_flow_qos);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_modification_request->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_ESM_CAUSE_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_ESM_CAUSE_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_esm_cause(pkbuf, &bearer_resource_modification_request->esm_cause);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_modification_request->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &bearer_resource_modification_request->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_modification_request->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_DEVICE_PROPERTIES_PRESENT)
|
||||
{
|
||||
bearer_resource_modification_request->device_properties.type = (NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_DEVICE_PROPERTIES_TYPE >> 4);
|
||||
|
||||
size = nas_encode_device_properties(pkbuf, &bearer_resource_modification_request->device_properties);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_modification_request->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &bearer_resource_modification_request->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_modification_request->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_HEADER_COMPRESSION_CONFIGURATION_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_HEADER_COMPRESSION_CONFIGURATION_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_header_compression_configuration(pkbuf, &bearer_resource_modification_request->header_compression_configuration);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_modification_request->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &bearer_resource_modification_request->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_bearer_resource_modification_reject(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_bearer_resource_modification_reject_t *bearer_resource_modification_reject = &message->esm.bearer_resource_modification_reject;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_encode_esm_cause(pkbuf, &bearer_resource_modification_reject->esm_cause);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
if (bearer_resource_modification_reject->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_protocol_configuration_options(pkbuf, &bearer_resource_modification_reject->protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_modification_reject->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REJECT_BACK_OFF_TIMER_VALUE_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REJECT_BACK_OFF_TIMER_VALUE_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_gprs_timer_3(pkbuf, &bearer_resource_modification_reject->back_off_timer_value);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_modification_reject->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REJECT_RE_ATTEMPT_INDICATOR_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REJECT_RE_ATTEMPT_INDICATOR_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_re_attempt_indicator(pkbuf, &bearer_resource_modification_reject->re_attempt_indicator);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_modification_reject->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REJECT_NBIFOM_CONTAINER_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REJECT_NBIFOM_CONTAINER_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_nbifom_container(pkbuf, &bearer_resource_modification_reject->nbifom_container);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
if (bearer_resource_modification_reject->presencemask & NAS_BEARER_RESOURCE_MODIFICATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT)
|
||||
{
|
||||
size = nas_encode_optional_type(pkbuf, NAS_BEARER_RESOURCE_MODIFICATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
|
||||
size = nas_encode_extended_protocol_configuration_options(pkbuf, &bearer_resource_modification_reject->extended_protocol_configuration_options);
|
||||
d_assert(size >= 0, return encoded, "decode failed");
|
||||
encoded += size;
|
||||
}
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_esm_information_response(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_esm_information_response_t *esm_information_response = &message->esm.esm_information_response;
|
||||
|
|
@ -2047,6 +2864,19 @@ c_int32_t nas_encode_esm_information_response(pkbuf_t *pkbuf, nas_message_t *mes
|
|||
return encoded;
|
||||
}
|
||||
|
||||
c_int32_t nas_encode_esm_status(pkbuf_t *pkbuf, nas_message_t *message)
|
||||
{
|
||||
nas_esm_status_t *esm_status = &message->esm.esm_status;
|
||||
c_int32_t encoded = 0;
|
||||
c_int32_t size = 0;
|
||||
|
||||
size = nas_encode_esm_cause(pkbuf, &esm_status->esm_cause);
|
||||
d_assert(size >= 0, return -1, "encode failed");
|
||||
encoded += size;
|
||||
|
||||
return encoded;
|
||||
}
|
||||
|
||||
status_t nas_emm_encode(pkbuf_t **pkbuf, nas_message_t *message)
|
||||
{
|
||||
status_t rv = CORE_ERROR;
|
||||
|
|
@ -2273,6 +3103,46 @@ status_t nas_esm_encode(pkbuf_t **pkbuf, nas_message_t *message)
|
|||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST:
|
||||
size = nas_encode_activate_dedicated_eps_bearer_context_request(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT:
|
||||
size = nas_encode_activate_dedicated_eps_bearer_context_accept(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT:
|
||||
size = nas_encode_activate_dedicated_eps_bearer_context_reject(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST:
|
||||
size = nas_encode_modify_eps_bearer_context_request(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT:
|
||||
size = nas_encode_modify_eps_bearer_context_accept(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT:
|
||||
size = nas_encode_modify_eps_bearer_context_reject(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST:
|
||||
size = nas_encode_deactivate_eps_bearer_context_request(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT:
|
||||
size = nas_encode_deactivate_eps_bearer_context_accept(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_PDN_CONNECTIVITY_REQUEST:
|
||||
size = nas_encode_pdn_connectivity_request(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
|
|
@ -2293,6 +3163,26 @@ status_t nas_esm_encode(pkbuf_t **pkbuf, nas_message_t *message)
|
|||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REQUEST:
|
||||
size = nas_encode_bearer_resource_allocation_request(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_ALLOCATION_REJECT:
|
||||
size = nas_encode_bearer_resource_allocation_reject(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REQUEST:
|
||||
size = nas_encode_bearer_resource_modification_request(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_BEARER_RESOURCE_MODIFICATION_REJECT:
|
||||
size = nas_encode_bearer_resource_modification_reject(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_ESM_INFORMATION_REQUEST:
|
||||
break;
|
||||
case NAS_ESM_INFORMATION_RESPONSE:
|
||||
|
|
@ -2300,6 +3190,11 @@ status_t nas_esm_encode(pkbuf_t **pkbuf, nas_message_t *message)
|
|||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
case NAS_ESM_STATUS:
|
||||
size = nas_encode_esm_status(*pkbuf, message);
|
||||
d_assert(size >= 0, return CORE_ERROR, "decode error");
|
||||
encoded += size;
|
||||
break;
|
||||
default:
|
||||
d_error("Unknown message type (0x%x) or not implemented",
|
||||
message->esm.h.message_type);
|
||||
|
|
|
|||
|
|
@ -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-26 14:51:04.120969 by acetcom
|
||||
* Created on: 2017-04-26 16:05:18.033672 by acetcom
|
||||
* from 24301-d80.docx
|
||||
******************************************************************************/
|
||||
|
||||
|
|
@ -1908,6 +1908,62 @@ c_int16_t nas_encode_request_type(pkbuf_t *pkbuf, nas_request_type_t *request_ty
|
|||
return size;
|
||||
}
|
||||
|
||||
/* 9.9.4.15 Traffic flow aggregate description
|
||||
* M LV 2-256 */
|
||||
c_int16_t nas_decode_traffic_flow_aggregate_description(nas_traffic_flow_aggregate_description_t *traffic_flow_aggregate_description, pkbuf_t *pkbuf)
|
||||
{
|
||||
c_uint16_t size = 0;
|
||||
nas_traffic_flow_aggregate_description_t *source = pkbuf->payload;
|
||||
|
||||
traffic_flow_aggregate_description->length = source->length;
|
||||
size = traffic_flow_aggregate_description->length + sizeof(traffic_flow_aggregate_description->length);
|
||||
|
||||
d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error");
|
||||
memcpy(traffic_flow_aggregate_description, pkbuf->payload - size, size);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
c_int16_t nas_encode_traffic_flow_aggregate_description(pkbuf_t *pkbuf, nas_traffic_flow_aggregate_description_t *traffic_flow_aggregate_description)
|
||||
{
|
||||
c_uint16_t size = traffic_flow_aggregate_description->length + sizeof(traffic_flow_aggregate_description->length);
|
||||
nas_traffic_flow_aggregate_description_t target;
|
||||
|
||||
memcpy(&target, traffic_flow_aggregate_description, sizeof(nas_traffic_flow_aggregate_description_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.16 Traffic flow template
|
||||
* M LV 2-256 */
|
||||
c_int16_t nas_decode_traffic_flow_template(nas_traffic_flow_template_t *traffic_flow_template, pkbuf_t *pkbuf)
|
||||
{
|
||||
c_uint16_t size = 0;
|
||||
nas_traffic_flow_template_t *source = pkbuf->payload;
|
||||
|
||||
traffic_flow_template->length = source->length;
|
||||
size = traffic_flow_template->length + sizeof(traffic_flow_template->length);
|
||||
|
||||
d_assert(pkbuf_header(pkbuf, -size) == CORE_OK, return -1, "pkbuf_header error");
|
||||
memcpy(traffic_flow_template, pkbuf->payload - size, size);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
c_int16_t nas_encode_traffic_flow_template(pkbuf_t *pkbuf, nas_traffic_flow_template_t *traffic_flow_template)
|
||||
{
|
||||
c_uint16_t size = traffic_flow_template->length + sizeof(traffic_flow_template->length);
|
||||
nas_traffic_flow_template_t target;
|
||||
|
||||
memcpy(&target, traffic_flow_template, sizeof(nas_traffic_flow_template_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.17 Transaction identifier
|
||||
* O TLV 3-4 */
|
||||
c_int16_t nas_decode_transaction_identifier(nas_transaction_identifier_t *transaction_identifier, pkbuf_t *pkbuf)
|
||||
|
|
|
|||
|
|
@ -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-26 14:51:04.114843 by acetcom
|
||||
* Created on: 2017-04-26 16:05:18.026166 by acetcom
|
||||
* from 24301-d80.docx
|
||||
******************************************************************************/
|
||||
|
||||
|
|
@ -113,6 +113,8 @@ CORE_DECLARE(c_int16_t) nas_decode_quality_of_service(nas_quality_of_service_t *
|
|||
CORE_DECLARE(c_int16_t) nas_decode_radio_priority(nas_radio_priority_t *radio_priority, pkbuf_t *pkbuf);
|
||||
CORE_DECLARE(c_int16_t) nas_decode_re_attempt_indicator(nas_re_attempt_indicator_t *re_attempt_indicator, pkbuf_t *pkbuf);
|
||||
CORE_DECLARE(c_int16_t) nas_decode_request_type(nas_request_type_t *request_type, pkbuf_t *pkbuf);
|
||||
CORE_DECLARE(c_int16_t) nas_decode_traffic_flow_aggregate_description(nas_traffic_flow_aggregate_description_t *traffic_flow_aggregate_description, pkbuf_t *pkbuf);
|
||||
CORE_DECLARE(c_int16_t) nas_decode_traffic_flow_template(nas_traffic_flow_template_t *traffic_flow_template, pkbuf_t *pkbuf);
|
||||
CORE_DECLARE(c_int16_t) nas_decode_transaction_identifier(nas_transaction_identifier_t *transaction_identifier, pkbuf_t *pkbuf);
|
||||
CORE_DECLARE(c_int16_t) nas_decode_wlan_offload_acceptability(nas_wlan_offload_acceptability_t *wlan_offload_acceptability, pkbuf_t *pkbuf);
|
||||
CORE_DECLARE(c_int16_t) nas_decode_nbifom_container(nas_nbifom_container_t *nbifom_container, pkbuf_t *pkbuf);
|
||||
|
|
@ -202,6 +204,8 @@ CORE_DECLARE(c_int16_t) nas_encode_quality_of_service(pkbuf_t *pkbuf, nas_qualit
|
|||
CORE_DECLARE(c_int16_t) nas_encode_radio_priority(pkbuf_t *pkbuf, nas_radio_priority_t *radio_priority);
|
||||
CORE_DECLARE(c_int16_t) nas_encode_re_attempt_indicator(pkbuf_t *pkbuf, nas_re_attempt_indicator_t *re_attempt_indicator);
|
||||
CORE_DECLARE(c_int16_t) nas_encode_request_type(pkbuf_t *pkbuf, nas_request_type_t *request_type);
|
||||
CORE_DECLARE(c_int16_t) nas_encode_traffic_flow_aggregate_description(pkbuf_t *pkbuf, nas_traffic_flow_aggregate_description_t *traffic_flow_aggregate_description);
|
||||
CORE_DECLARE(c_int16_t) nas_encode_traffic_flow_template(pkbuf_t *pkbuf, nas_traffic_flow_template_t *traffic_flow_template);
|
||||
CORE_DECLARE(c_int16_t) nas_encode_transaction_identifier(pkbuf_t *pkbuf, nas_transaction_identifier_t *transaction_identifier);
|
||||
CORE_DECLARE(c_int16_t) nas_encode_wlan_offload_acceptability(pkbuf_t *pkbuf, nas_wlan_offload_acceptability_t *wlan_offload_acceptability);
|
||||
CORE_DECLARE(c_int16_t) nas_encode_nbifom_container(pkbuf_t *pkbuf, nas_nbifom_container_t *nbifom_container);
|
||||
|
|
|
|||
|
|
@ -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-26 14:51:04.133462 by acetcom
|
||||
* Created on: 2017-04-26 16:05:18.046860 by acetcom
|
||||
* from 24301-d80.docx
|
||||
******************************************************************************/
|
||||
|
||||
|
|
@ -877,6 +877,224 @@ typedef struct _nas_activate_default_eps_bearer_context_reject_t {
|
|||
} nas_activate_default_eps_bearer_context_reject_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* ACTIVATE DEDICATED EPS BEARER CONTEXT REQUEST
|
||||
******************************************************/
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_TRANSACTION_IDENTIFIER_PRESENT (1<<0)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_QOS_PRESENT (1<<1)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_PRESENT (1<<2)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_PRESENT (1<<3)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_PRESENT (1<<4)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<5)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_PRESENT (1<<6)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_PRESENT (1<<7)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<8)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_TRANSACTION_IDENTIFIER_TYPE 0x5D
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_QOS_TYPE 0x30
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_TYPE 0x32
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_TYPE 0x80
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_TYPE 0x34
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_TYPE 0xC0
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_activate_dedicated_eps_bearer_context_request_t {
|
||||
/* Mandatory fields */
|
||||
nas_linked_eps_bearer_identity_t linked_eps_bearer_identity;
|
||||
nas_eps_quality_of_service_t eps_qos;
|
||||
nas_traffic_flow_template_t tft;
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_transaction_identifier_t transaction_identifier;
|
||||
nas_quality_of_service_t negotiated_qos;
|
||||
nas_llc_service_access_point_identifier_t negotiated_llc_sapi;
|
||||
nas_radio_priority_t radio_priority;
|
||||
nas_packet_flow_identifier_t packet_flow_identifier;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_wlan_offload_acceptability_t wlan_offload_indication;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_activate_dedicated_eps_bearer_context_request_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* ACTIVATE DEDICATED EPS BEARER CONTEXT ACCEPT
|
||||
******************************************************/
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<0)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_PRESENT (1<<1)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<2)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_activate_dedicated_eps_bearer_context_accept_t {
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_activate_dedicated_eps_bearer_context_accept_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* ACTIVATE DEDICATED EPS BEARER CONTEXT REJECT
|
||||
******************************************************/
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<0)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_PRESENT (1<<1)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<2)
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_activate_dedicated_eps_bearer_context_reject_t {
|
||||
/* Mandatory fields */
|
||||
nas_esm_cause_t esm_cause;
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_activate_dedicated_eps_bearer_context_reject_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* MODIFY EPS BEARER CONTEXT REQUEST
|
||||
******************************************************/
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_EPS_QOS_PRESENT (1<<0)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_TFT_PRESENT (1<<1)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_QOS_PRESENT (1<<2)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_PRESENT (1<<3)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_PRESENT (1<<4)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_PRESENT (1<<5)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_APN_AMBR_PRESENT (1<<6)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<7)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_PRESENT (1<<8)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_PRESENT (1<<9)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_HEADER_COMPRESSION_CONFIGURATION_PRESENT (1<<10)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<11)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_EPS_QOS_TYPE 0x5B
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_TFT_TYPE 0x36
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEW_QOS_TYPE 0x30
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NEGOTIATED_LLC_SAPI_TYPE 0x32
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_RADIO_PRIORITY_TYPE 0x80
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PACKET_FLOW_IDENTIFIER_TYPE 0x34
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_APN_AMBR_TYPE 0x5E
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_TYPE 0xC0
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_HEADER_COMPRESSION_CONFIGURATION_TYPE 0x66
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_modify_eps_bearer_context_request_t {
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_eps_quality_of_service_t new_eps_qos;
|
||||
nas_traffic_flow_template_t tft;
|
||||
nas_quality_of_service_t new_qos;
|
||||
nas_llc_service_access_point_identifier_t negotiated_llc_sapi;
|
||||
nas_radio_priority_t radio_priority;
|
||||
nas_packet_flow_identifier_t packet_flow_identifier;
|
||||
nas_apn_aggregate_maximum_bit_rate_t apn_ambr;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_wlan_offload_acceptability_t wlan_offload_indication;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_header_compression_configuration_t header_compression_configuration;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_modify_eps_bearer_context_request_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* MODIFY EPS BEARER CONTEXT ACCEPT
|
||||
******************************************************/
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<0)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_PRESENT (1<<1)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<2)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_modify_eps_bearer_context_accept_t {
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_modify_eps_bearer_context_accept_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* MODIFY EPS BEARER CONTEXT REJECT
|
||||
******************************************************/
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<0)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_PRESENT (1<<1)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<2)
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_MODIFY_EPS_BEARER_CONTEXT_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_modify_eps_bearer_context_reject_t {
|
||||
/* Mandatory fields */
|
||||
nas_esm_cause_t esm_cause;
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_modify_eps_bearer_context_reject_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* DEACTIVATE EPS BEARER CONTEXT REQUEST
|
||||
******************************************************/
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<0)
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_T3396_VALUE_PRESENT (1<<1)
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_PRESENT (1<<2)
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_PRESENT (1<<3)
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<4)
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_T3396_VALUE_TYPE 0x37
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_WLAN_OFFLOAD_INDICATION_TYPE 0xC0
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_deactivate_eps_bearer_context_request_t {
|
||||
/* Mandatory fields */
|
||||
nas_esm_cause_t esm_cause;
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_gprs_timer_3_t t3396_value;
|
||||
nas_wlan_offload_acceptability_t wlan_offload_indication;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_deactivate_eps_bearer_context_request_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* DEACTIVATE EPS BEARER CONTEXT ACCEPT
|
||||
******************************************************/
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<0)
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<1)
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_deactivate_eps_bearer_context_accept_t {
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_deactivate_eps_bearer_context_accept_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* PDN CONNECTIVITY REQUEST
|
||||
******************************************************/
|
||||
|
|
@ -977,6 +1195,124 @@ typedef struct _nas_pdn_disconnect_reject_t {
|
|||
} nas_pdn_disconnect_reject_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* BEARER RESOURCE ALLOCATION REQUEST
|
||||
******************************************************/
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<0)
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_DEVICE_PROPERTIES_PRESENT (1<<1)
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_NBIFOM_CONTAINER_PRESENT (1<<2)
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<3)
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_DEVICE_PROPERTIES_TYPE 0xC0
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_bearer_resource_allocation_request_t {
|
||||
/* Mandatory fields */
|
||||
nas_linked_eps_bearer_identity_t linked_eps_bearer_identity;
|
||||
nas_traffic_flow_aggregate_description_t traffic_flow_aggregate;
|
||||
nas_eps_quality_of_service_t required_traffic_flow_qos;
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_device_properties_t device_properties;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_bearer_resource_allocation_request_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* BEARER RESOURCE ALLOCATION REJECT
|
||||
******************************************************/
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<0)
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REJECT_BACK_OFF_TIMER_VALUE_PRESENT (1<<1)
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REJECT_RE_ATTEMPT_INDICATOR_PRESENT (1<<2)
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REJECT_NBIFOM_CONTAINER_PRESENT (1<<3)
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<4)
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REJECT_BACK_OFF_TIMER_VALUE_TYPE 0x37
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REJECT_RE_ATTEMPT_INDICATOR_TYPE 0x6B
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REJECT_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_BEARER_RESOURCE_ALLOCATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_bearer_resource_allocation_reject_t {
|
||||
/* Mandatory fields */
|
||||
nas_esm_cause_t esm_cause;
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_gprs_timer_3_t back_off_timer_value;
|
||||
nas_re_attempt_indicator_t re_attempt_indicator;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_bearer_resource_allocation_reject_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* BEARER RESOURCE MODIFICATION REQUEST
|
||||
******************************************************/
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_REQUIRED_TRAFFIC_FLOW_QOS_PRESENT (1<<0)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_ESM_CAUSE_PRESENT (1<<1)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<2)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_DEVICE_PROPERTIES_PRESENT (1<<3)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_NBIFOM_CONTAINER_PRESENT (1<<4)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_HEADER_COMPRESSION_CONFIGURATION_PRESENT (1<<5)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<6)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_REQUIRED_TRAFFIC_FLOW_QOS_TYPE 0x5B
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_ESM_CAUSE_TYPE 0x58
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_DEVICE_PROPERTIES_TYPE 0xC0
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_HEADER_COMPRESSION_CONFIGURATION_TYPE 0x66
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REQUEST_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_bearer_resource_modification_request_t {
|
||||
/* Mandatory fields */
|
||||
nas_linked_eps_bearer_identity_t eps_bearer_identity_for_packet_filter;
|
||||
nas_traffic_flow_aggregate_description_t traffic_flow_aggregate;
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_eps_quality_of_service_t required_traffic_flow_qos;
|
||||
nas_esm_cause_t esm_cause;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_device_properties_t device_properties;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_header_compression_configuration_t header_compression_configuration;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_bearer_resource_modification_request_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* BEARER RESOURCE MODIFICATION REJECT
|
||||
******************************************************/
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<0)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REJECT_BACK_OFF_TIMER_VALUE_PRESENT (1<<1)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REJECT_RE_ATTEMPT_INDICATOR_PRESENT (1<<2)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REJECT_NBIFOM_CONTAINER_PRESENT (1<<3)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT (1<<4)
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REJECT_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x27
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REJECT_BACK_OFF_TIMER_VALUE_TYPE 0x37
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REJECT_RE_ATTEMPT_INDICATOR_TYPE 0x6B
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REJECT_NBIFOM_CONTAINER_TYPE 0x33
|
||||
#define NAS_BEARER_RESOURCE_MODIFICATION_REJECT_EXTENDED_PROTOCOL_CONFIGURATION_OPTIONS_TYPE 0x7B
|
||||
|
||||
typedef struct _nas_bearer_resource_modification_reject_t {
|
||||
/* Mandatory fields */
|
||||
nas_esm_cause_t esm_cause;
|
||||
|
||||
/* Optional fields */
|
||||
c_uint32_t presencemask;
|
||||
nas_protocol_configuration_options_t protocol_configuration_options;
|
||||
nas_gprs_timer_3_t back_off_timer_value;
|
||||
nas_re_attempt_indicator_t re_attempt_indicator;
|
||||
nas_nbifom_container_t nbifom_container;
|
||||
nas_extended_protocol_configuration_options_t extended_protocol_configuration_options;
|
||||
} nas_bearer_resource_modification_reject_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* ESM INFORMATION RESPONSE
|
||||
******************************************************/
|
||||
|
|
@ -997,6 +1333,16 @@ typedef struct _nas_esm_information_response_t {
|
|||
} nas_esm_information_response_t;
|
||||
|
||||
|
||||
/*******************************************************
|
||||
* ESM STATUS
|
||||
******************************************************/
|
||||
|
||||
typedef struct _nas_esm_status_t {
|
||||
/* Mandatory fields */
|
||||
nas_esm_cause_t esm_cause;
|
||||
} nas_esm_status_t;
|
||||
|
||||
|
||||
typedef struct _nas_emm_message_t {
|
||||
nas_emm_header_t h;
|
||||
union {
|
||||
|
|
@ -1037,11 +1383,24 @@ typedef struct _nas_esm_message_t {
|
|||
nas_activate_default_eps_bearer_context_request_t activate_default_eps_bearer_context_request;
|
||||
nas_activate_default_eps_bearer_context_accept_t activate_default_eps_bearer_context_accept;
|
||||
nas_activate_default_eps_bearer_context_reject_t activate_default_eps_bearer_context_reject;
|
||||
nas_activate_dedicated_eps_bearer_context_request_t activate_dedicated_eps_bearer_context_request;
|
||||
nas_activate_dedicated_eps_bearer_context_accept_t activate_dedicated_eps_bearer_context_accept;
|
||||
nas_activate_dedicated_eps_bearer_context_reject_t activate_dedicated_eps_bearer_context_reject;
|
||||
nas_modify_eps_bearer_context_request_t modify_eps_bearer_context_request;
|
||||
nas_modify_eps_bearer_context_accept_t modify_eps_bearer_context_accept;
|
||||
nas_modify_eps_bearer_context_reject_t modify_eps_bearer_context_reject;
|
||||
nas_deactivate_eps_bearer_context_request_t deactivate_eps_bearer_context_request;
|
||||
nas_deactivate_eps_bearer_context_accept_t deactivate_eps_bearer_context_accept;
|
||||
nas_pdn_connectivity_request_t pdn_connectivity_request;
|
||||
nas_pdn_connectivity_reject_t pdn_connectivity_reject;
|
||||
nas_pdn_disconnect_request_t pdn_disconnect_request;
|
||||
nas_pdn_disconnect_reject_t pdn_disconnect_reject;
|
||||
nas_bearer_resource_allocation_request_t bearer_resource_allocation_request;
|
||||
nas_bearer_resource_allocation_reject_t bearer_resource_allocation_reject;
|
||||
nas_bearer_resource_modification_request_t bearer_resource_modification_request;
|
||||
nas_bearer_resource_modification_reject_t bearer_resource_modification_reject;
|
||||
nas_esm_information_response_t esm_information_response;
|
||||
nas_esm_status_t esm_status;
|
||||
};
|
||||
} nas_esm_message_t;
|
||||
|
||||
|
|
|
|||
|
|
@ -1237,6 +1237,24 @@ ED4(c_uint8_t spare1:1;,
|
|||
c_uint8_t pdn_type:3;)
|
||||
} __attribute__ ((packed)) nas_request_type_t;
|
||||
|
||||
/* 9.9.4.15 Traffic flow aggregate description
|
||||
* see subclause 10.5.6.12 in 3GPP TS 24.008 [13]
|
||||
* M LV 2-256 */
|
||||
#define NAS_MAX_TRAFFIC_FLOW_AGGREGATE_DESCRIPTION 255
|
||||
typedef struct _nas_traffic_flow_aggregate_description_t {
|
||||
c_uint8_t length;
|
||||
c_uint8_t buffer[NAS_MAX_TRAFFIC_FLOW_AGGREGATE_DESCRIPTION];
|
||||
} __attribute__ ((packed)) nas_traffic_flow_aggregate_description_t;
|
||||
|
||||
/* 9.9.4.16 Traffic flow template
|
||||
* See subclause 10.5.6.12 in 3GPP TS 24.008 [13].
|
||||
* M LV 2-256 */
|
||||
#define NAS_MAX_TRAFFIC_FLOW_TEMPLATE 255
|
||||
typedef struct _nas_traffic_flow_template_t {
|
||||
c_uint8_t length;
|
||||
c_uint8_t buffer[NAS_MAX_TRAFFIC_FLOW_TEMPLATE];
|
||||
} __attribute__ ((packed)) nas_traffic_flow_template_t;
|
||||
|
||||
/* 9.9.4.17 Transaction identifier
|
||||
* 3GPP TS 24.008 [13], subclause 10.5.6.7.
|
||||
* O TLV 3-4 */
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -0,0 +1,14 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "", "value" : "Linked EPS bearer identity", "type" : "Linked EPS bearer identity", "reference" : "9.9.4.6", "presence" : "M", "format" : "V", "length" : "1/2"})
|
||||
ies.append({ "iei" : "", "value" : "EPS QoS", "type" : "EPS quality of service", "reference" : "9.9.4.3", "presence" : "M", "format" : "LV", "length" : "2-14"})
|
||||
ies.append({ "iei" : "", "value" : "TFT", "type" : "Traffic flow template", "reference" : "9.9.4.16", "presence" : "M", "format" : "LV", "length" : "2-256"})
|
||||
ies.append({ "iei" : "5D", "value" : "Transaction identifier", "type" : "Transaction identifier", "reference" : "9.9.4.17", "presence" : "O", "format" : "TLV", "length" : "3-4"})
|
||||
ies.append({ "iei" : "30", "value" : "Negotiated QoS", "type" : "Quality of service", "reference" : "9.9.4.12", "presence" : "O", "format" : "TLV", "length" : "14-22"})
|
||||
ies.append({ "iei" : "32", "value" : "Negotiated LLC SAPI", "type" : "LLC service access point identifier", "reference" : "9.9.4.7", "presence" : "O", "format" : "TV", "length" : "2"})
|
||||
ies.append({ "iei" : "8-", "value" : "Radio priority", "type" : "Radio priority", "reference" : "9.9.4.13", "presence" : "O", "format" : "TV", "length" : "1"})
|
||||
ies.append({ "iei" : "34", "value" : "Packet flow Identifier", "type" : "Packet flow Identifier", "reference" : "9.9.4.8", "presence" : "O", "format" : "TLV", "length" : "3"})
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "C-", "value" : "WLAN offload indication", "type" : "WLAN offload acceptability", "reference" : "9.9.4.18", "presence" : "O", "format" : "TV", "length" : "1"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV ", "length" : "3-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "", "value" : "ESM cause", "type" : "ESM cause", "reference" : "9.9.4.4", "presence" : "M", "format" : "V", "length" : "1"})
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "5B", "value" : "New EPS QoS", "type" : "EPS quality of service", "reference" : "9.9.4.3", "presence" : "O", "format" : "TLV", "length" : "3-15"})
|
||||
ies.append({ "iei" : "36", "value" : "TFT", "type" : "Traffic flow template", "reference" : "9.9.4.16", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "30", "value" : "New QoS", "type" : "Quality of service", "reference" : "9.9.4.12", "presence" : "O", "format" : "TLV", "length" : "14-22"})
|
||||
ies.append({ "iei" : "32", "value" : "Negotiated LLC SAPI", "type" : "LLC service access point identifier", "reference" : "9.9.4.7", "presence" : "O", "format" : "TV", "length" : "2"})
|
||||
ies.append({ "iei" : "8-", "value" : "Radio priority", "type" : "Radio priority", "reference" : "9.9.4.13", "presence" : "O", "format" : "TV", "length" : "1"})
|
||||
ies.append({ "iei" : "34", "value" : "Packet flow Identifier", "type" : "Packet flow Identifier", "reference" : "9.9.4.8", "presence" : "O", "format" : "TLV", "length" : "3"})
|
||||
ies.append({ "iei" : "5E", "value" : "APN-AMBR", "type" : "APN aggregate maximum bit rate", "reference" : "9.9.4.2", "presence" : "O", "format" : "TLV", "length" : "4-8"})
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "C-", "value" : "WLAN offload indication", "type" : "WLAN offload acceptability", "reference" : "9.9.4.18", "presence" : "O", "format" : "TV", "length" : "1"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "66", "value" : "Header compression configuration", "type" : "Header compression configuration", "reference" : "9.9.4.22", "presence" : "O", "format" : "TLV", "length" : "5-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "", "value" : "ESM cause", "type" : "ESM cause", "reference" : "9.9.4.4", "presence" : "M", "format" : "V", "length" : "1"})
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "", "value" : "ESM cause", "type" : "ESM cause", "reference" : "9.9.4.4", "presence" : "M", "format" : "V", "length" : "1"})
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "37", "value" : "T3396 value", "type" : "GPRS timer 3", "reference" : "9.9.3.16B", "presence" : "O", "format" : "TLV", "length" : "3"})
|
||||
ies.append({ "iei" : "C-", "value" : "WLAN offload indication", "type" : "WLAN offload acceptability", "reference" : "9.9.4.18", "presence" : "O", "format" : "TV", "length" : "1"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "", "value" : "Linked EPS bearer identity", "type" : "Linked EPS bearer identity", "reference" : "9.9.4.6", "presence" : "M", "format" : "V", "length" : "1/2"})
|
||||
ies.append({ "iei" : "", "value" : "Traffic flow aggregate", "type" : "Traffic flow aggregate description", "reference" : "9.9.4.15", "presence" : "M", "format" : "LV", "length" : "2-256"})
|
||||
ies.append({ "iei" : "", "value" : "Required traffic flow QoS", "type" : "EPS quality of service", "reference" : "9.9.4.3", "presence" : "M", "format" : "LV", "length" : "2-14"})
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "C-", "value" : "Device properties", "type" : "Device properties", "reference" : "9.9.2.0A", "presence" : "O", "format" : "TV", "length" : "1"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "", "value" : "ESM cause", "type" : "ESM cause", "reference" : "9.9.4.4", "presence" : "M", "format" : "V", "length" : "1"})
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "37", "value" : "Back-off timer value", "type" : "GPRS timer 3", "reference" : "9.9.3.16B", "presence" : "O", "format" : "TLV", "length" : "3"})
|
||||
ies.append({ "iei" : "6B", "value" : "Re-attempt indicator", "type" : "Re-attempt indicator", "reference" : "9.9.4.13A", "presence" : "O", "format" : "TLV", "length" : "3"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "", "value" : "EPS bearer identity for packet filter", "type" : "Linked EPS bearer identity", "reference" : "9.9.4.6", "presence" : "M", "format" : "V", "length" : "1/2"})
|
||||
ies.append({ "iei" : "", "value" : "Traffic flow aggregate", "type" : "Traffic flow aggregate description", "reference" : "9.9.4.15", "presence" : "M", "format" : "LV", "length" : "2-256"})
|
||||
ies.append({ "iei" : "5B", "value" : "Required traffic flow QoS", "type" : "EPS quality of service", "reference" : "9.9.4.3", "presence" : "O", "format" : "TLV", "length" : "3-15"})
|
||||
ies.append({ "iei" : "58", "value" : "ESM cause", "type" : "ESM cause", "reference" : "9.9.4.4", "presence" : "O", "format" : "TV", "length" : "2"})
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "C-", "value" : "Device properties", "type" : "Device properties", "reference" : "9.9.2.0A", "presence" : "O", "format" : "TV", "length" : "1"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "66", "value" : "Header compression configuration", "type" : "Header compression configuration", "reference" : "9.9.4.22", "presence" : "O", "format" : "TLV", "length" : "5-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "", "value" : "ESM cause", "type" : "ESM cause", "reference" : "9.9.4.4", "presence" : "M", "format" : "V", "length" : "1"})
|
||||
ies.append({ "iei" : "27", "value" : "Protocol configuration options", "type" : "Protocol configuration options", "reference" : "9.9.4.11", "presence" : "O", "format" : "TLV", "length" : "3-253"})
|
||||
ies.append({ "iei" : "37", "value" : "Back-off timer value", "type" : "GPRS timer 3", "reference" : "9.9.3.16B", "presence" : "O", "format" : "TLV", "length" : "3"})
|
||||
ies.append({ "iei" : "6B", "value" : "Re-attempt indicator", "type" : "Re-attempt indicator", "reference" : "9.9.4.13A", "presence" : "O", "format" : "TLV", "length" : "3"})
|
||||
ies.append({ "iei" : "33", "value" : "NBIFOM container", "type" : "NBIFOM container", "reference" : "9.9.4.19", "presence" : "O", "format" : "TLV", "length" : "3-257"})
|
||||
ies.append({ "iei" : "7B", "value" : "Extended protocol configuration options", "type" : "Extended protocol configuration options", "reference" : "9.9.4.26", "presence" : "O", "format" : "TLV-E", "length" : "4-65538"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
ies = []
|
||||
ies.append({ "iei" : "", "value" : "ESM cause", "type" : "ESM cause", "reference" : "9.9.4.4", "presence" : "M", "format" : "V", "length" : "1"})
|
||||
msg_list[key]["ies"] = ies
|
||||
|
|
@ -243,12 +243,24 @@ msg_list["UPLINK NAS TRANSPORT"]["table"] = 31
|
|||
msg_list["DOWNLINK GENERIC NAS TRANSPORT"]["table"] = 32
|
||||
msg_list["UPLINK GENERIC NAS TRANSPORT"]["table"] = 33
|
||||
|
||||
msg_list["ACTIVATE DEDICATED EPS BEARER CONTEXT ACCEPT"]["table"] = 36
|
||||
msg_list["ACTIVATE DEDICATED EPS BEARER CONTEXT REJECT"]["table"] = 37
|
||||
msg_list["ACTIVATE DEDICATED EPS BEARER CONTEXT REQUEST"]["table"] = 38
|
||||
msg_list["ACTIVATE DEFAULT EPS BEARER CONTEXT ACCEPT"]["table"] = 39
|
||||
msg_list["ACTIVATE DEFAULT EPS BEARER CONTEXT REJECT"]["table"] = 40
|
||||
msg_list["ACTIVATE DEFAULT EPS BEARER CONTEXT REQUEST"]["table"] = 41
|
||||
msg_list["BEARER RESOURCE ALLOCATION REJECT"]["table"] = 42
|
||||
msg_list["BEARER RESOURCE ALLOCATION REQUEST"]["table"] = 43
|
||||
msg_list["BEARER RESOURCE MODIFICATION REJECT"]["table"] = 44
|
||||
msg_list["BEARER RESOURCE MODIFICATION REQUEST"]["table"] = 45
|
||||
msg_list["DEACTIVATE EPS BEARER CONTEXT ACCEPT"]["table"] = 46
|
||||
msg_list["DEACTIVATE EPS BEARER CONTEXT REQUEST"]["table"] = 47
|
||||
msg_list["ESM INFORMATION REQUEST"]["table"] = 49
|
||||
msg_list["ESM INFORMATION RESPONSE"]["table"] = 50
|
||||
|
||||
msg_list["ESM STATUS"]["table"] = 51
|
||||
msg_list["MODIFY EPS BEARER CONTEXT ACCEPT"]["table"] = 52
|
||||
msg_list["MODIFY EPS BEARER CONTEXT REJECT"]["table"] = 53
|
||||
msg_list["MODIFY EPS BEARER CONTEXT REQUEST"]["table"] = 54
|
||||
msg_list["PDN CONNECTIVITY REJECT"]["table"] = 56
|
||||
msg_list["PDN CONNECTIVITY REQUEST"]["table"] = 57
|
||||
msg_list["PDN DISCONNECT REJECT"]["table"] = 58
|
||||
|
|
|
|||
Loading…
Reference in New Issue