Changes in / [1453:05185ab84cf8:1449:ffe2f27e00e5] in freeDiameter

Files:

• extensions/CMakeLists.txt (modified) (1 diff)
• extensions/dbg_dict_dump_json/CMakeLists.txt (deleted)
• extensions/dbg_dict_dump_json/dbg_dict_dump_json.cc (deleted)
• freeDiameterd/main.c (modified) (1 diff)
• libfdproto/dictionary-internal.h (deleted)
• libfdproto/dictionary.c (modified) (126 diffs)

extensions/CMakeLists.txt

@@ -90 +90 @@
 
 FD_EXTENSION_SUBDIR(dbg_dict_dump   "Log dictionary dump"                            ON)
-FD_EXTENSION_SUBDIR(dbg_dict_dump_json   "Dump dictionary as JSON"                            ON)
 FD_EXTENSION_SUBDIR(dbg_loglevel "Read loglevel from file -- allows runtime change"  ON)
 FD_EXTENSION_SUBDIR(dbg_monitor     "Outputs periodical status information"              ON)

freeDiameterd/main.c

@@ -91 +91 @@
         }
 
-        /* Cleanup pidfile on exit */
+        /* Cleaup pidfile on exit */
         if (atexit(pidfile_cleanup) != 0) {
                 LOG_F("Unable to setup pidfile cleanup");

libfdproto/dictionary.c

@@ -35 +35 @@
 
 #include "fdproto-internal.h"
-#include "dictionary-internal.h"
 #include <inttypes.h>
 
@@ -50 +49 @@
         };
 
+/* 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 */
@@ -85 +178 @@
 } 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) )
@@ -138 +231 @@
         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  );
 
@@ -156 +249 @@
 
         /* 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);
 }
@@ -173 +266 @@
         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 */
@@ -183 +276 @@
                         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
                                         );
@@ -206 +299 @@
                         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;
 }
@@ -223 +316 @@
 {
         TRACE_ENTRY("%p", obj);
-
+        
         CHECK_PARAMS_DO(  obj
                         && (obj->objeyec == OBJECT_EYECATCHER)
@@ -241 +334 @@
                         return 0;
                 }  );
-
+        
         /* The object is probably valid. */
         return 1;
@@ -250 +343 @@
 {
         /* 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 );
@@ -271 +364 @@
                         free( obj->data.avp.avp_name );
                         break;
-
+                        
                 case DICT_COMMAND:
                         free( obj->data.cmd.cmd_name );
                         break;
-
+                
                 default:
                         /* nothing to do */
@@ -286 +379 @@
 
 /* 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))
@@ -297 +390 @@
         }
 }
-
+        
 /* 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])
@@ -323 +416 @@
                         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 */ );
@@ -330 +423 @@
         }
         CHECK_POSIX_DO( pthread_rwlock_unlock(&fd_disp_lock), /* continue */ );
-
+        
         /* Last, destroy the object */
         free(obj);
@@ -345 +438 @@
 /* Compare two values */
 #define ORDER_scalar( i1, i2 ) \
-        ((i1 < i2 ) ? -1 : ( i1 > i2 ? 1 : 0 ))
+        ((i1 < i2 ) ? -1 : ( i1 > i2 ? 1 : 0 )) 
 
 
@@ -352 +445 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-
+        
         return ORDER_scalar( o1->data.vendor.vendor_id, o2->data.vendor.vendor_id );
 }
@@ -360 +453 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-
+        
         return ORDER_scalar( o1->data.application.application_id, o2->data.application.application_id );
 }
@@ -368 +461 @@
 {
         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 );
 }
@@ -376 +469 @@
 {
         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 );
 }
@@ -384 +477 @@
 {
         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 );
@@ -420 +513 @@
 {
         TRACE_ENTRY("%p %p", o1, o2);
-
+        
         return ORDER_scalar( o1->data.avp.avp_code, o2->data.avp.avp_code );
 }
@@ -428 +521 @@
 {
         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 );
 }
@@ -436 +529 @@
 {
         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 );
 }
