Changeset 1451:6c3485887511 in freeDiameter for libfdproto

Timestamp:

Feb 27, 2020, 11:40:25 PM (4 years ago)

Author:

Thomas Klausner <tk@giga.or.at>

Branch:

default

Phase:

public

Message:

Move some structures to a header file for use by dbg_dict_dump_json.

Remove trailing whitespace.

Location:

libfdproto

Files:

• dictionary-internal.h (added)
• dictionary.c (modified) (126 diffs)

libfdproto/dictionary.c

@@ -35 +35 @@
 
 #include "fdproto-internal.h"
+#include "dictionary-internal.h"
 #include <inttypes.h>
 
@@ -49 +50 @@
         };
 
-/* The number of lists in an object */
-#define NB_LISTS_PER_OBJ        3
-
 /* Some eye catchers definitions */
 #define OBJECT_EYECATCHER       (0x0b13c7)
 #define DICT_EYECATCHER         (0x00d1c7)
-
-/* Definition of the dictionary objects */
-struct dict_object {
-        enum dict_object_type   type;   /* What type of object is this? */
-        int                     objeyec;/* eyecatcher for this object */
-        int                     typeyec;/* eyecatcher for this type of object */
-        struct dictionary       *dico;  /* The dictionary this object belongs to */
-        
-        union {
-                struct dict_vendor_data         vendor;         /* datastr_len = strlen(vendor_name) */
-                struct dict_application_data    application;    /* datastr_len = strlen(application_name) */
-                struct dict_type_data           type;           /* datastr_len = strlen(type_name) */
-                struct dict_enumval_data        enumval;        /* datastr_len = strlen(enum_name) */
-                struct dict_avp_data            avp;            /* datastr_len = strlen(avp_name) */
-                struct dict_cmd_data            cmd;            /* datastr_len = strlen(cmd_name) */
-                struct dict_rule_data           rule;           /* datastr_len = 0 */
-        } data;                         /* The data of this object */
-        
-        size_t                  datastr_len; /* cached length of the string inside the data. Saved when the object is created. */
-        
-        struct dict_object *    parent; /* The parent of this object, if any */
-        
-        struct fd_list          list[NB_LISTS_PER_OBJ];/* used to chain objects.*/
-        /* More information about the lists :
-        
-         - the use for each list depends on the type of object. See detail below.
-         
-         - a sentinel for a list has its 'o' field cleared. (this is the criteria to detect end of a loop)
-         
-         - The lists are always ordered. The criteria are described below. the functions to order them are referenced in dict_obj_info
-         
-         - The dict_lock must be held for any list operation.
-         
-         => VENDORS:
-         list[0]: list of the vendors, ordered by their id. The sentinel is g_dict_vendors (vendor with id 0)
-         list[1]: sentinel for the list of AVPs from this vendor, ordered by AVP code.
-         list[2]: sentinel for the list of AVPs from this vendor, ordered by AVP name (fd_os_cmp).
-         
-         => APPLICATIONS:
-         list[0]: list of the applications, ordered by their id. The sentinel is g_dict_applications (application with id 0)
-         list[1]: not used
-         list[2]: not used.
-         
-         => TYPES:
-         list[0]: list of the types, ordered by their names. The sentinel is g_list_types.
-         list[1]: sentinel for the type_enum list of this type, ordered by their constant name (fd_os_cmp).
-         list[2]: sentinel for the type_enum list of this type, ordered by their constant value.
-         
-         => TYPE_ENUMS:
-         list[0]: list of the contants for a given type, ordered by the constant name (fd_os_cmp). Sentinel is a (list[1]) element of a TYPE object.
-         list[1]: list of the contants for a given type, ordered by the constant value. Sentinel is a (list[2]) element of a TYPE object.
-         list[2]: not used
-         
-         => AVPS:
-         list[0]: list of the AVP from a given vendor, ordered by avp code. Sentinel is a list[1] element of a VENDOR object.
-         list[1]: list of the AVP from a given vendor, ordered by avp name (fd_os_cmp). Sentinel is a list[2] element of a VENDOR object.
-         list[2]: sentinel for the rule list that apply to this AVP.
-         
-         => COMMANDS:
-         list[0]: list of the commands, ordered by their names (fd_os_cmp). The sentinel is g_list_cmd_name.
-         list[1]: list of the commands, ordered by their command code and 'R' flag. The sentinel is g_list_cmd_code.
-         list[2]: sentinel for the rule list that apply to this command.
-         
-         => RULES:
-         list[0]: list of the rules for a given (grouped) AVP or Command, ordered by the AVP vendor & code to which they refer. sentinel is list[2] of a command or (grouped) avp.
-         list[1]: not used
-         list[2]: not used.
-         
-         */
-         
-         /* Sentinel for the dispatch callbacks */
-         struct fd_list         disp_cbs;
-        
-};
-
-/* Definition of the dictionary structure */
-struct dictionary {
-        int                     dict_eyec;              /* Eye-catcher for the dictionary (DICT_EYECATCHER) */
-        
-        pthread_rwlock_t        dict_lock;              /* The global rwlock for the dictionary */
-        
-        struct dict_object      dict_vendors;           /* Sentinel for the list of vendors, corresponding to vendor 0 */
-        struct dict_object      dict_applications;      /* Sentinel for the list of applications, corresponding to app 0 */
-        struct fd_list          dict_types;             /* Sentinel for the list of types */
-        struct fd_list          dict_cmd_name;          /* Sentinel for the list of commands, ordered by names */
-        struct fd_list          dict_cmd_code;          /* Sentinel for the list of commands, ordered by codes */
-        
-        struct dict_object      dict_cmd_error;         /* Special command object for answers with the 'E' bit set */
-        
-        int                     dict_count[DICT_TYPE_MAX + 1]; /* Number of objects of each type */
-};
 
 /* Forward declarations of dump functions */
@@ -178 +85 @@
 } dict_obj_info[] = { { 0, "(error)", 0, 0, 0, 0, NULL, NULL, {0, 0, 0} }
 
-        /* type                  name           datasize                          parent        parenttype 
+        /* type                  name           datasize                          parent        parenttype
                         eyecatcher              dump_data               search_fct,             haslist[]       */
 
         ,{ DICT_VENDOR,         "VENDOR",       sizeof(struct dict_vendor_data),        0,      0,
                         OBJECT_EYECATCHER + 1,  dump_vendor_data,       search_vendor,          { 1, 0, 0 } }
-        
+
         ,{ DICT_APPLICATION,    "APPLICATION",  sizeof(struct dict_application_data),   1,      DICT_VENDOR,
                         OBJECT_EYECATCHER + 2,  dump_application_data,  search_application,     { 1, 0, 0 } }
-        
+
         ,{ DICT_TYPE,           "TYPE",         sizeof(struct dict_type_data),          1,      DICT_APPLICATION,
                         OBJECT_EYECATCHER + 3,  dump_type_data,         search_type,            { 1, 0, 0 } }
-        
+
         ,{ DICT_ENUMVAL,        "ENUMVAL",      sizeof(struct dict_enumval_data),       2,      DICT_TYPE,
                         OBJECT_EYECATCHER + 4,  NULL,                   search_enumval, { 1, 1, 0 } }
-        
+
         ,{ DICT_AVP,            "AVP",          sizeof(struct dict_avp_data),           1,      DICT_TYPE,
                         OBJECT_EYECATCHER + 5,  dump_avp_data,          search_avp,             { 1, 1, 0 } }
-        
+
         ,{ DICT_COMMAND,        "COMMAND",      sizeof(struct dict_cmd_data),           1,      DICT_APPLICATION,
                         OBJECT_EYECATCHER + 6,  dump_command_data,      search_cmd,             { 1, 1, 0 } }
-        
+
         ,{ DICT_RULE,           "RULE",         sizeof(struct dict_rule_data),          2,      -1 /* special case: grouped avp or command */,
                         OBJECT_EYECATCHER + 7,  dump_rule_data,         search_rule,            { 1, 0, 0 } }
-        
+
 };
