Navigation


Ignore:
Timestamp:
Jan 14, 2011, 3:15:23 PM (13 years ago)
Author:
Sebastien Decugis <sdecugis@nict.go.jp>
Branch:
default
Phase:
public
Message:

Initial commit for 1.1.0:

  • Restructuring:
    • libfreeDiameter:
      • renamed folder & binary into libfdproto
      • renamed libfD.h into fdproto-internal.h
      • removed signals management (replaced by triggers in libfdcore)
  • freeDiameter split into:
    • libfdcore (most contents)
      • renamed fD.h into fdcore-internal.h
      • added core.c for framework init/shutdown.
      • new triggers mechanism in events.c.
  • freeDiameterd (main, command line parsing, signals management)
  • tests:
    • now in top-level directory tests.
  • other changes:
    • fd_dict_new now returns 0 on duplicate identical entries.
    • fixes in dict_legacy_xml
    • fixes in some dictionaries
    • moved FD_DEFAULT_CONF_FILENAME definition to freeDiameter-host.h
File:
1 edited

Legend:

Unmodified
Added
Removed

  • extensions/dict_legacy_xml/dict_lxml_xml.c

    r616 r658  
    933933                                        { TRACE_DEBUG(INFO, "Invalid 'type' tag found without 'name' attribute."); goto xml_tree_error; } );
    934934                               
     935                                /* Check there is only 1 type */
     936                                if (!FD_IS_LIST_EMPTY(&data->cur_avp->type)) {
     937                                        TRACE_DEBUG(INFO, "Multiple 'type' tags found for AVP.");
     938                                        goto xml_tree_error;
     939                                }
     940                               
     941                                /* Add the new type */
    935942                                CHECK_FCT_DO( new_avptype(&data->cur_avp->type, xname),
    936943                                        { TRACE_DEBUG(INFO, "An error occurred while parsing a type tag. Entry ignored."); goto xml_tree_error; } )
    … …  
    10111018        }
    10121019        data->error_depth += 1;
     1020        if (data->cur_app || data->cur_cmd || data->cur_avp) {
     1021                TRACE_DEBUG(INFO, "Error encountered while parsing tag of:");
     1022                if (data->cur_app)
     1023                        fd_log_debug("  Application: '%s'\n", data->cur_app->name);
     1024                if (data->cur_cmd)
     1025                        fd_log_debug("  Command    : '%s'\n", data->cur_cmd->name);
     1026                if (data->cur_avp)
     1027                        fd_log_debug("  AVP        : '%s'\n", data->cur_avp->name);
     1028        }
    10131029        return;
    10141030}
    … …  
    13871403               
    13881404                /* Now create the new rule */
    1389                 CHECK_FCT( fd_dict_new ( fD_dict, DICT_RULE, &rd, parent, NULL ) );
     1405                CHECK_FCT_DO( ret = fd_dict_new ( fD_dict, DICT_RULE, &rd, parent, NULL ),
     1406                        { TRACE_DEBUG(INFO, "Error creating rule for sub-AVP '%s'", r->avpname); return ret; } );
    13901407                if (nb_added)
    13911408                        *nb_added += 1;
    … …  
    13981415static int rules_to_fD(struct dictionary * fD_dict, struct dict_object * parent, struct fd_list * fixed, struct fd_list * required, struct fd_list * optional, int * nb_added)
    13991416{
     1417        int ret;
     1418       
    14001419        TRACE_ENTRY("%p %p %p %p %p %p", fD_dict, parent, fixed, required, optional, nb_added);
    14011420       
    14021421        /* Process the rules */
    1403         CHECK_FCT( rules_to_fD_onelist(fD_dict, parent, RULE_FIXED_HEAD, fixed, nb_added) );
    1404         CHECK_FCT( rules_to_fD_onelist(fD_dict, parent, RULE_REQUIRED, required, nb_added) );
    1405         CHECK_FCT( rules_to_fD_onelist(fD_dict, parent, RULE_OPTIONAL, optional, nb_added) );
     1422        CHECK_FCT_DO( ret = rules_to_fD_onelist(fD_dict, parent, RULE_FIXED_HEAD, fixed, nb_added),
     1423                { TRACE_DEBUG(INFO, "Error processing FIXED rules"); return ret; } );
     1424        CHECK_FCT_DO( ret = rules_to_fD_onelist(fD_dict, parent, RULE_REQUIRED, required, nb_added),
     1425                { TRACE_DEBUG(INFO, "Error processing REQUIRED rules"); return ret; } );
     1426        CHECK_FCT_DO( ret = rules_to_fD_onelist(fD_dict, parent, RULE_OPTIONAL, optional, nb_added),
     1427                { TRACE_DEBUG(INFO, "Error processing OPTIONAL rules"); return ret; } );
    14061428       
    14071429        return 0;
    … …  
    14251447        ad.avp_vendor = a->vendor;
    14261448        ad.avp_name   = (char *)a->name;
    1427         ad.avp_flag_mask = a->fmask;
     1449        ad.avp_flag_mask = a->fmask | AVP_FLAG_VENDOR;
    14281450        ad.avp_flag_val  = a->flags;
    14291451       
    14301452        if (!FD_IS_LIST_EMPTY(&a->type)) {
    14311453                /* special exception: we use per-AVP enumerated types in fD */
    1432                 if (strcasecmp("Enumerated", (char *)((struct t_avptype *)a->type.next)->type_name))
     1454                if (!strcasecmp("Enumerated", (char *)((struct t_avptype *)a->type.next)->type_name))
     1455                        goto enumerated;
     1456                /* Let's allow "Unsigned32" instead of "Enumerated" also... */
     1457                if ((!FD_IS_LIST_EMPTY(&a->enums)) && (!strcasecmp("Unsigned32", (char *)((struct t_avptype *)a->type.next)->type_name)))
    14331458                        goto enumerated;
    14341459               
    … …  
    14411466                        || !FD_IS_LIST_EMPTY(&a->grouped_fixed) ) {
    14421467                        /* The AVP has rules, it is a grouped AVP */
    1443                         CHECK_PARAMS( FD_IS_LIST_EMPTY(&a->enums) );
     1468                        CHECK_PARAMS_DO( FD_IS_LIST_EMPTY(&a->enums),
     1469                                { TRACE_DEBUG(INFO, "Conflict: The AVP '%s' has both enum values and rules.", ad.avp_name); return EINVAL; } );
    14441470                        ad.avp_basetype = AVP_TYPE_GROUPED;
    14451471                } else {
    14461472                        /* It should be an enumerated AVP... */
    14471473                        if (FD_IS_LIST_EMPTY(&a->enums)) {
    1448                                 TRACE_DEBUG(INFO, "[dict_legacy_xml] Error: Missing type information for AVP '%s'", ad.avp_name);
     1474                                TRACE_DEBUG(INFO, "Error: Missing type information for AVP '%s'", ad.avp_name);
    14491475                                return EINVAL;
    14501476                        } else {
    … …  
    14921518        /* Now, the inner elements, if any */
    14931519       
     1520        if ( (!FD_IS_LIST_EMPTY(&a->enums)) && (ad.avp_basetype != AVP_TYPE_UNSIGNED32)) {
     1521                TRACE_DEBUG(INFO, "AVP '%s' type is not an Unsigned32 but it has enum values (invalid in this extension).", ad.avp_name);
     1522                return EINVAL;
     1523        }
     1524
    14941525        /* In case of enumeration, define the enum values */
    1495         ASSERT( FD_IS_LIST_EMPTY(&a->enums) || (type && (ad.avp_basetype == AVP_TYPE_UNSIGNED32)) ); /* u32 type must be defined for enumerators */
    14961526        for (li = a->enums.next; li != &a->enums; li = li->next) {
    14971527                struct t_enum * e = (struct t_enum *)li;
    … …  
    15021532                ed.enum_value.u32 = e->code;
    15031533               
    1504                 CHECK_FCT( fd_dict_new ( fD_dict, DICT_ENUMVAL, &ed, type, NULL ) );
     1534                CHECK_FCT_DO( ret = fd_dict_new ( fD_dict, DICT_ENUMVAL, &ed, type, NULL ),
     1535                        {
     1536                                TRACE_DEBUG(INFO, "Error defining constant value '%s' for AVP '%s': %s", ed.enum_name, ad.avp_name, strerror(ret));
     1537                                return ret;
     1538                        } );
    15051539                if (nb_added)
    15061540                        *nb_added += 1;
    … …  
    15111545          || !FD_IS_LIST_EMPTY(&a->grouped_required)
    15121546          || !FD_IS_LIST_EMPTY(&a->grouped_fixed) ) {
    1513                 CHECK_PARAMS( ad.avp_basetype == AVP_TYPE_GROUPED );
    1514                 CHECK_FCT( rules_to_fD(fD_dict, prev, &a->grouped_fixed, &a->grouped_required, &a->grouped_optional, nb_added) );
     1547                CHECK_PARAMS_DO( ad.avp_basetype == AVP_TYPE_GROUPED,
     1548                        { TRACE_DEBUG(INFO, "Got rules for non-grouped AVP '%s'", ad.avp_name); return EINVAL;} );
     1549                CHECK_FCT_DO( ret = rules_to_fD(fD_dict, prev, &a->grouped_fixed, &a->grouped_required, &a->grouped_optional, nb_added),
     1550                        { TRACE_DEBUG(INFO, "Error processing rules for AVP '%s': %s", ad.avp_name, strerror(ret)); return ret; } );
    15151551        }
    15161552       
    … …  
    15361572        snprintf(cmdname, sizeof(cmdname), "%s-Request", (char *)c->name);
    15371573        cd.cmd_name = &cmdname[0];
    1538         cd.cmd_flag_mask = c->fmask | CMD_FLAG_REQUEST;
     1574        cd.cmd_flag_mask = c->fmask | CMD_FLAG_REQUEST | CMD_FLAG_ERROR;
    15391575        cd.cmd_flag_val  = c->flags | CMD_FLAG_REQUEST;
    15401576       
    … …  
    15641600        snprintf(cmdname, sizeof(cmdname), "%s-Answer", (char *)c->name);
    15651601        cd.cmd_flag_val &= ~CMD_FLAG_REQUEST;
     1602        cd.cmd_flag_mask &= ~CMD_FLAG_ERROR;
    15661603       
    15671604        ret = fd_dict_new ( fD_dict, DICT_COMMAND, &cd, fd_appl, &ans );
    … …  
    15851622rules:
    15861623        /* Now process the rules inside the command */
    1587         CHECK_FCT( rules_to_fD(fD_dict, req, &c->reqrules_fixed, &c->reqrules_required, &c->reqrules_optional, nb_added) );
    1588         CHECK_FCT( rules_to_fD(fD_dict, ans, &c->ansrules_fixed, &c->ansrules_required, &c->ansrules_optional, nb_added) );
     1624        CHECK_FCT_DO( ret = rules_to_fD(fD_dict, req, &c->reqrules_fixed, &c->reqrules_required, &c->reqrules_optional, nb_added),
     1625                        {
     1626                                TRACE_DEBUG(INFO, "Error converting data from request rules: %s", strerror(ret));
     1627                                return ret;
     1628                        }   );
     1629        CHECK_FCT_DO( ret = rules_to_fD(fD_dict, ans, &c->ansrules_fixed, &c->ansrules_required, &c->ansrules_optional, nb_added),
     1630                        {
     1631                                TRACE_DEBUG(INFO, "Error converting data from answer rules: %s", strerror(ret));
     1632                                return ret;
     1633                        }   );
    15891634       
    15901635        /* Done */
    … …  
    16411686        /* First, define all the types */
    16421687        for (li = a->types.next; li != &a->types; li = li->next) {
    1643                 CHECK_FCT( typdefn_to_fD((struct t_typedefn *)li, fD_dict, prev, NULL, nb_added) );
     1688                CHECK_FCT_DO( ret = typdefn_to_fD((struct t_typedefn *)li, fD_dict, prev, NULL, nb_added),
     1689                        {
     1690                                TRACE_DEBUG(INFO, "Error converting data from typedefn '%s': %s", ((struct t_typedefn *)li)->name, strerror(ret));
     1691                                return ret;
     1692                        }  );
    16441693        }
    16451694       
    16461695        /* Then, AVPs, enums, and grouped AVP rules */
    16471696        for (li = a->avps.next; li != &a->avps; li = li->next) {
    1648                 CHECK_FCT( avp_to_fD((struct t_avp *)li, fD_dict, prev, NULL, nb_added) );
     1697                CHECK_FCT_DO( ret = avp_to_fD((struct t_avp *)li, fD_dict, prev, NULL, nb_added),
     1698                        {
     1699                                TRACE_DEBUG(INFO, "Error converting data from AVP '%s': %s", ((struct t_avp *)li)->name, strerror(ret));
     1700                                return ret;
     1701                        }  );
    16491702        }
    16501703       
    16511704        /* Finally, the commands and rules */
    16521705        for (li = a->commands.next; li != &a->commands; li = li->next) {
    1653                 CHECK_FCT( cmd_to_fD((struct t_cmd *)li, fD_dict, prev, NULL, nb_added) );
     1706                CHECK_FCT_DO( ret = cmd_to_fD((struct t_cmd *)li, fD_dict, prev, NULL, nb_added),
     1707                        {
     1708                                TRACE_DEBUG(INFO, "Error converting data from command '%s': %s", ((struct t_cmd *)li)->name, strerror(ret));
     1709                                return ret;
     1710                        }  );
    16541711        }
    16551712       
    … …  
    16621719{
    16631720        struct fd_list * li;
     1721        int ret;
    16641722       
    16651723        TRACE_ENTRY("%p %p %p", fD_dict, xmldict, nb_added);
    … …  
    16711729        /* Create all the vendors */
    16721730        for (li = xmldict->vendors.next; li != &xmldict->vendors; li = li->next) {
    1673                 CHECK_FCT( vend_to_fD((struct t_vend *)li, fD_dict, NULL, nb_added) );
     1731                CHECK_FCT_DO( ret = vend_to_fD((struct t_vend *)li, fD_dict, NULL, nb_added),
     1732                        {
     1733                                TRACE_DEBUG(INFO, "Error converting data from vendor '%s': %s", ((struct t_vend *)li)->name, strerror(ret));
     1734                                return ret;
     1735                        } );
    16741736        }
    16751737       
    16761738        /* Now, process each application */
    1677         CHECK_FCT( appl_to_fD(&xmldict->base_and_applications, fD_dict, NULL, nb_added) );
     1739        CHECK_FCT_DO( ret = appl_to_fD(&xmldict->base_and_applications, fD_dict, NULL, nb_added),
     1740                        {
     1741                                TRACE_DEBUG(INFO, "Error converting data from Base application: %s", strerror(ret));
     1742                                return ret;
     1743                        } );
    16781744        for (li = xmldict->base_and_applications.chain.next; li != &xmldict->base_and_applications.chain; li = li->next) {
    1679                 CHECK_FCT( appl_to_fD((struct t_appl *) li, fD_dict, NULL, nb_added) );
     1745                CHECK_FCT_DO( ret = appl_to_fD((struct t_appl *) li, fD_dict, NULL, nb_added),
     1746                        {
     1747                                TRACE_DEBUG(INFO, "Error converting data from application '%s': %s", ((struct t_appl *)li)->name, strerror(ret));
     1748                                return ret;
     1749                        }  );
    16801750        }
    16811751       
    … …  
    17251795        }
    17261796       
    1727         TRACE_DEBUG(FULL, "XML file parsing complete.");
     1797        TRACE_DEBUG(FULL, "XML file parsing, 1st pass completed.");
    17281798        if (TRACE_BOOL(ANNOYING)) {
    17291799                dump_dict(&data.dict);
    … …  
    17311801       
    17321802        /* Now, convert all the objects from the temporary tree into the freeDiameter dictionary */
    1733         CHECK_FCT_DO( dict_to_fD(fd_g_config->cnf_dict, &data.dict, &ret), { del_dict_contents(&data.dict); return -1; } );
    1734        
    1735         TRACE_DEBUG(FULL, "Conversion to freeDiameter internal format complete.");
     1803        CHECK_FCT_DO( dict_to_fD(fd_g_config->cnf_dict, &data.dict, &ret),
     1804                {
     1805                        TRACE_DEBUG(INFO, "Error while converting data read from file '%s'", xmlfilename);
     1806                        del_dict_contents(&data.dict);
     1807                        return -1;
     1808                } );
     1809       
     1810        TRACE_DEBUG(FULL, "Conversion from '%s' to freeDiameter internal format complete.", xmlfilename);
    17361811        if (TRACE_BOOL(ANNOYING)) {
    17371812                fd_dict_dump(fd_g_config->cnf_dict);
Note: See TracChangeset for help on using the changeset viewer.