@@ -445 +538 @@
         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);
-
+                
 }
 
@@ -465 +558 @@
 {
         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) ;
 }
@@ -652 +745 @@
         int ret = 0;
         vendor_id_t id;
-
+        
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-
+        
         switch (criteria) {
                 case VENDOR_BY_ID:
@@ -660 +753 @@
                         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 */
@@ -688 +781 @@
         int ret = 0;
         application_id_t id;
-
+        
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-
+        
         switch (criteria) {
                 case APPLICATION_BY_ID:
@@ -697 +790 @@
                         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 */
@@ -724 +817 @@
 {
         int ret = 0;
-
+        
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-
+        
         switch (criteria) {
                 case TYPE_BY_NAME:
@@ -732 +825 @@
                         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 */
@@ -755 +848 @@
 {
         int ret = 0;
-
+        
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-
+        
         switch (criteria) {
                 case ENUMVAL_BY_STRUCT:
@@ -763 +856 @@
                                 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;
@@ -774 +867 @@
                                                         CHECK_PARAMS( 0 ) );
                                 }
-
+                                
                                 /* From here the "parent" object is valid */
-
+                                
                                 if ( _what->search.enum_name != NULL ) {
                                         /* We are looking for this string */
@@ -784 +877 @@
                                         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;
@@ -798 +891 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-
+                                                        
                                                 case AVP_TYPE_INTEGER64:
                                                         SEARCH_scalar(  _what->search.enum_value.i64,
@@ -806 +899 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-
+                                                        
                                                 case AVP_TYPE_UNSIGNED32:
                                                         SEARCH_scalar(  _what->search.enum_value.u32,
@@ -814 +907 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-
+                                                        
                                                 case AVP_TYPE_UNSIGNED64:
                                                         SEARCH_scalar(  _what->search.enum_value.u64,
@@ -822 +915 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-
+                                                        
                                                 case AVP_TYPE_FLOAT32:
                                                         SEARCH_scalar(  _what->search.enum_value.f32,
@@ -830 +923 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-
+                                                        
                                                 case AVP_TYPE_FLOAT64:
                                                         SEARCH_scalar(  _what->search.enum_value.f64,
@@ -838 +931 @@
                                                                         (struct dict_object *)NULL);
                                                         break;
-
+                                                        
                                                 default:
                                                         /* Invalid parent type basetype */
@@ -844 +937 @@
                                         }
                                 }
-
+                                
                         }
                         break;
-
-
+                
+                                
                 default:
                         /* Invalid criteria */
@@ -860 +953 @@
 {
         int ret = 0;
-
+        
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-
+        
         switch (criteria) {
                 case AVP_BY_CODE:
@@ -872 +965 @@
                         }
                         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:
@@ -883 +976 @@
                                 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 ) );
@@ -895 +988 @@
                                         goto end;
                                 }
-
+                                
                                 /* We now have our vendor = head of the appropriate avp list */
                                 if (criteria == AVP_BY_NAME_AND_VENDOR) {
@@ -905 +998 @@
                         }
                         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) {
@@ -924 +1017 @@
                                         CHECK_FCT( search_vendor( dict, VENDOR_BY_NAME, _what->avp_vendor.vendor_name, &vendor ) );
                                 }
-
+                                
                                 if (vendor == NULL) {
                                         if (result)
@@ -932 +1025 @@
                                         goto end;
                                 }
-
+                                
                                 /* We now have our vendor = head of the appropriate avp list */
                                 if (_what->avp_data.avp_code) {
@@ -942 +1035 @@
                         }
                         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) {
@@ -957 +1050 @@
                         }
                         break;
-
+                
                 default:
                         /* Invalid criteria */
@@ -969 +1062 @@
 {
         int ret = 0;
-
+        
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-
+        
         switch (criteria) {
                 case CMD_BY_NAME:
@@ -977 +1070 @@
                         SEARCH_os0( what, &dict->dict_cmd_name, cmd.cmd_name, 1);
                         break;
-
+                        
                 case CMD_BY_CODE_R:
                 case CMD_BY_CODE_A:
@@ -983 +1076 @@
                                 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:
                         {
@@ -1002 +1095 @@
                                 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;
@@ -1015 +1108 @@
                                         goto end;
                                 }
-
+                                
                                 /* Now check that the ans element is really the correct one */
                                 if (  (ans->data.cmd.cmd_code != req->data.cmd.cmd_code)
@@ -1024 +1117 @@
                                         goto end;
                                 }
-
+                                
                                 if (result)
                                         *result = ans;
                                 ret = 0;
-                        }
-                        break;
-
+                        }                                               
+                        break;
+                        
                 default:
                         /* Invalid criteria */
@@ -1042 +1135 @@
 {
         int ret = 0;
-
+        
         TRACE_ENTRY("%p %d %p %p", dict, criteria, what, result);
-
+        
         switch (criteria) {
                 case RULE_BY_AVP_AND_PARENT:
@@ -1051 +1144 @@
                                 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 */
@@ -1087 +1180 @@
 {
         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);
 }
@@ -1098 +1191 @@
 {
         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);
 }
@@ -1119 +1212 @@
                         }
                         break;
-
+                
                 case AVP_TYPE_INTEGER32:
                         CHECK_MALLOC_DO(fd_dump_extend( FD_DUMP_STD_PARAMS, "%i", enumval->enum_value.i32), return NULL);
@@ -1143 +1236 @@
                         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);
