Changeset 658:f198d16fa7f4 in freeDiameter for libfdproto/dictionary.c

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:

• libfdproto/dictionary.c (moved) (moved from libfreeDiameter/dictionary.c) (7 diffs)

libfdproto/dictionary.c

@@ -34 +34 @@
 *********************************************************************************************************/
 
-#include "libfD.h"
+#include "fdproto-internal.h"
 
 /* Names of the base types */
@@ -323 +323 @@
                                                 obj->objeyec, OBJECT_EYECATCHER,
                                                 obj->typeyec, _OBINFO(obj).eyecatcher);
+                        } else {
+                                TRACE_DEBUG(FULL, "Invalid object : NULL pointer");
                         }
                         return 0;
@@ -552 +554 @@
 }
 
-/* Compare two rule object by the AVP name that they refer (checks already performed) */
+/* Compare two rule object by the AVP vendor & code that they refer (checks already performed) */
 static int order_rule_by_avpn ( struct dict_object *o1, struct dict_object *o2 )
 {
         TRACE_ENTRY("%p %p", o1, o2);
         
-        return strcmp( o1->data.rule.rule_avp->data.avp.avp_name, o2->data.rule.rule_avp->data.avp.avp_name );
+        return ORDER_scalar(o1->data.rule.rule_avp->data.avp.avp_vendor, o2->data.rule.rule_avp->data.avp.avp_vendor) 
+                ?: ORDER_scalar(o1->data.rule.rule_avp->data.avp.avp_code, o2->data.rule.rule_avp->data.avp.avp_code) ;
 }
 
@@ -1496 +1499 @@
         struct dict_object * new = NULL;
         struct dict_object * vendor = NULL;
+        struct dict_object * locref = NULL;
         
         TRACE_ENTRY("%p %d(%s) %p %p %p", dict, type, dict_obj_info[CHECK_TYPE(type) ? type : 0].name, data, parent, ref);
@@ -1525 +1529 @@
         if (type == DICT_AVP) {
                 CHECK_FCT_DO(  fd_dict_search( dict, DICT_VENDOR, VENDOR_BY_ID, &(((struct dict_avp_data *)data)->avp_vendor), (void*)&vendor, ENOENT ),
-                                CHECK_PARAMS( vendor = NULL )  );
+                        { TRACE_DEBUG(INFO, "Unable to find vendor '%d' referenced in the AVP data", ((struct dict_avp_data *)data)->avp_vendor); return EINVAL; }  );
                 
                 /* Also check if a parent is provided, that the type are the same */
@@ -1568 +1572 @@
                 case DICT_VENDOR:
                         /* A vendor object is linked in the g_dict_vendors.list[0], by their id */
-                        CHECK_FCT_DO(  ret = fd_list_insert_ordered ( &dict->dict_vendors.list[0], &new->list[0], (int (*)(void*, void *))order_vendor_by_id, (void **)ref ),
-                                        goto error_unlock  );
+                        ret = fd_list_insert_ordered ( &dict->dict_vendors.list[0], &new->list[0], (int (*)(void*, void *))order_vendor_by_id, (void **)&locref );
+                        if (ret)
+                                goto error_unlock;
                         break;
                 
                 case DICT_APPLICATION:
                         /* An application object is linked in the g_dict_applciations.list[0], by their id */
-                        CHECK_FCT_DO(  ret = fd_list_insert_ordered ( &dict->dict_applications.list[0], &new->list[0], (int (*)(void*, void *))order_appli_by_id, (void **)ref ),
-                                        goto error_unlock  );
+                        ret = fd_list_insert_ordered ( &dict->dict_applications.list[0], &new->list[0], (int (*)(void*, void *))order_appli_by_id, (void **)&locref );
+                        if (ret)
+                                goto error_unlock;
                         break;
                 
                 case DICT_TYPE:
                         /* A type object is linked in g_list_types by its name */
