/*********************************************************************************************************
* Software License Agreement (BSD License)                                                               *
* Author: Francois Bard <francois@tera.ics.keio.ac.jp>							 *
*													 *
* Copyright (c) 2010, Teraoka Laboratory, Keio University						 *
* 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.								 *
*********************************************************************************************************/

/*

The following table complete the one in RFC 5777. The AVPs are implemented in the order of the table.
We try to keep the structure of the grouped AVP by declaring the contained AVPs just before the grouped AVP they depend on.
The number of '+' indicates the depth of the contained AVP.

DEPTH	NAME					AVP	RFC	TYPE			NOTES

++	Vendor-Id				266	3588	Unsigned32
++	QoS-Profile-Id				573	5777	Unsigned32
+	QoS-Profile-Template			574	5777	Grouped
	QoS-Capability				578	5777	Grouped
+++	QoS-Parameters				576	5777	Grouped			no specific AVPs? see RFC 5624
+++	QoS-Profile-Template			--------------------------------
+++	Treatment-Action			572	5777	Enumerated		Type is Enumerated. See Errata 2334 for RFC5777
++	Excess-Treatment			577	5777	Grouped
++	QoS-Parameters				--------------------------------
++	QoS-Profile-Template			--------------------------------
++	QoS-Semantics				575	5777	Enumerated
++	Treatment-Action			--------------------------------
+++	Timezone-Offset				571	5777	Integer32
+++	Timezone-Flag				570	5777	Enumerated
+++	Absolute-End-Fractional-Seconds		569	5777	Unsigned32
+++	Absolute-End-Time			568	5777	Time
+++	Absolute-Start-Fractional-Seconds	567	5777	Unsigned32
+++	Absolute-Start-Time			566	5777	Time
+++	Month-Of-Year-Mask			565	5777	Unsigned32
+++	Day-Of-Month-Mask			564	5777	Unsigned32
+++	Day-Of-Week-Mask			563	5777	Unsigned32
+++	Time-Of-Day-End				562	5777	Unsigned32
+++	Time-Of-Day-Start			561	5777	Unsigned32
++	Time-Of-Day-Condition			560	5777	Grouped			Some AVPs were omitted. See Errata 2333 for RFC5777
+++++	High-User-Priority			559	5777	Unsigned32
+++++	Low-User-Priority			558	5777	Unsigned32
++++	User-Priority-Range			557	5777	Grouped
+++++	S-VID-Start				553	5777	Unsigned32
+++++	S-VID-End				554	5777	Unsigned32
+++++	C-VID-Start				555	5777	Unsigned32
+++++	C-VID-End				556	5777	Unsigned32
++++	VLAN-ID-Range				552	5777	Grouped
+++++	ETH-SAP					551	5777	OctetString
+++++	ETH-Ether-Type				550	5777	OctetString
++++	ETH-Proto-Type				549	5777	Grouped
+++	ETH-Option				548	5777	Grouped
++++	Negated					517	5777	Enumerated
++++	ICMP-Code				547	5777	Integer32		Changed from Enumerated for implementation reason. See AVP for details.
++++	ICMP-Type-Number			546	5777	Enumerated
+++	ICMP-Type				545	5777	Grouped
++++	Negated					--------------------------------
++++	TCP-Flag-Type				544	5777	Unsigned32
+++	TCP-Flags				543	5777	Grouped
++++	TCP-Option-Type				541	5777	Enumerated
++++	TCP-Option-Value			542	5777	OctetString
++++	Negated					--------------------------------
+++	TCP-Option				540	5777	Grouped
++++	IP-Option-Type				538	5777	Enumerated
++++	IP-Option-Value				539	5777	OctetString
++++	Negated					--------------------------------
+++	IP-Option				537	5777	Grouped
+++	Fragmentation-Flag			536	5777	Enumerated
+++	Diffserv-Code-Point			535	5777	Enumerated
++++	IP-Address				518	5777	Address
+++++	IP-Address-Start			520	5777	Address
+++++	IP-Address-End				521	5777	Address
++++	IP-Address-Range			519	5777	Grouped
+++++	IP-Address				--------------------------------
+++++	IP-Mask-Bit-Mask-Width			523	5777	Unsigned32		Name is IP-Mask-Bit-Mask-Width. See Errata 2335 for RFC5777
++++	IP-Address-Mask				522	5777	Grouped
++++	MAC-Address				524	5777	OctetString
+++++	MAC-Address				--------------------------------
+++++	MAC-Address-Mask-Pattern		526	5777	OctetString
++++	MAC-Address-Mask			525	5777	Grouped
++++	EUI64-Address				527	5777	OctetString
+++++	EUI64-Address				--------------------------------
+++++	EUI64-Address-Mask-Pattern		529	5777	OctetString
++++	EUI64-Address-Mask			528	5777	Grouped
++++	Port					530	5777	Integer32
+++++	Port-Start				532	5777	Integer32
+++++	Port-End				533	5777	Integer32
++++	Port-Range				531	5777	Grouped
++++	Negated					--------------------------------
++++	Use-Assigned-Address			534	5777	Enumerated
+++	From-Spec				515	5777	Grouped
++++	------------------------------------------------------------------------
++++	-----------------same dependencies as From-Spec-------------------------
++++	------------------------------------------------------------------------
+++	To-Spec					516	5777	Grouped
+++	Direction				514	5777	Enumerated
+++	Protocol				513	5777	Enumerated
+++	Classifier-ID				512	5777	OctetString
++	Classifier				511	5777	Grouped
++	Filter-Rule-Precedence			510	5777	Unsigned32
+	Filter-Rule				509	5777	Grouped			careful if we have to change vendor specifics or such.
	QoS-Resources				508	5777	Grouped

*/