@@ -1152 +1245 @@
 {
         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 );
 }
@@ -1162 +1255 @@
 {
         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);
 }
@@ -1169 +1262 @@
         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);
@@ -1198 +1291 @@
 {
         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);
@@ -1213 +1306 @@
                 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;
@@ -1228 +1321 @@
                 }
         }
-
+        
         return *buf;
 }
@@ -1235 +1328 @@
 {
         FD_DUMP_HANDLE_OFFSET();
-
+        
         CHECK_MALLOC_DO( dump_object(FD_DUMP_STD_PARAMS, obj, 1, 2, 0), return NULL);
-
+        
         return *buf;
 }
@@ -1245 +1338 @@
         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);
@@ -1262 +1355 @@
                 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);
@@ -1269 +1362 @@
                 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 */  );
@@ -1294 +1387 @@
 {
         int i;
-
+        
         CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, "<"), return NULL);
         for (i = 0; i < value->os.len; i++) {
@@ -1343 +1436 @@
                 case AVP_TYPE_OCTETSTRING:
                         return &dump_val_os;
-
+                
                 case AVP_TYPE_INTEGER32:
                         return &dump_val_i32;
@@ -1361 +1454 @@
                 case AVP_TYPE_FLOAT64:
                         return &dump_val_f64;
-
+                
                 case AVP_TYPE_GROUPED:
                         TRACE_DEBUG(FULL, "error: grouped AVP with a value!");
@@ -1375 +1468 @@
 
 /* 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)
 {
@@ -1387 +1480 @@
                 /* 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);
@@ -1410 +1503 @@
                 CHECK_MALLOC_DO( fd_dump_extend( FD_DUMP_STD_PARAMS, ")"), return NULL);
         }
-
+        
         /* Done! */
         return *buf;
@@ -1422 +1515 @@
         char * type_name = NULL;
         char * const_name = NULL;
-
+        
         FD_DUMP_HANDLE_OFFSET();
-
+        
         /* Handle invalid parameters */
         if (!avp_value) {
@@ -1435 +1528 @@
                 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;
@@ -1446 +1539 @@
                 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));
@@ -1463 +1556 @@
                 }
         }
-
+        
         /* 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 );
@@ -1483 +1576 @@
 {
         TRACE_ENTRY("%p %p", object, type);
-
+        
         CHECK_PARAMS( type && verify_object(object) );
-
+        
         /* Copy the value and return */
         *type = object->type;
