/*
* Copyright (c) 2017 Sprint
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*    http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/****************
 Generated By: fdtool enhancements to diafuzzer
 License: same as freeDiameter
****************/


/* 
 * Dictionary definitions of objects specified in rfc7155_avps.
 */
#include <freeDiameter/extension.h>

#define PROTO_VER "unspecified"
#define GEN_DATE  1506697143.67

const char *rfc7155_avps_proto_ver = PROTO_VER;
const double rfc7155_avps_gen_date = GEN_DATE;

/* The content of this file follows the same structure as dict_base_proto.c */

#define CHECK_dict_new( _type, _data, _parent, _ref )                                     \
{                                                                                         \
    int _ret = fd_dict_new( fd_g_config->cnf_dict, (_type), (_data), (_parent), (_ref) ); \
    if ( _ret != 0 && _ret != EEXIST )                                                    \
       return _ret;                                                                       \
}

#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 {
    struct dict_avp_request avp_vendor_plus_name;
    enum rule_position	position;
    int 			min;
    int			max;
};

#define RULE_ORDER( _position ) ((((_position) == RULE_FIXED_HEAD) || ((_position) == RULE_FIXED_TAIL)) ? 1 : 0 )

/* Attention! This version of the macro uses AVP_BY_NAME_AND_VENDOR, in contrast to most other copies! */
#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_AND_VENDOR,                                                         \
                        &(_rulearray)[__ar].avp_vendor_plus_name,                                       \
                        &__data.rule_avp, 0 ) );                                                        \
                if ( !__data.rule_avp ) {                                                               \
                        TRACE_DEBUG(INFO, "AVP Not found: '%s'", (_rulearray)[__ar].avp_vendor_plus_name.avp_name);             \
                        return ENOENT;                                                                  \
                }                                                                                       \
                {                                                                                       \
                         int _ret = fd_dict_new( fd_g_config->cnf_dict, DICT_RULE, &(__data), (_parent), NULL ); \
                         if ( _ret != 0 && _ret != EEXIST )      {                                      \
                                TRACE_DEBUG(INFO, "Error on rule with AVP '%s'",                        \
                                            (_rulearray)[__ar].avp_vendor_plus_name.avp_name);          \
                                return EINVAL;                                                          \
                         }                                                                              \
                }                                                                                       \
        }                                                                                               \
}

#define CHECK_vendor_new( _data ) { \
        struct dict_object * vendor_found; \
        if (fd_dict_search(fd_g_config->cnf_dict,DICT_VENDOR,VENDOR_BY_ID,&_data.vendor_id,&vendor_found,ENOENT) == ENOENT) { \
                CHECK_FCT(fd_dict_new(fd_g_config->cnf_dict, DICT_VENDOR, &_data, NULL, NULL)); \
        } \
}

#define enumval_def_u32( _val_, _str_ )		\
    { _str_, 		{ .u32 = _val_ }}

#define enumval_def_os( _len_, _val_, _str_ )				\
    { _str_, 		{ .os = { .data = (unsigned char *)_val_, .len = _len_ }}}


