Navigation


Changeset 1086:f2f4b9ddd8e5 in freeDiameter


Ignore:
Timestamp:
May 4, 2013, 5:05:07 AM (11 years ago)
Author:
Thomas Klausner <tk@giga.or.at>
Branch:
default
Phase:
public
Message:

Add many more rules, license, and some comments.

Location:
extensions/dict_dcca_3gpp
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • extensions/dict_dcca_3gpp/dict_dcca_3gpp.c

    r1065 r1086  
     1/*********************************************************************************************************
     2 * Software License Agreement (BSD License)                                                               *
     3 * Author: Thomas Klausner <tk@giga.or.at>                                                                *
     4 *                                                                                                        *
     5 * Copyright (c) 2013, Thomas Klausner                                                                    *
     6 * All rights reserved.                                                                                   *
     7 *                                                                                                        *
     8 * Written under contract by nfotex IT GmbH, http://nfotex.com/                                           *
     9 *                                                                                                        *
     10 * Redistribution and use of this software in source and binary forms, with or without modification, are  *
     11 * permitted provided that the following conditions are met:                                              *
     12 *                                                                                                        *
     13 * * Redistributions of source code must retain the above                                                 *
     14 *   copyright notice, this list of conditions and the                                                    *
     15 *   following disclaimer.                                                                                *
     16 *                                                                                                        *
     17 * * Redistributions in binary form must reproduce the above                                              *
     18 *   copyright notice, this list of conditions and the                                                    *
     19 *   following disclaimer in the documentation and/or other                                               *
     20 *   materials provided with the distribution.                                                            *
     21 *                                                                                                        *
     22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED *
     23 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
     24 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR *
     25 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT     *
     26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS    *
     27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR *
     28 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF   *
     29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                                                             *
     30 *********************************************************************************************************/
     31
    132/*
    2  * Dictionary definitions of objects specified in DCCA (Nokia, 3GPP).
     33 * Dictionary definitions for objects specified for DCCA by 3GPP.
     34 *
     35 * This extensions contains a lot of AVPs from various 3GPP standards
     36 * documents, and some rules for the grouped AVPs described therein.
     37 *
     38 * This extension does not contain ALL AVPs described by 3GPP, but
     39 * quite a big number of them.
     40 *
     41 * When extending the AVPs, please edit dict_dcca_3gpp.org instead and
     42 * create pastable code with contrib/tools/org_to_fd.pl.
     43 *
     44 * Some points of consideration:
     45 * 1. This dictionary could be split up per document.
     46 *
     47 * + pro: you can only load the AVPs/Rules you're interested in ->
     48 * smaller memory size
     49 *
     50 * - con: the documents use AVPs from each other A LOT, so setting the
     51 * dependencies correctly will be annoying
     52 *
     53 * - con: you need to load all of them as extensions
     54 *
     55 * 2. This dictionary contains ONE AVP in the "3GPP2" vendor space,
     56 * since I found it wasteful to write a separate dictionary just for
     57 * one AVP. Also, it is defined in a 3GPP document.
     58 *
     59 * 3. While there are quite a number of rules here already, many more
     60 * are missing. I've only added rules for those grouped AVPs or
     61 * commands in which I was concretely interested so far; many more
     62 * will need to be added to make this complete.
     63 *
     64 * That being said, I hope this will be useful for you.
     65 *
    366 */
     67
     68
     69/*
     70 * Some comments on the 3GPP Standards documents themselves:
     71 *
     72 * 1. It would be good if 29.061 was reviewed to check for each AVP if
     73 * it is Mandatory or not. The data currently in the document does not
     74 * match what was in the previous version of the freeDiameter
     75 * extension (the one that existedbefore I rewrote it) or what I saw
     76 * so far. IIRC, even the table and the document contradict each
     77 * other. The AVP table is also missing an entry for
     78 * "External-Identifier", 28.
     79 *
     80 * 2. 29.140 has conflicting AVP names with other documents:
     81 *   - Sequence-Number is also in 32.329
     82 *   - Recipient-Address is also in 32.299
     83 *   - Status is also in 32.299
     84 *
     85 * 3. 29.229 has name conflict with 29.329 about User-Data (different
     86 * AVP code 702, instead of 606) -- the weird thing is, the latter
     87 * uses some AVPs from the former, but not this one.
     88*/
    489#include <freeDiameter/extension.h>
    590
     
    66151                        struct dict_vendor_data vendor_data = { 10415, "3GPP" };
    67152                        CHECK_FCT(fd_dict_new(fd_g_config->cnf_dict, DICT_VENDOR, &vendor_data, NULL, NULL));
    68                 }                               
     153                }
    69154                {
    70155                        struct dict_vendor_data vendor_data = { 5535, "3GPP2" };
    71156                        CHECK_FCT(fd_dict_new(fd_g_config->cnf_dict, DICT_VENDOR, &vendor_data, NULL, NULL));
    72                 }                               
    73  
     157                }
     158
    74159        }
    75160       
     
    86171        CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "DiameterURI", &DiameterURI_type);
    87172        CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "IPFilterRule", &IPFilterRule_type);
    88         CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Time", &Time_type);                               
     173        CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "Time", &Time_type);
    89174        CHECK_dict_search( DICT_TYPE, TYPE_BY_NAME, "UTF8String", &UTF8String_type);
    90175       
     
    42684353        };
    42694354
    4270         /* Application-provided-called-party-address */
     4355        /* Application-Provided-Called-Party-Address */
    42714356        {
    42724357                struct dict_avp_data data = {
    42734358                        837,    /* Code */
    42744359                        10415,  /* Vendor */
    4275                         "Application-provided-called-party-address",    /* Name */
     4360                        "Application-Provided-Called-Party-Address",    /* Name */
    42764361                        AVP_FLAG_VENDOR |AVP_FLAG_MANDATORY,    /* Fixed flags */
    42774362                        AVP_FLAG_VENDOR |AVP_FLAG_MANDATORY,    /* Fixed flag values */
     
    1019510280
    1019610281
     10282
    1019710283        /*****************************************************/
    1019810284        /* end of generated data, rules below added manually */
     
    1021410300        };
    1021510301
    10216         /* 32.299 */
     10302        /* 29.212 */
     10303       
    1021710304        {
    1021810305                struct dict_object *rule_avp;
    1021910306                struct dict_avp_request vpa;
    1022010307                vpa.avp_vendor = 10415;
    10221                 vpa.avp_name = "Service-Information";
     10308                vpa.avp_name = "Allocation-Retention-Priority";
    1022210309                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
    10223                 struct local_rules_definition rules[] = 
     10310                struct local_rules_definition rules[] =
    1022410311                        {
    10225                                 { { .avp_vendor = 0,     .avp_name = "Subscription-Id" }, RULE_OPTIONAL, -1, -1 },
    10226                                 { { .avp_vendor = 10415, .avp_name = "AoC-Information" }, RULE_OPTIONAL, -1, 1 },
    10227                                 { { .avp_vendor = 10415, .avp_name = "PS-Information" }, RULE_OPTIONAL, -1, 1 },
    10228                                 { { .avp_vendor = 10415, .avp_name = "WLAN-Information" }, RULE_OPTIONAL, -1, 1 },
    10229                                 { { .avp_vendor = 10415, .avp_name = "IMS-Information" }, RULE_OPTIONAL, -1, 1 },
    10230                                 { { .avp_vendor = 10415, .avp_name = "MMS-Information" }, RULE_OPTIONAL, -1, 1 },
    10231                                 { { .avp_vendor = 10415, .avp_name = "LCS-Information" }, RULE_OPTIONAL, -1, 1 },
    10232                                 { { .avp_vendor = 10415, .avp_name = "PoC-Information" }, RULE_OPTIONAL, -1, 1 },
    10233                                 { { .avp_vendor = 10415, .avp_name = "MBMS-Information" }, RULE_OPTIONAL, -1, 1 },
    10234                                 { { .avp_vendor = 10415, .avp_name = "SMS-Information" }, RULE_OPTIONAL, -1, 1 },
    10235                                 { { .avp_vendor = 10415, .avp_name = "MMTel-Information" }, RULE_OPTIONAL, -1, 1 },
    10236                                 { { .avp_vendor = 10415, .avp_name = "Service-Generic-Information" }, RULE_OPTIONAL, -1, 1 },
    10237                                 { { .avp_vendor = 10415, .avp_name = "IM-Information" }, RULE_OPTIONAL, -1, 1 },
    10238                                 { { .avp_vendor = 10415, .avp_name = "DCD-Information" }, RULE_OPTIONAL, -1, 1 },
     10312                                { { .avp_vendor = 10415, .avp_name = "Priority-Level" }, RULE_REQUIRED, -1, 1 },
     10313                                { { .avp_vendor = 10415, .avp_name = "Pre-emption-Capability" }, RULE_OPTIONAL, -1, 1 },
     10314                                { { .avp_vendor = 10415, .avp_name = "Pre-emption-Vulnerability" }, RULE_OPTIONAL, -1, 1 },
    1023910315                        };
    1024010316                        PARSE_loc_rules(rules, rule_avp);
    1024110317        }
     10318
     10319        {
     10320                struct dict_object *rule_avp;
     10321                struct dict_avp_request vpa;
     10322                vpa.avp_vendor = 10415;
     10323                vpa.avp_name = "QoS-Information";
     10324                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10325                struct local_rules_definition rules[] =
     10326                        {
     10327                                { { .avp_vendor = 10415, .avp_name = "QoS-Class-Identifier" }, RULE_OPTIONAL, -1, 1 },
     10328                                { { .avp_vendor = 10415, .avp_name = "Max-Requested-Bandwidth-UL" }, RULE_OPTIONAL, -1, 1 },
     10329                                { { .avp_vendor = 10415, .avp_name = "Max-Requested-Bandwidth-DL" }, RULE_OPTIONAL, -1, 1 },
     10330                                { { .avp_vendor = 10415, .avp_name = "Guaranteed-Bitrate-UL" }, RULE_OPTIONAL, -1, 1 },
     10331                                { { .avp_vendor = 10415, .avp_name = "Guaranteed-Bitrate-DL" }, RULE_OPTIONAL, -1, 1 },
     10332                                { { .avp_vendor = 10415, .avp_name = "Bearer-Identifier" }, RULE_OPTIONAL, -1, 1 },
     10333                                { { .avp_vendor = 10415, .avp_name = "Allocation-Retention-Priority" }, RULE_OPTIONAL, -1, 1 },
     10334                                { { .avp_vendor = 10415, .avp_name = "APN-Aggregate-Max-Bitrate-UL" }, RULE_OPTIONAL, -1, 1 },
     10335                                { { .avp_vendor = 10415, .avp_name = "APN-Aggregate-Max-Bitrate-DL" }, RULE_OPTIONAL, -1, 1 },
     10336                        };
     10337                        PARSE_loc_rules(rules, rule_avp);
     10338        }
     10339
     10340        /* 32.299 */
     10341
     10342        {
     10343                struct dict_object *rule_avp;
     10344                struct dict_avp_request vpa;
     10345                vpa.avp_vendor = 10415;
     10346                vpa.avp_name = "Application-Server-Information";
     10347                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10348                struct local_rules_definition rules[] =
     10349                        {
     10350                                { { .avp_vendor = 10415, .avp_name = "Application-Server" }, RULE_REQUIRED, -1, 1 },
     10351                                { { .avp_vendor = 10415, .avp_name = "Application-Provided-Called-Party-Address" }, RULE_OPTIONAL, -1, -1 },
     10352                        };
     10353                        PARSE_loc_rules(rules, rule_avp);
     10354        }
     10355
     10356        {
     10357                struct dict_object *rule_avp;
     10358                struct dict_avp_request vpa;
     10359                vpa.avp_vendor = 10415;
     10360                vpa.avp_name = "Envelope";
     10361                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10362                struct local_rules_definition rules[] =
     10363                        {
     10364                                { { .avp_vendor = 10415, .avp_name = "Envelope-Start-Time" }, RULE_REQUIRED, -1, 1 },
     10365                                { { .avp_vendor = 10415, .avp_name = "Envelope-End-Time" }, RULE_OPTIONAL, -1, 1 },
     10366                                { { .avp_vendor = 0,     .avp_name = "CC-Total-Octets" }, RULE_REQUIRED, -1, 1 },
     10367                                { { .avp_vendor = 0,     .avp_name = "CC-Input-Octets" }, RULE_OPTIONAL, -1, 1 },
     10368                                { { .avp_vendor = 0,     .avp_name = "CC-Output-Octets" }, RULE_OPTIONAL, -1, 1 },
     10369                                { { .avp_vendor = 0,     .avp_name = "CC-Service-Specific-Units" }, RULE_OPTIONAL, -1, 1 },
     10370                        };
     10371                        PARSE_loc_rules(rules, rule_avp);
     10372        }
     10373
    1024210374        {
    1024310375                struct dict_object *rule_avp;
     
    1024610378                vpa.avp_name = "IMS-Information";
    1024710379                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
    10248                 struct local_rules_definition rules[] = 
     10380                struct local_rules_definition rules[] =
    1024910381                        {
    10250                                 { { .avp_vendor = 10415, .avp_name = "Event-Type" }, RULE_OPTIONAL, -1, -1 },
    10251                                 { { .avp_vendor = 10415, .avp_name = "Role-Of-Node" }, RULE_OPTIONAL, -1, -1 },
    10252                                 { { .avp_vendor = 10415, .avp_name = "Node-Functionality" }, RULE_REQUIRED, -1, -1 },
     10382                                { { .avp_vendor = 10415, .avp_name = "Event-Type" }, RULE_OPTIONAL, -1, 1 },
     10383                                { { .avp_vendor = 10415, .avp_name = "Role-Of-Node" }, RULE_OPTIONAL, -1, 1 },
     10384                                { { .avp_vendor = 10415, .avp_name = "Node-Functionality" }, RULE_REQUIRED, -1, 1 },
    1025310385                                { { .avp_vendor = 10415, .avp_name = "User-Session-Id" }, RULE_OPTIONAL, -1, 1 },
    1025410386                                { { .avp_vendor = 10415, .avp_name = "Outgoing-Session-Id" }, RULE_OPTIONAL, -1, 1 },
    1025510387                                { { .avp_vendor = 10415, .avp_name = "Session-Priority" }, RULE_OPTIONAL, -1, 1 },
    1025610388                                { { .avp_vendor = 10415, .avp_name = "Calling-Party-Address" }, RULE_OPTIONAL, -1, -1 },
    10257                                 { { .avp_vendor = 10415, .avp_name = "Called-Party-Address" }, RULE_OPTIONAL, -1, -1 },
     10389                                { { .avp_vendor = 10415, .avp_name = "Called-Party-Address" }, RULE_OPTIONAL, -1, 1 },
     10390                                { { .avp_vendor = 10415, .avp_name = "Called-Asserted-Identity" }, RULE_OPTIONAL, -1, -1 },
    1025810391                                { { .avp_vendor = 10415, .avp_name = "Number-Portability-Routing-Information" }, RULE_OPTIONAL, -1, 1 },
    1025910392                                { { .avp_vendor = 10415, .avp_name = "Carrier-Select-Routing-Information" }, RULE_OPTIONAL, -1, 1 },
     10393                                { { .avp_vendor = 10415, .avp_name = "Alternate-Charged-Party-Address" }, RULE_OPTIONAL, -1, 1 },
    1026010394                                { { .avp_vendor = 10415, .avp_name = "Requested-Party-Address" }, RULE_OPTIONAL, -1, -1 },
    1026110395                                { { .avp_vendor = 10415, .avp_name = "Associated-URI" }, RULE_OPTIONAL, -1, -1 },
     
    1029010424                        PARSE_loc_rules(rules, rule_avp);
    1029110425        }
     10426
    1029210427        {
    1029310428                struct dict_object *rule_avp;
    1029410429                struct dict_avp_request vpa;
    1029510430                vpa.avp_vendor = 10415;
    10296                 vpa.avp_name = "Time-Stamps";
     10431                vpa.avp_name = "MMS-Information";
    1029710432                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
    10298                 struct local_rules_definition rules[] = 
     10433                struct local_rules_definition rules[] =
    1029910434                        {
    10300                                 { { .avp_vendor = 10415, .avp_name = "SIP-Request-Timestamp" }, RULE_OPTIONAL, -1, 1 },
    10301                                 { { .avp_vendor = 10415, .avp_name = "SIP-Response-Timestamp" }, RULE_OPTIONAL, -1, 1 },
    10302                                 { { .avp_vendor = 10415, .avp_name = "SIP-Request-Timestamp-Fraction" }, RULE_OPTIONAL, -1, 1 },
    10303                                 { { .avp_vendor = 10415, .avp_name = "SIP-Response-Timestamp-Fraction" }, RULE_OPTIONAL, -1, 1 },
     10435                                { { .avp_vendor = 10415, .avp_name = "Originator-Address" }, RULE_OPTIONAL, -1, 1 },
     10436                                { { .avp_vendor = 10415, .avp_name = "Recipient-Address" }, RULE_OPTIONAL, -1, -1 },
     10437                                { { .avp_vendor = 10415, .avp_name = "Submission-Time" }, RULE_OPTIONAL, -1, 1 },
     10438                                { { .avp_vendor = 10415, .avp_name = "MM-Content-Type" }, RULE_OPTIONAL, -1, 1 },
     10439                                { { .avp_vendor = 10415, .avp_name = "Priority" }, RULE_OPTIONAL, -1, -1 },
     10440                                { { .avp_vendor = 10415, .avp_name = "Message-ID" }, RULE_OPTIONAL, -1, 1 },
     10441                                { { .avp_vendor = 10415, .avp_name = "Message-Type" }, RULE_OPTIONAL, -1, 1 },
     10442                                { { .avp_vendor = 10415, .avp_name = "Message-Size" }, RULE_OPTIONAL, -1, 1 },
     10443                                { { .avp_vendor = 10415, .avp_name = "Message-Class" }, RULE_OPTIONAL, -1, 1 },
     10444                                { { .avp_vendor = 10415, .avp_name = "Delivery-Report-Requested" }, RULE_OPTIONAL, -1, 1 },
     10445                                { { .avp_vendor = 10415, .avp_name = "Read-Reply-Report-Requested" }, RULE_OPTIONAL, -1, 1 },
     10446                                { { .avp_vendor = 10415, .avp_name = "MMBox-Storage-Requested" }, RULE_OPTIONAL, -1, 1 },
     10447                                { { .avp_vendor = 10415, .avp_name = "Applic-ID" }, RULE_OPTIONAL, -1, 1 },
     10448                                { { .avp_vendor = 10415, .avp_name = "Reply-Applic-ID" }, RULE_OPTIONAL, -1, 1 },
     10449                                { { .avp_vendor = 10415, .avp_name = "Aux-Applic-Info" }, RULE_OPTIONAL, -1, 1 },
     10450                                { { .avp_vendor = 10415, .avp_name = "Content-Class" }, RULE_OPTIONAL, -1, 1 },
     10451                                { { .avp_vendor = 10415, .avp_name = "DRM-Content" }, RULE_OPTIONAL, -1, 1 },
     10452                                { { .avp_vendor = 10415, .avp_name = "Adaptations" }, RULE_OPTIONAL, -1, 1 },
     10453                                { { .avp_vendor = 10415, .avp_name = "VASP-ID" }, RULE_OPTIONAL, -1, 1 },
     10454                                { { .avp_vendor = 10415, .avp_name = "VAS-ID" }, RULE_OPTIONAL, -1, 1 },
    1030410455                        };
    1030510456                        PARSE_loc_rules(rules, rule_avp);
    1030610457        }
     10458
     10459        {
     10460                /* Multiple-Services-Credit-Control */
     10461                /* additional allowed AVPs */
     10462                struct dict_object *rule_avp;
     10463                struct dict_avp_request vpa;
     10464                vpa.avp_vendor = 0;
     10465                vpa.avp_name = "Multiple-Services-Credit-Control";
     10466                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10467                struct local_rules_definition rules[] =
     10468                        {
     10469                                { { .avp_vendor = 10415, .avp_name = "Time-Quota-Threshold" }, RULE_OPTIONAL, -1, 1 },
     10470                                { { .avp_vendor = 10415, .avp_name = "Volume-Quota-Threshold" }, RULE_OPTIONAL, -1, 1 },
     10471                                { { .avp_vendor = 10415, .avp_name = "Unit-Quota-Threshold" }, RULE_OPTIONAL, -1, 1 },
     10472                                { { .avp_vendor = 10415, .avp_name = "Quota-Holding-Time" }, RULE_OPTIONAL, -1, 1 },
     10473                                { { .avp_vendor = 10415, .avp_name = "Quota-Consumption-Time" }, RULE_OPTIONAL, -1, 1 },
     10474                                { { .avp_vendor = 10415, .avp_name = "Reporting-Reason" }, RULE_OPTIONAL, -1, -1 },
     10475                                { { .avp_vendor = 10415, .avp_name = "Trigger" }, RULE_OPTIONAL, -1, 1 },
     10476                                { { .avp_vendor = 10415, .avp_name = "PS-Furnish-Charging-Information" }, RULE_OPTIONAL, -1, 1 },
     10477                                { { .avp_vendor = 10415, .avp_name = "Refund-Information" }, RULE_OPTIONAL, -1, 1 },
     10478                                { { .avp_vendor = 10415, .avp_name = "AF-Correlation-Information" }, RULE_OPTIONAL, -1, -1 },
     10479                                { { .avp_vendor = 10415, .avp_name = "Envelope" }, RULE_OPTIONAL, -1, -1 },
     10480                                { { .avp_vendor = 10415, .avp_name = "Envelope-Reporting" }, RULE_OPTIONAL, -1, 1 },
     10481                                { { .avp_vendor = 10415, .avp_name = "Time-Quota-Mechanism" }, RULE_OPTIONAL, -1, 1 },
     10482                                { { .avp_vendor = 10415, .avp_name = "Service-Specific-Info" }, RULE_OPTIONAL, -1, -1 },
     10483                                { { .avp_vendor = 10415, .avp_name = "QoS-Information" }, RULE_OPTIONAL, -1, 1 },
     10484                        };
     10485                PARSE_loc_rules(rules, rule_avp);
     10486        }
     10487
    1030710488        {
    1030810489                struct dict_object *rule_avp;
    1030910490                struct dict_avp_request vpa;
    1031010491                vpa.avp_vendor = 10415;
    10311                 vpa.avp_name = "SDP-Media-Component";
     10492                vpa.avp_name = "Offline-Charging";
    1031210493                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
    10313                 struct local_rules_definition rules[] = 
     10494                struct local_rules_definition rules[] =
    1031410495                        {
    10315                                 { { .avp_vendor = 10415, .avp_name = "SDP-Media-Name" }, RULE_OPTIONAL, -1, 1 },
    10316                                 { { .avp_vendor = 10415, .avp_name = "SDP-Media-Description" }, RULE_OPTIONAL, -1, -1 },
    10317                                 { { .avp_vendor = 10415, .avp_name = "Local-GW-Inserted-Indication" }, RULE_OPTIONAL, -1, 1 },
    10318                                 { { .avp_vendor = 10415, .avp_name = "IP-Realm-Default-Indication" }, RULE_OPTIONAL, -1, 1 },
    10319                                 { { .avp_vendor = 10415, .avp_name = "Transcoder-Inserted-Indication" }, RULE_OPTIONAL, -1, 1 },
    10320                                 { { .avp_vendor = 10415, .avp_name = "Media-Initiator-Flag" }, RULE_OPTIONAL, -1, 1 },
    10321                                 { { .avp_vendor = 10415, .avp_name = "Media-Initiator-Party" }, RULE_OPTIONAL, -1, 1 },
    10322                                 { { .avp_vendor = 10415, .avp_name = "3GPP-Charging-Id" }, RULE_OPTIONAL, -1, 1 },
    10323                                 { { .avp_vendor = 10415, .avp_name = "Access-Network-Charging-Identifier-Value" }, RULE_OPTIONAL, -1, 1 },
    10324                                 { { .avp_vendor = 10415, .avp_name = "SDP-Type" }, RULE_OPTIONAL, -1, 1 },
     10496                                { { .avp_vendor = 10415, .avp_name = "Quota-Consumption-Time" }, RULE_OPTIONAL, -1, 1 },
     10497                                { { .avp_vendor = 10415, .avp_name = "Time-Quota-Mechanism" }, RULE_OPTIONAL, -1, 1 },
     10498                                { { .avp_vendor = 10415, .avp_name = "Envelope-Reporting" }, RULE_OPTIONAL, -1, 1 },
     10499                                { { .avp_vendor = 0,     .avp_name = "Multiple-Services-Credit-Control" }, RULE_OPTIONAL, -1, -1 },
    1032510500                        };
    1032610501                        PARSE_loc_rules(rules, rule_avp);
    1032710502        }
     10503
     10504        {
     10505                struct dict_object *rule_avp;
     10506                struct dict_avp_request vpa;
     10507                vpa.avp_vendor = 10415;
     10508                vpa.avp_name = "Originator-Address";
     10509                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10510                struct local_rules_definition rules[] =
     10511                        {
     10512                                { { .avp_vendor = 10415, .avp_name = "Address-Type" }, RULE_OPTIONAL, -1, 1 },
     10513                                { { .avp_vendor = 10415, .avp_name = "Address-Data" }, RULE_OPTIONAL, -1, 1 },
     10514                                { { .avp_vendor = 10415, .avp_name = "Address-Domain" }, RULE_OPTIONAL, -1, 1 },
     10515                        };
     10516                        PARSE_loc_rules(rules, rule_avp);
     10517        }
     10518
     10519        {
     10520                struct dict_object *rule_avp;
     10521                struct dict_avp_request vpa;
     10522                vpa.avp_vendor = 10415;
     10523                vpa.avp_name = "PS-Furnish-Charging-Information";
     10524                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10525                struct local_rules_definition rules[] =
     10526                        {
     10527                                { { .avp_vendor = 10415, .avp_name = "3GPP-Charging-Id" }, RULE_REQUIRED, -1, 1 },
     10528                                { { .avp_vendor = 10415, .avp_name = "PS-Free-Format-Data" }, RULE_REQUIRED, -1, 1 },
     10529                                { { .avp_vendor = 10415, .avp_name = "PS-Append-Free-Format-Data" }, RULE_OPTIONAL, -1, 1 },
     10530                        };
     10531                        PARSE_loc_rules(rules, rule_avp);
     10532        }
     10533
    1032810534        {
    1032910535                struct dict_object *rule_avp;
     
    1033210538                vpa.avp_name = "PS-Information";
    1033310539                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
    10334                 struct local_rules_definition rules[] = 
     10540                struct local_rules_definition rules[] =
    1033510541                        {
    1033610542                                { { .avp_vendor = 10415, .avp_name = "3GPP-Charging-Id" }, RULE_OPTIONAL, -1, 1 },
     
    1038410590        }
    1038510591
     10592        {
     10593                struct dict_object *rule_avp;
     10594                struct dict_avp_request vpa;
     10595                vpa.avp_vendor = 10415;
     10596                vpa.avp_name = "Recipient-Address";
     10597                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10598                struct local_rules_definition rules[] =
     10599                        {
     10600                                { { .avp_vendor = 10415, .avp_name = "Address-Type" }, RULE_OPTIONAL, -1, 1 },
     10601                                { { .avp_vendor = 10415, .avp_name = "Address-Data" }, RULE_OPTIONAL, -1, 1 },
     10602                                { { .avp_vendor = 10415, .avp_name = "Address-Domain" }, RULE_OPTIONAL, -1, 1 },
     10603                                { { .avp_vendor = 10415, .avp_name = "Addressee-Type" }, RULE_OPTIONAL, -1, 1 },
     10604                        };
     10605                        PARSE_loc_rules(rules, rule_avp);
     10606        }
     10607
     10608        {
     10609                struct dict_object *rule_avp;
     10610                struct dict_avp_request vpa;
     10611                vpa.avp_vendor = 10415;
     10612                vpa.avp_name = "SDP-Media-Component";
     10613                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10614                struct local_rules_definition rules[] =
     10615                        {
     10616                                { { .avp_vendor = 10415, .avp_name = "SDP-Media-Name" }, RULE_OPTIONAL, -1, 1 },
     10617                                { { .avp_vendor = 10415, .avp_name = "SDP-Media-Description" }, RULE_OPTIONAL, -1, -1 },
     10618                                { { .avp_vendor = 10415, .avp_name = "Local-GW-Inserted-Indication" }, RULE_OPTIONAL, -1, 1 },
     10619                                { { .avp_vendor = 10415, .avp_name = "IP-Realm-Default-Indication" }, RULE_OPTIONAL, -1, 1 },
     10620                                { { .avp_vendor = 10415, .avp_name = "Transcoder-Inserted-Indication" }, RULE_OPTIONAL, -1, 1 },
     10621                                { { .avp_vendor = 10415, .avp_name = "Media-Initiator-Flag" }, RULE_OPTIONAL, -1, 1 },
     10622                                { { .avp_vendor = 10415, .avp_name = "Media-Initiator-Party" }, RULE_OPTIONAL, -1, 1 },
     10623                                { { .avp_vendor = 10415, .avp_name = "3GPP-Charging-Id" }, RULE_OPTIONAL, -1, 1 },
     10624                                { { .avp_vendor = 10415, .avp_name = "Access-Network-Charging-Identifier-Value" }, RULE_OPTIONAL, -1, 1 },
     10625                                { { .avp_vendor = 10415, .avp_name = "SDP-Type" }, RULE_OPTIONAL, -1, 1 },
     10626                        };
     10627                        PARSE_loc_rules(rules, rule_avp);
     10628        }
     10629
     10630        {
     10631                struct dict_object *rule_avp;
     10632                struct dict_avp_request vpa;
     10633                vpa.avp_vendor = 10415;
     10634                vpa.avp_name = "Service-Information";
     10635                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10636                struct local_rules_definition rules[] =
     10637                        {
     10638                                { { .avp_vendor = 0,     .avp_name = "Subscription-Id" }, RULE_OPTIONAL, -1, -1 },
     10639                                { { .avp_vendor = 10415, .avp_name = "AoC-Information" }, RULE_OPTIONAL, -1, 1 },
     10640                                { { .avp_vendor = 10415, .avp_name = "PS-Information" }, RULE_OPTIONAL, -1, 1 },
     10641                                { { .avp_vendor = 10415, .avp_name = "WLAN-Information" }, RULE_OPTIONAL, -1, 1 },
     10642                                { { .avp_vendor = 10415, .avp_name = "IMS-Information" }, RULE_OPTIONAL, -1, 1 },
     10643                                { { .avp_vendor = 10415, .avp_name = "MMS-Information" }, RULE_OPTIONAL, -1, 1 },
     10644                                { { .avp_vendor = 10415, .avp_name = "LCS-Information" }, RULE_OPTIONAL, -1, 1 },
     10645                                { { .avp_vendor = 10415, .avp_name = "PoC-Information" }, RULE_OPTIONAL, -1, 1 },
     10646                                { { .avp_vendor = 10415, .avp_name = "MBMS-Information" }, RULE_OPTIONAL, -1, 1 },
     10647                                { { .avp_vendor = 10415, .avp_name = "SMS-Information" }, RULE_OPTIONAL, -1, 1 },
     10648                                { { .avp_vendor = 10415, .avp_name = "MMTel-Information" }, RULE_OPTIONAL, -1, 1 },
     10649                                { { .avp_vendor = 10415, .avp_name = "Service-Generic-Information" }, RULE_OPTIONAL, -1, 1 },
     10650                                { { .avp_vendor = 10415, .avp_name = "IM-Information" }, RULE_OPTIONAL, -1, 1 },
     10651                                { { .avp_vendor = 10415, .avp_name = "DCD-Information" }, RULE_OPTIONAL, -1, 1 },
     10652                        };
     10653                        PARSE_loc_rules(rules, rule_avp);
     10654        }
     10655
     10656        {
     10657                struct dict_object *rule_avp;
     10658                struct dict_avp_request vpa;
     10659                vpa.avp_vendor = 10415;
     10660                vpa.avp_name = "SMS-Information";
     10661                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10662                struct local_rules_definition rules[] =
     10663                        {
     10664                                { { .avp_vendor = 10415, .avp_name = "SMS-Node" }, RULE_OPTIONAL, -1, 1 },
     10665                                { { .avp_vendor = 10415, .avp_name = "Client-Address" }, RULE_OPTIONAL, -1, 1 },
     10666                                { { .avp_vendor = 10415, .avp_name = "Originator-SCCP-Address" }, RULE_OPTIONAL, -1, 1 },
     10667                                { { .avp_vendor = 10415, .avp_name = "SMSC-Address" }, RULE_OPTIONAL, -1, 1 },
     10668                                { { .avp_vendor = 10415, .avp_name = "Data-Coding-Scheme" }, RULE_OPTIONAL, -1, 1 },
     10669                                { { .avp_vendor = 10415, .avp_name = "SM-Discharge-Time" }, RULE_OPTIONAL, -1, 1 },
     10670                                { { .avp_vendor = 10415, .avp_name = "SM-Message-Type" }, RULE_OPTIONAL, -1, 1 },
     10671                                { { .avp_vendor = 10415, .avp_name = "Originator-Interface" }, RULE_OPTIONAL, -1, 1 },
     10672                                { { .avp_vendor = 10415, .avp_name = "SM-Protocol-ID" }, RULE_OPTIONAL, -1, 1 },
     10673                                { { .avp_vendor = 10415, .avp_name = "Reply-Path-Requested" }, RULE_OPTIONAL, -1, 1 },
     10674                                { { .avp_vendor = 10415, .avp_name = "SM-Status" }, RULE_OPTIONAL, -1, 1 },
     10675                                { { .avp_vendor = 10415, .avp_name = "SM-User-Data-Header" }, RULE_OPTIONAL, -1, 1 },
     10676                                { { .avp_vendor = 10415, .avp_name = "Number-Of-Messages-Sent" }, RULE_OPTIONAL, -1, 1 },
     10677                                { { .avp_vendor = 10415, .avp_name = "Recipient-Info" }, RULE_OPTIONAL, -1, -1 },
     10678                                { { .avp_vendor = 10415, .avp_name = "Originator-Received-Address" }, RULE_OPTIONAL, -1, 1 },
     10679                                { { .avp_vendor = 10415, .avp_name = "SM-Service-Type" }, RULE_OPTIONAL, -1, 1 },
     10680                        };
     10681                        PARSE_loc_rules(rules, rule_avp);
     10682        }
     10683
     10684        {
     10685                struct dict_object *rule_avp;
     10686                struct dict_avp_request vpa;
     10687                vpa.avp_vendor = 10415;
     10688                vpa.avp_name = "Time-Quota-Mechanism";
     10689                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10690                struct local_rules_definition rules[] =
     10691                        {
     10692                                { { .avp_vendor = 10415, .avp_name = "Time-Quota-Type" }, RULE_REQUIRED, -1, 1 },
     10693                                { { .avp_vendor = 10415, .avp_name = "Base-Time-Interval" }, RULE_REQUIRED, -1, 1 },
     10694                        };
     10695                        PARSE_loc_rules(rules, rule_avp);
     10696        }
     10697
     10698        {
     10699                struct dict_object *rule_avp;
     10700                struct dict_avp_request vpa;
     10701                vpa.avp_vendor = 10415;
     10702                vpa.avp_name = "Time-Stamps";
     10703                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
     10704                struct local_rules_definition rules[] =
     10705                        {
     10706                                { { .avp_vendor = 10415, .avp_name = "SIP-Request-Timestamp" }, RULE_OPTIONAL, -1, 1 },
     10707                                { { .avp_vendor = 10415, .avp_name = "SIP-Response-Timestamp" }, RULE_OPTIONAL, -1, 1 },
     10708                                { { .avp_vendor = 10415, .avp_name = "SIP-Request-Timestamp-Fraction" }, RULE_OPTIONAL, -1, 1 },
     10709                                { { .avp_vendor = 10415, .avp_name = "SIP-Response-Timestamp-Fraction" }, RULE_OPTIONAL, -1, 1 },
     10710                        };
     10711                        PARSE_loc_rules(rules, rule_avp);
     10712        }
     10713
    1038610714        /* OMA */
    1038710715        {
     
    1039110719                vpa.avp_name = "DCD-Information";
    1039210720                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
    10393                 struct local_rules_definition rules[] = 
     10721                struct local_rules_definition rules[] =
    1039410722                        {
    1039510723                                { { .avp_vendor = 10415, .avp_name = "Content-ID" }, RULE_OPTIONAL, -1, 1 },
     
    1040410732                vpa.avp_name = "IM-Information";
    1040510733                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
    10406                 struct local_rules_definition rules[] = 
     10734                struct local_rules_definition rules[] =
    1040710735                        {
    1040810736                                { { .avp_vendor = 10415, .avp_name = "Total-Number-Of-Messages-Sent" }, RULE_OPTIONAL, -1, 1 },
     
    1041910747                vpa.avp_name = "Service-Generic-Information";
    1042010748                CHECK_dict_search(DICT_AVP, AVP_BY_NAME_AND_VENDOR, &vpa, &rule_avp);
    10421                 struct local_rules_definition rules[] = 
     10749                struct local_rules_definition rules[] =
    1042210750                        {
    1042310751                                { { .avp_vendor = 10415, .avp_name = "Application-Server-Id" }, RULE_OPTIONAL, -1, 1 },
  • extensions/dict_dcca_3gpp/dict_dcca_3gpp.org

    r1065 r1086  
    341341| Application-Server                                            |  836 |                 | UTF8String       | M,V  | P   |          |          | N    |
    342342| Application-Server-Information                                |  850 |                 | Grouped          | M,V  | P   |          |          | N    |
    343 | Application-provided-called-party-address                     |  837 |                 | UTF8String       | M,V  | P   |          |          | N    |
     343| Application-Provided-Called-Party-Address                     |  837 |                 | UTF8String       | M,V  | P   |          |          | N    |
    344344| Associated-Party-Address                                      | 2035 |                 | UTF8String       | M,V  | P   |          |          | N    |
    345345| Associated-URI                                                |  856 |                 | UTF8String       | M,V  | P   |          |          | N    |
Note: See TracChangeset for help on using the changeset viewer.