Mercurial > hg > freeDiameter

comparison extensions/dict_dcca_3gpp/dict_dcca_3gpp.c @ 1534:c83e60f28632

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
dict_dcca_3gpp: simplify rule creation Refactor local_rules_definition to simplify rule creation (to avoid c99 struct initialisers that result in long lines). No change to generated rules.
author Luke Mewburn <luke@mewburn.net>
date Mon, 20 Apr 2020 12:12:42 +1000
parents 64d0a145b041
children 00278a2c5b90
comparison
equal deleted inserted replaced
1533:f8561a0f7ac1 1534:c83e60f28632
95 95
96 #define CHECK_dict_search( _type, _criteria, _what, _result ) \ 96 #define CHECK_dict_search( _type, _criteria, _what, _result ) \
97 CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, (_type), (_criteria), (_what), (_result), ENOENT) ); 97 CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, (_type), (_criteria), (_what), (_result), ENOENT) );
98 98
99 struct local_rules_definition { 99 struct local_rules_definition {
100 struct dict_avp_request avp_vendor_plus_name; 100 vendor_id_t vendor;
101 char * name;
101 enum rule_position position; 102 enum rule_position position;
102 int min; 103 int min;
103 int max; 104 int max;
104 }; 105 };
105 106
107 108
108 /* Attention! This version of the macro uses AVP_BY_NAME_AND_VENDOR, in contrast to most other copies! */ 109 /* Attention! This version of the macro uses AVP_BY_NAME_AND_VENDOR, in contrast to most other copies! */
109 #define PARSE_loc_rules( _rulearray, _parent) { \ 110 #define PARSE_loc_rules( _rulearray, _parent) { \
110 int __ar; \ 111 int __ar; \
111 for (__ar=0; __ar < sizeof(_rulearray) / sizeof((_rulearray)[0]); __ar++) { \ 112 for (__ar=0; __ar < sizeof(_rulearray) / sizeof((_rulearray)[0]); __ar++) { \
113 struct dict_avp_request __avp = { \
114 .avp_vendor = (_rulearray)[__ar].vendor, \
115 .avp_name = (_rulearray)[__ar].name, \
116 }; \
112 struct dict_rule_data __data = { NULL, \ 117 struct dict_rule_data __data = { NULL, \
113 (_rulearray)[__ar].position, \ 118 (_rulearray)[__ar].position, \
114 0, \ 119 0, \
115 (_rulearray)[__ar].min, \ 120 (_rulearray)[__ar].min, \
116 (_rulearray)[__ar].max}; \ 121 (_rulearray)[__ar].max}; \
117 __data.rule_order = RULE_ORDER(__data.rule_position); \ 122 __data.rule_order = RULE_ORDER(__data.rule_position); \
118 CHECK_FCT( fd_dict_search( \ 123 CHECK_FCT( fd_dict_search( \
119 fd_g_config->cnf_dict, \ 124 fd_g_config->cnf_dict, \
120 DICT_AVP, \ 125 DICT_AVP, \
121 AVP_BY_NAME_AND_VENDOR, \ 126 AVP_BY_NAME_AND_VENDOR, \
122 &(_rulearray)[__ar].avp_vendor_plus_name, \ 127 &__avp, \
123 &__data.rule_avp, 0 ) ); \ 128 &__data.rule_avp, 0 ) ); \
124 if ( !__data.rule_avp ) { \ 129 if ( !__data.rule_avp ) { \
125 LOG_E( "AVP Not found: '%s'", (_rulearray)[__ar].avp_vendor_plus_name.avp_name); \ 130 LOG_E( "AVP Not found: '%s'", __avp.avp_name); \
126 return ENOENT; \ 131 return ENOENT; \
127 } \ 132 } \
128 CHECK_FCT_DO( fd_dict_new( fd_g_config->cnf_dict, DICT_RULE, &__data, _parent, NULL), \ 133 CHECK_FCT_DO( fd_dict_new( fd_g_config->cnf_dict, DICT_RULE, &__data, _parent, NULL), \
129 { \ 134 { \
130 LOG_E( "Error on rule with AVP '%s'", \ 135 LOG_E( "Error on rule with AVP '%s'", __avp.avp_name); \
131 (_rulearray)[__ar].avp_vendor_plus_name.avp_name); \
132 return EINVAL; \ 136 return EINVAL; \
133 } ); \ 137 } ); \
134 } \ 138 } \
135 } 139 }
136 140
357 vpa.avp_vendor = 10415; 361 vpa.avp_vendor = 10415;
358 vpa.avp_name = "Allocation-Retention-Priority"; 362 vpa.avp_name = "Allocation-Retention-Priority";
359 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 363 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
360 struct local_rules_definition rules[] = 364 struct local_rules_definition rules[] =
361 { 365 {
362 { { .avp_vendor = 10415, .avp_name = "Priority-Level" }, RULE_REQUIRED, -1, 1 }, 366 { 10415, "Priority-Level", RULE_REQUIRED, -1, 1 },
363 { { .avp_vendor = 10415, .avp_name = "Pre-emption-Capability" }, RULE_OPTIONAL, -1, 1 }, 367 { 10415, "Pre-emption-Capability", RULE_OPTIONAL, -1, 1 },
364 { { .avp_vendor = 10415, .avp_name = "Pre-emption-Vulnerability" }, RULE_OPTIONAL, -1, 1 }, 368 { 10415, "Pre-emption-Vulnerability", RULE_OPTIONAL, -1, 1 },
365 }; 369 };
366 PARSE_loc_rules(rules, rule_avp); 370 PARSE_loc_rules(rules, rule_avp);
367 } 371 }
368 372
369 { 373 {
372 vpa.avp_vendor = 10415; 376 vpa.avp_vendor = 10415;
373 vpa.avp_name = "QoS-Information"; 377 vpa.avp_name = "QoS-Information";
374 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 378 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
375 struct local_rules_definition rules[] = 379 struct local_rules_definition rules[] =
376 { 380 {
377 { { .avp_vendor = 10415, .avp_name = "QoS-Class-Identifier" }, RULE_OPTIONAL, -1, 1 }, 381 { 10415, "QoS-Class-Identifier", RULE_OPTIONAL, -1, 1 },
378 { { .avp_vendor = 10415, .avp_name = "Max-Requested-Bandwidth-UL" }, RULE_OPTIONAL, -1, 1 }, 382 { 10415, "Max-Requested-Bandwidth-UL", RULE_OPTIONAL, -1, 1 },
379 { { .avp_vendor = 10415, .avp_name = "Max-Requested-Bandwidth-DL" }, RULE_OPTIONAL, -1, 1 }, 383 { 10415, "Max-Requested-Bandwidth-DL", RULE_OPTIONAL, -1, 1 },
380 { { .avp_vendor = 10415, .avp_name = "Guaranteed-Bitrate-UL" }, RULE_OPTIONAL, -1, 1 }, 384 { 10415, "Guaranteed-Bitrate-UL", RULE_OPTIONAL, -1, 1 },
381 { { .avp_vendor = 10415, .avp_name = "Guaranteed-Bitrate-DL" }, RULE_OPTIONAL, -1, 1 }, 385 { 10415, "Guaranteed-Bitrate-DL", RULE_OPTIONAL, -1, 1 },
382 { { .avp_vendor = 10415, .avp_name = "Bearer-Identifier" }, RULE_OPTIONAL, -1, 1 }, 386 { 10415, "Bearer-Identifier", RULE_OPTIONAL, -1, 1 },
383 { { .avp_vendor = 10415, .avp_name = "Allocation-Retention-Priority" }, RULE_OPTIONAL, -1, 1 }, 387 { 10415, "Allocation-Retention-Priority", RULE_OPTIONAL, -1, 1 },
384 { { .avp_vendor = 10415, .avp_name = "APN-Aggregate-Max-Bitrate-UL" }, RULE_OPTIONAL, -1, 1 }, 388 { 10415, "APN-Aggregate-Max-Bitrate-UL", RULE_OPTIONAL, -1, 1 },
385 { { .avp_vendor = 10415, .avp_name = "APN-Aggregate-Max-Bitrate-DL" }, RULE_OPTIONAL, -1, 1 }, 389 { 10415, "APN-Aggregate-Max-Bitrate-DL", RULE_OPTIONAL, -1, 1 },
386 }; 390 };
387 PARSE_loc_rules(rules, rule_avp); 391 PARSE_loc_rules(rules, rule_avp);
388 } 392 }
389 393
390 /* 32.299 */ 394 /* 32.299 */
393 /* additional allowed AVPs */ 397 /* additional allowed AVPs */
394 struct dict_object *ccr; 398 struct dict_object *ccr;
395 CHECK_dict_search(DICT_COMMAND, CMD_BY_NAME, "Credit-Control-Request", &ccr); 399 CHECK_dict_search(DICT_COMMAND, CMD_BY_NAME, "Credit-Control-Request", &ccr);
396 struct local_rules_definition rules[] = 400 struct local_rules_definition rules[] =
397 { 401 {
398 { { .avp_vendor = 10415, .avp_name = "AoC-Request-Type"}, RULE_OPTIONAL, -1, 1 }, 402 { 10415, "AoC-Request-Type", RULE_OPTIONAL, -1, 1 },
399 { { .avp_vendor = 10415, .avp_name = "Service-Information"}, RULE_OPTIONAL, -1, 1 }, 403 { 10415, "Service-Information", RULE_OPTIONAL, -1, 1 },
400 }; 404 };
401 PARSE_loc_rules(rules, ccr); 405 PARSE_loc_rules(rules, ccr);
402 } 406 }
403 407
404 { 408 {
405 /* additional allowed AVPs */ 409 /* additional allowed AVPs */
406 struct dict_object *ccr; 410 struct dict_object *ccr;
407 CHECK_dict_search(DICT_COMMAND, CMD_BY_NAME, "Credit-Control-Answer", &ccr); 411 CHECK_dict_search(DICT_COMMAND, CMD_BY_NAME, "Credit-Control-Answer", &ccr);
408 struct local_rules_definition rules[] = 412 struct local_rules_definition rules[] =
409 { 413 {
410 { { .avp_vendor = 10415, .avp_name = "Low-Balance-Indication"}, RULE_OPTIONAL, -1, 1 }, 414 { 10415, "Low-Balance-Indication", RULE_OPTIONAL, -1, 1 },
411 { { .avp_vendor = 10415, .avp_name = "Remaining-Balance"}, RULE_OPTIONAL, -1, 1 }, 415 { 10415, "Remaining-Balance", RULE_OPTIONAL, -1, 1 },
412 { { .avp_vendor = 10415, .avp_name = "Service-Information"}, RULE_OPTIONAL, -1, 1 }, 416 { 10415, "Service-Information", RULE_OPTIONAL, -1, 1 },
413 }; 417 };
414 PARSE_loc_rules(rules, ccr); 418 PARSE_loc_rules(rules, ccr);
415 } 419 }
416 420
417 { 421 {
420 vpa.avp_vendor = 10415; 424 vpa.avp_vendor = 10415;
421 vpa.avp_name = "Address-Domain"; 425 vpa.avp_name = "Address-Domain";
422 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 426 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
423 struct local_rules_definition rules[] = 427 struct local_rules_definition rules[] =
424 { 428 {
425 { { .avp_vendor = 10415, .avp_name = "Domain-Name" }, RULE_OPTIONAL, -1, 1 }, 429 { 10415, "Domain-Name", RULE_OPTIONAL, -1, 1 },
426 { { .avp_vendor = 10415, .avp_name = "3GPP-IMSI-MCC-MNC" }, RULE_OPTIONAL, -1, 1 }, 430 { 10415, "3GPP-IMSI-MCC-MNC", RULE_OPTIONAL, -1, 1 },
427 }; 431 };
428 PARSE_loc_rules(rules, rule_avp); 432 PARSE_loc_rules(rules, rule_avp);
429 } 433 }
430 434
431 { 435 {
434 vpa.avp_vendor = 10415; 438 vpa.avp_vendor = 10415;
435 vpa.avp_name = "Application-Server-Information"; 439 vpa.avp_name = "Application-Server-Information";
436 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 440 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
437 struct local_rules_definition rules[] = 441 struct local_rules_definition rules[] =
438 { 442 {
439 { { .avp_vendor = 10415, .avp_name = "Application-Server" }, RULE_REQUIRED, -1, 1 }, 443 { 10415, "Application-Server", RULE_REQUIRED, -1, 1 },
440 { { .avp_vendor = 10415, .avp_name = "Application-Provided-Called-Party-Address" }, RULE_OPTIONAL, -1, -1 }, 444 { 10415, "Application-Provided-Called-Party-Address", RULE_OPTIONAL, -1, -1 },
441 }; 445 };
442 PARSE_loc_rules(rules, rule_avp); 446 PARSE_loc_rules(rules, rule_avp);
443 } 447 }
444 448
445 { 449 {
448 vpa.avp_vendor = 10415; 452 vpa.avp_vendor = 10415;
449 vpa.avp_name = "Destination-Interface"; 453 vpa.avp_name = "Destination-Interface";
450 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 454 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
451 struct local_rules_definition rules[] = 455 struct local_rules_definition rules[] =
452 { 456 {
453 { { .avp_vendor = 10415, .avp_name = "Interface-Id" }, RULE_OPTIONAL, -1, 1 }, 457 { 10415, "Interface-Id", RULE_OPTIONAL, -1, 1 },
454 { { .avp_vendor = 10415, .avp_name = "Interface-Text" }, RULE_OPTIONAL, -1, 1 }, 458 { 10415, "Interface-Text", RULE_OPTIONAL, -1, 1 },
455 { { .avp_vendor = 10415, .avp_name = "Interface-Port" }, RULE_OPTIONAL, -1, 1 }, 459 { 10415, "Interface-Port", RULE_OPTIONAL, -1, 1 },
456 { { .avp_vendor = 10415, .avp_name = "Interface-Type" }, RULE_OPTIONAL, -1, 1 }, 460 { 10415, "Interface-Type", RULE_OPTIONAL, -1, 1 },
457 }; 461 };
458 PARSE_loc_rules(rules, rule_avp); 462 PARSE_loc_rules(rules, rule_avp);
459 } 463 }
460 464
461 { 465 {
464 vpa.avp_vendor = 10415; 468 vpa.avp_vendor = 10415;
465 vpa.avp_name = "Envelope"; 469 vpa.avp_name = "Envelope";
466 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 470 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
467 struct local_rules_definition rules[] = 471 struct local_rules_definition rules[] =
468 { 472 {
469 { { .avp_vendor = 10415, .avp_name = "Envelope-Start-Time" }, RULE_REQUIRED, -1, 1 }, 473 { 10415, "Envelope-Start-Time", RULE_REQUIRED, -1, 1 },
470 { { .avp_vendor = 10415, .avp_name = "Envelope-End-Time" }, RULE_OPTIONAL, -1, 1 }, 474 { 10415, "Envelope-End-Time", RULE_OPTIONAL, -1, 1 },
471 { { .avp_vendor = 0, .avp_name = "CC-Total-Octets" }, RULE_REQUIRED, -1, 1 }, 475 { 0, "CC-Total-Octets", RULE_REQUIRED, -1, 1 },
472 { { .avp_vendor = 0, .avp_name = "CC-Input-Octets" }, RULE_OPTIONAL, -1, 1 }, 476 { 0, "CC-Input-Octets", RULE_OPTIONAL, -1, 1 },
473 { { .avp_vendor = 0, .avp_name = "CC-Output-Octets" }, RULE_OPTIONAL, -1, 1 }, 477 { 0, "CC-Output-Octets", RULE_OPTIONAL, -1, 1 },
474 { { .avp_vendor = 0, .avp_name = "CC-Service-Specific-Units" }, RULE_OPTIONAL, -1, 1 }, 478 { 0, "CC-Service-Specific-Units", RULE_OPTIONAL, -1, 1 },
475 }; 479 };
476 PARSE_loc_rules(rules, rule_avp); 480 PARSE_loc_rules(rules, rule_avp);
477 } 481 }
478 482
479 { 483 {
482 vpa.avp_vendor = 10415; 486 vpa.avp_vendor = 10415;
483 vpa.avp_name = "Event-Type"; 487 vpa.avp_name = "Event-Type";
484 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 488 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
485 struct local_rules_definition rules[] = 489 struct local_rules_definition rules[] =
486 { 490 {
487 { { .avp_vendor = 10415, .avp_name = "SIP-Method" }, RULE_OPTIONAL, -1, 1 }, 491 { 10415, "SIP-Method", RULE_OPTIONAL, -1, 1 },
488 { { .avp_vendor = 10415, .avp_name = "Event" }, RULE_OPTIONAL, -1, 1 }, 492 { 10415, "Event", RULE_OPTIONAL, -1, 1 },
489 { { .avp_vendor = 10415, .avp_name = "Expires" }, RULE_OPTIONAL, -1, 1 }, 493 { 10415, "Expires", RULE_OPTIONAL, -1, 1 },
490 }; 494 };
491 PARSE_loc_rules(rules, rule_avp); 495 PARSE_loc_rules(rules, rule_avp);
492 } 496 }
493 497
494 { 498 {
497 vpa.avp_vendor = 10415; 501 vpa.avp_vendor = 10415;
498 vpa.avp_name = "IMS-Information"; 502 vpa.avp_name = "IMS-Information";
499 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 503 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
500 struct local_rules_definition rules[] = 504 struct local_rules_definition rules[] =
501 { 505 {
502 { { .avp_vendor = 10415, .avp_name = "Event-Type" }, RULE_OPTIONAL, -1, 1 }, 506 { 10415, "Event-Type", RULE_OPTIONAL, -1, 1 },
503 { { .avp_vendor = 10415, .avp_name = "Role-Of-Node" }, RULE_OPTIONAL, -1, 1 }, 507 { 10415, "Role-Of-Node", RULE_OPTIONAL, -1, 1 },
504 { { .avp_vendor = 10415, .avp_name = "Node-Functionality" }, RULE_REQUIRED, -1, 1 }, 508 { 10415, "Node-Functionality", RULE_REQUIRED, -1, 1 },
505 { { .avp_vendor = 10415, .avp_name = "User-Session-Id" }, RULE_OPTIONAL, -1, 1 }, 509 { 10415, "User-Session-Id", RULE_OPTIONAL, -1, 1 },
506 { { .avp_vendor = 10415, .avp_name = "Outgoing-Session-Id" }, RULE_OPTIONAL, -1, 1 }, 510 { 10415, "Outgoing-Session-Id", RULE_OPTIONAL, -1, 1 },
507 { { .avp_vendor = 10415, .avp_name = "Session-Priority" }, RULE_OPTIONAL, -1, 1 }, 511 { 10415, "Session-Priority", RULE_OPTIONAL, -1, 1 },
508 { { .avp_vendor = 10415, .avp_name = "Calling-Party-Address" }, RULE_OPTIONAL, -1, -1 }, 512 { 10415, "Calling-Party-Address", RULE_OPTIONAL, -1, -1 },
509 { { .avp_vendor = 10415, .avp_name = "Called-Party-Address" }, RULE_OPTIONAL, -1, 1 }, 513 { 10415, "Called-Party-Address", RULE_OPTIONAL, -1, 1 },
510 { { .avp_vendor = 10415, .avp_name = "Called-Asserted-Identity" }, RULE_OPTIONAL, -1, -1 }, 514 { 10415, "Called-Asserted-Identity", RULE_OPTIONAL, -1, -1 },
511 { { .avp_vendor = 10415, .avp_name = "Number-Portability-Routing-Information" }, RULE_OPTIONAL, -1, 1 }, 515 { 10415, "Number-Portability-Routing-Information", RULE_OPTIONAL, -1, 1 },
512 { { .avp_vendor = 10415, .avp_name = "Carrier-Select-Routing-Information" }, RULE_OPTIONAL, -1, 1 }, 516 { 10415, "Carrier-Select-Routing-Information", RULE_OPTIONAL, -1, 1 },
513 { { .avp_vendor = 10415, .avp_name = "Alternate-Charged-Party-Address" }, RULE_OPTIONAL, -1, 1 }, 517 { 10415, "Alternate-Charged-Party-Address", RULE_OPTIONAL, -1, 1 },
514 { { .avp_vendor = 10415, .avp_name = "Requested-Party-Address" }, RULE_OPTIONAL, -1, -1 }, 518 { 10415, "Requested-Party-Address", RULE_OPTIONAL, -1, -1 },
515 { { .avp_vendor = 10415, .avp_name = "Associated-URI" }, RULE_OPTIONAL, -1, -1 }, 519 { 10415, "Associated-URI", RULE_OPTIONAL, -1, -1 },
516 { { .avp_vendor = 10415, .avp_name = "Time-Stamps" }, RULE_OPTIONAL, -1, 1 }, 520 { 10415, "Time-Stamps", RULE_OPTIONAL, -1, 1 },
517 { { .avp_vendor = 10415, .avp_name = "Application-Server-Information" }, RULE_OPTIONAL, -1, -1 }, 521 { 10415, "Application-Server-Information", RULE_OPTIONAL, -1, -1 },
518 { { .avp_vendor = 10415, .avp_name = "Inter-Operator-Identifier" }, RULE_OPTIONAL, -1, -1 }, 522 { 10415, "Inter-Operator-Identifier", RULE_OPTIONAL, -1, -1 },
519 { { .avp_vendor = 10415, .avp_name = "Transit-IOI-List" }, RULE_OPTIONAL, -1, 1 }, 523 { 10415, "Transit-IOI-List", RULE_OPTIONAL, -1, 1 },
520 { { .avp_vendor = 10415, .avp_name = "IMS-Charging-Identifier" }, RULE_OPTIONAL, -1, 1 }, 524 { 10415, "IMS-Charging-Identifier", RULE_OPTIONAL, -1, 1 },
521 { { .avp_vendor = 10415, .avp_name = "SDP-Session-Description" }, RULE_OPTIONAL, -1, -1 }, 525 { 10415, "SDP-Session-Description", RULE_OPTIONAL, -1, -1 },
522 { { .avp_vendor = 10415, .avp_name = "SDP-Media-Component" }, RULE_OPTIONAL, -1, -1 }, 526 { 10415, "SDP-Media-Component", RULE_OPTIONAL, -1, -1 },
523 { { .avp_vendor = 10415, .avp_name = "Served-Party-IP-Address" }, RULE_OPTIONAL, -1, 1 }, 527 { 10415, "Served-Party-IP-Address", RULE_OPTIONAL, -1, 1 },
524 { { .avp_vendor = 10415, .avp_name = "Server-Capabilities" }, RULE_OPTIONAL, -1, 1 }, 528 { 10415, "Server-Capabilities", RULE_OPTIONAL, -1, 1 },
525 { { .avp_vendor = 10415, .avp_name = "Trunk-Group-Id" }, RULE_OPTIONAL, -1, 1 }, 529 { 10415, "Trunk-Group-Id", RULE_OPTIONAL, -1, 1 },
526 { { .avp_vendor = 10415, .avp_name = "Bearer-Service" }, RULE_OPTIONAL, -1, 1 }, 530 { 10415, "Bearer-Service", RULE_OPTIONAL, -1, 1 },
527 { { .avp_vendor = 10415, .avp_name = "Service-Id" }, RULE_OPTIONAL, -1, 1 }, 531 { 10415, "Service-Id", RULE_OPTIONAL, -1, 1 },
528 { { .avp_vendor = 10415, .avp_name = "Service-Specific-Info" }, RULE_OPTIONAL, -1, -1 }, 532 { 10415, "Service-Specific-Info", RULE_OPTIONAL, -1, -1 },
529 { { .avp_vendor = 10415, .avp_name = "Message-Body" }, RULE_OPTIONAL, -1, -1 }, 533 { 10415, "Message-Body", RULE_OPTIONAL, -1, -1 },
530 { { .avp_vendor = 10415, .avp_name = "Cause-Code" }, RULE_OPTIONAL, -1, 1 }, 534 { 10415, "Cause-Code", RULE_OPTIONAL, -1, 1 },
531 { { .avp_vendor = 10415, .avp_name = "Access-Network-Information" }, RULE_OPTIONAL, -1, 1 }, 535 { 10415, "Access-Network-Information", RULE_OPTIONAL, -1, 1 },
532 { { .avp_vendor = 10415, .avp_name = "Early-Media-Description" }, RULE_OPTIONAL, -1, -1 }, 536 { 10415, "Early-Media-Description", RULE_OPTIONAL, -1, -1 },
533 { { .avp_vendor = 10415, .avp_name = "IMS-Communication-Service-Identifier" }, RULE_OPTIONAL, -1, 1 }, 537 { 10415, "IMS-Communication-Service-Identifier",RULE_OPTIONAL, -1, 1 },
534 { { .avp_vendor = 10415, .avp_name = "IMS-Application-Reference-Identifier" }, RULE_OPTIONAL, -1, 1 }, 538 { 10415, "IMS-Application-Reference-Identifier",RULE_OPTIONAL, -1, 1 },
535 { { .avp_vendor = 10415, .avp_name = "Online-Charging-Flag" }, RULE_OPTIONAL, -1, 1 }, 539 { 10415, "Online-Charging-Flag", RULE_OPTIONAL, -1, 1 },
536 { { .avp_vendor = 10415, .avp_name = "Real-Time-Tariff-Information" }, RULE_OPTIONAL, -1, 1 }, 540 { 10415, "Real-Time-Tariff-Information", RULE_OPTIONAL, -1, 1 },
537 { { .avp_vendor = 10415, .avp_name = "Account-Expiration" }, RULE_OPTIONAL, -1, 1 }, 541 { 10415, "Account-Expiration", RULE_OPTIONAL, -1, 1 },
538 { { .avp_vendor = 10415, .avp_name = "Initial-IMS-Charging-Identifier" }, RULE_OPTIONAL, -1, 1 }, 542 { 10415, "Initial-IMS-Charging-Identifier", RULE_OPTIONAL, -1, 1 },
539 { { .avp_vendor = 10415, .avp_name = "NNI-Information" }, RULE_OPTIONAL, -1, -1 }, 543 { 10415, "NNI-Information", RULE_OPTIONAL, -1, -1 },
540 { { .avp_vendor = 10415, .avp_name = "From-Address" }, RULE_OPTIONAL, -1, 1 }, 544 { 10415, "From-Address", RULE_OPTIONAL, -1, 1 },
541 { { .avp_vendor = 10415, .avp_name = "IMS-Emergency-Indicator" }, RULE_OPTIONAL, -1, 1 }, 545 { 10415, "IMS-Emergency-Indicator", RULE_OPTIONAL, -1, 1 },
542 { { .avp_vendor = 10415, .avp_name = "Access-Transfer-Information" }, RULE_OPTIONAL, -1, -1 }, 546 { 10415, "Access-Transfer-Information", RULE_OPTIONAL, -1, -1 },
543 }; 547 };
544 PARSE_loc_rules(rules, rule_avp); 548 PARSE_loc_rules(rules, rule_avp);
545 } 549 }
546 550
547 { 551 {
550 vpa.avp_vendor = 10415; 554 vpa.avp_vendor = 10415;
551 vpa.avp_name = "Message-Class"; 555 vpa.avp_name = "Message-Class";
552 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 556 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
553 struct local_rules_definition rules[] = 557 struct local_rules_definition rules[] =
554 { 558 {
555 { { .avp_vendor = 10415, .avp_name = "Class-Identifier" }, RULE_OPTIONAL, -1, 1 }, 559 { 10415, "Class-Identifier", RULE_OPTIONAL, -1, 1 },
556 { { .avp_vendor = 10415, .avp_name = "Token-Text" }, RULE_OPTIONAL, -1, 1 }, 560 { 10415, "Token-Text", RULE_OPTIONAL, -1, 1 },
557 }; 561 };
558 PARSE_loc_rules(rules, rule_avp); 562 PARSE_loc_rules(rules, rule_avp);
559 } 563 }
560 564
561 { 565 {
564 vpa.avp_vendor = 10415; 568 vpa.avp_vendor = 10415;
565 vpa.avp_name = "MMS-Information"; 569 vpa.avp_name = "MMS-Information";
566 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 570 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
567 struct local_rules_definition rules[] = 571 struct local_rules_definition rules[] =
568 { 572 {
569 { { .avp_vendor = 10415, .avp_name = "Originator-Address" }, RULE_OPTIONAL, -1, 1 }, 573 { 10415, "Originator-Address", RULE_OPTIONAL, -1, 1 },
570 { { .avp_vendor = 10415, .avp_name = "Recipient-Address" }, RULE_OPTIONAL, -1, -1 }, 574 { 10415, "Recipient-Address", RULE_OPTIONAL, -1, -1 },
571 { { .avp_vendor = 10415, .avp_name = "Submission-Time" }, RULE_OPTIONAL, -1, 1 }, 575 { 10415, "Submission-Time", RULE_OPTIONAL, -1, 1 },
572 { { .avp_vendor = 10415, .avp_name = "MM-Content-Type" }, RULE_OPTIONAL, -1, 1 }, 576 { 10415, "MM-Content-Type", RULE_OPTIONAL, -1, 1 },
573 { { .avp_vendor = 10415, .avp_name = "Priority" }, RULE_OPTIONAL, -1, -1 }, 577 { 10415, "Priority", RULE_OPTIONAL, -1, -1 },
574 { { .avp_vendor = 10415, .avp_name = "Message-ID" }, RULE_OPTIONAL, -1, 1 }, 578 { 10415, "Message-ID", RULE_OPTIONAL, -1, 1 },
575 { { .avp_vendor = 10415, .avp_name = "Message-Type" }, RULE_OPTIONAL, -1, 1 }, 579 { 10415, "Message-Type", RULE_OPTIONAL, -1, 1 },
576 { { .avp_vendor = 10415, .avp_name = "Message-Size" }, RULE_OPTIONAL, -1, 1 }, 580 { 10415, "Message-Size", RULE_OPTIONAL, -1, 1 },
577 { { .avp_vendor = 10415, .avp_name = "Message-Class" }, RULE_OPTIONAL, -1, 1 }, 581 { 10415, "Message-Class", RULE_OPTIONAL, -1, 1 },
578 { { .avp_vendor = 10415, .avp_name = "Delivery-Report-Requested" }, RULE_OPTIONAL, -1, 1 }, 582 { 10415, "Delivery-Report-Requested", RULE_OPTIONAL, -1, 1 },
579 { { .avp_vendor = 10415, .avp_name = "Read-Reply-Report-Requested" }, RULE_OPTIONAL, -1, 1 }, 583 { 10415, "Read-Reply-Report-Requested", RULE_OPTIONAL, -1, 1 },
580 { { .avp_vendor = 10415, .avp_name = "MMBox-Storage-Requested" }, RULE_OPTIONAL, -1, 1 }, 584 { 10415, "MMBox-Storage-Requested", RULE_OPTIONAL, -1, 1 },
581 { { .avp_vendor = 10415, .avp_name = "Applic-ID" }, RULE_OPTIONAL, -1, 1 }, 585 { 10415, "Applic-ID", RULE_OPTIONAL, -1, 1 },
582 { { .avp_vendor = 10415, .avp_name = "Reply-Applic-ID" }, RULE_OPTIONAL, -1, 1 }, 586 { 10415, "Reply-Applic-ID", RULE_OPTIONAL, -1, 1 },
583 { { .avp_vendor = 10415, .avp_name = "Aux-Applic-Info" }, RULE_OPTIONAL, -1, 1 }, 587 { 10415, "Aux-Applic-Info", RULE_OPTIONAL, -1, 1 },
584 { { .avp_vendor = 10415, .avp_name = "Content-Class" }, RULE_OPTIONAL, -1, 1 }, 588 { 10415, "Content-Class", RULE_OPTIONAL, -1, 1 },
585 { { .avp_vendor = 10415, .avp_name = "DRM-Content" }, RULE_OPTIONAL, -1, 1 }, 589 { 10415, "DRM-Content", RULE_OPTIONAL, -1, 1 },
586 { { .avp_vendor = 10415, .avp_name = "Adaptations" }, RULE_OPTIONAL, -1, 1 }, 590 { 10415, "Adaptations", RULE_OPTIONAL, -1, 1 },
587 { { .avp_vendor = 10415, .avp_name = "VASP-ID" }, RULE_OPTIONAL, -1, 1 }, 591 { 10415, "VASP-ID", RULE_OPTIONAL, -1, 1 },
588 { { .avp_vendor = 10415, .avp_name = "VAS-ID" }, RULE_OPTIONAL, -1, 1 }, 592 { 10415, "VAS-ID", RULE_OPTIONAL, -1, 1 },
589 }; 593 };
590 PARSE_loc_rules(rules, rule_avp); 594 PARSE_loc_rules(rules, rule_avp);
591 } 595 }
592 596
593 { 597 {
598 vpa.avp_vendor = 0; 602 vpa.avp_vendor = 0;
599 vpa.avp_name = "Multiple-Services-Credit-Control"; 603 vpa.avp_name = "Multiple-Services-Credit-Control";
600 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 604 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
601 struct local_rules_definition rules[] = 605 struct local_rules_definition rules[] =
602 { 606 {
603 { { .avp_vendor = 10415, .avp_name = "Time-Quota-Threshold" }, RULE_OPTIONAL, -1, 1 }, 607 { 10415, "Time-Quota-Threshold", RULE_OPTIONAL, -1, 1 },
604 { { .avp_vendor = 10415, .avp_name = "Volume-Quota-Threshold" }, RULE_OPTIONAL, -1, 1 }, 608 { 10415, "Volume-Quota-Threshold", RULE_OPTIONAL, -1, 1 },
605 { { .avp_vendor = 10415, .avp_name = "Unit-Quota-Threshold" }, RULE_OPTIONAL, -1, 1 }, 609 { 10415, "Unit-Quota-Threshold", RULE_OPTIONAL, -1, 1 },
606 { { .avp_vendor = 10415, .avp_name = "Quota-Holding-Time" }, RULE_OPTIONAL, -1, 1 }, 610 { 10415, "Quota-Holding-Time", RULE_OPTIONAL, -1, 1 },
607 { { .avp_vendor = 10415, .avp_name = "Quota-Consumption-Time" }, RULE_OPTIONAL, -1, 1 }, 611 { 10415, "Quota-Consumption-Time", RULE_OPTIONAL, -1, 1 },
608 { { .avp_vendor = 10415, .avp_name = "Reporting-Reason" }, RULE_OPTIONAL, -1, -1 }, 612 { 10415, "Reporting-Reason", RULE_OPTIONAL, -1, -1 },
609 { { .avp_vendor = 10415, .avp_name = "Trigger" }, RULE_OPTIONAL, -1, 1 }, 613 { 10415, "Trigger", RULE_OPTIONAL, -1, 1 },
610 { { .avp_vendor = 10415, .avp_name = "PS-Furnish-Charging-Information" }, RULE_OPTIONAL, -1, 1 }, 614 { 10415, "PS-Furnish-Charging-Information", RULE_OPTIONAL, -1, 1 },
611 { { .avp_vendor = 10415, .avp_name = "Refund-Information" }, RULE_OPTIONAL, -1, 1 }, 615 { 10415, "Refund-Information", RULE_OPTIONAL, -1, 1 },
612 { { .avp_vendor = 10415, .avp_name = "AF-Correlation-Information" }, RULE_OPTIONAL, -1, -1 }, 616 { 10415, "AF-Correlation-Information", RULE_OPTIONAL, -1, -1 },
613 { { .avp_vendor = 10415, .avp_name = "Envelope" }, RULE_OPTIONAL, -1, -1 }, 617 { 10415, "Envelope", RULE_OPTIONAL, -1, -1 },
614 { { .avp_vendor = 10415, .avp_name = "Envelope-Reporting" }, RULE_OPTIONAL, -1, 1 }, 618 { 10415, "Envelope-Reporting", RULE_OPTIONAL, -1, 1 },
615 { { .avp_vendor = 10415, .avp_name = "Time-Quota-Mechanism" }, RULE_OPTIONAL, -1, 1 }, 619 { 10415, "Time-Quota-Mechanism", RULE_OPTIONAL, -1, 1 },
616 { { .avp_vendor = 10415, .avp_name = "Service-Specific-Info" }, RULE_OPTIONAL, -1, -1 }, 620 { 10415, "Service-Specific-Info", RULE_OPTIONAL, -1, -1 },
617 { { .avp_vendor = 10415, .avp_name = "QoS-Information" }, RULE_OPTIONAL, -1, 1 }, 621 { 10415, "QoS-Information", RULE_OPTIONAL, -1, 1 },
618 }; 622 };
619 PARSE_loc_rules(rules, rule_avp); 623 PARSE_loc_rules(rules, rule_avp);
620 } 624 }
621 625
622 { 626 {
625 vpa.avp_vendor = 10415; 629 vpa.avp_vendor = 10415;
626 vpa.avp_name = "Offline-Charging"; 630 vpa.avp_name = "Offline-Charging";
627 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 631 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
628 struct local_rules_definition rules[] = 632 struct local_rules_definition rules[] =
629 { 633 {
630 { { .avp_vendor = 10415, .avp_name = "Quota-Consumption-Time" }, RULE_OPTIONAL, -1, 1 }, 634 { 10415, "Quota-Consumption-Time", RULE_OPTIONAL, -1, 1 },
631 { { .avp_vendor = 10415, .avp_name = "Time-Quota-Mechanism" }, RULE_OPTIONAL, -1, 1 }, 635 { 10415, "Time-Quota-Mechanism", RULE_OPTIONAL, -1, 1 },
632 { { .avp_vendor = 10415, .avp_name = "Envelope-Reporting" }, RULE_OPTIONAL, -1, 1 }, 636 { 10415, "Envelope-Reporting", RULE_OPTIONAL, -1, 1 },
633 { { .avp_vendor = 0, .avp_name = "Multiple-Services-Credit-Control" }, RULE_OPTIONAL, -1, -1 }, 637 { 0, "Multiple-Services-Credit-Control", RULE_OPTIONAL, -1, -1 },
634 }; 638 };
635 PARSE_loc_rules(rules, rule_avp); 639 PARSE_loc_rules(rules, rule_avp);
636 } 640 }
637 641
638 { 642 {
641 vpa.avp_vendor = 10415; 645 vpa.avp_vendor = 10415;
642 vpa.avp_name = "Originator-Address"; 646 vpa.avp_name = "Originator-Address";
643 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 647 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
644 struct local_rules_definition rules[] = 648 struct local_rules_definition rules[] =
645 { 649 {
646 { { .avp_vendor = 10415, .avp_name = "Address-Type" }, RULE_OPTIONAL, -1, 1 }, 650 { 10415, "Address-Type", RULE_OPTIONAL, -1, 1 },
647 { { .avp_vendor = 10415, .avp_name = "Address-Data" }, RULE_OPTIONAL, -1, 1 }, 651 { 10415, "Address-Data", RULE_OPTIONAL, -1, 1 },
648 { { .avp_vendor = 10415, .avp_name = "Address-Domain" }, RULE_OPTIONAL, -1, 1 }, 652 { 10415, "Address-Domain", RULE_OPTIONAL, -1, 1 },
649 }; 653 };
650 PARSE_loc_rules(rules, rule_avp); 654 PARSE_loc_rules(rules, rule_avp);
651 } 655 }
652 656
653 { 657 {
656 vpa.avp_vendor = 10415; 660 vpa.avp_vendor = 10415;
657 vpa.avp_name = "Originator-Interface"; 661 vpa.avp_name = "Originator-Interface";
658 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 662 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
659 struct local_rules_definition rules[] = 663 struct local_rules_definition rules[] =
660 { 664 {
661 { { .avp_vendor = 10415, .avp_name = "Interface-Id" }, RULE_OPTIONAL, -1, 1 }, 665 { 10415, "Interface-Id", RULE_OPTIONAL, -1, 1 },
662 { { .avp_vendor = 10415, .avp_name = "Interface-Text" }, RULE_OPTIONAL, -1, 1 }, 666 { 10415, "Interface-Text", RULE_OPTIONAL, -1, 1 },
663 { { .avp_vendor = 10415, .avp_name = "Interface-Port" }, RULE_OPTIONAL, -1, 1 }, 667 { 10415, "Interface-Port", RULE_OPTIONAL, -1, 1 },
664 { { .avp_vendor = 10415, .avp_name = "Interface-Type" }, RULE_OPTIONAL, -1, 1 }, 668 { 10415, "Interface-Type", RULE_OPTIONAL, -1, 1 },
665 }; 669 };
666 PARSE_loc_rules(rules, rule_avp); 670 PARSE_loc_rules(rules, rule_avp);
667 } 671 }
668 672
669 { 673 {
672 vpa.avp_vendor = 10415; 676 vpa.avp_vendor = 10415;
673 vpa.avp_name = "Originator-Received-Address"; 677 vpa.avp_name = "Originator-Received-Address";
674 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 678 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
675 struct local_rules_definition rules[] = 679 struct local_rules_definition rules[] =
676 { 680 {
677 { { .avp_vendor = 10415, .avp_name = "Address-Type" }, RULE_OPTIONAL, -1, 1 }, 681 { 10415, "Address-Type", RULE_OPTIONAL, -1, 1 },
678 { { .avp_vendor = 10415, .avp_name = "Address-Data" }, RULE_OPTIONAL, -1, 1 }, 682 { 10415, "Address-Data", RULE_OPTIONAL, -1, 1 },
679 { { .avp_vendor = 10415, .avp_name = "Address-Domain" }, RULE_OPTIONAL, -1, 1 }, 683 { 10415, "Address-Domain", RULE_OPTIONAL, -1, 1 },
680 }; 684 };
681 PARSE_loc_rules(rules, rule_avp); 685 PARSE_loc_rules(rules, rule_avp);
682 } 686 }
683 687
684 { 688 {
687 vpa.avp_vendor = 10415; 691 vpa.avp_vendor = 10415;
688 vpa.avp_name = "PS-Furnish-Charging-Information"; 692 vpa.avp_name = "PS-Furnish-Charging-Information";
689 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 693 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
690 struct local_rules_definition rules[] = 694 struct local_rules_definition rules[] =
691 { 695 {
692 { { .avp_vendor = 10415, .avp_name = "3GPP-Charging-Id" }, RULE_REQUIRED, -1, 1 }, 696 { 10415, "3GPP-Charging-Id", RULE_REQUIRED, -1, 1 },
693 { { .avp_vendor = 10415, .avp_name = "PS-Free-Format-Data" }, RULE_REQUIRED, -1, 1 }, 697 { 10415, "PS-Free-Format-Data", RULE_REQUIRED, -1, 1 },
694 { { .avp_vendor = 10415, .avp_name = "PS-Append-Free-Format-Data" }, RULE_OPTIONAL, -1, 1 }, 698 { 10415, "PS-Append-Free-Format-Data", RULE_OPTIONAL, -1, 1 },
695 }; 699 };
696 PARSE_loc_rules(rules, rule_avp); 700 PARSE_loc_rules(rules, rule_avp);
697 } 701 }
698 702
699 { 703 {
702 vpa.avp_vendor = 10415; 706 vpa.avp_vendor = 10415;
703 vpa.avp_name = "PS-Information"; 707 vpa.avp_name = "PS-Information";
704 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 708 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
705 struct local_rules_definition rules[] = 709 struct local_rules_definition rules[] =
706 { 710 {
707 { { .avp_vendor = 10415, .avp_name = "3GPP-Charging-Id" }, RULE_OPTIONAL, -1, 1 }, 711 { 10415, "3GPP-Charging-Id", RULE_OPTIONAL, -1, 1 },
708 { { .avp_vendor = 10415, .avp_name = "PDN-Connection-Charging-ID" }, RULE_OPTIONAL, -1, 1 }, 712 { 10415, "PDN-Connection-Charging-ID", RULE_OPTIONAL, -1, 1 },
709 { { .avp_vendor = 10415, .avp_name = "Node-Id" }, RULE_OPTIONAL, -1, 1 }, 713 { 10415, "Node-Id", RULE_OPTIONAL, -1, 1 },
710 { { .avp_vendor = 10415, .avp_name = "3GPP-PDP-Type" }, RULE_OPTIONAL, -1, 1 }, 714 { 10415, "3GPP-PDP-Type", RULE_OPTIONAL, -1, 1 },
711 { { .avp_vendor = 10415, .avp_name = "PDP-Address" }, RULE_OPTIONAL, -1, -1 }, 715 { 10415, "PDP-Address", RULE_OPTIONAL, -1, -1 },
712 { { .avp_vendor = 10415, .avp_name = "PDP-Address-Prefix-Length" }, RULE_OPTIONAL, -1, 1 }, 716 { 10415, "PDP-Address-Prefix-Length", RULE_OPTIONAL, -1, 1 },
713 { { .avp_vendor = 10415, .avp_name = "Dynamic-Address-Flag" }, RULE_OPTIONAL, -1, 1 }, 717 { 10415, "Dynamic-Address-Flag", RULE_OPTIONAL, -1, 1 },
714 { { .avp_vendor = 10415, .avp_name = "Dynamic-Address-Flag-Extension" }, RULE_OPTIONAL, -1, 1 }, 718 { 10415, "Dynamic-Address-Flag-Extension", RULE_OPTIONAL, -1, 1 },
715 { { .avp_vendor = 10415, .avp_name = "QoS-Information" }, RULE_OPTIONAL, -1, 1 }, 719 { 10415, "QoS-Information", RULE_OPTIONAL, -1, 1 },
716 { { .avp_vendor = 10415, .avp_name = "SGSN-Address" }, RULE_OPTIONAL, -1, -1 }, 720 { 10415, "SGSN-Address", RULE_OPTIONAL, -1, -1 },
717 { { .avp_vendor = 10415, .avp_name = "GGSN-Address" }, RULE_OPTIONAL, -1, -1 }, 721 { 10415, "GGSN-Address", RULE_OPTIONAL, -1, -1 },
718 { { .avp_vendor = 10415, .avp_name = "SGW-Address" }, RULE_OPTIONAL, -1, -1 }, 722 { 10415, "SGW-Address", RULE_OPTIONAL, -1, -1 },
719 { { .avp_vendor = 10415, .avp_name = "CG-Address" }, RULE_OPTIONAL, -1, 1 }, 723 { 10415, "CG-Address", RULE_OPTIONAL, -1, 1 },
720 { { .avp_vendor = 10415, .avp_name = "Serving-Node-Type" }, RULE_OPTIONAL, -1, 1 }, 724 { 10415, "Serving-Node-Type", RULE_OPTIONAL, -1, 1 },
721 { { .avp_vendor = 10415, .avp_name = "SGW-Change" }, RULE_OPTIONAL, -1, 1 }, 725 { 10415, "SGW-Change", RULE_OPTIONAL, -1, 1 },
722 { { .avp_vendor = 10415, .avp_name = "3GPP-IMSI-MCC-MNC" }, RULE_OPTIONAL, -1, 1 }, 726 { 10415, "3GPP-IMSI-MCC-MNC", RULE_OPTIONAL, -1, 1 },
723 { { .avp_vendor = 10415, .avp_name = "IMSI-Unauthenticated-Flag" }, RULE_OPTIONAL, -1, 1 }, 727 { 10415, "IMSI-Unauthenticated-Flag", RULE_OPTIONAL, -1, 1 },
724 { { .avp_vendor = 10415, .avp_name = "3GPP-GGSN-MCC-MNC" }, RULE_OPTIONAL, -1, 1 }, 728 { 10415, "3GPP-GGSN-MCC-MNC", RULE_OPTIONAL, -1, 1 },
725 { { .avp_vendor = 10415, .avp_name = "3GPP-NSAPI" }, RULE_OPTIONAL, -1, 1 }, 729 { 10415, "3GPP-NSAPI", RULE_OPTIONAL, -1, 1 },
726 { { .avp_vendor = 0, .avp_name = "Called-Station-Id" }, RULE_OPTIONAL, -1, 1 }, 730 { 0, "Called-Station-Id", RULE_OPTIONAL, -1, 1 },
727 { { .avp_vendor = 10415, .avp_name = "3GPP-Session-Stop-Indicator" }, RULE_OPTIONAL, -1, 1 }, 731 { 10415, "3GPP-Session-Stop-Indicator", RULE_OPTIONAL, -1, 1 },
728 { { .avp_vendor = 10415, .avp_name = "3GPP-Selection-Mode" }, RULE_OPTIONAL, -1, 1 }, 732 { 10415, "3GPP-Selection-Mode", RULE_OPTIONAL, -1, 1 },
729 { { .avp_vendor = 10415, .avp_name = "3GPP-Charging-Characteristics" }, RULE_OPTIONAL, -1, 1 }, 733 { 10415, "3GPP-Charging-Characteristics", RULE_OPTIONAL, -1, 1 },
730 { { .avp_vendor = 10415, .avp_name = "Charging-Characteristics-Selection-Mode" }, RULE_OPTIONAL, -1, 1 }, 734 { 10415, "Charging-Characteristics-Selection-Mode", RULE_OPTIONAL, -1, 1 },
731 { { .avp_vendor = 10415, .avp_name = "3GPP-SGSN-MCC-MNC" }, RULE_OPTIONAL, -1, 1 }, 735 { 10415, "3GPP-SGSN-MCC-MNC", RULE_OPTIONAL, -1, 1 },
732 { { .avp_vendor = 10415, .avp_name = "3GPP-MS-TimeZone" }, RULE_OPTIONAL, -1, 1 }, 736 { 10415, "3GPP-MS-TimeZone", RULE_OPTIONAL, -1, 1 },
733 { { .avp_vendor = 10415, .avp_name = "Charging-Rule-Base-Name" }, RULE_OPTIONAL, -1, 1 }, 737 { 10415, "Charging-Rule-Base-Name", RULE_OPTIONAL, -1, 1 },
734 { { .avp_vendor = 10415, .avp_name = "3GPP-User-Location-Info" }, RULE_OPTIONAL, -1, 1 }, 738 { 10415, "3GPP-User-Location-Info", RULE_OPTIONAL, -1, 1 },
735 { { .avp_vendor = 10415, .avp_name = "User-CSG-Information" }, RULE_OPTIONAL, -1, 1 }, 739 { 10415, "User-CSG-Information", RULE_OPTIONAL, -1, 1 },
736 { { .avp_vendor = 5535, .avp_name = "3GPP2-BSID" }, RULE_OPTIONAL, -1, 1 }, 740 { 5535, "3GPP2-BSID", RULE_OPTIONAL, -1, 1 },
737 { { .avp_vendor = 10415, .avp_name = "3GPP-RAT-Type" }, RULE_OPTIONAL, -1, 1 }, 741 { 10415, "3GPP-RAT-Type", RULE_OPTIONAL, -1, 1 },
738 { { .avp_vendor = 10415, .avp_name = "PS-Furnish-Charging-Information" }, RULE_OPTIONAL, -1, 1 }, 742 { 10415, "PS-Furnish-Charging-Information", RULE_OPTIONAL, -1, 1 },
739 { { .avp_vendor = 10415, .avp_name = "PDP-Context-Type" }, RULE_OPTIONAL, -1, 1 }, 743 { 10415, "PDP-Context-Type", RULE_OPTIONAL, -1, 1 },
740 { { .avp_vendor = 10415, .avp_name = "Offline-Charging" }, RULE_OPTIONAL, -1, 1 }, 744 { 10415, "Offline-Charging", RULE_OPTIONAL, -1, 1 },
741 { { .avp_vendor = 10415, .avp_name = "Traffic-Data-Volumes" }, RULE_OPTIONAL, -1, -1 }, 745 { 10415, "Traffic-Data-Volumes", RULE_OPTIONAL, -1, -1 },
742 { { .avp_vendor = 10415, .avp_name = "Service-Data-Container" }, RULE_OPTIONAL, -1, -1 }, 746 { 10415, "Service-Data-Container", RULE_OPTIONAL, -1, -1 },
743 { { .avp_vendor = 0, .avp_name = "User-Equipment-Info" }, RULE_OPTIONAL, -1, 1 }, 747 { 0, "User-Equipment-Info", RULE_OPTIONAL, -1, 1 },
744 { { .avp_vendor = 10415, .avp_name = "Terminal-Information" }, RULE_OPTIONAL, -1, 1 }, 748 { 10415, "Terminal-Information", RULE_OPTIONAL, -1, 1 },
745 { { .avp_vendor = 10415, .avp_name = "Start-Time" }, RULE_OPTIONAL, -1, 1 }, 749 { 10415, "Start-Time", RULE_OPTIONAL, -1, 1 },
746 { { .avp_vendor = 10415, .avp_name = "Stop-Time" }, RULE_OPTIONAL, -1, 1 }, 750 { 10415, "Stop-Time", RULE_OPTIONAL, -1, 1 },
747 { { .avp_vendor = 10415, .avp_name = "Change-Condition" }, RULE_OPTIONAL, -1, 1 }, 751 { 10415, "Change-Condition", RULE_OPTIONAL, -1, 1 },
748 { { .avp_vendor = 10415, .avp_name = "Diagnostics" }, RULE_OPTIONAL, -1, 1 }, 752 { 10415, "Diagnostics", RULE_OPTIONAL, -1, 1 },
749 { { .avp_vendor = 10415, .avp_name = "Low-Priority-Indicator" }, RULE_OPTIONAL, -1, 1 }, 753 { 10415, "Low-Priority-Indicator", RULE_OPTIONAL, -1, 1 },
750 { { .avp_vendor = 10415, .avp_name = "MME-Number-for-MT-SMS" }, RULE_OPTIONAL, -1, 1 }, 754 { 10415, "MME-Number-for-MT-SMS", RULE_OPTIONAL, -1, 1 },
751 { { .avp_vendor = 10415, .avp_name = "MME-Name" }, RULE_OPTIONAL, -1, 1 }, 755 { 10415, "MME-Name", RULE_OPTIONAL, -1, 1 },
752 { { .avp_vendor = 10415, .avp_name = "MME-Realm" }, RULE_OPTIONAL, -1, 1 }, 756 { 10415, "MME-Realm", RULE_OPTIONAL, -1, 1 },
753 }; 757 };
754 PARSE_loc_rules(rules, rule_avp); 758 PARSE_loc_rules(rules, rule_avp);
755 } 759 }
756 760
757 { 761 {
760 vpa.avp_vendor = 10415; 764 vpa.avp_vendor = 10415;
761 vpa.avp_name = "Recipient-Address"; 765 vpa.avp_name = "Recipient-Address";
762 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 766 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
763 struct local_rules_definition rules[] = 767 struct local_rules_definition rules[] =
764 { 768 {
765 { { .avp_vendor = 10415, .avp_name = "Address-Type" }, RULE_OPTIONAL, -1, 1 }, 769 { 10415, "Address-Type", RULE_OPTIONAL, -1, 1 },
766 { { .avp_vendor = 10415, .avp_name = "Address-Data" }, RULE_OPTIONAL, -1, 1 }, 770 { 10415, "Address-Data", RULE_OPTIONAL, -1, 1 },
767 { { .avp_vendor = 10415, .avp_name = "Address-Domain" }, RULE_OPTIONAL, -1, 1 }, 771 { 10415, "Address-Domain", RULE_OPTIONAL, -1, 1 },
768 { { .avp_vendor = 10415, .avp_name = "Addressee-Type" }, RULE_OPTIONAL, -1, 1 }, 772 { 10415, "Addressee-Type", RULE_OPTIONAL, -1, 1 },
769 }; 773 };
770 PARSE_loc_rules(rules, rule_avp); 774 PARSE_loc_rules(rules, rule_avp);
771 } 775 }
772 776
773 { 777 {
776 vpa.avp_vendor = 10415; 780 vpa.avp_vendor = 10415;
777 vpa.avp_name = "Recipient-Info"; 781 vpa.avp_name = "Recipient-Info";
778 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 782 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
779 struct local_rules_definition rules[] = 783 struct local_rules_definition rules[] =
780 { 784 {
781 { { .avp_vendor = 10415, .avp_name = "Destination-Interface" }, RULE_OPTIONAL, -1, 1 }, 785 { 10415, "Destination-Interface", RULE_OPTIONAL, -1, 1 },
782 { { .avp_vendor = 10415, .avp_name = "Recipient-Address" }, RULE_OPTIONAL, -1, -1 }, 786 { 10415, "Recipient-Address", RULE_OPTIONAL, -1, -1 },
783 { { .avp_vendor = 10415, .avp_name = "Recipient-Received-Address" }, RULE_OPTIONAL, -1, -1 }, 787 { 10415, "Recipient-Received-Address", RULE_OPTIONAL, -1, -1 },
784 { { .avp_vendor = 10415, .avp_name = "Recipient-SCCP-Address" }, RULE_OPTIONAL, -1, 1 }, 788 { 10415, "Recipient-SCCP-Address", RULE_OPTIONAL, -1, 1 },
785 { { .avp_vendor = 10415, .avp_name = "SM-Protocol-ID" }, RULE_OPTIONAL, -1, 1 }, 789 { 10415, "SM-Protocol-ID", RULE_OPTIONAL, -1, 1 },
786 }; 790 };
787 PARSE_loc_rules(rules, rule_avp); 791 PARSE_loc_rules(rules, rule_avp);
788 } 792 }
789 793
790 { 794 {
793 vpa.avp_vendor = 10415; 797 vpa.avp_vendor = 10415;
794 vpa.avp_name = "Recipient-Received-Address"; 798 vpa.avp_name = "Recipient-Received-Address";
795 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 799 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
796 struct local_rules_definition rules[] = 800 struct local_rules_definition rules[] =
797 { 801 {
798 { { .avp_vendor = 10415, .avp_name = "Address-Type" }, RULE_OPTIONAL, -1, 1 }, 802 { 10415, "Address-Type", RULE_OPTIONAL, -1, 1 },
799 { { .avp_vendor = 10415, .avp_name = "Address-Data" }, RULE_OPTIONAL, -1, 1 }, 803 { 10415, "Address-Data", RULE_OPTIONAL, -1, 1 },
800 { { .avp_vendor = 10415, .avp_name = "Address-Domain" }, RULE_OPTIONAL, -1, 1 }, 804 { 10415, "Address-Domain", RULE_OPTIONAL, -1, 1 },
801 }; 805 };
802 PARSE_loc_rules(rules, rule_avp); 806 PARSE_loc_rules(rules, rule_avp);
803 } 807 }
804 808
805 { 809 {
808 vpa.avp_vendor = 10415; 812 vpa.avp_vendor = 10415;
809 vpa.avp_name = "SDP-Media-Component"; 813 vpa.avp_name = "SDP-Media-Component";
810 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 814 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
811 struct local_rules_definition rules[] = 815 struct local_rules_definition rules[] =
812 { 816 {
813 { { .avp_vendor = 10415, .avp_name = "SDP-Media-Name" }, RULE_OPTIONAL, -1, 1 }, 817 { 10415, "SDP-Media-Name", RULE_OPTIONAL, -1, 1 },
814 { { .avp_vendor = 10415, .avp_name = "SDP-Media-Description" }, RULE_OPTIONAL, -1, -1 }, 818 { 10415, "SDP-Media-Description", RULE_OPTIONAL, -1, -1 },
815 { { .avp_vendor = 10415, .avp_name = "Local-GW-Inserted-Indication" }, RULE_OPTIONAL, -1, 1 }, 819 { 10415, "Local-GW-Inserted-Indication", RULE_OPTIONAL, -1, 1 },
816 { { .avp_vendor = 10415, .avp_name = "IP-Realm-Default-Indication" }, RULE_OPTIONAL, -1, 1 }, 820 { 10415, "IP-Realm-Default-Indication", RULE_OPTIONAL, -1, 1 },
817 { { .avp_vendor = 10415, .avp_name = "Transcoder-Inserted-Indication" }, RULE_OPTIONAL, -1, 1 }, 821 { 10415, "Transcoder-Inserted-Indication", RULE_OPTIONAL, -1, 1 },
818 { { .avp_vendor = 10415, .avp_name = "Media-Initiator-Flag" }, RULE_OPTIONAL, -1, 1 }, 822 { 10415, "Media-Initiator-Flag", RULE_OPTIONAL, -1, 1 },
819 { { .avp_vendor = 10415, .avp_name = "Media-Initiator-Party" }, RULE_OPTIONAL, -1, 1 }, 823 { 10415, "Media-Initiator-Party", RULE_OPTIONAL, -1, 1 },
820 { { .avp_vendor = 10415, .avp_name = "3GPP-Charging-Id" }, RULE_OPTIONAL, -1, 1 }, 824 { 10415, "3GPP-Charging-Id", RULE_OPTIONAL, -1, 1 },
821 { { .avp_vendor = 10415, .avp_name = "Access-Network-Charging-Identifier-Value" }, RULE_OPTIONAL, -1, 1 }, 825 { 10415, "Access-Network-Charging-Identifier-Value", RULE_OPTIONAL, -1, 1 },
822 { { .avp_vendor = 10415, .avp_name = "SDP-Type" }, RULE_OPTIONAL, -1, 1 }, 826 { 10415, "SDP-Type", RULE_OPTIONAL, -1, 1 },
823 }; 827 };
824 PARSE_loc_rules(rules, rule_avp); 828 PARSE_loc_rules(rules, rule_avp);
825 } 829 }
826 830
827 { 831 {
830 vpa.avp_vendor = 10415; 834 vpa.avp_vendor = 10415;
831 vpa.avp_name = "Service-Information"; 835 vpa.avp_name = "Service-Information";
832 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 836 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
833 struct local_rules_definition rules[] = 837 struct local_rules_definition rules[] =
834 { 838 {
835 { { .avp_vendor = 0, .avp_name = "Subscription-Id" }, RULE_OPTIONAL, -1, -1 }, 839 { 0, "Subscription-Id", RULE_OPTIONAL, -1, -1 },
836 { { .avp_vendor = 10415, .avp_name = "AoC-Information" }, RULE_OPTIONAL, -1, 1 }, 840 { 10415, "AoC-Information", RULE_OPTIONAL, -1, 1 },
837 { { .avp_vendor = 10415, .avp_name = "PS-Information" }, RULE_OPTIONAL, -1, 1 }, 841 { 10415, "PS-Information", RULE_OPTIONAL, -1, 1 },
838 { { .avp_vendor = 10415, .avp_name = "IMS-Information" }, RULE_OPTIONAL, -1, 1 }, 842 { 10415, "IMS-Information", RULE_OPTIONAL, -1, 1 },
839 { { .avp_vendor = 10415, .avp_name = "MMS-Information" }, RULE_OPTIONAL, -1, 1 }, 843 { 10415, "MMS-Information", RULE_OPTIONAL, -1, 1 },
840 { { .avp_vendor = 10415, .avp_name = "LCS-Information" }, RULE_OPTIONAL, -1, 1 }, 844 { 10415, "LCS-Information", RULE_OPTIONAL, -1, 1 },
841 { { .avp_vendor = 10415, .avp_name = "PoC-Information" }, RULE_OPTIONAL, -1, 1 }, 845 { 10415, "PoC-Information", RULE_OPTIONAL, -1, 1 },
842 { { .avp_vendor = 10415, .avp_name = "MBMS-Information" }, RULE_OPTIONAL, -1, 1 }, 846 { 10415, "MBMS-Information", RULE_OPTIONAL, -1, 1 },
843 { { .avp_vendor = 10415, .avp_name = "SMS-Information" }, RULE_OPTIONAL, -1, 1 }, 847 { 10415, "SMS-Information", RULE_OPTIONAL, -1, 1 },
844 { { .avp_vendor = 10415, .avp_name = "MMTel-Information" }, RULE_OPTIONAL, -1, 1 }, 848 { 10415, "MMTel-Information", RULE_OPTIONAL, -1, 1 },
845 { { .avp_vendor = 10415, .avp_name = "Service-Generic-Information" }, RULE_OPTIONAL, -1, 1 }, 849 { 10415, "Service-Generic-Information", RULE_OPTIONAL, -1, 1 },
846 { { .avp_vendor = 10415, .avp_name = "IM-Information" }, RULE_OPTIONAL, -1, 1 }, 850 { 10415, "IM-Information", RULE_OPTIONAL, -1, 1 },
847 { { .avp_vendor = 10415, .avp_name = "DCD-Information" }, RULE_OPTIONAL, -1, 1 }, 851 { 10415, "DCD-Information", RULE_OPTIONAL, -1, 1 },
848 }; 852 };
849 PARSE_loc_rules(rules, rule_avp); 853 PARSE_loc_rules(rules, rule_avp);
850 } 854 }
851 855
852 { 856 {
855 vpa.avp_vendor = 10415; 859 vpa.avp_vendor = 10415;
856 vpa.avp_name = "SMS-Information"; 860 vpa.avp_name = "SMS-Information";
857 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 861 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
858 struct local_rules_definition rules[] = 862 struct local_rules_definition rules[] =
859 { 863 {
860 { { .avp_vendor = 10415, .avp_name = "SMS-Node" }, RULE_OPTIONAL, -1, 1 }, 864 { 10415, "SMS-Node", RULE_OPTIONAL, -1, 1 },
861 { { .avp_vendor = 10415, .avp_name = "Client-Address" }, RULE_OPTIONAL, -1, 1 }, 865 { 10415, "Client-Address", RULE_OPTIONAL, -1, 1 },
862 { { .avp_vendor = 10415, .avp_name = "Originator-SCCP-Address" }, RULE_OPTIONAL, -1, 1 }, 866 { 10415, "Originator-SCCP-Address", RULE_OPTIONAL, -1, 1 },
863 { { .avp_vendor = 10415, .avp_name = "SMSC-Address" }, RULE_OPTIONAL, -1, 1 }, 867 { 10415, "SMSC-Address", RULE_OPTIONAL, -1, 1 },
864 { { .avp_vendor = 10415, .avp_name = "Data-Coding-Scheme" }, RULE_OPTIONAL, -1, 1 }, 868 { 10415, "Data-Coding-Scheme", RULE_OPTIONAL, -1, 1 },
865 { { .avp_vendor = 10415, .avp_name = "SM-Discharge-Time" }, RULE_OPTIONAL, -1, 1 }, 869 { 10415, "SM-Discharge-Time", RULE_OPTIONAL, -1, 1 },
866 { { .avp_vendor = 10415, .avp_name = "SM-Message-Type" }, RULE_OPTIONAL, -1, 1 }, 870 { 10415, "SM-Message-Type", RULE_OPTIONAL, -1, 1 },
867 { { .avp_vendor = 10415, .avp_name = "Originator-Interface" }, RULE_OPTIONAL, -1, 1 }, 871 { 10415, "Originator-Interface", RULE_OPTIONAL, -1, 1 },
868 { { .avp_vendor = 10415, .avp_name = "SM-Protocol-ID" }, RULE_OPTIONAL, -1, 1 }, 872 { 10415, "SM-Protocol-ID", RULE_OPTIONAL, -1, 1 },
869 { { .avp_vendor = 10415, .avp_name = "Reply-Path-Requested" }, RULE_OPTIONAL, -1, 1 }, 873 { 10415, "Reply-Path-Requested", RULE_OPTIONAL, -1, 1 },
870 { { .avp_vendor = 10415, .avp_name = "SM-Status" }, RULE_OPTIONAL, -1, 1 }, 874 { 10415, "SM-Status", RULE_OPTIONAL, -1, 1 },
871 { { .avp_vendor = 10415, .avp_name = "SM-User-Data-Header" }, RULE_OPTIONAL, -1, 1 }, 875 { 10415, "SM-User-Data-Header", RULE_OPTIONAL, -1, 1 },
872 { { .avp_vendor = 10415, .avp_name = "Number-Of-Messages-Sent" }, RULE_OPTIONAL, -1, 1 }, 876 { 10415, "Number-Of-Messages-Sent", RULE_OPTIONAL, -1, 1 },
873 { { .avp_vendor = 10415, .avp_name = "Recipient-Info" }, RULE_OPTIONAL, -1, -1 }, 877 { 10415, "Recipient-Info", RULE_OPTIONAL, -1, -1 },
874 { { .avp_vendor = 10415, .avp_name = "Originator-Received-Address" }, RULE_OPTIONAL, -1, 1 }, 878 { 10415, "Originator-Received-Address", RULE_OPTIONAL, -1, 1 },
875 { { .avp_vendor = 10415, .avp_name = "SM-Service-Type" }, RULE_OPTIONAL, -1, 1 }, 879 { 10415, "SM-Service-Type", RULE_OPTIONAL, -1, 1 },
876 }; 880 };
877 PARSE_loc_rules(rules, rule_avp); 881 PARSE_loc_rules(rules, rule_avp);
878 } 882 }
879 883
880 { 884 {
883 vpa.avp_vendor = 10415; 887 vpa.avp_vendor = 10415;
884 vpa.avp_name = "Time-Quota-Mechanism"; 888 vpa.avp_name = "Time-Quota-Mechanism";
885 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 889 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
886 struct local_rules_definition rules[] = 890 struct local_rules_definition rules[] =
887 { 891 {
888 { { .avp_vendor = 10415, .avp_name = "Time-Quota-Type" }, RULE_REQUIRED, -1, 1 }, 892 { 10415, "Time-Quota-Type", RULE_REQUIRED, -1, 1 },
889 { { .avp_vendor = 10415, .avp_name = "Base-Time-Interval" }, RULE_REQUIRED, -1, 1 }, 893 { 10415, "Base-Time-Interval", RULE_REQUIRED, -1, 1 },
890 }; 894 };
891 PARSE_loc_rules(rules, rule_avp); 895 PARSE_loc_rules(rules, rule_avp);
892 } 896 }
893 897
894 { 898 {
897 vpa.avp_vendor = 10415; 901 vpa.avp_vendor = 10415;
898 vpa.avp_name = "Time-Stamps"; 902 vpa.avp_name = "Time-Stamps";
899 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 903 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
900 struct local_rules_definition rules[] = 904 struct local_rules_definition rules[] =
901 { 905 {
902 { { .avp_vendor = 10415, .avp_name = "SIP-Request-Timestamp" }, RULE_OPTIONAL, -1, 1 }, 906 { 10415, "SIP-Request-Timestamp", RULE_OPTIONAL, -1, 1 },
903 { { .avp_vendor = 10415, .avp_name = "SIP-Response-Timestamp" }, RULE_OPTIONAL, -1, 1 }, 907 { 10415, "SIP-Response-Timestamp", RULE_OPTIONAL, -1, 1 },
904 { { .avp_vendor = 10415, .avp_name = "SIP-Request-Timestamp-Fraction" }, RULE_OPTIONAL, -1, 1 }, 908 { 10415, "SIP-Request-Timestamp-Fraction", RULE_OPTIONAL, -1, 1 },
905 { { .avp_vendor = 10415, .avp_name = "SIP-Response-Timestamp-Fraction" }, RULE_OPTIONAL, -1, 1 }, 909 { 10415, "SIP-Response-Timestamp-Fraction", RULE_OPTIONAL, -1, 1 },
906 }; 910 };
907 PARSE_loc_rules(rules, rule_avp); 911 PARSE_loc_rules(rules, rule_avp);
908 } 912 }
909 913
910 { 914 {
915 vpa.avp_vendor = 0; 919 vpa.avp_vendor = 0;
916 vpa.avp_name = "Used-Service-Unit"; 920 vpa.avp_name = "Used-Service-Unit";
917 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 921 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
918 struct local_rules_definition rules[] = 922 struct local_rules_definition rules[] =
919 { 923 {
920 { { .avp_vendor = 10415, .avp_name = "Reporting-Reason" }, RULE_OPTIONAL, -1, 1 }, 924 { 10415, "Reporting-Reason", RULE_OPTIONAL, -1, 1 },
921 { { .avp_vendor = 10415, .avp_name = "Event-Charging-TimeStamp" }, RULE_OPTIONAL, -1, -1 }, 925 { 10415, "Event-Charging-TimeStamp", RULE_OPTIONAL, -1, -1 },
922 }; 926 };
923 PARSE_loc_rules(rules, rule_avp); 927 PARSE_loc_rules(rules, rule_avp);
924 } 928 }
925 929
926 /* OMA */ 930 /* OMA */
930 vpa.avp_vendor = 10415; 934 vpa.avp_vendor = 10415;
931 vpa.avp_name = "DCD-Information"; 935 vpa.avp_name = "DCD-Information";
932 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 936 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
933 struct local_rules_definition rules[] = 937 struct local_rules_definition rules[] =
934 { 938 {
935 { { .avp_vendor = 10415, .avp_name = "Content-ID" }, RULE_OPTIONAL, -1, 1 }, 939 { 10415, "Content-ID", RULE_OPTIONAL, -1, 1 },
936 { { .avp_vendor = 10415, .avp_name = "Content-provider-ID" }, RULE_OPTIONAL, -1, 1 }, 940 { 10415, "Content-provider-ID", RULE_OPTIONAL, -1, 1 },
937 }; 941 };
938 PARSE_loc_rules(rules, rule_avp); 942 PARSE_loc_rules(rules, rule_avp);
939 } 943 }
940 { 944 {
941 struct dict_object *rule_avp; 945 struct dict_object *rule_avp;
943 vpa.avp_vendor = 10415; 947 vpa.avp_vendor = 10415;
944 vpa.avp_name = "IM-Information"; 948 vpa.avp_name = "IM-Information";
945 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 949 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
946 struct local_rules_definition rules[] = 950 struct local_rules_definition rules[] =
947 { 951 {
948 { { .avp_vendor = 10415, .avp_name = "Total-Number-Of-Messages-Sent" }, RULE_OPTIONAL, -1, 1 }, 952 { 10415, "Total-Number-Of-Messages-Sent", RULE_OPTIONAL, -1, 1 },
949 { { .avp_vendor = 10415, .avp_name = "Total-Number-Of-Messages-Exploded" }, RULE_OPTIONAL, -1, 1 }, 953 { 10415, "Total-Number-Of-Messages-Exploded", RULE_OPTIONAL, -1, 1 },
950 { { .avp_vendor = 10415, .avp_name = "Number-Of-Messages-Successfully-Sent" }, RULE_OPTIONAL, -1, 1 }, 954 { 10415, "Number-Of-Messages-Successfully-Sent", RULE_OPTIONAL, -1, 1 },
951 { { .avp_vendor = 10415, .avp_name = "Number-Of-Messages-Successfully-Exploded" }, RULE_OPTIONAL, -1, 1 }, 955 { 10415, "Number-Of-Messages-Successfully-Exploded", RULE_OPTIONAL, -1, 1 },
952 }; 956 };
953 PARSE_loc_rules(rules, rule_avp); 957 PARSE_loc_rules(rules, rule_avp);
954 } 958 }
955 { 959 {
956 struct dict_object *rule_avp; 960 struct dict_object *rule_avp;
958 vpa.avp_vendor = 10415; 962 vpa.avp_vendor = 10415;
959 vpa.avp_name = "Service-Generic-Information"; 963 vpa.avp_name = "Service-Generic-Information";
960 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp); 964 CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
961 struct local_rules_definition rules[] = 965 struct local_rules_definition rules[] =
962 { 966 {
963 { { .avp_vendor = 10415, .avp_name = "Application-Server-Id" }, RULE_OPTIONAL, -1, 1 }, 967 { 10415, "Application-Server-Id", RULE_OPTIONAL, -1, 1 },
964 { { .avp_vendor = 10415, .avp_name = "Application-Service-Type" }, RULE_OPTIONAL, -1, 1 }, 968 { 10415, "Application-Service-Type", RULE_OPTIONAL, -1, 1 },
965 { { .avp_vendor = 10415, .avp_name = "Application-Session-Id" }, RULE_OPTIONAL, -1, 1 }, 969 { 10415, "Application-Session-Id", RULE_OPTIONAL, -1, 1 },
966 { { .avp_vendor = 10415, .avp_name = "Delivery-Status" }, RULE_OPTIONAL, -1, 1 }, 970 { 10415, "Delivery-Status", RULE_OPTIONAL, -1, 1 },
967 }; 971 };
968 PARSE_loc_rules(rules, rule_avp); 972 PARSE_loc_rules(rules, rule_avp);
969 } 973 }
970 974
971 LOG_D( "Extension 'Dictionary definitions for DCCA 3GPP' initialized"); 975 LOG_D( "Extension 'Dictionary definitions for DCCA 3GPP' initialized");
"Welcome to our mercurial repository"