static int dict_rfc7155_avps_load_defs(char * conffile)
{
   TRACE_ENTRY("%p", conffile);

	/* Derived AVP types section */
	{
		/* QoSFilterRule */
		{
			/*
				The QosFilterRule format is derived from the OctetString AVP Base
				Format.  It uses the ASCII charset.  Packets may be marked or
				metered based on the following information:

				 Direction                          (in or out)
				 Source and destination IP address  (possibly masked)
				 Protocol
				 Source and destination port        (lists or ranges)
				 DSCP values                        (no mask or range)

				Rules for the appropriate direction are evaluated in order; the
				first matched rule terminates the evaluation.  Each packet is
				evaluated once.  If no rule matches, the packet is treated as best
				effort.  An access device unable to interpret or apply a QoS rule
				SHOULD NOT terminate the session.

				QoSFilterRule filters MUST follow the following format:

				action dir proto from src to dst [options]

        				tag    - Mark packet with a specific DSCP
                				 [DIFFSERV].  The DSCP option MUST be
                				 included.
        				meter  - Meter traffic.  The metering options
                				 MUST be included.

				dir           The format is as described under IPFilterRule.

				proto         The format is as described under IPFilterRule.

				src and dst   The format is as described under IPFilterRule.

				 options:

				 DSCP <color>
				       Color values as defined in [DIFFSERV].  Exact
				       matching of DSCP values is required (no masks or
				       ranges).

				 metering <rate> <color_under> <color_over>
				       The metering option provides Assured Forwarding,
				       as defined in [DIFFSERVAF], and MUST be present
				       if the action is set to meter.  The rate option is
				       the throughput, in bits per second, used
				       by the access device to mark packets.  Traffic
				       over the rate is marked with the color_over
				       codepoint, and traffic under the rate is marked
				       with the color_under codepoint.  The color_under
				       and color_over options contain the drop
				       preferences and MUST conform to the recommended
				       codepoint keywords described in [DIFFSERVAF]
				       (e.g., AF13).

				       The metering option also supports the strict
				       limit on traffic required by Expedited
				       Forwarding, as defined in [DIFFSERVEF].  The
				       color_over option may contain the keyword "drop"
				       to prevent forwarding of traffic that exceeds the
				       rate parameter.

				 The rule syntax is a modified subset of ipfw(8) from FreeBSD,
				 and the ipfw.c code may provide a useful base for
				 implementations.
			*/
			struct dict_type_data data = { AVP_TYPE_OCTETSTRING,	"QoSFilterRule"		, NULL			, NULL			};
			CHECK_dict_new( DICT_TYPE, &data , NULL, NULL);
		}
		
	}
	
   /* AVP section */
   {
		struct dict_object * Address_type;
		struct dict_object * UTF8String_type;
		struct dict_object * DiameterIdentity_type;
		struct dict_object * DiameterURI_type;
		struct dict_object * Time_type;
		struct dict_object * IPFilterRule_type;
		struct dict_object * QoSFilterRule_type;

		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Address", &Address_type);
		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "UTF8String", &UTF8String_type);
		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "DiameterIdentity", &DiameterIdentity_type);
		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "DiameterURI", &DiameterURI_type);
		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Time", &Time_type);
		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "IPFilterRule", &IPFilterRule_type);
		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "QoSFilterRule", &QoSFilterRule_type);
		/* NAS-Port */
		{
			struct dict_avp_data data = {
				5,	/* Code */
				0,	/* Vendor */
				"NAS-Port",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* NAS-Port-Id */
		{
			struct dict_avp_data data = {
				87,	/* Code */
				0,	/* Vendor */
				"NAS-Port-Id",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* NAS-Port-Type */
		{
			struct dict_avp_data data = {
				61,	/* Code */
				0,	/* Vendor */
				"NAS-Port-Type",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(NAS-Port-Type)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "ASYNC", { .i32=0 }};
			struct dict_enumval_data        t_2 = { "SYNC", { .i32=1 }};
			struct dict_enumval_data        t_3 = { "ISDN_SYNC", { .i32=2 }};
			struct dict_enumval_data        t_4 = { "ISDN_ASYNC_V120", { .i32=3 }};
			struct dict_enumval_data        t_5 = { "ISDN_ASYNC_V110", { .i32=4 }};
			struct dict_enumval_data        t_6 = { "VIRTUAL", { .i32=5 }};
			struct dict_enumval_data        t_7 = { "PIAFS", { .i32=6 }};
			struct dict_enumval_data        t_8 = { "HDLC_CLEAR_CHANNEL", { .i32=7 }};
			struct dict_enumval_data        t_9 = { "X25", { .i32=8 }};
			struct dict_enumval_data        t_10 = { "X75", { .i32=9 }};
			struct dict_enumval_data        t_11 = { "G.3_FAX", { .i32=10 }};
			struct dict_enumval_data        t_12 = { "SDSL_SYMMETRIC_DSL", { .i32=11 }};
			struct dict_enumval_data        t_13 = { "IDSL_ISDN_DIGITAL_SUBSCRIBER_LINE", { .i32=14 }};
			struct dict_enumval_data        t_14 = { "ETHERNET", { .i32=15 }};
			struct dict_enumval_data        t_15 = { "XDSL_DIGITAL_SUBSCRIBER_LINE_OF_UNKNOWN_TYPE", { .i32=16 }};
			struct dict_enumval_data        t_16 = { "CABLE", { .i32=17 }};
			struct dict_enumval_data        t_17 = { "WIRELESS_OTHER", { .i32=18 }};
			struct dict_enumval_data        t_18 = { "WIRELESS_IEEE_802.11", { .i32=19 }};
			struct dict_enumval_data        t_19 = { "TOKEN_RING", { .i32=20 }};
			struct dict_enumval_data        t_20 = { "FDDI", { .i32=21 }};
			struct dict_enumval_data        t_21 = { "WIRELESS_CDMA2000", { .i32=22 }};
			struct dict_enumval_data        t_22 = { "WIRELESS_UMTS", { .i32=23 }};
			struct dict_enumval_data        t_23 = { "WIRELESS_1X_EV", { .i32=24 }};
			struct dict_enumval_data        t_24 = { "IAPP", { .i32=25 }};
			struct dict_enumval_data        t_25 = { "FTTP_FIBER_TO_THE_PREMISES", { .i32=26 }};
			struct dict_enumval_data        t_26 = { "WIRELESS_IEEE_802.16", { .i32=27 }};
			struct dict_enumval_data        t_27 = { "WIRELESS_IEEE_802.20", { .i32=28 }};
			struct dict_enumval_data        t_28 = { "WIRELESS_IEEE_802.22", { .i32=29 }};
			struct dict_enumval_data        t_29 = { "PPPOA_PPP_OVER_ATM", { .i32=30 }};
			struct dict_enumval_data        t_30 = { "PPPOEOA_PPP_OVER_ETHERNET_OVER_ATM", { .i32=31 }};
			struct dict_enumval_data        t_31 = { "PPPOEOE_PPP_OVER_ETHERNET_OVER_ETHERNET", { .i32=32 }};
			struct dict_enumval_data        t_32 = { "PPPOEOVLAN_PPP_OVER_ETHERNET_OVER_VLAN", { .i32=33 }};
			struct dict_enumval_data        t_33 = { "PPPOEOQINQ_PPP_OVER_ETHERNET_OVER_IEEE_802.1QINQ", { .i32=34 }};
			struct dict_enumval_data        t_34 = { "XPON_PASSIVE_OPTICAL_NETWORK", { .i32=35 }};
			struct dict_enumval_data        t_35 = { "WIRELESS_XGP", { .i32=36 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_ENUMVAL, &t_5, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_9, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_10, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_11, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_12, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_13, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_14, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_15, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_16, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_17, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_18, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_19, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_20, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_21, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_22, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_23, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_24, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_25, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_26, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_27, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_28, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_29, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_30, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_31, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_32, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_33, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_34, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_35, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* Called-Station-Id */
		{
			struct dict_avp_data data = {
				30,	/* Code */
				0,	/* Vendor */
				"Called-Station-Id",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Calling-Station-Id */
		{
			struct dict_avp_data data = {
				31,	/* Code */
				0,	/* Vendor */
				"Calling-Station-Id",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Connect-Info */
		{
			struct dict_avp_data data = {
				77,	/* Code */
				0,	/* Vendor */
				"Connect-Info",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Originating-Line-Info */
		{
			struct dict_avp_data data = {
				94,	/* Code */
				0,	/* Vendor */
				"Originating-Line-Info",	/* 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);
		};
		/* Reply-Message */
		{
			struct dict_avp_data data = {
				18,	/* Code */
				0,	/* Vendor */
				"Reply-Message",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* User-Password */
		{
			struct dict_avp_data data = {
				2,	/* Code */
				0,	/* Vendor */
				"User-Password",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Password-Retry */
		{
			struct dict_avp_data data = {
				75,	/* Code */
				0,	/* Vendor */
				"Password-Retry",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Prompt */
		{
			struct dict_avp_data data = {
				76,	/* Code */
				0,	/* Vendor */
				"Prompt",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Prompt)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "NO_ECHO", { .i32=0 }};
			struct dict_enumval_data        t_2 = { "ECHO", { .i32=1 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* CHAP-Algorithm */
		{
			struct dict_avp_data data = {
				403,	/* Code */
				0,	/* Vendor */
				"CHAP-Algorithm",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(CHAP-Algorithm)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "CHAP_WITH_MD5", { .i32=5 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* CHAP-Ident */
		{
			struct dict_avp_data data = {
				404,	/* Code */
				0,	/* Vendor */
				"CHAP-Ident",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* CHAP-Response */
		{
			struct dict_avp_data data = {
				405,	/* Code */
				0,	/* Vendor */
				"CHAP-Response",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* CHAP-Challenge */
		{
			struct dict_avp_data data = {
				60,	/* Code */
				0,	/* Vendor */
				"CHAP-Challenge",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* ARAP-Password */
		{
			struct dict_avp_data data = {
				70,	/* Code */
				0,	/* Vendor */
				"ARAP-Password",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* ARAP-Challenge-Response */
		{
			struct dict_avp_data data = {
				84,	/* Code */
				0,	/* Vendor */
				"ARAP-Challenge-Response",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* ARAP-Security */
		{
			struct dict_avp_data data = {
				73,	/* Code */
				0,	/* Vendor */
				"ARAP-Security",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* ARAP-Security-Data */
		{
			struct dict_avp_data data = {
				74,	/* Code */
				0,	/* Vendor */
				"ARAP-Security-Data",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Service-Type */
		{
			struct dict_avp_data data = {
				6,	/* Code */
				0,	/* Vendor */
				"Service-Type",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Service-Type)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "UNKNOWN", { .i32=0 }};
			struct dict_enumval_data        t_2 = { "LOGIN", { .i32=1 }};
			struct dict_enumval_data        t_3 = { "FRAMED", { .i32=2 }};
			struct dict_enumval_data        t_4 = { "CALLBACK_LOGIN", { .i32=3 }};
			struct dict_enumval_data        t_5 = { "CALLBACK_FRAMED", { .i32=4 }};
			struct dict_enumval_data        t_6 = { "OUTBOUND", { .i32=5 }};
			struct dict_enumval_data        t_7 = { "ADMINISTRATIVE", { .i32=6 }};
			struct dict_enumval_data        t_8 = { "NAS_PROMPT", { .i32=7 }};
			struct dict_enumval_data        t_9 = { "AUTHENTICATE_ONLY", { .i32=8 }};
			struct dict_enumval_data        t_10 = { "CALLBACK_NAS_PROMPT", { .i32=9 }};
			struct dict_enumval_data        t_11 = { "CALL_CHECK", { .i32=10 }};
			struct dict_enumval_data        t_12 = { "CALLBACK_ADMINISTRATIVE", { .i32=11 }};
			struct dict_enumval_data        t_13 = { "VOICE", { .i32=12 }};
			struct dict_enumval_data        t_14 = { "FAX", { .i32=13 }};
			struct dict_enumval_data        t_15 = { "MODEM_RELAY", { .i32=14 }};
			struct dict_enumval_data        t_16 = { "IAPP_REGISTER", { .i32=15 }};
			struct dict_enumval_data        t_17 = { "IAPP_AP_CHECK", { .i32=16 }};
			struct dict_enumval_data        t_18 = { "AUTHORIZE_ONLY", { .i32=17 }};
			struct dict_enumval_data        t_19 = { "FRAMED_MANAGEMENT", { .i32=18 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_ENUMVAL, &t_5, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_9, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_10, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_11, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_12, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_13, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_14, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_15, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_16, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_17, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_18, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_19, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* Callback-Number */
		{
			struct dict_avp_data data = {
				19,	/* Code */
				0,	/* Vendor */
				"Callback-Number",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Callback-Id */
		{
			struct dict_avp_data data = {
				20,	/* Code */
				0,	/* Vendor */
				"Callback-Id",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Idle-Timeout */
		{
			struct dict_avp_data data = {
				28,	/* Code */
				0,	/* Vendor */
				"Idle-Timeout",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Port-Limit */
		{
			struct dict_avp_data data = {
				62,	/* Code */
				0,	/* Vendor */
				"Port-Limit",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* NAS-Filter-Rule */
		{
			struct dict_avp_data data = {
				400,	/* Code */
				0,	/* Vendor */
				"NAS-Filter-Rule",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, IPFilterRule_type, NULL);
		};
		/* Filter-Id */
		{
			struct dict_avp_data data = {
				11,	/* Code */
				0,	/* Vendor */
				"Filter-Id",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Configuration-Token */
		{
			struct dict_avp_data data = {
				78,	/* Code */
				0,	/* Vendor */
				"Configuration-Token",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* QoS-Filter-Rule */
		{
			struct dict_avp_data data = {
				407,	/* Code */
				0,	/* Vendor */
				"QoS-Filter-Rule",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, QoSFilterRule_type, NULL);
		};
		/* Framed-Protocol */
		{
			struct dict_avp_data data = {
				7,	/* Code */
				0,	/* Vendor */
				"Framed-Protocol",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Framed-Protocol)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "PPP", { .i32=1 }};
			struct dict_enumval_data        t_2 = { "SLIP", { .i32=2 }};
			struct dict_enumval_data        t_3 = { "ARAP", { .i32=3 }};
			struct dict_enumval_data        t_4 = { "GANDALF", { .i32=4 }};
			struct dict_enumval_data        t_5 = { "XYLOGICS", { .i32=5 }};
			struct dict_enumval_data        t_6 = { "X.75", { .i32=6 }};
			struct dict_enumval_data        t_7 = { "GPRS_PDP_CONTEXT", { .i32=7 }};
			struct dict_enumval_data        t_8 = { "ASCEND_ARA", { .i32=255 }};
			struct dict_enumval_data        t_9 = { "MPP", { .i32=256 }};
			struct dict_enumval_data        t_10 = { "EURAW", { .i32=257 }};
			struct dict_enumval_data        t_11 = { "EUUI", { .i32=258 }};
			struct dict_enumval_data        t_12 = { "X25", { .i32=259 }};
			struct dict_enumval_data        t_13 = { "COMB", { .i32=260 }};
			struct dict_enumval_data        t_14 = { "FR", { .i32=261 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_ENUMVAL, &t_5, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_9, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_10, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_11, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_12, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_13, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_14, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* Framed-Routing */
		{
			struct dict_avp_data data = {
				10,	/* Code */
				0,	/* Vendor */
				"Framed-Routing",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Framed-Routing)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "NONE", { .i32=0 }};
			struct dict_enumval_data        t_2 = { "SEND_ROUTING_PACKETS", { .i32=1 }};
			struct dict_enumval_data        t_3 = { "LISTEN_FOR_ROUTING_PACKETS", { .i32=2 }};
			struct dict_enumval_data        t_4 = { "SEND_AND_LISTEN", { .i32=3 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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, type, NULL);
		};
		/* Framed-MTU */
		{
			struct dict_avp_data data = {
				12,	/* Code */
				0,	/* Vendor */
				"Framed-MTU",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Framed-Compression */
		{
			struct dict_avp_data data = {
				13,	/* Code */
				0,	/* Vendor */
				"Framed-Compression",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Framed-Compression)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "NONE", { .i32=0 }};
			struct dict_enumval_data        t_2 = { "IPX_HEADER_COMPRESSION", { .i32=2 }};
			struct dict_enumval_data        t_3 = { "STAC_LZS_COMPRESSION", { .i32=3 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_AVP, &data, type, NULL);
		};
		/* Framed-IP-Address */
		{
			struct dict_avp_data data = {
				8,	/* Code */
				0,	/* Vendor */
				"Framed-IP-Address",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Framed-IP-Netmask */
		{
			struct dict_avp_data data = {
				9,	/* Code */
				0,	/* Vendor */
				"Framed-IP-Netmask",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Framed-Route */
		{
			struct dict_avp_data data = {
				22,	/* Code */
				0,	/* Vendor */
				"Framed-Route",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Framed-Pool */
		{
			struct dict_avp_data data = {
				88,	/* Code */
				0,	/* Vendor */
				"Framed-Pool",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Framed-Interface-Id */
		{
			struct dict_avp_data data = {
				96,	/* Code */
				0,	/* Vendor */
				"Framed-Interface-Id",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED64	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Framed-IPv6-Prefix */
		{
			struct dict_avp_data data = {
				97,	/* Code */
				0,	/* Vendor */
				"Framed-IPv6-Prefix",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Framed-IPv6-Route */
		{
			struct dict_avp_data data = {
				99,	/* Code */
				0,	/* Vendor */
				"Framed-IPv6-Route",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Framed-IPv6-Pool */
		{
			struct dict_avp_data data = {
				100,	/* Code */
				0,	/* Vendor */
				"Framed-IPv6-Pool",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Framed-IPX-Network */
		{
			struct dict_avp_data data = {
				23,	/* Code */
				0,	/* Vendor */
				"Framed-IPX-Network",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Framed-Appletalk-Link */
		{
			struct dict_avp_data data = {
				37,	/* Code */
				0,	/* Vendor */
				"Framed-Appletalk-Link",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Framed-Appletalk-Network */
		{
			struct dict_avp_data data = {
				38,	/* Code */
				0,	/* Vendor */
				"Framed-Appletalk-Network",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Framed-Appletalk-Zone */
		{
			struct dict_avp_data data = {
				39,	/* Code */
				0,	/* Vendor */
				"Framed-Appletalk-Zone",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* ARAP-Features */
		{
			struct dict_avp_data data = {
				71,	/* Code */
				0,	/* Vendor */
				"ARAP-Features",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* ARAP-Zone-Access */
		{
			struct dict_avp_data data = {
				72,	/* Code */
				0,	/* Vendor */
				"ARAP-Zone-Access",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(ARAP-Zone-Access)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "ONLY_ALLOW_ACCESS_TO_DEFAULT_ZONE", { .i32=1 }};
			struct dict_enumval_data        t_2 = { "USE_ZONE_FILTER_INCLUSIVELY", { .i32=2 }};
			struct dict_enumval_data        t_3 = { "USE_ZONE_FILTER_EXCLUSIVELY", { .i32=3 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_AVP, &data, type, NULL);
		};
		/* Login-IP-Host */
		{
			struct dict_avp_data data = {
				14,	/* Code */
				0,	/* Vendor */
				"Login-IP-Host",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Login-IPv6-Host */
		{
			struct dict_avp_data data = {
				98,	/* Code */
				0,	/* Vendor */
				"Login-IPv6-Host",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Login-Service */
		{
			struct dict_avp_data data = {
				15,	/* Code */
				0,	/* Vendor */
				"Login-Service",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Login-Service)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "TELNET", { .i32=0 }};
			struct dict_enumval_data        t_2 = { "RLOGIN", { .i32=1 }};
			struct dict_enumval_data        t_3 = { "TCP_CLEAR", { .i32=2 }};
			struct dict_enumval_data        t_4 = { "PORTMASTER", { .i32=3 }};
			struct dict_enumval_data        t_5 = { "LAT", { .i32=4 }};
			struct dict_enumval_data        t_6 = { "X25_PAD", { .i32=5 }};
			struct dict_enumval_data        t_7 = { "X25_T3POS", { .i32=6 }};
			struct dict_enumval_data        t_8 = { "UNASSIGNED", { .i32=7 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_ENUMVAL, &t_5, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* Login-TCP-Port */
		{
			struct dict_avp_data data = {
				16,	/* Code */
				0,	/* Vendor */
				"Login-TCP-Port",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Login-LAT-Service */
		{
			struct dict_avp_data data = {
				34,	/* Code */
				0,	/* Vendor */
				"Login-LAT-Service",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Login-LAT-Node */
		{
			struct dict_avp_data data = {
				35,	/* Code */
				0,	/* Vendor */
				"Login-LAT-Node",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Login-LAT-Group */
		{
			struct dict_avp_data data = {
				36,	/* Code */
				0,	/* Vendor */
				"Login-LAT-Group",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Login-LAT-Port */
		{
			struct dict_avp_data data = {
				63,	/* Code */
				0,	/* Vendor */
				"Login-LAT-Port",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Tunnel-Type */
		{
			struct dict_avp_data data = {
				64,	/* Code */
				0,	/* Vendor */
				"Tunnel-Type",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Tunnel-Type)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "PPTP", { .i32=1 }};
			struct dict_enumval_data        t_2 = { "L2F", { .i32=2 }};
			struct dict_enumval_data        t_3 = { "L2TP", { .i32=3 }};
			struct dict_enumval_data        t_4 = { "ATMP", { .i32=4 }};
			struct dict_enumval_data        t_5 = { "VTP", { .i32=5 }};
			struct dict_enumval_data        t_6 = { "AH", { .i32=6 }};
			struct dict_enumval_data        t_7 = { "IP_IP_ENCAP", { .i32=7 }};
			struct dict_enumval_data        t_8 = { "MIN_IP_IP", { .i32=8 }};
			struct dict_enumval_data        t_9 = { "ESP", { .i32=9 }};
			struct dict_enumval_data        t_10 = { "GRE", { .i32=10 }};
			struct dict_enumval_data        t_11 = { "DVS", { .i32=11 }};
			struct dict_enumval_data        t_12 = { "IP_IN_IP_TUNNELING", { .i32=12 }};
			struct dict_enumval_data        t_13 = { "VLAN", { .i32=13 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_ENUMVAL, &t_5, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_9, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_10, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_11, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_12, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_13, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* Tunnel-Medium-Type */
		{
			struct dict_avp_data data = {
				65,	/* Code */
				0,	/* Vendor */
				"Tunnel-Medium-Type",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Tunnel-Medium-Type)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "IPV4", { .i32=1 }};
			struct dict_enumval_data        t_2 = { "IPV6", { .i32=2 }};
			struct dict_enumval_data        t_3 = { "NSAP", { .i32=3 }};
			struct dict_enumval_data        t_4 = { "HDLC", { .i32=4 }};
			struct dict_enumval_data        t_5 = { "BBN", { .i32=5 }};
			struct dict_enumval_data        t_6 = { "IEEE_802", { .i32=6 }};
			struct dict_enumval_data        t_7 = { "E_163", { .i32=7 }};
			struct dict_enumval_data        t_8 = { "E_164", { .i32=8 }};
			struct dict_enumval_data        t_9 = { "F_69", { .i32=9 }};
			struct dict_enumval_data        t_10 = { "X_121", { .i32=10 }};
			struct dict_enumval_data        t_11 = { "IPX", { .i32=11 }};
			struct dict_enumval_data        t_12 = { "APPLETALK_802", { .i32=12 }};
			struct dict_enumval_data        t_13 = { "DECNET4", { .i32=13 }};
			struct dict_enumval_data        t_14 = { "VINES", { .i32=14 }};
			struct dict_enumval_data        t_15 = { "E_164_NSAP", { .i32=15 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_ENUMVAL, &t_5, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_9, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_10, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_11, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_12, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_13, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_14, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_15, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* Tunnel-Client-Endpoint */
		{
			struct dict_avp_data data = {
				66,	/* Code */
				0,	/* Vendor */
				"Tunnel-Client-Endpoint",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Tunnel-Server-Endpoint */
		{
			struct dict_avp_data data = {
				67,	/* Code */
				0,	/* Vendor */
				"Tunnel-Server-Endpoint",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Tunnel-Password */
		{
			struct dict_avp_data data = {
				69,	/* Code */
				0,	/* Vendor */
				"Tunnel-Password",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Tunnel-Private-Group-Id */
		{
			struct dict_avp_data data = {
				81,	/* Code */
				0,	/* Vendor */
				"Tunnel-Private-Group-Id",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Tunnel-Assignment-Id */
		{
			struct dict_avp_data data = {
				82,	/* Code */
				0,	/* Vendor */
				"Tunnel-Assignment-Id",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Tunnel-Preference */
		{
			struct dict_avp_data data = {
				83,	/* Code */
				0,	/* Vendor */
				"Tunnel-Preference",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Tunnel-Client-Auth-Id */
		{
			struct dict_avp_data data = {
				90,	/* Code */
				0,	/* Vendor */
				"Tunnel-Client-Auth-Id",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Tunnel-Server-Auth-Id */
		{
			struct dict_avp_data data = {
				91,	/* Code */
				0,	/* Vendor */
				"Tunnel-Server-Auth-Id",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* Accounting-Input-Octets */
		{
			struct dict_avp_data data = {
				363,	/* Code */
				0,	/* Vendor */
				"Accounting-Input-Octets",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED64	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Accounting-Output-Octets */
		{
			struct dict_avp_data data = {
				364,	/* Code */
				0,	/* Vendor */
				"Accounting-Output-Octets",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED64	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Accounting-Input-Packets */
		{
			struct dict_avp_data data = {
				365,	/* Code */
				0,	/* Vendor */
				"Accounting-Input-Packets",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED64	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Accounting-Output-Packets */
		{
			struct dict_avp_data data = {
				366,	/* Code */
				0,	/* Vendor */
				"Accounting-Output-Packets",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED64	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Acct-Session-Time */
		{
			struct dict_avp_data data = {
				46,	/* Code */
				0,	/* Vendor */
				"Acct-Session-Time",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Acct-Authentic */
		{
			struct dict_avp_data data = {
				45,	/* Code */
				0,	/* Vendor */
				"Acct-Authentic",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Acct-Authentic)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "NONE", { .i32=0 }};
			struct dict_enumval_data        t_2 = { "RADIUS", { .i32=1 }};
			struct dict_enumval_data        t_3 = { "LOCAL", { .i32=2 }};
			struct dict_enumval_data        t_4 = { "REMOTE", { .i32=3 }};
			struct dict_enumval_data        t_5 = { "DIAMETER", { .i32=4 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_ENUMVAL, &t_5, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* Accounting-Auth-Method */
		{
			struct dict_avp_data data = {
				406,	/* Code */
				0,	/* Vendor */
				"Accounting-Auth-Method",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Accounting-Auth-Method)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "PAP", { .i32=1 }};
			struct dict_enumval_data        t_2 = { "CHAP", { .i32=2 }};
			struct dict_enumval_data        t_3 = { "MS_CHAP_1", { .i32=3 }};
			struct dict_enumval_data        t_4 = { "MS_CHAP_2", { .i32=4 }};
			struct dict_enumval_data        t_5 = { "EAP", { .i32=5 }};
			struct dict_enumval_data        t_6 = { "UNDEFINED", { .i32=6 }};
			struct dict_enumval_data        t_7 = { "NONE", { .i32=7 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_ENUMVAL, &t_5, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* Acct-Delay-Time */
		{
			struct dict_avp_data data = {
				41,	/* Code */
				0,	/* Vendor */
				"Acct-Delay-Time",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Acct-Link-Count */
		{
			struct dict_avp_data data = {
				51,	/* Code */
				0,	/* Vendor */
				"Acct-Link-Count",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Acct-Tunnel-Connection */
		{
			struct dict_avp_data data = {
				68,	/* Code */
				0,	/* Vendor */
				"Acct-Tunnel-Connection",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Acct-Tunnel-Packets-Lost */
		{
			struct dict_avp_data data = {
				86,	/* Code */
				0,	/* Vendor */
				"Acct-Tunnel-Packets-Lost",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* NAS-Identifier */
		{
			struct dict_avp_data data = {
				32,	/* Code */
				0,	/* Vendor */
				"NAS-Identifier",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
		};
		/* NAS-IP-Address */
		{
			struct dict_avp_data data = {
				4,	/* Code */
				0,	/* Vendor */
				"NAS-IP-Address",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* NAS-IPv6-Address */
		{
			struct dict_avp_data data = {
				95,	/* Code */
				0,	/* Vendor */
				"NAS-IPv6-Address",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Origin-AAA-Protocol */
		{
			struct dict_avp_data data = {
				408,	/* Code */
				0,	/* Vendor */
				"Origin-AAA-Protocol",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Origin-AAA-Protocol)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "RADIUS", { .i32=1 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* State */
		{
			struct dict_avp_data data = {
				24,	/* Code */
				0,	/* Vendor */
				"State",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Redirect-Host */
		{
			struct dict_avp_data data = {
				292,	/* Code */
				0,	/* Vendor */
				"Redirect-Host",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_OCTETSTRING	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, DiameterURI_type, NULL);
		};
		/* Redirect-Host-Usage */
		{
			struct dict_avp_data data = {
				261,	/* Code */
				0,	/* Vendor */
				"Redirect-Host-Usage",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_INTEGER32	/* base type of data */
			};
			struct dict_object        *type;
			struct dict_type_data     tdata = { AVP_TYPE_INTEGER32, "Enumerated(Redirect-Host-Usage)", NULL, NULL, NULL };
			struct dict_enumval_data        t_1 = { "DONT_CACHE", { .i32=0 }};
			struct dict_enumval_data        t_2 = { "ALL_SESSION", { .i32=1 }};
			struct dict_enumval_data        t_3 = { "ALL_REALM", { .i32=2 }};
			struct dict_enumval_data        t_4 = { "REALM_AND_APPLICATION", { .i32=3 }};
			struct dict_enumval_data        t_5 = { "ALL_APPLICATION", { .i32=4 }};
			struct dict_enumval_data        t_6 = { "ALL_HOST", { .i32=5 }};
			struct dict_enumval_data        t_7 = { "ALL_USER", { .i32=6 }};
			/* Create the Enumerated type, and then the AVP */
			CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
			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_ENUMVAL, &t_5, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
			CHECK_dict_new( DICT_AVP, &data, type, NULL);
		};
		/* Redirect-Max-Cache-Time */
		{
			struct dict_avp_data data = {
				262,	/* Code */
				0,	/* Vendor */
				"Redirect-Max-Cache-Time",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_UNSIGNED32	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
		};
		/* Tunneling */
		{
			/* Grouped */
			struct dict_object * avp;
			struct dict_avp_data data = {
				401,	/* Code */
				0,	/* Vendor */
				"Tunneling",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_GROUPED	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}
		/* CHAP-Auth */
		{
			/* Grouped */
			struct dict_object * avp;
			struct dict_avp_data data = {
				402,	/* Code */
				0,	/* Vendor */
				"CHAP-Auth",	/* Name */
				AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY,	/* Fixed flags */
				AVP_FLAG_MANDATORY,	/* Fixed flag values */
				AVP_TYPE_GROUPED	/* base type of data */
			};
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

	
   }

   /* Commands section */
   {

   }

   return 0;
}

static int dict_rfc7155_avps_load_rules(char * conffile)
{
   /* Grouped AVP section */
   {
	  /* Tunneling */
	  {
		/* Grouped */
		struct dict_object * avp;
		struct dict_avp_request avp_vendor_plus_name =  { .avp_vendor = 0, .avp_name = "Tunneling"};
		CHECK_dict_search(DICT_AVP,  AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
		struct local_rules_definition rules[] =
		{
			{ { .avp_vendor = 0, .avp_name = "Tunnel-Type"}, RULE_REQUIRED, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "Tunnel-Medium-Type"}, RULE_REQUIRED, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "Tunnel-Client-Endpoint"}, RULE_REQUIRED, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "Tunnel-Server-Endpoint"}, RULE_REQUIRED, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "Tunnel-Preference"}, RULE_OPTIONAL, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "Tunnel-Client-Auth-Id"}, RULE_OPTIONAL, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "Tunnel-Server-Auth-Id"}, RULE_OPTIONAL, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "Tunnel-Assignment-Id"}, RULE_OPTIONAL, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "Tunnel-Password"}, RULE_OPTIONAL, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "Tunnel-Private-Group-Id"}, RULE_OPTIONAL, -1, -1 }
		};
		PARSE_loc_rules( rules, avp );
	  }
	  /* CHAP-Auth */
	  {
		/* Grouped */
		struct dict_object * avp;
		struct dict_avp_request avp_vendor_plus_name =  { .avp_vendor = 0, .avp_name = "CHAP-Auth"};
		CHECK_dict_search(DICT_AVP,  AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
		struct local_rules_definition rules[] =
		{
			{ { .avp_vendor = 0, .avp_name = "CHAP-Algorithm"}, RULE_REQUIRED, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "CHAP-Ident"}, RULE_REQUIRED, -1, -1 },
			{ { .avp_vendor = 0, .avp_name = "CHAP-Response"}, RULE_OPTIONAL, -1, -1 }
		};
		PARSE_loc_rules( rules, avp );
	  }

   }	

   /* Commands section */
   {

   }

   LOG_D( "Extension 'Dictionary definitions for rfc7155_avps (None)' initialized");
   return 0;
}

int dict_entry(char * conffile)
{
	dict_rfc7155_avps_load_defs(conffile);
	return dict_rfc7155_avps_load_rules(conffile);
}

const char* dict_rfc7155_avps_proto_ver(char * conffile) {
	return rfc7155_avps_proto_ver;
}

const double dict_rfc7155_avps_gen_ts(char * conffile) {
	return rfc7155_avps_gen_date;
}

EXTENSION_ENTRY2("dict_rfc7155_avps", dict_rfc7155_avps_load_defs, dict_rfc7155_avps_load_rules, "dict_rfc4004_avps");