-                        CHECK_FCT_DO(  ret = fd_list_insert_ordered ( &dict->dict_types, &new->list[0], (int (*)(void*, void *))order_type_by_name, (void **)ref ),
-                                        goto error_unlock  );
+                        ret = fd_list_insert_ordered ( &dict->dict_types, &new->list[0], (int (*)(void*, void *))order_type_by_name, (void **)&locref );
+                        if (ret)
+                                goto error_unlock;
                         break;
                 
                 case DICT_ENUMVAL:
                         /* A type_enum object is linked in it's parent 'type' object lists 1 and 2 by its name and values */
-                        CHECK_FCT_DO(  ret = fd_list_insert_ordered ( &parent->list[1], &new->list[0], (int (*)(void*, void *))order_enum_by_name, (void **)ref ),
-                                        goto error_unlock  );
-                        CHECK_FCT_DO(  ret = fd_list_insert_ordered ( &parent->list[2], &new->list[1], (int (*)(void*, void *))order_enum_by_val, (void **)ref ),
-                                        { fd_list_unlink(&new->list[0]); goto error_unlock; }  );
+                        ret = fd_list_insert_ordered ( &parent->list[1], &new->list[0], (int (*)(void*, void *))order_enum_by_name, (void **)&locref );
+                        if (ret)
+                                goto error_unlock;
+                        
+                        ret = fd_list_insert_ordered ( &parent->list[2], &new->list[1], (int (*)(void*, void *))order_enum_by_val, (void **)&locref );
+                        if (ret) { 
+                                fd_list_unlink(&new->list[0]); 
+                                goto error_unlock; 
+                        }
                         break;
                 
                 case DICT_AVP:
                         /* An avp object is linked in lists 1 and 2 of its vendor, by code and name */
-                        CHECK_FCT_DO(  ret = fd_list_insert_ordered ( &vendor->list[1], &new->list[0], (int (*)(void*, void *))order_avp_by_code, (void **)ref ),
-                                        goto error_unlock  );
-                        CHECK_FCT_DO(  ret = fd_list_insert_ordered ( &vendor->list[2], &new->list[1], (int (*)(void*, void *))order_avp_by_name, (void **)ref ),
-                                        { fd_list_unlink(&new->list[0]); goto error_unlock; }  );
+                        ret = fd_list_insert_ordered ( &vendor->list[1], &new->list[0], (int (*)(void*, void *))order_avp_by_code, (void **)&locref );
+                        if (ret)
+                                goto error_unlock;
+                        
+                        ret = fd_list_insert_ordered ( &vendor->list[2], &new->list[1], (int (*)(void*, void *))order_avp_by_name, (void **)&locref );
+                        if (ret) {
+                                fd_list_unlink(&new->list[0]);
+                                goto error_unlock;
+                        }
                         break;
                         
                 case DICT_COMMAND:
                         /* A command object is linked in g_list_cmd_name and g_list_cmd_code by its name and code */
-                        CHECK_FCT_DO(  ret = fd_list_insert_ordered ( &dict->dict_cmd_code, &new->list[1], (int (*)(void*, void *))order_cmd_by_codefl, (void **)ref ),
-                                        goto error_unlock  );
-                        CHECK_FCT_DO(  ret = fd_list_insert_ordered ( &dict->dict_cmd_name, &new->list[0], (int (*)(void*, void *))order_cmd_by_name, (void **)ref ),
-                                        { fd_list_unlink(&new->list[1]); goto error_unlock; }  );
+                        ret = fd_list_insert_ordered ( &dict->dict_cmd_code, &new->list[1], (int (*)(void*, void *))order_cmd_by_codefl, (void **)&locref );
+                        if (ret)
+                                goto error_unlock;
+                        
+                        ret = fd_list_insert_ordered ( &dict->dict_cmd_name, &new->list[0], (int (*)(void*, void *))order_cmd_by_name, (void **)&locref );
+                        if (ret) {
+                                fd_list_unlink(&new->list[1]);
+                                goto error_unlock;
+                        }
                         break;
                 
                 case DICT_RULE:
                         /* A rule object is linked in list[2] of its parent command or AVP by the name of the AVP it refers */
