Gitiles
Code Review Sign In
gerrit.opencord.org / freeDiameter-old / eb10c6f4f21b424a7cededddce3bda18669d1b1f / . / extensions / dict_ts29212_avps / dict_ts29212_avps.c
blob: f0012beaa4774b8a343ac372e507038a6244663f [file] [log] [blame]
Brian Waters13d96012017-12-08 16:53:31 -0600[diff] [blame]1/*
2* Copyright (c) 2017 Sprint
3*
4* Licensed under the Apache License, Version 2.0 (the "License");
5* you may not use this file except in compliance with the License.
6* You may obtain a copy of the License at
7*
8* http://www.apache.org/licenses/LICENSE-2.0
9*
10* Unless required by applicable law or agreed to in writing, software
11* distributed under the License is distributed on an "AS IS" BASIS,
12* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13* See the License for the specific language governing permissions and
14* limitations under the License.
15*/
16
17/****************
18 Generated By: fdtool enhancements to diafuzzer
19 License: same as freeDiameter
20****************/
21
22
23/*
24 * Dictionary definitions of objects specified in ts29212_avps (e30).
25 */
26#include <freeDiameter/extension.h>
27
28#define PROTO_VER "e30"
29#define GEN_DATE 1506697181.97
30
31const char *ts29212_avps_proto_ver = PROTO_VER;
32const double ts29212_avps_gen_date = GEN_DATE;
33
34/* The content of this file follows the same structure as dict_base_proto.c */
35
36#define CHECK_dict_new( _type, _data, _parent, _ref ) \
37{ \
38 int _ret = fd_dict_new( fd_g_config->cnf_dict, (_type), (_data), (_parent), (_ref) ); \
39 if ( _ret != 0 && _ret != EEXIST ) \
40 return _ret; \
41}
42
43#define CHECK_dict_search( _type, _criteria, _what, _result ) \
44 CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, (_type), (_criteria), (_what), (_result), ENOENT) );
45
46struct local_rules_definition {
47 struct dict_avp_request avp_vendor_plus_name;
48 enum rule_position position;
49 int min;
50 int max;
51};
52
53#define RULE_ORDER( _position ) ((((_position) == RULE_FIXED_HEAD) || ((_position) == RULE_FIXED_TAIL)) ? 1 : 0 )
54
55/* Attention! This version of the macro uses AVP_BY_NAME_AND_VENDOR, in contrast to most other copies! */
56#define PARSE_loc_rules( _rulearray, _parent) { \
57 int __ar; \
58 for (__ar=0; __ar < sizeof(_rulearray) / sizeof((_rulearray)[0]); __ar++) { \
59 struct dict_rule_data __data = { NULL, \
60 (_rulearray)[__ar].position, \
61 0, \
62 (_rulearray)[__ar].min, \
63 (_rulearray)[__ar].max}; \
64 __data.rule_order = RULE_ORDER(__data.rule_position); \
65 CHECK_FCT( fd_dict_search( \
66 fd_g_config->cnf_dict, \
67 DICT_AVP, \
68 AVP_BY_NAME_AND_VENDOR, \
69 &(_rulearray)[__ar].avp_vendor_plus_name, \
70 &__data.rule_avp, 0 ) ); \
71 if ( !__data.rule_avp ) { \
72 TRACE_DEBUG(INFO, "AVP Not found: '%s'", (_rulearray)[__ar].avp_vendor_plus_name.avp_name); \
73 return ENOENT; \
74 } \
75 { \
76 int _ret = fd_dict_new( fd_g_config->cnf_dict, DICT_RULE, &(__data), (_parent), NULL ); \
77 if ( _ret != 0 && _ret != EEXIST ) { \
78 TRACE_DEBUG(INFO, "Error on rule with AVP '%s'", \
79 (_rulearray)[__ar].avp_vendor_plus_name.avp_name); \
80 return EINVAL; \
81 } \
82 } \
83 } \
84}
85
86#define CHECK_vendor_new( _data ) { \
87 struct dict_object * vendor_found; \
88 if (fd_dict_search(fd_g_config->cnf_dict,DICT_VENDOR,VENDOR_BY_ID,&_data.vendor_id,&vendor_found,ENOENT) == ENOENT) { \
89 CHECK_FCT(fd_dict_new(fd_g_config->cnf_dict, DICT_VENDOR, &_data, NULL, NULL)); \
90 } \
91}
92
93#define enumval_def_u32( _val_, _str_ ) \
94 { _str_, { .u32 = _val_ }}
95
96#define enumval_def_os( _len_, _val_, _str_ ) \
97 { _str_, { .os = { .data = (unsigned char *)_val_, .len = _len_ }}}
98
99
100static int dict_ts29212_avps_load_defs(char * conffile)
101{
102 TRACE_ENTRY("%p", conffile);
103 /* Application Section */
104 {
105 /* Create the vendors */ {
106 struct dict_vendor_data vendor_data = { 10415, "3GPP" };
107 CHECK_dict_new(DICT_VENDOR, &vendor_data, NULL, NULL)
108 }
109 }
110
111
112 /* AVP section */
113 {
114 struct dict_object * Address_type;
115 struct dict_object * UTF8String_type;
116 struct dict_object * DiameterIdentity_type;
117 struct dict_object * DiameterURI_type;
118 struct dict_object * Time_type;
119 struct dict_object * IPFilterRule_type;
120
121 CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Address", &Address_type);
122 CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "UTF8String", &UTF8String_type);
123 CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "DiameterIdentity", &DiameterIdentity_type);
124 CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "DiameterURI", &DiameterURI_type);
125 CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Time", &Time_type);
126 CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "IPFilterRule", &IPFilterRule_type);
127 /* 3GPP-PS-Data-Off-Status */
128 {
129 struct dict_avp_data data = {
130 2847, /* Code */
131 10415, /* Vendor */
132 "3GPP-PS-Data-Off-Status", /* Name */
133 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
134 AVP_FLAG_VENDOR, /* Fixed flag values */
135 AVP_TYPE_INTEGER32 /* base type of data */
136 };
137 struct dict_object *type;
138 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(3GPP-PS-Data-Off-Status)", NULL, NULL, NULL };
139 struct dict_enumval_data t_1 = { "ACTIVE", { .i32=0 }};
140 struct dict_enumval_data t_2 = { "INACTIVE", { .i32=1 }};
141 /* Create the Enumerated type, and then the AVP */
142 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
143 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
144 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
145 CHECK_dict_new( DICT_AVP, &data, type, NULL);
146 };
147 /* Access-Availability-Change-Reason */
148 {
149 struct dict_avp_data data = {
150 2833, /* Code */
151 10415, /* Vendor */
152 "Access-Availability-Change-Reason", /* Name */
153 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
154 AVP_FLAG_VENDOR, /* Fixed flag values */
155 AVP_TYPE_UNSIGNED32 /* base type of data */
156 };
157 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
158 };
159 /* AN-GW-Address */
160 {
161 struct dict_avp_data data = {
162 1050, /* Code */
163 10415, /* Vendor */
164 "AN-GW-Address", /* Name */
165 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
166 AVP_FLAG_VENDOR, /* Fixed flag values */
167 AVP_TYPE_OCTETSTRING /* base type of data */
168 };
169 CHECK_dict_new( DICT_AVP, &data, Address_type, NULL);
170 };
171 /* AN-GW-Status */
172 {
173 struct dict_avp_data data = {
174 2811, /* Code */
175 10415, /* Vendor */
176 "AN-GW-Status", /* Name */
177 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
178 AVP_FLAG_VENDOR, /* Fixed flag values */
179 AVP_TYPE_INTEGER32 /* base type of data */
180 };
181 struct dict_object *type;
182 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(AN-GW-Status)", NULL, NULL, NULL };
183 struct dict_enumval_data t_1 = { "AN_GW_FAILED", { .i32=0 }};
184 /* Create the Enumerated type, and then the AVP */
185 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
186 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
187 CHECK_dict_new( DICT_AVP, &data, type, NULL);
188 };
189 /* APN-Aggregate-Max-Bitrate-DL */
190 {
191 struct dict_avp_data data = {
192 1040, /* Code */
193 10415, /* Vendor */
194 "APN-Aggregate-Max-Bitrate-DL", /* Name */
195 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
196 AVP_FLAG_VENDOR, /* Fixed flag values */
197 AVP_TYPE_UNSIGNED32 /* base type of data */
198 };
199 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
200 };
201 /* APN-Aggregate-Max-Bitrate-UL */
202 {
203 struct dict_avp_data data = {
204 1041, /* Code */
205 10415, /* Vendor */
206 "APN-Aggregate-Max-Bitrate-UL", /* Name */
207 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
208 AVP_FLAG_VENDOR, /* Fixed flag values */
209 AVP_TYPE_UNSIGNED32 /* base type of data */
210 };
211 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
212 };
213 /* Bearer-Control-Mode */
214 {
215 struct dict_avp_data data = {
216 1023, /* Code */
217 10415, /* Vendor */
218 "Bearer-Control-Mode", /* Name */
219 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
220 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
221 AVP_TYPE_INTEGER32 /* base type of data */
222 };
223 struct dict_object *type;
224 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Bearer-Control-Mode)", NULL, NULL, NULL };
225 struct dict_enumval_data t_1 = { "UE_ONLY", { .i32=0 }};
226 struct dict_enumval_data t_2 = { "RESERVED", { .i32=1 }};
227 struct dict_enumval_data t_3 = { "UE_NW", { .i32=2 }};
228 /* Create the Enumerated type, and then the AVP */
229 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
230 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
231 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
232 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
233 CHECK_dict_new( DICT_AVP, &data, type, NULL);
234 };
235 /* Bearer-Identifier */
236 {
237 struct dict_avp_data data = {
238 1020, /* Code */
239 10415, /* Vendor */
240 "Bearer-Identifier", /* Name */
241 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
242 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
243 AVP_TYPE_OCTETSTRING /* base type of data */
244 };
245 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
246 };
247 /* Bearer-Operation */
248 {
249 struct dict_avp_data data = {
250 1021, /* Code */
251 10415, /* Vendor */
252 "Bearer-Operation", /* Name */
253 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
254 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
255 AVP_TYPE_INTEGER32 /* base type of data */
256 };
257 struct dict_object *type;
258 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Bearer-Operation)", NULL, NULL, NULL };
259 struct dict_enumval_data t_1 = { "TERMINATION", { .i32=0 }};
260 struct dict_enumval_data t_2 = { "ESTABLISHMENT", { .i32=1 }};
261 struct dict_enumval_data t_3 = { "MODIFICATION", { .i32=2 }};
262 /* Create the Enumerated type, and then the AVP */
263 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
264 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
265 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
266 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
267 CHECK_dict_new( DICT_AVP, &data, type, NULL);
268 };
269 /* Bearer-Usage */
270 {
271 struct dict_avp_data data = {
272 1000, /* Code */
273 10415, /* Vendor */
274 "Bearer-Usage", /* Name */
275 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
276 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
277 AVP_TYPE_INTEGER32 /* base type of data */
278 };
279 struct dict_object *type;
280 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Bearer-Usage)", NULL, NULL, NULL };
281 struct dict_enumval_data t_1 = { "GENERAL", { .i32=0 }};
282 struct dict_enumval_data t_2 = { "IMS_SIGNALLING", { .i32=1 }};
283 /* Create the Enumerated type, and then the AVP */
284 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
285 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
286 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
287 CHECK_dict_new( DICT_AVP, &data, type, NULL);
288 };
289 /* Charging-Correlation-Indicator */
290 {
291 struct dict_avp_data data = {
292 1073, /* Code */
293 10415, /* Vendor */
294 "Charging-Correlation-Indicator", /* Name */
295 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
296 AVP_FLAG_VENDOR, /* Fixed flag values */
297 AVP_TYPE_INTEGER32 /* base type of data */
298 };
299 struct dict_object *type;
300 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Charging-Correlation-Indicator)", NULL, NULL, NULL };
301 struct dict_enumval_data t_1 = { "CHARGING_IDENTIFIER_REQUIRED", { .i32=0 }};
302 /* Create the Enumerated type, and then the AVP */
303 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
304 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
305 CHECK_dict_new( DICT_AVP, &data, type, NULL);
306 };
307 /* Charging-Rule-Base-Name */
308 {
309 struct dict_avp_data data = {
310 1004, /* Code */
311 10415, /* Vendor */
312 "Charging-Rule-Base-Name", /* Name */
313 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
314 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
315 AVP_TYPE_OCTETSTRING /* base type of data */
316 };
317 CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
318 };
319 /* Charging-Rule-Name */
320 {
321 struct dict_avp_data data = {
322 1005, /* Code */
323 10415, /* Vendor */
324 "Charging-Rule-Name", /* Name */
325 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
326 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
327 AVP_TYPE_OCTETSTRING /* base type of data */
328 };
329 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
330 };
331 /* CoA-IP-Address */
332 {
333 struct dict_avp_data data = {
334 1035, /* Code */
335 10415, /* Vendor */
336 "CoA-IP-Address", /* Name */
337 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
338 AVP_FLAG_VENDOR, /* Fixed flag values */
339 AVP_TYPE_OCTETSTRING /* base type of data */
340 };
341 CHECK_dict_new( DICT_AVP, &data, Address_type, NULL);
342 };
343 /* Credit-Management-Status */
344 {
345 struct dict_avp_data data = {
346 1082, /* Code */
347 10415, /* Vendor */
348 "Credit-Management-Status", /* Name */
349 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
350 AVP_FLAG_VENDOR, /* Fixed flag values */
351 AVP_TYPE_UNSIGNED32 /* base type of data */
352 };
353 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
354 };
355 /* CSG-Information-Reporting */
356 {
357 struct dict_avp_data data = {
358 1071, /* Code */
359 10415, /* Vendor */
360 "CSG-Information-Reporting", /* Name */
361 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
362 AVP_FLAG_VENDOR, /* Fixed flag values */
363 AVP_TYPE_INTEGER32 /* base type of data */
364 };
365 struct dict_object *type;
366 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(CSG-Information-Reporting)", NULL, NULL, NULL };
367 struct dict_enumval_data t_1 = { "CHANGE_CSG_CELL", { .i32=0 }};
368 struct dict_enumval_data t_2 = { "CHANGE_CSG_SUBSCRIBED_HYBRID_CELL", { .i32=1 }};
369 struct dict_enumval_data t_3 = { "CHANGE_CSG_UNSUBSCRIBED_HYBRID_CELL", { .i32=2 }};
370 /* Create the Enumerated type, and then the AVP */
371 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
372 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
373 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
374 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
375 CHECK_dict_new( DICT_AVP, &data, type, NULL);
376 };
377 /* Default-Access */
378 {
379 struct dict_avp_data data = {
380 2829, /* Code */
381 10415, /* Vendor */
382 "Default-Access", /* Name */
383 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
384 AVP_FLAG_VENDOR, /* Fixed flag values */
385 AVP_TYPE_INTEGER32 /* base type of data */
386 };
387 struct dict_object *type;
388 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Default-Access)", NULL, NULL, NULL };
389 struct dict_enumval_data t_1 = { "GPP_GPRS", { .i32=0 }};
390 struct dict_enumval_data t_2 = { "DOCSIS", { .i32=1 }};
391 struct dict_enumval_data t_3 = { "xDSL", { .i32=2 }};
392 struct dict_enumval_data t_4 = { "WiMAX", { .i32=3 }};
393 struct dict_enumval_data t_5 = { "GPP2", { .i32=4 }};
394 struct dict_enumval_data t_6 = { "GPP_EPS", { .i32=5 }};
395 struct dict_enumval_data t_7 = { "Non_3GPP_EPS", { .i32=6 }};
396 struct dict_enumval_data t_8 = { "FBA", { .i32=7 }};
397 /* Create the Enumerated type, and then the AVP */
398 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
399 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
400 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
401 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
402 CHECK_dict_new( DICT_ENUMVAL, &t_4, type, NULL);
403 CHECK_dict_new( DICT_ENUMVAL, &t_5, type, NULL);
404 CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
405 CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
406 CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
407 CHECK_dict_new( DICT_AVP, &data, type, NULL);
408 };
409 /* Default-Bearer-Indication */
410 {
411 struct dict_avp_data data = {
412 2844, /* Code */
413 10415, /* Vendor */
414 "Default-Bearer-Indication", /* Name */
415 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
416 AVP_FLAG_VENDOR, /* Fixed flag values */
417 AVP_TYPE_INTEGER32 /* base type of data */
418 };
419 struct dict_object *type;
420 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Default-Bearer-Indication)", NULL, NULL, NULL };
421 struct dict_enumval_data t_1 = { "BIND_TO_DEF_BEARER", { .i32=0 }};
422 struct dict_enumval_data t_2 = { "BIND_TO_APPLICABLE_BEARER", { .i32=1 }};
423 /* Create the Enumerated type, and then the AVP */
424 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
425 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
426 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
427 CHECK_dict_new( DICT_AVP, &data, type, NULL);
428 };
429 /* Default-QoS-Name */
430 {
431 struct dict_avp_data data = {
432 2817, /* Code */
433 10415, /* Vendor */
434 "Default-QoS-Name", /* Name */
435 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
436 AVP_FLAG_VENDOR, /* Fixed flag values */
437 AVP_TYPE_OCTETSTRING /* base type of data */
438 };
439 CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
440 };
441 /* Event-Trigger */
442 {
443 struct dict_avp_data data = {
444 1006, /* Code */
445 10415, /* Vendor */
446 "Event-Trigger", /* Name */
447 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
448 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
449 AVP_TYPE_INTEGER32 /* base type of data */
450 };
451 struct dict_object *type;
452 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Event-Trigger)", NULL, NULL, NULL };
453 struct dict_enumval_data t_1 = { "SGSN_CHANGE", { .i32=0 }};
454 struct dict_enumval_data t_2 = { "QOS_CHANGE", { .i32=1 }};
455 struct dict_enumval_data t_3 = { "QOS_CHANGE_EXCEEDING_AUTHORIZATION", { .i32=11 }};
456 struct dict_enumval_data t_4 = { "RAI_CHANGE", { .i32=12 }};
457 struct dict_enumval_data t_5 = { "USER_LOCATION_CHANGE", { .i32=13 }};
458 struct dict_enumval_data t_6 = { "NO_EVENT_TRIGGERS", { .i32=14 }};
459 struct dict_enumval_data t_7 = { "OUT_OF_CREDIT", { .i32=15 }};
460 struct dict_enumval_data t_8 = { "REALLOCATION_OF_CREDIT", { .i32=16 }};
461 struct dict_enumval_data t_9 = { "REVALIDATION_TIMEOUT", { .i32=17 }};
462 struct dict_enumval_data t_10 = { "UE_IP_ADDRESS_ALLOCATE", { .i32=18 }};
463 struct dict_enumval_data t_11 = { "UE_IP_ADDRESS_RELEASE", { .i32=19 }};
464 struct dict_enumval_data t_12 = { "RAT_CHANGE", { .i32=2 }};
465 struct dict_enumval_data t_13 = { "DEFAULT_EPS_BEARER_QOS_CHANGE", { .i32=20 }};
466 struct dict_enumval_data t_14 = { "AN_GW_CHANGE", { .i32=21 }};
467 struct dict_enumval_data t_15 = { "SUCCESSFUL_RESOURCE_ALLOCATION", { .i32=22 }};
468 struct dict_enumval_data t_16 = { "RESOURCE_MODIFICATION_REQUEST", { .i32=23 }};
469 struct dict_enumval_data t_17 = { "PGW_TRACE_CONTROL", { .i32=24 }};
470 struct dict_enumval_data t_18 = { "UE_TIME_ZONE_CHANGE", { .i32=25 }};
471 struct dict_enumval_data t_19 = { "TAI_CHANGE", { .i32=26 }};
472 struct dict_enumval_data t_20 = { "ECGI_CHANGE", { .i32=27 }};
473 struct dict_enumval_data t_21 = { "CHARGING_CORRELATION_EXCHANGE", { .i32=28 }};
474 struct dict_enumval_data t_22 = { "APN_AMBR_MODIFICATION_FAILURE", { .i32=29 }};
475 struct dict_enumval_data t_23 = { "TFT_CHANGE", { .i32=3 }};
476 struct dict_enumval_data t_24 = { "USER_CSG_INFORMATION_CHANGE", { .i32=30 }};
477 struct dict_enumval_data t_25 = { "USAGE_REPORT", { .i32=33 }};
478 struct dict_enumval_data t_26 = { "DEFAULT_EPS_BEARER_QOS_MODIFICATION_FAILURE", { .i32=34 }};
479 struct dict_enumval_data t_27 = { "USER_CSG_HYBRID_SUBSCRIBED_INFORMATION_CHANGE", { .i32=35 }};
480 struct dict_enumval_data t_28 = { "HYBRID_UNSUBSCRIBED_INFORMATION_CHANGE", { .i32=36 }};
481 struct dict_enumval_data t_29 = { "ROUTING_RULE_CHANGE", { .i32=37 }};
482 struct dict_enumval_data t_30 = { "APPLICATION_START", { .i32=39 }};
483 struct dict_enumval_data t_31 = { "PLMN_CHANGE", { .i32=4 }};
484 struct dict_enumval_data t_32 = { "APPLICATION_STOP", { .i32=40 }};
485 struct dict_enumval_data t_33 = { "CS_TO_PS_HANDOVER", { .i32=42 }};
486 struct dict_enumval_data t_34 = { "UE_LOCAL_IP_ADDRESS_CHANGE", { .i32=43 }};
487 struct dict_enumval_data t_35 = { "NB_LOCAL_IP_ADDRESS_CHANGE", { .i32=44 }};
488 struct dict_enumval_data t_36 = { "ACCESS_NETWORK_INFO_REPORT", { .i32=45 }};
489 struct dict_enumval_data t_37 = { "CREDIT_MANAGEMENT_SESSION_FAILURE", { .i32=46 }};
490 struct dict_enumval_data t_38 = { "DEFAULT_QOS_CHANGE", { .i32=47 }};
491 struct dict_enumval_data t_39 = { "CHANGE_OF_UE_PRESENCE_IN_PRESENCE_REPORTING_AREA_REPORT", { .i32=48 }};
492 struct dict_enumval_data t_40 = { "ADDITION_OF_ACCESS", { .i32=49 }};
493 struct dict_enumval_data t_41 = { "LOSS_OF_BEARER", { .i32=5 }};
494 struct dict_enumval_data t_42 = { "REMOVAL_OF_ACCESS", { .i32=50 }};
495 struct dict_enumval_data t_43 = { "UNAVAILABLITY_OF_ACCESS", { .i32=51 }};
496 struct dict_enumval_data t_44 = { "AVAILABLITY_OF_ACCESS", { .i32=52 }};
497 struct dict_enumval_data t_45 = { "RESOURCE_RELEASE", { .i32=53 }};
498 struct dict_enumval_data t_46 = { "ENODEB_CHANGE", { .i32=54 }};
499 struct dict_enumval_data t_47 = { "GPP_PS_DATA_OFF_CHANGE", { .i32=55 }};
500 struct dict_enumval_data t_48 = { "RECOVERY_OF_BEARER", { .i32=6 }};
501 struct dict_enumval_data t_49 = { "IP_CAN_CHANGE", { .i32=7 }};
502 /* Create the Enumerated type, and then the AVP */
503 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
504 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
505 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
506 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
507 CHECK_dict_new( DICT_ENUMVAL, &t_4, type, NULL);
508 CHECK_dict_new( DICT_ENUMVAL, &t_5, type, NULL);
509 CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
510 CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
511 CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
512 CHECK_dict_new( DICT_ENUMVAL, &t_9, type, NULL);
513 CHECK_dict_new( DICT_ENUMVAL, &t_10, type, NULL);
514 CHECK_dict_new( DICT_ENUMVAL, &t_11, type, NULL);
515 CHECK_dict_new( DICT_ENUMVAL, &t_12, type, NULL);
516 CHECK_dict_new( DICT_ENUMVAL, &t_13, type, NULL);
517 CHECK_dict_new( DICT_ENUMVAL, &t_14, type, NULL);
518 CHECK_dict_new( DICT_ENUMVAL, &t_15, type, NULL);
519 CHECK_dict_new( DICT_ENUMVAL, &t_16, type, NULL);
520 CHECK_dict_new( DICT_ENUMVAL, &t_17, type, NULL);
521 CHECK_dict_new( DICT_ENUMVAL, &t_18, type, NULL);
522 CHECK_dict_new( DICT_ENUMVAL, &t_19, type, NULL);
523 CHECK_dict_new( DICT_ENUMVAL, &t_20, type, NULL);
524 CHECK_dict_new( DICT_ENUMVAL, &t_21, type, NULL);
525 CHECK_dict_new( DICT_ENUMVAL, &t_22, type, NULL);
526 CHECK_dict_new( DICT_ENUMVAL, &t_23, type, NULL);
527 CHECK_dict_new( DICT_ENUMVAL, &t_24, type, NULL);
528 CHECK_dict_new( DICT_ENUMVAL, &t_25, type, NULL);
529 CHECK_dict_new( DICT_ENUMVAL, &t_26, type, NULL);
530 CHECK_dict_new( DICT_ENUMVAL, &t_27, type, NULL);
531 CHECK_dict_new( DICT_ENUMVAL, &t_28, type, NULL);
532 CHECK_dict_new( DICT_ENUMVAL, &t_29, type, NULL);
533 CHECK_dict_new( DICT_ENUMVAL, &t_30, type, NULL);
534 CHECK_dict_new( DICT_ENUMVAL, &t_31, type, NULL);
535 CHECK_dict_new( DICT_ENUMVAL, &t_32, type, NULL);
536 CHECK_dict_new( DICT_ENUMVAL, &t_33, type, NULL);
537 CHECK_dict_new( DICT_ENUMVAL, &t_34, type, NULL);
538 CHECK_dict_new( DICT_ENUMVAL, &t_35, type, NULL);
539 CHECK_dict_new( DICT_ENUMVAL, &t_36, type, NULL);
540 CHECK_dict_new( DICT_ENUMVAL, &t_37, type, NULL);
541 CHECK_dict_new( DICT_ENUMVAL, &t_38, type, NULL);
542 CHECK_dict_new( DICT_ENUMVAL, &t_39, type, NULL);
543 CHECK_dict_new( DICT_ENUMVAL, &t_40, type, NULL);
544 CHECK_dict_new( DICT_ENUMVAL, &t_41, type, NULL);
545 CHECK_dict_new( DICT_ENUMVAL, &t_42, type, NULL);
546 CHECK_dict_new( DICT_ENUMVAL, &t_43, type, NULL);
547 CHECK_dict_new( DICT_ENUMVAL, &t_44, type, NULL);
548 CHECK_dict_new( DICT_ENUMVAL, &t_45, type, NULL);
549 CHECK_dict_new( DICT_ENUMVAL, &t_46, type, NULL);
550 CHECK_dict_new( DICT_ENUMVAL, &t_47, type, NULL);
551 CHECK_dict_new( DICT_ENUMVAL, &t_48, type, NULL);
552 CHECK_dict_new( DICT_ENUMVAL, &t_49, type, NULL);
553 CHECK_dict_new( DICT_AVP, &data, type, NULL);
554 };
555 /* Execution-Time */
556 {
557 struct dict_avp_data data = {
558 2839, /* Code */
559 10415, /* Vendor */
560 "Execution-Time", /* Name */
561 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
562 AVP_FLAG_VENDOR, /* Fixed flag values */
563 AVP_TYPE_OCTETSTRING /* base type of data */
564 };
565 CHECK_dict_new( DICT_AVP, &data, Time_type, NULL);
566 };
567 /* Flow-Direction */
568 {
569 struct dict_avp_data data = {
570 1080, /* Code */
571 10415, /* Vendor */
572 "Flow-Direction", /* Name */
573 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
574 AVP_FLAG_VENDOR, /* Fixed flag values */
575 AVP_TYPE_INTEGER32 /* base type of data */
576 };
577 struct dict_object *type;
578 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Flow-Direction)", NULL, NULL, NULL };
579 struct dict_enumval_data t_1 = { "UNSPECIFIED", { .i32=0 }};
580 struct dict_enumval_data t_2 = { "DOWNLINK", { .i32=1 }};
581 struct dict_enumval_data t_3 = { "UPLINK", { .i32=2 }};
582 struct dict_enumval_data t_4 = { "BIDIRECTIONAL", { .i32=3 }};
583 /* Create the Enumerated type, and then the AVP */
584 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
585 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
586 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
587 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
588 CHECK_dict_new( DICT_ENUMVAL, &t_4, type, NULL);
589 CHECK_dict_new( DICT_AVP, &data, type, NULL);
590 };
591 /* Flow-Label */
592 {
593 struct dict_avp_data data = {
594 1057, /* Code */
595 10415, /* Vendor */
596 "Flow-Label", /* Name */
597 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
598 AVP_FLAG_VENDOR, /* Fixed flag values */
599 AVP_TYPE_OCTETSTRING /* base type of data */
600 };
601 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
602 };
603 /* Guaranteed-Bitrate-DL */
604 {
605 struct dict_avp_data data = {
606 1025, /* Code */
607 10415, /* Vendor */
608 "Guaranteed-Bitrate-DL", /* Name */
609 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
610 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
611 AVP_TYPE_UNSIGNED32 /* base type of data */
612 };
613 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
614 };
615 /* Guaranteed-Bitrate-UL */
616 {
617 struct dict_avp_data data = {
618 1026, /* Code */
619 10415, /* Vendor */
620 "Guaranteed-Bitrate-UL", /* Name */
621 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
622 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
623 AVP_TYPE_UNSIGNED32 /* base type of data */
624 };
625 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
626 };
627 /* HeNB-Local-IP-Address */
628 {
629 struct dict_avp_data data = {
630 2804, /* Code */
631 10415, /* Vendor */
632 "HeNB-Local-IP-Address", /* Name */
633 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
634 AVP_FLAG_VENDOR, /* Fixed flag values */
635 AVP_TYPE_OCTETSTRING /* base type of data */
636 };
637 CHECK_dict_new( DICT_AVP, &data, Address_type, NULL);
638 };
639 /* IP-CAN-Session-Charging-Scope */
640 {
641 struct dict_avp_data data = {
642 2827, /* Code */
643 10415, /* Vendor */
644 "IP-CAN-Session-Charging-Scope", /* Name */
645 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
646 AVP_FLAG_VENDOR, /* Fixed flag values */
647 AVP_TYPE_INTEGER32 /* base type of data */
648 };
649 struct dict_object *type;
650 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(IP-CAN-Session-Charging-Scope)", NULL, NULL, NULL };
651 struct dict_enumval_data t_1 = { "IP_CAN_SESSION_SCOPE", { .i32=0 }};
652 /* Create the Enumerated type, and then the AVP */
653 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
654 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
655 CHECK_dict_new( DICT_AVP, &data, type, NULL);
656 };
657 /* IP-CAN-Type */
658 {
659 struct dict_avp_data data = {
660 1027, /* Code */
661 10415, /* Vendor */
662 "IP-CAN-Type", /* Name */
663 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
664 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
665 AVP_TYPE_INTEGER32 /* base type of data */
666 };
667 struct dict_object *type;
668 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(IP-CAN-Type)", NULL, NULL, NULL };
669 struct dict_enumval_data t_1 = { "GPP_GPRS", { .i32=0 }};
670 struct dict_enumval_data t_2 = { "DOCSIS", { .i32=1 }};
671 struct dict_enumval_data t_3 = { "xDSL", { .i32=2 }};
672 struct dict_enumval_data t_4 = { "WiMAX", { .i32=3 }};
673 struct dict_enumval_data t_5 = { "GPP2", { .i32=4 }};
674 struct dict_enumval_data t_6 = { "GPP_EPS", { .i32=5 }};
675 struct dict_enumval_data t_7 = { "Non_3GPP_EPS", { .i32=6 }};
676 struct dict_enumval_data t_8 = { "FBA", { .i32=7 }};
677 /* Create the Enumerated type, and then the AVP */
678 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
679 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
680 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
681 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
682 CHECK_dict_new( DICT_ENUMVAL, &t_4, type, NULL);
683 CHECK_dict_new( DICT_ENUMVAL, &t_5, type, NULL);
684 CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
685 CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
686 CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
687 CHECK_dict_new( DICT_AVP, &data, type, NULL);
688 };
689 /* Metering-Method */
690 {
691 struct dict_avp_data data = {
692 1007, /* Code */
693 10415, /* Vendor */
694 "Metering-Method", /* Name */
695 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
696 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
697 AVP_TYPE_INTEGER32 /* base type of data */
698 };
699 struct dict_object *type;
700 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Metering-Method)", NULL, NULL, NULL };
701 struct dict_enumval_data t_1 = { "DURATION", { .i32=0 }};
702 struct dict_enumval_data t_2 = { "VOLUME", { .i32=1 }};
703 struct dict_enumval_data t_3 = { "DURATION_VOLUME", { .i32=2 }};
704 struct dict_enumval_data t_4 = { "EVENT", { .i32=3 }};
705 /* Create the Enumerated type, and then the AVP */
706 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
707 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
708 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
709 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
710 CHECK_dict_new( DICT_ENUMVAL, &t_4, type, NULL);
711 CHECK_dict_new( DICT_AVP, &data, type, NULL);
712 };
713 /* Monitoring-Flags */
714 {
715 struct dict_avp_data data = {
716 2828, /* Code */
717 10415, /* Vendor */
718 "Monitoring-Flags", /* Name */
719 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
720 AVP_FLAG_VENDOR, /* Fixed flag values */
721 AVP_TYPE_UNSIGNED32 /* base type of data */
722 };
723 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
724 };
725 /* Monitoring-Key */
726 {
727 struct dict_avp_data data = {
728 1066, /* Code */
729 10415, /* Vendor */
730 "Monitoring-Key", /* Name */
731 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
732 AVP_FLAG_VENDOR, /* Fixed flag values */
733 AVP_TYPE_OCTETSTRING /* base type of data */
734 };
735 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
736 };
737 /* Mute-Notification */
738 {
739 struct dict_avp_data data = {
740 2809, /* Code */
741 10415, /* Vendor */
742 "Mute-Notification", /* Name */
743 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
744 AVP_FLAG_VENDOR, /* Fixed flag values */
745 AVP_TYPE_INTEGER32 /* base type of data */
746 };
747 struct dict_object *type;
748 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Mute-Notification)", NULL, NULL, NULL };
749 struct dict_enumval_data t_1 = { "MUTE_REQUIRED", { .i32=0 }};
750 /* Create the Enumerated type, and then the AVP */
751 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
752 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
753 CHECK_dict_new( DICT_AVP, &data, type, NULL);
754 };
755 /* Monitoring-Time */
756 {
757 struct dict_avp_data data = {
758 2810, /* Code */
759 10415, /* Vendor */
760 "Monitoring-Time", /* Name */
761 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
762 AVP_FLAG_VENDOR, /* Fixed flag values */
763 AVP_TYPE_OCTETSTRING /* base type of data */
764 };
765 CHECK_dict_new( DICT_AVP, &data, Time_type, NULL);
766 };
767 /* NBIFOM-Mode */
768 {
769 struct dict_avp_data data = {
770 2830, /* Code */
771 10415, /* Vendor */
772 "NBIFOM-Mode", /* Name */
773 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
774 AVP_FLAG_VENDOR, /* Fixed flag values */
775 AVP_TYPE_INTEGER32 /* base type of data */
776 };
777 struct dict_object *type;
778 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(NBIFOM-Mode)", NULL, NULL, NULL };
779 struct dict_enumval_data t_1 = { "UE_INITIATED", { .i32=0 }};
780 struct dict_enumval_data t_2 = { "NETWORK_INITIATED", { .i32=1 }};
781 /* Create the Enumerated type, and then the AVP */
782 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
783 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
784 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
785 CHECK_dict_new( DICT_AVP, &data, type, NULL);
786 };
787 /* NBIFOM-Support */
788 {
789 struct dict_avp_data data = {
790 2831, /* Code */
791 10415, /* Vendor */
792 "NBIFOM-Support", /* Name */
793 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
794 AVP_FLAG_VENDOR, /* Fixed flag values */
795 AVP_TYPE_INTEGER32 /* base type of data */
796 };
797 struct dict_object *type;
798 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(NBIFOM-Support)", NULL, NULL, NULL };
799 struct dict_enumval_data t_1 = { "NBIFOM_NOT_SUPPORTED", { .i32=0 }};
800 struct dict_enumval_data t_2 = { "NBIFOM_SUPPORTED", { .i32=1 }};
801 /* Create the Enumerated type, and then the AVP */
802 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
803 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
804 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
805 CHECK_dict_new( DICT_AVP, &data, type, NULL);
806 };
807 /* NetLoc-Access-Support */
808 {
809 struct dict_avp_data data = {
810 2824, /* Code */
811 10415, /* Vendor */
812 "NetLoc-Access-Support", /* Name */
813 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
814 AVP_FLAG_VENDOR, /* Fixed flag values */
815 AVP_TYPE_UNSIGNED32 /* base type of data */
816 };
817 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
818 };
819 /* Network-Request-Support */
820 {
821 struct dict_avp_data data = {
822 1024, /* Code */
823 10415, /* Vendor */
824 "Network-Request-Support", /* Name */
825 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
826 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
827 AVP_TYPE_INTEGER32 /* base type of data */
828 };
829 struct dict_object *type;
830 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Network-Request-Support)", NULL, NULL, NULL };
831 struct dict_enumval_data t_1 = { "NETWORK_REQUEST_NOT_SUPPORTED", { .i32=0 }};
832 struct dict_enumval_data t_2 = { "NETWORK_REQUEST_SUPPORTED", { .i32=1 }};
833 /* Create the Enumerated type, and then the AVP */
834 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
835 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
836 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
837 CHECK_dict_new( DICT_AVP, &data, type, NULL);
838 };
839 /* Offline */
840 {
841 struct dict_avp_data data = {
842 1008, /* Code */
843 10415, /* Vendor */
844 "Offline", /* Name */
845 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
846 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
847 AVP_TYPE_INTEGER32 /* base type of data */
848 };
849 struct dict_object *type;
850 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Offline)", NULL, NULL, NULL };
851 struct dict_enumval_data t_1 = { "DISABLE_OFFLINE", { .i32=0 }};
852 struct dict_enumval_data t_2 = { "ENABLE_OFFLINE", { .i32=1 }};
853 /* Create the Enumerated type, and then the AVP */
854 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
855 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
856 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
857 CHECK_dict_new( DICT_AVP, &data, type, NULL);
858 };
859 /* Online */
860 {
861 struct dict_avp_data data = {
862 1009, /* Code */
863 10415, /* Vendor */
864 "Online", /* Name */
865 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
866 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
867 AVP_TYPE_INTEGER32 /* base type of data */
868 };
869 struct dict_object *type;
870 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Online)", NULL, NULL, NULL };
871 struct dict_enumval_data t_1 = { "DISABLE_ONLINE", { .i32=0 }};
872 struct dict_enumval_data t_2 = { "ENABLE_ONLINE", { .i32=1 }};
873 /* Create the Enumerated type, and then the AVP */
874 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
875 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
876 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
877 CHECK_dict_new( DICT_AVP, &data, type, NULL);
878 };
879 /* Packet-Filter-Content */
880 {
881 struct dict_avp_data data = {
882 1059, /* Code */
883 10415, /* Vendor */
884 "Packet-Filter-Content", /* Name */
885 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
886 AVP_FLAG_VENDOR, /* Fixed flag values */
887 AVP_TYPE_OCTETSTRING /* base type of data */
888 };
889 CHECK_dict_new( DICT_AVP, &data, IPFilterRule_type, NULL);
890 };
891 /* Packet-Filter-Identifier */
892 {
893 struct dict_avp_data data = {
894 1060, /* Code */
895 10415, /* Vendor */
896 "Packet-Filter-Identifier", /* Name */
897 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
898 AVP_FLAG_VENDOR, /* Fixed flag values */
899 AVP_TYPE_OCTETSTRING /* base type of data */
900 };
901 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
902 };
903 /* Packet-Filter-Operation */
904 {
905 struct dict_avp_data data = {
906 1062, /* Code */
907 10415, /* Vendor */
908 "Packet-Filter-Operation", /* Name */
909 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
910 AVP_FLAG_VENDOR, /* Fixed flag values */
911 AVP_TYPE_INTEGER32 /* base type of data */
912 };
913 struct dict_object *type;
914 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Packet-Filter-Operation)", NULL, NULL, NULL };
915 struct dict_enumval_data t_1 = { "DELETION", { .i32=0 }};
916 struct dict_enumval_data t_2 = { "ADDITION", { .i32=1 }};
917 struct dict_enumval_data t_3 = { "MODIFICATION", { .i32=2 }};
918 /* Create the Enumerated type, and then the AVP */
919 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
920 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
921 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
922 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
923 CHECK_dict_new( DICT_AVP, &data, type, NULL);
924 };
925 /* Packet-Filter-Usage */
926 {
927 struct dict_avp_data data = {
928 1072, /* Code */
929 10415, /* Vendor */
930 "Packet-Filter-Usage", /* Name */
931 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
932 AVP_FLAG_VENDOR, /* Fixed flag values */
933 AVP_TYPE_INTEGER32 /* base type of data */
934 };
935 struct dict_object *type;
936 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Packet-Filter-Usage)", NULL, NULL, NULL };
937 struct dict_enumval_data t_1 = { "SEND_TO_UE", { .i32=1 }};
938 /* Create the Enumerated type, and then the AVP */
939 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
940 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
941 CHECK_dict_new( DICT_AVP, &data, type, NULL);
942 };
943 /* PCC-Rule-Status */
944 {
945 struct dict_avp_data data = {
946 1019, /* Code */
947 10415, /* Vendor */
948 "PCC-Rule-Status", /* Name */
949 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
950 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
951 AVP_TYPE_INTEGER32 /* base type of data */
952 };
953 struct dict_object *type;
954 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(PCC-Rule-Status)", NULL, NULL, NULL };
955 struct dict_enumval_data t_1 = { "ACTIVE", { .i32=0 }};
956 struct dict_enumval_data t_2 = { "INACTIVE", { .i32=1 }};
957 struct dict_enumval_data t_3 = { "TEMPORARILY_INACTIVE", { .i32=2 }};
958 /* Create the Enumerated type, and then the AVP */
959 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
960 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
961 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
962 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
963 CHECK_dict_new( DICT_AVP, &data, type, NULL);
964 };
965 /* PDN-Connection-ID */
966 {
967 struct dict_avp_data data = {
968 1065, /* Code */
969 10415, /* Vendor */
970 "PDN-Connection-ID", /* Name */
971 AVP_FLAG_VENDOR, /* Fixed flags */
972 AVP_FLAG_VENDOR, /* Fixed flag values */
973 AVP_TYPE_OCTETSTRING /* base type of data */
974 };
975 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
976 };
977 /* Precedence */
978 {
979 struct dict_avp_data data = {
980 1010, /* Code */
981 10415, /* Vendor */
982 "Precedence", /* Name */
983 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
984 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
985 AVP_TYPE_UNSIGNED32 /* base type of data */
986 };
987 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
988 };
989 /* Pre-emption-Capability */
990 {
991 struct dict_avp_data data = {
992 1047, /* Code */
993 10415, /* Vendor */
994 "Pre-emption-Capability", /* Name */
995 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
996 AVP_FLAG_VENDOR, /* Fixed flag values */
997 AVP_TYPE_INTEGER32 /* base type of data */
998 };
999 struct dict_object *type;
1000 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Pre-emption-Capability)", NULL, NULL, NULL };
1001 struct dict_enumval_data t_1 = { "PRE_EMPTION_CAPABILITY_ENABLED", { .i32=0 }};
1002 struct dict_enumval_data t_2 = { "PRE_EMPTION_CAPABILITY_DISABLED", { .i32=1 }};
1003 /* Create the Enumerated type, and then the AVP */
1004 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1005 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1006 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1007 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1008 };
1009 /* Pre-emption-Vulnerability */
1010 {
1011 struct dict_avp_data data = {
1012 1048, /* Code */
1013 10415, /* Vendor */
1014 "Pre-emption-Vulnerability", /* Name */
1015 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1016 AVP_FLAG_VENDOR, /* Fixed flag values */
1017 AVP_TYPE_INTEGER32 /* base type of data */
1018 };
1019 struct dict_object *type;
1020 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Pre-emption-Vulnerability)", NULL, NULL, NULL };
1021 struct dict_enumval_data t_1 = { "PRE_EMPTION_VULNERABILITY_ENABLED", { .i32=0 }};
1022 struct dict_enumval_data t_2 = { "PRE_EMPTION_VULNERABILITY_DISABLED", { .i32=1 }};
1023 /* Create the Enumerated type, and then the AVP */
1024 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1025 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1026 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1027 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1028 };
1029 /* Presence-Reporting-Area-Elements-List */
1030 {
1031 struct dict_avp_data data = {
1032 2820, /* Code */
1033 10415, /* Vendor */
1034 "Presence-Reporting-Area-Elements-List", /* Name */
1035 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1036 AVP_FLAG_VENDOR, /* Fixed flag values */
1037 AVP_TYPE_OCTETSTRING /* base type of data */
1038 };
1039 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1040 };
1041 /* Presence-Reporting-Area-Identifier */
1042 {
1043 struct dict_avp_data data = {
1044 2821, /* Code */
1045 10415, /* Vendor */
1046 "Presence-Reporting-Area-Identifier", /* Name */
1047 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1048 AVP_FLAG_VENDOR, /* Fixed flag values */
1049 AVP_TYPE_OCTETSTRING /* base type of data */
1050 };
1051 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1052 };
1053 /* Presence-Reporting-Area-Status */
1054 {
1055 struct dict_avp_data data = {
1056 2823, /* Code */
1057 10415, /* Vendor */
1058 "Presence-Reporting-Area-Status", /* Name */
1059 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1060 AVP_FLAG_VENDOR, /* Fixed flag values */
1061 AVP_TYPE_UNSIGNED32 /* base type of data */
1062 };
1063 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1064 };
1065 /* Priority-Level */
1066 {
1067 struct dict_avp_data data = {
1068 1046, /* Code */
1069 10415, /* Vendor */
1070 "Priority-Level", /* Name */
1071 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1072 AVP_FLAG_VENDOR, /* Fixed flag values */
1073 AVP_TYPE_UNSIGNED32 /* base type of data */
1074 };
1075 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1076 };
1077 /* PS-to-CS-Session-Continuity */
1078 {
1079 struct dict_avp_data data = {
1080 1099, /* Code */
1081 10415, /* Vendor */
1082 "PS-to-CS-Session-Continuity", /* Name */
1083 AVP_FLAG_VENDOR, /* Fixed flags */
1084 AVP_FLAG_VENDOR, /* Fixed flag values */
1085 AVP_TYPE_INTEGER32 /* base type of data */
1086 };
1087 struct dict_object *type;
1088 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(PS-to-CS-Session-Continuity)", NULL, NULL, NULL };
1089 struct dict_enumval_data t_1 = { "VIDEO_PS2CS_CONT_CANDIDATE", { .i32=0 }};
1090 /* Create the Enumerated type, and then the AVP */
1091 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1092 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1093 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1094 };
1095 /* QoS-Class-Identifier */
1096 {
1097 struct dict_avp_data data = {
1098 1028, /* Code */
1099 10415, /* Vendor */
1100 "QoS-Class-Identifier", /* Name */
1101 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1102 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1103 AVP_TYPE_INTEGER32 /* base type of data */
1104 };
1105 struct dict_object *type;
1106 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(QoS-Class-Identifier)", NULL, NULL, NULL };
1107 struct dict_enumval_data t_1 = { "QCI_1", { .i32=1 }};
1108 struct dict_enumval_data t_2 = { "QCI_2", { .i32=2 }};
1109 struct dict_enumval_data t_3 = { "QCI_3", { .i32=3 }};
1110 struct dict_enumval_data t_4 = { "QCI_4", { .i32=4 }};
1111 struct dict_enumval_data t_5 = { "QCI_5", { .i32=5 }};
1112 struct dict_enumval_data t_6 = { "QCI_6", { .i32=6 }};
1113 struct dict_enumval_data t_7 = { "QCI_65", { .i32=65 }};
1114 struct dict_enumval_data t_8 = { "QCI_66", { .i32=66 }};
1115 struct dict_enumval_data t_9 = { "QCI_69", { .i32=69 }};
1116 struct dict_enumval_data t_10 = { "QCI_7", { .i32=7 }};
1117 struct dict_enumval_data t_11 = { "QCI_70", { .i32=70 }};
1118 struct dict_enumval_data t_12 = { "QCI_75", { .i32=75 }};
1119 struct dict_enumval_data t_13 = { "QCI_79", { .i32=79 }};
1120 struct dict_enumval_data t_14 = { "QCI_8", { .i32=8 }};
1121 struct dict_enumval_data t_15 = { "QCI_9", { .i32=9 }};
1122 /* Create the Enumerated type, and then the AVP */
1123 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1124 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1125 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1126 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
1127 CHECK_dict_new( DICT_ENUMVAL, &t_4, type, NULL);
1128 CHECK_dict_new( DICT_ENUMVAL, &t_5, type, NULL);
1129 CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
1130 CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
1131 CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
1132 CHECK_dict_new( DICT_ENUMVAL, &t_9, type, NULL);
1133 CHECK_dict_new( DICT_ENUMVAL, &t_10, type, NULL);
1134 CHECK_dict_new( DICT_ENUMVAL, &t_11, type, NULL);
1135 CHECK_dict_new( DICT_ENUMVAL, &t_12, type, NULL);
1136 CHECK_dict_new( DICT_ENUMVAL, &t_13, type, NULL);
1137 CHECK_dict_new( DICT_ENUMVAL, &t_14, type, NULL);
1138 CHECK_dict_new( DICT_ENUMVAL, &t_15, type, NULL);
1139 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1140 };
1141 /* QoS-Negotiation */
1142 {
1143 struct dict_avp_data data = {
1144 1029, /* Code */
1145 10415, /* Vendor */
1146 "QoS-Negotiation", /* Name */
1147 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1148 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1149 AVP_TYPE_INTEGER32 /* base type of data */
1150 };
1151 struct dict_object *type;
1152 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(QoS-Negotiation)", NULL, NULL, NULL };
1153 struct dict_enumval_data t_1 = { "NO_QoS_NEGOTIATION", { .i32=0 }};
1154 struct dict_enumval_data t_2 = { "QoS_NEGOTIATION_SUPPORTED", { .i32=1 }};
1155 /* Create the Enumerated type, and then the AVP */
1156 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1157 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1158 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1159 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1160 };
1161 /* QoS-Upgrade */
1162 {
1163 struct dict_avp_data data = {
1164 1030, /* Code */
1165 10415, /* Vendor */
1166 "QoS-Upgrade", /* Name */
1167 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1168 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1169 AVP_TYPE_INTEGER32 /* base type of data */
1170 };
1171 struct dict_object *type;
1172 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(QoS-Upgrade)", NULL, NULL, NULL };
1173 struct dict_enumval_data t_1 = { "QoS_UPGRADE_NOT_SUPPORTED", { .i32=0 }};
1174 struct dict_enumval_data t_2 = { "QoS_UPGRADE_SUPPORTED", { .i32=1 }};
1175 /* Create the Enumerated type, and then the AVP */
1176 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1177 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1178 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1179 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1180 };
1181 /* RAN-NAS-Release-Cause */
1182 {
1183 struct dict_avp_data data = {
1184 2819, /* Code */
1185 10415, /* Vendor */
1186 "RAN-NAS-Release-Cause", /* Name */
1187 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1188 AVP_FLAG_VENDOR, /* Fixed flag values */
1189 AVP_TYPE_OCTETSTRING /* base type of data */
1190 };
1191 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1192 };
1193 /* RAN-Rule-Support */
1194 {
1195 struct dict_avp_data data = {
1196 2832, /* Code */
1197 10415, /* Vendor */
1198 "RAN-Rule-Support", /* Name */
1199 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1200 AVP_FLAG_VENDOR, /* Fixed flag values */
1201 AVP_TYPE_UNSIGNED32 /* base type of data */
1202 };
1203 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1204 };
1205 /* RAT-Type */
1206 {
1207 struct dict_avp_data data = {
1208 1032, /* Code */
1209 10415, /* Vendor */
1210 "RAT-Type", /* Name */
1211 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1212 AVP_FLAG_VENDOR, /* Fixed flag values */
1213 AVP_TYPE_INTEGER32 /* base type of data */
1214 };
1215 struct dict_object *type;
1216 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(RAT-Type)", NULL, NULL, NULL };
1217 struct dict_enumval_data t_1 = { "WLAN", { .i32=0 }};
1218 struct dict_enumval_data t_2 = { "VIRTUAL", { .i32=1 }};
1219 /* Create the Enumerated type, and then the AVP */
1220 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1221 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1222 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1223 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1224 };
1225 /* Redirect-Support */
1226 {
1227 struct dict_avp_data data = {
1228 1086, /* Code */
1229 10415, /* Vendor */
1230 "Redirect-Support", /* Name */
1231 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1232 AVP_FLAG_VENDOR, /* Fixed flag values */
1233 AVP_TYPE_INTEGER32 /* base type of data */
1234 };
1235 struct dict_object *type;
1236 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Redirect-Support)", NULL, NULL, NULL };
1237 struct dict_enumval_data t_1 = { "REDIRECTION_DISABLED", { .i32=0 }};
1238 struct dict_enumval_data t_2 = { "REDIRECTION_ENABLED", { .i32=1 }};
1239 /* Create the Enumerated type, and then the AVP */
1240 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1241 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1242 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1243 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1244 };
1245 /* Removal-Of-Access */
1246 {
1247 struct dict_avp_data data = {
1248 2842, /* Code */
1249 10415, /* Vendor */
1250 "Removal-Of-Access", /* Name */
1251 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1252 AVP_FLAG_VENDOR, /* Fixed flag values */
1253 AVP_TYPE_INTEGER32 /* base type of data */
1254 };
1255 struct dict_object *type;
1256 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Removal-Of-Access)", NULL, NULL, NULL };
1257 struct dict_enumval_data t_1 = { "REMOVAL_OF_ACCESS", { .i32=0 }};
1258 /* Create the Enumerated type, and then the AVP */
1259 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1260 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1261 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1262 };
1263 /* Reporting-Level */
1264 {
1265 struct dict_avp_data data = {
1266 1011, /* Code */
1267 10415, /* Vendor */
1268 "Reporting-Level", /* Name */
1269 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1270 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1271 AVP_TYPE_INTEGER32 /* base type of data */
1272 };
1273 struct dict_object *type;
1274 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Reporting-Level)", NULL, NULL, NULL };
1275 struct dict_enumval_data t_1 = { "SERVICE_IDENTIFIER_LEVEL", { .i32=0 }};
1276 struct dict_enumval_data t_2 = { "RATING_GROUP_LEVEL", { .i32=1 }};
1277 struct dict_enumval_data t_3 = { "SPONSORED_CONNECTIVITY_LEVEL", { .i32=2 }};
1278 /* Create the Enumerated type, and then the AVP */
1279 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1280 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1281 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1282 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
1283 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1284 };
1285 /* Resource-Allocation-Notification */
1286 {
1287 struct dict_avp_data data = {
1288 1063, /* Code */
1289 10415, /* Vendor */
1290 "Resource-Allocation-Notification", /* Name */
1291 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1292 AVP_FLAG_VENDOR, /* Fixed flag values */
1293 AVP_TYPE_INTEGER32 /* base type of data */
1294 };
1295 struct dict_object *type;
1296 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Resource-Allocation-Notification)", NULL, NULL, NULL };
1297 struct dict_enumval_data t_1 = { "ENABLE_NOTIFICATION", { .i32=0 }};
1298 /* Create the Enumerated type, and then the AVP */
1299 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1300 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1301 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1302 };
1303 /* Resource-Release-Notification */
1304 {
1305 struct dict_avp_data data = {
1306 2841, /* Code */
1307 10415, /* Vendor */
1308 "Resource-Release-Notification", /* Name */
1309 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1310 AVP_FLAG_VENDOR, /* Fixed flag values */
1311 AVP_TYPE_INTEGER32 /* base type of data */
1312 };
1313 struct dict_object *type;
1314 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Resource-Release-Notification)", NULL, NULL, NULL };
1315 struct dict_enumval_data t_1 = { "ENABLE_NOTIFICATION", { .i32=0 }};
1316 /* Create the Enumerated type, and then the AVP */
1317 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1318 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1319 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1320 };
1321 /* Revalidation-Time */
1322 {
1323 struct dict_avp_data data = {
1324 1042, /* Code */
1325 10415, /* Vendor */
1326 "Revalidation-Time", /* Name */
1327 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1328 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1329 AVP_TYPE_OCTETSTRING /* base type of data */
1330 };
1331 CHECK_dict_new( DICT_AVP, &data, Time_type, NULL);
1332 };
1333 /* Routing-IP-Address */
1334 {
1335 struct dict_avp_data data = {
1336 1079, /* Code */
1337 10415, /* Vendor */
1338 "Routing-IP-Address", /* Name */
1339 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1340 AVP_FLAG_VENDOR, /* Fixed flag values */
1341 AVP_TYPE_OCTETSTRING /* base type of data */
1342 };
1343 CHECK_dict_new( DICT_AVP, &data, Address_type, NULL);
1344 };
1345 /* Routing-Rule-Identifier */
1346 {
1347 struct dict_avp_data data = {
1348 1077, /* Code */
1349 10415, /* Vendor */
1350 "Routing-Rule-Identifier", /* Name */
1351 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1352 AVP_FLAG_VENDOR, /* Fixed flag values */
1353 AVP_TYPE_OCTETSTRING /* base type of data */
1354 };
1355 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1356 };
1357 /* Routing-Rule-Failure-Code */
1358 {
1359 struct dict_avp_data data = {
1360 2834, /* Code */
1361 10415, /* Vendor */
1362 "Routing-Rule-Failure-Code", /* Name */
1363 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1364 AVP_FLAG_VENDOR, /* Fixed flag values */
1365 AVP_TYPE_UNSIGNED32 /* base type of data */
1366 };
1367 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1368 };
1369 /* Rule-Activation-Time */
1370 {
1371 struct dict_avp_data data = {
1372 1043, /* Code */
1373 10415, /* Vendor */
1374 "Rule-Activation-Time", /* Name */
1375 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1376 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1377 AVP_TYPE_OCTETSTRING /* base type of data */
1378 };
1379 CHECK_dict_new( DICT_AVP, &data, Time_type, NULL);
1380 };
1381 /* Rule-Deactivation-Time */
1382 {
1383 struct dict_avp_data data = {
1384 1044, /* Code */
1385 10415, /* Vendor */
1386 "Rule-Deactivation-Time", /* Name */
1387 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1388 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1389 AVP_TYPE_OCTETSTRING /* base type of data */
1390 };
1391 CHECK_dict_new( DICT_AVP, &data, Time_type, NULL);
1392 };
1393 /* Rule-Failure-Code */
1394 {
1395 struct dict_avp_data data = {
1396 1031, /* Code */
1397 10415, /* Vendor */
1398 "Rule-Failure-Code", /* Name */
1399 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1400 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1401 AVP_TYPE_INTEGER32 /* base type of data */
1402 };
1403 struct dict_object *type;
1404 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Rule-Failure-Code)", NULL, NULL, NULL };
1405 struct dict_enumval_data t_1 = { "UNKNOWN_RULE_NAME", { .i32=1 }};
1406 struct dict_enumval_data t_2 = { "RESOURCE_ALLOCATION_FAILURE", { .i32=10 }};
1407 struct dict_enumval_data t_3 = { "UNSUCCESSFUL_QOS_VALIDATION", { .i32=11 }};
1408 struct dict_enumval_data t_4 = { "INCORRECT_FLOW_INFORMATION", { .i32=12 }};
1409 struct dict_enumval_data t_5 = { "PS_TO_CS_HANDOVER", { .i32=13 }};
1410 struct dict_enumval_data t_6 = { "TDF_APPLICATION_IDENTIFIER_ERROR", { .i32=14 }};
1411 struct dict_enumval_data t_7 = { "NO_BEARER_BOUND", { .i32=15 }};
1412 struct dict_enumval_data t_8 = { "FILTER_RESTRICTIONS", { .i32=16 }};
1413 struct dict_enumval_data t_9 = { "AN_GW_FAILED", { .i32=17 }};
1414 struct dict_enumval_data t_10 = { "MISSING_REDIRECT_SERVER_ADDRESS", { .i32=18 }};
1415 struct dict_enumval_data t_11 = { "CM_END_USER_SERVICE_DENIED", { .i32=19 }};
1416 struct dict_enumval_data t_12 = { "RATING_GROUP_ERROR", { .i32=2 }};
1417 struct dict_enumval_data t_13 = { "CM_CREDIT_CONTROL_NOT_APPLICABLE", { .i32=20 }};
1418 struct dict_enumval_data t_14 = { "CM_AUTHORIZATION_REJECTED", { .i32=21 }};
1419 struct dict_enumval_data t_15 = { "CM_USER_UNKNOWN", { .i32=22 }};
1420 struct dict_enumval_data t_16 = { "CM_RATING_FAILED", { .i32=23 }};
1421 struct dict_enumval_data t_17 = { "ROUTING_RULE_REJECTION", { .i32=24 }};
1422 struct dict_enumval_data t_18 = { "NO_NBIFOM_SUPPORT", { .i32=25 }};
1423 struct dict_enumval_data t_19 = { "SERVICE_IDENTIFIER_ERROR", { .i32=3 }};
1424 struct dict_enumval_data t_20 = { "GW_PCEF_MALFUNCTION", { .i32=4 }};
1425 struct dict_enumval_data t_21 = { "RESOURCES_LIMITATION", { .i32=5 }};
1426 struct dict_enumval_data t_22 = { "MAX_NR_BEARERS_REACHED", { .i32=6 }};
1427 struct dict_enumval_data t_23 = { "UNKNOWN_BEARER_ID", { .i32=7 }};
1428 struct dict_enumval_data t_24 = { "MISSING_BEARER_ID", { .i32=8 }};
1429 struct dict_enumval_data t_25 = { "MISSING_FLOW_INFORMATION", { .i32=9 }};
1430 /* Create the Enumerated type, and then the AVP */
1431 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1432 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1433 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1434 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
1435 CHECK_dict_new( DICT_ENUMVAL, &t_4, type, NULL);
1436 CHECK_dict_new( DICT_ENUMVAL, &t_5, type, NULL);
1437 CHECK_dict_new( DICT_ENUMVAL, &t_6, type, NULL);
1438 CHECK_dict_new( DICT_ENUMVAL, &t_7, type, NULL);
1439 CHECK_dict_new( DICT_ENUMVAL, &t_8, type, NULL);
1440 CHECK_dict_new( DICT_ENUMVAL, &t_9, type, NULL);
1441 CHECK_dict_new( DICT_ENUMVAL, &t_10, type, NULL);
1442 CHECK_dict_new( DICT_ENUMVAL, &t_11, type, NULL);
1443 CHECK_dict_new( DICT_ENUMVAL, &t_12, type, NULL);
1444 CHECK_dict_new( DICT_ENUMVAL, &t_13, type, NULL);
1445 CHECK_dict_new( DICT_ENUMVAL, &t_14, type, NULL);
1446 CHECK_dict_new( DICT_ENUMVAL, &t_15, type, NULL);
1447 CHECK_dict_new( DICT_ENUMVAL, &t_16, type, NULL);
1448 CHECK_dict_new( DICT_ENUMVAL, &t_17, type, NULL);
1449 CHECK_dict_new( DICT_ENUMVAL, &t_18, type, NULL);
1450 CHECK_dict_new( DICT_ENUMVAL, &t_19, type, NULL);
1451 CHECK_dict_new( DICT_ENUMVAL, &t_20, type, NULL);
1452 CHECK_dict_new( DICT_ENUMVAL, &t_21, type, NULL);
1453 CHECK_dict_new( DICT_ENUMVAL, &t_22, type, NULL);
1454 CHECK_dict_new( DICT_ENUMVAL, &t_23, type, NULL);
1455 CHECK_dict_new( DICT_ENUMVAL, &t_24, type, NULL);
1456 CHECK_dict_new( DICT_ENUMVAL, &t_25, type, NULL);
1457 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1458 };
1459 /* Security-Parameter-Index */
1460 {
1461 struct dict_avp_data data = {
1462 1056, /* Code */
1463 10415, /* Vendor */
1464 "Security-Parameter-Index", /* Name */
1465 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1466 AVP_FLAG_VENDOR, /* Fixed flag values */
1467 AVP_TYPE_OCTETSTRING /* base type of data */
1468 };
1469 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1470 };
1471 /* Session-Release-Cause */
1472 {
1473 struct dict_avp_data data = {
1474 1045, /* Code */
1475 10415, /* Vendor */
1476 "Session-Release-Cause", /* Name */
1477 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1478 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1479 AVP_TYPE_INTEGER32 /* base type of data */
1480 };
1481 struct dict_object *type;
1482 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Session-Release-Cause)", NULL, NULL, NULL };
1483 struct dict_enumval_data t_1 = { "UNSPECIFIED_REASON", { .i32=0 }};
1484 struct dict_enumval_data t_2 = { "UE_SUBSCRIPTION_REASON", { .i32=1 }};
1485 struct dict_enumval_data t_3 = { "INSUFFICIENT_SERVER_RESOURCES", { .i32=2 }};
1486 struct dict_enumval_data t_4 = { "IP_CAN_SESSION_TERMINATION", { .i32=3 }};
1487 struct dict_enumval_data t_5 = { "UE_IP_ADDRESS_RELEASE", { .i32=4 }};
1488 /* Create the Enumerated type, and then the AVP */
1489 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1490 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1491 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1492 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
1493 CHECK_dict_new( DICT_ENUMVAL, &t_4, type, NULL);
1494 CHECK_dict_new( DICT_ENUMVAL, &t_5, type, NULL);
1495 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1496 };
1497 /* TCP-Source-Port */
1498 {
1499 struct dict_avp_data data = {
1500 2843, /* Code */
1501 10415, /* Vendor */
1502 "TCP-Source-Port", /* Name */
1503 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1504 AVP_FLAG_VENDOR, /* Fixed flag values */
1505 AVP_TYPE_UNSIGNED32 /* base type of data */
1506 };
1507 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1508 };
1509 /* TDF-Application-Identifier */
1510 {
1511 struct dict_avp_data data = {
1512 1088, /* Code */
1513 10415, /* Vendor */
1514 "TDF-Application-Identifier", /* Name */
1515 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1516 AVP_FLAG_VENDOR, /* Fixed flag values */
1517 AVP_TYPE_OCTETSTRING /* base type of data */
1518 };
1519 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1520 };
1521 /* TDF-Application-Instance-Identifier */
1522 {
1523 struct dict_avp_data data = {
1524 2802, /* Code */
1525 10415, /* Vendor */
1526 "TDF-Application-Instance-Identifier", /* Name */
1527 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1528 AVP_FLAG_VENDOR, /* Fixed flag values */
1529 AVP_TYPE_OCTETSTRING /* base type of data */
1530 };
1531 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1532 };
1533 /* TDF-Destination-Host */
1534 {
1535 struct dict_avp_data data = {
1536 1089, /* Code */
1537 10415, /* Vendor */
1538 "TDF-Destination-Host", /* Name */
1539 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1540 AVP_FLAG_VENDOR, /* Fixed flag values */
1541 AVP_TYPE_OCTETSTRING /* base type of data */
1542 };
1543 CHECK_dict_new( DICT_AVP, &data, DiameterIdentity_type, NULL);
1544 };
1545 /* TDF-Destination-Realm */
1546 {
1547 struct dict_avp_data data = {
1548 1090, /* Code */
1549 10415, /* Vendor */
1550 "TDF-Destination-Realm", /* Name */
1551 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1552 AVP_FLAG_VENDOR, /* Fixed flag values */
1553 AVP_TYPE_OCTETSTRING /* base type of data */
1554 };
1555 CHECK_dict_new( DICT_AVP, &data, DiameterIdentity_type, NULL);
1556 };
1557 /* TDF-IP-Address */
1558 {
1559 struct dict_avp_data data = {
1560 1091, /* Code */
1561 10415, /* Vendor */
1562 "TDF-IP-Address", /* Name */
1563 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1564 AVP_FLAG_VENDOR, /* Fixed flag values */
1565 AVP_TYPE_OCTETSTRING /* base type of data */
1566 };
1567 CHECK_dict_new( DICT_AVP, &data, Address_type, NULL);
1568 };
1569 /* TFT-Filter */
1570 {
1571 struct dict_avp_data data = {
1572 1012, /* Code */
1573 10415, /* Vendor */
1574 "TFT-Filter", /* Name */
1575 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1576 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1577 AVP_TYPE_OCTETSTRING /* base type of data */
1578 };
1579 CHECK_dict_new( DICT_AVP, &data, IPFilterRule_type, NULL);
1580 };
1581 /* Traffic-Steering-Policy-Identifier-DL */
1582 {
1583 struct dict_avp_data data = {
1584 2836, /* Code */
1585 10415, /* Vendor */
1586 "Traffic-Steering-Policy-Identifier-DL", /* Name */
1587 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1588 AVP_FLAG_VENDOR, /* Fixed flag values */
1589 AVP_TYPE_OCTETSTRING /* base type of data */
1590 };
1591 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1592 };
1593 /* Traffic-Steering-Policy-Identifier-UL */
1594 {
1595 struct dict_avp_data data = {
1596 2837, /* Code */
1597 10415, /* Vendor */
1598 "Traffic-Steering-Policy-Identifier-UL", /* Name */
1599 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1600 AVP_FLAG_VENDOR, /* Fixed flag values */
1601 AVP_TYPE_OCTETSTRING /* base type of data */
1602 };
1603 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1604 };
1605 /* ToS-Traffic-Class */
1606 {
1607 struct dict_avp_data data = {
1608 1014, /* Code */
1609 10415, /* Vendor */
1610 "ToS-Traffic-Class", /* Name */
1611 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1612 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1613 AVP_TYPE_OCTETSTRING /* base type of data */
1614 };
1615 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1616 };
1617 /* Tunnel-Header-Filter */
1618 {
1619 struct dict_avp_data data = {
1620 1036, /* Code */
1621 10415, /* Vendor */
1622 "Tunnel-Header-Filter", /* Name */
1623 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1624 AVP_FLAG_VENDOR, /* Fixed flag values */
1625 AVP_TYPE_OCTETSTRING /* base type of data */
1626 };
1627 CHECK_dict_new( DICT_AVP, &data, IPFilterRule_type, NULL);
1628 };
1629 /* Tunnel-Header-Length */
1630 {
1631 struct dict_avp_data data = {
1632 1037, /* Code */
1633 10415, /* Vendor */
1634 "Tunnel-Header-Length", /* Name */
1635 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1636 AVP_FLAG_VENDOR, /* Fixed flag values */
1637 AVP_TYPE_UNSIGNED32 /* base type of data */
1638 };
1639 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1640 };
1641 /* UDP-Source-Port */
1642 {
1643 struct dict_avp_data data = {
1644 2806, /* Code */
1645 10415, /* Vendor */
1646 "UDP-Source-Port", /* Name */
1647 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1648 AVP_FLAG_VENDOR, /* Fixed flag values */
1649 AVP_TYPE_UNSIGNED32 /* base type of data */
1650 };
1651 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1652 };
1653 /* UE-Local-IP-Address */
1654 {
1655 struct dict_avp_data data = {
1656 2805, /* Code */
1657 10415, /* Vendor */
1658 "UE-Local-IP-Address", /* Name */
1659 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1660 AVP_FLAG_VENDOR, /* Fixed flag values */
1661 AVP_TYPE_OCTETSTRING /* base type of data */
1662 };
1663 CHECK_dict_new( DICT_AVP, &data, Address_type, NULL);
1664 };
1665 /* Usage-Monitoring-Level */
1666 {
1667 struct dict_avp_data data = {
1668 1068, /* Code */
1669 10415, /* Vendor */
1670 "Usage-Monitoring-Level", /* Name */
1671 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1672 AVP_FLAG_VENDOR, /* Fixed flag values */
1673 AVP_TYPE_INTEGER32 /* base type of data */
1674 };
1675 struct dict_object *type;
1676 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Usage-Monitoring-Level)", NULL, NULL, NULL };
1677 struct dict_enumval_data t_1 = { "SESSION_LEVEL", { .i32=0 }};
1678 struct dict_enumval_data t_2 = { "PCC_RULE_LEVEL", { .i32=1 }};
1679 struct dict_enumval_data t_3 = { "ADC_RULE_LEVEL", { .i32=2 }};
1680 /* Create the Enumerated type, and then the AVP */
1681 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1682 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1683 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1684 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
1685 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1686 };
1687 /* Usage-Monitoring-Report */
1688 {
1689 struct dict_avp_data data = {
1690 1069, /* Code */
1691 10415, /* Vendor */
1692 "Usage-Monitoring-Report", /* Name */
1693 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1694 AVP_FLAG_VENDOR, /* Fixed flag values */
1695 AVP_TYPE_INTEGER32 /* base type of data */
1696 };
1697 struct dict_object *type;
1698 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Usage-Monitoring-Report)", NULL, NULL, NULL };
1699 struct dict_enumval_data t_1 = { "USAGE_MONITORING_REPORT_REQUIRED", { .i32=0 }};
1700 /* Create the Enumerated type, and then the AVP */
1701 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1702 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1703 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1704 };
1705 /* Usage-Monitoring-Support */
1706 {
1707 struct dict_avp_data data = {
1708 1070, /* Code */
1709 10415, /* Vendor */
1710 "Usage-Monitoring-Support", /* Name */
1711 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1712 AVP_FLAG_VENDOR, /* Fixed flag values */
1713 AVP_TYPE_INTEGER32 /* base type of data */
1714 };
1715 struct dict_object *type;
1716 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Usage-Monitoring-Support)", NULL, NULL, NULL };
1717 struct dict_enumval_data t_1 = { "USAGE_MONITORING_DISABLED", { .i32=0 }};
1718 /* Create the Enumerated type, and then the AVP */
1719 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1720 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1721 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1722 };
1723 /* User-Location-Info-Time */
1724 {
1725 struct dict_avp_data data = {
1726 2812, /* Code */
1727 10415, /* Vendor */
1728 "User-Location-Info-Time", /* Name */
1729 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1730 AVP_FLAG_VENDOR, /* Fixed flag values */
1731 AVP_TYPE_OCTETSTRING /* base type of data */
1732 };
1733 CHECK_dict_new( DICT_AVP, &data, Time_type, NULL);
1734 };
1735 /* PCSCF-Restoration-Indication */
1736 {
1737 struct dict_avp_data data = {
1738 2826, /* Code */
1739 10415, /* Vendor */
1740 "PCSCF-Restoration-Indication", /* Name */
1741 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1742 AVP_FLAG_VENDOR, /* Fixed flag values */
1743 AVP_TYPE_UNSIGNED32 /* base type of data */
1744 };
1745 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1746 };
1747 /* QoS-Rule-Name */
1748 {
1749 struct dict_avp_data data = {
1750 1054, /* Code */
1751 10415, /* Vendor */
1752 "QoS-Rule-Name", /* Name */
1753 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1754 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1755 AVP_TYPE_OCTETSTRING /* base type of data */
1756 };
1757 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1758 };
1759 /* QoS-Rule-Base-Name */
1760 {
1761 struct dict_avp_data data = {
1762 1074, /* Code */
1763 10415, /* Vendor */
1764 "QoS-Rule-Base-Name", /* Name */
1765 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1766 AVP_FLAG_VENDOR, /* Fixed flag values */
1767 AVP_TYPE_OCTETSTRING /* base type of data */
1768 };
1769 CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
1770 };
1771 /* Session-Linking-Indicator */
1772 {
1773 struct dict_avp_data data = {
1774 1064, /* Code */
1775 10415, /* Vendor */
1776 "Session-Linking-Indicator", /* Name */
1777 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1778 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1779 AVP_TYPE_INTEGER32 /* base type of data */
1780 };
1781 struct dict_object *type;
1782 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(Session-Linking-Indicator)", NULL, NULL, NULL };
1783 struct dict_enumval_data t_1 = { "UE_ONLY", { .i32=0 }};
1784 struct dict_enumval_data t_2 = { "RESERVED", { .i32=1 }};
1785 struct dict_enumval_data t_3 = { "UE_NW", { .i32=2 }};
1786 /* Create the Enumerated type, and then the AVP */
1787 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1788 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1789 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1790 CHECK_dict_new( DICT_ENUMVAL, &t_3, type, NULL);
1791 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1792 };
1793 /* ADC-Rule-Base-Name */
1794 {
1795 struct dict_avp_data data = {
1796 1095, /* Code */
1797 10415, /* Vendor */
1798 "ADC-Rule-Base-Name", /* Name */
1799 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1800 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1801 AVP_TYPE_OCTETSTRING /* base type of data */
1802 };
1803 CHECK_dict_new( DICT_AVP, &data, UTF8String_type, NULL);
1804 };
1805 /* ADC-Rule-Name */
1806 {
1807 struct dict_avp_data data = {
1808 1096, /* Code */
1809 10415, /* Vendor */
1810 "ADC-Rule-Name", /* Name */
1811 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1812 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1813 AVP_TYPE_OCTETSTRING /* base type of data */
1814 };
1815 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1816 };
1817 /* Request-Type */
1818 {
1819 struct dict_avp_data data = {
1820 2838, /* Code */
1821 10415, /* Vendor */
1822 "Request-Type", /* Name */
1823 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1824 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1825 AVP_TYPE_UNSIGNED32 /* base type of data */
1826 };
1827 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1828 };
1829 /* CS-Service-QoS-Request-Identifier */
1830 {
1831 struct dict_avp_data data = {
1832 2807, /* Code */
1833 10415, /* Vendor */
1834 "CS-Service-QoS-Request-Identifier", /* Name */
1835 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1836 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1837 AVP_TYPE_OCTETSTRING /* base type of data */
1838 };
1839 CHECK_dict_new( DICT_AVP, &data, NULL, NULL);
1840 };
1841 /* CS-Service-QoS-Request-Operation */
1842 {
1843 struct dict_avp_data data = {
1844 2808, /* Code */
1845 10415, /* Vendor */
1846 "CS-Service-QoS-Request-Operation", /* Name */
1847 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1848 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1849 AVP_TYPE_INTEGER32 /* base type of data */
1850 };
1851 struct dict_object *type;
1852 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(CS-Service-QoS-Request-Operation)", NULL, NULL, NULL };
1853 struct dict_enumval_data t_1 = { "DELETION", { .i32=0 }};
1854 struct dict_enumval_data t_2 = { "MODIFICATION", { .i32=1 }};
1855 /* Create the Enumerated type, and then the AVP */
1856 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1857 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1858 CHECK_dict_new( DICT_ENUMVAL, &t_2, type, NULL);
1859 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1860 };
1861 /* CS-Service-Resource-Failure-Cause */
1862 {
1863 struct dict_avp_data data = {
1864 2814, /* Code */
1865 10415, /* Vendor */
1866 "CS-Service-Resource-Failure-Cause", /* Name */
1867 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1868 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1869 AVP_TYPE_INTEGER32 /* base type of data */
1870 };
1871 struct dict_object *type;
1872 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(CS-Service-Resource-Failure-Cause)", NULL, NULL, NULL };
1873 struct dict_enumval_data t_1 = { "RESOURCE_RELEASED", { .i32=0 }};
1874 /* Create the Enumerated type, and then the AVP */
1875 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1876 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1877 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1878 };
1879 /* CS-Service-Resource-Result-Operation */
1880 {
1881 struct dict_avp_data data = {
1882 2815, /* Code */
1883 10415, /* Vendor */
1884 "CS-Service-Resource-Result-Operation", /* Name */
1885 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1886 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1887 AVP_TYPE_INTEGER32 /* base type of data */
1888 };
1889 struct dict_object *type;
1890 struct dict_type_data tdata = { AVP_TYPE_INTEGER32, "3GPP/Enumerated(CS-Service-Resource-Result-Operation)", NULL, NULL, NULL };
1891 struct dict_enumval_data t_1 = { "DELETION", { .i32=0 }};
1892 /* Create the Enumerated type, and then the AVP */
1893 CHECK_dict_new( DICT_TYPE, &tdata, NULL, &type);
1894 CHECK_dict_new( DICT_ENUMVAL, &t_1, type, NULL);
1895 CHECK_dict_new( DICT_AVP, &data, type, NULL);
1896 };
1897 /* Charging-Rule-Remove */
1898 {
1899 /* Grouped */
1900 struct dict_object * avp;
1901 struct dict_avp_data data = {
1902 1002, /* Code */
1903 10415, /* Vendor */
1904 "Charging-Rule-Remove", /* Name */
1905 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1906 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1907 AVP_TYPE_GROUPED /* base type of data */
1908 };
1909 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
1910 }
1911 /* QoS-Rule-Report */
1912 {
1913 /* Grouped */
1914 struct dict_object * avp;
1915 struct dict_avp_data data = {
1916 1055, /* Code */
1917 10415, /* Vendor */
1918 "QoS-Rule-Report", /* Name */
1919 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1920 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
1921 AVP_TYPE_GROUPED /* base type of data */
1922 };
1923 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
1924 }
1925 /* Redirect-Information */
1926 {
1927 /* Grouped */
1928 struct dict_object * avp;
1929 struct dict_avp_data data = {
1930 1085, /* Code */
1931 10415, /* Vendor */
1932 "Redirect-Information", /* Name */
1933 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1934 AVP_FLAG_VENDOR, /* Fixed flag values */
1935 AVP_TYPE_GROUPED /* base type of data */
1936 };
1937 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
1938 }
1939 /* PRA-Remove */
1940 {
1941 /* Grouped */
1942 struct dict_object * avp;
1943 struct dict_avp_data data = {
1944 2846, /* Code */
1945 10415, /* Vendor */
1946 "PRA-Remove", /* Name */
1947 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1948 AVP_FLAG_VENDOR, /* Fixed flag values */
1949 AVP_TYPE_GROUPED /* base type of data */
1950 };
1951 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
1952 }
1953 /* Flow-Information */
1954 {
1955 /* Grouped */
1956 struct dict_object * avp;
1957 struct dict_avp_data data = {
1958 1058, /* Code */
1959 10415, /* Vendor */
1960 "Flow-Information", /* Name */
1961 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1962 AVP_FLAG_VENDOR, /* Fixed flag values */
1963 AVP_TYPE_GROUPED /* base type of data */
1964 };
1965 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
1966 }
1967 /* Tunnel-Information */
1968 {
1969 /* Grouped */
1970 struct dict_object * avp;
1971 struct dict_avp_data data = {
1972 1038, /* Code */
1973 10415, /* Vendor */
1974 "Tunnel-Information", /* Name */
1975 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1976 AVP_FLAG_VENDOR, /* Fixed flag values */
1977 AVP_TYPE_GROUPED /* base type of data */
1978 };
1979 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
1980 }
1981 /* TDF-Information */
1982 {
1983 /* Grouped */
1984 struct dict_object * avp;
1985 struct dict_avp_data data = {
1986 1087, /* Code */
1987 10415, /* Vendor */
1988 "TDF-Information", /* Name */
1989 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
1990 AVP_FLAG_VENDOR, /* Fixed flag values */
1991 AVP_TYPE_GROUPED /* base type of data */
1992 };
1993 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
1994 }
1995 /* Routing-Rule-Remove */
1996 {
1997 /* Grouped */
1998 struct dict_object * avp;
1999 struct dict_avp_data data = {
2000 1075, /* Code */
2001 10415, /* Vendor */
2002 "Routing-Rule-Remove", /* Name */
2003 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2004 AVP_FLAG_VENDOR, /* Fixed flag values */
2005 AVP_TYPE_GROUPED /* base type of data */
2006 };
2007 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2008 }
2009 /* CS-Service-Resource-Report */
2010 {
2011 /* Grouped */
2012 struct dict_object * avp;
2013 struct dict_avp_data data = {
2014 2813, /* Code */
2015 10415, /* Vendor */
2016 "CS-Service-Resource-Report", /* Name */
2017 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2018 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2019 AVP_TYPE_GROUPED /* base type of data */
2020 };
2021 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2022 }
2023 /* Presence-Reporting-Area-Information */
2024 {
2025 /* Grouped */
2026 struct dict_object * avp;
2027 struct dict_avp_data data = {
2028 2822, /* Code */
2029 10415, /* Vendor */
2030 "Presence-Reporting-Area-Information", /* Name */
2031 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2032 AVP_FLAG_VENDOR, /* Fixed flag values */
2033 AVP_TYPE_GROUPED /* base type of data */
2034 };
2035 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2036 }
2037 /* Conditional-APN-Aggregate-Max-Bitrate */
2038 {
2039 /* Grouped */
2040 struct dict_object * avp;
2041 struct dict_avp_data data = {
2042 2818, /* Code */
2043 10415, /* Vendor */
2044 "Conditional-APN-Aggregate-Max-Bitrate", /* Name */
2045 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2046 AVP_FLAG_VENDOR, /* Fixed flag values */
2047 AVP_TYPE_GROUPED /* base type of data */
2048 };
2049 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2050 }
2051 /* Access-Network-Charging-Identifier-Gx */
2052 {
2053 /* Grouped */
2054 struct dict_object * avp;
2055 struct dict_avp_data data = {
2056 1022, /* Code */
2057 10415, /* Vendor */
2058 "Access-Network-Charging-Identifier-Gx", /* Name */
2059 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2060 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2061 AVP_TYPE_GROUPED /* base type of data */
2062 };
2063 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2064 }
2065 /* Allocation-Retention-Priority */
2066 {
2067 /* Grouped */
2068 struct dict_object * avp;
2069 struct dict_avp_data data = {
2070 1034, /* Code */
2071 10415, /* Vendor */
2072 "Allocation-Retention-Priority", /* Name */
2073 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2074 AVP_FLAG_VENDOR, /* Fixed flag values */
2075 AVP_TYPE_GROUPED /* base type of data */
2076 };
2077 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2078 }
2079 /* QoS-Rule-Remove */
2080 {
2081 /* Grouped */
2082 struct dict_object * avp;
2083 struct dict_avp_data data = {
2084 1052, /* Code */
2085 10415, /* Vendor */
2086 "QoS-Rule-Remove", /* Name */
2087 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2088 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2089 AVP_TYPE_GROUPED /* base type of data */
2090 };
2091 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2092 }
2093 /* Routing-Rule-Report */
2094 {
2095 /* Grouped */
2096 struct dict_object * avp;
2097 struct dict_avp_data data = {
2098 2835, /* Code */
2099 10415, /* Vendor */
2100 "Routing-Rule-Report", /* Name */
2101 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2102 AVP_FLAG_VENDOR, /* Fixed flag values */
2103 AVP_TYPE_GROUPED /* base type of data */
2104 };
2105 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2106 }
2107 /* TFT-Packet-Filter-Information */
2108 {
2109 /* Grouped */
2110 struct dict_object * avp;
2111 struct dict_avp_data data = {
2112 1013, /* Code */
2113 10415, /* Vendor */
2114 "TFT-Packet-Filter-Information", /* Name */
2115 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2116 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2117 AVP_TYPE_GROUPED /* base type of data */
2118 };
2119 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2120 }
2121 /* Fixed-User-Location-Info */
2122 {
2123 /* Grouped */
2124 struct dict_object * avp;
2125 struct dict_avp_data data = {
2126 2825, /* Code */
2127 10415, /* Vendor */
2128 "Fixed-User-Location-Info", /* Name */
2129 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2130 AVP_FLAG_VENDOR, /* Fixed flag values */
2131 AVP_TYPE_GROUPED /* base type of data */
2132 };
2133 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2134 }
2135 /* Default-QoS-Information */
2136 {
2137 /* Grouped */
2138 struct dict_object * avp;
2139 struct dict_avp_data data = {
2140 2816, /* Code */
2141 10415, /* Vendor */
2142 "Default-QoS-Information", /* Name */
2143 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2144 AVP_FLAG_VENDOR, /* Fixed flag values */
2145 AVP_TYPE_GROUPED /* base type of data */
2146 };
2147 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2148 }
2149 /* Packet-Filter-Information */
2150 {
2151 /* Grouped */
2152 struct dict_object * avp;
2153 struct dict_avp_data data = {
2154 1061, /* Code */
2155 10415, /* Vendor */
2156 "Packet-Filter-Information", /* Name */
2157 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2158 AVP_FLAG_VENDOR, /* Fixed flag values */
2159 AVP_TYPE_GROUPED /* base type of data */
2160 };
2161 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2162 }
2163 /* Routing-Filter */
2164 {
2165 /* Grouped */
2166 struct dict_object * avp;
2167 struct dict_avp_data data = {
2168 1078, /* Code */
2169 10415, /* Vendor */
2170 "Routing-Filter", /* Name */
2171 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2172 AVP_FLAG_VENDOR, /* Fixed flag values */
2173 AVP_TYPE_GROUPED /* base type of data */
2174 };
2175 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2176 }
2177 /* ADC-Rule-Remove */
2178 {
2179 /* Grouped */
2180 struct dict_object * avp;
2181 struct dict_avp_data data = {
2182 1093, /* Code */
2183 10415, /* Vendor */
2184 "ADC-Rule-Remove", /* Name */
2185 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2186 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2187 AVP_TYPE_GROUPED /* base type of data */
2188 };
2189 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2190 }
2191 /* QoS-Information */
2192 {
2193 /* Grouped */
2194 struct dict_object * avp;
2195 struct dict_avp_data data = {
2196 1016, /* Code */
2197 10415, /* Vendor */
2198 "QoS-Information", /* Name */
2199 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2200 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2201 AVP_TYPE_GROUPED /* base type of data */
2202 };
2203 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2204 }
2205 /* PRA-Install */
2206 {
2207 /* Grouped */
2208 struct dict_object * avp;
2209 struct dict_avp_data data = {
2210 2845, /* Code */
2211 10415, /* Vendor */
2212 "PRA-Install", /* Name */
2213 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2214 AVP_FLAG_VENDOR, /* Fixed flag values */
2215 AVP_TYPE_GROUPED /* base type of data */
2216 };
2217 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2218 }
2219 /* Routing-Rule-Definition */
2220 {
2221 /* Grouped */
2222 struct dict_object * avp;
2223 struct dict_avp_data data = {
2224 1076, /* Code */
2225 10415, /* Vendor */
2226 "Routing-Rule-Definition", /* Name */
2227 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2228 AVP_FLAG_VENDOR, /* Fixed flag values */
2229 AVP_TYPE_GROUPED /* base type of data */
2230 };
2231 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2232 }
2233 /* Default-EPS-Bearer-QoS */
2234 {
2235 /* Grouped */
2236 struct dict_object * avp;
2237 struct dict_avp_data data = {
2238 1049, /* Code */
2239 10415, /* Vendor */
2240 "Default-EPS-Bearer-QoS", /* Name */
2241 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2242 AVP_FLAG_VENDOR, /* Fixed flag values */
2243 AVP_TYPE_GROUPED /* base type of data */
2244 };
2245 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2246 }
2247 /* CoA-Information */
2248 {
2249 /* Grouped */
2250 struct dict_object * avp;
2251 struct dict_avp_data data = {
2252 1039, /* Code */
2253 10415, /* Vendor */
2254 "CoA-Information", /* Name */
2255 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2256 AVP_FLAG_VENDOR, /* Fixed flag values */
2257 AVP_TYPE_GROUPED /* base type of data */
2258 };
2259 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2260 }
2261 /* Application-Detection-Information */
2262 {
2263 /* Grouped */
2264 struct dict_object * avp;
2265 struct dict_avp_data data = {
2266 1098, /* Code */
2267 10415, /* Vendor */
2268 "Application-Detection-Information", /* Name */
2269 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2270 AVP_FLAG_VENDOR, /* Fixed flag values */
2271 AVP_TYPE_GROUPED /* base type of data */
2272 };
2273 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2274 }
2275 /* Conditional-Policy-Information */
2276 {
2277 /* Grouped */
2278 struct dict_object * avp;
2279 struct dict_avp_data data = {
2280 2840, /* Code */
2281 10415, /* Vendor */
2282 "Conditional-Policy-Information", /* Name */
2283 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2284 AVP_FLAG_VENDOR, /* Fixed flag values */
2285 AVP_TYPE_GROUPED /* base type of data */
2286 };
2287 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2288 }
2289 /* Charging-Rule-Definition */
2290 {
2291 /* Grouped */
2292 struct dict_object * avp;
2293 struct dict_avp_data data = {
2294 1003, /* Code */
2295 10415, /* Vendor */
2296 "Charging-Rule-Definition", /* Name */
2297 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2298 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2299 AVP_TYPE_GROUPED /* base type of data */
2300 };
2301 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2302 }
2303 /* Routing-Rule-Install */
2304 {
2305 /* Grouped */
2306 struct dict_object * avp;
2307 struct dict_avp_data data = {
2308 1081, /* Code */
2309 10415, /* Vendor */
2310 "Routing-Rule-Install", /* Name */
2311 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2312 AVP_FLAG_VENDOR, /* Fixed flag values */
2313 AVP_TYPE_GROUPED /* base type of data */
2314 };
2315 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2316 }
2317 /* ADC-Rule-Definition */
2318 {
2319 /* Grouped */
2320 struct dict_object * avp;
2321 struct dict_avp_data data = {
2322 1094, /* Code */
2323 10415, /* Vendor */
2324 "ADC-Rule-Definition", /* Name */
2325 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2326 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2327 AVP_TYPE_GROUPED /* base type of data */
2328 };
2329 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2330 }
2331 /* ADC-Rule-Report */
2332 {
2333 /* Grouped */
2334 struct dict_object * avp;
2335 struct dict_avp_data data = {
2336 1097, /* Code */
2337 10415, /* Vendor */
2338 "ADC-Rule-Report", /* Name */
2339 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2340 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2341 AVP_TYPE_GROUPED /* base type of data */
2342 };
2343 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2344 }
2345 /* QoS-Rule-Definition */
2346 {
2347 /* Grouped */
2348 struct dict_object * avp;
2349 struct dict_avp_data data = {
2350 1053, /* Code */
2351 10415, /* Vendor */
2352 "QoS-Rule-Definition", /* Name */
2353 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2354 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2355 AVP_TYPE_GROUPED /* base type of data */
2356 };
2357 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2358 }
2359 /* Charging-Rule-Report */
2360 {
2361 /* Grouped */
2362 struct dict_object * avp;
2363 struct dict_avp_data data = {
2364 1018, /* Code */
2365 10415, /* Vendor */
2366 "Charging-Rule-Report", /* Name */
2367 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2368 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2369 AVP_TYPE_GROUPED /* base type of data */
2370 };
2371 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2372 }
2373 /* Event-Report-Indication */
2374 {
2375 /* Grouped */
2376 struct dict_object * avp;
2377 struct dict_avp_data data = {
2378 1033, /* Code */
2379 10415, /* Vendor */
2380 "Event-Report-Indication", /* Name */
2381 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2382 AVP_FLAG_VENDOR, /* Fixed flag values */
2383 AVP_TYPE_GROUPED /* base type of data */
2384 };
2385 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2386 }
2387 /* Charging-Rule-Install */
2388 {
2389 /* Grouped */
2390 struct dict_object * avp;
2391 struct dict_avp_data data = {
2392 1001, /* Code */
2393 10415, /* Vendor */
2394 "Charging-Rule-Install", /* Name */
2395 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2396 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2397 AVP_TYPE_GROUPED /* base type of data */
2398 };
2399 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2400 }
2401 /* QoS-Rule-Install */
2402 {
2403 /* Grouped */
2404 struct dict_object * avp;
2405 struct dict_avp_data data = {
2406 1051, /* Code */
2407 10415, /* Vendor */
2408 "QoS-Rule-Install", /* Name */
2409 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2410 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2411 AVP_TYPE_GROUPED /* base type of data */
2412 };
2413 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2414 }
2415 /* ADC-Rule-Install */
2416 {
2417 /* Grouped */
2418 struct dict_object * avp;
2419 struct dict_avp_data data = {
2420 1092, /* Code */
2421 10415, /* Vendor */
2422 "ADC-Rule-Install", /* Name */
2423 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2424 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flag values */
2425 AVP_TYPE_GROUPED /* base type of data */
2426 };
2427 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2428 }
2429 /* Usage-Monitoring-Information */
2430 {
2431 /* Grouped */
2432 struct dict_object * avp;
2433 struct dict_avp_data data = {
2434 1067, /* Code */
2435 10415, /* Vendor */
2436 "Usage-Monitoring-Information", /* Name */
2437 AVP_FLAG_VENDOR | AVP_FLAG_MANDATORY, /* Fixed flags */
2438 AVP_FLAG_VENDOR, /* Fixed flag values */
2439 AVP_TYPE_GROUPED /* base type of data */
2440 };
2441 CHECK_dict_new( DICT_AVP, &data , NULL, &avp);
2442 }
2443
2444
2445 }
2446
2447 /* Commands section */
2448 {
2449
2450 }
2451
2452 return 0;
2453}
2454
2455static int dict_ts29212_avps_load_rules(char * conffile)
2456{
2457 /* Grouped AVP section */
2458 {
2459 /* Charging-Rule-Remove */
2460 {
2461 /* Grouped */
2462 struct dict_object * avp;
2463 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Charging-Rule-Remove"};
2464 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2465 struct local_rules_definition rules[] =
2466 {
2467 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Name"}, RULE_OPTIONAL, -1, -1 },
2468 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Base-Name"}, RULE_OPTIONAL, -1, -1 },
2469 { { .avp_vendor = 10415, .avp_name = "Required-Access-Info"}, RULE_OPTIONAL, -1, -1 },
2470 { { .avp_vendor = 10415, .avp_name = "Resource-Release-Notification"}, RULE_OPTIONAL, -1, -1 }
2471 };
2472 PARSE_loc_rules( rules, avp );
2473 }
2474 /* QoS-Rule-Report */
2475 {
2476 /* Grouped */
2477 struct dict_object * avp;
2478 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "QoS-Rule-Report"};
2479 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2480 struct local_rules_definition rules[] =
2481 {
2482 { { .avp_vendor = 10415, .avp_name = "QoS-Rule-Name"}, RULE_OPTIONAL, -1, -1 },
2483 { { .avp_vendor = 10415, .avp_name = "QoS-Rule-Base-Name"}, RULE_OPTIONAL, -1, -1 },
2484 { { .avp_vendor = 10415, .avp_name = "PCC-Rule-Status"}, RULE_OPTIONAL, -1, -1 },
2485 { { .avp_vendor = 10415, .avp_name = "Rule-Failure-Code"}, RULE_OPTIONAL, -1, -1 },
2486 { { .avp_vendor = 10415, .avp_name = "Content-Version"}, RULE_OPTIONAL, -1, -1 }
2487 };
2488 PARSE_loc_rules( rules, avp );
2489 }
2490 /* Redirect-Information */
2491 {
2492 /* Grouped */
2493 struct dict_object * avp;
2494 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Redirect-Information"};
2495 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2496 struct local_rules_definition rules[] =
2497 {
2498 { { .avp_vendor = 10415, .avp_name = "Redirect-Support"}, RULE_OPTIONAL, -1, -1 },
2499 { { .avp_vendor = 0, .avp_name = "Redirect-Address-Type"}, RULE_OPTIONAL, -1, -1 },
2500 { { .avp_vendor = 0, .avp_name = "Redirect-Server-Address"}, RULE_OPTIONAL, -1, -1 }
2501 };
2502 PARSE_loc_rules( rules, avp );
2503 }
2504 /* PRA-Remove */
2505 {
2506 /* Grouped */
2507 struct dict_object * avp;
2508 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "PRA-Remove"};
2509 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2510 struct local_rules_definition rules[] =
2511 {
2512 { { .avp_vendor = 10415, .avp_name = "Presence-Reporting-Area-Identifier"}, RULE_OPTIONAL, -1, -1 }
2513 };
2514 PARSE_loc_rules( rules, avp );
2515 }
2516 /* Flow-Information */
2517 {
2518 /* Grouped */
2519 struct dict_object * avp;
2520 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Flow-Information"};
2521 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2522 struct local_rules_definition rules[] =
2523 {
2524 { { .avp_vendor = 10415, .avp_name = "Flow-Description"}, RULE_OPTIONAL, -1, -1 },
2525 { { .avp_vendor = 10415, .avp_name = "Packet-Filter-Identifier"}, RULE_OPTIONAL, -1, -1 },
2526 { { .avp_vendor = 10415, .avp_name = "Packet-Filter-Usage"}, RULE_OPTIONAL, -1, -1 },
2527 { { .avp_vendor = 10415, .avp_name = "ToS-Traffic-Class"}, RULE_OPTIONAL, -1, -1 },
2528 { { .avp_vendor = 10415, .avp_name = "Security-Parameter-Index"}, RULE_OPTIONAL, -1, -1 },
2529 { { .avp_vendor = 10415, .avp_name = "Flow-Label"}, RULE_OPTIONAL, -1, -1 },
2530 { { .avp_vendor = 10415, .avp_name = "Flow-Direction"}, RULE_OPTIONAL, -1, -1 },
2531 { { .avp_vendor = 10415, .avp_name = "Routing-Rule-Identifier"}, RULE_OPTIONAL, -1, -1 }
2532 };
2533 PARSE_loc_rules( rules, avp );
2534 }
2535 /* Tunnel-Information */
2536 {
2537 /* Grouped */
2538 struct dict_object * avp;
2539 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Tunnel-Information"};
2540 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2541 struct local_rules_definition rules[] =
2542 {
2543 { { .avp_vendor = 10415, .avp_name = "Tunnel-Header-Length"}, RULE_OPTIONAL, -1, -1 }
2544 };
2545 PARSE_loc_rules( rules, avp );
2546 }
2547 /* TDF-Information */
2548 {
2549 /* Grouped */
2550 struct dict_object * avp;
2551 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "TDF-Information"};
2552 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2553 struct local_rules_definition rules[] =
2554 {
2555 { { .avp_vendor = 10415, .avp_name = "TDF-Destination-Realm"}, RULE_OPTIONAL, -1, -1 },
2556 { { .avp_vendor = 10415, .avp_name = "TDF-Destination-Host"}, RULE_OPTIONAL, -1, -1 },
2557 { { .avp_vendor = 10415, .avp_name = "TDF-IP-Address"}, RULE_OPTIONAL, -1, -1 }
2558 };
2559 PARSE_loc_rules( rules, avp );
2560 }
2561 /* Routing-Rule-Remove */
2562 {
2563 /* Grouped */
2564 struct dict_object * avp;
2565 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Routing-Rule-Remove"};
2566 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2567 struct local_rules_definition rules[] =
2568 {
2569 { { .avp_vendor = 10415, .avp_name = "Routing-Rule-Identifier"}, RULE_OPTIONAL, -1, -1 }
2570 };
2571 PARSE_loc_rules( rules, avp );
2572 }
2573 /* CS-Service-Resource-Report */
2574 {
2575 /* Grouped */
2576 struct dict_object * avp;
2577 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "CS-Service-Resource-Report"};
2578 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2579 struct local_rules_definition rules[] =
2580 {
2581 { { .avp_vendor = 10415, .avp_name = "CS-Service-QoS-Request-Identifier"}, RULE_OPTIONAL, -1, -1 },
2582 { { .avp_vendor = 10415, .avp_name = "CS-Service-Resource-Result-Operation"}, RULE_OPTIONAL, -1, -1 },
2583 { { .avp_vendor = 10415, .avp_name = "CS-Service-Resource-Failure-Cause"}, RULE_OPTIONAL, -1, -1 }
2584 };
2585 PARSE_loc_rules( rules, avp );
2586 }
2587 /* Presence-Reporting-Area-Information */
2588 {
2589 /* Grouped */
2590 struct dict_object * avp;
2591 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Presence-Reporting-Area-Information"};
2592 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2593 struct local_rules_definition rules[] =
2594 {
2595 { { .avp_vendor = 10415, .avp_name = "Presence-Reporting-Area-Identifier"}, RULE_OPTIONAL, -1, -1 },
2596 { { .avp_vendor = 10415, .avp_name = "Presence-Reporting-Area-Status"}, RULE_OPTIONAL, -1, -1 },
2597 { { .avp_vendor = 10415, .avp_name = "Presence-Reporting-Area-Elements-List"}, RULE_OPTIONAL, -1, -1 }
2598 };
2599 PARSE_loc_rules( rules, avp );
2600 }
2601 /* Conditional-APN-Aggregate-Max-Bitrate */
2602 {
2603 /* Grouped */
2604 struct dict_object * avp;
2605 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Conditional-APN-Aggregate-Max-Bitrate"};
2606 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2607 struct local_rules_definition rules[] =
2608 {
2609 { { .avp_vendor = 10415, .avp_name = "APN-Aggregate-Max-Bitrate-UL"}, RULE_OPTIONAL, -1, -1 },
2610 { { .avp_vendor = 10415, .avp_name = "APN-Aggregate-Max-Bitrate-DL"}, RULE_OPTIONAL, -1, -1 },
2611 { { .avp_vendor = 10415, .avp_name = "IP-CAN-Type"}, RULE_OPTIONAL, -1, -1 },
2612 { { .avp_vendor = 10415, .avp_name = "RAT-Type"}, RULE_OPTIONAL, -1, -1 }
2613 };
2614 PARSE_loc_rules( rules, avp );
2615 }
2616 /* Access-Network-Charging-Identifier-Gx */
2617 {
2618 /* Grouped */
2619 struct dict_object * avp;
2620 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Access-Network-Charging-Identifier-Gx"};
2621 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2622 struct local_rules_definition rules[] =
2623 {
2624 { { .avp_vendor = 10415, .avp_name = "Access-Network-Charging-Identifier-Value"}, RULE_REQUIRED, -1, -1 },
2625 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Base-Name"}, RULE_OPTIONAL, -1, -1 },
2626 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Name"}, RULE_OPTIONAL, -1, -1 },
2627 { { .avp_vendor = 10415, .avp_name = "IP-CAN-Session-Charging-Scope"}, RULE_OPTIONAL, -1, -1 }
2628 };
2629 PARSE_loc_rules( rules, avp );
2630 }
2631 /* Allocation-Retention-Priority */
2632 {
2633 /* Grouped */
2634 struct dict_object * avp;
2635 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Allocation-Retention-Priority"};
2636 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2637 struct local_rules_definition rules[] =
2638 {
2639 { { .avp_vendor = 10415, .avp_name = "Priority-Level"}, RULE_REQUIRED, -1, -1 },
2640 { { .avp_vendor = 10415, .avp_name = "Pre-emption-Capability"}, RULE_OPTIONAL, -1, -1 },
2641 { { .avp_vendor = 10415, .avp_name = "Pre-emption-Vulnerability"}, RULE_OPTIONAL, -1, -1 }
2642 };
2643 PARSE_loc_rules( rules, avp );
2644 }
2645 /* QoS-Rule-Remove */
2646 {
2647 /* Grouped */
2648 struct dict_object * avp;
2649 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "QoS-Rule-Remove"};
2650 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2651 struct local_rules_definition rules[] =
2652 {
2653 { { .avp_vendor = 10415, .avp_name = "QoS-Rule-Name"}, RULE_OPTIONAL, -1, -1 },
2654 { { .avp_vendor = 10415, .avp_name = "QoS-Rule-Base-Name"}, RULE_OPTIONAL, -1, -1 },
2655 { { .avp_vendor = 10415, .avp_name = "Required-Access-Info"}, RULE_OPTIONAL, -1, -1 }
2656 };
2657 PARSE_loc_rules( rules, avp );
2658 }
2659 /* Routing-Rule-Report */
2660 {
2661 /* Grouped */
2662 struct dict_object * avp;
2663 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Routing-Rule-Report"};
2664 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2665 struct local_rules_definition rules[] =
2666 {
2667 { { .avp_vendor = 10415, .avp_name = "Routing-Rule-Identifier"}, RULE_OPTIONAL, -1, -1 },
2668 { { .avp_vendor = 10415, .avp_name = "PCC-Rule-Status"}, RULE_OPTIONAL, -1, -1 },
2669 { { .avp_vendor = 10415, .avp_name = "Routing-Rule-Failure-Code"}, RULE_OPTIONAL, -1, -1 }
2670 };
2671 PARSE_loc_rules( rules, avp );
2672 }
2673 /* TFT-Packet-Filter-Information */
2674 {
2675 /* Grouped */
2676 struct dict_object * avp;
2677 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "TFT-Packet-Filter-Information"};
2678 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2679 struct local_rules_definition rules[] =
2680 {
2681 { { .avp_vendor = 10415, .avp_name = "Precedence"}, RULE_OPTIONAL, -1, -1 },
2682 { { .avp_vendor = 10415, .avp_name = "TFT-Filter"}, RULE_OPTIONAL, -1, -1 },
2683 { { .avp_vendor = 10415, .avp_name = "ToS-Traffic-Class"}, RULE_OPTIONAL, -1, -1 },
2684 { { .avp_vendor = 10415, .avp_name = "Security-Parameter-Index"}, RULE_OPTIONAL, -1, -1 },
2685 { { .avp_vendor = 10415, .avp_name = "Flow-Label"}, RULE_OPTIONAL, -1, -1 },
2686 { { .avp_vendor = 10415, .avp_name = "Flow-Direction"}, RULE_OPTIONAL, -1, -1 }
2687 };
2688 PARSE_loc_rules( rules, avp );
2689 }
2690 /* Fixed-User-Location-Info */
2691 {
2692 /* Grouped */
2693 struct dict_object * avp;
2694 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Fixed-User-Location-Info"};
2695 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2696 struct local_rules_definition rules[] =
2697 {
2698 { { .avp_vendor = 10415, .avp_name = "SSID"}, RULE_OPTIONAL, -1, -1 },
2699 { { .avp_vendor = 10415, .avp_name = "BSSID"}, RULE_OPTIONAL, -1, -1 },
2700 { { .avp_vendor = 13019, .avp_name = "Logical-Access-Id"}, RULE_OPTIONAL, -1, -1 },
2701 { { .avp_vendor = 13019, .avp_name = "Physical-Access-Id"}, RULE_OPTIONAL, -1, -1 }
2702 };
2703 PARSE_loc_rules( rules, avp );
2704 }
2705 /* Default-QoS-Information */
2706 {
2707 /* Grouped */
2708 struct dict_object * avp;
2709 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Default-QoS-Information"};
2710 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2711 struct local_rules_definition rules[] =
2712 {
2713 { { .avp_vendor = 10415, .avp_name = "QoS-Class-Identifier"}, RULE_OPTIONAL, -1, -1 },
2714 { { .avp_vendor = 10415, .avp_name = "Max-Requested-Bandwidth-UL"}, RULE_OPTIONAL, -1, -1 },
2715 { { .avp_vendor = 10415, .avp_name = "Max-Requested-Bandwidth-DL"}, RULE_OPTIONAL, -1, -1 },
2716 { { .avp_vendor = 10415, .avp_name = "Default-QoS-Name"}, RULE_OPTIONAL, -1, -1 }
2717 };
2718 PARSE_loc_rules( rules, avp );
2719 }
2720 /* Packet-Filter-Information */
2721 {
2722 /* Grouped */
2723 struct dict_object * avp;
2724 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Packet-Filter-Information"};
2725 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2726 struct local_rules_definition rules[] =
2727 {
2728 { { .avp_vendor = 10415, .avp_name = "Packet-Filter-Identifier"}, RULE_OPTIONAL, -1, -1 },
2729 { { .avp_vendor = 10415, .avp_name = "Precedence"}, RULE_OPTIONAL, -1, -1 },
2730 { { .avp_vendor = 10415, .avp_name = "Packet-Filter-Content"}, RULE_OPTIONAL, -1, -1 },
2731 { { .avp_vendor = 10415, .avp_name = "ToS-Traffic-Class"}, RULE_OPTIONAL, -1, -1 },
2732 { { .avp_vendor = 10415, .avp_name = "Security-Parameter-Index"}, RULE_OPTIONAL, -1, -1 },
2733 { { .avp_vendor = 10415, .avp_name = "Flow-Label"}, RULE_OPTIONAL, -1, -1 },
2734 { { .avp_vendor = 10415, .avp_name = "Flow-Direction"}, RULE_OPTIONAL, -1, -1 }
2735 };
2736 PARSE_loc_rules( rules, avp );
2737 }
2738 /* Routing-Filter */
2739 {
2740 /* Grouped */
2741 struct dict_object * avp;
2742 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Routing-Filter"};
2743 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2744 struct local_rules_definition rules[] =
2745 {
2746 { { .avp_vendor = 10415, .avp_name = "Flow-Description"}, RULE_REQUIRED, -1, -1 },
2747 { { .avp_vendor = 10415, .avp_name = "Flow-Direction"}, RULE_REQUIRED, -1, -1 },
2748 { { .avp_vendor = 10415, .avp_name = "ToS-Traffic-Class"}, RULE_OPTIONAL, -1, -1 },
2749 { { .avp_vendor = 10415, .avp_name = "Security-Parameter-Index"}, RULE_OPTIONAL, -1, -1 },
2750 { { .avp_vendor = 10415, .avp_name = "Flow-Label"}, RULE_OPTIONAL, -1, -1 }
2751 };
2752 PARSE_loc_rules( rules, avp );
2753 }
2754 /* ADC-Rule-Remove */
2755 {
2756 /* Grouped */
2757 struct dict_object * avp;
2758 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "ADC-Rule-Remove"};
2759 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2760 struct local_rules_definition rules[] =
2761 {
2762 { { .avp_vendor = 10415, .avp_name = "ADC-Rule-Name"}, RULE_OPTIONAL, -1, -1 },
2763 { { .avp_vendor = 10415, .avp_name = "ADC-Rule-Base-Name"}, RULE_OPTIONAL, -1, -1 }
2764 };
2765 PARSE_loc_rules( rules, avp );
2766 }
2767 /* QoS-Information */
2768 {
2769 /* Grouped */
2770 struct dict_object * avp;
2771 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "QoS-Information"};
2772 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2773 struct local_rules_definition rules[] =
2774 {
2775 { { .avp_vendor = 10415, .avp_name = "QoS-Class-Identifier"}, RULE_OPTIONAL, -1, -1 },
2776 { { .avp_vendor = 10415, .avp_name = "Max-Requested-Bandwidth-UL"}, RULE_OPTIONAL, -1, -1 },
2777 { { .avp_vendor = 10415, .avp_name = "Max-Requested-Bandwidth-DL"}, RULE_OPTIONAL, -1, -1 },
2778 { { .avp_vendor = 10415, .avp_name = "Guaranteed-Bitrate-UL"}, RULE_OPTIONAL, -1, -1 },
2779 { { .avp_vendor = 10415, .avp_name = "Guaranteed-Bitrate-DL"}, RULE_OPTIONAL, -1, -1 },
2780 { { .avp_vendor = 10415, .avp_name = "Bearer-Identifier"}, RULE_OPTIONAL, -1, -1 },
2781 { { .avp_vendor = 10415, .avp_name = "Allocation-Retention-Priority"}, RULE_OPTIONAL, -1, -1 },
2782 { { .avp_vendor = 10415, .avp_name = "APN-Aggregate-Max-Bitrate-UL"}, RULE_OPTIONAL, -1, -1 },
2783 { { .avp_vendor = 10415, .avp_name = "APN-Aggregate-Max-Bitrate-DL"}, RULE_OPTIONAL, -1, -1 },
2784 { { .avp_vendor = 10415, .avp_name = "Conditional-APN-Aggregate-Max-Bitrate"}, RULE_OPTIONAL, -1, -1 }
2785 };
2786 PARSE_loc_rules( rules, avp );
2787 }
2788 /* PRA-Install */
2789 {
2790 /* Grouped */
2791 struct dict_object * avp;
2792 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "PRA-Install"};
2793 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2794 struct local_rules_definition rules[] =
2795 {
2796 { { .avp_vendor = 10415, .avp_name = "Presence-Reporting-Area-Information"}, RULE_OPTIONAL, -1, -1 }
2797 };
2798 PARSE_loc_rules( rules, avp );
2799 }
2800 /* Routing-Rule-Definition */
2801 {
2802 /* Grouped */
2803 struct dict_object * avp;
2804 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Routing-Rule-Definition"};
2805 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2806 struct local_rules_definition rules[] =
2807 {
2808 { { .avp_vendor = 10415, .avp_name = "Routing-Rule-Identifier"}, RULE_REQUIRED, -1, -1 },
2809 { { .avp_vendor = 10415, .avp_name = "Routing-Filter"}, RULE_OPTIONAL, -1, -1 },
2810 { { .avp_vendor = 10415, .avp_name = "Precedence"}, RULE_OPTIONAL, -1, -1 },
2811 { { .avp_vendor = 10415, .avp_name = "Routing-IP-Address"}, RULE_OPTIONAL, -1, -1 },
2812 { { .avp_vendor = 10415, .avp_name = "IP-CAN-Type"}, RULE_OPTIONAL, -1, -1 }
2813 };
2814 PARSE_loc_rules( rules, avp );
2815 }
2816 /* Default-EPS-Bearer-QoS */
2817 {
2818 /* Grouped */
2819 struct dict_object * avp;
2820 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Default-EPS-Bearer-QoS"};
2821 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2822 struct local_rules_definition rules[] =
2823 {
2824 { { .avp_vendor = 10415, .avp_name = "QoS-Class-Identifier"}, RULE_OPTIONAL, -1, -1 },
2825 { { .avp_vendor = 10415, .avp_name = "Allocation-Retention-Priority"}, RULE_OPTIONAL, -1, -1 }
2826 };
2827 PARSE_loc_rules( rules, avp );
2828 }
2829 /* CoA-Information */
2830 {
2831 /* Grouped */
2832 struct dict_object * avp;
2833 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "CoA-Information"};
2834 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2835 struct local_rules_definition rules[] =
2836 {
2837 { { .avp_vendor = 10415, .avp_name = "Tunnel-Information"}, RULE_REQUIRED, -1, -1 },
2838 { { .avp_vendor = 10415, .avp_name = "CoA-IP-Address"}, RULE_REQUIRED, -1, -1 }
2839 };
2840 PARSE_loc_rules( rules, avp );
2841 }
2842 /* Application-Detection-Information */
2843 {
2844 /* Grouped */
2845 struct dict_object * avp;
2846 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Application-Detection-Information"};
2847 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2848 struct local_rules_definition rules[] =
2849 {
2850 { { .avp_vendor = 10415, .avp_name = "TDF-Application-Identifier"}, RULE_REQUIRED, -1, -1 },
2851 { { .avp_vendor = 10415, .avp_name = "TDF-Application-Instance-Identifier"}, RULE_OPTIONAL, -1, -1 },
2852 { { .avp_vendor = 10415, .avp_name = "Flow-Information"}, RULE_OPTIONAL, -1, -1 }
2853 };
2854 PARSE_loc_rules( rules, avp );
2855 }
2856 /* Conditional-Policy-Information */
2857 {
2858 /* Grouped */
2859 struct dict_object * avp;
2860 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Conditional-Policy-Information"};
2861 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2862 struct local_rules_definition rules[] =
2863 {
2864 { { .avp_vendor = 10415, .avp_name = "Execution-Time"}, RULE_OPTIONAL, -1, -1 },
2865 { { .avp_vendor = 10415, .avp_name = "Default-EPS-Bearer-QoS"}, RULE_OPTIONAL, -1, -1 },
2866 { { .avp_vendor = 10415, .avp_name = "APN-Aggregate-Max-Bitrate-UL"}, RULE_OPTIONAL, -1, -1 },
2867 { { .avp_vendor = 10415, .avp_name = "APN-Aggregate-Max-Bitrate-DL"}, RULE_OPTIONAL, -1, -1 },
2868 { { .avp_vendor = 10415, .avp_name = "Conditional-APN-Aggregate-Max-Bitrate"}, RULE_OPTIONAL, -1, -1 }
2869 };
2870 PARSE_loc_rules( rules, avp );
2871 }
2872 /* Charging-Rule-Definition */
2873 {
2874 /* Grouped */
2875 struct dict_object * avp;
2876 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Charging-Rule-Definition"};
2877 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2878 struct local_rules_definition rules[] =
2879 {
2880 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Name"}, RULE_REQUIRED, -1, -1 },
2881 { { .avp_vendor = 0, .avp_name = "Service-Identifier"}, RULE_OPTIONAL, -1, -1 },
2882 { { .avp_vendor = 0, .avp_name = "Rating-Group"}, RULE_OPTIONAL, -1, -1 },
2883 { { .avp_vendor = 10415, .avp_name = "Flow-Information"}, RULE_OPTIONAL, -1, -1 },
2884 { { .avp_vendor = 10415, .avp_name = "Default-Bearer-Indication"}, RULE_OPTIONAL, -1, -1 },
2885 { { .avp_vendor = 10415, .avp_name = "TDF-Application-Identifier"}, RULE_OPTIONAL, -1, -1 },
2886 { { .avp_vendor = 10415, .avp_name = "Flow-Status"}, RULE_OPTIONAL, -1, -1 },
2887 { { .avp_vendor = 10415, .avp_name = "QoS-Information"}, RULE_OPTIONAL, -1, -1 },
2888 { { .avp_vendor = 10415, .avp_name = "PS-to-CS-Session-Continuity"}, RULE_OPTIONAL, -1, -1 },
2889 { { .avp_vendor = 10415, .avp_name = "Reporting-Level"}, RULE_OPTIONAL, -1, -1 },
2890 { { .avp_vendor = 10415, .avp_name = "Online"}, RULE_OPTIONAL, -1, -1 },
2891 { { .avp_vendor = 10415, .avp_name = "Offline"}, RULE_OPTIONAL, -1, -1 },
2892 { { .avp_vendor = 10415, .avp_name = "Metering-Method"}, RULE_OPTIONAL, -1, -1 },
2893 { { .avp_vendor = 10415, .avp_name = "Precedence"}, RULE_OPTIONAL, -1, -1 },
2894 { { .avp_vendor = 10415, .avp_name = "AF-Charging-Identifier"}, RULE_OPTIONAL, -1, -1 },
2895 { { .avp_vendor = 10415, .avp_name = "Flows"}, RULE_OPTIONAL, -1, -1 },
2896 { { .avp_vendor = 10415, .avp_name = "Monitoring-Key"}, RULE_OPTIONAL, -1, -1 },
2897 { { .avp_vendor = 10415, .avp_name = "Redirect-Information"}, RULE_OPTIONAL, -1, -1 },
2898 { { .avp_vendor = 10415, .avp_name = "Mute-Notification"}, RULE_OPTIONAL, -1, -1 },
2899 { { .avp_vendor = 10415, .avp_name = "AF-Signalling-Protocol"}, RULE_OPTIONAL, -1, -1 },
2900 { { .avp_vendor = 10415, .avp_name = "Sponsor-Identity"}, RULE_OPTIONAL, -1, -1 },
2901 { { .avp_vendor = 10415, .avp_name = "Application-Service-Provider-Identity"}, RULE_OPTIONAL, -1, -1 },
2902 { { .avp_vendor = 10415, .avp_name = "Required-Access-Info"}, RULE_OPTIONAL, -1, -1 },
2903 { { .avp_vendor = 10415, .avp_name = "Sharing-Key-DL"}, RULE_OPTIONAL, -1, -1 },
2904 { { .avp_vendor = 10415, .avp_name = "Sharing-Key-UL"}, RULE_OPTIONAL, -1, -1 },
2905 { { .avp_vendor = 10415, .avp_name = "Traffic-Steering-Policy-Identifier-DL"}, RULE_OPTIONAL, -1, -1 },
2906 { { .avp_vendor = 10415, .avp_name = "Traffic-Steering-Policy-Identifier-UL"}, RULE_OPTIONAL, -1, -1 },
2907 { { .avp_vendor = 10415, .avp_name = "Content-Version"}, RULE_OPTIONAL, -1, -1 }
2908 };
2909 PARSE_loc_rules( rules, avp );
2910 }
2911 /* Routing-Rule-Install */
2912 {
2913 /* Grouped */
2914 struct dict_object * avp;
2915 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Routing-Rule-Install"};
2916 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2917 struct local_rules_definition rules[] =
2918 {
2919 { { .avp_vendor = 10415, .avp_name = "Routing-Rule-Definition"}, RULE_OPTIONAL, -1, -1 }
2920 };
2921 PARSE_loc_rules( rules, avp );
2922 }
2923 /* ADC-Rule-Definition */
2924 {
2925 /* Grouped */
2926 struct dict_object * avp;
2927 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "ADC-Rule-Definition"};
2928 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2929 struct local_rules_definition rules[] =
2930 {
2931 { { .avp_vendor = 10415, .avp_name = "ADC-Rule-Name"}, RULE_REQUIRED, -1, -1 },
2932 { { .avp_vendor = 10415, .avp_name = "TDF-Application-Identifier"}, RULE_OPTIONAL, -1, -1 },
2933 { { .avp_vendor = 10415, .avp_name = "Flow-Information"}, RULE_OPTIONAL, -1, -1 },
2934 { { .avp_vendor = 0, .avp_name = "Service-Identifier"}, RULE_OPTIONAL, -1, -1 },
2935 { { .avp_vendor = 0, .avp_name = "Rating-Group"}, RULE_OPTIONAL, -1, -1 },
2936 { { .avp_vendor = 10415, .avp_name = "Reporting-Level"}, RULE_OPTIONAL, -1, -1 },
2937 { { .avp_vendor = 10415, .avp_name = "Online"}, RULE_OPTIONAL, -1, -1 },
2938 { { .avp_vendor = 10415, .avp_name = "Offline"}, RULE_OPTIONAL, -1, -1 },
2939 { { .avp_vendor = 10415, .avp_name = "Metering-Method"}, RULE_OPTIONAL, -1, -1 },
2940 { { .avp_vendor = 10415, .avp_name = "Precedence"}, RULE_OPTIONAL, -1, -1 },
2941 { { .avp_vendor = 10415, .avp_name = "Flow-Status"}, RULE_OPTIONAL, -1, -1 },
2942 { { .avp_vendor = 10415, .avp_name = "QoS-Information"}, RULE_OPTIONAL, -1, -1 },
2943 { { .avp_vendor = 10415, .avp_name = "Monitoring-Key"}, RULE_OPTIONAL, -1, -1 },
2944 { { .avp_vendor = 10415, .avp_name = "Sponsor-Identity"}, RULE_OPTIONAL, -1, -1 },
2945 { { .avp_vendor = 10415, .avp_name = "Application-Service-Provider-Identity"}, RULE_OPTIONAL, -1, -1 },
2946 { { .avp_vendor = 10415, .avp_name = "Redirect-Information"}, RULE_OPTIONAL, -1, -1 },
2947 { { .avp_vendor = 10415, .avp_name = "Mute-Notification"}, RULE_OPTIONAL, -1, -1 },
2948 { { .avp_vendor = 10415, .avp_name = "Traffic-Steering-Policy-Identifier-DL"}, RULE_OPTIONAL, -1, -1 },
2949 { { .avp_vendor = 10415, .avp_name = "Traffic-Steering-Policy-Identifier-UL"}, RULE_OPTIONAL, -1, -1 },
2950 { { .avp_vendor = 10415, .avp_name = "ToS-Traffic-Class"}, RULE_OPTIONAL, -1, -1 }
2951 };
2952 PARSE_loc_rules( rules, avp );
2953 }
2954 /* ADC-Rule-Report */
2955 {
2956 /* Grouped */
2957 struct dict_object * avp;
2958 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "ADC-Rule-Report"};
2959 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2960 struct local_rules_definition rules[] =
2961 {
2962 { { .avp_vendor = 10415, .avp_name = "ADC-Rule-Name"}, RULE_OPTIONAL, -1, -1 },
2963 { { .avp_vendor = 10415, .avp_name = "ADC-Rule-Base-Name"}, RULE_OPTIONAL, -1, -1 },
2964 { { .avp_vendor = 10415, .avp_name = "PCC-Rule-Status"}, RULE_OPTIONAL, -1, -1 },
2965 { { .avp_vendor = 10415, .avp_name = "Rule-Failure-Code"}, RULE_OPTIONAL, -1, -1 },
2966 { { .avp_vendor = 0, .avp_name = "Final-Unit-Indication"}, RULE_OPTIONAL, -1, -1 }
2967 };
2968 PARSE_loc_rules( rules, avp );
2969 }
2970 /* QoS-Rule-Definition */
2971 {
2972 /* Grouped */
2973 struct dict_object * avp;
2974 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "QoS-Rule-Definition"};
2975 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2976 struct local_rules_definition rules[] =
2977 {
2978 { { .avp_vendor = 10415, .avp_name = "QoS-Rule-Name"}, RULE_REQUIRED, -1, -1 },
2979 { { .avp_vendor = 10415, .avp_name = "Flow-Information"}, RULE_OPTIONAL, -1, -1 },
2980 { { .avp_vendor = 10415, .avp_name = "QoS-Information"}, RULE_OPTIONAL, -1, -1 },
2981 { { .avp_vendor = 10415, .avp_name = "Precedence"}, RULE_OPTIONAL, -1, -1 },
2982 { { .avp_vendor = 10415, .avp_name = "Required-Access-Info"}, RULE_OPTIONAL, -1, -1 },
2983 { { .avp_vendor = 10415, .avp_name = "Sharing-Key-DL"}, RULE_OPTIONAL, -1, -1 },
2984 { { .avp_vendor = 10415, .avp_name = "Sharing-Key-UL"}, RULE_OPTIONAL, -1, -1 },
2985 { { .avp_vendor = 10415, .avp_name = "Content-Version"}, RULE_OPTIONAL, -1, -1 }
2986 };
2987 PARSE_loc_rules( rules, avp );
2988 }
2989 /* Charging-Rule-Report */
2990 {
2991 /* Grouped */
2992 struct dict_object * avp;
2993 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Charging-Rule-Report"};
2994 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
2995 struct local_rules_definition rules[] =
2996 {
2997 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Name"}, RULE_OPTIONAL, -1, -1 },
2998 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Base-Name"}, RULE_OPTIONAL, -1, -1 },
2999 { { .avp_vendor = 10415, .avp_name = "Bearer-Identifier"}, RULE_OPTIONAL, -1, -1 },
3000 { { .avp_vendor = 10415, .avp_name = "PCC-Rule-Status"}, RULE_OPTIONAL, -1, -1 },
3001 { { .avp_vendor = 10415, .avp_name = "Rule-Failure-Code"}, RULE_OPTIONAL, -1, -1 },
3002 { { .avp_vendor = 0, .avp_name = "Final-Unit-Indication"}, RULE_OPTIONAL, -1, -1 },
3003 { { .avp_vendor = 10415, .avp_name = "RAN-NAS-Release-Cause"}, RULE_OPTIONAL, -1, -1 },
3004 { { .avp_vendor = 10415, .avp_name = "Content-Version"}, RULE_OPTIONAL, -1, -1 }
3005 };
3006 PARSE_loc_rules( rules, avp );
3007 }
3008 /* Event-Report-Indication */
3009 {
3010 /* Grouped */
3011 struct dict_object * avp;
3012 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Event-Report-Indication"};
3013 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
3014 struct local_rules_definition rules[] =
3015 {
3016 { { .avp_vendor = 10415, .avp_name = "AN-Trusted"}, RULE_OPTIONAL, -1, -1 },
3017 { { .avp_vendor = 10415, .avp_name = "Event-Trigger"}, RULE_OPTIONAL, -1, -1 },
3018 { { .avp_vendor = 10415, .avp_name = "User-CSG-Information"}, RULE_OPTIONAL, -1, -1 },
3019 { { .avp_vendor = 10415, .avp_name = "IP-CAN-Type"}, RULE_OPTIONAL, -1, -1 },
3020 { { .avp_vendor = 10415, .avp_name = "AN-GW-Address"}, RULE_OPTIONAL, 0, 2 },
3021 { { .avp_vendor = 10415, .avp_name = "3GPP-SGSN-Address"}, RULE_OPTIONAL, -1, -1 },
3022 { { .avp_vendor = 10415, .avp_name = "3GPP-SGSN-Ipv6-Address"}, RULE_OPTIONAL, -1, -1 },
3023 { { .avp_vendor = 10415, .avp_name = "3GPP-SGSN-MCC-MNC"}, RULE_OPTIONAL, -1, -1 },
3024 { { .avp_vendor = 0, .avp_name = "Framed-IP-Address"}, RULE_OPTIONAL, -1, -1 },
3025 { { .avp_vendor = 10415, .avp_name = "RAT-Type"}, RULE_OPTIONAL, -1, -1 },
3026 { { .avp_vendor = 10415, .avp_name = "RAI"}, RULE_OPTIONAL, -1, -1 },
3027 { { .avp_vendor = 10415, .avp_name = "3GPP-User-Location-Info"}, RULE_OPTIONAL, -1, -1 },
3028 { { .avp_vendor = 10415, .avp_name = "Trace-Data"}, RULE_OPTIONAL, -1, -1 },
3029 { { .avp_vendor = 10415, .avp_name = "Trace-Reference"}, RULE_OPTIONAL, -1, -1 },
3030 { { .avp_vendor = 5535, .avp_name = "3GPP2-BSID"}, RULE_OPTIONAL, -1, -1 },
3031 { { .avp_vendor = 10415, .avp_name = "3GPP-MS-TimeZone"}, RULE_OPTIONAL, -1, -1 },
3032 { { .avp_vendor = 10415, .avp_name = "Routing-IP-Address"}, RULE_OPTIONAL, -1, -1 },
3033 { { .avp_vendor = 10415, .avp_name = "UE-Local-IP-Address"}, RULE_OPTIONAL, -1, -1 },
3034 { { .avp_vendor = 10415, .avp_name = "HeNB-Local-IP-Address"}, RULE_OPTIONAL, -1, -1 },
3035 { { .avp_vendor = 10415, .avp_name = "UDP-Source-Port"}, RULE_OPTIONAL, -1, -1 },
3036 { { .avp_vendor = 10415, .avp_name = "Presence-Reporting-Area-Information"}, RULE_OPTIONAL, -1, -1 }
3037 };
3038 PARSE_loc_rules( rules, avp );
3039 }
3040 /* Charging-Rule-Install */
3041 {
3042 /* Grouped */
3043 struct dict_object * avp;
3044 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Charging-Rule-Install"};
3045 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
3046 struct local_rules_definition rules[] =
3047 {
3048 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Definition"}, RULE_OPTIONAL, -1, -1 },
3049 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Name"}, RULE_OPTIONAL, -1, -1 },
3050 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Base-Name"}, RULE_OPTIONAL, -1, -1 },
3051 { { .avp_vendor = 10415, .avp_name = "Bearer-Identifier"}, RULE_OPTIONAL, -1, -1 },
3052 { { .avp_vendor = 10415, .avp_name = "Monitoring-Flags"}, RULE_OPTIONAL, -1, -1 },
3053 { { .avp_vendor = 10415, .avp_name = "Rule-Activation-Time"}, RULE_OPTIONAL, -1, -1 },
3054 { { .avp_vendor = 10415, .avp_name = "Rule-Deactivation-Time"}, RULE_OPTIONAL, -1, -1 },
3055 { { .avp_vendor = 10415, .avp_name = "Resource-Allocation-Notification"}, RULE_OPTIONAL, -1, -1 },
3056 { { .avp_vendor = 10415, .avp_name = "Charging-Correlation-Indicator"}, RULE_OPTIONAL, -1, -1 },
3057 { { .avp_vendor = 10415, .avp_name = "IP-CAN-Type"}, RULE_OPTIONAL, -1, -1 }
3058 };
3059 PARSE_loc_rules( rules, avp );
3060 }
3061 /* QoS-Rule-Install */
3062 {
3063 /* Grouped */
3064 struct dict_object * avp;
3065 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "QoS-Rule-Install"};
3066 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
3067 struct local_rules_definition rules[] =
3068 {
3069 { { .avp_vendor = 10415, .avp_name = "QoS-Rule-Definition"}, RULE_OPTIONAL, -1, -1 },
3070 { { .avp_vendor = 10415, .avp_name = "QoS-Rule-Name"}, RULE_OPTIONAL, -1, -1 },
3071 { { .avp_vendor = 10415, .avp_name = "QoS-Rule-Base-Name"}, RULE_OPTIONAL, -1, -1 },
3072 { { .avp_vendor = 10415, .avp_name = "Tunnel-Information"}, RULE_OPTIONAL, -1, -1 },
3073 { { .avp_vendor = 10415, .avp_name = "Access-Network-Charging-Identifier-Value"}, RULE_OPTIONAL, -1, -1 },
3074 { { .avp_vendor = 10415, .avp_name = "Resource-Allocation-Notification"}, RULE_OPTIONAL, -1, -1 },
3075 { { .avp_vendor = 10415, .avp_name = "Rule-Activation-Time"}, RULE_OPTIONAL, -1, -1 },
3076 { { .avp_vendor = 10415, .avp_name = "Rule-Deactivation-Time"}, RULE_OPTIONAL, -1, -1 },
3077 { { .avp_vendor = 10415, .avp_name = "3GPP-GGSN-Address"}, RULE_OPTIONAL, -1, -1 },
3078 { { .avp_vendor = 10415, .avp_name = "3GPP-GGSN-Ipv6-Address"}, RULE_OPTIONAL, -1, -1 },
3079 { { .avp_vendor = 10415, .avp_name = "AN-GW-Address"}, RULE_OPTIONAL, 0, 2 },
3080 { { .avp_vendor = 10415, .avp_name = "UDP-Source-Port"}, RULE_OPTIONAL, -1, -1 }
3081 };
3082 PARSE_loc_rules( rules, avp );
3083 }
3084 /* ADC-Rule-Install */
3085 {
3086 /* Grouped */
3087 struct dict_object * avp;
3088 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "ADC-Rule-Install"};
3089 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
3090 struct local_rules_definition rules[] =
3091 {
3092 { { .avp_vendor = 10415, .avp_name = "ADC-Rule-Definition"}, RULE_OPTIONAL, -1, -1 },
3093 { { .avp_vendor = 10415, .avp_name = "ADC-Rule-Name"}, RULE_OPTIONAL, -1, -1 },
3094 { { .avp_vendor = 10415, .avp_name = "ADC-Rule-Base-Name"}, RULE_OPTIONAL, -1, -1 },
3095 { { .avp_vendor = 10415, .avp_name = "Monitoring-Flags"}, RULE_OPTIONAL, -1, -1 },
3096 { { .avp_vendor = 10415, .avp_name = "Rule-Activation-Time"}, RULE_OPTIONAL, -1, -1 },
3097 { { .avp_vendor = 10415, .avp_name = "Rule-Deactivation-Time"}, RULE_OPTIONAL, -1, -1 }
3098 };
3099 PARSE_loc_rules( rules, avp );
3100 }
3101 /* Usage-Monitoring-Information */
3102 {
3103 /* Grouped */
3104 struct dict_object * avp;
3105 struct dict_avp_request avp_vendor_plus_name = { .avp_vendor = 10415, .avp_name = "Usage-Monitoring-Information"};
3106 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avp_vendor_plus_name, &avp)
3107 struct local_rules_definition rules[] =
3108 {
3109 { { .avp_vendor = 10415, .avp_name = "Monitoring-Key"}, RULE_OPTIONAL, -1, -1 },
3110 { { .avp_vendor = 0, .avp_name = "Granted-Service-Unit"}, RULE_OPTIONAL, 0, 2 },
3111 { { .avp_vendor = 0, .avp_name = "Used-Service-Unit"}, RULE_OPTIONAL, 0, 2 },
3112 { { .avp_vendor = 10415, .avp_name = "Quota-Consumption-Time"}, RULE_OPTIONAL, -1, -1 },
3113 { { .avp_vendor = 10415, .avp_name = "Usage-Monitoring-Level"}, RULE_OPTIONAL, -1, -1 },
3114 { { .avp_vendor = 10415, .avp_name = "Usage-Monitoring-Report"}, RULE_OPTIONAL, -1, -1 },
3115 { { .avp_vendor = 10415, .avp_name = "Usage-Monitoring-Support"}, RULE_OPTIONAL, -1, -1 }
3116 };
3117 PARSE_loc_rules( rules, avp );
3118 }
3119
3120 }
3121
3122 /* Commands section */
3123 {
3124
3125 }
3126
3127 LOG_D( "Extension 'Dictionary definitions for ts29212_avps (e30)' initialized");
3128 return 0;
3129}
3130
3131int dict_entry(char * conffile)
3132{
3133 dict_ts29212_avps_load_defs(conffile);
3134 return dict_ts29212_avps_load_rules(conffile);
3135}
3136
3137const char* dict_ts29212_avps_proto_ver(char * conffile) {
3138 return ts29212_avps_proto_ver;
3139}
3140
3141const double dict_ts29212_avps_gen_ts(char * conffile) {
3142 return ts29212_avps_gen_date;
3143}
3144
3145EXTENSION_ENTRY2("dict_ts29212_avps", dict_ts29212_avps_load_defs, dict_ts29212_avps_load_rules, "dict_ts32299_avps", "dict_ts29273_avps", "dict_ts29214_avps", "dict_ts29272_avps", "dict_ts29229_avps", "dict_rfc4006bis_avps", "dict_ts29061_avps", "dict_draftload_avps", "dict_rfc7683_avps", "dict_rfc7155_avps", "dict_etsi283034_avps", "dict_3gpp2_avps", "dict_rfc7944_avps");
3146
3147
3148