1560 lines
60 KiB
C
1560 lines
60 KiB
C
/****************
|
|
Contributed by: Konstantin Chekushin <koch@lmt.lv> and Thomas Klausner <tk@giga.or.at>
|
|
License: same as freeDiameter
|
|
****************/
|
|
|
|
|
|
/*
|
|
* Dictionary definitions of objects specified in DCCA (rfc4006).
|
|
*/
|
|
#include "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_ }}}
|
|
|
|
struct dict_object * g_dict_dba;
|
|
struct dict_object * g_dict_dcca;
|
|
struct dict_object * g_dict_cxdx;
|
|
|
|
extern int PARSE_loc_rules_(struct local_rules_definition _rulearray[], int len, struct dict_object *_parent);
|
|
int dict_dcca_entry(char * conffile)
|
|
{
|
|
TRACE_ENTRY("%p", conffile);
|
|
|
|
/* Applications section */
|
|
{
|
|
/* DBA */
|
|
{
|
|
struct dict_application_data data = { 3, "Diameter Base Accounting" };
|
|
CHECK_dict_new( DICT_APPLICATION, &data, NULL, &g_dict_dba);
|
|
}
|
|
|
|
/* DCCA */
|
|
{
|
|
struct dict_application_data data = { 4, "Diameter Credit Control Application" };
|
|
CHECK_dict_new( DICT_APPLICATION, &data, NULL, &g_dict_dcca);
|
|
}
|
|
/* CXDX */
|
|
{
|
|
struct dict_application_data data = { 16777216, "CX/DX" };
|
|
CHECK_dict_new( DICT_APPLICATION, &data, NULL, &g_dict_cxdx);
|
|
}
|
|
|
|
}
|
|
|
|
/* Result codes */
|
|
{
|
|
struct dict_object *ResultCodeType;
|
|
CHECK_dict_search(DICT_TYPE, TYPE_BY_NAME, "Enumerated*(Result-Code)", &ResultCodeType);
|
|
|
|
{
|
|
struct dict_enumval_data error_code = {"END_USER_SERVICE_DENIED",
|
|
{ .u32 = 4010}};
|
|
CHECK_dict_new(DICT_ENUMVAL, &error_code, ResultCodeType, NULL);
|
|
}
|
|
{
|
|
struct dict_enumval_data error_code = {"CREDIT_CONTROL_NOT_APPLICABLE",
|
|
{ .u32 = 4011}};
|
|
CHECK_dict_new(DICT_ENUMVAL, &error_code, ResultCodeType, NULL);
|
|
}
|
|
{
|
|
struct dict_enumval_data error_code = {"CREDIT_LIMIT_REACHED",
|
|
{ .u32 = 4012}};
|
|
CHECK_dict_new(DICT_ENUMVAL, &error_code, ResultCodeType, NULL);
|
|
}
|
|
{
|
|
struct dict_enumval_data error_code = {"USER_UNKNOWN",
|
|
{ .u32 = 5030}};
|
|
CHECK_dict_new(DICT_ENUMVAL, &error_code, ResultCodeType, NULL);
|
|
}
|
|
{
|
|
struct dict_enumval_data error_code = {"RATING_FAILED",
|
|
{ .u32 = 5031}};
|
|
CHECK_dict_new(DICT_ENUMVAL, &error_code, ResultCodeType, 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;
|
|
|
|
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);
|
|
|
|
|
|
/* CC-Correlation-Id */
|
|
{
|
|
/*
|
|
OctetString.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
411, /* Code */
|
|
0, /* Vendor */
|
|
"CC-Correlation-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);
|
|
}
|
|
|
|
/* CC-Input-Octets */
|
|
{
|
|
/*
|
|
Unsigned64.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
412, /* Code */
|
|
0, /* Vendor */
|
|
"CC-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);
|
|
}
|
|
|
|
/* CC-Output-Octets */
|
|
{
|
|
/*
|
|
Unsigned64.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
414, /* Code */
|
|
0, /* Vendor */
|
|
"CC-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);
|
|
}
|
|
|
|
/* CC-Request-Number */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
415, /* Code */
|
|
0, /* Vendor */
|
|
"CC-Request-Number", /* 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);
|
|
}
|
|
|
|
/* CC-Request-Type */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(CC-Request-Type)", NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "INITIAL_REQUEST", { .i32 = 1 }};
|
|
struct dict_enumval_data t_2 = { "UPDATE_REQUEST", { .i32 = 2 }};
|
|
struct dict_enumval_data t_3 = { "TERMINATION_REQUEST", { .i32 = 3 }};
|
|
struct dict_enumval_data t_4 = { "EVENT_REQUEST", { .i32 = 4 }};
|
|
|
|
|
|
struct dict_avp_data data = {
|
|
416, /* Code */
|
|
0, /* Vendor */
|
|
"CC-Request-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_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);
|
|
}
|
|
|
|
|
|
/* CC-Service-Specific-Units */
|
|
{
|
|
/*
|
|
Unsigned64.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
417, /* Code */
|
|
0, /* Vendor */
|
|
"CC-Service-Specific-Units", /* 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);
|
|
}
|
|
|
|
/* CC-Session-Failover */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(CC-Session-Failover)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "FAILOVER_NOT_SUPPORTED", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "FAILOVER_SUPPORTED", { .i32 = 1 }};
|
|
|
|
|
|
struct dict_avp_data data = {
|
|
418, /* Code */
|
|
0, /* Vendor */
|
|
"CC-Session-Failover", /* 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_1 , type, NULL);
|
|
CHECK_dict_new( DICT_ENUMVAL, &t_2 , type, NULL);
|
|
CHECK_dict_new( DICT_AVP, &data , type, NULL);
|
|
}
|
|
|
|
/* CC-Sub-Session-Id */
|
|
{
|
|
/*
|
|
Unsigned64.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
419, /* Code */
|
|
0, /* Vendor */
|
|
"CC-Sub-Session-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);
|
|
}
|
|
|
|
/* CC-Time */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
420, /* Code */
|
|
0, /* Vendor */
|
|
"CC-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);
|
|
}
|
|
|
|
/* CC-Total-Octets */
|
|
{
|
|
/*
|
|
Unsigned64.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
421, /* Code */
|
|
0, /* Vendor */
|
|
"CC-Total-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);
|
|
}
|
|
|
|
/* CC-Unit-Type */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(CC-Unit-Type)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "TIME", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "MONEY", { .i32 = 1 }};
|
|
struct dict_enumval_data t_3 = { "TOTAL-OCTETS", { .i32 = 2 }};
|
|
struct dict_enumval_data t_4 = { "INPUT-OCTETS", { .i32 = 3 }};
|
|
struct dict_enumval_data t_5 = { "OUTPUT-OCTETS", { .i32 = 4 }};
|
|
struct dict_enumval_data t_6 = { "SERVICE-SPECIFIC-UNITS", { .i32 = 5 }};
|
|
|
|
|
|
struct dict_avp_data data = {
|
|
454, /* Code */
|
|
0, /* Vendor */
|
|
"CC-Unit-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_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_AVP, &data , type, NULL);
|
|
}
|
|
|
|
/* Check-Balance-Result */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Check-Balance-Result)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "ENOUGH_CREDIT", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "NO_CREDIT", { .i32 = 1 }};
|
|
|
|
|
|
struct dict_avp_data data = {
|
|
422, /* Code */
|
|
0, /* Vendor */
|
|
"Check-Balance-Result", /* 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_1 , type, NULL);
|
|
CHECK_dict_new( DICT_ENUMVAL, &t_2 , type, NULL);
|
|
CHECK_dict_new( DICT_AVP, &data , type, NULL);
|
|
}
|
|
|
|
/* Cost-Unit */
|
|
{
|
|
/*
|
|
UTF8String.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
424, /* Code */
|
|
0, /* Vendor */
|
|
"Cost-Unit", /* 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);
|
|
}
|
|
|
|
/* Credit-Control */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Credit-Control)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "CREDIT_AUTHORIZATION", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "RE_AUTHORIZATION", { .i32 = 1 }};
|
|
|
|
struct dict_avp_data data = {
|
|
426, /* Code */
|
|
0, /* Vendor */
|
|
"Credit-Control", /* 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_1, type, NULL);
|
|
CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
|
|
CHECK_dict_new( DICT_AVP, &data , type, NULL);
|
|
}
|
|
|
|
/* Credit-Control-Failure-Handling */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Credit-Control-Failure-Handling)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "TERMINATE", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "CONTINUE", { .i32 = 1 }};
|
|
struct dict_enumval_data t_3 = { "RETRY_AND_TERMINATE", { .i32 = 2 }};
|
|
|
|
struct dict_avp_data data = {
|
|
427, /* Code */
|
|
0, /* Vendor */
|
|
"Credit-Control-Failure-Handling", /* 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_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);
|
|
}
|
|
|
|
/* Currency-Code */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
425, /* Code */
|
|
0, /* Vendor */
|
|
"Currency-Code", /* 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);
|
|
}
|
|
|
|
/* Direct-Debiting-Failure-Handling */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Direct-Debiting-Failure-Handling)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "TERMINATE_OR_BUFFER", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "CONTINUE", { .i32 = 1 }};
|
|
|
|
struct dict_avp_data data = {
|
|
428, /* Code */
|
|
0, /* Vendor */
|
|
"Direct-Debiting-Failure-Handling", /* 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_1 , type, NULL);
|
|
CHECK_dict_new( DICT_ENUMVAL, &t_2 , type, NULL);
|
|
CHECK_dict_new( DICT_AVP, &data , type, NULL);
|
|
}
|
|
|
|
/* Exponent */
|
|
{
|
|
/*
|
|
Integer32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
429, /* Code */
|
|
0, /* Vendor */
|
|
"Exponent", /* 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);
|
|
}
|
|
|
|
/* Final-Unit-Action */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Final-Unit-Action)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "TERMINATE", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "REDIRECT", { .i32 = 1 }};
|
|
struct dict_enumval_data t_3 = { "RESTRICT_ACCESS", { .i32 = 2 }};
|
|
|
|
struct dict_avp_data data = {
|
|
449, /* Code */
|
|
0, /* Vendor */
|
|
"Final-Unit-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_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);
|
|
}
|
|
|
|
/* G-S-U-Pool-Identifier */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
453, /* Code */
|
|
0, /* Vendor */
|
|
"G-S-U-Pool-Identifier", /* 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);
|
|
}
|
|
|
|
/* Multiple-Services-Indicator */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Multiple-Services-Indicator)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "MULTIPLE_SERVICES_NOT_SUPPORTED", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "MULTIPLE_SERVICES_SUPPORTED", { .i32 = 1 }};
|
|
|
|
struct dict_avp_data data = {
|
|
455, /* Code */
|
|
0, /* Vendor */
|
|
"Multiple-Services-Indicator", /* 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_1 , type, NULL);
|
|
CHECK_dict_new( DICT_ENUMVAL, &t_2 , type, NULL);
|
|
CHECK_dict_new( DICT_AVP, &data , type, NULL);
|
|
}
|
|
|
|
/* Rating-Group */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
432, /* Code */
|
|
0, /* Vendor */
|
|
"Rating-Group", /* 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);
|
|
}
|
|
|
|
/* Redirect-Address-Type */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Redirect-Address-Type)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "IPV4_ADDRESS", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "IPV6_ADDRESS", { .i32 = 1 }};
|
|
struct dict_enumval_data t_3 = { "URL", { .i32 = 2 }};
|
|
struct dict_enumval_data t_4 = { "SIP_URI", { .i32 = 3 }};
|
|
|
|
struct dict_avp_data data = {
|
|
433, /* Code */
|
|
0, /* Vendor */
|
|
"Redirect-Address-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_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);
|
|
}
|
|
|
|
/* Redirect-Server-Address */
|
|
{
|
|
/*
|
|
UTF8String.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
435, /* Code */
|
|
0, /* Vendor */
|
|
"Redirect-Server-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 , UTF8String_type, NULL);
|
|
}
|
|
|
|
/* Requested-Action */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Requested-Action)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "DIRECT_DEBITING", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "REFUND_ACCOUNT", { .i32 = 1 }};
|
|
struct dict_enumval_data t_3 = { "CHECK_BALANCE", { .i32 = 2 }};
|
|
struct dict_enumval_data t_4 = { "PRICE_ENQUIRY", { .i32 = 3 }};
|
|
|
|
struct dict_avp_data data = {
|
|
436, /* Code */
|
|
0, /* Vendor */
|
|
"Requested-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_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);
|
|
}
|
|
|
|
/* Restriction-Filter-Rule */
|
|
{
|
|
/*
|
|
IPFiltrRule.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
438, /* Code */
|
|
0, /* Vendor */
|
|
"Restriction-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);
|
|
}
|
|
/*Service-Context-Id */
|
|
{
|
|
/*
|
|
UTF8String.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
461, /* Code */
|
|
0, /* Vendor */
|
|
"Service-Context-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);
|
|
}
|
|
|
|
/* Service-Identifier */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
439, /* Code */
|
|
0, /* Vendor */
|
|
"Service-Identifier", /* 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);
|
|
}
|
|
|
|
/* Service-Parameter-Type */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
441, /* Code */
|
|
0, /* Vendor */
|
|
"Service-Parameter-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);
|
|
}
|
|
|
|
/* Service-Parameter-Value */
|
|
{
|
|
/*
|
|
OctetString.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
442, /* Code */
|
|
0, /* Vendor */
|
|
"Service-Parameter-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);
|
|
}
|
|
|
|
/* Subscription-Id-Data */
|
|
{
|
|
/*
|
|
UTF8String.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
444, /* Code */
|
|
0, /* Vendor */
|
|
"Subscription-Id-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 , UTF8String_type, NULL);
|
|
}
|
|
|
|
/* Subscription-Id-Type */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Subscription-Id-Type)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "END_USER_E164", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "END_USER_IMSI", { .i32 = 1 }};
|
|
struct dict_enumval_data t_3 = { "END_USER_SIP_URI", { .i32 = 2 }};
|
|
struct dict_enumval_data t_4 = { "END_USER_NAI", { .i32 = 3 }};
|
|
|
|
struct dict_avp_data data = {
|
|
450, /* Code */
|
|
0, /* Vendor */
|
|
"Subscription-Id-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_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);
|
|
}
|
|
|
|
/* Tariff-Change-Usage */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(Tariff-Change-Usage)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "UNIT_BEFORE_TARIFF_CHANGE", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "UNIT_AFTER_TARIFF_CHANGE", { .i32 = 1 }};
|
|
struct dict_enumval_data t_3 = { "UNIT_INDETERMINATE", { .i32 = 2 }};
|
|
|
|
struct dict_avp_data data = {
|
|
452, /* Code */
|
|
0, /* Vendor */
|
|
"Tariff-Change-Usage", /* 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_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);
|
|
}
|
|
|
|
/* Tariff-Time-Change */
|
|
{
|
|
/*
|
|
Time.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
451, /* Code */
|
|
0, /* Vendor */
|
|
"Tariff-Time-Change", /* 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);
|
|
}
|
|
|
|
/* User-Equipment-Info-Type */
|
|
{
|
|
/*
|
|
Enumerated.
|
|
*/
|
|
|
|
struct dict_object *type;
|
|
struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "Enumerated(User-Equipment-Info-Type)" , NULL, NULL, NULL };
|
|
struct dict_enumval_data t_1 = { "IMEISV", { .i32 = 0 }};
|
|
struct dict_enumval_data t_2 = { "MAC", { .i32 = 1 }};
|
|
struct dict_enumval_data t_3 = { "EUI64", { .i32 = 2 }};
|
|
|
|
struct dict_avp_data data = {
|
|
459, /* Code */
|
|
0, /* Vendor */
|
|
"User-Equipment-Info-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_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);
|
|
}
|
|
|
|
/* User-Equipment-Info-Value */
|
|
{
|
|
/*
|
|
OctetString.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
460, /* Code */
|
|
0, /* Vendor */
|
|
"User-Equipment-Info-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);
|
|
}
|
|
|
|
/* Value-Digits */
|
|
{
|
|
/*
|
|
Integer64.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
447, /* Code */
|
|
0, /* Vendor */
|
|
"Value-Digits", /* Name */
|
|
AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
|
|
AVP_FLAG_MANDATORY, /* Fixed flag values */
|
|
AVP_TYPE_INTEGER64 /* base type of data */
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
|
|
}
|
|
|
|
/* Validity-Time */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
448, /* Code */
|
|
0, /* Vendor */
|
|
"Validity-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);
|
|
}
|
|
|
|
/* Time-Quota-Threshold */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
868, /* Code */
|
|
10415, /* Vendor */
|
|
"Time-Quota-Threshold", /* Name */
|
|
AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
|
|
AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
|
|
AVP_TYPE_UNSIGNED32 /* base type of data */
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
|
|
}
|
|
|
|
|
|
/* Grouped AVPs below since they have dependencies on types above */
|
|
|
|
/* Redirect-Server */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
434, /* Code */
|
|
0, /* Vendor */
|
|
"Redirect-Server", /* 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[] = {
|
|
{ "Redirect-Address-Type", RULE_REQUIRED, -1, 1 },
|
|
{ "Redirect-Server-Address", RULE_REQUIRED, -1, 1 }
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* Service-Parameter-Info */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
440, /* Code */
|
|
0, /* Vendor */
|
|
"Service-Parameter-Info", /* 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[] = {
|
|
{ "Service-Parameter-Type", RULE_REQUIRED, -1, 1 },
|
|
{ "Service-Parameter-Value", RULE_REQUIRED, -1, 1 }
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* Subscription-Id */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
443, /* Code */
|
|
0, /* Vendor */
|
|
"Subscription-Id", /* 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[] = {
|
|
{ "Subscription-Id-Type", RULE_REQUIRED, -1, 1 },
|
|
{ "Subscription-Id-Data", RULE_REQUIRED, -1, 1 }
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* Unit-Value */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
445, /* Code */
|
|
0, /* Vendor */
|
|
"Unit-Value", /* 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[] = {
|
|
{ "Value-Digits", RULE_REQUIRED, -1, 1 },
|
|
{ "Exponent", RULE_OPTIONAL, -1, 1 }
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* User-Equipment-Info */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
458, /* Code */
|
|
0, /* Vendor */
|
|
"User-Equipment-Info", /* 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[] = {
|
|
{ "User-Equipment-Info-Type", RULE_REQUIRED, -1, 1 },
|
|
{ "User-Equipment-Info-Value", RULE_REQUIRED, -1, 1 }
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* grouped AVPs using grouped AVPs */
|
|
|
|
/* CC-Money */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
413, /* Code */
|
|
0, /* Vendor */
|
|
"CC-Money", /* 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[] = {
|
|
{ "Unit-Value", RULE_REQUIRED, -1, 1 },
|
|
{ "Currency-Code", RULE_OPTIONAL, -1, 1 }
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* Cost-Information */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
423, /* Code */
|
|
0, /* Vendor */
|
|
"Cost-Information", /* 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[] = {
|
|
{ "Unit-Value", RULE_REQUIRED, -1, 1 },
|
|
{ "Currency-Code", RULE_REQUIRED, -1, 1 },
|
|
{ "Cost-Unit", RULE_OPTIONAL, -1, 1 }
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* Final-Unit-Indication */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
430, /* Code */
|
|
0, /* Vendor */
|
|
"Final-Unit-Indication", /* 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[] = {
|
|
{ "Final-Unit-Action", RULE_REQUIRED, -1, 1 },
|
|
{ "Restriction-Filter-Rule", RULE_OPTIONAL, -1, -1 },
|
|
{ "Filter-Id", RULE_OPTIONAL, -1, -1 },
|
|
{ "Redirect-Server", RULE_OPTIONAL, -1, 1 },
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* Granted-Service-Unit */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
431, /* Code */
|
|
0, /* Vendor */
|
|
"Granted-Service-Unit", /* 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[] = {
|
|
{ "Tariff-Time-Change", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Time", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Money", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Total-Octets", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Input-Octets", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Output-Octets", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Service-Specific-Units", RULE_OPTIONAL, -1, 1 }
|
|
/* plus any additional AVPs { "AVP", RULE_OPTIONAL, -1, -1 } */
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* G-S-U-Pool-Reference */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
457, /* Code */
|
|
0, /* Vendor */
|
|
"G-S-U-Pool-Reference", /* 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[] = {
|
|
{ "G-S-U-Pool-Identifier", RULE_REQUIRED, -1, 1 },
|
|
{ "CC-Unit-Type", RULE_REQUIRED, -1, 1 },
|
|
{ "Unit-Value", RULE_REQUIRED, -1, 1 }
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* Requested-Service-Unit */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
437, /* Code */
|
|
0, /* Vendor */
|
|
"Requested-Service-Unit", /* 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[] = {
|
|
{ "CC-Time", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Money", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Total-Octets", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Input-Octets", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Output-Octets", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Service-Specific-Units", RULE_OPTIONAL, -1, 1 }
|
|
/* plus any additional AVPs { "AVP", RULE_OPTIONAL, -1, -1 } */
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
/* Used-Service-Unit */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
446, /* Code */
|
|
0, /* Vendor */
|
|
"Used-Service-Unit", /* 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[] = {
|
|
{ "Tariff-Change-Usage", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Time", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Money", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Total-Octets", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Input-Octets", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Output-Octets", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Service-Specific-Units", RULE_OPTIONAL, -1, 1 }
|
|
/* plus any additional AVPs { "AVP", RULE_OPTIONAL, -1, -1 } */
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
|
|
/* fj added 20170511. huawei expended */
|
|
/* Volume-Quota-Threshold */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
869, /* Code */
|
|
10415, /* Vendor */
|
|
"Volume-Quota-Threshold", /* Name */
|
|
AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
|
|
AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
|
|
AVP_TYPE_UNSIGNED32 /* base type of data */
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
|
|
}
|
|
|
|
/* Quota-Holding-Time */
|
|
{
|
|
/*
|
|
Unsigned32.
|
|
*/
|
|
struct dict_avp_data data = {
|
|
871, /* Code */
|
|
10415, /* Vendor */
|
|
"Quota-Holding-Time", /* Name */
|
|
AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
|
|
AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
|
|
AVP_TYPE_UNSIGNED32 /* base type of data */
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, NULL);
|
|
}
|
|
|
|
|
|
/* at least three levels of grouping */
|
|
/* Multiple-Services-Credit-Control */
|
|
{
|
|
/*
|
|
Grouped
|
|
*/
|
|
struct dict_object * avp;
|
|
struct dict_avp_data data = {
|
|
456, /* Code */
|
|
0, /* Vendor */
|
|
"Multiple-Services-Credit-Control", /* 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[] = {
|
|
{ "Granted-Service-Unit", RULE_OPTIONAL, -1, 1 },
|
|
{ "Requested-Service-Unit", RULE_OPTIONAL, -1, 1 },
|
|
{ "Used-Service-Unit", RULE_OPTIONAL, -1, -1 },
|
|
{ "Tariff-Change-Usage", RULE_OPTIONAL, -1, 1 },
|
|
{ "Service-Identifier", RULE_OPTIONAL, -1, -1 },
|
|
{ "Rating-Group", RULE_OPTIONAL, -1, 1 },
|
|
{ "G-S-U-Pool-Reference", RULE_OPTIONAL, -1, -1 },
|
|
{ "Validity-Time", RULE_OPTIONAL, -1, 1 },
|
|
{ "Result-Code", RULE_OPTIONAL, -1, 1 },
|
|
{ "Final-Unit-Indication", RULE_OPTIONAL, -1, 1 },
|
|
{ "Time-Quota-Threshold", RULE_OPTIONAL, -1, 1 },
|
|
{ "Volume-Quota-Threshold", RULE_OPTIONAL, -1, 1 },
|
|
{ "Quota-Holding-Time", RULE_OPTIONAL, -1, 1 },
|
|
|
|
/* plus any additional AVPs { "AVP", RULE_OPTIONAL, -1, -1 } */
|
|
};
|
|
CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), avp );
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/* Commands section */
|
|
{
|
|
/* Credit-Control-Request (CCR) Command */
|
|
{
|
|
/*
|
|
From RFC 4006:
|
|
|
|
3.1. Credit-Control-Request (CCR) Command
|
|
|
|
The Credit-Control-Request message (CCR) is indicated by the
|
|
command-code field being set to 272 and the 'R' bit being set in the
|
|
Command Flags field. It is used between the Diameter credit-control
|
|
client and the credit-control server to request credit authorization
|
|
for a given service.
|
|
|
|
The Auth-Application-Id MUST be set to the value 4, indicating the
|
|
Diameter credit-control application.
|
|
|
|
Message Format
|
|
|
|
<Credit-Control-Request> ::= < Diameter Header: 272, REQ, PXY >
|
|
< Session-Id >
|
|
{ Origin-Host }
|
|
{ Origin-Realm }
|
|
{ Destination-Realm }
|
|
{ Auth-Application-Id }
|
|
{ Service-Context-Id }
|
|
{ CC-Request-Type }
|
|
{ CC-Request-Number }
|
|
[ Destination-Host ]
|
|
[ User-Name ]
|
|
[ CC-Sub-Session-Id ]
|
|
[ Acct-Multi-Session-Id ]
|
|
[ Origin-State-Id ]
|
|
[ Event-Timestamp ]
|
|
*[ Subscription-Id ]
|
|
[ Service-Identifier ]
|
|
[ Termination-Cause ]
|
|
[ Requested-Service-Unit ]
|
|
[ Requested-Action ]
|
|
*[ Used-Service-Unit ]
|
|
[ Multiple-Services-Indicator ]
|
|
*[ Multiple-Services-Credit-Control ]
|
|
*[ Service-Parameter-Info ]
|
|
[ CC-Correlation-Id ]
|
|
[ User-Equipment-Info ]
|
|
*[ Proxy-Info ]
|
|
*[ Route-Record ]
|
|
*[ AVP ]
|
|
|
|
10.1. Credit-Control AVP Table
|
|
|
|
The table in this section is used to represent which credit-control
|
|
applications specific AVPs defined in this document are to be present
|
|
in the credit-control messages.
|
|
|
|
+-----------+
|
|
| Command |
|
|
| Code |
|
|
|-----+-----+
|
|
Attribute Name | CCR | CCA |
|
|
------------------------------|-----+-----+
|
|
Acct-Multi-Session-Id | 0-1 | 0-1 |
|
|
Auth-Application-Id | 1 | 1 |
|
|
CC-Correlation-Id | 0-1 | 0 |
|
|
CC-Session-Failover | 0 | 0-1 |
|
|
CC-Request-Number | 1 | 1 |
|
|
CC-Request-Type | 1 | 1 |
|
|
CC-Sub-Session-Id | 0-1 | 0-1 |
|
|
Check-Balance-Result | 0 | 0-1 |
|
|
Cost-Information | 0 | 0-1 |
|
|
Credit-Control-Failure- | 0 | 0-1 |
|
|
Handling | | |
|
|
Destination-Host | 0-1 | 0 |
|
|
Destination-Realm | 1 | 0 |
|
|
Direct-Debiting-Failure- | 0 | 0-1 |
|
|
Handling | | |
|
|
Event-Timestamp | 0-1 | 0-1 |
|
|
Failed-AVP | 0 | 0+ |
|
|
Final-Unit-Indication | 0 | 0-1 |
|
|
Granted-Service-Unit | 0 | 0-1 |
|
|
Multiple-Services-Credit- | 0+ | 0+ |
|
|
Control | | |
|
|
Multiple-Services-Indicator | 0-1 | 0 |
|
|
Origin-Host | 1 | 1 |
|
|
Origin-Realm | 1 | 1 |
|
|
Origin-State-Id | 0-1 | 0-1 |
|
|
Proxy-Info | 0+ | 0+ |
|
|
Redirect-Host | 0 | 0+ |
|
|
Redirect-Host-Usage | 0 | 0-1 |
|
|
Redirect-Max-Cache-Time | 0 | 0-1 |
|
|
Requested-Action | 0-1 | 0 |
|
|
Requested-Service-Unit | 0-1 | 0 |
|
|
Route-Record | 0+ | 0+ |
|
|
Result-Code | 0 | 1 |
|
|
Service-Context-Id | 1 | 0 |
|
|
Service-Identifier | 0-1 | 0 |
|
|
Service-Parameter-Info | 0+ | 0 |
|
|
Session-Id | 1 | 1 |
|
|
Subscription-Id | 0+ | 0 |
|
|
Termination-Cause | 0-1 | 0 |
|
|
User-Equipment-Info | 0-1 | 0 |
|
|
Used-Service-Unit | 0+ | 0 |
|
|
User-Name | 0-1 | 0-1 |
|
|
Validity-Time | 0 | 0-1 |
|
|
------------------------------|-----+-----+
|
|
|
|
|
|
*/
|
|
struct dict_object * cmd;
|
|
struct dict_cmd_data data = {
|
|
272, /* Code */
|
|
"Credit-Control-Request", /* Name */
|
|
CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE, /* Fixed flags */
|
|
CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE /* Fixed flag values */
|
|
};
|
|
struct local_rules_definition rules[] =
|
|
{
|
|
{ "Session-Id", RULE_FIXED_HEAD, -1, 1 },
|
|
{ "Origin-Host", RULE_REQUIRED, -1, 1 },
|
|
{ "Origin-Realm", RULE_REQUIRED, -1, 1 },
|
|
{ "Destination-Realm", RULE_REQUIRED, -1, 1 },
|
|
{ "Auth-Application-Id", RULE_REQUIRED, -1, 1 },
|
|
{ "Service-Context-Id", RULE_REQUIRED, -1, 1 },
|
|
{ "CC-Request-Type", RULE_REQUIRED, -1, 1 },
|
|
{ "CC-Request-Number", RULE_REQUIRED, -1, 1 },
|
|
{ "Destination-Host", RULE_OPTIONAL, -1, 1 },
|
|
{ "User-Name", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Sub-Session-Id", RULE_OPTIONAL, -1, 1 },
|
|
{ "Acct-Multi-Session-Id", RULE_OPTIONAL, -1, 1 },
|
|
{ "Origin-State-Id", RULE_OPTIONAL, -1, 1 },
|
|
{ "Event-Timestamp", RULE_OPTIONAL, -1, 1 },
|
|
{ "Subscription-Id", RULE_OPTIONAL, -1, -1 },
|
|
{ "Service-Identifier", RULE_OPTIONAL, -1, 1 },
|
|
{ "Termination-Cause", RULE_OPTIONAL, -1, 1 },
|
|
{ "Requested-Service-Unit", RULE_OPTIONAL, -1, 1 },
|
|
{ "Requested-Action", RULE_OPTIONAL, -1, 1 },
|
|
{ "Used-Service-Unit", RULE_OPTIONAL, -1, -1 },
|
|
{ "Multiple-Services-Indicator", RULE_OPTIONAL, -1, 1 },
|
|
{ "Multiple-Services-Credit-Control", RULE_OPTIONAL, -1, -1 },
|
|
{ "Service-Parameter-Info", RULE_OPTIONAL, -1, -1 },
|
|
{ "CC-Correlation-Id", RULE_OPTIONAL, -1, 1 },
|
|
{ "User-Equipment-Info", RULE_OPTIONAL, -1, 1 },
|
|
{ "Proxy-Info", RULE_OPTIONAL, -1, -1 },
|
|
{ "Route-Record", RULE_OPTIONAL, -1, -1 },
|
|
{ "Service-Information", RULE_OPTIONAL, -1, 1 },
|
|
/* plus any additional AVPs { "AVP", RULE_OPTIONAL, -1, -1 } */
|
|
};
|
|
|
|
CHECK_dict_new( DICT_COMMAND, &data, g_dict_dcca, &cmd);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), cmd );
|
|
}
|
|
|
|
/* Credit-Control-Answer (CCA) Command */
|
|
{
|
|
/*
|
|
From RFC 4006:
|
|
3.2. Credit-Control-Answer (CCA) Command
|
|
|
|
The Credit-Control-Answer message (CCA) is indicated by the command-
|
|
code field being set to 272 and the 'R' bit being cleared in the
|
|
Command Flags field. It is used between the credit-control server
|
|
and the Diameter credit-control client to acknowledge a Credit-
|
|
Control-Request command.
|
|
|
|
Message Format
|
|
|
|
<Credit-Control-Answer> ::= < Diameter Header: 272, PXY >
|
|
< Session-Id >
|
|
{ Result-Code }
|
|
{ Origin-Host }
|
|
{ Origin-Realm }
|
|
{ Auth-Application-Id }
|
|
{ CC-Request-Type }
|
|
{ CC-Request-Number }
|
|
[ User-Name ]
|
|
[ CC-Session-Failover ]
|
|
[ CC-Sub-Session-Id ]
|
|
[ Acct-Multi-Session-Id ]
|
|
[ Origin-State-Id ]
|
|
[ Event-Timestamp ]
|
|
[ Granted-Service-Unit ]
|
|
*[ Multiple-Services-Credit-Control ]
|
|
[ Cost-Information]
|
|
[ Final-Unit-Indication ]
|
|
[ Check-Balance-Result ]
|
|
[ Credit-Control-Failure-Handling ]
|
|
[ Direct-Debiting-Failure-Handling ]
|
|
[ Validity-Time]
|
|
*[ Redirect-Host]
|
|
[ Redirect-Host-Usage ]
|
|
[ Redirect-Max-Cache-Time ]
|
|
*[ Proxy-Info ]
|
|
*[ Route-Record ]
|
|
*[ Failed-AVP ]
|
|
*[ AVP ]
|
|
|
|
*/
|
|
struct dict_object * cmd;
|
|
struct dict_cmd_data data = {
|
|
272, /* Code */
|
|
"Credit-Control-Answer", /* Name */
|
|
CMD_FLAG_REQUEST | CMD_FLAG_PROXIABLE | CMD_FLAG_ERROR, /* Fixed flags */
|
|
CMD_FLAG_PROXIABLE /* Fixed flag values */
|
|
};
|
|
struct local_rules_definition rules[] =
|
|
{
|
|
{ "Session-Id", RULE_FIXED_HEAD, -1, 1 },
|
|
{ "Result-Code", RULE_REQUIRED, -1, 1 },
|
|
{ "Origin-Host", RULE_REQUIRED, -1, 1 },
|
|
{ "Origin-Realm", RULE_REQUIRED, -1, 1 },
|
|
{ "Auth-Application-Id", RULE_REQUIRED, -1, 1 },
|
|
{ "CC-Request-Type", RULE_REQUIRED, -1, 1 },
|
|
{ "CC-Request-Number", RULE_REQUIRED, -1, 1 },
|
|
{ "User-Name", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Session-Failover", RULE_OPTIONAL, -1, 1 },
|
|
{ "CC-Sub-Session-Id", RULE_OPTIONAL, -1, 1 },
|
|
{ "Acct-Multi-Session-Id", RULE_OPTIONAL, -1, 1 },
|
|
{ "Origin-State-Id", RULE_OPTIONAL, -1, 1 },
|
|
{ "Event-Timestamp", RULE_OPTIONAL, -1, 1 },
|
|
{ "Granted-Service-Unit", RULE_OPTIONAL, -1, 1 },
|
|
{ "Multiple-Services-Credit-Control", RULE_OPTIONAL, -1, -1 },
|
|
{ "Cost-Information", RULE_OPTIONAL, -1, 1 },
|
|
{ "Final-Unit-Indication", RULE_OPTIONAL, -1, 1 },
|
|
{ "Check-Balance-Result", RULE_OPTIONAL, -1, 1 },
|
|
{ "Credit-Control-Failure-Handling", RULE_OPTIONAL, -1, 1 },
|
|
{ "Direct-Debiting-Failure-Handling", RULE_OPTIONAL, -1, 1 },
|
|
{ "Validity-Time", RULE_OPTIONAL, -1, 1 },
|
|
{ "Time-Quota-Threshold", RULE_OPTIONAL, -1, 1 },
|
|
{ "Redirect-Host", RULE_OPTIONAL, -1, -1 },
|
|
{ "Redirect-Host-Usage", RULE_OPTIONAL, -1, 1 },
|
|
{ "Redirect-Max-Cache-Time", RULE_OPTIONAL, -1, 1 },
|
|
{ "Proxy-Info", RULE_OPTIONAL, -1, -1 },
|
|
{ "Route-Record", RULE_OPTIONAL, -1, -1 },
|
|
{ "Failed-AVP", RULE_OPTIONAL, -1, -1 }
|
|
/* plus any additional AVPs { "AVP", RULE_OPTIONAL, -1, -1 } */
|
|
};
|
|
|
|
CHECK_dict_new( DICT_COMMAND, &data, g_dict_dcca, &cmd);
|
|
PARSE_loc_rules_( rules, sizeof(rules)/sizeof(rules[0]), cmd );
|
|
}
|
|
}
|
|
LOG_D( "Extension 'Dictionary definitions for DCCA (rfc4006)' initialized");
|
|
return 0;
|
|
}
|
|
|
|
/* needs dict_nasreq for Filter-Id */
|
|
// EXTENSION_ENTRY("dict_dcca", dict_dcca_entry, "dict_nasreq");
|