-        
+
 /* Macro to verify a "type" value */
 #define CHECK_TYPE( type ) ( ((type) > 0) && ((type) <= DICT_TYPE_MAX) )
@@ -231 +138 @@
         str = os0dup( str, *(plen));            \
 }
-        
+
 /* Initialize an object */
 static void init_object( struct dict_object * obj, enum dict_object_type type )
 {
         int i;
-        
+
         TRACE_ENTRY("%p %d", obj, type);
-        
+
         /* Clean the object first */
         memset ( obj, 0, sizeof(struct dict_object));
-        
+
         CHECK_PARAMS_DO(  CHECK_TYPE(type),  return  );
 
@@ -249 +156 @@
 
         /* We don't initialize the data nor the parent here */
-        
+
         /* Now init the lists */
         for (i=0; i<NB_LISTS_PER_OBJ; i++) {
-                if (_OBINFO(obj).haslist[i] != 0) 
+                if (_OBINFO(obj).haslist[i] != 0)
                         fd_list_init(&obj->list[i], obj);
                 else
                         fd_list_init(&obj->list[i], NULL);
         }
-        
+
         fd_list_init(&obj->disp_cbs, NULL);
 }
@@ -266 +173 @@
         TRACE_ENTRY("%p %p %d", dest, source, type);
         CHECK_PARAMS( dest && source && CHECK_TYPE(type) );
-        
-        /* Generic: copy the full data structure */     
+
+        /* Generic: copy the full data structure */
         memcpy( &dest->data, source, dict_obj_info[type].datasize );
-        
+
         /* Then strings must be duplicated, not copied */
         /* This function might be simplified by always defining the "name" field as the first field of the structures, but... it's error-prone */
@@ -276 +183 @@
                         DUP_string_len( dest->data.vendor.vendor_name, &dest->datastr_len );
                         break;
-                
+
                 case DICT_APPLICATION:
                         DUP_string_len( dest->data.application.application_name, &dest->datastr_len );
                         break;
-                        
+
                 case DICT_TYPE:
                         DUP_string_len( dest->data.type.type_name, &dest->datastr_len );
                         break;
-                        
+
                 case DICT_ENUMVAL:
                         DUP_string_len( dest->data.enumval.enum_name, &dest->datastr_len );
                         if (dupos) {
                                 // we also need to duplicate the octetstring constant value since it is a pointer.
-                                dest->data.enumval.enum_value.os.data = os0dup( 
-                                                ((struct dict_enumval_data *)source)->enum_value.os.data, 
+                                dest->data.enumval.enum_value.os.data = os0dup(
+                                                ((struct dict_enumval_data *)source)->enum_value.os.data,
                                                 ((struct dict_enumval_data *)source)->enum_value.os.len
                                         );
@@ -299 +206 @@
                         DUP_string_len( dest->data.avp.avp_name, &dest->datastr_len );
                         break;
-                        
+
                 case DICT_COMMAND:
                         DUP_string_len( dest->data.cmd.cmd_name, &dest->datastr_len );
                         break;
-                
+
                 default:
                         /* Nothing to do for RULES */
                         ;
         }
-        
+
         return 0;
 }
@@ -316 +223 @@
 {
         TRACE_ENTRY("%p", obj);
-        
+
         CHECK_PARAMS_DO(  obj
                         && (obj->objeyec == OBJECT_EYECATCHER)
@@ -334 +241 @@
                         return 0;
                 }  );
-        
+
         /* The object is probably valid. */
         return 1;
@@ -343 +250 @@
 {
         /* TRACE_ENTRY("%p", obj); */
-        
+
         switch (obj->type) {
                 case DICT_VENDOR:
                         free( obj->data.vendor.vendor_name );
                         break;
-                
+
                 case DICT_APPLICATION:
                         free( obj->data.application.application_name );
                         break;
-                        
+
                 case DICT_TYPE:
                         free( obj->data.type.type_name );
                         break;
-                        
+
                 case DICT_ENUMVAL:
                         free( obj->data.enumval.enum_name );
@@ -364 +271 @@
                         free( obj->data.avp.avp_name );
                         break;
-                        
+
                 case DICT_COMMAND:
                         free( obj->data.cmd.cmd_name );
                         break;
-                
+
                 default:
                         /* nothing to do */
@@ -379 +286 @@
 
 /* Destroy all objects in a list - the lock must be held */
-static void destroy_list(struct fd_list * head) 
+static void destroy_list(struct fd_list * head)
 {
         /* TRACE_ENTRY("%p", head); */
-        
+
         /* loop in the list */
         while (!FD_IS_LIST_EMPTY(head))
@@ -390 +297 @@
         }
 }
-        
+
 /* Free an object and its sublists */
 static void destroy_object(struct dict_object * obj)
 {
         int i;
-        
+
         /* TRACE_ENTRY("%p", obj); */
-        
+
         /* Update global count */
-        if (obj->dico) 
+        if (obj->dico)
                 obj->dico->dict_count[obj->type]--;
-        
+
         /* Mark the object as invalid */
         obj->objeyec = 0xdead;
-        
+
         /* First, destroy the data associated to the object */
         destroy_object_data(obj);
-        
+
         for (i=0; i<NB_LISTS_PER_OBJ; i++) {
                 if (_OBINFO(obj).haslist[i])
@@ -416 +323 @@
                         destroy_list( &obj->list[i] );
         }
-        
+
         /* Unlink all elements from the dispatch list; they will be freed when callback is unregistered */
         CHECK_POSIX_DO( pthread_rwlock_wrlock(&fd_disp_lock), /* continue */ );
@@ -423 +330 @@
         }
         CHECK_POSIX_DO( pthread_rwlock_unlock(&fd_disp_lock), /* continue */ );
-        
+
         /* Last, destroy the object */
         free(obj);
@@ -438 +345 @@
 /* Compare two values */
 #define ORDER_scalar( i1, i2 ) \
-        ((i1 < i2 ) ? -1 : ( i1 > i2 ? 1 : 0 )) 
+        ((i1 < i2 ) ? -1 : ( i1 > i2 ? 1 : 0 ))
 
 
@@ -445 +352 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-        
+
         return ORDER_scalar( o1->data.vendor.vendor_id, o2->data.vendor.vendor_id );
 }
