diff -rupN freeDiameter-1.2.0/extensions/CMakeLists.txt freeDiameter-1.2.0.yang/extensions/CMakeLists.txt --- freeDiameter-1.2.0/extensions/CMakeLists.txt 2013-09-14 12:09:01.000000000 +0200 +++ freeDiameter-1.2.0.yang/extensions/CMakeLists.txt 2015-03-17 15:47:15.237308388 +0100 @@ -36,6 +36,7 @@ INCLUDE_DIRECTORIES(${LFDCORE_INCLUDES}) #### # Diameter applications dictionaries +FD_EXTENSION_SUBDIR(dict_s6a "3GPP S6A TS.29.279-990" ON) FD_EXTENSION_SUBDIR(dict_nasreq "NASREQ (RFC4005) Dictionary definitions" ON) FD_EXTENSION_SUBDIR(dict_eap "Diameter EAP (RFC4072) Dictionary definitions" ON) diff -rupN freeDiameter-1.2.0/extensions/dict_s6a/CMakeLists.txt freeDiameter-1.2.0.yang/extensions/dict_s6a/CMakeLists.txt --- freeDiameter-1.2.0/extensions/dict_s6a/CMakeLists.txt 1970-01-01 01:00:00.000000000 +0100 +++ freeDiameter-1.2.0.yang/extensions/dict_s6a/CMakeLists.txt 2015-03-17 15:22:46.729309000 +0100 @@ -0,0 +1,14 @@ +# The dict_rfc5777 extension +PROJECT("S6a protocol based on 3GPP 29.272-990" C) + +# Compile as a module +FD_ADD_EXTENSION(dict_s6a dict_s6a.c) + + +#### +## INSTALL section ## + +INSTALL(TARGETS dict_s6a + LIBRARY DESTINATION ${INSTALL_EXTENSIONS_SUFFIX} + COMPONENT freeDiameter-dictionary-s6a) + diff -rupN freeDiameter-1.2.0/extensions/dict_s6a/dict_s6a.c freeDiameter-1.2.0.yang/extensions/dict_s6a/dict_s6a.c --- freeDiameter-1.2.0/extensions/dict_s6a/dict_s6a.c 1970-01-01 01:00:00.000000000 +0100 +++ freeDiameter-1.2.0.yang/extensions/dict_s6a/dict_s6a.c 2015-03-17 15:22:46.729309000 +0100 @@ -0,0 +1,4212 @@ +/********************************************************************************************************* +* Software License Agreement (BSD License) * +* Author: Sebastien ROUX * +* * +* Copyright (c) 2013, Eurecom * +* All rights reserved. * +* * +* Redistribution and use of this software in source and binary forms, with or without modification, are * +* permitted provided that the following conditions are met: * +* * +* * Redistributions of source code must retain the above * +* copyright notice, this list of conditions and the * +* following disclaimer. * +* * +* * Redistributions in binary form must reproduce the above * +* copyright notice, this list of conditions and the * +* following disclaimer in the documentation and/or other * +* materials provided with the distribution. * +* * +* * Neither the name of the Teraoka Laboratory nor the * +* names of its contributors may be used to endorse or * +* promote products derived from this software without * +* specific prior written permission of Teraoka Laboratory * +* * +* * +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED * +* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * +* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR * +* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * +* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR * +* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * +* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * +*********************************************************************************************************/ + +#include + +/* The content of this file follows the same structure as dict_base_proto.c */ + +#define CHECK_dict_new( _type, _data, _parent, _ref ) \ + CHECK_FCT( fd_dict_new( fd_g_config->cnf_dict, (_type), (_data), (_parent), (_ref)) ); + +#define CHECK_dict_search( _type, _criteria, _what, _result ) \ + CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, (_type), (_criteria), (_what), (_result), ENOENT) ); + +struct local_rules_definition { + char *avp_name; + enum rule_position position; + int min; + int max; +}; + +#define RULE_ORDER( _position ) ((((_position) == RULE_FIXED_HEAD) || ((_position) == RULE_FIXED_TAIL)) ? 1 : 0 ) + +#define PARSE_loc_rules( _rulearray, _parent) { \ + int __ar; \ + for (__ar=0; __ar < sizeof(_rulearray) / sizeof((_rulearray)[0]); __ar++) { \ + struct dict_rule_data __data = { NULL, \ + (_rulearray)[__ar].position, \ + 0, \ + (_rulearray)[__ar].min, \ + (_rulearray)[__ar].max}; \ + __data.rule_order = RULE_ORDER(__data.rule_position); \ + CHECK_FCT( fd_dict_search( \ + fd_g_config->cnf_dict, \ + DICT_AVP, \ + AVP_BY_NAME_ALL_VENDORS, \ + (_rulearray)[__ar].avp_name, \ + &__data.rule_avp, 0 ) ); \ + if ( !__data.rule_avp ) { \ + TRACE_DEBUG(INFO, "AVP Not found: '%s'", (_rulearray)[__ar].avp_name ); \ + return ENOENT; \ + } \ + CHECK_FCT_DO( fd_dict_new( fd_g_config->cnf_dict, DICT_RULE, &__data, _parent, NULL), \ + { \ + TRACE_DEBUG(INFO, "Error on rule with AVP '%s'", \ + (_rulearray)[__ar].avp_name ); \ + return EINVAL; \ + } ); \ + } \ +} + +#define enumval_def_u32( _val_, _str_ ) \ + { _str_, { .u32 = _val_ }} + +#define enumval_def_os( _len_, _val_, _str_ ) \ + { _str_, { .os = { .data = (unsigned char *)_val_, .len = _len_ }}} + +/* Defines if there are any */ + +/* Dictionary */ + +int dict_s6a_init(char * conffile) +{ +#define VENDOR_3GPP_Id 10415 + + TRACE_ENTRY("%p", conffile); + + struct dict_object * vendor_dict; + { + struct dict_vendor_data vendor_data = { VENDOR_3GPP_Id, "3GPP" }; + CHECK_dict_new (DICT_VENDOR, &vendor_data, NULL, &vendor_dict); + } + + struct dict_object * s6a_dict; + { + struct dict_application_data data = { 16777251, "Diameter S6a 3GPP" }; + CHECK_dict_new( DICT_APPLICATION, &data , NULL, &s6a_dict); + } + + /* AVP section */ + { + /* Loading the derived data formats */ + + struct dict_object * Time_type; + struct dict_object * Address_type; + struct dict_object * UTF8String_type; + + CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Time", &Time_type); + CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Address", &Address_type); + CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "UTF8String", &UTF8String_type); + + /* 3GPP-Charging-Characteristics */ + { + struct dict_avp_data data = { + 13, /* Code */ + 0, /* Vendor */ + "3GPP-Charging-Characteristics", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , UTF8String_type, NULL); + } + + /* Service-Selection - RFC 5778 */ + { + struct dict_avp_data data = { + 493, /* Code */ + VENDOR_3GPP_Id, /* Vendor , EURECOM: with FD 1.2.0 does not work if vendor ID is 0 for this AVP*/ + "Service-Selection", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , UTF8String_type, NULL); + } + + /* Max-Requested-Bandwidth-DL AVP - 3GPP TS 29.214 #5.3.14 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 515, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Max-Requested-Bandwidth-DL", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Max-Requested-Bandwidth-UL AVP - 3GPP TS 29.214 #5.3.15 */ + { + struct dict_avp_data data = { + 516, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Max-Requested-Bandwidth-UL", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, NULL); + } + + /* Visited-Network-Identifier AVP - 3GPP TS 29.229 #6.3.1 */ + { + struct dict_avp_data data = { + 600, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Visited-Network-Identifier", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Confidentiality-Key AVP - 3GPP TS 29.229 #6.3.27 */ + { + struct dict_avp_data data = { + 625, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Confidentiality-Key", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Integrity-Key AVP - 3GPP TS 29.229 #6.3.28 */ + { + struct dict_avp_data data = { + 626, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Integrity-Key", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Feature-List-ID AVP - 3GPP TS 29.229 #6.3.29 */ + { + struct dict_avp_data data = { + 629, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Feature-List-ID", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Feature-List AVP - 3GPP TS 29.229 #6.3.30 */ + { + struct dict_avp_data data = { + 630, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Feature-List", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* MSISDN AVP - 3GPP TS 29.329 #6.3.2 */ + { + struct dict_avp_data data = { + 701, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "MSISDN", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Served-Party-IP-Address AVP - 3GPP TS 32.299 #7.2.187 + * The Served-Party-IP-Address AVP (AVP code 848) is of type Address + * and holds the IP address of either the calling or called party, + * depending on whether the P-CSCF is in touch with the calling or the + * called party. This AVP is only provided by the P-CSCF. + */ + { + struct dict_avp_data data = { + 848, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Served-Party-IP-Address", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , Address_type, NULL); + } + + /* QoS-Class-Identifier AVP - 3GPP TS 29.212 #5.3.17 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(QoS-Class-Identifier)" , NULL, NULL, NULL }; + struct dict_enumval_data t_1 = { "QCI_1", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "QCI_2", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "QCI_3", { .i32 = 3 }}; + struct dict_enumval_data t_4 = { "QCI_4", { .i32 = 4 }}; + struct dict_enumval_data t_5 = { "QCI_5", { .i32 = 5 }}; + struct dict_enumval_data t_6 = { "QCI_6", { .i32 = 6 }}; + struct dict_enumval_data t_7 = { "QCI_7", { .i32 = 7 }}; + struct dict_enumval_data t_8 = { "QCI_8", { .i32 = 8 }}; + struct dict_enumval_data t_9 = { "QCI_9", { .i32 = 9 }}; + + struct dict_avp_data data = { + 1028, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "QoS-Class-Identifier", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata, NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_1, avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2, avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3, avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_4, avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_5, avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_6, avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_7, avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_8, avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_9, avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* RAT-Type AVP - 3GPP TS 29.212 #5.3.31 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_UNSIGNED32, "Enumerated(RAT-Type)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "WLAN", { .u32 = 0 }}; + struct dict_enumval_data t_1 = { "VIRTUAL", { .u32 = 1 }}; + struct dict_enumval_data t_1000 = { "UTRAN", { .u32 = 1000 }}; + struct dict_enumval_data t_1001 = { "GERAN", { .u32 = 1001 }}; + struct dict_enumval_data t_1002 = { "GAN", { .u32 = 1002 }}; + struct dict_enumval_data t_1003 = { "HSPA_EVOLUTION", { .u32 = 1003 }}; + struct dict_enumval_data t_1004 = { "EUTRAN", { .u32 = 1004 }}; + struct dict_enumval_data t_2000 = { "CDMA2000_1X", { .u32 = 2000 }}; + struct dict_enumval_data t_2001 = { "HRPD", { .u32 = 2001 }}; + struct dict_enumval_data t_2002 = { "UMB", { .u32 = 2002 }}; + struct dict_enumval_data t_2003 = { "EHRPD", { .u32 = 2003 }}; + + struct dict_avp_data data = { + 1032, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "RAT-Type", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1000 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1001 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1002 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1003 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1004 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2000 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2001 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2002 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2003 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Priority-Level AVP - 3GPP TS 29.272 #5.3.45 */ + { + struct dict_avp_data data = { + 1046, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Priority-Level", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Pre-emption-Capability AVP - 3GPP TS 29.212 #5.3.46 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Pre-emption-Capability)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "PRE-EMPTION_CAPABILITY_ENABLED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "PRE-EMPTION_CAPABILITY_DISABLED", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1047, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Pre-emption-Capability", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Pre-emption-Vulnerability AVP - 3GPP TS 29.212 #5.3.47 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Pre-emption-Vulnerability)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "PRE-EMPTION_VULNERABILITY_ENABLED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "PRE-EMPTION_VULNERABILITY_DISABLED", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1048, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Pre-emption-Vulnerability", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Allocation-Retention-Priority AVP - 3GPP TS 29.272 #5.3.32 */ + { + /* + + Allocation-Retention-Priority ::= < AVP Header: 1034 > + { Priority-Level } + [ Pre-emption-Capability ] + [ Pre-emption-Vulnerability ] + + The Allocation-Retention-Priority AVP (AVP code 1034) is of type + Grouped, and it is used to indicate the priority of allocation and + retention, the pre-emption capability and pre-emption vulnerability + for the SDF if provided within the QoS-Information-AVP or for the + EPS default bearer if provided within the Default-EPS-Bearer-QoS AVP. + */ + struct dict_object * avp; + struct dict_avp_data data = { + 1034, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Allocation-Retention-Priority", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Priority-Level", RULE_REQUIRED, -1, 1 } + ,{ "Pre-emption-Capability", RULE_OPTIONAL, -1, 1 } + ,{ "Pre-emption-Vulnerability", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* PDP-Address AVP - 3GPP TS 32.299 #6.3.2 */ + { + /* + * The PDP-Address-Prefix-Length AVP needs not be available for IPv6 + * typed IP-address prefix length of 64 bits. + */ + struct dict_avp_data data = { + 1227, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "PDP-Address", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , Address_type, NULL); + } + + /* Subscriber-Status - 3GPP TS 29.272 #7.3.29 */ + { + struct dict_object * type; + struct dict_type_data tdata = { AVP_TYPE_UNSIGNED32, "Enumerated(Subscriber-Status)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "SERVICE_GRANTED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "OPERATOR_DETERMINED_BARRING", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1424, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Subscriber-Status", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type); + CHECK_dict_new( DICT_ENUMVAL, &t_0, type, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL); + CHECK_dict_new( DICT_AVP, &data, NULL, &type); + } + + /* STN-SR AVP - 3GPP TS 29.272 #7.3.33 */ + { + struct dict_avp_data data = { + 1433, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "STN-SR", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , UTF8String_type, NULL); + } + + /* ICS-Indicator AVP - 3GPP TS 29.272 #7.3.104 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(ICS-Indicator)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "FALSE", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "TRUE", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1491, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "ICS-Indicator", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* IMEI AVP - 3GPP TS 29.272 #7.3.4 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1402, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "IMEI", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , UTF8String_type, &avp); + } + + /* 3GPP2-MEID AVP - 3GPP TS 29.272 #7.3.6 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1471, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "3GPP2-MEID", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* Software Version - 3GPP TS 29.272 #7.3.5 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1403, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Software-Version", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , UTF8String_type, &avp); + } + + /* Terminal Information AVP - 3GPP TS 29.272 #7.3.3 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1401, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Terminal-Information", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "IMEI", RULE_REQUIRED, 1, 1 } + ,{ "3GPP2-MEID", RULE_REQUIRED, 1, 1 } + ,{ "Software-Version", RULE_REQUIRED, 1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* ULA-Flags - 3GPP TS 29.272 #7.3.8 */ + { + struct dict_avp_data data = { + 1406, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "ULA-Flags", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Visited-PLMN-Id AVP - 3GPP TS 29.272 #7.3.9 */ + { + struct dict_avp_data data = { + 1407, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Visited-PLMN-Id", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Number-Of-Requested-Vectors - 3GPP TS 29.272 #7.3.14 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1410, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Number-Of-Requested-Vectors", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Re-Synchronization-Info - 3GPP TS 29.272 #7.3.15 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1411, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Re-Synchronization-Info", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Immediate-Response-Preferred - 3GPP TS 29.272 #7.3.16 */ + { + struct dict_avp_data data = { + 1412, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Immediate-Response-Preferred", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Requested-EUTRAN-Authentication-Info AVP - 3GPP TS 29.272 #7.3.11 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1408, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Requested-EUTRAN-Authentication-Info", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Number-Of-Requested-Vectors", RULE_OPTIONAL, -1, 1 } + ,{ "Immediate-Response-Preferred", RULE_OPTIONAL, -1, 1 } + ,{ "Re-Synchronization-Info", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Requested-UTRAN-GERAN-Authentication-Info AVP - 3GPP TS 29.272 #7.3.12 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1409, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Requested-UTRAN-GERAN-Authentication-Info", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Number-Of-Requested-Vectors", RULE_OPTIONAL, -1, 1 } + ,{ "Immediate-Response-Preferred", RULE_OPTIONAL, -1, 1 } + ,{ "Re-Synchronization-Info", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Item-Number AVP - 3GPP TS 29.272 #7.3.23 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1419, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Item-Number", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* RAND AVP - 3GPP TS 29.272 #7.3.53 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1447, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "RAND", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* XRES AVP - 3GPP TS 29.272 #7.3.54 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1448, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "XRES", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* AUTN AVP - 3GPP TS 29.272 #7.3.55 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1449, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "AUTN", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* SRES AVP - 3GPP TS 29.272 #7.3.60 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1454, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "SRES", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* KASME AVP - 3GPP TS 29.272 #7.3.56 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1450, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "KASME", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Kc AVP - 3GPP TS 29.272 #7.3.59 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1453, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Kc", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* Trace-Collection-Entity AVP - 3GPP TS 29.272 #7.3.96 */ + { + struct dict_avp_data data = { + 1452, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Trace-Collection-Entity", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, Address_type, NULL); + } + + /* E-UTRAN-Vector - 3GPP TS 29.272 #7.3.18 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1414, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "E-UTRAN-Vector", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Item-Number", RULE_OPTIONAL, -1, 1 } + ,{ "RAND", RULE_REQUIRED, -1, 1 } + ,{ "XRES", RULE_REQUIRED, -1, 1 } + ,{ "AUTN", RULE_REQUIRED, -1, 1 } + ,{ "KASME", RULE_REQUIRED, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* UTRAN-Vector - 3GPP TS 29.272 #7.3.19 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1415, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "UTRAN-Vector", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Item-Number", RULE_OPTIONAL, -1, 1 } + ,{ "RAND", RULE_REQUIRED, -1, 1 } + ,{ "XRES", RULE_REQUIRED, -1, 1 } + ,{ "AUTN", RULE_REQUIRED, -1, 1 } + ,{ "Confidentiality-Key", RULE_REQUIRED, -1, 1 } + ,{ "Integrity-Key", RULE_REQUIRED, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* GERAN-Vector - 3GPP TS 29.272 #7.3.20 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1416, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "GERAN-Vector", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Item-Number", RULE_OPTIONAL, -1, 1 } + ,{ "RAND", RULE_REQUIRED, -1, 1 } + ,{ "SRES", RULE_REQUIRED, -1, 1 } + ,{ "Kc", RULE_REQUIRED, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Authentication-Info - 3GPP TS 29.272 #7.3.17 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1413, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Authentication-Info", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "E-UTRAN-Vector", RULE_OPTIONAL, -1, -1 } + ,{ "UTRAN-Vector", RULE_OPTIONAL, -1, -1 } + ,{ "GERAN-Vector", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Network-Access-Mode - 3GPP TS 29.272 #7.3.21 */ + { + struct dict_object * type; + struct dict_type_data tdata = { AVP_TYPE_UNSIGNED32, "Enumerated(Network-Access-Mode)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "PACKET_AND_CIRCUIT", { .u32 = 0 }}; + struct dict_enumval_data t_1 = { "ONLY_PACKET", { .u32 = 1 }}; + + struct dict_avp_data data = { + 1417, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Network-Access-Mode", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &type); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , type, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , type, NULL); + CHECK_dict_new( DICT_AVP, &data , type, NULL); + } + + /* HPLMN-ODB AVP - 3GPP TS 29.272 #7.3.22 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1418, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "HPLMN-ODB", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Cancellation-Type - 3GPP TS 29.272 #7.3.24 */ + { + struct dict_object * type; + struct dict_type_data tdata = { AVP_TYPE_UNSIGNED32, "Enumerated(Cancellation-Type)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "MME_UPDATE_PROCEDURE", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "SGSN_UPDATE_PROCEDURE", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "SUBSCRIPTION_WITHDRAWAL", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "UPDATE_PROCEDURE_IWF", { .i32 = 3 }}; + struct dict_enumval_data t_4 = { "INITIAL_ATTACH_PROCEDURE", { .i32 = 4 }}; + + struct dict_avp_data data = { + 1420, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Cancellation-Type", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type); + CHECK_dict_new( DICT_ENUMVAL, &t_0, type, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_4, type, NULL); + CHECK_dict_new( DICT_AVP, &data, NULL, &type); + } + + /* DSR-Flags AVP - 3GPP TS 29.272 #7.3.25 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1421, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "DSR-Flags", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* DSA-Flags AVP - 3GPP TS 29.272 #7.3.26 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1422, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "DSA-Flags", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Context-Identifier AVP - 3GPP TS 29.272 #7.3.27 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1423, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Context-Identifier", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Operator-Determined-Barring AVP - 3GPP TS 29.272 #7.3.30 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1425, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Operator-Determined-Barring", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Access-Restriction-Data AVP - 3GPP TS 29.272 #7.3.31 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1426, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Access-Restriction-Data", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* APN-OI-Replacement AVP - 3GPP TS 29.272 #7.3.32 */ + { + struct dict_avp_data data = { + 1427, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "APN-OI-Replacement", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , UTF8String_type, NULL); + } + + /* All-APN-Configurations-Included-Indicator AVP - 3GPP TS 29.272 #7.3.33 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(All-APN-Configurations-Included-Indicator)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "All_APN_CONFIGURATIONS_INCLUDED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "MODIFIED/ADDED_APN_CONFIGURATIONS_INCLUDED", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1428, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "All-APN-Configurations-Included-Indicator", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* PDN-Type AVP - 3GPP TS 29.272 #7.3.62 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(PDN-Type)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "IPv4", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "IPv6", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "IPv4v6", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "IPv4_OR_IPv6", { .i32 = 3 }}; + + struct dict_avp_data data = { + 1456, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "PDN-Type", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* EPS-Subscribed-QoS-Profile AVP - 3GPP TS 29.272 #7.3.37 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1431, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "EPS-Subscribed-QoS-Profile", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "QoS-Class-Identifier", RULE_REQUIRED, -1, 1 } + ,{ "Allocation-Retention-Priority", RULE_REQUIRED, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* VPLMN-Dynamic-Address-Allowed AVP - 3GPP TS 29.272 #7.3.38 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(VPLMN-Dynamic-Address-Allowed)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "NOTALLOWED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "ALLOWED", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1432, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "VPLMN-Dynamic-Address-Allowed", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* Alert-Reason AVP - 3GPP TS 29.272 #7.3.83 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Alert-Reason)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "UE_PRESENT", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "UE_MEMORY_AVAILABLE", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1434, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Alert-Reason", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* PDN-GW-Allocation-Type AVP - 3GPP TS 29.272 #7.3.44 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(PDN-GW-Allocation-Type)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "STATIC", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "DYNAMIC", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1438, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "PDN-GW-Allocation-Type", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* Expiration-Date AVP - 3GPP TS 29.272 #7.3.80 */ + { + struct dict_avp_data data = { + 1439, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Expiration-Date", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , Time_type, NULL); + } + + /* CSG-Id AVP - 3GPP TS 29.272 #7.3.79 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1437, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "CSG-Id", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* AMBR AVP - 3GPP TS 29.272 #7.3.41 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1435, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "AMBR", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Max-Requested-Bandwidth-UL", RULE_REQUIRED, -1, 1 } + ,{ "Max-Requested-Bandwidth-DL", RULE_REQUIRED, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Specific-APN-Info AVP - 3GPP TS 29.272 #7.3.82 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1472, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Specific-APN-Info", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Service-Selection", RULE_REQUIRED, -1, 1 } + ,{ "MIP6-Agent-Info", RULE_REQUIRED, -1, 1 } + ,{ "Visited-Network-Identifier", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* SIPTO-Permission AVP - 3GPP TS 29.272 #7.3.135 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(SIPTO-Permission)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "SIPTO_ALLOWED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "SIPTO_NOTALLOWED", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1613, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "SIPTO-Permission", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* LIPA-Permission AVP - 3GPP TS 29.272 #7.3.133 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(LIPA-Permission)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "LIPA-PROHIBITED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "LIPA-ONLY", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "LIPA-CONDITIONAL", { .i32 = 2 }}; + + struct dict_avp_data data = { + 1618, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "LIPA-Permission", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* List-Of-Measurements AVP - 3GPP TS 29.272 #7.3.139 */ + { + struct dict_avp_data data = { + 1625, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "List-Of-Measurements", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Reporting-Trigger AVP - 3GPP TS 29.272 #7.3.140 */ + { + struct dict_avp_data data = { + 1626, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Reporting-Trigger", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Report-Interval AVP - 3GPP TS 29.272 #7.3.141 and TS 32.422 #5.10.5 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Report-Interval)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "250ms", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "500ms", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "1000ms", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "2000ms", { .i32 = 3 }}; + struct dict_enumval_data t_4 = { "3000ms", { .i32 = 4 }}; + struct dict_enumval_data t_5 = { "4000ms", { .i32 = 5 }}; + struct dict_enumval_data t_6 = { "6000ms", { .i32 = 6 }}; + struct dict_enumval_data t_7 = { "8000ms", { .i32 = 7 }}; + struct dict_enumval_data t_8 = { "12000ms", { .i32 = 8 }}; + struct dict_enumval_data t_9 = { "16000ms", { .i32 = 9 }}; + struct dict_enumval_data t_10 = { "20000ms", { .i32 = 10 }}; + struct dict_enumval_data t_11 = { "24000ms", { .i32 = 11 }}; + struct dict_enumval_data t_12 = { "28000ms", { .i32 = 12 }}; + struct dict_enumval_data t_13 = { "32000ms", { .i32 = 13 }}; + struct dict_enumval_data t_14 = { "64000ms", { .i32 = 14 }}; + /* Possible in LTE */ + struct dict_enumval_data t_15 = { "120ms", { .i32 = 15 }}; + struct dict_enumval_data t_16 = { "240ms", { .i32 = 16 }}; + struct dict_enumval_data t_17 = { "480ms", { .i32 = 17 }}; + struct dict_enumval_data t_18 = { "640ms", { .i32 = 18 }}; + struct dict_enumval_data t_19 = { "1024ms", { .i32 = 19 }}; + struct dict_enumval_data t_20 = { "2048ms", { .i32 = 20 }}; + struct dict_enumval_data t_21 = { "5120ms", { .i32 = 21 }}; + struct dict_enumval_data t_22 = { "10240ms", { .i32 = 22 }}; + struct dict_enumval_data t_23 = { "1min", { .i32 = 23 }}; + struct dict_enumval_data t_24 = { "6min", { .i32 = 24 }}; + struct dict_enumval_data t_25 = { "12min", { .i32 = 25 }}; + struct dict_enumval_data t_26 = { "30min", { .i32 = 26 }}; + struct dict_enumval_data t_27 = { "60min", { .i32 = 27 }}; + + struct dict_avp_data data = { + 1627, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Report-Interval", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_6 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_7 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_8 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_9 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_10 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_11 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_12 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_13 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_14 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_15 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_16 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_17 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_18 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_19 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_20 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_21 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_22 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_23 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_24 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_25 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_26 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_27 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* Report-Amount AVP - 3GPP TS 29.272 #7.3.142 and TS 32.422 #5.10.6 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Report-Amount)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "1", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "2", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "4", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "8", { .i32 = 3 }}; + struct dict_enumval_data t_4 = { "16", { .i32 = 4 }}; + struct dict_enumval_data t_5 = { "32", { .i32 = 5 }}; + struct dict_enumval_data t_6 = { "64", { .i32 = 6 }}; + struct dict_enumval_data t_7 = { "infinity", { .i32 = 7 }}; + + struct dict_avp_data data = { + 1628, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Report-Amount", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_6 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_7 , avp, NULL); + + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* Event-Threshold-RSRP AVP - 3GPP TS 29.272 #7.3.143 */ + { + struct dict_avp_data data = { + 1629, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Event-Threshold-RSRP", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Event-Threshold-RSRQ AVP - 3GPP TS 29.272 #7.3.144 */ + { + struct dict_avp_data data = { + 1630, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Event-Threshold-RSRQ", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Logging-Interval AVP - 3GPP TS 29.272 #7.3.145 and TS 32.422 #5.10.8 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Logging-Interval)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "1.28", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "2.56", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "5.12", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "10.24", { .i32 = 3 }}; + struct dict_enumval_data t_4 = { "20.48", { .i32 = 4 }}; + struct dict_enumval_data t_5 = { "30.72", { .i32 = 5 }}; + struct dict_enumval_data t_6 = { "40.96", { .i32 = 6 }}; + struct dict_enumval_data t_7 = { "61.44", { .i32 = 7 }}; + + struct dict_avp_data data = { + 1631, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Logging-Interval", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_6 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_7 , avp, NULL); + + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* Logging-Duration AVP - 3GPP TS 29.272 #7.3.145 and TS 32.422 #5.10.9 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Logging-Duration)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "600sec", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "1200sec", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "2400sec", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "3600sec", { .i32 = 3 }}; + struct dict_enumval_data t_4 = { "5400sec", { .i32 = 4 }}; + struct dict_enumval_data t_5 = { "7200sec", { .i32 = 5 }}; + + struct dict_avp_data data = { + 1632, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Logging-Duration", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL); + + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* APN-Configuration AVP - 3GPP TS 29.272 #7.3.35 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1430, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "APN-Configuration", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Context-Identifier", RULE_REQUIRED, -1, 1 } + ,{ "Served-Party-IP-Address", RULE_OPTIONAL, -1, 2 } + ,{ "PDN-Type", RULE_REQUIRED, -1, 1 } + ,{ "Service-Selection", RULE_REQUIRED, -1, 1 } + ,{ "EPS-Subscribed-QoS-Profile", RULE_OPTIONAL, -1, 1 } + ,{ "VPLMN-Dynamic-Address-Allowed", RULE_OPTIONAL, -1, 1 } + ,{ "MIP6-Agent-Info", RULE_OPTIONAL, -1, 1 } + ,{ "Visited-Network-Identifier", RULE_OPTIONAL, -1, 1 } + ,{ "PDN-GW-Allocation-Type", RULE_OPTIONAL, -1, 1 } + ,{ "3GPP-Charging-Characteristics", RULE_OPTIONAL, -1, 1 } + ,{ "AMBR", RULE_OPTIONAL, -1, 1 } + ,{ "Specific-APN-Info", RULE_OPTIONAL, -1, -1 } + ,{ "APN-OI-Replacement", RULE_OPTIONAL, -1, 1 } + ,{ "SIPTO-Permission", RULE_OPTIONAL, -1, 1 } + ,{ "LIPA-Permission", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* APN-Configuration-Profile AVP - 3GPP TS 29.272 #7.3.34 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1429, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "APN-Configuration-Profile", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Context-Identifier", RULE_REQUIRED, -1, 1 } + ,{ "All-APN-Configurations-Included-Indicator", RULE_REQUIRED, -1, 1 } + ,{ "APN-Configuration", RULE_REQUIRED, -1, -1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* CSG-Subscription-Data AVP - 3GPP TS 29.272 #7.3.78 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1436, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "CSG-Subscription-Data", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "CSG-Id", RULE_REQUIRED, -1, 1 } + ,{ "Expiration-Date", RULE_OPTIONAL, -1, 1 } + ,{ "Service-Selection", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* RAT-Frequency-Selection-Priority-ID AVP - 3GPP TS 29.272 #7.3.46 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1440, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "RAT-Frequency-Selection-Priority-ID", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* IDA-Flags AVP - 3GPP TS 29.272 #7.3.47 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1441, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "IDA-Flags", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* PUA-Flags AVP - 3GPP TS 29.272 #7.3.48 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1442, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "PUA-Flags", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* NOR-Flags AVP - 3GPP TS 29.272 #7.3.49 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1443, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "NOR-Flags", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* User-Id AVP - 3GPP TS 29.272 #7.3.50 */ + { + struct dict_avp_data data = { + 1444, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "User-Id", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , UTF8String_type, NULL); + } + + /* Equipment-Status AVP - 3GPP TS 29.272 #7.3.51 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Equipment-Status)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "WHITELISTED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "BLACKLISTED", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "GREYLISTED", { .i32 = 2 }}; + + struct dict_avp_data data = { + 1445, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Equipment-Status", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* Regional-Subscription-Zone-Code AVP - 3GPP TS 29.272 #7.3.52 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1446, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Regional-Subscription-Zone-Code", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Roaming-Restricted-Due-To-Unsupported-Feature AVP - 3GPP TS 29.272 #7.3.81 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Roaming-Restricted-Due-To-Unsupported-Feature)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "Roaming-Restricted-Due-To-Unsupported-Feature", { .i32 = 0 }}; + + struct dict_avp_data data = { + 1457, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Roaming-Restricted-Due-To-Unsupported-Feature", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* Trace-Reference AVP - 3GPP TS 29.272 #7.3.64 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1459, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Trace-Reference", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* Trace-Depth AVP - 3GPP TS 29.272 #7.3.67 and 3GPP TS 32.422 #5.3 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Trace-Depth)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "Minimum", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "Medium", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "Maximum", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "MinimumWithoutVendorSpecificExtension", { .i32 = 3 }}; + struct dict_enumval_data t_4 = { "MediumWithoutVendorSpecificExtension", { .i32 = 4 }}; + struct dict_enumval_data t_5 = { "MaximumWithoutVendorSpecificExtension", { .i32 = 5 }}; + + struct dict_avp_data data = { + 1462, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Trace-Depth", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* Trace-NE-Type-List AVP - 3GPP TS 29.272 #7.3.68 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1463, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Trace-NE-Type-List", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* Trace-Event-List AVP - 3GPP TS 29.272 #7.3.69 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1464, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Trace-Interface-List", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* Trace-Event-List AVP - 3GPP TS 29.272 #7.3.70 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1465, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Trace-Event-List", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* OMC-Id AVP - 3GPP TS 29.272 #7.3.71 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1466, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "OMC-Id", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* Complete-Data-List-Included-Indicator AVP - 3GPP TS 29.272 #7.3.73 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Complete-Data-List-Included-Indicator)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "All_PDP_CONTEXTS_INCLUDED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "MODIFIED/ADDED_PDP CONTEXTS_INCLUDED", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1468, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Complete-Data-List-Included-Indicator", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* PDP-Type AVP - 3GPP TS 29.272 #7.3.75 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1470, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "PDP-Type", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* GMLC-Number AVP - 3GPP TS 29.272 #7.3.85 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1474, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "GMLC-Number", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* SS-Code AVP - 3GPP TS 29.272 #7.3.87 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1476, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "SS-Code", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* SS-Status AVP - 3GPP TS 29.272 #7.3.88 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1477, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "SS-Status", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* Notification-To-UE-User AVP - 3GPP TS 29.272 #7.3.89 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Notification-To-UE-User)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "NOTIFY_LOCATION_ALLOWED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "NOTIFYANDVERIFY_LOCATION_ALLOWED_IF_NO_RESPONSE", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "NOTIFYANDVERIFY_LOCATION_NOT_ALLOWED_IF_NO_RESPONSE", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "LOCATION_NOT_ALLOWED", { .i32 = 3 }}; + + struct dict_avp_data data = { + 1478, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Notification-To-UE-User", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* Client-Identity AVP - 3GPP TS 29.272 #7.3.91 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1480, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Client-Identity", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* GMLC-Restriction AVP - 3GPP TS 29.272 #7.3.92 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(GMLC-Restriction)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "GMLC_LIST", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "HOME_COUNTRY", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1481, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "GMLC-Restriction", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* PLMN-Client AVP - 3GPP TS 29.272 #7.3.92 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(PLMN-Client)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "BROADCAST_SERVICE", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "O_AND_M_HPLMN", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "O_AND_M_VPLMN", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "ANONYMOUS_LOCATION", { .i32 = 3 }}; + struct dict_enumval_data t_4 = { "TARGET_UE_SUBSCRIBED_SERVICE", { .i32 = 4 }}; + + struct dict_avp_data data = { + 1482, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "PLMN-Client", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* ServiceTypeIdentity AVP - 3GPP TS 29.272 #7.3.95 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1484, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "ServiceTypeIdentity", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + } + + /* QoS-Subscribed - 3GPP TS 29.272 #7.3.77 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1404, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "QoS-Subscribed", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* ULR-Flags - 3GPP TS 29.272 #7.3.7 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1405, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "ULR-Flags", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Ext-PDP-Type AVP - 3GPP TS 29.272 #7.3.75A */ + { + struct dict_avp_data data = { + 1620, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Ext-PDP-Type", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, NULL); + } + + /* Ext-PDP-Address AVP - 3GPP TS 29.272 #7.3.129 */ + { + struct dict_avp_data data = { + 1621, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Ext-PDP-Address", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, Address_type, NULL); + } + + /* TS-Code AVP - 3GPP TS 29.272 #7.3.100 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1487, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "TS-Code", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* External-Client AVP - 3GPP TS 29.272 #7.3.90 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1479, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "External-Client", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Client-Identity", RULE_REQUIRED, -1, 1 } + ,{ "GMLC-Restriction", RULE_OPTIONAL, -1, 1 } + ,{ "Notification-To-UE-User", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Service-Type AVP - 3GPP TS 29.272 #7.3.94 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1483, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Service-Type", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "ServiceTypeIdentity", RULE_REQUIRED, -1, 1 } + ,{ "GMLC-Restriction", RULE_OPTIONAL, -1, 1 } + ,{ "Notification-To-UE-User", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* LCS-PrivacyException AVP - 3GPP TS 29.272 #7.3.86 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1475, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "LCS-PrivacyException", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "SS-Code", RULE_REQUIRED, -1, 1 } + ,{ "SS-Status", RULE_REQUIRED, -1, 1 } + ,{ "Notification-To-UE-User", RULE_OPTIONAL, -1, 1 } + ,{ "External-Client", RULE_OPTIONAL, -1, -1 } + ,{ "PLMN-Client", RULE_OPTIONAL, -1, -1 } + ,{ "Service-Type", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* MO-LR AVP - 3GPP TS 29.272 #7.3.96 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1485, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "MO-LR", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "SS-Code", RULE_REQUIRED, -1, 1 } + ,{ "SS-Status", RULE_REQUIRED, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* LCS-Info AVP - 3GPP TS 29.272 #7.3.84 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1473, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "LCS-Info", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "GMLC-Number", RULE_OPTIONAL, -1, -1 } + ,{ "LCS-PrivacyException", RULE_OPTIONAL, -1, -1 } + ,{ "MO-LR", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* PDP-Context AVP - 3GPP TS 29.272 #7.3.74 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1469, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "PDP-Context", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Context-Identifier", RULE_REQUIRED, -1, 1 } + ,{ "PDP-Type", RULE_REQUIRED, -1, 1 } + ,{ "PDP-Address", RULE_OPTIONAL, -1, 1 } + ,{ "QoS-Subscribed", RULE_REQUIRED, -1, 1 } + ,{ "VPLMN-Dynamic-Address-Allowed", RULE_OPTIONAL, -1, 1 } + ,{ "Service-Selection", RULE_REQUIRED, -1, 1 } + ,{ "3GPP-Charging-Characteristics", RULE_OPTIONAL, -1, 1 } + ,{ "Ext-PDP-Type", RULE_OPTIONAL, -1, 1 } + ,{ "Ext-PDP-Address", RULE_OPTIONAL, -1, 1 } + ,{ "AMBR", RULE_OPTIONAL, -1, 1 } + ,{ "SIPTO-Permission", RULE_OPTIONAL, -1, 1 } + ,{ "LIPA-Permission", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* GPRS-Subscription-Data AVP - 3GPP TS 29.272 #7.3.72 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1467, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "GPRS-Subscription-Data", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Complete-Data-List-Included-Indicator", RULE_REQUIRED, -1, 1 } + ,{ "PDP-Context", RULE_REQUIRED, -1, 50 } + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Teleservice-List AVP - 3GPP TS 29.272 #7.3.99 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1486, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Teleservice-List", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "TS-Code", RULE_REQUIRED, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Call-Barring-Infor-List AVP - 3GPP TS 29.272 #7.3.101 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1488, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Call-Barring-Infor-List", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "SS-Code", RULE_REQUIRED, 1, -1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* SGSN-Number AVP - 3GPP TS 29.272 #7.3.102 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1489, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "SGSN-Number", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* IDR-Flags AVP - 3GPP TS 29.272 #7.3.103 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 1490, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "IDR-Flags", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* IMS-Voice-Over-PS-Sessions-Supported AVP - 3GPP TS 29.272 #7.3.106 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(IMS-Voice-Over-PS-Sessions-Supported)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "NOT_SUPPORTED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "SUPPORTED", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1492, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "IMS-Voice-Over-PS-Sessions-Supported", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + /* Create the Enumerated type, and then the AVP */ + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , avp, NULL); + } + + /* SGSN-Number AVP - 3GPP TS 29.272 #7.3.102 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Homogeneous-Support-of-IMS-Voice-Over-PSSessions)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "NOT_SUPPORTED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "SUPPORTED", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1493, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Homogeneous-Support-of-IMS-Voice-Over-PSSessions", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Last-UE-Activity-Time AVP - 3GPP TS 29.272 #7.3.108 */ + { + struct dict_avp_data data = { + 1494, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Last-UE-Activity-Time", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , Time_type, NULL); + } + + /* E-UTRAN-Cell-Global-Identity AVP - 3GPP TS 29.272 #7.3.117 */ + { + struct dict_avp_data data = { + 1602, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "E-UTRAN-Cell-Global-Identity", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, NULL); + } + + /* Tracking-Area-Identity AVP - 3GPP TS 29.272 #7.3.118 */ + { + struct dict_avp_data data = { + 1603, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Tracking-Area-Identity", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, NULL); + } + + /* Cell-Global-Identity AVP - 3GPP TS 29.272 #7.3.119 */ + { + struct dict_avp_data data = { + 1604, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Cell-Global-Identity", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, NULL); + } + + /* Routing-Area-Identity AVP - 3GPP TS 29.272 #7.3.120 */ + { + struct dict_avp_data data = { + 1605, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Routing-Area-Identity", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, NULL); + } + + /* Location-Area-Identity AVP - 3GPP TS 29.272 #7.3.121 */ + { + struct dict_avp_data data = { + 1606, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Location-Area-Identity", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, NULL); + } + + /* Service-Area-Identity AVP - 3GPP TS 29.272 #7.3.122 */ + { + struct dict_avp_data data = { + 1607, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Service-Area-Identity", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, NULL); + } + + /* Geographical-Information AVP - 3GPP TS 29.272 #7.3.123 */ + { + struct dict_avp_data data = { + 1608, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Geographical-Information", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, NULL); + } + + /* Geodetic-Information AVP - 3GPP TS 29.272 #7.3.124 */ + { + struct dict_avp_data data = { + 1609, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Geodetic-Information", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, NULL); + } + + /* Current-Location-Retrieved AVP - 3GPP TS 29.272 #7.3.125 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Current-Location-Retrieved)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "ACTIVE-LOCATION-RETRIEVAL", { .i32 = 0 }}; + + struct dict_avp_data data = { + 1610, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Current-Location-Retrieved", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Age-Of-Location-Information AVP - 3GPP TS 29.272 #7.3.126 */ + { + struct dict_avp_data data = { + 1611, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Age-Of-Location-Information", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* UE-SRVCC-Capability AVP - 3GPP TS 29.272 #7.3.130 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(UE-SRVCC-Capability)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "UE-SRVCC-NOT-SUPPORTED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "UE-SRVCC-SUPPORTED", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1615, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "UE-SRVCC-Capability", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* MPS-Priority AVP - 3GPP TS 29.272 #7.3.131 */ + { + struct dict_avp_data data = { + 1616, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "MPS-Priority", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* VPLMN-LIPA-Allowed AVP - 3GPP TS 29.272 #7.3.132 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(VPLMN-LIPA-Allowed)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "LIPA-NOTALLOWED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "LIPA-ALLOWED", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1617, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "VPLMN-LIPA-Allowed", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Subscribed-Periodic-RAU-TAU-Timer AVP - 3GPP TS 29.272 #7.3.134 */ + { + struct dict_avp_data data = { + 1619, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Subscribed-Periodic-RAU-TAU-Timer", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* Job-Type AVP - 3GPP TS 29.272 #7.3.132 and 3GPP TS 32.422 #5.10.1 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Job-Type)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "Immediate-MDT-Only", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "Logged-MDT-only", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "Trace-Only", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "Immediate-MDT-and-Trace", { .i32 = 3 }}; + + struct dict_avp_data data = { + 1623, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Job-Type", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* Relay-Node-Indicator AVP - 3GPP TS 29.272 #7.3.147 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Relay-Node-Indicator)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "NOT_RELAY_NODE", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "RELAY_NODE", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1633, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Relay-Node-Indicator", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* MDT-User-Consent AVP - 3GPP TS 29.272 #7.3.148 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(MDT-User-Consent)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "CONSENT_NOT_GIVEN", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "CONSENT_GIVEN", { .i32 = 1 }}; + + struct dict_avp_data data = { + 1634, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "MDT-User-Consent", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* PUR-Flags AVP - 3GPP TS 29.272 #7.3.149 */ + { + struct dict_avp_data data = { + 1635, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "PUR-Flags", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_UNSIGNED32 /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, NULL); + } + + /* User-State AVP - 3GPP TS 29.272 #7.3.114 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(User-State)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "DETACHED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "ATTACHED_NOT_REACHABLE_FOR_PAGING", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "ATTACHED_REACHABLE_FOR_PAGING", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "CONNECTED_NOT_REACHABLE_FOR_PAGING", { .i32 = 3 }}; + struct dict_enumval_data t_4 = { "CONNECTED_REACHABLE_FOR_PAGING", { .i32 = 4 }}; + struct dict_enumval_data t_5 = { "NETWORK_DETERMINED_NOT_REACHABLE", { .i32 = 5 }}; + + struct dict_avp_data data = { + 1499, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "User-State", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_5 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* MME-User-State AVP - 3GPP TS 29.272 #7.3.112 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1497, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "MME-User-State", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "User-State", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* SGSN-User-State AVP - 3GPP TS 29.272 #7.3.113 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1498, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "SGSN-User-State", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "User-State", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* EPS-User-State AVP - 3GPP TS 29.272 #7.3.110 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1495, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "EPS-User-State", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "MME-User-State", RULE_OPTIONAL, -1, 1 } + ,{ "SGSN-User-State", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* MME-Location-Information AVP - 3GPP TS 29.272 #7.3.115 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1600, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "MME-Location-Information", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "E-UTRAN-Cell-Global-Identity", RULE_OPTIONAL, -1, 1 } + ,{ "Tracking-Area-Identity", RULE_OPTIONAL, -1, 1 } + ,{ "Geographical-Information", RULE_OPTIONAL, -1, 1 } + ,{ "Geodetic-Information", RULE_OPTIONAL, -1, 1 } + ,{ "Current-Location-Retrieved", RULE_OPTIONAL, -1, 1 } + ,{ "Age-Of-Location-Information", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* SGSN-Location-Information AVP - 3GPP TS 29.272 #7.3.116 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1601, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "SGSN-Location-Information", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Cell-Global-Identity", RULE_OPTIONAL, -1, 1 } + ,{ "Location-Area-Identity", RULE_OPTIONAL, -1, 1 } + ,{ "Service-Area-Identity", RULE_OPTIONAL, -1, 1 } + ,{ "Routing-Area-Identity", RULE_OPTIONAL, -1, 1 } + ,{ "Geographical-Information", RULE_OPTIONAL, -1, 1 } + ,{ "Geodetic-Information", RULE_OPTIONAL, -1, 1 } + ,{ "Current-Location-Retrieved", RULE_OPTIONAL, -1, 1 } + ,{ "Age-Of-Location-Information", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Area-Scope AVP - 3GPP TS 29.272 #7.3.138 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1624, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Area-Scope", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Cell-Global-Identity", RULE_OPTIONAL, -1, -1 } + ,{ "E-UTRAN-Cell-Global-Identity", RULE_OPTIONAL, -1, -1 } + ,{ "Routing-Area-Identity", RULE_OPTIONAL, -1, -1 } + ,{ "Location-Area-Identity", RULE_OPTIONAL, -1, -1 } + ,{ "Tracking-Area-Identity", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* MDT-Configuration AVP - 3GPP TS 29.272 #7.3.136 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1622, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "MDT-Configuration", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Job-Type", RULE_REQUIRED, -1, 1 } + ,{ "Area-Scope", RULE_OPTIONAL, -1, 1 } + ,{ "List-Of-Measurements", RULE_OPTIONAL, -1, 1 } + ,{ "Reporting-Trigger", RULE_OPTIONAL, -1, 1 } + ,{ "Report-Interval", RULE_OPTIONAL, -1, 1 } + ,{ "Report-Amount", RULE_OPTIONAL, -1, 1 } + ,{ "Event-Threshold-RSRP", RULE_OPTIONAL, -1, 1 } + ,{ "Event-Threshold-RSRQ", RULE_OPTIONAL, -1, 1 } + ,{ "Logging-Interval", RULE_OPTIONAL, -1, 1 } + ,{ "Logging-Duration", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* EPS-Location-Information AVP - 3GPP TS 29.272 #7.3.111 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1496, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "EPS-Location-Information", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "MME-Location-Information", RULE_OPTIONAL, -1, 1 } + ,{ "SGSN-Location-Information", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Active-APN AVP - 3GPP TS 29.173 #7.3.127 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1612, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Active-APN", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Context-Identifier", RULE_REQUIRED, -1, 1 } + ,{ "Service-Selection", RULE_OPTIONAL, -1, 1 } + ,{ "MIP6-Agent-Info", RULE_OPTIONAL, -1, 1 } + ,{ "Visited-Network-Identifier", RULE_OPTIONAL, -1, 1 } + ,{ "Specific-APN-Info", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Error-Diagnostic AVP - 3GPP TS 29.272 #7.3.128 */ + { + struct dict_object * avp; + struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Error-Diagnostic)" , NULL, NULL, NULL }; + struct dict_enumval_data t_0 = { "GPRS_DATA_SUBSCRIBED", { .i32 = 0 }}; + struct dict_enumval_data t_1 = { "NO_GPRS_DATA_SUBSCRIBED", { .i32 = 1 }}; + struct dict_enumval_data t_2 = { "ODB-ALL-APN", { .i32 = 2 }}; + struct dict_enumval_data t_3 = { "ODB-HPLMN-APN", { .i32 = 3 }}; + struct dict_enumval_data t_4 = { "ODB-VPLMN-APN", { .i32 = 4 }}; + + struct dict_avp_data data = { + 1614, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Error-Diagnostic", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_INTEGER32 /* base type of data */ + }; + + CHECK_dict_new( DICT_TYPE, &tdata , NULL, &avp); + CHECK_dict_new( DICT_ENUMVAL, &t_0 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_1 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_2 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_3 , avp, NULL); + CHECK_dict_new( DICT_ENUMVAL, &t_4 , avp, NULL); + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + } + + /* GMLC-Address AVP - 3GPP TS 29.173 #6.4.7 */ + { + struct dict_avp_data data = { + 2405, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "GMLC-Address", /* Name */ + AVP_FLAG_VENDOR, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_OCTETSTRING /* base type of data */ + }; + + CHECK_dict_new( DICT_AVP, &data , Address_type, NULL); + } + + /* Supported Features AVP - 3GPP TS 29.229 */ + { + struct dict_object * avp; + struct dict_avp_data data = { + 628, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Supported-Features", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Vendor-Id", RULE_REQUIRED, 1, 1 } + ,{ "Feature-List-ID", RULE_REQUIRED, 1, 1 } + ,{ "Feature-List", RULE_REQUIRED, 1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Trace-Data AVP - 3GPP TS 29.272 #7.3.63 */ + { + struct dict_object * avp; + + struct dict_avp_data data = { + 1458, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Trace-Data", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Trace-Reference", RULE_REQUIRED, -1, 1 } + ,{ "Trace-Depth", RULE_REQUIRED, -1, 1 } + ,{ "Trace-NE-Type-List", RULE_REQUIRED, -1, 1 } + ,{ "Trace-Interface-List", RULE_OPTIONAL, -1, 1 } + ,{ "Trace-Event-List", RULE_REQUIRED, -1, 1 } + ,{ "OMC-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Trace-Collection-Entity", RULE_REQUIRED, -1, 1 } + ,{ "MDT-Configuration", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data, NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* Subscription-Data AVP - 3GPP TS 29.272 #7.3.2 */ + { + /* + + * The Subscription-Data AVP is of type Grouped. It shall contain + * the information related to the user profile relevant for + * EPS and GERAN/UTRAN. + + Subscription-Data ::= + [ Subscriber-Status ] + [ MSISDN ] + [ STN-SR ] + [ ICS-Indicator ] + [ Network-Access-Mode ] + [ Operator-Determined-Barring ] + [ HPLMN-ODB ] + *10[ Regional-Subscription-Zone-Code] + [ Access-Restriction-Data ] + [ APN-OI-Replacement ] + [ LCS-Info ] + [ Teleservice-List ] + [ Call-Barring-Infor-List ] + [ 3GPP-Charging-Characteristics ] + [ AMBR ] + [ APN-Configuration-Profile ] + [ RAT-Frequency-Selection-Priority-ID ] + [ Trace-Data] + [ GPRS-Subscription-Data ] + *[ CSG-Subscription-Data ] + [ Roaming-Restricted-Due-To-Unsupported-Feature ] + [ Subscribed-Periodic-RAU-TAU-Timer ] + [ MPS-Priority ] + [ VPLMN-LIPA-Allowed ] + [ Relay-Node-Indicator ] + [ MDT-User-Consent ] + *[ AVP ] + + * The AMBR included in this grouped AVP shall include the AMBR + * associated to the user’s subscription (UE-AMBR); + * Max-Requested-Bandwidth-UL and Max-Requested-Bandwidth-DL within + * this AVP shall not both be set to "0". + * The APN-OI-Replacement included in this grouped AVP shall include + * the UE level APN-OI-Replacement associated to the user’s subscription. + */ + struct dict_object * avp; + struct dict_avp_data data = { + 1400, /* Code */ + VENDOR_3GPP_Id, /* Vendor */ + "Subscription-Data", /* Name */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */ + AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */ + AVP_TYPE_GROUPED /* base type of data */ + }; + + struct local_rules_definition rules[] = + { + { "Subscriber-Status", RULE_OPTIONAL, -1, 1 } + ,{ "MSISDN", RULE_OPTIONAL, -1, 1 } + ,{ "STN-SR", RULE_OPTIONAL, -1, 1 } + ,{ "ICS-Indicator", RULE_OPTIONAL, -1, 1 } + ,{ "Network-Access-Mode", RULE_OPTIONAL, -1, 1 } + ,{ "Operator-Determined-Barring", RULE_OPTIONAL, -1, 1 } + ,{ "HPLMN-ODB", RULE_OPTIONAL, -1, 1 } + ,{ "Regional-Subscription-Zone-Code", RULE_OPTIONAL, -1, 10 } + ,{ "Access-Restriction-Data", RULE_OPTIONAL, -1, 1 } + ,{ "APN-OI-Replacement", RULE_OPTIONAL, -1, 1 } + ,{ "LCS-Info", RULE_OPTIONAL, -1, 1 } + ,{ "Teleservice-List", RULE_OPTIONAL, -1, 1 } + ,{ "Call-Barring-Infor-List", RULE_OPTIONAL, -1, 1 } + ,{ "3GPP-Charging-Characteristics", RULE_OPTIONAL, -1, 1 } + ,{ "AMBR", RULE_OPTIONAL, -1, 1 } + ,{ "APN-Configuration-Profile", RULE_OPTIONAL, -1, 1 } + ,{ "RAT-Frequency-Selection-Priority-ID", RULE_OPTIONAL, -1, 1 } + ,{ "Trace-Data", RULE_OPTIONAL, -1, 1 } + ,{ "GPRS-Subscription-Data", RULE_OPTIONAL, -1, 1 } + ,{ "CSG-Subscription-Data", RULE_OPTIONAL, -1, -1 } + ,{ "Roaming-Restricted-Due-To-Unsupported-Feature", RULE_OPTIONAL, -1, 1 } + ,{ "Subscribed-Periodic-RAU-TAU-Timer", RULE_OPTIONAL, -1, 1 } + ,{ "MPS-Priority", RULE_OPTIONAL, -1, 1 } + ,{ "VPLMN-LIPA-Allowed", RULE_OPTIONAL, -1, 1 } + ,{ "Relay-Node-Indicator", RULE_OPTIONAL, -1, 1 } + ,{ "MDT-User-Consent", RULE_OPTIONAL, -1, 1 } + }; + + CHECK_dict_new( DICT_AVP, &data , NULL, &avp); + PARSE_loc_rules( rules, avp ); + } + + /* S6A-Update Location Request - 3GPP TS 29.272 #7.2.3 */ + { + /* + + The Update-Location-Request (ULR) command, indicated by the + Command-Code field set to 316 and the "R" bit set in + the Command Flags field, is sent from MME or SGSN to HSS. + + < Update-Location-Request> ::= < Diameter Header: 316, REQ, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + [ Destination-Host ] + { Destination-Realm } + { User-Name } + *[ Supported-Features ] + [ Terminal-Information ] + { RAT-Type } + { ULR-Flags } + [ UE-SRVCC-Capability ] + { Visited-PLMN-Id } + [ SGSN-Number ] + [ Homogeneous-Support-of-IMS-Voice-Over-PS-Sessions ] + [ GMLC-Address ] + *[ Active-APN ] + *[ AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 316, /* Code */ + "Update-Location-Request", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Host", RULE_OPTIONAL, -1, 1 } + ,{ "Destination-Realm", RULE_REQUIRED, -1, 1 } + ,{ "User-Name", RULE_REQUIRED, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Terminal-Information", RULE_OPTIONAL, -1, 1 } + ,{ "RAT-Type", RULE_REQUIRED, 1, 1 } + ,{ "ULR-Flags", RULE_REQUIRED, 1, 1 } + ,{ "UE-SRVCC-Capability", RULE_OPTIONAL, -1, 1 } + ,{ "Visited-PLMN-Id", RULE_REQUIRED, 1, 1 } + ,{ "SGSN-Number", RULE_OPTIONAL, -1, 1 } + ,{ "Homogeneous-Support-of-IMS-Voice-Over-PSSessions", RULE_OPTIONAL, -1, 1 } + ,{ "GMLC-Address", RULE_OPTIONAL, -1, 1 } + ,{ "Active-APN", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* S6A-Update Location Answer - 3GPP TS 29.272 #7.2.4 */ + { + /* + + The Update-Location-Answer (ULA) command, indicated by the + Command-Code field set to 316 and the 'R' bit cleared + in the Command Flags field, is sent from HSS to MME or SGSN. + + < Update-Location-Answer> ::= < Diameter Header: 316, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + [ Result-Code ] + [ Experimental-Result ] + [ Error-Diagnostic ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + *[ Supported-Features ] + [ ULA-Flags ] + [ Subscription-Data ] + *[ AVP ] + *[ Failed-AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 316, /* Code */ + "Update-Location-Answer", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Result-Code", RULE_OPTIONAL, -1, 1 } + ,{ "Experimental-Result", RULE_OPTIONAL, -1, 1 } + ,{ "Error-Diagnostic", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "ULA-Flags", RULE_OPTIONAL, -1, 1 } + ,{ "Subscription-Data", RULE_OPTIONAL, -1, 1 } + ,{ "Failed-AVP", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* S6A-Cancel-Location-Request - 3GPP TS 29.272 #7.2.7 */ + { + /* + + The Cancel-Location-Request (CLR) command, indicated by the + Command-Code field set to 317 and the 'R' bit set in + the Command Flags field, is sent from HSS to MME or SGSN. + + < Cancel-Location-Request> ::= < Diameter Header: 317, REQ, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + { Destination-Host } + { Destination-Realm } + { User-Name } + *[Supported-Features ] + { Cancellation-Type } + *[ AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 317, /* Code */ + "Cancel-Location-Request", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Host", RULE_OPTIONAL, -1, 1 } + ,{ "Destination-Realm", RULE_REQUIRED, -1, 1 } + ,{ "User-Name", RULE_REQUIRED, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Cancellation-Type", RULE_REQUIRED, -1, 1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* S6A-Cancel-Location-Answer - 3GPP TS 29.272 #7.2.8 */ + { + /* + + The Cancel-Location-Answer (CLA) command, indicated by the + Command-Code field set to 317 and the 'R' bit cleared + in the Command Flags field, is sent from MME or SGSN to HSS. + + < Cancel-Location-Answer> ::= < Diameter Header: 317, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + *[ Supported-Features ] + [ Result-Code ] + [ Experimental-Result ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + *[ AVP ] + *[ Failed-AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 317, /* Code */ + "Cancel-Location-Answer", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Result-Code", RULE_OPTIONAL, -1, 1 } + ,{ "Experimental-Result", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Failed-AVP", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* S6A-Authentication-Information-Request - 3GPP TS 29.272 #7.2.4 */ + { + /* + + The Authentication-Information-Request (AIR) command, indicated by + the Command-Code field set to 318 and the 'R' + bit set in the Command Flags field, is sent from MME or SGSN to HSS. + + < Authentication-Information-Request> ::= < Diameter Header: 318, REQ, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + [ Destination-Host ] + { Destination-Realm } + { User-Name } + *[ Supported-Features ] + [ Requested-EUTRAN-Authentication-Info ] + [ Requested-UTRAN-GERAN-Authentication-Info ] + { Visited-PLMN-Id } + *[ AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 318, /* Code */ + "Authentication-Information-Request", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Host", RULE_OPTIONAL, -1, 1 } + ,{ "Destination-Realm", RULE_REQUIRED, -1, 1 } + ,{ "User-Name", RULE_REQUIRED, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Requested-EUTRAN-Authentication-Info", RULE_OPTIONAL, -1, 1 } + ,{ "Requested-UTRAN-GERAN-Authentication-Info", RULE_OPTIONAL, -1, 1 } + ,{ "Visited-PLMN-Id", RULE_REQUIRED, -1, 1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* S6A-Authentication-Information-Answer - 3GPP TS 29.272 #7.2.6 */ + { + /* + + The Authentication-Information-Answer (AIA) command, indicated by + the Command-Code field set to318 and the 'R' bit cleared in the + Command Flags field, is sent from HSS to MME or SGSN. + + < Authentication-Information-Answer> ::= < Diameter Header: 318, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + [ Result-Code ] + [ Experimental-Result ] + [ Error-Diagnostic ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + *[ Supported-Features ] + [ Authentication-Info ] + *[ AVP ] + *[ Failed-AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 318, /* Code */ + "Authentication-Information-Answer", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Result-Code", RULE_OPTIONAL, -1, 1 } + ,{ "Experimental-Result", RULE_OPTIONAL, -1, 1 } + ,{ "Error-Diagnostic", RULE_OPTIONAL, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Authentication-Info", RULE_OPTIONAL, -1, 1 } + ,{ "Failed-AVP", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* Insert-Subscriber-Data-Request IDR Command - 3GPP TS 29.272 #7.2.9 */ + { + /* + + The Insert-Subscriber-Data-Request (IDR) command, indicated by the + Command-Code field set to 319 and the 'R' bit set in the Command + Flags field, is sent from HSS to MME or SGSN. + + < Insert-Subscriber-Data-Request> ::= < Diameter Header: 319, REQ, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + { Destination-Host } + { Destination-Realm } + { User-Name } + *[ Supported-Features] + { Subscription-Data} + [IDR- Flags ] + *[ AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 319, /* Code */ + "Insert-Subscriber-Data-Request", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Host", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Realm", RULE_REQUIRED, -1, 1 } + ,{ "User-Name", RULE_REQUIRED, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Subscription-Data", RULE_REQUIRED, -1, 1 } + ,{ "IDR-Flags", RULE_OPTIONAL, -1, 1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* Insert-Subscriber-Data-Answer IDA Command - 3GPP TS 29.272 #7.2.10 */ + { + /* + + The Insert-Subscriber-Data-Request (IDR) command, indicated by the + Command-Code field set to 319 and the 'R' bit set in the Command + Flags field, is sent from HSS to MME or SGSN. + + < Insert-Subscriber-Data-Answer> ::= < Diameter Header: 319, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + *[ Supported-Features ] + [ Result-Code ] + [ Experimental-Result ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + [ IMS-Voice-Over-PS-Sessions-Supported ] + [ Last-UE-Activity-Time ] + [ RAT-Type ] + [ IDA-Flags ] + [ EPS-User-State ] + [ EPS-Location-Information ] + *[ AVP ] + *[ Failed-AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 319, /* Code */ + "Insert-Subscriber-Data-Answer", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Result-Code", RULE_OPTIONAL, -1, 1 } + ,{ "Experimental-Result", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "IMS-Voice-Over-PS-Sessions-Supported", RULE_OPTIONAL, -1, 1 } + ,{ "Last-UE-Activity-Time", RULE_OPTIONAL, -1, 1 } + ,{ "RAT-Type", RULE_OPTIONAL, -1, 1 } + ,{ "IDA-Flags", RULE_OPTIONAL, -1, 1 } + ,{ "EPS-User-State", RULE_OPTIONAL, -1, 1 } + ,{ "EPS-Location-Information", RULE_OPTIONAL, -1, 1 } + ,{ "Failed-AVP", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* Delete-Subscriber-Data-Request (DSR) Command - 3GPP TS 29.272 #7.2.11 */ + { + /* + + The Delete-SubscriberData-Request (DSR) command, indicated by + the Command-Code field set to 320 and the 'R' bit + set in the Command Flags field, is sent from HSS to MME or SGSN. + + < Delete-Subscriber-Data-Request > ::= < Diameter Header: 320, REQ, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + { Destination-Host } + { Destination-Realm } + { User-Name } + *[ Supported-Features ] + { DSR-Flags } + *[ Context-Identifier ] + [ Trace-Reference ] + *[ TS-Code ] + *[ SS-Code ] + *[ AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 320, /* Code */ + "Delete-SubscriberData-Request", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Host", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Realm", RULE_REQUIRED, -1, 1 } + ,{ "User-Name", RULE_REQUIRED, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "DSR-Flags", RULE_REQUIRED, -1, 1 } + ,{ "Context-Identifier", RULE_OPTIONAL, -1, -1 } + ,{ "Trace-Reference", RULE_OPTIONAL, -1, 1 } + ,{ "TS-Code", RULE_OPTIONAL, -1, -1 } + ,{ "SS-Code", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* Delete-Subscriber-Data-Answer (DSA) Command - 3GPP TS 29.272 #7.2.12 */ + { + /* + + The Delete-SubscriberData-Answer (DSA) command, indicated by the + Command-Code field set to 320 and the 'R' bit + cleared in the Command Flags field, is sent from MME or SGSN to HSS. + + < Delete-Subscriber-Data-Answer> ::= < Diameter Header: 320, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + *[ Supported-Features ] + [ Result-Code ] + [ Experimental-Result ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + [ DSA-Flags ] + *[ AVP ] + *[ Failed-AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 320, /* Code */ + "Delete-SubscriberData-Answer", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Result-Code", RULE_OPTIONAL, -1, 1 } + ,{ "Experimental-Result", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "DSA-Flags", RULE_OPTIONAL, -1, 1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* Purge-UE-Request (PUR) Command - 3GPP TS 29.272 #7.2.13 */ + { + /* + + The Delete-SubscriberData-Request (DSR) command, indicated by + the Command-Code field set to 320 and the 'R' bit + set in the Command Flags field, is sent from HSS to MME or SGSN. + + < Purge-UE-Request> ::= < Diameter Header: 321, REQ, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + [ Destination-Host ] + { Destination-Realm } + { User-Name } + [ PUR-Flags ] + *[ Supported-Features ] + *[ AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 321, /* Code */ + "Purge-UE-Request", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Host", RULE_OPTIONAL, -1, 1 } + ,{ "Destination-Realm", RULE_REQUIRED, -1, 1 } + ,{ "User-Name", RULE_REQUIRED, -1, 1 } + ,{ "PUR-Flags", RULE_OPTIONAL, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* Purge-UE-Answer (PUA) Command - 3GPP TS 29.272 #7.2.14 */ + { + /* + + The Purge-UE-Answer (PUA) command, indicated by the Command-Code + field set to 321 and the 'R' bit cleared in the + Command Flags field, is sent from HSS to MME or SGSN. + + < Purge-UE-Answer> ::= < Diameter Header: 321, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + *[ Supported-Features ] + [ Result-Code ] + [ Experimental-Result ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + [ PUA-Flags ] + *[ AVP ] + *[ Failed-AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 321, /* Code */ + "Purge-UE-Answer", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Result-Code", RULE_OPTIONAL, -1, 1 } + ,{ "Experimental-Result", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "PUA-Flags", RULE_OPTIONAL, -1, 1 } + ,{ "Failed-AVP", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* Reset-Request (RSR) Command - 3GPP TS 29.272 #7.2.15 */ + { + /* + + The Reset-Request (RSR) command, indicated by the Command-Code + field set to 322 and the 'R' bit set in the + Command Flags field, is sent from HSS to MME or SGSN. + + < Reset-Request> ::= < Diameter Header: 322, REQ, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + { Destination-Host } + { Destination-Realm } + *[ Supported-Features ] + *[ User-Id ] + *[ AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 322, /* Code */ + "Reset-Request", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Host", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "User-Id", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* Reset-Answer (RSA) Command - 3GPP TS 29.272 #7.2.16 */ + { + /* + + The Authentication-Information-Answer (RSA) command, indicated by + the Command-Code field set to 322 and the 'R' + bit cleared in the Command Flags field, is sent from MME or SGSN to HSS. + + < Reset-Answer> ::= < Diameter Header: 322, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + *[ Supported-Features ] + [ Result-Code ] + [ Experimental-Result ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + *[ AVP ] + *[ Failed-AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 322, /* Code */ + "Reset-Anwer", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Result-Code", RULE_OPTIONAL, -1, 1 } + ,{ "Experimental-Result", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Failed-AVP", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* Notify-Request (NOR) Command - 3GPP TS 29.272 #7.2.17 */ + { + /* + + The Notify-Request (NOR) command, indicated by the Command-Code + field set to 323 and the 'R' bit set in the Command Flags field, + is sent from MME or SGSN to HSS. + + < Notify-Request> ::= < Diameter Header: 323, REQ, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + [ Destination-Host ] + { Destination-Realm } + { User-Name } + *[ Supported-Features ] + [ Terminal-Information ] + [ MIP6-Agent-Info ] + [ Visited-Network-Identifier ] + [ Context-Identifier ] + [ Service-Selection ] + [ Alert-Reason ] + [ UE-SRVCC-Capability ] + [ NOR-Flags ] + *[ AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 323, /* Code */ + "Notify-Request", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Host", RULE_OPTIONAL, -1, 1 } + ,{ "Destination-Realm", RULE_REQUIRED, -1, 1 } + ,{ "User-Name", RULE_REQUIRED, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Terminal-Information", RULE_OPTIONAL, -1, 1 } + ,{ "MIP6-Agent-Info", RULE_OPTIONAL, -1, 1 } + ,{ "Visited-Network-Identifier", RULE_OPTIONAL, -1, 1 } + ,{ "Context-Identifier", RULE_OPTIONAL, -1, 1 } + ,{ "Service-Selection", RULE_OPTIONAL, -1, 1 } + ,{ "Alert-Reason", RULE_OPTIONAL, -1, 1 } + ,{ "UE-SRVCC-Capability", RULE_OPTIONAL, -1, 1 } + ,{ "NOR-Flags", RULE_OPTIONAL, -1, 1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* Notify-Answer (NOA) Command - 3GPP TS 29.272 #7.2.18 */ + { + /* + + The Notify-Answer (NOA) command, indicated by the Command-Code + field set to 323 and the 'R' bit cleared in the + Command Flags field, is sent from HSS to MME or SGSN. + + < Notify-Answer> ::= < Diameter Header: 323, PXY, 16777251 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + [ Result-Code ] + [ Experimental-Result ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + *[ Supported-Features ] + *[ AVP ] + *[ Failed-AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 323, /* Code */ + "Notify-Answer", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Result-Code", RULE_OPTIONAL, -1, 1 } + ,{ "Experimental-Result", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Supported-Features", RULE_OPTIONAL, -1, -1 } + ,{ "Failed-AVP", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* ME-Identity-Check-Request (ECR) Command - 3GPP TS 29.272 #7.2.19 */ + { + /* + + The ME-Identity-Check-Request (ECR) command, indicated by the + Command-Code field set to 324 and the 'R' bit set + in the Command Flags field, is sent from MME or SGSN to EIR. + + < ME-Identity-Check-Request > ::= < Diameter Header: 324, REQ, PXY, 16777252 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + [ Destination-Host ] + { Destination-Realm } + { Terminal-Information } + [ User-Name ] + *[ AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 324, /* Code */ + "ME-Identity-Check-Request", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Destination-Host", RULE_OPTIONAL, -1, 1 } + ,{ "Destination-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Terminal-Information", RULE_REQUIRED, -1, 1 } + ,{ "User-Name", RULE_OPTIONAL, -1, 1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + + /* ME-Identity-Check-Answer (ECA) Command - 3GPP TS 29.272 #7.2.20 */ + { + /* + + The ME-Identity-Check-Answer (ECA) command, indicated by the + Command-Code field set to 324 and the 'R' bit + cleared in the Command Flags field, is sent from EIR to MME or SGSN. + + < ME-Identity-Check-Answer> ::= < Diameter Header: 324, PXY, 16777252 > + < Session-Id > + [ Vendor-Specific-Application-Id ] + [ Result-Code ] + [ Experimental-Result ] + { Auth-Session-State } + { Origin-Host } + { Origin-Realm } + [ Equipment-Status ] + *[ AVP ] + *[ Failed-AVP ] + *[ Proxy-Info ] + *[ Route-Record ] + */ + struct dict_object * cmd; + struct dict_cmd_data data = { + 324, /* Code */ + "ME-Identity-Check-Answer", /* Name */ + CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */ + CMD_FLAG_PROXIABLE /* Fixed flag values */ + }; + + struct local_rules_definition rules[] = + { + { "Session-Id", RULE_FIXED_HEAD, -1, 1 } + ,{ "Vendor-Specific-Application-Id", RULE_OPTIONAL, -1, 1 } + ,{ "Result-Code", RULE_OPTIONAL, -1, 1 } + ,{ "Experimental-Result", RULE_OPTIONAL, -1, 1 } + ,{ "Auth-Session-State", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Host", RULE_REQUIRED, -1, 1 } + ,{ "Origin-Realm", RULE_REQUIRED, -1, 1 } + ,{ "Equipment-Status", RULE_OPTIONAL, -1, 1 } + ,{ "User-Name", RULE_OPTIONAL, -1, 1 } + ,{ "Failed-AVP", RULE_OPTIONAL, -1, -1 } + ,{ "Proxy-Info", RULE_OPTIONAL, -1, -1 } + ,{ "Route-Record", RULE_OPTIONAL, -1, -1 } + }; + + CHECK_dict_new( DICT_COMMAND, &data, s6a_dict, &cmd); + PARSE_loc_rules( rules, cmd ); + } + } + + TRACE_DEBUG(INFO, "Dictionary Extension 'S6A from 3GPP standard v.10.5' initialized"); + return 0; +} +EXTENSION_ENTRY("dict_s6a", dict_s6a_init, "dict_nas_mipv6");