@@ -1494 +1587 @@
 {
         TRACE_ENTRY("%p %p", object, dict);
-
+        
         CHECK_PARAMS( dict && verify_object(object) );
-
+        
         /* Copy the value and return */
         *dict = object->dico;
@@ -1507 +1600 @@
 {
         TRACE_ENTRY("%p %p", object, val);
-
+        
         CHECK_PARAMS( val && verify_object(object) );
-
+        
         /* Copy the value and return */
         memcpy(val, &object->data, _OBINFO(object).datasize);;
@@ -1523 +1616 @@
         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 {
@@ -1548 +1641 @@
                         }
         }
-
+        
         /* 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) {
@@ -1559 +1652 @@
                 }
         }
-
+        
         /* For RULE object, we must also check that the "avp" referenced exists */
         if (type == DICT_RULE) {
@@ -1565 +1658 @@
                 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) {
@@ -1576 +1669 @@
                         dupos = 1;
         }
-
+        
         /* We have to check that the new values are not equal to the sentinels */
         if (type == DICT_VENDOR) {
@@ -1584 +1677 @@
                 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);
@@ -1593 +1686 @@
         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) {
@@ -1605 +1698 @@
                                 goto error_unlock;
                         break;
-
+                
                 case DICT_APPLICATION:
                         /* An application object is linked in the g_dict_applciations.list[0], by their id */
@@ -1612 +1705 @@
                                 goto error_unlock;
                         break;
-
+                
                 case DICT_TYPE:
                         /* A type object is linked in g_list_types by its name */
@@ -1619 +1712 @@
                                 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 */
@@ -1625 +1718 @@
                         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 */
@@ -1638 +1731 @@
                         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) {
@@ -1645 +1738 @@
                         }
                         break;
-
+                        
                 case DICT_COMMAND:
                         /* A command object is linked in g_list_cmd_name and g_list_cmd_code by its name and code */
@@ -1651 +1744 @@
                         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) {
@@ -1658 +1751 @@
                         }
                         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 */
@@ -1665 +1758 @@
                                 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;
@@ -1694 +1787 @@
                                 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);
@@ -1700 +1793 @@
                                 }
                                 /* Otherwise (same name), we consider the function succeeded, since the (same) object is in the dictionary */
-                                ret = 0;
+                                ret = 0; 
                                 break;
 
@@ -1706 +1799 @@
                                 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");
@@ -1844 +1937 @@
                 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 ));
@@ -1850 +1943 @@
                         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;
@@ -1871 +1964 @@
         struct dictionary * dict;
         int ret=0;
-
+        
         /* check params */
         CHECK_PARAMS( verify_object(obj) && obj->dico);
@@ -1878 +1971 @@
         /* 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++) {
@@ -1891 +1984 @@
                 }
         }
-
+        
         /* ok, now destroy the object */
         if (!ret)
                 destroy_object(obj);
-
+        
         /* Unlock */
         CHECK_POSIX(  pthread_rwlock_unlock(&dict->dict_lock)  );
-
+        
         return ret;
 }
@@ -1906 +1999 @@
 {
         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;
 }
@@ -1937 +2030 @@
   }
 
-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)
@@ -1960 +2053 @@
         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 */
@@ -1970 +2063 @@
                         *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;
 }
@@ -2038 +2131 @@
 {
         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 );
@@ -2062 +2155 @@
         /* 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 );
@@ -2070 +2163 @@
         /* 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 );
@@ -2086 +2179 @@
         new->dict_cmd_error.data.cmd.cmd_flag_val =CMD_FLAG_ERROR;
         new->dict_cmd_error.dico = new;
-
+        
         *dict = new;
-
+        
         /* Done */
         return 0;
@@ -2097 +2190 @@
 {
         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] );
@@ -2113 +2206 @@
                 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;
 }
@@ -2137 +2230 @@
         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) {
@@ -2159 +2252 @@
                         break;
         }
-
+                
         /* Release the lock */
         CHECK_POSIX(  pthread_rwlock_unlock(&parent->dico->dict_lock)  );
-
+        
         return ret;
 }
@@ -2172 +2265 @@
         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) {
@@ -2187 +2280 @@
                 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;
 }