@@ -453 +360 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-        
+
         return ORDER_scalar( o1->data.application.application_id, o2->data.application.application_id );
 }
@@ -461 +368 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-        
+
         return fd_os_cmp( o1->data.type.type_name, o1->datastr_len, o2->data.type.type_name, o2->datastr_len );
 }
@@ -469 +376 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-        
+
         return fd_os_cmp( o1->data.enumval.enum_name, o1->datastr_len, o2->data.enumval.enum_name, o2->datastr_len );
 }
@@ -477 +384 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-        
+
         /* The comparison function depends on the type of data */
         switch ( o1->parent->data.type.type_base ) {
                 case AVP_TYPE_OCTETSTRING:
-                        return fd_os_cmp( o1->data.enumval.enum_value.os.data, o1->data.enumval.enum_value.os.len, 
+                        return fd_os_cmp( o1->data.enumval.enum_value.os.data, o1->data.enumval.enum_value.os.len,
                                           o2->data.enumval.enum_value.os.data, o2->data.enumval.enum_value.os.len);
-                
+
                 case AVP_TYPE_INTEGER32:
                         return ORDER_scalar( o1->data.enumval.enum_value.i32, o2->data.enumval.enum_value.i32 );
@@ -513 +420 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-        
+
         return ORDER_scalar( o1->data.avp.avp_code, o2->data.avp.avp_code );
 }
@@ -521 +428 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-        
+
         return fd_os_cmp( o1->data.avp.avp_name, o1->datastr_len, o2->data.avp.avp_name, o2->datastr_len );
 }
@@ -529 +436 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-        
+
         return fd_os_cmp( o1->data.cmd.cmd_name, o1->datastr_len, o2->data.cmd.cmd_name, o2->datastr_len );
 }
@@ -538 +445 @@
         uint8_t fl1, fl2;
         int cmp = 0;
-        
+
         TRACE_ENTRY("%p %p", o1, o2);
-        
+
         cmp = ORDER_scalar( o1->data.cmd.cmd_code, o2->data.cmd.cmd_code );
-        if (cmp) 
+        if (cmp)
                 return cmp;
-        
+
         /* Same command code, we must compare the value of the 'R' flag */
         fl1 = o1->data.cmd.cmd_flag_val & CMD_FLAG_REQUEST;
         fl2 = o2->data.cmd.cmd_flag_val & CMD_FLAG_REQUEST;
-        
+
         /* We want requests first, so we reverse the operators here */
         return ORDER_scalar(fl2, fl1);
-                
+
 }
 
@@ -558 +465 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-        
-        return ORDER_scalar(o1->data.rule.rule_avp->data.avp.avp_vendor, o2->data.rule.rule_avp->data.avp.avp_vendor) 
+
+        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) ;
 }
@@ -745 +652 @@
         int ret = 0;
         vendor_id_t id;