/****************************************************************************************************************************************
*																	*
* This table contains the Enumerated AVPs whose values are managed by the IANA.								*
*																	*
* Note : The ICMP-Code AVP (AVP Code 547) has been changed to type Integer32. See AVP for details					*
*                                                                                                       				*
* AVP	NAME			LAST UPDATED	LAST CHECKED	SOURCE                                                  		*
* 546	ICMP-Type-Number	2010-04-22	2010-07-02	http://www.iana.org/assignments/icmp-parameters         		*
* 541	TCP-Option-Type		2010-06-22	2010-07-02	http://www.iana.org/assignments/tcp-parameters/tcp-parameters.txt	*
* 538	IP-Option-Type		2007-02-15	2010-07-02	http://www.iana.org/assignments/ip-parameters				*
* 535	Diffserv-Code-Point	2010-05-11	2010-07-02	http://www.iana.org/assignments/dscp-registry/dscp-registry.txt		*
* 513   Protocol                2004-01-26      2010-07-02	http://www.iana.org/assignments/ips-protocols                           *
*																	*
****************************************************************************************************************************************/


/*

NOTES

Sections 10.2 and 10.3 of the RFC5777 have been ignored

*/


#include <freeDiameter/extension.h>

/* 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, 									\
			(_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 */

// No result-Code or values to define in RFC5777, we proceed

/* Dictionary */