-                        CHECK_FCT_DO(  ret = fd_list_insert_ordered ( &parent->list[2], &new->list[0], (int (*)(void*, void *))order_rule_by_avpn, (void **)ref ),
-                                        goto error_unlock  );
+                        ret = fd_list_insert_ordered ( &parent->list[2], &new->list[0], (int (*)(void*, void *))order_rule_by_avpn, (void **)&locref );
+                        if (ret)
+                                goto error_unlock;
                         break;
                         
@@ -1632 +1655 @@
 error_unlock:
         CHECK_POSIX_DO(  pthread_rwlock_unlock(&dict->dict_lock),  /* continue */  );
+        if (ret == EEXIST) {
+                /* We have a duplicate key in locref. Check if the pointed object is the same or not */
+                switch (type) {
+                        case DICT_VENDOR:
+                                /* if we are here, it meas the two vendor id are identical */
+                                if (strcmp(locref->data.vendor.vendor_name, new->data.vendor.vendor_name)) {
+                                        TRACE_DEBUG(FULL, "Conflicting vendor name");
+                                        break;
+                                }
+                                /* Otherwise (same name), we consider the function succeeded, since the (same) object is in the dictionary */
+                                ret = 0; 
+                                break;
+
+                        case DICT_APPLICATION:
+                                /* got same id */
+                                if (strcmp(locref->data.application.application_name, new->data.application.application_name)) {
+                                        TRACE_DEBUG(FULL, "Conflicting application name");
+                                        break;
+                                }
+                                ret = 0;
+                                break;
+
+                        case DICT_TYPE:
+                                /* got same name */
+                                if (locref->data.type.type_base != new->data.type.type_base) {
+                                        TRACE_DEBUG(FULL, "Conflicting base type");
+                                        break;
+                                }
+                                /* discard new definition only it a callback is provided and different from the previous one */
+                                if ((new->data.type.type_interpret) && (locref->data.type.type_interpret != new->data.type.type_interpret)) {
+                                        TRACE_DEBUG(FULL, "Conflicting interpret cb");
+                                        break;
+                                }
+                                if ((new->data.type.type_encode) && (locref->data.type.type_encode != new->data.type.type_encode)) {
+                                        TRACE_DEBUG(FULL, "Conflicting encode cb");
+                                        break;
+                                }
+                                if ((new->data.type.type_dump) && (locref->data.type.type_dump != new->data.type.type_dump)) {
+                                        TRACE_DEBUG(FULL, "Conflicting dump cb");
+                                        break;
+                                }
+                                ret = 0;
+                                break;
+
+                        case DICT_ENUMVAL:
+                                /* got either same name or same value. We check that both are true */
+                                if (order_enum_by_name(locref, new)) {
+                                        TRACE_DEBUG(FULL, "Conflicting enum name");
+                                        break;
+                                }
+                                if (order_enum_by_val(locref, new)) {
+                                        TRACE_DEBUG(FULL, "Conflicting enum value");
+                                        break;
+                                }
+                                ret = 0;
+                                break;
+
+                        case DICT_AVP:
+                                /* got either same name or code */
+                                if (order_avp_by_code(locref, new)) {
+                                        TRACE_DEBUG(FULL, "Conflicting AVP code");
+                                        break;
+                                }
+                                if (order_avp_by_name(locref, new)) {
+                                        TRACE_DEBUG(FULL, "Conflicting AVP name");
+                                        break;
+                                }
+                                if  (locref->data.avp.avp_vendor != new->data.avp.avp_vendor) {
+                                        TRACE_DEBUG(FULL, "Conflicting AVP vendor");
+                                        break;
+                                }
+                                if  (locref->data.avp.avp_flag_mask != new->data.avp.avp_flag_mask) {
+                                        TRACE_DEBUG(FULL, "Conflicting AVP flags mask");
+                                        break;
+                                }
+                                if  ((locref->data.avp.avp_flag_val & locref->data.avp.avp_flag_mask) != (new->data.avp.avp_flag_val & new->data.avp.avp_flag_mask)) {
+                                        TRACE_DEBUG(FULL, "Conflicting AVP flags value");
+                                        break;
+                                }
+                                if  (locref->data.avp.avp_basetype != new->data.avp.avp_basetype) {
+                                        TRACE_DEBUG(FULL, "Conflicting AVP base type");
+                                        break;
+                                }
+                                ret = 0;
+                                break;
+
+                        case DICT_COMMAND:
+                                /* We got either same name, or same code + R flag */
+                                if (order_cmd_by_name(locref, new)) {
+                                        TRACE_DEBUG(FULL, "Conflicting command name");
+                                        break;
+                                }
+                                if (locref->data.cmd.cmd_code != new->data.cmd.cmd_code) {
+                                        TRACE_DEBUG(FULL, "Conflicting command code");
+                                        break;
+                                }
+                                if (locref->data.cmd.cmd_flag_mask != new->data.cmd.cmd_flag_mask) {
+                                        TRACE_DEBUG(FULL, "Conflicting command flags mask %hhx:%hhx", locref->data.cmd.cmd_flag_mask, new->data.cmd.cmd_flag_mask);
+                                        break;
+                                }
+                                if ((locref->data.cmd.cmd_flag_val & locref->data.cmd.cmd_flag_mask) != (new->data.cmd.cmd_flag_val & new->data.cmd.cmd_flag_mask)) {
+                                        TRACE_DEBUG(FULL, "Conflicting command flags value");
+                                        break;
+                                }
+                                ret = 0;
+                                break;
+
+                        case DICT_RULE:
+                                /* Both rules point to the same AVPs */
+                                if (locref->data.rule.rule_position != new->data.rule.rule_position) {
+                                        TRACE_DEBUG(FULL, "Conflicting rule position");
+                                        break;
+                                }
+                                if ( ((locref->data.rule.rule_position == RULE_FIXED_HEAD) ||
+                                        (locref->data.rule.rule_position == RULE_FIXED_TAIL))
+                                    && (locref->data.rule.rule_order != new->data.rule.rule_order)) {
+                                        TRACE_DEBUG(FULL, "Conflicting rule order");
+                                        break;
+                                }
+                                if (locref->data.rule.rule_min != new->data.rule.rule_min) {
+                                        int r1 = locref->data.rule.rule_min;
+                                        int r2 = new->data.rule.rule_min;
+                                        int p  = locref->data.rule.rule_position;
+                                        if (  ((r1 != -1) && (r2 != -1)) /* none of the definitions contains the "default" value */
+                                           || ((p == RULE_OPTIONAL) && (r1 != 0) && (r2 != 0)) /* the other value is not 0 for an optional rule */
+                                           || ((r1 != 1) && (r2 != 1)) /* the other value is not 1 for another rule */
+                                        ) {
+                                                TRACE_DEBUG(FULL, "Conflicting rule min");
+                                                break;
+                                        }
+                                }
+                                if (locref->data.rule.rule_max != new->data.rule.rule_max) {
+                                        TRACE_DEBUG(FULL, "Conflicting rule max");
+                                        break;
+                                }
+                                ret = 0;
+                                break;
+                }
+                if (ret) {
+                        TRACE_DEBUG(INFO, "An existing object with different non-key data was found: EEXIST");
+                } else {
+                        TRACE_DEBUG(FULL, "An existing object with the same data was found, ignoring the error...");
+                }
+                if (ref)
+                        *ref = locref;
+        } else {
+                CHECK_FCT_DO( ret, ); /* log the error */ 
+        }
+
 error_free:
         free(new);