-        
+
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-        
+
         switch (criteria) {
                 case VENDOR_BY_ID:
@@ -753 +660 @@
                         SEARCH_scalar( id, &dict->dict_vendors.list[0], vendor.vendor_id, 1, &dict->dict_vendors );
                         break;
-                                
+
                 case VENDOR_BY_NAME:
                         /* "what" is a vendor name */
                         SEARCH_os0( what, &dict->dict_vendors.list[0], vendor.vendor_name, 0);
                         break;
-                        
+
                 case VENDOR_OF_APPLICATION:
                         /* "what" should be an application object */
                         SEARCH_childs_parent( DICT_APPLICATION, &dict->dict_vendors );
                         break;
-                
+
                 case VENDOR_OF_AVP:
                         /* "what" should be an avp object */
                         SEARCH_sentinel( DICT_AVP, 0, 1 );
                         break;
-                
+
                 default:
                         /* Invalid criteria */
@@ -781 +688 @@
         int ret = 0;
         application_id_t id;
-        
+
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-        
+
         switch (criteria) {
                 case APPLICATION_BY_ID:
@@ -790 +697 @@
                         SEARCH_scalar( id, &dict->dict_applications.list[0],  application.application_id, 1, &dict->dict_applications );
                         break;
-                                
+
                 case APPLICATION_BY_NAME:
                         /* "what" is an application name */
                         SEARCH_os0( what, &dict->dict_applications.list[0], application.application_name, 0);
                         break;
-                        
+
                 case APPLICATION_OF_TYPE:
                         /* "what" should be a type object */
                         SEARCH_childs_parent( DICT_TYPE, &dict->dict_applications );
                         break;
-                
+
                 case APPLICATION_OF_COMMAND:
                         /* "what" should be a command object */
                         SEARCH_childs_parent( DICT_COMMAND, &dict->dict_applications );
                         break;
-                
+
                 default:
                         /* Invalid criteria */
@@ -817 +724 @@
 {
         int ret = 0;
-        
+
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-        
+
         switch (criteria) {
                 case TYPE_BY_NAME:
@@ -825 +732 @@
                         SEARCH_os0( what, &dict->dict_types, type.type_name, 1);
                         break;
-                        
+
                 case TYPE_OF_ENUMVAL:
                         /* "what" should be a type_enum object */
                         SEARCH_childs_parent( DICT_ENUMVAL, NULL );
                         break;
-                
+
                 case TYPE_OF_AVP:
                         /* "what" should be an avp object */
                         SEARCH_childs_parent( DICT_AVP, NULL );
                         break;
-                
-                                
+
+
                 default:
                         /* Invalid criteria */
@@ -848 +755 @@
 {
         int ret = 0;
-        
+
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-        
+
         switch (criteria) {
                 case ENUMVAL_BY_STRUCT:
@@ -856 +763 @@
                                 struct dict_object * parent = NULL;
                                 struct dict_enumval_request * _what = (struct dict_enumval_request *) what;
-                                
+
                                 CHECK_PARAMS(  _what  &&  ( _what->type_obj || _what->type_name )  );
-                                
+
                                 if (_what->type_obj != NULL) {
                                         parent = _what->type_obj;
@@ -867 +774 @@
                                                         CHECK_PARAMS( 0 ) );
                                 }
-                                
+
                                 /* From here the "parent" object is valid */
-                                
+
                                 if ( _what->search.enum_name != NULL ) {
                                         /* We are looking for this string */
@@ -877 +784 @@
                                         switch (parent->data.type.type_base) {
                                                 case AVP_TYPE_OCTETSTRING:
-                                                        SEARCH_os(       _what->search.enum_value.os.data, 
-                                                                         _what->search.enum_value.os.len, 
-                                                                         &parent->list[2], 
-                                                                         enumval.enum_value.os , 
+                                                        SEARCH_os(       _what->search.enum_value.os.data,
+                                                                         _what->search.enum_value.os.len,
+                                                                         &parent->list[2],
+                                                                         enumval.enum_value.os ,
                                                                          1 );
                                                         break;
@@ -891 +798 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-                                                        
+
                                                 case AVP_TYPE_INTEGER64:
                                                         SEARCH_scalar(  _what->search.enum_value.i64,
@@ -899 +806 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-                                                        
+
                                                 case AVP_TYPE_UNSIGNED32:
                                                         SEARCH_scalar(  _what->search.enum_value.u32,
@@ -907 +814 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-                                                        
+
                                                 case AVP_TYPE_UNSIGNED64:
                                                         SEARCH_scalar(  _what->search.enum_value.u64,
@@ -915 +822 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-                                                        
+
                                                 case AVP_TYPE_FLOAT32:
                                                         SEARCH_scalar(  _what->search.enum_value.f32,
@@ -923 +830 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-                                                        
+
                                                 case AVP_TYPE_FLOAT64:
                                                         SEARCH_scalar(  _what->search.enum_value.f64,
@@ -931 +838 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-                                                        
+
                                                 default:
                                                         /* Invalid parent type basetype */
@@ -937 +844 @@
                                         }
                                 }
-                                
+
                         }
                         break;
-                
-                                
+
+
                 default:
                         /* Invalid criteria */
@@ -953 +860 @@
 {
         int ret = 0;
-        
+
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-        
+
         switch (criteria) {
                 case AVP_BY_CODE:
@@ -965 +872 @@
                         }
                         break;
-                                
+
                 case AVP_BY_NAME:
                         /* "what" is the AVP name, vendor 0 */
                         SEARCH_os0( what, &dict->dict_vendors.list[2], avp.avp_name, 1);
                         break;
-                        
+
                 case AVP_BY_CODE_AND_VENDOR:
                 case AVP_BY_NAME_AND_VENDOR:
@@ -976 +883 @@
                                 struct dict_avp_request * _what = (struct dict_avp_request *) what;
                                 struct dict_object * vendor = NULL;
-                                
+
                                 CHECK_PARAMS( (criteria != AVP_BY_NAME_AND_VENDOR) || _what->avp_name  );
-                                
+
                                 /* Now look for the vendor first */
                                 CHECK_FCT( search_vendor( dict, VENDOR_BY_ID, &_what->avp_vendor, &vendor ) );
@@ -988 +895 @@
                                         goto end;
                                 }
-                                
+
                                 /* We now have our vendor = head of the appropriate avp list */
                                 if (criteria == AVP_BY_NAME_AND_VENDOR) {
@@ -998 +905 @@
                         }
                         break;
-                
+
                 case AVP_BY_STRUCT:
                         {
                                 struct dict_avp_request_ex * _what = (struct dict_avp_request_ex *) what;
                                 struct dict_object * vendor = NULL;
-                                
+
                                 CHECK_PARAMS( _what->avp_vendor.vendor || _what->avp_vendor.vendor_id || _what->avp_vendor.vendor_name );
                                 CHECK_PARAMS( _what->avp_data.avp_code || _what->avp_data.avp_name );
-                                
+
                                 /* Now look for the vendor first */
                                 if (_what->avp_vendor.vendor) {
@@ -1017 +924 @@
                                         CHECK_FCT( search_vendor( dict, VENDOR_BY_NAME, _what->avp_vendor.vendor_name, &vendor ) );
                                 }
-                                
+
                                 if (vendor == NULL) {
                                         if (result)
@@ -1025 +932 @@
                                         goto end;
                                 }
-                                
+
                                 /* We now have our vendor = head of the appropriate avp list */
                                 if (_what->avp_data.avp_code) {
@@ -1035 +942 @@
                         }
                         break;
-                
+
                 case AVP_BY_NAME_ALL_VENDORS:
                         {
                                 struct fd_list * li;
                                 size_t wl = strlen((char *)what);
-                                
+
                                 /* First, search for vendor 0 */
                                 SEARCH_os0_l( what, wl, &dict->dict_vendors.list[2], avp.avp_name, 1);
-                                
+
                                 /* If not found, loop for all vendors, until found */
                                 for (li = dict->dict_vendors.list[0].next; li != &dict->dict_vendors.list[0]; li = li->next) {
@@ -1050 +957 @@
                         }
                         break;
-                
+
                 default:
                         /* Invalid criteria */
@@ -1062 +969 @@
 {
         int ret = 0;
-        
+
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-        
+
         switch (criteria) {
                 case CMD_BY_NAME:
@@ -1070 +977 @@
                         SEARCH_os0( what, &dict->dict_cmd_name, cmd.cmd_name, 1);
                         break;
-                        
+
                 case CMD_BY_CODE_R:
                 case CMD_BY_CODE_A:
@@ -1076 +983 @@
                                 command_code_t code;
                                 uint8_t searchfl = 0;
-                                
+
                                 /* The command code that we are searching */
                                 code = *(command_code_t *) what;
-                                
+
                                 /* The flag (request or answer) of the command we are searching */
                                 if (criteria == CMD_BY_CODE_R) {
                                         searchfl = CMD_FLAG_REQUEST;
                                 }
-                                
+
                                 /* perform the search */
                                 SEARCH_codefl( code, searchfl, &dict->dict_cmd_code );
                         }
                         break;
-                                
+
                 case CMD_ANSWER:
                         {
@@ -1095 +1002 @@
                                 struct dict_object * req = (struct dict_object *) what;
                                 struct dict_object * ans = NULL;
-                                
-                                CHECK_PARAMS( verify_object(req) 
+
+                                CHECK_PARAMS( verify_object(req)
                                                 && (req->type == DICT_COMMAND)
                                                 && (req->data.cmd.cmd_flag_mask & CMD_FLAG_REQUEST)
                                                 && (req->data.cmd.cmd_flag_val  & CMD_FLAG_REQUEST) );
-                                
+
                                 /* The answer is supposed to be the next element in the list, if it exists */
                                 ans = req->list[1].next->o;
@@ -1108 +1015 @@
                                         goto end;
                                 }
-                                
+
                                 /* Now check that the ans element is really the correct one */
                                 if (  (ans->data.cmd.cmd_code != req->data.cmd.cmd_code)
@@ -1117 +1024 @@
                                         goto end;
                                 }
-                                
+
                                 if (result)
                                         *result = ans;
                                 ret = 0;
-                        }                                               
-                        break;
-                        
+                        }
+                        break;
+
                 default:
                         /* Invalid criteria */
@@ -1135 +1042 @@
 {
         int ret = 0;
-        
+
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-        
+
         switch (criteria) {
                 case RULE_BY_AVP_AND_PARENT:
@@ -1144 +1051 @@
                                 struct dict_object * avp = NULL;
                                 struct dict_rule_request * _what = (struct dict_rule_request *) what;
-                                
-                                CHECK_PARAMS( _what 
+
+                                CHECK_PARAMS( _what
                                                 && (parent = _what->rule_parent)
                                                 && (avp    = _what->rule_avp   ) );
-                                
-                                CHECK_PARAMS( verify_object(parent) 
-                                                && ((parent->type == DICT_COMMAND) 
+
+                                CHECK_PARAMS( verify_object(parent)
+                                                && ((parent->type == DICT_COMMAND)
                                                  || ((parent->type == DICT_AVP) && (parent->data.avp.avp_basetype == AVP_TYPE_GROUPED))) );
-                                
+
                                 CHECK_PARAMS( verify_object(avp) && (avp->type == DICT_AVP) );
-                                
+
                                 /* Perform the search */
                                 SEARCH_ruleavpname( avp->data.avp.avp_name, avp->datastr_len, &parent->list[2]);
-                                
+
                         }
                         break;
-                        
+
                 default:
                         /* Invalid criteria */
@@ -1180 +1087 @@
 {
         struct dict_vendor_data * vendor = (struct dict_vendor_data *)data;
-        
+
         return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: %-6u \"%s\"", vendor->vendor_id, vendor->vendor_name);
 }
@@ -1191 +1098 @@
 {
         struct dict_type_data * type = ( struct dict_type_data * ) data;
-        
-        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: %-12s \"%s\"", 
-                        type_base_name[type->type_base], 
+
+        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: %-12s \"%s\"",
+                        type_base_name[type->type_base],
                         type->type_name);
 }
@@ -1212 +1119 @@
                         }
                         break;
-                
+
                 case AVP_TYPE_INTEGER32:
                         CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "%i", enumval->enum_value.i32), return NULL);
@@ -1236 +1143 @@
                         CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "%g", enumval->enum_value.f64), return NULL);
                         break;
-                
+
                 default:
                         CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "??? (ERROR unknown type %d)", type), return NULL);
@@ -1245 +1152 @@
 {
         struct dict_avp_data * avp = (struct dict_avp_data * ) data;
-        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: v/m:" DUMP_AVPFL_str "/" DUMP_AVPFL_str ", %12s, %-6u \"%s\"", 
-                        DUMP_AVPFL_val(avp->avp_flag_val), 
-                        DUMP_AVPFL_val(avp->avp_flag_mask), 
-                        type_base_name[avp->avp_basetype], 
-                        avp->avp_code, 
+        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: v/m:" DUMP_AVPFL_str "/" DUMP_AVPFL_str ", %12s, %-6u \"%s\"",
+                        DUMP_AVPFL_val(avp->avp_flag_val),
+                        DUMP_AVPFL_val(avp->avp_flag_mask),
+                        type_base_name[avp->avp_basetype],
+                        avp->avp_code,
                         avp->avp_name );
 }
@@ -1255 +1162 @@
 {
         struct dict_cmd_data * cmd = (struct dict_cmd_data *) data;
-        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: v/m:" DUMP_CMDFL_str "/" DUMP_CMDFL_str ", %-6u \"%s\"", 
+        return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: v/m:" DUMP_CMDFL_str "/" DUMP_CMDFL_str ", %-6u \"%s\"",
                         DUMP_CMDFL_val(cmd->cmd_flag_val), DUMP_CMDFL_val(cmd->cmd_flag_mask), cmd->cmd_code, cmd->cmd_name);
 }
@@ -1262 +1169 @@
         struct dict_rule_data * rule = (struct dict_rule_data * )data;
         return fd_dump_extend( FD_DUMP_STD_PARAMS, "data: pos:%d ord:%d m/M:%2d/%2d avp:\"%s\"",
-                        rule->rule_position, 
-                        rule->rule_order, 
-                        rule->rule_min, 
+                        rule->rule_position,
+                        rule->rule_order,
+                        rule->rule_min,
                         rule->rule_max,
                         rule->rule_avp->data.avp.avp_name);
@@ -1291 +1198 @@
 {
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%*s{dictobj}(@%p): ", indent, "", obj), return NULL);
-        
+
         if (!verify_object(obj)) {
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "INVALID/NULL"), return NULL);
                 return *buf;
         }
-        
-        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%s p:%p ", 
-                                                                _OBINFO(obj).name, 
+
+        CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "%s p:%p ",
+                                                                _OBINFO(obj).name,
                                                                 obj->parent), return NULL);
-        
+
         if (obj->type == DICT_ENUMVAL) {
                 CHECK_MALLOC_DO( dump_enumval_data ( FD_DUMP_STD_PARAMS, &obj->data.enumval, obj->parent->data.type.type_base ), return NULL);
@@ -1306 +1213 @@
                 CHECK_MALLOC_DO( _OBINFO(obj).dump_data(FD_DUMP_STD_PARAMS, &obj->data), return NULL);
         }
-        
+
         if (parents) {
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n%*sparent:", indent + 1, ""), return NULL);
                 CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, obj->parent, parents-1, 0, 0 ), return NULL);
         }