int dict_rfc5777_init(char * conffile)
{
	struct dict_object * rfc5777;
	{
		struct dict_application_data data = { 5777, "Traffic Classification and Quality of Service (QoS) Attributes for Diameter (RFC 5777)" };
		CHECK_dict_new( DICT_APPLICATION, &data , NULL, &rfc5777);
	}

	/* AVP section */
	{
		/* Loading the derived data formats */

		struct dict_object * Address_type;
		struct dict_object * Time_type;

		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Address", &Address_type);
		CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Time", &Time_type);

		/* Vendor_Id - RFC 3588 */

			/*
			Implemented in the base protocol
			*/

		/* QoS-Profile-Id - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					573, 					/* Code */
					0, 					/* Vendor */
					"QoS-Profile-Id", 			/* 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);
		}

		/* QoS-Profile-Template - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					574, 					/* Code */
					0, 					/* Vendor */
					"QoS-Profile-Template",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "Vendor-Id",	RULE_REQUIRED,	-1, 1 }
							,{  "QoS-Profile-Id",	RULE_REQUIRED,	-1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* QoS-Capability - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					578, 					/* Code */
					0, 					/* Vendor */
					"QoS-Capability",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "QoS-Profile-Template", RULE_REQUIRED, -1, -1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* QoS-Parameters - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					576, 					/* Code */
					0, 					/* Vendor */
					"QoS-Parameters",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			// the contents depend on the values of other AVPs and can not be defined
			// in the general case, so do not assign rules
			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
		}

		/* QoS-Profile-Template - RFC 5777 */

			/*
			Implemented higher
			*/


		/* Treatment-Action - RFC 5777 */
		{
			/*

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Treatment-Action)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "drop",		{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "shape", 	{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "mark",		{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 = { "permit", 	{ .i32 = 3 }};

			struct dict_avp_data 	data = {
					572, 					/* Code */
					0, 					/* Vendor */
					"Treatment-Action",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &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_AVP, &data , type, NULL);
		}


		/* Excess-Treatment - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					577, 					/* Code */
					0, 					/* Vendor */
					"Excess-Treatment",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "Treatment-Action",		RULE_REQUIRED, -1, 1 }
							,{  "QoS-Profile-Template",	RULE_OPTIONAL, -1, 1 }
							,{  "QoS-Parameters",		RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* QoS-Parameters - RFC 5777 */

			/*
			Implemented higher
			*/

		/* QoS-Profile-Template - RFC 5777 */

			/*
			Implemented higher
			*/

		/* QoS-Semantics - RFC 5777 */
		{
			/*

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(QoS-Semantics)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "QoS-Desired",		{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "QoS-Available", 	{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "QoS-Delivered",	{ .i32 = 2 }};
			struct dict_enumval_data 	t_3 = { "Minimum-QoS", 		{ .i32 = 3 }};
			struct dict_enumval_data 	t_4 = { "QoS-Authorized", 	{ .i32 = 4 }};

			struct dict_avp_data 	data = {
					575, 					/* Code */
					0, 					/* Vendor */
					"QoS-Semantics",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &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 , type, NULL);
		}



		/* Treatment-Action - RFC 5777 */

			/*
			Implemented higher
			*/

		/* Timezone-Offset - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					571, 					/* Code */
					0, 					/* Vendor */
					"Timezone-Offset", 			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_INTEGER32			/* base type of data */
					};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Timezone-Flag - RFC 5777 */
		{
			/*

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Timezone-Flag)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "UTC",		{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "LOCAL", 	{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "OFFSET",	{ .i32 = 2 }};

			struct dict_avp_data 	data = {
					570, 					/* Code */
					0, 					/* Vendor */
					"Timezone-Flag",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &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_AVP, &data , type, NULL);
		}


		/* Absolute-End-Fractional-Seconds - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					569, 					/* Code */
					0, 					/* Vendor */
					"Absolute-End-Fractional-Seconds", 	/* 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);
		}

		/* Absolute-End-Time - RFC 5777 */
		{
			/*

			*/
			struct dict_avp_data data = {
					568, 					/* Code */
					0, 					/* Vendor */
					"Absolute-End-Time", 			/* 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 , Time_type, NULL);
		}

		/* Absolute-Start-Fractional-Seconds - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					567, 					/* Code */
					0, 					/* Vendor */
					"Absolute-Start-Fractional-Seconds", 	/* 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);
		}

		/* Absolute-Start-Time - RFC 5777 */
		{
			/*

			*/
			struct dict_avp_data data = {
					566, 					/* Code */
					0, 					/* Vendor */
					"Absolute-Start-Time", 			/* 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 , Time_type, NULL);
		}

		/* Month-Of-Year-Mask - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					565, 					/* Code */
					0, 					/* Vendor */
					"Month-Of-Year-Mask", 			/* 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);
		}

		/* Day-Of-Month-Mask - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					564, 					/* Code */
					0, 					/* Vendor */
					"Day-Of-Month-Mask", 			/* 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);
		}

		/* Day-Of-Week-Mask - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					563, 					/* Code */
					0, 					/* Vendor */
					"Day-Of-Week-Mask", 			/* 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);
		}

		/* Time-Of-Day-End - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					562, 					/* Code */
					0, 					/* Vendor */
					"Time-Of-Day-End", 			/* 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);
		}

		/* Time-Of-Day-Start - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					561, 					/* Code */
					0, 					/* Vendor */
					"Time-Of-Day-Start", 			/* 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);
		}

		/* Time-Of-Day-Condition - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					560, 					/* Code */
					0, 					/* Vendor */
					"Time-Of-Day-Condition", 		/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,			/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};
			struct local_rules_definition rules[] =
						{ 	 {  "Time-Of-Day-Start", 	RULE_OPTIONAL, -1, 1 }
							,{  "Time-Of-Day-End",		RULE_OPTIONAL, -1, 1 }
							,{  "Day-Of-Week-Mask",		RULE_OPTIONAL, -1, 1 }
							,{  "Day-Of-Month-Mask",	RULE_OPTIONAL, -1, 1 }
							,{  "Month-Of-Year-Mask",	RULE_OPTIONAL, -1, 1 }
							,{  "Absolute-Start-Time",	RULE_OPTIONAL, -1, 1 }
							,{  "Absolute-End-Time",	RULE_OPTIONAL, -1, 1 }
							,{  "Timezone-Flag",		RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* High-User-Priority - RFC 5777*/
		{
			/*

			*/

			struct dict_avp_data data = {
					559, 					/* Code */
					0, 					/* Vendor */
					"High-User-Priority", 			/* 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);
		}

		/* Low-User-Priority - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					558, 					/* Code */
					0, 					/* Vendor */
					"Low-User-Priority", 			/* 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);
		}

		/* User-Priority-Range - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					557, 					/* Code */
					0, 					/* Vendor */
					"User-Priority-Range", 			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,			/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};
			struct local_rules_definition rules[] =
						{ 	 {  "Low-User-Priority", 	RULE_OPTIONAL, -1, -1 }
							,{  "High-User-Priority",	RULE_OPTIONAL, -1, -1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}
		/* S-VID-Start - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					553, 					/* Code */
					0, 					/* Vendor */
					"S-VID-Start", 				/* 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);
		}

		/* S-VID-End - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					554, 					/* Code */
					0, 					/* Vendor */
					"S-VID-End", 				/* 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);
		}

		/* C-VID-Start - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					555, 					/* Code */
					0, 					/* Vendor */
					"C-VID-Start",	 			/* 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);
		}

		/* C-VID-End - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					556, 					/* Code */
					0, 					/* Vendor */
					"C-VID-End",	 			/* 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);
		}

		/* VLAN-ID-Range - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					552, 					/* Code */
					0, 					/* Vendor */
					"VLAN-ID-Range",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "S-VID-Start",	RULE_OPTIONAL, -1, 1 }
							,{  "S-VID-End",	RULE_OPTIONAL, -1, 1 }
							,{  "C-VID-Start",	RULE_OPTIONAL, -1, 1 }
							,{  "C-VID-End",	RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* ETH-SAP - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					551, 					/* Code */
					0, 					/* Vendor */
					"ETH-SAP",				/* 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);
		}

		/* ETH-Ether-Type - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					550, 					/* Code */
					0, 					/* Vendor */
					"ETH-Ether-Type",			/* 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);
		}

		/* ETH-Proto-Type - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					549, 					/* Code */
					0, 					/* Vendor */
					"ETH-Proto-Type",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "ETH-Ether-Type",	RULE_OPTIONAL, -1, -1 }
							,{  "ETH-SAP",		RULE_OPTIONAL, -1, -1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* ETH-Option - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					548, 					/* Code */
					0, 					/* Vendor */
					"ETH-Option",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "ETH-Proto-Type",		RULE_REQUIRED, -1, 1 }
							,{  "VLAN-ID-Range",		RULE_OPTIONAL, -1, -1 }
							,{  "User-Priority-Range",	RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Negated - RFC 5777 */
		{
			/*

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Negated)"	, 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 = {
					517, 					/* Code */
					0, 					/* Vendor */
					"Negated",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &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);
		}

		/* ICMP-Code - RFC 5777 */
		{
			/*

			Here is what the RFC 5777 says :

			The ICMP-Code AVP (AVP Code 547) is of type Enumerated and the values
			are managed by IANA under the ICMP Type Numbers registry as defined
			in [RFC2780].

			The problem is (please refer to http://www.iana.org/assignments/icmp-parameters ) :
			Many of the ICMP types (AVP 456, see next AVP) have a "code" field (defined in this AVP).

			It means that the enum values defined in the current ICMP-Code AVP are not constants.

			We take the liberty of changing the Type of this AVP.

			NEW TYPE : Integer32

			*/

			struct dict_avp_data data = {
					547, 					/* Code */
					0, 					/* Vendor */
					"ICMP-Code", 				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_INTEGER32			/* base type of data */
					};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* ICMP-Type-Number - RFC 5777 */
		{
			/*

			The ICMP-Type-Number AVP (AVP Code 546) is of type Enumerated and the
			values are managed by IANA under the ICMP Type Numbers registry as
			defined in [RFC2780].

			The RFC2780 then redirect us to the IANA.

			The Values have been copied from the following page :
			http://www.iana.org/assignments/icmp-parameters

			Last updated : 2010-04-22

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(ICMP-Type-Number)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0  = { "Echo Reply",			{ .i32 = 0 }};
			struct dict_enumval_data 	t_3  = { "Destination Unreachable", 	{ .i32 = 3 }};
			struct dict_enumval_data 	t_4  = { "Source Quench",		{ .i32 = 4 }};
			struct dict_enumval_data 	t_5  = { "Redirect",			{ .i32 = 5 }};
			struct dict_enumval_data 	t_6  = { "Alternate Host Address",	{ .i32 = 6 }};
			struct dict_enumval_data 	t_8  = { "Echo",			{ .i32 = 8 }};
			struct dict_enumval_data 	t_9  = { "Router Advertisement",	{ .i32 = 9 }};
			struct dict_enumval_data 	t_10 = { "Router Solicitation",		{ .i32 = 10 }};
			struct dict_enumval_data 	t_11 = { "Time Exceeded",		{ .i32 = 11 }};
			struct dict_enumval_data 	t_12 = { "Parameter Problem",		{ .i32 = 12 }};
			struct dict_enumval_data 	t_13 = { "Timestamp",			{ .i32 = 13 }};
			struct dict_enumval_data 	t_14 = { "Timestamp Reply",		{ .i32 = 14 }};
			struct dict_enumval_data 	t_15 = { "Information Request",		{ .i32 = 15 }};
			struct dict_enumval_data 	t_16 = { "Information Reply",		{ .i32 = 16 }};
			struct dict_enumval_data 	t_17 = { "Address Mask Request",	{ .i32 = 17 }};
			struct dict_enumval_data 	t_18 = { "Address Mask Reply",		{ .i32 = 18 }};
			struct dict_enumval_data 	t_30 = { "Traceroute",			{ .i32 = 30 }};
			struct dict_enumval_data 	t_31 = { "Datagram Conversion Error",	{ .i32 = 31 }};
			struct dict_enumval_data 	t_32 = { "Mobile Host Redirect",	{ .i32 = 32 }};
			struct dict_enumval_data 	t_33 = { "IPv6 Where-Are-You",		{ .i32 = 33 }};
			struct dict_enumval_data 	t_34 = { "IPv6 I-Am-Here",		{ .i32 = 34 }};
			struct dict_enumval_data 	t_35 = { "Mobile Registration Request",	{ .i32 = 35 }};
			struct dict_enumval_data 	t_36 = { "Mobile Registration Reply  ",	{ .i32 = 36 }};
			struct dict_enumval_data 	t_37 = { "Domain Name Request",		{ .i32 = 37 }};
			struct dict_enumval_data 	t_38 = { "Domain Name Reply",		{ .i32 = 38 }};
			struct dict_enumval_data 	t_39 = { "SKIP",			{ .i32 = 39 }};
			struct dict_enumval_data 	t_40 = { "Photuris",			{ .i32 = 40 }};
			struct dict_enumval_data 	t_41 = { "ICMP messages utilized by experimental mobility protocols such as Seamoby",{ .i32 = 41 }};

			struct dict_avp_data 	data = {
					546, 					/* Code */
					0, 					/* Vendor */
					"ICMP-Type-Number",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &type);
			CHECK_dict_new( DICT_ENUMVAL, &t_0  , 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_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_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_ENUMVAL, &t_36 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_37 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_38 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_39 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_40 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_41 , type, NULL);
			CHECK_dict_new( DICT_AVP, &data , type, NULL);
		}

		/* ICMP-Type - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					545, 					/* Code */
					0, 					/* Vendor */
					"ICMP-Type",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "ICMP-Type-Number",	RULE_REQUIRED, -1, 1 }
							,{  "ICMP-Code",	RULE_OPTIONAL, -1, -1 }
							,{  "Negated",		RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Negated - RFC 5777 */

			/*
			Implemented higher
			*/

		/* TCP-Flag-Type - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					544, 					/* Code */
					0, 					/* Vendor */
					"TCP-Flag-Type",			/* 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);
		}

		/* TCP-Flags - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					543, 					/* Code */
					0, 					/* Vendor */
					"TCP-Flags",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "TCP-Flag-Type",	RULE_REQUIRED, -1, 1 }
							,{  "Negated",		RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* TCP-Option-Type - RFC 5777 */
		{
			/*
			The TCP-Option-Type AVP (AVP Code 541) is of type Enumerated and the
			values are managed by IANA under the TCP Option Numbers registry as
			defined in [RFC2780].

			The RFC2780 then redirect us to the IANA.

			The Values have been copied from the following page :
			http://www.iana.org/assignments/tcp-parameters/tcp-parameters.txt

			Last updated : 2010-06-22

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(TCP-Option-Type)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0   = { "End of Option List",			{ .i32 = 0  }};
			struct dict_enumval_data 	t_1   = { "No-Operation",			{ .i32 = 1  }};
			struct dict_enumval_data 	t_2   = { "Maximum Segment Size",		{ .i32 = 2  }};
			struct dict_enumval_data 	t_3   = { "WSOPT - Window Scale",		{ .i32 = 3  }};
			struct dict_enumval_data 	t_4   = { "SACK Permitted",			{ .i32 = 4  }};
			struct dict_enumval_data 	t_5   = { "SACK",				{ .i32 = 5  }};
			struct dict_enumval_data 	t_6   = { "Echo",				{ .i32 = 6  }};
			struct dict_enumval_data 	t_7   = { "Echo Reply",				{ .i32 = 7  }};
			struct dict_enumval_data 	t_8   = { "TSOPT - Time Stamp Option",		{ .i32 = 8  }};
			struct dict_enumval_data 	t_9   = { "Partial Order Connection Permitted",	{ .i32 = 9  }};
			struct dict_enumval_data 	t_10  = { "Partial Order Service Profile",	{ .i32 = 10 }};
			struct dict_enumval_data 	t_11  = { "CC",					{ .i32 = 11 }};
			struct dict_enumval_data 	t_12  = { "CC.NEW",				{ .i32 = 12 }};
			struct dict_enumval_data 	t_13  = { "CC.ECHO",				{ .i32 = 13 }};
			struct dict_enumval_data 	t_14  = { "TCP Alternate Checksum Request",	{ .i32 = 14 }};
			struct dict_enumval_data 	t_15  = { "TCP Alternate Checksum Data",	{ .i32 = 15 }};
			struct dict_enumval_data 	t_16  = { "Skeeter",				{ .i32 = 16 }};
			struct dict_enumval_data 	t_17  = { "Bubba",				{ .i32 = 17 }};
			struct dict_enumval_data 	t_18  = { "Trailer Checksum Option",		{ .i32 = 18 }};
			struct dict_enumval_data 	t_19  = { "MD5 Signature Option",		{ .i32 = 19 }};
			struct dict_enumval_data 	t_20  = { "SCPS Capabilities",			{ .i32 = 20 }};
			struct dict_enumval_data 	t_21  = { "Selective Negative Acknowledgements",{ .i32 = 21 }};
			struct dict_enumval_data 	t_22  = { "Record Boundaries",			{ .i32 = 22 }};
			struct dict_enumval_data 	t_23  = { "Corruption experienced",		{ .i32 = 23 }};
			struct dict_enumval_data 	t_24  = { "SNAP",				{ .i32 = 24 }};
			struct dict_enumval_data 	t_26  = { "TCP Compression Filter",		{ .i32 = 26 }};
			struct dict_enumval_data 	t_27  = { "Quick-Start Response",		{ .i32 = 27 }};
			struct dict_enumval_data 	t_28  = { "User Timeout Option",		{ .i32 = 28 }};
			struct dict_enumval_data 	t_29  = { "TCP Authentication Option (TCP-AO)",	{ .i32 = 29 }};

			struct dict_avp_data 	data = {
					541, 					/* Code */
					0, 					/* Vendor */
					"TCP-Option-Type",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &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_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_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_AVP, &data , type, NULL);
		}

		/* TCP-Option-Value - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					542, 					/* Code */
					0, 					/* Vendor */
					"TCP-Option-Value",			/* 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);
		}

		/* Negated - RFC 5777 */

			/*
			Implemented higher
			*/

		/* TCP-Option - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					540, 					/* Code */
					0, 					/* Vendor */
					"TCP-Option",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "TCP-Option-Type",	RULE_REQUIRED, -1, 1 }
							,{  "TCP-Option-Value",	RULE_OPTIONAL, -1, -1 }
							,{  "Negated",		RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* IP-Option-Type - RFC 5777 */
		{
			/*

			The IP-Option-Type AVP (AVP Code 538) is of type Enumerated and the
			values are managed by IANA under the IP Option Numbers registry as
			defined in [RFC2780].

			The RFC2780 then redirect us to the IANA.

			The Values have been copied from the following page :
			http://www.iana.org/assignments/ip-parameters

			Last updated : 2007-02-15

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(IP-Option-Type)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0   = { "End of Options List    [RFC791,JBP]",	{ .i32 = 0   }};
			struct dict_enumval_data 	t_1   = { "No Operation           [RFC791,JBP]", 	{ .i32 = 1   }};
			struct dict_enumval_data 	t_2   = { "Security                  [RFC1108]", 	{ .i32 = 2   }};
			struct dict_enumval_data 	t_3   = { "Loose Source Route     [RFC791,JBP]", 	{ .i32 = 3   }};
			struct dict_enumval_data 	t_4   = { "Time Stamp             [RFC791,JBP]", 	{ .i32 = 4   }};
			struct dict_enumval_data 	t_5   = { "Extended Security         [RFC1108]", 	{ .i32 = 5   }};
			struct dict_enumval_data 	t_6   = { "Commercial Security           [???]", 	{ .i32 = 6   }};
			struct dict_enumval_data 	t_7   = { "Record Route           [RFC791,JBP]", 	{ .i32 = 7   }};
			struct dict_enumval_data 	t_8   = { "Stream ID              [RFC791,JBP]", 	{ .i32 = 8   }};
			struct dict_enumval_data 	t_9   = { "Strict Source Route    [RFC791,JBP]", 	{ .i32 = 9   }};
			struct dict_enumval_data 	t_10  = { "Experimental Measurement      [ZSu]", 	{ .i32 = 10  }};
			struct dict_enumval_data 	t_11  = { "MTU Probe                 [RFC1191]*", 	{ .i32 = 11  }};
			struct dict_enumval_data 	t_12  = { "MTU Reply                 [RFC1191]*", 	{ .i32 = 12  }};
			struct dict_enumval_data 	t_13  = { "Experimental Flow Control    [Finn]", 	{ .i32 = 13  }};
			struct dict_enumval_data 	t_14  = { "Experimental Access Control [Estrin]", 	{ .i32 = 14  }};
			struct dict_enumval_data 	t_15  = { "???                      [VerSteeg]", 	{ .i32 = 15  }};
			struct dict_enumval_data 	t_16  = { "IMI Traffic Descriptor        [Lee]", 	{ .i32 = 16  }};
			struct dict_enumval_data 	t_17  = { "Extended Internet Protocol[RFC1385]", 	{ .i32 = 17  }};
			struct dict_enumval_data 	t_18  = { "Traceroute		   [RFC1393]", 		{ .i32 = 18  }};
			struct dict_enumval_data 	t_19  = { "Address Extension    [Ullmann IPv7]", 	{ .i32 = 19  }};
			struct dict_enumval_data 	t_20  = { "Router Alert              [RFC2113]", 	{ .i32 = 20  }};
			struct dict_enumval_data 	t_21  = { "Selective Directed Broadcast[Graff]", 	{ .i32 = 21  }};
			struct dict_enumval_data 	t_23  = { "Dynamic Packet State        [Malis]", 	{ .i32 = 23  }};
			struct dict_enumval_data 	t_24  = { "Upstream Multicast Pkt. [Farinacci]", 	{ .i32 = 24  }};
			struct dict_enumval_data 	t_25  = { "Quick-Start 		   [RFC4782]", 		{ .i32 = 25  }};

			struct dict_avp_data 	data = {
					538, 					/* Code */
					0, 					/* Vendor */
					"IP-Option-Type",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &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_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_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_AVP, &data , type, NULL);
		}

		/* IP-Option-Value - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					539, 					/* Code */
					0, 					/* Vendor */
					"IP-Option-Value",			/* 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);
		}

		/* Negated - RFC 5777 */

			/*
			Implemented higher
			*/

		/* IP-Option - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					537, 					/* Code */
					0, 					/* Vendor */
					"IP-Option",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "IP-Option-Type",	RULE_REQUIRED, -1, 1 }
							,{  "IP-Option-Value",	RULE_OPTIONAL, -1, -1 }
							,{  "Negated",		RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Fragmentation-Flag - RFC 5777 */
		{
			/*

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Fragmentation-Flag)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "DF",	{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "MF", 	{ .i32 = 1 }};

			struct dict_avp_data 	data = {
					536, 					/* Code */
					0, 					/* Vendor */
					"Fragmentation-Flag",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &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);
		}

		/* Diffserv-Code-Point - RFC 5777 */
		{
			/*
			The Diffserv-Code-Point AVP (AVP Code 535) is of type Enumerated and
			specifies the Differentiated Services Field Codepoints to match in
			the IP header.  The values are managed by IANA under the
			Differentiated Services Field Codepoints registry as defined in
			[RFC2474].

			The RFC2474 then redirect us to the IANA.

			The Values have been copied from the following page :
			http://www.iana.org/assignments/dscp-registry/dscp-registry.txt

			Last updated in code : 2010-05-11

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Diffserv-Code-Point)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0  = { "CS0",		{ .i32 = 0 }};
			struct dict_enumval_data 	t_8  = { "CS1",		{ .i32 = 8 }};
			struct dict_enumval_data 	t_16 = { "CS2",		{ .i32 = 16 }};
			struct dict_enumval_data 	t_24 = { "CS3",		{ .i32 = 24 }};
			struct dict_enumval_data 	t_32 = { "CS4",		{ .i32 = 32 }};
			struct dict_enumval_data 	t_40 = { "CS5",		{ .i32 = 40 }};
			struct dict_enumval_data 	t_48 = { "CS6",		{ .i32 = 48 }};
			struct dict_enumval_data 	t_56 = { "CS7",		{ .i32 = 56 }};
			struct dict_enumval_data 	t_10 = { "AF11",	{ .i32 = 10 }};
			struct dict_enumval_data 	t_12 = { "AF12",	{ .i32 = 12 }};
			struct dict_enumval_data 	t_14 = { "AF13",	{ .i32 = 14 }};
			struct dict_enumval_data 	t_18 = { "AF21",	{ .i32 = 18 }};
			struct dict_enumval_data 	t_20 = { "AF22",	{ .i32 = 20 }};
			struct dict_enumval_data 	t_22 = { "AF23",	{ .i32 = 22 }};
			struct dict_enumval_data 	t_26 = { "AF31",	{ .i32 = 26 }};
			struct dict_enumval_data 	t_28 = { "AF32",	{ .i32 = 28 }};
			struct dict_enumval_data 	t_30 = { "AF33",	{ .i32 = 30 }};
			struct dict_enumval_data 	t_34 = { "AF41",	{ .i32 = 34 }};
			struct dict_enumval_data 	t_36 = { "AF42",	{ .i32 = 36 }};
			struct dict_enumval_data 	t_38 = { "AF43",	{ .i32 = 38 }};
			struct dict_enumval_data 	t_46 = { "EF PHB",	{ .i32 = 46 }};
			struct dict_enumval_data 	t_44 = { "VOICE-ADMIT",	{ .i32 = 44 }};

			struct dict_avp_data 	data = {
					535, 					/* Code */
					0, 					/* Vendor */
					"Diffserv-Code-Point",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &type);
			CHECK_dict_new( DICT_ENUMVAL, &t_0  , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_8  , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_16 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_24 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_32 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_40 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_48 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_56 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_10 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_12 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_14 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_18 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_20 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_22 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_26 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_28 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_30 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_34 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_36 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_38 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_46 , type, NULL);
			CHECK_dict_new( DICT_ENUMVAL, &t_44 , type, NULL);
			CHECK_dict_new( DICT_AVP, &data , type, NULL);
		}

		/* IP-Address - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					518, 					/* Code */
					0, 					/* Vendor */
					"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 , Address_type, NULL);
		}

		/* IP-Address-Start - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					520, 					/* Code */
					0, 					/* Vendor */
					"IP-Address-Start",			/* 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 , Address_type, NULL);
		}

		/* IP-Address-End - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					521, 					/* Code */
					0, 					/* Vendor */
					"IP-Address-End",			/* 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 , Address_type, NULL);
		}

		/* IP-Address-Range - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					519, 					/* Code */
					0, 					/* Vendor */
					"IP-Address-Range",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "IP-Address-Start",	RULE_OPTIONAL, -1, 1 }
							,{  "IP-Address-End",	RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* IP-Address - RFC 5777 */

			/*
			Implemented higher
			*/

		/* IP-Mask-Bit-Mask-Width - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					523, 					/* Code */
					0, 					/* Vendor */
					"IP-Mask-Bit-Mask-Width",		/* 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);
		}

		/* IP-Address-Mask - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					522, 					/* Code */
					0, 					/* Vendor */
					"IP-Address-Mask",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "IP-Address",		RULE_REQUIRED, -1, 1 }
							,{  "IP-Mask-Bit-Mask-Width",	RULE_REQUIRED, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* MAC-Address - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					524, 					/* Code */
					0, 					/* Vendor */
					"MAC-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);
		}

		/* MAC-Address - RFC 5777 */

			/*
			Implemented higher
			*/

		/* MAC-Address-Mask-Pattern - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					526, 					/* Code */
					0, 					/* Vendor */
					"MAC-Address-Mask-Pattern",		/* 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);
		}

		/* MAC-Address-Mask - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					525, 					/* Code */
					0, 					/* Vendor */
					"MAC-Address-Mask",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "MAC-Address",		RULE_REQUIRED, -1, 1 }
							,{  "MAC-Address-Mask-Pattern",	RULE_REQUIRED, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* EUI64-Address - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					527, 					/* Code */
					0, 					/* Vendor */
					"EUI64-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);
		}

		/* EUI64-Address - RFC 5777 */

			/*
			Implemented higher
			*/

		/* EUI64-Address-Mask-Pattern - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					529, 					/* Code */
					0, 					/* Vendor */
					"EUI64-Address-Mask-Pattern",		/* 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);
		}

		/* EUI64-Address-Mask - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					528, 					/* Code */
					0, 					/* Vendor */
					"EUI64-Address-Mask",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "EUI64-Address",			RULE_REQUIRED, -1, 1 }
							,{  "EUI64-Address-Mask-Pattern",	RULE_REQUIRED, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Port - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					530, 					/* Code */
					0, 					/* Vendor */
					"Port",					/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_INTEGER32			/* base type of data */
					};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Port-Start - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					532, 					/* Code */
					0, 					/* Vendor */
					"Port-Start",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_INTEGER32			/* base type of data */
					};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Port-End - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					533, 					/* Code */
					0, 					/* Vendor */
					"Port-End",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_INTEGER32			/* base type of data */
					};

			CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
		}

		/* Port-Range - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					531, 					/* Code */
					0, 					/* Vendor */
					"Port-Range",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "Port-Start",	RULE_OPTIONAL, -1, 1 }
							,{  "Port-End",		RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Negated - RFC 5777 */

			/*
			Implemented higher
			*/

		/* Use-Assigned-Address - RFC 5777 */
		{
			/*

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Use-Assigned-Address)"	, 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 = {
					534, 					/* Code */
					0, 					/* Vendor */
					"Use-Assigned-Address",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &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);
		}

		/* From-Spec - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					515, 					/* Code */
					0, 					/* Vendor */
					"From-Spec",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "IP-Address",		RULE_OPTIONAL, -1, -1 }
							,{  "IP-Address-Range",		RULE_OPTIONAL, -1, -1 }
							,{  "IP-Address-Mask",		RULE_OPTIONAL, -1, -1 }
							,{  "MAC-Address",		RULE_OPTIONAL, -1, -1 }
							,{  "MAC-Address-Mask",		RULE_OPTIONAL, -1, -1 }
							,{  "EUI64-Address",		RULE_OPTIONAL, -1, -1 }
							,{  "EUI64-Address-Mask",	RULE_OPTIONAL, -1, -1 }
							,{  "Port",			RULE_OPTIONAL, -1, -1 }
							,{  "Port-Range",		RULE_OPTIONAL, -1, -1 }
							,{  "Negated",			RULE_OPTIONAL, -1, 1 }
							,{  "Use-Assigned-Address",	RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* To-Spec - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					516, 					/* Code */
					0, 					/* Vendor */
					"To-Spec",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "IP-Address",		RULE_OPTIONAL, -1, -1 }
							,{  "IP-Address-Range",		RULE_OPTIONAL, -1, -1 }
							,{  "IP-Address-Mask",		RULE_OPTIONAL, -1, -1 }
							,{  "MAC-Address",		RULE_OPTIONAL, -1, -1 }
							,{  "MAC-Address-Mask",		RULE_OPTIONAL, -1, -1 }
							,{  "EUI64-Address",		RULE_OPTIONAL, -1, -1 }
							,{  "EUI64-Address-Mask",	RULE_OPTIONAL, -1, -1 }
							,{  "Port",			RULE_OPTIONAL, -1, -1 }
							,{  "Port-Range",		RULE_OPTIONAL, -1, -1 }
							,{  "Negated",			RULE_OPTIONAL, -1, 1 }
							,{  "Use-Assigned-Address",	RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Direction - RFC 5777 */
		{
			/*

			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Direction)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "IN",	{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "OUT", 	{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "BOTH", { .i32 = 2 }};

			struct dict_avp_data 	data = {
					514, 					/* Code */
					0, 					/* Vendor */
					"Direction",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &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_AVP, &data , type, NULL);
		}

		/* Protocol - RFC 5777 */
		{
			/*
			The Protocol AVP (AVP Code 513) is of type Enumerated and specifies
			the protocol being matched.  The attributes included in the
			Classifier AVP MUST be consistent with the value of the Protocol AVP.
			Exactly zero or one Protocol AVP may be contained within a Classifier
			AVP.  If the Protocol AVP is omitted from the classifier, then
			comparison of the protocol of the packet is irrelevant.  The values
			for this AVP are managed by IANA under the Protocol Numbers registry
			as defined in [RFC3643].

			The RFC3643 then redirects us to the IANA.

			The Values have been copied from the following page :
			http://www.iana.org/assignments/ips-protocols

			Last updated : 2004-01-26
			*/
			struct dict_object 	* 	type;
			struct dict_type_data	 	tdata = { AVP_TYPE_INTEGER32,	"Enumerated(Protocol)"	, NULL, NULL, NULL };
			struct dict_enumval_data 	t_0 = { "Reserved",						{ .i32 = 0 }};
			struct dict_enumval_data 	t_1 = { "FCIP (Fibre Channel Over TCP/IP)", 			{ .i32 = 1 }};
			struct dict_enumval_data 	t_2 = { "iFCP (A Protocol for Internet Fibre Channel)", 	{ .i32 = 2 }};

			struct dict_avp_data 	data = {
					513, 					/* Code */
					0, 					/* Vendor */
					"Protocol",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					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, &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_AVP, &data , type, NULL);
		}

		/* Classifier-ID - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					512, 					/* Code */
					0, 					/* Vendor */
					"Classifier-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);
		}

		/* Classifier - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					511, 					/* Code */
					0, 					/* Vendor */
					"Classifier",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "Classifier-ID",		RULE_REQUIRED, -1, 1 }
							,{  "Protocol",			RULE_OPTIONAL, -1, 1 }
							,{  "Direction",		RULE_OPTIONAL, -1, 1 }
							,{  "From-Spec",		RULE_OPTIONAL, -1, -1 }
							,{  "To-Spec",			RULE_OPTIONAL, -1, -1 }
							,{  "Diffserv-Code-Point",	RULE_OPTIONAL, -1, -1 }
							,{  "Fragmentation-Flag",	RULE_OPTIONAL, -1, 1 }
							,{  "IP-Option",		RULE_OPTIONAL, -1, -1 }
							,{  "TCP-Option",		RULE_OPTIONAL, -1, -1 }
							,{  "TCP-Flags",		RULE_OPTIONAL, -1, 1 }
							,{  "ICMP-Type",		RULE_OPTIONAL, -1, -1 }
							,{  "ETH-Option",		RULE_OPTIONAL, -1, -1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* Filter-Rule-Precedence - RFC 5777 */
		{
			/*

			*/

			struct dict_avp_data data = {
					510, 					/* Code */
					0, 					/* Vendor */
					"Filter-Rule-Precedence",		/* 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);
		}

		/* Filter-Rule - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					509, 					/* Code */
					0, 					/* Vendor */
					"Filter-Rule",				/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "Filter-Rule-Precedence",	RULE_OPTIONAL, -1, 1 }
							,{  "Classifier",		RULE_OPTIONAL, -1, 1 }
							,{  "Time-Of-Day-Condition",	RULE_OPTIONAL, -1, -1 }
							,{  "Treatment-Action",		RULE_OPTIONAL, -1, 1 }
							,{  "QoS-Semantics",		RULE_OPTIONAL, -1, 1 }
							,{  "QoS-Profile-Template",	RULE_OPTIONAL, -1, 1 }
							,{  "QoS-Parameters",		RULE_OPTIONAL, -1, 1 }
							,{  "Excess-Treatment",		RULE_OPTIONAL, -1, 1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}

		/* QoS-Resources - RFC 5777 */
		{
			/*

			*/
			struct dict_object * avp;
			struct dict_avp_data data = {
					508, 					/* Code */
					0, 					/* Vendor */
					"QoS-Resources",			/* Name */
					AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, 	/* Fixed flags */
					AVP_FLAG_MANDATORY,		 	/* Fixed flag values */
					AVP_TYPE_GROUPED 			/* base type of data */
					};

			struct local_rules_definition rules[] =
						{ 	 {  "Filter-Rule", 		RULE_REQUIRED, -1, -1 }
						};

			CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
			PARSE_loc_rules( rules, avp );
		}
	}

	LOG_D( "Dictionary Extension 'Traffic Classification and Quality of Service (QoS) Attributes for Diameter (RFC 5777)' initialized");
	return 0;
}
EXTENSION_ENTRY("dict_rfc5777", dict_rfc5777_init);