-        
+
         if (depth) {
                 int i;
@@ -1321 +1228 @@
                 }
         }
-        
+
         return *buf;
 }
@@ -1328 +1235 @@
 {
         FD_DUMP_HANDLE_OFFSET();
-        
+
         CHECK_MALLOC_DO( dump_object(FD_DUMP_STD_PARAMS, obj, 1, 2, 0), return NULL);
-        
+
         return *buf;
 }
@@ -1338 +1245 @@
         int i;
         struct fd_list * li;
-        
+
         FD_DUMP_HANDLE_OFFSET();
-                
+
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "{dictionary}(@%p): ", dict), return NULL);
-        
+
         if ((dict == NULL) || (dict->dict_eyec != DICT_EYECATCHER)) {
                 return fd_dump_extend(FD_DUMP_STD_PARAMS, "INVALID/NULL");
         }
-        
+
         CHECK_POSIX_DO(  pthread_rwlock_rdlock( &dict->dict_lock ), /* ignore */  );
-        
+
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict}(@%p): VENDORS / AVP / RULES\n", dict), goto error);
         CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, &dict->dict_vendors, 0, 3, 3 ), goto error);
@@ -1355 +1262 @@
                 CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, li->o, 0, 3, 3 ), goto error);
         }
-        
+
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict}(@%p): APPLICATIONS\n", dict), goto error);
         CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, &dict->dict_applications, 0, 1, 3 ), goto error);
@@ -1362 +1269 @@
                 CHECK_MALLOC_DO( dump_object (FD_DUMP_STD_PARAMS, li->o, 0, 1, 3 ), goto error);
         }
-        
+
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict}(@%p): TYPES / ENUMVAL", dict), goto error);
         CHECK_MALLOC_DO( dump_list(FD_DUMP_STD_PARAMS, &dict->dict_types, 0, 2, 3 ), goto error);
-        
+
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict}(@%p): COMMANDS / RULES", dict), goto error);
         CHECK_MALLOC_DO( dump_list(FD_DUMP_STD_PARAMS, &dict->dict_cmd_code, 0, 0, 3 ), goto error);
-        
+
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n {dict}(@%p): statistics", dict), goto error);
         for (i=1; i<=DICT_TYPE_MAX; i++)
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "\n   %5d: %s",  dict->dict_count[i], dict_obj_info[i].name), goto error);
-        
+
         CHECK_POSIX_DO(  pthread_rwlock_unlock( &dict->dict_lock ), /* ignore */  );
         return *buf;
-error:  
+error:
         /* Free the rwlock */
         CHECK_POSIX_DO(  pthread_rwlock_unlock( &dict->dict_lock ), /* ignore */  );
@@ -1387 +1294 @@
 {
         int i;
-        
+
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "<"), return NULL);
         for (i = 0; i < value->os.len; i++) {
@@ -1436 +1343 @@
                 case AVP_TYPE_OCTETSTRING:
                         return &dump_val_os;
-                
+
                 case AVP_TYPE_INTEGER32:
                         return &dump_val_i32;
@@ -1454 +1361 @@
                 case AVP_TYPE_FLOAT64:
                         return &dump_val_f64;
-                
+
                 case AVP_TYPE_GROUPED:
                         TRACE_DEBUG(FULL, "error: grouped AVP with a value!");
@@ -1468 +1375 @@
 
 /* Formatter for the AVP value dump line */
-static DECLARE_FD_DUMP_PROTOTYPE(dump_avp_val, union avp_value *avp_value, 
-                        dump_val_cb_t def_dump_val_cb, 
-                        dump_val_cb_t dump_val_cb, 
-                        enum dict_avp_basetype datatype, 
-                        char * type_name, 
-                        char * const_name, 
-                        int indent, 
+static DECLARE_FD_DUMP_PROTOTYPE(dump_avp_val, union avp_value *avp_value,
+                        dump_val_cb_t def_dump_val_cb,
+                        dump_val_cb_t dump_val_cb,
+                        enum dict_avp_basetype datatype,
+                        char * type_name,
+                        char * const_name,
+                        int indent,
                         int header)
 {
@@ -1480 +1387 @@
                 /* Header for all AVP values dumps: */
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, INOBJHDR "value ", INOBJHDRVAL), return NULL);
-        
+
                 /* If the type is provided, write it */
                 if (type_name) {
                         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "t: '%s' ", type_name), return NULL);
                 }
-        
+
                 /* Always give the base datatype anyway */
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(%s) ", type_base_name[datatype]), return NULL);
@@ -1503 +1410 @@
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, ")"), return NULL);
         }
-        
+
         /* Done! */
         return *buf;
@@ -1515 +1422 @@
         char * type_name = NULL;
         char * const_name = NULL;
-        
+
         FD_DUMP_HANDLE_OFFSET();
-        
+
         /* Handle invalid parameters */
         if (!avp_value) {
@@ -1528 +1435 @@
                 return *buf;
         }
-        
+
         if (! ( verify_object(model) && (model->type == DICT_AVP) )) {
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "(invalid model)"), return NULL);
                 return *buf;
         }
-        
+
         /* Get the type definition of this AVP */
         type = model->parent;
@@ -1539 +1446 @@
                 struct dict_enumval_request  request;
                 struct dict_object * enumval = NULL;
-                
+
                 type_name = type->data.type.type_name;
-                
+
                 /* overwrite the dump function ? */
                 if (type->data.type.type_dump)
                         dump_val_cb = type->data.type.type_dump;
-                
+
                 /* Now check if the AVP value matches a constant */
                 memset(&request, 0, sizeof(request));
@@ -1556 +1463 @@
                 }
         }
-        
+
         /* And finally, dump the value */
         CHECK_MALLOC_DO( dump_avp_val(FD_DUMP_STD_PARAMS, avp_value, get_default_dump_val_cb(model->data.avp.avp_basetype), dump_val_cb, model->data.avp.avp_basetype, type_name, const_name, indent, header), return NULL );
@@ -1576 +1483 @@
 {
         TRACE_ENTRY("%p %p", object, type);
-        
+
         CHECK_PARAMS( type && verify_object(object) );
-        
+
         /* Copy the value and return */
         *type = object->type;
@@ -1587 +1494 @@
 {
         TRACE_ENTRY("%p %p", object, dict);
-        
+
         CHECK_PARAMS( dict && verify_object(object) );
-        
+
         /* Copy the value and return */
         *dict = object->dico;
@@ -1600 +1507 @@
 {
         TRACE_ENTRY("%p %p", object, val);
-        
+
         CHECK_PARAMS( val && verify_object(object) );
-        
+
         /* Copy the value and return */
         memcpy(val, &object->data, _OBINFO(object).datasize);;
@@ -1616 +1523 @@
         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);
-        
+
         /* Check parameters */
         CHECK_PARAMS( dict && (dict->dict_eyec == DICT_EYECATCHER) && CHECK_TYPE(type) && data  );
-        
+
         /* Check the "parent" parameter */
         switch (dict_obj_info[type].parent) {
                 case 0: /* parent is forbidden */
                         CHECK_PARAMS_DO( parent == NULL, goto error_param );
-                
+
                 case 1: /* parent is optional */
                         if (parent == NULL)
                                 break;
-                
+
                 case 2: /* parent is mandatory */
                         CHECK_PARAMS_DO(  verify_object(parent), goto error_param  );
-                        
+
                         if (type == DICT_RULE ) { /* Special case : grouped AVP or Command parents are allowed */
-                                CHECK_PARAMS_DO( (parent->type == DICT_COMMAND ) 
+                                CHECK_PARAMS_DO( (parent->type == DICT_COMMAND )
                                                 || ( (parent->type == DICT_AVP) && (parent->data.avp.avp_basetype == AVP_TYPE_GROUPED ) ), goto error_param );
                         } else {
@@ -1641 +1548 @@
                         }
         }
-        
+
         /* For AVP object, we must also check that the "vendor" referenced exists */
         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 ),
                         { TRACE_DEBUG(INFO, "Unable to find vendor '%d' referenced in the AVP data", ((struct dict_avp_data *)data)->avp_vendor); goto error_param; }  );
-                
+
                 /* Also check if a parent is provided, that the type are the same */
                 if (parent) {
@@ -1652 +1559 @@
                 }
         }
-        
+
         /* For RULE object, we must also check that the "avp" referenced exists */
         if (type == DICT_RULE) {
@@ -1658 +1565 @@
                 CHECK_PARAMS_DO(  ((struct dict_rule_data *)data)->rule_avp->type == DICT_AVP, goto error_param  );
         }
-        
+
         /* For COMMAND object, check that the 'R' flag is fixed */
         if (type == DICT_COMMAND) {
@@ -1669 +1576 @@
                         dupos = 1;
         }
-        
+
         /* We have to check that the new values are not equal to the sentinels */
         if (type == DICT_VENDOR) {
@@ -1677 +1584 @@
                 CHECK_PARAMS_DO( ((struct dict_application_data *)data)->application_id != 0, goto error_param   );
         }
-        
+
         /* Parameters are valid, create the new object */
         CHECK_MALLOC(  new = malloc(sizeof(struct dict_object))  );
-        
+
         /* Initialize the data of the new object */
         init_object(new, type);
@@ -1686 +1593 @@
         new->dico = dict;
         new->parent = parent;
-        
+
         /* We will change the dictionary => acquire the write lock */
         CHECK_POSIX_DO(  ret = pthread_rwlock_wrlock(&dict->dict_lock),  goto error_free  );
-        
+
         /* Now link the object -- this also checks that no object with same keys already exists */
         switch (type) {
@@ -1698 +1605 @@
                                 goto error_unlock;
                         break;
-                
+
                 case DICT_APPLICATION:
                         /* An application object is linked in the g_dict_applciations.list[0], by their id */
@@ -1705 +1612 @@
                                 goto error_unlock;
                         break;
-                
+
                 case DICT_TYPE:
                         /* A type object is linked in g_list_types by its name */
@@ -1712 +1619 @@
                                 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 */
@@ -1718 +1625 @@
                         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; 
+                        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 */
@@ -1731 +1638 @@
                         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) {
@@ -1738 +1645 @@
                         }
                         break;
-                        
+
                 case DICT_COMMAND:
                         /* A command object is linked in g_list_cmd_name and g_list_cmd_code by its name and code */
@@ -1744 +1651 @@
                         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) {
@@ -1751 +1658 @@
                         }
                         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 */
@@ -1758 +1665 @@
                                 goto error_unlock;
                         break;
-                        
+
                 default:
                         ASSERT(0);
         }
-        
+
         /* A new object has been created, increment the global counter */
         dict->dict_count[type]++;
-        
+
         /* Unlock the dictionary */
         CHECK_POSIX_DO(  ret = pthread_rwlock_unlock(&dict->dict_lock),  goto error_free  );
-        
+
         /* Save the pointer to the new object */
         if (ref)
                 *ref = new;
-        
+
         return 0;
-        
+
 error_param:
         ret = EINVAL;
@@ -1787 +1694 @@
                                 TRACE_DEBUG(FULL, "Vendor %s already in dictionary", new->data.vendor.vendor_name);
                                 /* if we are here, it means the two vendors id are identical */
-                                if (fd_os_cmp(locref->data.vendor.vendor_name, locref->datastr_len, 
+                                if (fd_os_cmp(locref->data.vendor.vendor_name, locref->datastr_len,
                                                 new->data.vendor.vendor_name, new->datastr_len)) {
                                         TRACE_DEBUG(INFO, "Conflicting vendor name: %s", new->data.vendor.vendor_name);
@@ -1793 +1700 @@
                                 }
                                 /* Otherwise (same name), we consider the function succeeded, since the (same) object is in the dictionary */
-                                ret = 0; 
+                                ret = 0;
                                 break;
 
@@ -1799 +1706 @@
                                 TRACE_DEBUG(FULL, "Application %s already in dictionary", new->data.application.application_name);
                                 /* got same id */
-                                if (fd_os_cmp(locref->data.application.application_name, locref->datastr_len, 
+                                if (fd_os_cmp(locref->data.application.application_name, locref->datastr_len,
                                                 new->data.application.application_name, new->datastr_len)) {
                                         TRACE_DEBUG(FULL, "Conflicting application name");
@@ -1937 +1844 @@
                 char * buf = NULL;
                 size_t len = 0, offset=0;
-                
+
                 if (type == DICT_ENUMVAL) {
                         CHECK_MALLOC( dump_enumval_data ( &buf, &len, &offset, data, parent->data.type.type_base ));
@@ -1943 +1850 @@
                         CHECK_MALLOC( dict_obj_info[CHECK_TYPE(type) ? type : 0].dump_data(&buf, &len, &offset, data) );
                 }
-        
+
                 TRACE_DEBUG(INFO, "An error occurred while adding the following data in the dictionary: %s", buf);
-                
+
                 if (ret == EEXIST) {
                         offset=0;
@@ -1964 +1871 @@
         struct dictionary * dict;
         int ret=0;
-        
+
         /* check params */
         CHECK_PARAMS( verify_object(obj) && obj->dico);
@@ -1971 +1878 @@
         /* Lock the dictionary for change */
         CHECK_POSIX(  pthread_rwlock_wrlock(&dict->dict_lock)  );
-        
+
         /* check the object is not sentinel for another list */
         for (i=0; i<NB_LISTS_PER_OBJ; i++) {
@@ -1984 +1891 @@
                 }
         }
-        
+
         /* ok, now destroy the object */
         if (!ret)
                 destroy_object(obj);
-        
+
         /* Unlock */
         CHECK_POSIX(  pthread_rwlock_unlock(&dict->dict_lock)  );
-        
+
         return ret;
 }
@@ -1999 +1906 @@
 {
         int ret = 0;
-        
+
         TRACE_ENTRY("%p %d(%s) %d %p %p %d", dict, type, dict_obj_info[CHECK_TYPE(type) ? type : 0].name, criteria, what, result, retval);
-        
+
         /* Check param */
         CHECK_PARAMS( dict && (dict->dict_eyec == DICT_EYECATCHER) && CHECK_TYPE(type) );
-        
+
         /* Lock the dictionary for reading */
         CHECK_POSIX(  pthread_rwlock_rdlock(&dict->dict_lock)  );
-        
+
         /* Now call the type-specific search function */
         ret = dict_obj_info[type].search_fct (dict, criteria, what, result);
-        
+
         /* Unlock */
         CHECK_POSIX(  pthread_rwlock_unlock(&dict->dict_lock)  );
-        
+
         /* Update the return value as needed */
         if ((result != NULL) && (*result == NULL))
                 ret = retval;
-        
+
         return ret;
 }
@@ -2030 +1937 @@
   }
 
-The following criteria are allowed, with corresponding parent. 
+The following criteria are allowed, with corresponding parent.
 The parent is either struct dictionary * or struct dict_object *
-                
+
 VENDOR_BY_ID : (parent = dictionary) returns list of vendors ordered by ID
 APPLICATION_BY_ID : (parent = dictionary) returns list of applications ordered by ID
-  ** for these two lists, the Vendor with id 0 and applciation with id 0 are excluded. 
+  ** for these two lists, the Vendor with id 0 and applciation with id 0 are excluded.
      You must resolve them separatly with dict_search.
-                
+
 TYPE_BY_NAME : (parent = dictionary) returns list of types ordered by name (osstring order)
 ENUMVAL_BY_NAME : (parent = type object) return list of constants for this type ordered by name (osstring order)
@@ -2053 +1960 @@
         struct dictionary * dict = parent;
         struct dict_object * obj_parent = parent;
-        
+
         TRACE_ENTRY("%i %p %p", criteria, parent, sentinel);
-        
+
         CHECK_PARAMS(sentinel && parent);
-        
+
         switch(criteria) {
                 case VENDOR_BY_ID: /* parent must be the dictionary */
@@ -2063 +1970 @@
                         *sentinel = &dict->dict_vendors.list[0];
                         break;
-                        
+
                 case APPLICATION_BY_ID: /* parent must be the dictionary */
                         CHECK_PARAMS(dict->dict_eyec == DICT_EYECATCHER);
                         *sentinel = &dict->dict_applications.list[0];
                         break;
-                        
+
                 case TYPE_BY_NAME: /* parent must be the dictionary */
                         CHECK_PARAMS(dict->dict_eyec == DICT_EYECATCHER);
                         *sentinel = &dict->dict_types;
                         break;
-                        
+
                 case ENUMVAL_BY_NAME: /* parent must be a type object */
                         CHECK_PARAMS(verify_object(obj_parent) && (obj_parent->type == DICT_TYPE));
                         *sentinel = &obj_parent->list[1];
                         break;
-                        
+
                 case ENUMVAL_BY_VALUE: /* parent must be a type object */
                         CHECK_PARAMS(verify_object(obj_parent) && (obj_parent->type == DICT_TYPE));
                         *sentinel = &obj_parent->list[2];
                         break;
-                        
+
                 case AVP_BY_NAME: /* parent must be a VENDOR object */
                         CHECK_PARAMS(verify_object(obj_parent) && (obj_parent->type == DICT_VENDOR));
                         *sentinel = &obj_parent->list[2];
                         break;
-                        
+
                 case AVP_BY_CODE: /* parent must be a VENDOR object */
                         CHECK_PARAMS(verify_object(obj_parent) && (obj_parent->type == DICT_VENDOR));
                         *sentinel = &obj_parent->list[1];
                         break;
-                        
+
                 case CMD_BY_NAME: /* parent must be the dictionary */
                         CHECK_PARAMS(dict->dict_eyec == DICT_EYECATCHER);
                         *sentinel = &dict->dict_cmd_name;
                         break;
-                        
+
                 case CMD_BY_CODE_R: /* parent must be the dictionary */
                         CHECK_PARAMS(dict->dict_eyec == DICT_EYECATCHER);
                         *sentinel = &dict->dict_cmd_code;
                         break;
-                        
+
                 case RULE_BY_AVP_AND_PARENT: /* parent must be command or grouped AVP */
                         CHECK_PARAMS(verify_object(obj_parent));
                         CHECK_PARAMS(   (obj_parent->type == DICT_COMMAND) ||
-                                        ((obj_parent->type == DICT_AVP) 
+                                        ((obj_parent->type == DICT_AVP)
                                           && (obj_parent->data.avp.avp_basetype == AVP_TYPE_GROUPED)) );
                         *sentinel = &obj_parent->list[2];
                         break;
-                        
+
                 default:
                         CHECK_PARAMS(0);
         }
-        
+
         return 0;
 }
@@ -2131 +2038 @@
 {
         struct dictionary * new = NULL;
-        
+
         TRACE_ENTRY("%p", dict);
-        
+
         /* Sanity checks */
         ASSERT( (sizeof(type_base_name) / sizeof(type_base_name[0])) == (AVP_TYPE_MAX + 1) );
         ASSERT( (sizeof(dict_obj_info)  / sizeof(dict_obj_info[0]))  == (DICT_TYPE_MAX + 1) );
         CHECK_PARAMS(dict);
-        
+
         /* Allocate the memory for the dictionary */
         CHECK_MALLOC( new = malloc(sizeof(struct dictionary)) );
         memset(new, 0, sizeof(struct dictionary));
-        
+
         new->dict_eyec = DICT_EYECATCHER;
-        
+
         /* Initialize the lock for the dictionary */
         CHECK_POSIX(  pthread_rwlock_init(&new->dict_lock, NULL)  );
-        
+
         /* Initialize the sentinel for vendors and AVP lists */
         init_object( &new->dict_vendors, DICT_VENDOR );
@@ -2155 +2062 @@
         /* new->dict_vendors.list[0].o = NULL; *//* overwrite since element is also sentinel for this list. */
         new->dict_vendors.dico = new;
-        
+
         /* Initialize the sentinel for applications */
         init_object( &new->dict_applications, DICT_APPLICATION );
@@ -2163 +2070 @@
         /* new->dict_applications.list[0].o = NULL; *//* overwrite since since element is also sentinel for this list. */
         new->dict_applications.dico = new;
-                        
+
         /* Initialize the sentinel for types */
         fd_list_init ( &new->dict_types, NULL );
-        
+
         /* Initialize the sentinels for commands */
         fd_list_init ( &new->dict_cmd_name, NULL );
         fd_list_init ( &new->dict_cmd_code, NULL );
-        
+
         /* Initialize the error command object */
         init_object( &new->dict_cmd_error, DICT_COMMAND );
@@ -2179 +2086 @@
         new->dict_cmd_error.data.cmd.cmd_flag_val =CMD_FLAG_ERROR;
         new->dict_cmd_error.dico = new;
-        
+
         *dict = new;
-        
+
         /* Done */
         return 0;
@@ -2190 +2097 @@
 {
         int i;
-        
+
         TRACE_ENTRY("");
         CHECK_PARAMS( dict && *dict && ((*dict)->dict_eyec == DICT_EYECATCHER) );
-        
+
         /* Acquire the write lock to make sure no other operation is ongoing */
         CHECK_POSIX(  pthread_rwlock_wrlock(&(*dict)->dict_lock)  );
-        
+
         /* Empty all the lists, free the elements */
         destroy_list ( &(*dict)->dict_cmd_error.list[2] );
@@ -2206 +2113 @@
                 destroy_list ( &(*dict)->dict_vendors.list[i] );
         }
-        
+
         /* Dictionary is empty, now destroy the lock */
         CHECK_POSIX(  pthread_rwlock_unlock(&(*dict)->dict_lock)  );
         CHECK_POSIX(  pthread_rwlock_destroy(&(*dict)->dict_lock)  );
-        
+
         free(*dict);
         *dict = NULL;
-        
+
         return 0;
 }
@@ -2230 +2137 @@
         int ret = 0;
         struct fd_list * li;
-        
+
         TRACE_ENTRY("%p %p %p", parent, data, cb);
-        
+
         /* Check parameters */
         CHECK_PARAMS(  verify_object(parent)  );
-        CHECK_PARAMS(  (parent->type == DICT_COMMAND) 
+        CHECK_PARAMS(  (parent->type == DICT_COMMAND)
                         || ((parent->type == DICT_AVP) && (parent->data.avp.avp_basetype == AVP_TYPE_GROUPED)) );
-        TRACE_DEBUG (FULL, "Iterating on rules of %s: '%s'.", 
-                        _OBINFO(parent).name, 
-                        parent->type == DICT_COMMAND ? 
+        TRACE_DEBUG (FULL, "Iterating on rules of %s: '%s'.",
+                        _OBINFO(parent).name,
+                        parent->type == DICT_COMMAND ?
                                   parent->data.cmd.cmd_name
                                 : parent->data.avp.avp_name);
-        
+
         /* Acquire the read lock  */
         CHECK_POSIX(  pthread_rwlock_rdlock(&parent->dico->dict_lock)  );
-        
+
         /* go through the list and call the cb on each rule data */
         for (li = &(parent->list[2]); li->next != &(parent->list[2]); li = li->next) {
@@ -2252 +2159 @@
                         break;
         }
-                
+
         /* Release the lock */
         CHECK_POSIX(  pthread_rwlock_unlock(&parent->dico->dict_lock)  );
-        
+
         return ret;
 }
@@ -2265 +2172 @@
         int i = 0;
         struct fd_list * li;
-        
+
         TRACE_ENTRY();
-        
+
         /* Acquire the read lock */
         CHECK_POSIX_DO(  pthread_rwlock_rdlock(&dict->dict_lock), return NULL  );
-        
+
         /* Allocate an array to contain all the elements */
         CHECK_MALLOC_DO( ret = calloc( dict->dict_count[DICT_VENDOR] + 1, sizeof(uint32_t) ), goto out );
-        
+
         /* Copy the vendors IDs */
         for (li = dict->dict_vendors.list[0].next; li != &(dict->dict_vendors.list[0]); li = li->next) {
@@ -2280 +2187 @@
                 ASSERT( i <= dict->dict_count[DICT_VENDOR] );
         }
-out:    
+out:
         /* Release the lock */
         CHECK_POSIX_DO(  pthread_rwlock_unlock(&dict->dict_lock), return NULL  );
-        
+
         return ret;
 }