Style fixes for /common

4 files changed, 1478 insertions, 1179 deletions

diff --git a/common/collection/collection.c b/common/collection/collection.c
index 4a5b5044..79e4421f 100644
--- a/common/collection/collection.c
+++ b/common/collection/collection.c
@@ -89,27 +89,27 @@ typedef int (*internal_item_fn)(struct collection_item *head,
                                 void *custom_data,
                                 int *stop);
 
-/******************** SUPPLIMENTARY FUNCTIONS ****************************/
+/******************** SUPPLEMENTARY FUNCTIONS ****************************/
 
 
 /* BASIC OPERATIONS */
 /* Function that checks if property can be added */
 static int validate_property(char *property)
 {
-    TRACE_FLOW_STRING("validate_property","Entry point.");
+    TRACE_FLOW_STRING("validate_property", "Entry point.");
     /* Only alpha numeric characters are allowed in names of the properties */
     int invalid = 0;
     char *check;
 
     check = property;
-    while(*check != '\0') {
-        if((!isalnum((int)(*check))) && (!ispunct((int)(*check)))) {
+    while (*check != '\0') {
+        if ((!isalnum(*check)) && (!ispunct(*check))) {
             invalid = 1;
             break;
         }
         check++;
     }
-    TRACE_FLOW_NUMBER("validate_property. Returning ",invalid);
+    TRACE_FLOW_NUMBER("validate_property. Returning ", invalid);
     return invalid;
 }
 
@@ -120,10 +120,10 @@ static void delete_item(struct collection_item *item)
 {
     TRACE_FLOW_STRING("delete_item","Entry point.");
 
-    if(item == (struct collection_item *)NULL) return;
+    if (item == NULL) return;
 
-    if(item->property != NULL) free(item->property);
-    if(item->data != NULL) free(item->data);
+    if (item->property != NULL) free(item->property);
+    if (item->data != NULL) free(item->data);
 
     free(item);
 
@@ -131,42 +131,43 @@ static void delete_item(struct collection_item *item)
 }
 
 /* A generic function to allocate a property item */
-static int allocate_item(struct collection_item **ci,char *property,void *item_data,int length, int type)
+static int allocate_item(struct collection_item **ci, char *property,
+                         void *item_data,int length, int type)
 {
     struct collection_item *item = NULL;
     int error = 0;
     errno = 0;
 
-    TRACE_FLOW_STRING("allocate_item","Entry point.");
-    TRACE_INFO_NUMBER("Will be using type:",type);
+    TRACE_FLOW_STRING("allocate_item", "Entry point.");
+    TRACE_INFO_NUMBER("Will be using type:", type);
 
     /* Check the length */
-    if(length >= COL_MAX_DATA) {
-        TRACE_ERROR_STRING("allocate_item","Data to long.");
+    if (length >= COL_MAX_DATA) {
+        TRACE_ERROR_STRING("allocate_item", "Data to long.");
         return EMSGSIZE;
     }
 
-    if(validate_property(property)) {
-        TRACE_ERROR_STRING("Invalid chracters in the property name",property);
+    if (validate_property(property)) {
+        TRACE_ERROR_STRING("Invalid chracters in the property name", property);
         return EINVAL;
     }
 
     /* Allocate memory for the structure */
-    item = (struct collection_item *)(malloc(sizeof(struct collection_item)));
-    if(item == (struct collection_item *)(NULL))  {
+    item = (struct collection_item *)malloc(sizeof(struct collection_item));
+    if (item == NULL)  {
         error = errno;
-        TRACE_ERROR_STRING("allocate_item","Malloc failed.");
+        TRACE_ERROR_STRING("allocate_item", "Malloc failed.");
         return error;
     }
 
     /* After we initialize "next" we can use delete_item() in case of error */
-    item->next = (struct collection_item *)(NULL);
+    item->next = NULL;
 
     /* Copy property */
     item->property = strdup(property);
-    if(item->property == NULL) {
+    if (item->property == NULL) {
         error = errno;
-        TRACE_ERROR_STRING("allocate_item","Failed to dup property.");
+        TRACE_ERROR_STRING("allocate_item", "Failed to dup property.");
         delete_item(item);
         return error;
     }
@@ -175,71 +176,74 @@ static int allocate_item(struct collection_item **ci,char *property,void *item_d
 
     /* Deal with data */
     item->data = malloc(length);
-    if(item->data == NULL) {
-        TRACE_ERROR_STRING("allocate_item","Failed to dup data.");
+    if (item->data == NULL) {
+        TRACE_ERROR_STRING("allocate_item", "Failed to dup data.");
         delete_item(item);
         return errno;
     }
-    memcpy(item->data,item_data,length);
+    memcpy(item->data, item_data, length);
 
     /* Deal with other properties of the item */
-    TRACE_INFO_NUMBER("About to set type to:",type);
+    TRACE_INFO_NUMBER("About to set type to:", type);
     item->type = type;
     item->length = length;
 
     /* Make sure that data is NULL terminated in case of string */
-    if(type == COL_TYPE_STRING) *(((char *)(item->data))+length-1) = '\0';
+    if (type == COL_TYPE_STRING) ((char *)(item->data))[length-1] = '\0';
 
     *ci = item;
 
-    TRACE_INFO_STRING("Item property",item->property);
-    TRACE_INFO_NUMBER("Item property type",item->type);
-    TRACE_INFO_NUMBER("Item data length",item->length);
-    TRACE_FLOW_STRING("allocate_item","Success exit.");
+    TRACE_INFO_STRING("Item property", item->property);
+    TRACE_INFO_NUMBER("Item property type", item->type);
+    TRACE_INFO_NUMBER("Item data length", item->length);
+    TRACE_FLOW_STRING("allocate_item", "Success exit.");
     return 0;
 }
 
 /* Add item to the end of collection */
 /* Can add itself to itself - nice...*/
-static int add_item_to_collection(struct collection_item *collection,struct collection_item *item)
+static int add_item_to_collection(struct collection_item *collection,
+                                  struct collection_item *item)
 {
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("add_item_to_collection","Entry point.");
+    TRACE_FLOW_STRING("add_item_to_collection", "Entry point.");
 
-    if(collection == (struct collection_item *)(NULL)) {
-        TRACE_INFO_STRING("add_item_to_collection","Collection accepting is NULL");
-        if((item != (struct collection_item *)(NULL)) &&
-           (item->type == COL_TYPE_COLLECTION)) {
+    if (collection == NULL) {
+        TRACE_INFO_STRING("add_item_to_collection",
+                          "Collection accepting is NULL");
+        if ((item != NULL) && (item->type == COL_TYPE_COLLECTION)) {
             /* This is a special case of self creation */
-            TRACE_INFO_STRING("add_item_to_collection","Adding header item to new collection.");
+            TRACE_INFO_STRING("add_item_to_collection",
+                              "Adding header item to new collection.");
             collection = item;
         }
     }
 
     /* We can add items only to collections */
-    if(collection->type != COL_TYPE_COLLECTION) {
-        TRACE_ERROR_STRING("add_item_to_collection","Attempt to add item to non collection.");
-        TRACE_ERROR_STRING("Collection name:",collection->property);
-        TRACE_ERROR_NUMBER("Collection type:",collection->type);
+    if (collection->type != COL_TYPE_COLLECTION) {
+        TRACE_ERROR_STRING("add_item_to_collection",
+                           "Attempt to add item to non collection.");
+        TRACE_ERROR_STRING("Collection name:", collection->property);
+        TRACE_ERROR_NUMBER("Collection type:", collection->type);
         return EINVAL;
     }
 
-    header = (struct collection_header *)(collection->data);
+    header = (struct collection_header *)collection->data;
 
     /* Link new item to the last item in the list if there any */
-    if(header->last != (struct collection_item *)(NULL)) (header->last)->next = item;
+    if (header->last != NULL) header->last->next = item;
 
     /* Make sure we save a new last element */
     header->last = item;
     header->count++;
 
-    TRACE_INFO_STRING("Collection:",collection->property);
-    TRACE_INFO_STRING("Just added item is:",item->property);
-    TRACE_INFO_NUMBER("Item type.",item->type);
-    TRACE_INFO_NUMBER("Number of items in collection now is.",header->count);
+    TRACE_INFO_STRING("Collection:", collection->property);
+    TRACE_INFO_STRING("Just added item is:", item->property);
+    TRACE_INFO_NUMBER("Item type.", item->type);
+    TRACE_INFO_NUMBER("Number of items in collection now is.", header->count);
 
-    TRACE_FLOW_STRING("add_item_to_collection","Success exit.");
+    TRACE_FLOW_STRING("add_item_to_collection", "Success exit.");
     return EOK;
 }
 
@@ -255,15 +259,15 @@ inline static int is_in_item_handler(char *property,
                                      void *found,
                                      int *dummy)
 {
-    TRACE_FLOW_STRING("is_in_item_handler","Entry.");
-    TRACE_INFO_STRING("Property:",property);
-    TRACE_INFO_NUMBER("Property length:",property_len);
-    TRACE_INFO_NUMBER("Type:",type);
-    TRACE_INFO_NUMBER("Length:",length);
+    TRACE_FLOW_STRING("is_in_item_handler", "Entry.");
+    TRACE_INFO_STRING("Property:", property);
+    TRACE_INFO_NUMBER("Property length:", property_len);
+    TRACE_INFO_NUMBER("Type:", type);
+    TRACE_INFO_NUMBER("Length:", length);
 
     *((int *)(found)) = COL_MATCH;
 
-    TRACE_FLOW_STRING("is_in_item_handler","Success Exit.");
+    TRACE_FLOW_STRING("is_in_item_handler", "Success Exit.");
 
     return EOK;
 }
@@ -277,11 +281,11 @@ inline static int get_subcollection(char *property,
                                     void *found,
                                     int *dummy)
 {
-    TRACE_FLOW_STRING("get_subcollection","Entry.");
-    TRACE_INFO_STRING("Property:",property);
-    TRACE_INFO_NUMBER("Property length:",property_len);
-    TRACE_INFO_NUMBER("Type:",type);
-    TRACE_INFO_NUMBER("Length:",length);
+    TRACE_FLOW_STRING("get_subcollection", "Entry.");
+    TRACE_INFO_STRING("Property:", property);
+    TRACE_INFO_NUMBER("Property length:", property_len);
+    TRACE_INFO_NUMBER("Type:", type);
+    TRACE_INFO_NUMBER("Length:", length);
 
     *((struct collection_item **)(found)) = *((struct collection_item **)(data));
 
@@ -294,7 +298,8 @@ inline static int get_subcollection(char *property,
 
 /* ADD PROPERTY */
 
-/* Add a single property to a collection. Returns a pointer to a newly allocated property */
+/* Add a single property to a collection.
+ * Returns a pointer to a newly allocated property */
 static struct collection_item *add_property(struct collection_item *collection,
                                             char *subcollection,
                                             char *property,
@@ -303,63 +308,68 @@ static struct collection_item *add_property(struct collection_item *collection,
                                             int type,
                                             int *error)
 {
-    struct collection_item *item = (struct collection_item *) NULL;
-    struct collection_item *acceptor = (struct collection_item *)(NULL);
+    struct collection_item *item = NULL;
+    struct collection_item *acceptor = NULL;
 
-    TRACE_FLOW_STRING("add_property","Entry.");
+    TRACE_FLOW_STRING("add_property", "Entry.");
     /* Allocate item */
 
-    TRACE_INFO_NUMBER("Property type to add",type);
-    *error = allocate_item(&item,property,item_data,length, type);
-    if(*error) return (struct collection_item *)(NULL);
+    TRACE_INFO_NUMBER("Property type to add", type);
+    *error = allocate_item(&item, property, item_data, length, type);
+    if (*error) return NULL;
 
-    TRACE_INFO_STRING("Created item:",item->property);
-    TRACE_INFO_NUMBER("Item has type:",item->type);
+    TRACE_INFO_STRING("Created item:", item->property);
+    TRACE_INFO_NUMBER("Item has type:", item->type);
 
     /* Add item to collection */
-    if(subcollection == NULL) acceptor = collection;
+    if (subcollection == NULL) {
+        acceptor = collection;
+    }
     else {
-        TRACE_INFO_STRING("Subcollection id not null, searching",subcollection);
-        *error = find_item_and_do(collection, subcollection, COL_TYPE_COLLECTIONREF,
+        TRACE_INFO_STRING("Subcollection id not null, searching", subcollection);
+        *error = find_item_and_do(collection, subcollection,
+                                  COL_TYPE_COLLECTIONREF,
                                   COL_TRAVERSE_DEFAULT,
-                                  get_subcollection,(void *)(&acceptor),COLLECTION_ACTION_FIND);
-        if(*error) {
-            TRACE_ERROR_NUMBER("Search for subcollection returned error:",*error);
+                                  get_subcollection, (void *)(&acceptor),
+                                  COLLECTION_ACTION_FIND);
+        if (*error) {
+            TRACE_ERROR_NUMBER("Search for subcollection returned error:", *error);
             delete_item(item);
-            return (struct collection_item *)(NULL);
+            return NULL;
         }
 
-        if(acceptor == (struct collection_item *)(NULL)) {
-            TRACE_ERROR_STRING("Search for subcollection returned NULL pointer","");
+        if (acceptor == NULL) {
+            TRACE_ERROR_STRING("Search for subcollection returned NULL pointer", "");
             delete_item(item);
-            *error=ENOENT;
-            return (struct collection_item *)(NULL);
+            *error = ENOENT;
+            return NULL;
         }
 
     }
-    *error = add_item_to_collection(acceptor,item);
-    if(*error) {
-        TRACE_ERROR_NUMBER("Failed to add item to collection error:",*error);
+    *error = add_item_to_collection(acceptor, item);
+    if (*error) {
+        TRACE_ERROR_NUMBER("Failed to add item to collection error:", *error);
         delete_item(item);
-        return (struct collection_item *)(NULL);
+        return NULL;
     }
 
-    TRACE_FLOW_STRING("add_property","Success Exit.");
+    TRACE_FLOW_STRING("add_property", "Success Exit.");
     return item;
 }
 
 /* CLEANUP */
 
 /* Cleans the collection tree including current item. */
-/* After the execution passed in variable should not be used - memory is gone!!! */
+/* The passed in variable should not be used after the call
+ * as memory is freed!!! */
 static void delete_collection(struct collection_item *ci)
 {
     struct collection_item *other_collection;
 
-    TRACE_FLOW_STRING("delete_collection","Entry.");
+    TRACE_FLOW_STRING("delete_collection", "Entry.");
 
-    if(ci == (struct collection_item *)(NULL)) {
-        TRACE_FLOW_STRING("delete_collection","Nothing to do Exit.");
+    if (ci == NULL) {
+        TRACE_FLOW_STRING("delete_collection", "Nothing to do Exit.");
         return;
     }
 
@@ -369,14 +379,15 @@ static void delete_collection(struct collection_item *ci)
 
     /* Handle external or embedded collection */
     if(ci->type == COL_TYPE_COLLECTIONREF)  {
-        /* Our data is a pointer to a whole external collection so dereference it or delete */
+        /* Our data is a pointer to a whole external collection so dereference
+         * it or delete */
         other_collection = *((struct collection_item **)(ci->data));
         destroy_collection(other_collection);
     }
 
     /* Delete this item */
     delete_item(ci);
-    TRACE_FLOW_STRING("delete_collection","Exit.");
+    TRACE_FLOW_STRING("delete_collection", "Exit.");
 }
 
 
@@ -408,21 +419,21 @@ static int create_path_data(struct path_data **name_path,
     int error = EOK;
     struct path_data *new_name_path;
 
-    TRACE_FLOW_STRING("create_path_data","Entry.");
+    TRACE_FLOW_STRING("create_path_data", "Entry.");
 
-    TRACE_INFO_STRING("Constructing path from name:",name);
-    TRACE_INFO_STRING("Constructing path from property:",property);
+    TRACE_INFO_STRING("Constructing path from name:", name);
+    TRACE_INFO_STRING("Constructing path from property:", property);
 
     /* Allocate structure */
     errno = 0;
-    new_name_path = (struct path_data *)(malloc(sizeof(struct path_data)));
-    if(new_name_path == (struct path_data *)(NULL)) return errno;
+    new_name_path = (struct path_data *)malloc(sizeof(struct path_data));
+    if (new_name_path == NULL) return errno;
 
-    new_name_path->name=malloc(length+property_len+2);
-    if(new_name_path->name == NULL) {
+    new_name_path->name = malloc(length + property_len + 2);
+    if (new_name_path->name == NULL) {
         error = errno;
-        TRACE_ERROR_NUMBER("Failed to allocate memory for new path name. Errno",error);
-        free((void *)(new_name_path));
+        TRACE_ERROR_NUMBER("Failed to allocate memory for new path name. Errno", error);
+        free(new_name_path);
         return error;
     }
 
@@ -430,26 +441,26 @@ static int create_path_data(struct path_data **name_path,
     new_name_path->length = 0;
 
     if(length > 0) {
-        memcpy(new_name_path->name,name,length);
+        memcpy(new_name_path->name, name, length);
         new_name_path->length = length;
-        *(new_name_path->name+new_name_path->length) = '.';
+        new_name_path->name[new_name_path->length] = '.';
         new_name_path->length++;
-        *(new_name_path->name+new_name_path->length) = '\0';
-        TRACE_INFO_STRING("Name so far:",new_name_path->name);
-        TRACE_INFO_NUMBER("Len so far:",new_name_path->length);
+        new_name_path->name[new_name_path->length] = '\0';
+        TRACE_INFO_STRING("Name so far:", new_name_path->name);
+        TRACE_INFO_NUMBER("Len so far:", new_name_path->length);
     }
-    memcpy(new_name_path->name+new_name_path->length,property,property_len);
+    memcpy(&new_name_path->name[new_name_path->length], property, property_len);
     new_name_path->length += property_len;
-    *(new_name_path->name + new_name_path->length) = '\0';
+    new_name_path->name[new_name_path->length] = '\0';
 
     /* Link to the chain */
     new_name_path->previous_path = *name_path;
     *name_path = new_name_path;
 
-    TRACE_INFO_STRING("Constructed path",new_name_path->name);
+    TRACE_INFO_STRING("Constructed path", new_name_path->name);
 
 
-    TRACE_FLOW_NUMBER("create_path_data. Returning:",error);
+    TRACE_FLOW_NUMBER("create_path_data. Returning:", error);
     return error;
 }
 
@@ -462,13 +473,14 @@ static int match_item(struct collection_item *current,
     char *start;
     char *data_str;
 
-    TRACE_FLOW_STRING("match_item","Entry");
+    TRACE_FLOW_STRING("match_item", "Entry");
 
-    if(traverse_data->type_to_match & current->type) {
+    if (traverse_data->type_to_match & current->type) {
         /* Check if there is any value to match */
-        if((traverse_data->name_to_find == NULL) ||
-           (*(traverse_data->name_to_find) == '\0')) {
-            TRACE_INFO_STRING("match_item","Returning MATCH because there is no search criteria!");
+        if ((traverse_data->name_to_find == NULL) ||
+            (*(traverse_data->name_to_find) == '\0')) {
+            TRACE_INFO_STRING("match_item",
+                              "Returning MATCH because there is no search criteria!");
             return COL_MATCH;
         }
 
@@ -477,26 +489,27 @@ static int match_item(struct collection_item *current,
         start = current->property;
         data_str = start + current->property_len;
 
-        TRACE_INFO_STRING("Searching for:",traverse_data->name_to_find);
-        TRACE_INFO_STRING("Item name:",current->property);
-        TRACE_INFO_STRING("Current path:",traverse_data->current_path->name);
-        TRACE_INFO_NUMBER("Searching:",toupper(*find_str));
-        TRACE_INFO_NUMBER("Have:",toupper(*data_str));
+        TRACE_INFO_STRING("Searching for:", traverse_data->name_to_find);
+        TRACE_INFO_STRING("Item name:", current->property);
+        TRACE_INFO_STRING("Current path:", traverse_data->current_path->name);
+        TRACE_INFO_NUMBER("Searching:", toupper(*find_str));
+        TRACE_INFO_NUMBER("Have:", toupper(*data_str));
 
         /* We start pointing to 0 so the loop will be executed at least once */
-        while(toupper(*data_str) == toupper(*find_str)) {
+        while (toupper(*data_str) == toupper(*find_str)) {
 
             TRACE_INFO_STRING("Loop iteration:","");
 
-            if(data_str == start) {
-                if(find_str > traverse_data->name_to_find) {
-                    if(*(find_str-1) == '.') {
-                        /* We matched the property but the search string is longer */
-                        /* so we need to continue matching */
-                        TRACE_INFO_STRING("match_item","Need to continue matching");
+            if (data_str == start) {
+                if (find_str > traverse_data->name_to_find) {
+                    if (*(find_str-1) == '.') {
+                        /* We matched the property but the search string is
+                         * longer so we need to continue matching */
+                        TRACE_INFO_STRING("match_item",
+                                          "Need to continue matching");
                         start = traverse_data->current_path->name;
-                        data_str = start + traverse_data->current_path->length - 1;
-                        find_str-=2;
+                        data_str = &start[traverse_data->current_path->length - 1];
+                        find_str -= 2;
                         continue;
                     }
                     else {
@@ -509,13 +522,13 @@ static int match_item(struct collection_item *current,
                     return COL_MATCH;
                 }
             }
-            else if((find_str == traverse_data->name_to_find) &&
-                    (*(data_str-1) == '.')) return COL_MATCH;
+            else if ((find_str == traverse_data->name_to_find) &&
+                     (*(data_str-1) == '.')) return COL_MATCH;
 
             data_str--;
             find_str--;
-             TRACE_INFO_NUMBER("Searching:",toupper(*find_str));
-            TRACE_INFO_NUMBER("Have:",toupper(*data_str));
+             TRACE_INFO_NUMBER("Searching:", toupper(*find_str));
+            TRACE_INFO_NUMBER("Have:", toupper(*data_str));
 
         }
     }
@@ -530,20 +543,21 @@ static void delete_path_data(struct path_data *path)
 {
     TRACE_FLOW_STRING("delete_path_data","Entry.");
 
-    if(path!= (struct path_data *)(NULL)) {
-        TRACE_INFO_STRING("delete_path_data","Item to delete exits.");
-        if(path->previous_path != (struct path_data *)(NULL)) {
-            TRACE_INFO_STRING("delete_path_data","But previous item to delete exits to. Nesting.");
+    if (path != NULL) {
+        TRACE_INFO_STRING("delete_path_data", "Item to delete exits.");
+        if (path->previous_path != NULL) {
+            TRACE_INFO_STRING("delete_path_data",
+                              "But previous item to delete exits to. Nesting.");
             delete_path_data(path->previous_path);
         }
-        if(path->name != NULL) {
-            TRACE_INFO_STRING("delete_path_data Deleting path:",path->name);
+        if (path->name != NULL) {
+            TRACE_INFO_STRING("delete_path_data Deleting path:", path->name);
             free(path->name);
         }
-        TRACE_INFO_STRING("delete_path_data","Deleting path element");
-        free((void *)(path));
+        TRACE_INFO_STRING("delete_path_data", "Deleting path element");
+        free(path);
     }
-    TRACE_FLOW_STRING("delete_path_data","Exit");
+    TRACE_FLOW_STRING("delete_path_data", "Exit");
 }
 
 
@@ -567,71 +581,75 @@ static int walk_items(struct collection_item *ci,
     int stop = 0;
     int error = EOK;
 
-    TRACE_FLOW_STRING("walk_items","Entry.");
-    TRACE_INFO_NUMBER("Mode flags:",mode_flags);
+    TRACE_FLOW_STRING("walk_items", "Entry.");
+    TRACE_INFO_NUMBER("Mode flags:", mode_flags);
 
     current = ci;
 
-    while(current != (struct collection_item *)(NULL)) {
+    while (current) {
 
-        TRACE_INFO_STRING("Processing item:",current->property);
-        TRACE_INFO_NUMBER("Item type:",current->type);
+        TRACE_INFO_STRING("Processing item:", current->property);
+        TRACE_INFO_NUMBER("Item type:", current->type);
 
-        if(current->type == COL_TYPE_COLLECTIONREF) {
+        if (current->type == COL_TYPE_COLLECTIONREF) {
 
-            TRACE_INFO_STRING("Subcollection:",current->property);
+            TRACE_INFO_STRING("Subcollection:", current->property);
 
-            if((mode_flags & COL_TRAVERSE_IGNORE) == 0) {
+            if ((mode_flags & COL_TRAVERSE_IGNORE) == 0) {
 
-                TRACE_INFO_STRING("Subcollection is not ignored.","");
+                TRACE_INFO_STRING("Subcollection is not ignored.", "");
 
                 /* We are not ignoring sub collections */
-                error = traverse_handler(ci,parent,current,traverse_data,user_item_handler,custom_data,&stop);
-                if(stop != 0) {
-                    TRACE_INFO_STRING("Traverse handler returned STOP.","");
+                error = traverse_handler(ci, parent, current, traverse_data,
+                                         user_item_handler, custom_data, &stop);
+                if (stop != 0) {
+                    TRACE_INFO_STRING("Traverse handler returned STOP.", "");
                     error = EINTR_INTERNAL;
                 }
                 /* Check what error we got */
-                if(error == EINTR_INTERNAL) {
-                    TRACE_FLOW_NUMBER("Internal error - means we are stopping.",error);
+                if (error == EINTR_INTERNAL) {
+                    TRACE_FLOW_NUMBER("Internal error - means we are stopping.", error);
                     return error;
                 }
-                else if(error) {
-                    TRACE_ERROR_NUMBER("Traverse handler returned error.",error);
+                else if (error) {
+                    TRACE_ERROR_NUMBER("Traverse handler returned error.", error);
                     return error;
                 }
 
-                if((mode_flags & COL_TRAVERSE_ONELEVEL) == 0) {
+                if ((mode_flags & COL_TRAVERSE_ONELEVEL) == 0) {
                     TRACE_INFO_STRING("Before diving into sub collection","");
                     sub = *((struct collection_item **)(current->data));
-                    TRACE_INFO_STRING("Sub collection name",sub->property);
-                    TRACE_INFO_NUMBER("Header type",sub->type);
+                    TRACE_INFO_STRING("Sub collection name", sub->property);
+                    TRACE_INFO_NUMBER("Header type", sub->type);
                     /* We need to go into sub collections */
-                    error = walk_items(sub, mode_flags,traverse_handler,traverse_data,
+                    error = walk_items(sub, mode_flags,
+                                       traverse_handler, traverse_data,
                                        user_item_handler, custom_data);
-                    TRACE_INFO_STRING("Returned from sub collection processing","");
-                    TRACE_INFO_STRING("Done processing item:",current->property);
-                    TRACE_INFO_NUMBER("Done processing item type:",current->type);
+                    TRACE_INFO_STRING("Returned from sub collection processing", "");
+                    TRACE_INFO_STRING("Done processing item:", current->property);
+                    TRACE_INFO_NUMBER("Done processing item type:", current->type);
 
                 }
             }
         }
         else
             /* Call handler then move on */
-            error = traverse_handler(ci,parent,current,traverse_data,user_item_handler,custom_data,&stop);
+            error = traverse_handler(ci, parent, current,
+                                     traverse_data, user_item_handler,
+                                     custom_data, &stop);
 
         /* If we are stopped - return EINTR_INTERNAL */
-        if(stop != 0) {
-            TRACE_INFO_STRING("Traverse handler returned STOP.","");
+        if (stop != 0) {
+            TRACE_INFO_STRING("Traverse handler returned STOP.", "");
             error = EINTR_INTERNAL;
         }
         /* Check what error we got */
-        if(error == EINTR_INTERNAL) {
-            TRACE_FLOW_NUMBER("Internal error - means we are stopping.",error);
+        if (error == EINTR_INTERNAL) {
+            TRACE_FLOW_NUMBER("Internal error - means we are stopping.", error);
             return error;
         }
-        else if(error) {
-            TRACE_ERROR_NUMBER("Traverse handler returned error.",error);
+        else if (error) {
+            TRACE_ERROR_NUMBER("Traverse handler returned error.", error);
             return error;
         }
 
@@ -640,14 +658,16 @@ static int walk_items(struct collection_item *ci,
 
     }
 
-    TRACE_INFO_STRING("Out of loop","");
+    TRACE_INFO_STRING("Out of loop", "");
 
-    if((mode_flags & COL_TRAVERSE_END) != 0) {
-        TRACE_INFO_STRING("About to do the special end collection invocation of handler","");
-        error = traverse_handler(ci,parent,current,traverse_data,user_item_handler,custom_data,&stop);
+    if ((mode_flags & COL_TRAVERSE_END) != 0) {
+        TRACE_INFO_STRING("About to do the special end collection invocation of handler", "");
+        error = traverse_handler(ci, parent, current,
+                                 traverse_data, user_item_handler,
+                                 custom_data, &stop);
     }
 
-    TRACE_FLOW_NUMBER("walk_items. Returns: ",error);
+    TRACE_FLOW_NUMBER("walk_items. Returns: ", error);
     return error;
 }
 
@@ -670,62 +690,64 @@ static int find_item_and_do(struct collection_item *ci,
     int error = EOK;
     struct find_name *traverse_data = NULL;
 
-    TRACE_FLOW_STRING("find_item_and_do","Entry.");
+    TRACE_FLOW_STRING("find_item_and_do", "Entry.");
 
     /* Item handler is always required */
-    if((item_handler == (item_fn)(NULL)) && (action ==COLLECTION_ACTION_FIND)) {
-        TRACE_ERROR_NUMBER("No item handler - returning error!",EINVAL);
+    if ((item_handler == NULL) &&
+        (action == COLLECTION_ACTION_FIND)) {
+        TRACE_ERROR_NUMBER("No item handler - returning error!", EINVAL);
         return EINVAL;
     }
 
     /* Make sure that there is anything to search */
     type &= COL_TYPE_ANY;
-    if((ci == (struct collection_item *)(NULL)) ||
-       ((property_to_find == NULL) && (type == 0)) ||
-       ((*property_to_find == '\0') && (type == 0))) {
-        TRACE_ERROR_NUMBER("No item search criteria specified - returning error!",ENOKEY);
+    if ((ci == NULL) ||
+        ((property_to_find == NULL) && (type == 0)) ||
+        ((*property_to_find == '\0') && (type == 0))) {
+        TRACE_ERROR_NUMBER("No item search criteria specified - returning error!", ENOKEY);
         return ENOKEY;
     }
     /* Prepare data for traversal */
     errno = 0;
-    traverse_data= (struct find_name *)(malloc(sizeof(struct find_name)));
-    if(traverse_data == (struct find_name *)(NULL)) {
+    traverse_data= (struct find_name *)malloc(sizeof(struct find_name));
+    if (traverse_data == NULL) {
         error = errno;
-        TRACE_ERROR_NUMBER("Failed to allocate traverse data memory - returning error!",errno);
+        TRACE_ERROR_NUMBER("Failed to allocate traverse data memory - returning error!", errno);
         return error;
     }
 
-    TRACE_INFO_STRING("find_item_and_do","Filling in traverse data.");
+    TRACE_INFO_STRING("find_item_and_do", "Filling in traverse data.");
 
     traverse_data->name_to_find = property_to_find;
     traverse_data->name_len_to_find = strlen(property_to_find);
     traverse_data->type_to_match = type;
     traverse_data->given_name = NULL;
     traverse_data->given_len = 0;
-    traverse_data->current_path = (struct path_data *)(NULL);
+    traverse_data->current_path = NULL;
     traverse_data->action = action;
 
     mode_flags |= COL_TRAVERSE_END;
 
-    TRACE_INFO_STRING("find_item_and_do","About to walk the tree.");
-    TRACE_INFO_NUMBER("Traverse flags",mode_flags);
+    TRACE_INFO_STRING("find_item_and_do", "About to walk the tree.");
+    TRACE_INFO_NUMBER("Traverse flags", mode_flags);
 
     error = walk_items(ci, mode_flags, act_traverse_handler,
                        (void *)traverse_data, item_handler, custom_data);
 
-    if(traverse_data->current_path != (struct path_data *)(NULL)) {
-        TRACE_INFO_STRING("find_item_and_do","Path was not cleared - deleting");
+    if (traverse_data->current_path != NULL) {
+        TRACE_INFO_STRING("find_item_and_do",
+                          "Path was not cleared - deleting");
         delete_path_data(traverse_data->current_path);
     }
 
-    free((void *)(traverse_data));
+    free(traverse_data);
 
-    if((error) && (error != EINTR_INTERNAL)) {
-        TRACE_ERROR_NUMBER("Walk items returned error. Returning: ",error);
+    if (error && (error != EINTR_INTERNAL)) {
+        TRACE_ERROR_NUMBER("Walk items returned error. Returning: ", error);
         return error;
     }
     else {
-        TRACE_FLOW_STRING("Walk items returned SUCCESS.","");
+        TRACE_FLOW_STRING("Walk items returned SUCCESS.", "");
         return EOK;
     }
 }
@@ -734,30 +756,33 @@ static int find_item_and_do(struct collection_item *ci,
 static int update_current_item(struct collection_item *current,
                                struct update_property *update_data)
 {
-    TRACE_FLOW_STRING("update_current_item","Entry");
+    TRACE_FLOW_STRING("update_current_item", "Entry");
 
-    /* If type is different or same but it is string or binary we need to replace the storage */
-    if((current->type != update_data->type) ||
-       ((current->type == update_data->type) &&
-       ((current->type == COL_TYPE_STRING) || (current->type == COL_TYPE_BINARY)))) {
-        TRACE_INFO_STRING("Replacing item data buffer","");
+    /* If type is different or same but it is string or binary we need to
+     * replace the storage */
+    if ((current->type != update_data->type) ||
+        ((current->type == update_data->type) &&
+        ((current->type == COL_TYPE_STRING) ||
+         (current->type == COL_TYPE_BINARY)))) {
+        TRACE_INFO_STRING("Replacing item data buffer", "");
         free(current->data);
         current->data = malloc(update_data->length);
-        if(current->data == NULL) {
-            TRACE_ERROR_STRING("Failed to allocate memory","");
+        if (current->data == NULL) {
+            TRACE_ERROR_STRING("Failed to allocate memory", "");
             current->length = 0;
             return ENOMEM;
         }
         current->length = update_data->length;
     }
 
-    TRACE_INFO_STRING("Overwriting item data","");
-    memcpy(current->data,update_data->data,current->length);
+    TRACE_INFO_STRING("Overwriting item data", "");
+    memcpy(current->data, update_data->data, current->length);
     current->type = update_data->type;
 
-    if(current->type == COL_TYPE_STRING) *(((char *)(current->data))+current->length-1) = '\0';
+    if (current->type == COL_TYPE_STRING)
+        ((char *)(current->data))[current->length-1] = '\0';
 
-    TRACE_FLOW_STRING("update_current_item","Exit");
+    TRACE_FLOW_STRING("update_current_item", "Exit");
     return EOK;
 }
 
@@ -775,9 +800,9 @@ inline static int simple_traverse_handler(struct collection_item *head,
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("simple_traverse_handler","Entry.");
+    TRACE_FLOW_STRING("simple_traverse_handler", "Entry.");
 
-    if(current == (struct collection_item *)(NULL)) current = &dummy;
+    if (current == NULL) current = &dummy;
 
     error = user_item_handler(current->property,
                               current->property_len,
@@ -787,7 +812,7 @@ inline static int simple_traverse_handler(struct collection_item *head,
                               custom_data,
                               stop);
 
-    TRACE_FLOW_NUMBER("simple_traverse_handler. Returning:",error);
+    TRACE_FLOW_NUMBER("simple_traverse_handler. Returning:", error);
     return error;
 }
 
@@ -812,16 +837,17 @@ static int act_traverse_handler(struct collection_item *head,
     int property_len;
     struct update_property *update_data;
 
-    TRACE_FLOW_STRING("act_traverse_handler","Entry.");
+    TRACE_FLOW_STRING("act_traverse_handler", "Entry.");
 
-    traverse_data = (struct find_name *)(passed_traverse_data);
+    traverse_data = (struct find_name *)passed_traverse_data;
 
     /* We can be called when current points to NULL */
-    if(current==(struct collection_item *)(NULL)) {
-        TRACE_INFO_STRING("act_traverse_handler","Special call at the end of the collection.");
+    if (current == NULL) {
+        TRACE_INFO_STRING("act_traverse_handler",
+                          "Special call at the end of the collection.");
         temp = traverse_data->current_path;
         traverse_data->current_path = temp->previous_path;
-        temp->previous_path = (struct path_data *)(NULL);
+        temp->previous_path = NULL;
         delete_path_data(temp);
         traverse_data->given_name = NULL;
         traverse_data->given_len = 0;
@@ -830,24 +856,25 @@ static int act_traverse_handler(struct collection_item *head,
     }
 
     /* Create new path at the beginning of a new sub collection */
-    if(current->type == COL_TYPE_COLLECTION) {
+    if (current->type == COL_TYPE_COLLECTION) {
 
-        TRACE_INFO_STRING("act_traverse_handler","Processing collection handle.");
+        TRACE_INFO_STRING("act_traverse_handler",
+                          "Processing collection handle.");
 
         /* Create new path */
-        if(traverse_data->current_path != (struct path_data *)(NULL)) {
-            TRACE_INFO_STRING("Already have part of the path","");
-            name = (traverse_data->current_path)->name;
-            length = (traverse_data->current_path)->length;
-            TRACE_INFO_STRING("Path:",name);
-            TRACE_INFO_NUMBER("Path len:",length);
+        if (traverse_data->current_path != NULL) {
+            TRACE_INFO_STRING("Already have part of the path", "");
+            name = traverse_data->current_path->name;
+            length = traverse_data->current_path->length;
+            TRACE_INFO_STRING("Path:", name);
+            TRACE_INFO_NUMBER("Path len:", length);
         }
         else {
             name = NULL;
             length = 0;
         }
 
-        if(traverse_data->given_name != NULL) {
+        if (traverse_data->given_name != NULL) {
             property = traverse_data->given_name;
             property_len = traverse_data->given_len;
         }
@@ -856,101 +883,108 @@ static int act_traverse_handler(struct collection_item *head,
             property_len = current->property_len;
         }
 
-        TRACE_INFO_STRING("act_traverse_handler","About to create path data.");
+        TRACE_INFO_STRING("act_traverse_handler", "About to create path data.");
 
         error = create_path_data(&(traverse_data->current_path),
-                                 name, length, property,property_len);
+                                 name, length, property, property_len);
 
         TRACE_INFO_NUMBER("create_path_data returned:", error);
         return error;
     }
 
     /* Handle the collection pointers */
-    if(current->type == COL_TYPE_COLLECTIONREF) {
+    if (current->type == COL_TYPE_COLLECTIONREF) {
         traverse_data->given_name = current->property;
         traverse_data->given_len = current->property_len;
-        TRACE_INFO_STRING("Saved given name:",traverse_data->given_name);
+        TRACE_INFO_STRING("Saved given name:", traverse_data->given_name);
     }
 
-    TRACE_INFO_STRING("Processing item with property:",current->property);
+    TRACE_INFO_STRING("Processing item with property:", current->property);
 
     /* Do here what we do with items */
-    if(match_item(current,traverse_data)) {
-        TRACE_INFO_STRING("Matched item:",current->property);
-        switch(traverse_data->action) {
-            case COLLECTION_ACTION_FIND:
-                TRACE_INFO_STRING("It is a find action - calling handler.","");
-                if(user_item_handler != (item_fn)(NULL)) {
-                    /* Call user handler */
-                    error = user_item_handler(current->property,
-                                              current->property_len,
-                                              current->type,
-                                              current->data,
-                                              current->length,
-                                              custom_data,
-                                              stop);
-
-                    TRACE_INFO_NUMBER("Handler returned:",error);
-                    TRACE_INFO_NUMBER("Handler set STOP to:",*stop);
+    if (match_item(current, traverse_data)) {
+        TRACE_INFO_STRING("Matched item:", current->property);
+        switch (traverse_data->action) {
+        case COLLECTION_ACTION_FIND:
+            TRACE_INFO_STRING("It is a find action - calling handler.", "");
+            if (user_item_handler != NULL) {
+                /* Call user handler */
+                error = user_item_handler(current->property,
+                                          current->property_len,
+                                          current->type,
+                                          current->data,
+                                          current->length,
+                                          custom_data,
+                                          stop);
+
+                TRACE_INFO_NUMBER("Handler returned:", error);
+                TRACE_INFO_NUMBER("Handler set STOP to:", *stop);
 
-                }
-                break;
-            case COLLECTION_ACTION_GET:
-                TRACE_INFO_STRING("It is a get action.","");
-                if(custom_data != NULL) *((struct collection_item **)(custom_data)) = current;
-                break;
-            case COLLECTION_ACTION_DEL:
-                TRACE_INFO_STRING("It is a delete action.","");
-                /* Make sure we tell the caller we found a match */
-                if(custom_data != NULL) *(int *)(custom_data) = COL_MATCH;
-                /* Dereference external collections */
-                if(current->type == COL_TYPE_COLLECTIONREF) {
-                    TRACE_INFO_STRING("Dereferencing a referenced collection.","");
-                    other = *((struct collection_item **)(current->data));
-                    header = (struct collection_header *)(other->data);
-                    destroy_collection(other);
-                }
+            }
+            break;
 
-                /* Adjust header of the collection */
-                header = (struct collection_header *)(head->data);
-                (header->count)--;
-                if(current->next == (struct collection_item *)(NULL)) header->last = previous;
+        case COLLECTION_ACTION_GET:
+            TRACE_INFO_STRING("It is a get action.", "");
+            if (custom_data != NULL)
+                *((struct collection_item **)(custom_data)) = current;
+            break;
 
-                /* Unlink and delete iteam */
-                /* Previous can't be NULL here becuase we never delete header elements */
-                previous->next = current->next;
-                delete_item(current);
-                TRACE_INFO_STRING("Did the delete of the item.","");
-                break;
-            case COLLECTION_ACTION_UPDATE:
-                TRACE_INFO_STRING("It is an update action.","");
-                if((current->type == COL_TYPE_COLLECTION) ||
-                   (current->type == COL_TYPE_COLLECTIONREF)) {
-                    TRACE_ERROR_STRING("Can't update collections it is an error for now","");
-                    return EINVAL;
-                }
+        case COLLECTION_ACTION_DEL:
+            TRACE_INFO_STRING("It is a delete action.", "");
+            /* Make sure we tell the caller we found a match */
+            if (custom_data != NULL)
+                *(int *)custom_data = COL_MATCH;
+            /* Dereference external collections */
+            if (current->type == COL_TYPE_COLLECTIONREF) {
+                TRACE_INFO_STRING("Dereferencing a referenced collection.", "");
+                other = *((struct collection_item **)current->data);
+                header = (struct collection_header *)other->data;
+                destroy_collection(other);
+            }
 
-                /* Make sure we tell the caller we found a match */
-                if(custom_data != NULL) {
-                    update_data = (struct update_property *) custom_data;
-                    update_data-> found = COL_MATCH;
-                    error = update_current_item(current, update_data);
-                }
-                else {
-                    TRACE_ERROR_STRING("Error - update data is required","");
-                    return EINVAL;
-                }
+            /* Adjust header of the collection */
+            header = (struct collection_header *)head->data;
+            header->count--;
+            if (current->next == NULL)
+                header->last = previous;
+
+            /* Unlink and delete iteam */
+            /* Previous can't be NULL here becuase we never delete
+             * header elements */
+            previous->next = current->next;
+            delete_item(current);
+            TRACE_INFO_STRING("Did the delete of the item.", "");
+            break;
 
-                TRACE_INFO_STRING("Did the delete of the item.","");
-                break;
-            default:
-                break;
+        case COLLECTION_ACTION_UPDATE:
+            TRACE_INFO_STRING("It is an update action.", "");
+            if((current->type == COL_TYPE_COLLECTION) ||
+               (current->type == COL_TYPE_COLLECTIONREF)) {
+                TRACE_ERROR_STRING("Can't update collections it is an error for now", "");
+                return EINVAL;
+            }
+
+            /* Make sure we tell the caller we found a match */
+            if (custom_data != NULL) {
+                update_data = (struct update_property *)custom_data;
+                update_data->found = COL_MATCH;
+                error = update_current_item(current, update_data);
+            }
+            else {
+                TRACE_ERROR_STRING("Error - update data is required", "");
+                return EINVAL;
+            }
+
+            TRACE_INFO_STRING("Did the delete of the item.", "");
+            break;
+        default:
+            break;
         }
         /* Force interrupt if we found */
         *stop = 1;
     }
 
-    TRACE_FLOW_NUMBER("act_traverse_handler returning",error);
+    TRACE_FLOW_NUMBER("act_traverse_handler returning", error);
     return error;
 }
 
@@ -967,80 +1001,85 @@ static int copy_traverse_handler(struct collection_item *head,
     int error = EOK;
     struct collection_item *parent;
     struct collection_item *item;
-    struct collection_item *new_collection = (struct collection_item *)(NULL);
+    struct collection_item *new_collection = NULL;
 
-    TRACE_FLOW_STRING("copy_traverse_handler","Entry.");
+    TRACE_FLOW_STRING("copy_traverse_handler", "Entry.");
 
-    parent = (struct collection_item *)(passed_traverse_data);
+    parent = (struct collection_item *)passed_traverse_data;
 
     /* Skip current element but rather work with next if it is not NULL */
     item = current->next;
-    if(item == (struct collection_item *)(NULL)) return error;
+    if (item == NULL) return error;
 
 
     /* Check if this is a special case of sub collection */
-    if(item->type == COL_TYPE_COLLECTIONREF) {
-        TRACE_INFO_STRING("Found a subcollection we need to copy. Name:",item->property);
+    if (item->type == COL_TYPE_COLLECTIONREF) {
+        TRACE_INFO_STRING("Found a subcollection we need to copy. Name:",
+                          item->property);
 
         error = copy_collection(&new_collection,
                                 *((struct collection_item **)(item->data)),
                                 item->property);
-        if(error) {
-            TRACE_ERROR_NUMBER("Copy subcollection returned error:",error);
+        if (error) {
+            TRACE_ERROR_NUMBER("Copy subcollection returned error:", error);
             return error;
         }
 
-        /* Add new item to a collection - all references are now sub collections */
-        (void)add_property(parent,NULL,item->property,(void *)(&new_collection),
-                           sizeof(struct collection_item **),
-                           COL_TYPE_COLLECTIONREF, &error);
-        if(error) {
-            TRACE_ERROR_NUMBER("Add property returned error:",error);
+        /* Add new item to a collection
+         * all references are now sub collections */
+        add_property(parent, NULL, item->property,
+                     (void *)(&new_collection),
+                     sizeof(struct collection_item **),
+                     COL_TYPE_COLLECTIONREF, &error);
+        if (error) {
+            TRACE_ERROR_NUMBER("Add property returned error:", error);
             return error;
         }
     }
     else {
-        (void)add_property(parent,NULL,item->property,item->data,
-                           item->length,item->type,&error);
-        if(error) {
-            TRACE_ERROR_NUMBER("Add property returned error:",error);
+        add_property(parent, NULL, item->property,
+                     item->data, item->length, item->type, &error);
+        if (error) {
+            TRACE_ERROR_NUMBER("Add property returned error:", error);
             return error;
         }
     }
 
-    TRACE_FLOW_NUMBER("copy_traverse_handler returning",error);
+    TRACE_FLOW_NUMBER("copy_traverse_handler returning", error);
     return error;
 }
 
 
 
-/********************* MAIN INTERFACE FUNCTIONS ***********************************/
+/********************* MAIN INTERFACE FUNCTIONS *****************************/
 
 
 /* CREATE */
 
 /* Function that creates an named collection of a given class*/
-int create_collection(struct collection_item **ci,char *name, unsigned class)
+int create_collection(struct collection_item **ci, char *name, unsigned cclass)
 {
-    struct collection_item *handle = (struct collection_item *)(NULL);
+    struct collection_item *handle = NULL;
     struct collection_header header;
-    int error=EOK;
+    int error = EOK;
 
-    TRACE_FLOW_STRING("create_collection","Entry.");
+    TRACE_FLOW_STRING("create_collection", "Entry.");
 
     /* Prepare header */
-    header.last = (struct collection_item *)(NULL);
+    header.last = NULL;
     header.reference_count = 1;
     header.count = 0;
-    header.class = class;
+    header.cclass = cclass;
 
     /* Create a collection type property */
-    handle = add_property((struct collection_item *)(NULL),NULL,name,&header,sizeof(header), COL_TYPE_COLLECTION, &error);
-    if(error) return error;
+    handle = add_property(NULL, NULL, name,
+                          &header, sizeof(header),
+                          COL_TYPE_COLLECTION, &error);
+    if (error) return error;
 
     *ci = handle;
 
-    TRACE_FLOW_STRING("create_collection","Success Exit.");
+    TRACE_FLOW_STRING("create_collection", "Success Exit.");
     return 0;
 }
 
@@ -1052,28 +1091,31 @@ void destroy_collection(struct collection_item *ci)
 {
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("destroy_collection","Entry.");
+    TRACE_FLOW_STRING("destroy_collection", "Entry.");
 
     /* Do not try to delete NULL */
-    if(ci == (struct collection_item *)(NULL)) return;
+    if (ci == NULL) return;
 
     /* You can delete only whole collection not a part of it */
-    if(ci->type != COL_TYPE_COLLECTION) {
-        TRACE_ERROR_STRING("Attempt to delete a non collection - BAD!","");
-        TRACE_ERROR_NUMBER("Actual type is:",ci->type);
+    if (ci->type != COL_TYPE_COLLECTION) {
+        TRACE_ERROR_STRING("Attempt to delete a non collection - BAD!", "");
+        TRACE_ERROR_NUMBER("Actual type is:", ci->type);
         return;
     }
 
     /* Collection can be referenced by other collection */
     header = (struct collection_header *)(ci->data);
-    if(header->reference_count>1) {
-        TRACE_INFO_STRING("Dereferencing a referenced collection.","");
-        (header->reference_count)--;
-        TRACE_INFO_NUMBER("Number after dereferencing.",header->reference_count);
+    if (header->reference_count > 1) {
+        TRACE_INFO_STRING("Dereferencing a referenced collection.", "");
+        header->reference_count--;
+        TRACE_INFO_NUMBER("Number after dereferencing.",
+                          header->reference_count);
+    }
+    else {
+        delete_collection(ci);
     }
-    else delete_collection(ci);
 
-    TRACE_FLOW_STRING("destroy_collection","Exit.");
+    TRACE_FLOW_STRING("destroy_collection", "Exit.");
 }
 
 
@@ -1082,272 +1124,313 @@ void destroy_collection(struct collection_item *ci)
 /* Add a string property.
    If length equals 0, the length is determined based on the string.
    Lenght INCLUDES the terminating 0 */
-inline int add_str_property(struct collection_item *ci,char *subcollection, char *property,char *string,int length)
+inline int add_str_property(struct collection_item *ci, char *subcollection,
+                            char *property,char *string,int length)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_str_property","Entry.");
+    TRACE_FLOW_STRING("add_str_property", "Entry.");
+
+    if (length == 0)
+        length = strlen(string) + 1;
 
-    if(length == 0) length = strlen(string) + 1;
-    (void)(add_property(ci,subcollection,property,(void *)(string),length, COL_TYPE_STRING, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(string), length, COL_TYPE_STRING, &error);
 
-    TRACE_FLOW_NUMBER("add_str_property returning",error);
+    TRACE_FLOW_NUMBER("add_str_property returning", error);
     return error;
 }
 
 /* Add a binary property. */
-inline int add_binary_property(struct collection_item *ci,char *subcollection, char *property,void *binary_data,int length)
+inline int add_binary_property(struct collection_item *ci, char *subcollection,
+                               char *property, void *binary_data, int length)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_binary_property","Entry.");
+    TRACE_FLOW_STRING("add_binary_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,binary_data,length, COL_TYPE_BINARY, &error));
+    add_property(ci, subcollection, property,
+                 binary_data, length, COL_TYPE_BINARY, &error);
 
-    TRACE_FLOW_NUMBER("add_binary_property returning",error);
+    TRACE_FLOW_NUMBER("add_binary_property returning", error);
     return error;
 }
 
 /* Add an int property. */
-inline int add_int_property(struct collection_item *ci,char *subcollection, char *property,int number)
+inline int add_int_property(struct collection_item *ci, char *subcollection,
+                            char *property,int number)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_int_property","Entry.");
+    TRACE_FLOW_STRING("add_int_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_INTEGER, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&number), sizeof(int),
+                 COL_TYPE_INTEGER, &error);
 
-    TRACE_FLOW_NUMBER("add_int_property returning",error);
+    TRACE_FLOW_NUMBER("add_int_property returning", error);
     return error;
 }
 
 /* Add an unsigned int property. */
-inline int add_unsigned_property(struct collection_item *ci,char *subcollection, char *property,unsigned int number)
+inline int add_unsigned_property(struct collection_item *ci,
+                                 char *subcollection,
+                                 char *property, unsigned int number)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_unsigned_property","Entry.");
+    TRACE_FLOW_STRING("add_unsigned_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_UNSIGNED, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&number), sizeof(int), COL_TYPE_UNSIGNED, &error);
 
-    TRACE_FLOW_NUMBER("add_unsigned_property returning",error);
+    TRACE_FLOW_NUMBER("add_unsigned_property returning", error);
     return error;
 }
 
 /* Add an long property. */
-inline int add_long_property(struct collection_item *ci,char *subcollection, char *property,long number)
+inline int add_long_property(struct collection_item *ci, char *subcollection,
+                             char *property,long number)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_long_property","Entry.");
+    TRACE_FLOW_STRING("add_long_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_LONG, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&number), sizeof(long), COL_TYPE_LONG, &error);
 
-    TRACE_FLOW_NUMBER("add_long_property returning",error);
+    TRACE_FLOW_NUMBER("add_long_property returning", error);
     return error;
 }
 
 /* Add an unsigned long property. */
-inline int add_ulong_property(struct collection_item *ci,char *subcollection, char *property,unsigned long number)
+inline int add_ulong_property(struct collection_item *ci, char *subcollection,
+                              char *property, unsigned long number)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_ulong_property","Entry.");
+    TRACE_FLOW_STRING("add_ulong_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_ULONG, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&number), sizeof(long),
+                 COL_TYPE_ULONG, &error);
 
-    TRACE_FLOW_NUMBER("add_ulong_property returning",error);
+    TRACE_FLOW_NUMBER("add_ulong_property returning", error);
     return error;
 }
 
 /* Add a double property. */
-inline int add_double_property(struct collection_item *ci,char *subcollection, char *property,double number)
+inline int add_double_property(struct collection_item *ci, char *subcollection,
+                               char *property,double number)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_double_property","Entry.");
+    TRACE_FLOW_STRING("add_double_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(double), COL_TYPE_DOUBLE, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&number), sizeof(double), COL_TYPE_DOUBLE, &error);
 
-    TRACE_FLOW_NUMBER("add_double_property returning",error);
+    TRACE_FLOW_NUMBER("add_double_property returning", error);
     return error;
 }
 
 /* Add a bool property. */
-inline int add_bool_property(struct collection_item *ci,char *subcollection, char *property,unsigned char logical)
+inline int add_bool_property(struct collection_item *ci, char *subcollection,
+                             char *property,unsigned char logical)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_bool_property","Entry.");
+    TRACE_FLOW_STRING("add_bool_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,(void *)(&logical),sizeof(unsigned char), COL_TYPE_BOOL, &error));
+    add_property(ci, subcollection, property,
+                 (void *)(&logical), sizeof(unsigned char),
+                 COL_TYPE_BOOL, &error);
 
-    TRACE_FLOW_NUMBER("add_bool_property returning",error);
+    TRACE_FLOW_NUMBER("add_bool_property returning", error);
     return error;
 }
 
 /* A function to add a property */
 inline int add_any_property(struct collection_item *ci,
-                            char *subcollection,
-                            char *property,
-                            int type,
-                            void *data,
-                            int length)
+                            char *subcollection, char *property,
+                            int type, void *data, int length)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_any_property","Entry.");
+    TRACE_FLOW_STRING("add_any_property", "Entry.");
 
-    (void)(add_property(ci,subcollection,property,data,length, type, &error));
+    add_property(ci, subcollection, property, data, length, type, &error);
 
-    TRACE_FLOW_NUMBER("add_any_property returning",error);
+    TRACE_FLOW_NUMBER("add_any_property returning", error);
     return error;
 }
 
 /* Add a string property.
    If length equals 0, the length is determined based on the string.
    Lenght INCLUDES the terminating 0 */
-inline int add_str_property_with_ref(struct collection_item *ci,char *subcollection,
-                                     char *property,char *string,int length,
+inline int add_str_property_with_ref(struct collection_item *ci,
+                                     char *subcollection, char *property,
+                                     char *string, int length,
                                      struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_str_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_str_property_with_ref", "Entry.");
 
-    if(length == 0) length = strlen(string) + 1;
-    item = add_property(ci,subcollection,property,(void *)(string),length, COL_TYPE_STRING, &error);
+    if (length == 0) length = strlen(string) + 1;
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    item = add_property(ci, subcollection, property,
+                        (void *)(string), length, COL_TYPE_STRING, &error);
 
-    TRACE_FLOW_NUMBER("add_str_property_with_ref returning",error);
+    if (ref_ret != NULL) *ref_ret = item;
+
+    TRACE_FLOW_NUMBER("add_str_property_with_ref returning", error);
     return error;
 }
 
 /* Add a binary property. */
-inline int add_binary_property_with_ref(struct collection_item *ci,char *subcollection,
-                                        char *property,void *binary_data,int length,
+inline int add_binary_property_with_ref(struct collection_item *ci,
+                                        char *subcollection, char *property,
+                                        void *binary_data, int length,
                                         struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_binary_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_binary_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,binary_data,length, COL_TYPE_BINARY, &error);
+    item = add_property(ci, subcollection, property,
+                        binary_data, length, COL_TYPE_BINARY, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_binary_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_binary_property_with_ref returning", error);
     return error;
 }
 
 /* Add an int property. */
-inline int add_int_property_with_ref(struct collection_item *ci,char *subcollection,
-                                     char *property,int number,
+inline int add_int_property_with_ref(struct collection_item *ci,
+                                     char *subcollection, char *property,
+                                     int number,
                                      struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_int_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_int_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_INTEGER, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&number), sizeof(int),
+                        COL_TYPE_INTEGER, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_int_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_int_property_with_ref returning", error);
     return error;
 }
 
 /* Add an unsigned int property. */
-inline int add_unsigned_property_with_ref(struct collection_item *ci,char *subcollection,
-                                          char *property,unsigned int number,
+inline int add_unsigned_property_with_ref(struct collection_item *ci,
+                                          char *subcollection, char *property,
+                                          unsigned int number,
                                           struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_unsigned_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_unsigned_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_UNSIGNED, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&number), sizeof(int),
+                        COL_TYPE_UNSIGNED, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_unsigned_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_unsigned_property_with_ref returning", error);
     return error;
 }
 
 /* Add an long property. */
-inline int add_long_property_with_ref(struct collection_item *ci,char *subcollection,
-                                      char *property,long number,
+inline int add_long_property_with_ref(struct collection_item *ci,
+                                      char *subcollection, char *property,
+                                      long number,
                                       struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_long_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_long_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_LONG, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&number), sizeof(long), COL_TYPE_LONG, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_long_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_long_property_with_ref returning", error);
     return error;
 }
 
 /* Add an unsigned long property. */
-inline int add_ulong_property_with_ref(struct collection_item *ci,char *subcollection,
-                                       char *property,unsigned long number,
+inline int add_ulong_property_with_ref(struct collection_item *ci,
+                                       char *subcollection, char *property,
+                                       unsigned long number,
                                        struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_ulong_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_ulong_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_ULONG, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&number), sizeof(long),
+                        COL_TYPE_ULONG, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_ulong_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_ulong_property_with_ref returning", error);
     return error;
 }
 
 /* Add a double property. */
-inline int add_double_property_with_ref(struct collection_item *ci,char *subcollection,
-                                        char *property,double number,
+inline int add_double_property_with_ref(struct collection_item *ci,
+                                        char *subcollection, char *property,
+                                        double number,
                                         struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_double_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_double_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&number),sizeof(double), COL_TYPE_DOUBLE, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&number), sizeof(double),
+                        COL_TYPE_DOUBLE, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_double_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_double_property_with_ref returning", error);
     return error;
 }
 
 /* Add a bool property. */
-inline int add_bool_property_with_ref(struct collection_item *ci,char *subcollection,
-                                      char *property,unsigned char logical,
+inline int add_bool_property_with_ref(struct collection_item *ci,
+                                      char *subcollection, char *property,
+                                      unsigned char logical,
                                       struct collection_item **ref_ret)
 {
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_bool_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_bool_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,(void *)(&logical),sizeof(unsigned char), COL_TYPE_BOOL, &error);
+    item = add_property(ci, subcollection, property,
+                        (void *)(&logical), sizeof(unsigned char),
+                        COL_TYPE_BOOL, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_bool_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_bool_property_with_ref returning", error);
     return error;
 }
 
@@ -1363,13 +1446,14 @@ inline int add_any_property_with_ref(struct collection_item *ci,
     int error = EOK;
     struct collection_item *item;
 
-    TRACE_FLOW_STRING("add_any_property_with_ref","Entry.");
+    TRACE_FLOW_STRING("add_any_property_with_ref", "Entry.");
 
-    item = add_property(ci,subcollection,property,data,length, type, &error);
+    item = add_property(ci, subcollection, property,
+                        data, length, type, &error);
 
-    if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item;
+    if (ref_ret != NULL) *ref_ret = item;
 
-    TRACE_FLOW_NUMBER("add_any_property_with_ref returning",error);
+    TRACE_FLOW_NUMBER("add_any_property_with_ref returning", error);
     return error;
 }
 
@@ -1381,35 +1465,37 @@ inline int add_any_property_with_ref(struct collection_item *ci,
 /* Referenced collections of the donor are copied as sub collections. */
 int copy_collection(struct collection_item **collection_copy,
                     struct collection_item *collection_to_copy,
-                    char *name_to_use) {
-
+                    char *name_to_use)
+{
     int error = EOK;
-    struct collection_item *new_collection = (struct collection_item *)(NULL);
+    struct collection_item *new_collection = NULL;
     char *name;
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("copy_collection","Entry.");
+    TRACE_FLOW_STRING("copy_collection", "Entry.");
 
     /* Determine what name to use */
-    if(name_to_use != NULL) name = name_to_use;
-    else name = collection_to_copy->property;
+    if (name_to_use != NULL)
+        name = name_to_use;
+    else
+        name = collection_to_copy->property;
 
-    header = (struct collection_header *)(collection_to_copy->data);
+    header = (struct collection_header *)collection_to_copy->data;
 
     /* Create a new collection */
-    error = create_collection(&new_collection,name,header->class);
-    if(error) {
-        TRACE_ERROR_NUMBER("Create_cllection failed returning",error);
+    error = create_collection(&new_collection, name, header->cclass);
+    if (error) {
+        TRACE_ERROR_NUMBER("Create_cllection failed returning", error);
         return error;
     }
 
-    error = walk_items(collection_to_copy, COL_TRAVERSE_ONELEVEL, copy_traverse_handler,
-                       new_collection, NULL, NULL);
+    error = walk_items(collection_to_copy, COL_TRAVERSE_ONELEVEL,
+                       copy_traverse_handler, new_collection, NULL, NULL);
 
-    if(!error) *collection_copy = new_collection;
+    if (!error) *collection_copy = new_collection;
     else destroy_collection(new_collection);
 
-    TRACE_FLOW_NUMBER("copy_collection returning",error);
+    TRACE_FLOW_NUMBER("copy_collection returning", error);
     return error;
 
 }
@@ -1422,42 +1508,46 @@ int get_collection_reference(struct collection_item *ci,          /* High level
                              char *collection_to_find)            /* Name to of the collection */
 {
     struct collection_header *header;
-    struct collection_item *subcollection = (struct collection_item *)(NULL);
+    struct collection_item *subcollection = NULL;
     int error = EOK;
 
-    TRACE_FLOW_STRING("get_collection_reference","Entry.");
+    TRACE_FLOW_STRING("get_collection_reference", "Entry.");
 
-    if((ci == (struct collection_item *)(NULL)) ||
-       (ci->type != COL_TYPE_COLLECTION) ||
-       (acceptor == (struct collection_item **)(NULL)) ||
-       (collection_to_find == NULL)) {
+    if ((ci == NULL) ||
+        (ci->type != COL_TYPE_COLLECTION) ||
+        (acceptor == NULL) ||
+        (collection_to_find == NULL)) {
         TRACE_ERROR_NUMBER("Invalid parameter - returning error",EINVAL);
         return EINVAL;
     }
 
     /* Find a sub collection */
-    TRACE_INFO_STRING("We are given subcollection name - search it:",collection_to_find);
-    error = find_item_and_do(ci,collection_to_find,COL_TYPE_COLLECTIONREF,
+    TRACE_INFO_STRING("We are given subcollection name - search it:",
+                      collection_to_find);
+    error = find_item_and_do(ci, collection_to_find,
+                             COL_TYPE_COLLECTIONREF,
                              COL_TRAVERSE_DEFAULT,
-                             get_subcollection,(void *)(&subcollection),COLLECTION_ACTION_FIND);
-    if(error) {
-        TRACE_ERROR_NUMBER("Search failed returning error",error);
+                             get_subcollection,
+                             (void *)(&subcollection),
+                             COLLECTION_ACTION_FIND);
+    if (error) {
+        TRACE_ERROR_NUMBER("Search failed returning error", error);
         return error;
     }
 
-    if(subcollection == (struct collection_item *)(NULL)) {
-        TRACE_ERROR_STRING("Search for subcollection returned NULL pointer","");
+    if (subcollection == NULL) {
+        TRACE_ERROR_STRING("Search for subcollection returned NULL pointer", "");
         return ENOENT;
     }
 
-    header = (struct collection_header *)(subcollection->data);
-    TRACE_INFO_NUMBER("Count:",header->count);
-    TRACE_INFO_NUMBER("Ref count:",header->reference_count);
-    (header->reference_count)++;
-    TRACE_INFO_NUMBER("Ref count after increment:",header->reference_count);
+    header = (struct collection_header *)subcollection->data;
+    TRACE_INFO_NUMBER("Count:", header->count);
+    TRACE_INFO_NUMBER("Ref count:", header->reference_count);
+    header->reference_count++;
+    TRACE_INFO_NUMBER("Ref count after increment:", header->reference_count);
     *acceptor = subcollection;
 
-    TRACE_FLOW_STRING("get_collection_reference","Success Exit.");
+    TRACE_FLOW_STRING("get_collection_reference", "Success Exit.");
     return EOK;
 }
 
@@ -1466,27 +1556,27 @@ int get_reference_from_item(struct collection_item *ci,
                             struct collection_item **acceptor)
 {
     struct collection_header *header;
-    struct collection_item *subcollection = (struct collection_item *)(NULL);
+    struct collection_item *subcollection = NULL;
 
-    TRACE_FLOW_STRING("get_reference_from_item","Entry.");
+    TRACE_FLOW_STRING("get_reference_from_item", "Entry.");
 
-    if((ci == (struct collection_item *)(NULL)) ||
-       (ci->type != COL_TYPE_COLLECTIONREF) ||
-       (acceptor == (struct collection_item **)(NULL))) {
+    if ((ci == NULL) ||
+        (ci->type != COL_TYPE_COLLECTIONREF) ||
+        (acceptor == NULL)) {
         TRACE_ERROR_NUMBER("Invalid parameter - returning error",EINVAL);
         return EINVAL;
     }
 
-    subcollection = *((struct collection_item **)(ci->data));
+    subcollection = *((struct collection_item **)ci->data);
 
-    header = (struct collection_header *)(subcollection->data);
-    TRACE_INFO_NUMBER("Count:",header->count);
-    TRACE_INFO_NUMBER("Ref count:",header->reference_count);
-    (header->reference_count)++;
-    TRACE_INFO_NUMBER("Ref count after increment:",header->reference_count);
+    header = (struct collection_header *)subcollection->data;
+    TRACE_INFO_NUMBER("Count:", header->count);
+    TRACE_INFO_NUMBER("Ref count:", header->reference_count);
+    header->reference_count++;
+    TRACE_INFO_NUMBER("Ref count after increment:", header->reference_count);
     *acceptor = subcollection;
 
-    TRACE_FLOW_STRING("get_reference_from_item","Success Exit.");
+    TRACE_FLOW_STRING("get_reference_from_item", "Success Exit.");
     return EOK;
 }
 
@@ -1504,121 +1594,143 @@ int add_collection_to_collection(
    struct collection_item *collection_to_add, /* Collection to add */
    int mode)                                  /* How this collection needs to be added */
 {
-    struct collection_item *acceptor = (struct collection_item *)(NULL);
+    struct collection_item *acceptor = NULL;
     char *name_to_use;
     struct collection_header *header;
     struct collection_item *collection_copy;
     int error = EOK;
 
-    TRACE_FLOW_STRING("add_collection_to_collection","Entry.");
+    TRACE_FLOW_STRING("add_collection_to_collection", "Entry.");
 
-    if((ci == (struct collection_item *)(NULL)) ||
-       (ci->type != COL_TYPE_COLLECTION) ||
-       (collection_to_add == (struct collection_item *)(NULL)) ||
-       (collection_to_add->type != COL_TYPE_COLLECTION)) {
+    if ((ci == NULL) ||
+        (ci->type != COL_TYPE_COLLECTION) ||
+        (collection_to_add == NULL) ||
+        (collection_to_add->type != COL_TYPE_COLLECTION)) {
         /* Need to debug here */
-        TRACE_ERROR_NUMBER("Missing parameter - returning error",EINVAL);
+        TRACE_ERROR_NUMBER("Missing parameter - returning error", EINVAL);
         return EINVAL;
     }
 
-    if(sub_collection_name != NULL) {
+    if (sub_collection_name != NULL) {
         /* Find a sub collection */
-        TRACE_INFO_STRING("We are given subcollection name - search it:",sub_collection_name);
-        error = find_item_and_do(ci,sub_collection_name,COL_TYPE_COLLECTIONREF,
+        TRACE_INFO_STRING("We are given subcollection name - search it:",
+                          sub_collection_name);
+        error = find_item_and_do(ci, sub_collection_name,
+                                 COL_TYPE_COLLECTIONREF,
                                  COL_TRAVERSE_DEFAULT,
-                                 get_subcollection,(void *)(&acceptor),COLLECTION_ACTION_FIND);
-        if(error) {
-            TRACE_ERROR_NUMBER("Search failed returning error",error);
+                                 get_subcollection,
+                                 (void *)(&acceptor),
+                                 COLLECTION_ACTION_FIND);
+        if (error) {
+            TRACE_ERROR_NUMBER("Search failed returning error", error);
             return error;
         }
 
-        if(acceptor == (struct collection_item *)(NULL)) {
-            TRACE_ERROR_STRING("Search for subcollection returned NULL pointer","");
+        if (acceptor == NULL) {
+            TRACE_ERROR_STRING("Search for subcollection returned NULL pointer", "");
             return ENOENT;
         }
 
     }
-    else acceptor = ci;
+    else {
+        acceptor = ci;
+    }
 
-    if(as_property != NULL)
+    if (as_property != NULL)
         name_to_use = as_property;
     else
         name_to_use = collection_to_add->property;
 
 
-    TRACE_INFO_STRING("Going to use name:",name_to_use);
-
-
-    switch(mode) {
-        case COL_ADD_MODE_REFERENCE:
-            TRACE_INFO_STRING("We are adding a reference.","");
-            TRACE_INFO_NUMBER("Type of the header element:",collection_to_add->type);
-            TRACE_INFO_STRING("Header name we are adding.",collection_to_add->property);
-            /* Create a pointer to external collection */
-            /* For future thread safety: Transaction start -> */
-            (void)(add_property(acceptor,NULL,name_to_use,(void *)(&collection_to_add),
-                                sizeof(struct collection_item **),
-                                COL_TYPE_COLLECTIONREF, &error));
-
-            TRACE_INFO_NUMBER("Type of the header element after add_property:",collection_to_add->type);
-            TRACE_INFO_STRING("Header name we just added.",collection_to_add->property);
-            if(error) {
-                TRACE_ERROR_NUMBER("Adding property failed with error:",error);
-                return error;
-            }
-            header = (struct collection_header *)(collection_to_add->data);
-            TRACE_INFO_NUMBER("Count:",header->count);
-            TRACE_INFO_NUMBER("Ref count:",header->reference_count);
-            (header->reference_count)++;
-            TRACE_INFO_NUMBER("Ref count after increment:",header->reference_count);
-            /* -> Transaction end */
-            break;
-        case COL_ADD_MODE_EMBED:
-            TRACE_INFO_STRING("We are embedding the collection.","");
-            /* First check if the passed in collection is referenced more than once */
-            TRACE_INFO_NUMBER("Type of the header element we are adding:",collection_to_add->type);
-            TRACE_INFO_STRING("Header name we are adding.",collection_to_add->property);
-            TRACE_INFO_NUMBER("Type of the header element we are adding to:",acceptor->type);
-            TRACE_INFO_STRING("Header name we are adding to.",acceptor->property);
-
-            (void)(add_property(acceptor,NULL,name_to_use,(void *)(&collection_to_add),
-                                sizeof(struct collection_item **),
-                                COL_TYPE_COLLECTIONREF, &error));
-
-            TRACE_INFO_NUMBER("Adding property returned:",error);
-            break;
-
-        case COL_ADD_MODE_CLONE:
-            TRACE_INFO_STRING("We are cloning the collection.","");
-            TRACE_INFO_STRING("Name we will use.",name_to_use);
-
-            /* For future thread safety: Transaction start -> */
-            error = copy_collection(&collection_copy, collection_to_add, name_to_use);
-            if(error) return error;
-
-            TRACE_INFO_STRING("We have a collection copy.", collection_copy->property);
-            TRACE_INFO_NUMBER("Collection type.", collection_copy->type);
-            TRACE_INFO_STRING("Acceptor collection.", acceptor->property);
-            TRACE_INFO_NUMBER("Acceptor collection type.", acceptor->type);
-
-            (void)(add_property(acceptor,NULL,name_to_use,(void *)(&collection_copy),
-                                sizeof(struct collection_item **),
-                                COL_TYPE_COLLECTIONREF, &error));
-
-            /* -> Transaction end */
-            TRACE_INFO_NUMBER("Adding property returned:",error);
-            break;
-
-        default: error = EINVAL;
-    }
-
-    TRACE_FLOW_NUMBER("add_collection_to_collection returning:",error);
+    TRACE_INFO_STRING("Going to use name:", name_to_use);
+
+
+    switch (mode) {
+    case COL_ADD_MODE_REFERENCE:
+        TRACE_INFO_STRING("We are adding a reference.", "");
+        TRACE_INFO_NUMBER("Type of the header element:",
+                          collection_to_add->type);
+        TRACE_INFO_STRING("Header name we are adding.",
+                          collection_to_add->property);
+        /* Create a pointer to external collection */
+        /* For future thread safety: Transaction start -> */
+        add_property(acceptor, NULL, name_to_use,
+                     (void *)(&collection_to_add),
+                     sizeof(struct collection_item **),
+                     COL_TYPE_COLLECTIONREF, &error);
+
+        TRACE_INFO_NUMBER("Type of the header element after add_property:",
+                          collection_to_add->type);
+        TRACE_INFO_STRING("Header name we just added.",
+                          collection_to_add->property);
+        if (error) {
+            TRACE_ERROR_NUMBER("Adding property failed with error:", error);
+            return error;
+        }
+        header = (struct collection_header *)collection_to_add->data;
+        TRACE_INFO_NUMBER("Count:", header->count);
+        TRACE_INFO_NUMBER("Ref count:", header->reference_count);
+        header->reference_count++;
+        TRACE_INFO_NUMBER("Ref count after increment:",
+                          header->reference_count);
+        /* -> Transaction end */
+        break;
+
+    case COL_ADD_MODE_EMBED:
+        TRACE_INFO_STRING("We are embedding the collection.", "");
+        /* First check if the passed in collection is referenced more than once */
+        TRACE_INFO_NUMBER("Type of the header element we are adding:",
+                          collection_to_add->type);
+        TRACE_INFO_STRING("Header name we are adding.",
+                          collection_to_add->property);
+        TRACE_INFO_NUMBER("Type of the header element we are adding to:",
+                          acceptor->type);
+        TRACE_INFO_STRING("Header name we are adding to.",
+                          acceptor->property);
+
+        add_property(acceptor, NULL, name_to_use,
+                     (void *)(&collection_to_add),
+                     sizeof(struct collection_item **),
+                     COL_TYPE_COLLECTIONREF, &error);
+
+        TRACE_INFO_NUMBER("Adding property returned:", error);
+        break;
+
+    case COL_ADD_MODE_CLONE:
+        TRACE_INFO_STRING("We are cloning the collection.", "");
+        TRACE_INFO_STRING("Name we will use.", name_to_use);
+
+        /* For future thread safety: Transaction start -> */
+        error = copy_collection(&collection_copy,
+                                collection_to_add, name_to_use);
+        if (error) return error;
+
+        TRACE_INFO_STRING("We have a collection copy.", collection_copy->property);
+        TRACE_INFO_NUMBER("Collection type.", collection_copy->type);
+        TRACE_INFO_STRING("Acceptor collection.", acceptor->property);
+        TRACE_INFO_NUMBER("Acceptor collection type.", acceptor->type);
+
+        add_property(acceptor, NULL, name_to_use,
+                     (void *)(&collection_copy),
+                     sizeof(struct collection_item **),
+                     COL_TYPE_COLLECTIONREF, &error);
+
+        /* -> Transaction end */
+        TRACE_INFO_NUMBER("Adding property returned:", error);
+        break;
+
+    default:
+        error = EINVAL;
+    }
+
+    TRACE_FLOW_NUMBER("add_collection_to_collection returning:", error);
     return error;
 }
 
 /* TRAVERSING */
 
-/* Function to traverse the entire collection including optionally sub collections */
+/* Function to traverse the entire collection including optionally
+ * sub collections */
 inline int traverse_collection(struct collection_item *ci,
                                int mode_flags,
                                item_fn item_handler,
@@ -1626,17 +1738,17 @@ inline int traverse_collection(struct collection_item *ci,
 {
 
     int error = EOK;
-    TRACE_FLOW_STRING("traverse_collection","Entry.");
+    TRACE_FLOW_STRING("traverse_collection", "Entry.");
 
     error = walk_items(ci, mode_flags, simple_traverse_handler,
                        NULL, item_handler, custom_data);
 
-    if((error != 0) && (error != EINTR_INTERNAL)) {
-        TRACE_ERROR_NUMBER("Error walking tree",error);
+    if ((error != 0) && (error != EINTR_INTERNAL)) {
+        TRACE_ERROR_NUMBER("Error walking tree", error);
         return error;
     }
 
-    TRACE_FLOW_STRING("traverse_collection","Success exit.");
+    TRACE_FLOW_STRING("traverse_collection", "Success exit.");
     return EOK;
 }
 
@@ -1654,10 +1766,13 @@ inline int is_item_in_collection(struct collection_item *ci,
     TRACE_FLOW_STRING("is_item_in_collection","Entry.");
 
     *found = COL_NOMATCH;
-    error = find_item_and_do(ci,property_to_find,type,mode_flags,
-                             is_in_item_handler,(void *)found,COLLECTION_ACTION_FIND);
+    error = find_item_and_do(ci, property_to_find,
+                             type, mode_flags,
+                             is_in_item_handler,
+                             (void *)found,
+                             COLLECTION_ACTION_FIND);
 
-    TRACE_FLOW_NUMBER("is_item_in_collection returning",error);
+    TRACE_FLOW_NUMBER("is_item_in_collection returning", error);
     return error;
 }
 
@@ -1676,9 +1791,13 @@ inline int get_item_and_do(struct collection_item *ci,       /* Collection to fi
 
     TRACE_FLOW_STRING("get_item_and_do","Entry.");
 
-    error = find_item_and_do(ci,property_to_find,type,mode_flags,item_handler,custom_data,COLLECTION_ACTION_FIND);
+    error = find_item_and_do(ci, property_to_find,
+                             type, mode_flags,
+                             item_handler,
+                             custom_data,
+                             COLLECTION_ACTION_FIND);
 
-    TRACE_FLOW_NUMBER("get_item_and_do returning",error);
+    TRACE_FLOW_NUMBER("get_item_and_do returning", error);
     return error;
 }
 
@@ -1693,11 +1812,14 @@ inline int get_item(struct collection_item *ci,       /* Collection to find thin
 
     int error = EOK;
 
-    TRACE_FLOW_STRING("get_item","Entry.");
+    TRACE_FLOW_STRING("get_item", "Entry.");
 
-    error = find_item_and_do(ci,property_to_find,type,mode_flags,NULL,(void *)(item),COLLECTION_ACTION_GET);
+    error = find_item_and_do(ci, property_to_find,
+                             type, mode_flags,
+                             NULL, (void *)item,
+                             COLLECTION_ACTION_GET);
 
-    TRACE_FLOW_NUMBER("get_item returning",error);
+    TRACE_FLOW_NUMBER("get_item returning", error);
     return error;
 }
 
@@ -1711,13 +1833,18 @@ inline int delete_property(struct collection_item *ci,    /* Collection to find
     int error = EOK;
     int found;
 
-    TRACE_FLOW_STRING("delete_property","Entry.");
+    TRACE_FLOW_STRING("delete_property", "Entry.");
     found = COL_NOMATCH;
 
-    error = find_item_and_do(ci,property_to_find,type,mode_flags,NULL,(void *)(&found),COLLECTION_ACTION_DEL);
+    error = find_item_and_do(ci, property_to_find,
+                             type, mode_flags,
+                             NULL, (void *)(&found),
+                             COLLECTION_ACTION_DEL);
 
-    if((error == EOK) && (found == COL_NOMATCH)) error = ENOENT;
-    TRACE_FLOW_NUMBER("delete_property returning",error);
+    if ((error == EOK) && (found == COL_NOMATCH))
+        error = ENOENT;
+
+    TRACE_FLOW_NUMBER("delete_property returning", error);
     return error;
 }
 
@@ -1734,20 +1861,26 @@ int update_property(struct collection_item *ci,    /* Collection to find things
     int error = EOK;
     struct update_property update_data;
 
-    TRACE_FLOW_STRING("update_property","Entry.");
+    TRACE_FLOW_STRING("update_property", "Entry.");
     update_data.type = type;
     update_data.data = new_data;
     update_data.length = length;
     update_data.found = COL_NOMATCH;
 
-    error = find_item_and_do(ci,property_to_find,type,mode_flags,NULL,(void *)(&update_data),COLLECTION_ACTION_UPDATE);
+    error = find_item_and_do(ci, property_to_find,
+                             type, mode_flags,
+                             NULL, (void *)(&update_data),
+                             COLLECTION_ACTION_UPDATE);
+
+    if ((error == EOK) && (update_data.found == COL_NOMATCH))
+        error = ENOENT;
 
-    if((error == EOK) && (update_data.found == COL_NOMATCH)) error = ENOENT;
-    TRACE_FLOW_NUMBER("update_property returning",error);
+    TRACE_FLOW_NUMBER("update_property returning", error);
     return error;
 }
 
-/* Update a string property in the collection. Length should include the null terminating 0  */
+/* Update a string property in the collection.
+ * Length should include the terminating 0  */
 inline int update_str_property(struct collection_item *ci,
                                char *property,
                                int mode_flags,
@@ -1755,12 +1888,13 @@ inline int update_str_property(struct collection_item *ci,
                                int length)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_str_property","Entry.");
+    TRACE_FLOW_STRING("update_str_property", "Entry.");
 
-    if(length == 0) length = strlen(string) + 1;
-    error =  update_property(ci,property, COL_TYPE_STRING, (void *)(string),length,mode_flags);
+    if (length == 0) length = strlen(string) + 1;
+    error =  update_property(ci, property, COL_TYPE_STRING,
+                             (void *)string, length, mode_flags);
 
-    TRACE_FLOW_NUMBER("update_str_property Returning",error);
+    TRACE_FLOW_NUMBER("update_str_property Returning", error);
     return error;
 }
 
@@ -1772,11 +1906,12 @@ inline int update_binary_property(struct collection_item *ci,
                                   int length)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_binary_property","Entry.");
+    TRACE_FLOW_STRING("update_binary_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_BINARY, binary_data, length, mode_flags);
+    error =  update_property(ci, property, COL_TYPE_BINARY,
+                             binary_data, length, mode_flags);
 
-    TRACE_FLOW_NUMBER("update_binary_property Returning",error);
+    TRACE_FLOW_NUMBER("update_binary_property Returning", error);
     return error;
 }
 
@@ -1787,25 +1922,28 @@ inline int update_int_property(struct collection_item *ci,
                                int number)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_int_property","Entry.");
+    TRACE_FLOW_STRING("update_int_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_INTEGER, (void *)(&number), sizeof(int), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_INTEGER,
+                             (void *)(&number), sizeof(int), mode_flags);
 
-    TRACE_FLOW_NUMBER("update_int_property Returning",error);
+    TRACE_FLOW_NUMBER("update_int_property Returning", error);
     return error;
 }
 
 /* Update an unsigned int property. */
 inline int update_unsigned_property(struct collection_item *ci,
-                                    char *property,int mode_flags,
+                                    char *property, int mode_flags,
                                     unsigned int number)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_unsigned_property","Entry.");
+    TRACE_FLOW_STRING("update_unsigned_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_UNSIGNED, (void *)(&number), sizeof(unsigned int), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_UNSIGNED,
+                             (void *)(&number), sizeof(unsigned int),
+                             mode_flags);
 
-    TRACE_FLOW_NUMBER("update_unsigned_property Returning",error);
+    TRACE_FLOW_NUMBER("update_unsigned_property Returning", error);
     return error;
 }
 /* Update a long property. */
@@ -1815,11 +1953,12 @@ inline int update_long_property(struct collection_item *ci,
                                 long number)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_long_property","Entry.");
+    TRACE_FLOW_STRING("update_long_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_LONG, (void *)(&number), sizeof(long), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_LONG,
+                             (void *)(&number), sizeof(long), mode_flags);
 
-    TRACE_FLOW_NUMBER("update_long_property Returning",error);
+    TRACE_FLOW_NUMBER("update_long_property Returning", error);
     return error;
 
 }
@@ -1831,11 +1970,13 @@ inline int update_ulong_property(struct collection_item *ci,
                                  unsigned long number)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_ulong_property","Entry.");
+    TRACE_FLOW_STRING("update_ulong_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_ULONG, (void *)(&number), sizeof(unsigned long), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_ULONG,
+                             (void *)(&number), sizeof(unsigned long),
+                             mode_flags);
 
-    TRACE_FLOW_NUMBER("update_ulong_property Returning",error);
+    TRACE_FLOW_NUMBER("update_ulong_property Returning", error);
     return error;
 }
 
@@ -1846,11 +1987,12 @@ inline int update_double_property(struct collection_item *ci,
                                   double number)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_double_property","Entry.");
+    TRACE_FLOW_STRING("update_double_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_DOUBLE, (void *)(&number), sizeof(double), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_DOUBLE,
+                             (void *)(&number), sizeof(double), mode_flags);
 
-    TRACE_FLOW_NUMBER("update_double_property Returning",error);
+    TRACE_FLOW_NUMBER("update_double_property Returning", error);
     return error;
 }
 
@@ -1861,11 +2003,13 @@ inline int update_bool_property(struct collection_item *ci,
                                 unsigned char logical)
 {
     int error = EOK;
-    TRACE_FLOW_STRING("update_bool_property","Entry.");
+    TRACE_FLOW_STRING("update_bool_property", "Entry.");
 
-    error =  update_property(ci,property, COL_TYPE_BOOL, (void *)(&logical), sizeof(unsigned char), mode_flags);
+    error =  update_property(ci, property, COL_TYPE_BOOL,
+                             (void *)(&logical), sizeof(unsigned char),
+                             mode_flags);
 
-    TRACE_FLOW_NUMBER("update_bool_property Returning",error);
+    TRACE_FLOW_NUMBER("update_bool_property Returning", error);
     return error;
 }
 
@@ -1876,33 +2020,34 @@ int modify_item(struct collection_item *item,
                 void *data,
                 int length)
 {
-    TRACE_FLOW_STRING("modify_item","Entry");
+    TRACE_FLOW_STRING("modify_item", "Entry");
 
-    if((item == (struct collection_item *)(NULL)) ||
-       (item->type == COL_TYPE_COLLECTION) ||
-       (item->type == COL_TYPE_COLLECTIONREF)) {
-        TRACE_ERROR_NUMBER("Invalid argument or invalid argument type",EINVAL);
+    if ((item == NULL) ||
+        (item->type == COL_TYPE_COLLECTION) ||
+        (item->type == COL_TYPE_COLLECTIONREF)) {
+        TRACE_ERROR_NUMBER("Invalid argument or invalid argument type", EINVAL);
         return EINVAL;
     }
 
-    if(property != NULL) {
+    if (property != NULL) {
         free(item->property);
         item->property=strdup(property);
-        if(item->property == NULL) {
-            TRACE_ERROR_STRING("Failed to allocate memory","");
+        if (item->property == NULL) {
+            TRACE_ERROR_STRING("Failed to allocate memory", "");
             return ENOMEM;
         }
     }
 
-    /* If type is different or same but it is string or binary we need to replace the storage */
-    if((item->type != type) ||
-       ((item->type == type) &&
-       ((item->type == COL_TYPE_STRING) || (item->type == COL_TYPE_BINARY)))) {
-        TRACE_INFO_STRING("Replacing item data buffer","");
+    /* If type is different or same but it is string or binary we need to
+     * replace the storage */
+    if ((item->type != type) ||
+        ((item->type == type) &&
+        ((item->type == COL_TYPE_STRING) || (item->type == COL_TYPE_BINARY)))) {
+        TRACE_INFO_STRING("Replacing item data buffer", "");
         free(item->data);
         item->data = malloc(length);
-        if(item->data == NULL) {
-            TRACE_ERROR_STRING("Failed to allocate memory","");
+        if (item->data == NULL) {
+            TRACE_ERROR_STRING("Failed to allocate memory", "");
             item->length = 0;
             return ENOMEM;
         }
@@ -1910,13 +2055,14 @@ int modify_item(struct collection_item *item,
     }
 
 
-    TRACE_INFO_STRING("Overwriting item data","");
-    memcpy(item->data,data,item->length);
+    TRACE_INFO_STRING("Overwriting item data", "");
+    memcpy(item->data, data, item->length);
     item->type = type;
 
-    if(item->type == COL_TYPE_STRING) *(((char *)(item->data))+item->length-1) = '\0';
+    if (item->type == COL_TYPE_STRING)
+        ((char *)(item->data))[item->length - 1] = '\0';
 
-    TRACE_FLOW_STRING("modify_item","Exit");
+    TRACE_FLOW_STRING("modify_item", "Exit");
     return EOK;
 }
 
@@ -1931,14 +2077,16 @@ inline int modify_str_item(struct collection_item *item,
     int len;
     int error;
 
-    TRACE_FLOW_STRING("modify_str_item","Entry");
+    TRACE_FLOW_STRING("modify_str_item", "Entry");
 
-    if(length != 0) len = length;
-    else len = strlen(string) + 1;
+    if (length != 0)
+        len = length;
+    else
+        len = strlen(string) + 1;
 
-    error = modify_item(item,property,COL_TYPE_STRING,(void *)string,len);
+    error = modify_item(item, property, COL_TYPE_STRING, (void *)string, len);
 
-    TRACE_FLOW_STRING("modify_str_item","Exit");
+    TRACE_FLOW_STRING("modify_str_item", "Exit");
     return error;
 }
 
@@ -1950,11 +2098,11 @@ inline int modify_binary_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_binary_item","Entry");
+    TRACE_FLOW_STRING("modify_binary_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_BINARY,binary_data,length);
+    error = modify_item(item, property, COL_TYPE_BINARY, binary_data, length);
 
-    TRACE_FLOW_STRING("modify_binary_item","Exit");
+    TRACE_FLOW_STRING("modify_binary_item", "Exit");
     return error;
 }
 
@@ -1965,11 +2113,11 @@ inline int modify_bool_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_bool_item","Entry");
+    TRACE_FLOW_STRING("modify_bool_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_BOOL,(void *)(&logical),1);
+    error = modify_item(item, property, COL_TYPE_BOOL, (void *)(&logical), 1);
 
-    TRACE_FLOW_STRING("modify_bool_item","Exit");
+    TRACE_FLOW_STRING("modify_bool_item", "Exit");
     return error;
 }
 
@@ -1982,9 +2130,10 @@ inline int modify_int_item(struct collection_item *item,
 
     TRACE_FLOW_STRING("modify_int_item","Entry");
 
-    error = modify_item(item,property,COL_TYPE_INTEGER,(void *)(&number),sizeof(int));
+    error = modify_item(item, property, COL_TYPE_INTEGER,
+                        (void *)(&number), sizeof(int));
 
-    TRACE_FLOW_STRING("modify_int_item","Exit");
+    TRACE_FLOW_STRING("modify_int_item", "Exit");
     return error;
 }
 
@@ -1995,11 +2144,12 @@ inline int modify_long_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_long_item","Entry");
+    TRACE_FLOW_STRING("modify_long_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_LONG,(void *)(&number),sizeof(long));
+    error = modify_item(item, property, COL_TYPE_LONG,
+                        (void *)(&number), sizeof(long));
 
-    TRACE_FLOW_STRING("modify_long_item","Exit");
+    TRACE_FLOW_STRING("modify_long_item", "Exit");
     return error;
 }
 
@@ -2010,11 +2160,12 @@ inline int modify_ulong_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_ulong_item","Entry");
+    TRACE_FLOW_STRING("modify_ulong_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_ULONG,(void *)(&number),sizeof(unsigned long));
+    error = modify_item(item, property, COL_TYPE_ULONG,
+                        (void *)(&number), sizeof(unsigned long));
 
-    TRACE_FLOW_STRING("modify_ulong_item","Exit");
+    TRACE_FLOW_STRING("modify_ulong_item", "Exit");
     return error;
 }
 
@@ -2024,11 +2175,12 @@ inline int modify_unsigned_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_unsigned_item","Entry");
+    TRACE_FLOW_STRING("modify_unsigned_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_UNSIGNED,(void *)(&number),sizeof(unsigned));
+    error = modify_item(item, property, COL_TYPE_UNSIGNED,
+                        (void *)(&number), sizeof(unsigned));
 
-    TRACE_FLOW_STRING("modify_unsigned_item","Exit");
+    TRACE_FLOW_STRING("modify_unsigned_item", "Exit");
     return error;
 }
 
@@ -2038,11 +2190,12 @@ inline int modify_double_item(struct collection_item *item,
 {
     int error;
 
-    TRACE_FLOW_STRING("modify_double_item","Entry");
+    TRACE_FLOW_STRING("modify_double_item", "Entry");
 
-    error = modify_item(item,property,COL_TYPE_DOUBLE,(void *)(&number),sizeof(double));
+    error = modify_item(item, property, COL_TYPE_DOUBLE,
+                        (void *)(&number), sizeof(double));
 
-    TRACE_FLOW_STRING("modify_double_item","Exit");
+    TRACE_FLOW_STRING("modify_double_item", "Exit");
     return error;
 }
 
@@ -2053,20 +2206,20 @@ static int grow_stack(struct collection_iterator *iterator, unsigned desired)
     int grow_by = 0;
     struct collection_item **temp;
 
-    TRACE_FLOW_STRING("grow_stack","Entry.");
+    TRACE_FLOW_STRING("grow_stack", "Entry.");
 
-    if(desired > iterator->stack_size) {
+    if (desired > iterator->stack_size) {
         grow_by = (((desired - iterator->stack_size) / STACK_DEPTH_BLOCK) + 1) * STACK_DEPTH_BLOCK;
         errno = 0;
-        temp = (struct collection_item **)(realloc(iterator->stack,grow_by * sizeof(struct collection_item *)));
-        if(temp == (struct collection_item **)(NULL)) {
-            TRACE_ERROR_NUMBER("Failed to allocate memory",ENOMEM);
+        temp = (struct collection_item **)realloc(iterator->stack, grow_by * sizeof(struct collection_item *));
+        if (temp == NULL) {
+            TRACE_ERROR_NUMBER("Failed to allocate memory", ENOMEM);
             return ENOMEM;
         }
         iterator->stack = temp;
         iterator->stack_size += grow_by;
     }
-    TRACE_FLOW_STRING("grow_stack","Exit.");
+    TRACE_FLOW_STRING("grow_stack", "Exit.");
     return EOK;
 }
 
@@ -2079,83 +2232,81 @@ int bind_iterator(struct collection_iterator **iterator,
 {
     int error;
     struct collection_header *header;
-    struct collection_iterator *iter = (struct collection_iterator *)(NULL);
+    struct collection_iterator *iter = NULL;
 
-    TRACE_FLOW_STRING("bind_iterator","Entry.");
+    TRACE_FLOW_STRING("bind_iterator", "Entry.");
 
     /* Do some argument checking first */
-    if((iterator == (struct collection_iterator **)(NULL)) ||
-       (ci == (struct collection_item *)(NULL))) {
-        TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL);
+    if ((iterator == NULL) || (ci == NULL)) {
+        TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL);
         return EINVAL;
     }
 
     iter = (struct collection_iterator *)malloc(sizeof(struct collection_iterator));
-    if(iter == (struct collection_iterator *)(NULL)) {
-        TRACE_ERROR_NUMBER("Error allocating memory for the iterator.",ENOMEM);
+    if (iter == NULL) {
+        TRACE_ERROR_NUMBER("Error allocating memory for the iterator.", ENOMEM);
         return ENOMEM;
     }
 
     /* Allocate memory for the stack */
-    iter->stack = (struct collection_item **)(NULL);
+    iter->stack = NULL;
     iter->stack_size = 0;
     iter->stack_depth = 0;
     iter->flags = mode_flags;
 
     /* Allocate memory for stack */
-    error = grow_stack(iter,1);
+    error = grow_stack(iter, 1);
     if(error) {
         free(iter);
-        TRACE_ERROR_NUMBER("Error growing stack.",error);
+        TRACE_ERROR_NUMBER("Error growing stack.", error);
         return error;
     }
 
     /* Make sure that we tie iterator to the collection */
-    header = (struct collection_header *)(ci->data);
-    (header->reference_count)++;
+    header = (struct collection_header *)ci->data;
+    header->reference_count++;
     iter->top = ci;
     *(iter->stack) = ci;
     iter->stack_depth++;
 
     *iterator = iter;
 
-    TRACE_FLOW_STRING("bind_iterator","Exit");
+    TRACE_FLOW_STRING("bind_iterator", "Exit");
     return EOK;
 }
 
-/* Stop processing this subcollection and move to the next item in the collection 'level' levels up.*/
+/* Stop processing this subcollection and move to the next item in the
+ * collection 'level' levels up.*/
 inline int iterate_up(struct collection_iterator *iterator, int level)
 {
-    TRACE_FLOW_STRING("iterate_up","Entry");
+    TRACE_FLOW_STRING("iterate_up", "Entry");
 
-    if((iterator == (struct collection_iterator *)(NULL)) ||
-       (level >= iterator->stack_depth)) {
-        TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL);
+    if ((iterator == NULL) || (level >= iterator->stack_depth)) {
+        TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL);
         return EINVAL;
     }
 
-    TRACE_INFO_NUMBER("Going up:",level);
+    TRACE_INFO_NUMBER("Going up:", level);
 
     iterator->stack_depth--;
 
-    TRACE_INFO_NUMBER("Stack depth at the end:",iterator->stack_depth);
-    TRACE_FLOW_STRING("iterate_up","Exit");
+    TRACE_INFO_NUMBER("Stack depth at the end:", iterator->stack_depth);
+    TRACE_FLOW_STRING("iterate_up", "Exit");
     return EOK;
 }
 /* How deep are we relative to the top level.*/
 inline int get_iterator_depth(struct collection_iterator *iterator, int *depth)
 {
-    TRACE_FLOW_STRING("iterate_up","Entry");
+    TRACE_FLOW_STRING("iterate_up", "Entry");
 
-    if((iterator == (struct collection_iterator *)(NULL)) ||
-       (depth == (int *)(NULL))) {
-        TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL);
+    if ((iterator == NULL) || (depth == NULL)) {
+        TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL);
         return EINVAL;
     }
 
     *depth = iterator->stack_depth -1;
 
-    TRACE_INFO_NUMBER("Stack depth at the end:",iterator->stack_depth);
+    TRACE_INFO_NUMBER("Stack depth at the end:", iterator->stack_depth);
     TRACE_FLOW_STRING("iterate_up","Exit");
     return EOK;
 }
@@ -2164,177 +2315,181 @@ inline int get_iterator_depth(struct collection_iterator *iterator, int *depth)
 /* Unbind the iterator from the collection */
 inline void unbind_iterator(struct collection_iterator *iterator)
 {
-    TRACE_FLOW_STRING("unbind_iterator","Entry.");
-    if(iterator != (struct collection_iterator *)(NULL)) {
+    TRACE_FLOW_STRING("unbind_iterator", "Entry.");
+    if (iterator != NULL) {
         destroy_collection(iterator->top);
-        if(iterator->stack != (struct collection_item **)(NULL)) free(iterator->stack);
+        if (iterator->stack != NULL) free(iterator->stack);
         free(iterator);
     }
-    TRACE_FLOW_STRING("unbind_iterator","Exit");
+    TRACE_FLOW_STRING("unbind_iterator", "Exit");
 }
 
 /* Get items from the collection one by one following the tree */
-int iterate_collection(struct collection_iterator *iterator, struct collection_item **item)
+int iterate_collection(struct collection_iterator *iterator,
+                       struct collection_item **item)
 {
     int error;
     struct collection_item *current;
     struct collection_item *other;
 
-    TRACE_FLOW_STRING("iterate_collection","Entry.");
+    TRACE_FLOW_STRING("iterate_collection", "Entry.");
 
     /* Check if we have storage for item */
-    if(item == (struct collection_item **)(NULL)) {
-        TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL);
+    if (item == NULL) {
+        TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL);
         return EINVAL;
     }
 
-    while(1) {
+    while (1) {
 
-        TRACE_INFO_NUMBER("Stack depth:",iterator->stack_depth);
+        TRACE_INFO_NUMBER("Stack depth:", iterator->stack_depth);
 
         /* Are we done? */
-        if(iterator->stack_depth == 0) {
-            TRACE_FLOW_STRING("We are done.","");
-            *item = (struct collection_item *)(NULL);
+        if (iterator->stack_depth == 0) {
+            TRACE_FLOW_STRING("We are done.", "");
+            *item = NULL;
             return EOK;
         }
 
         /* Is current item available */
-        current = *(iterator->stack + iterator->stack_depth - 1);
+        current = iterator->stack[iterator->stack_depth - 1];
 
         /* We are not done so check if we have an item  */
-        if(current != (struct collection_item *)(NULL)) {
+        if (current != NULL) {
 
-            TRACE_INFO_STRING("Current item:",current->property);
-            TRACE_INFO_NUMBER("Current item type:",current->type);
+            TRACE_INFO_STRING("Current item:", current->property);
+            TRACE_INFO_NUMBER("Current item type:", current->type);
 
             /* Is this a collection reference */
-            if(current->type == COL_TYPE_COLLECTIONREF) {
+            if (current->type == COL_TYPE_COLLECTIONREF) {
                 /* We do follow references? */
-                TRACE_INFO_STRING("Current item:","collection reference");
-                if((iterator->flags & COL_TRAVERSE_IGNORE) == 0) {
+                TRACE_INFO_STRING("Current item:", "collection reference");
+                if ((iterator->flags & COL_TRAVERSE_IGNORE) == 0) {
                     /* We should not ignore - then move on */
-                    TRACE_INFO_STRING("Collection references are not ignored","");
-                    error = grow_stack(iterator,iterator->stack_depth + 1);
-                    if(error) {
-                        TRACE_ERROR_NUMBER("Error growing stack.",error);
+                    TRACE_INFO_STRING("Collection references are not ignored", "");
+                    error = grow_stack(iterator, iterator->stack_depth + 1);
+                    if (error) {
+                        TRACE_ERROR_NUMBER("Error growing stack.", error);
                         return error;
                     }
                     /* Do we need to go deeper than one level ? */
-                    if((iterator->flags & COL_TRAVERSE_ONELEVEL) == 0) {
-                        TRACE_INFO_STRING("Need to go deeper","");
+                    if ((iterator->flags & COL_TRAVERSE_ONELEVEL) == 0) {
+                        TRACE_INFO_STRING("Need to go deeper", "");
                         /* We need to go deeper... */
                         /* Do we need to show headers but not reference? */
-                        if((iterator->flags & COL_TRAVERSE_ONLYSUB) != 0) {
-                            TRACE_INFO_STRING("Instructed to show header not reference","");
-                            other = *((struct collection_item **)(current->data));
-                            *(iterator->stack + iterator->stack_depth) = other->next;
+                        if ((iterator->flags & COL_TRAVERSE_ONLYSUB) != 0) {
+                            TRACE_INFO_STRING("Instructed to show header not reference", "");
+                            other = *((struct collection_item **)current->data);
+                            iterator->stack[iterator->stack_depth] = other->next;
                             *item = other;
                         }
                         /* Do we need to show both? */
-                        else if((iterator->flags & COL_TRAVERSE_SHOWSUB) != 0) {
+                        else if ((iterator->flags & COL_TRAVERSE_SHOWSUB) != 0) {
                             TRACE_INFO_STRING("Instructed to show header and reference","");
-                            *(iterator->stack + iterator->stack_depth) = *((struct collection_item **)(current->data));
+                            iterator->stack[iterator->stack_depth] = *((struct collection_item **)(current->data));
                             *item = current;
                         }
                         /* We need to show reference only */
                         else {
-                            TRACE_INFO_STRING("Instructed to show reference only","");
-                            other = *((struct collection_item **)(current->data));
-                            TRACE_INFO_STRING("Sub collection:",other->property);
-                            TRACE_INFO_NUMBER("Sub collection type:",other->type);
-                            *(iterator->stack + iterator->stack_depth) = other->next;
-                            if(other->next != (struct collection_item *)(NULL)) {
-                                TRACE_INFO_STRING("Will show this item next time:",(other->next)->property);
-                                TRACE_INFO_NUMBER("Will show this item next time type:",(other->next)->type);
+                            TRACE_INFO_STRING("Instructed to show reference only", "");
+                            other = *((struct collection_item **)current->data);
+                            TRACE_INFO_STRING("Sub collection:", other->property);
+                            TRACE_INFO_NUMBER("Sub collection type:", other->type);
+                            iterator->stack[iterator->stack_depth] = other->next;
+                            if (other->next != NULL) {
+                                TRACE_INFO_STRING("Will show this item next time:", other->next->property);
+                                TRACE_INFO_NUMBER("Will show this item next time type:", other->next->type);
                             }
                             *item = current;
                         }
 
-                        TRACE_INFO_STRING("We return item:",(*item)->property);
-                        TRACE_INFO_NUMBER("We return item type:",(*item)->type);
-                        TRACE_INFO_STRING("Moving to the next item on the previous item in stack","");
-                        *(iterator->stack + iterator->stack_depth - 1) = current->next;
-                        (iterator->stack_depth)++;
+                        TRACE_INFO_STRING("We return item:", (*item)->property);
+                        TRACE_INFO_NUMBER("We return item type:", (*item)->type);
+                        TRACE_INFO_STRING("Moving to the next item on the previous item in stack", "");
+                        iterator->stack[iterator->stack_depth - 1] = current->next;
+                        iterator->stack_depth++;
 
                     }
                     else {
-                        TRACE_INFO_STRING("Instructed to parse just one level","");
+                        TRACE_INFO_STRING("Instructed to parse just one level", "");
                         /* On one level - just return current */
                         *item = current;
-                        TRACE_INFO_STRING("Moving to the next item on one level","");
-                        *(iterator->stack + iterator->stack_depth - 1) = current->next;
+                        TRACE_INFO_STRING("Moving to the next item on one level", "");
+                        iterator->stack[iterator->stack_depth - 1] = current->next;
                     }
                     break;
                 }
                 else {
                     /* We need to ignore references so move to the next item */
-                    TRACE_INFO_STRING("Stepping over the reference","");
-                    *(iterator->stack + iterator->stack_depth - 1) = current->next;
+                    TRACE_INFO_STRING("Stepping over the reference", "");
+                    iterator->stack[iterator->stack_depth - 1] = current->next;
                     continue;
                 }
             }
             else {
                 /* Got a normal item - return it and move to the next one */
-                TRACE_INFO_STRING("Simple item","");
+                TRACE_INFO_STRING("Simple item", "");
                 *item = current;
-                *(iterator->stack + iterator->stack_depth - 1) = current->next;
+                iterator->stack[iterator->stack_depth - 1] = current->next;
                 break;
             }
         }
         else {
             /* Item is NULL */
-            TRACE_INFO_STRING("Finished level","moving to upper level");
+            TRACE_INFO_STRING("Finished level", "moving to upper level");
             iterator->stack_depth--;
-            TRACE_INFO_NUMBER("Stack depth at the end:",iterator->stack_depth);
-            if((iterator->flags & COL_TRAVERSE_END) != 0) {
+            TRACE_INFO_NUMBER("Stack depth at the end:", iterator->stack_depth);
+            if ((iterator->flags & COL_TRAVERSE_END) != 0) {
                 /* Return dummy entry to indicate the end of the collection */
-                TRACE_INFO_STRING("Finished level","told to return END");
+                TRACE_INFO_STRING("Finished level", "told to return END");
                 *item = &dummy;
                 break;
             }
-            else continue; /* Move to next level */
+            else {
+                /* Move to next level */
+                continue;
+            }
         }
     }
 
-    TRACE_FLOW_STRING("iterate_collection","Exit");
+    TRACE_FLOW_STRING("iterate_collection", "Exit");
     return EOK;
 }
 
 /* Set collection class */
-inline int set_collection_class(struct collection_item *item, unsigned class)
+inline int set_collection_class(struct collection_item *item, unsigned cclass)
 {
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("set_collection_class","Entry");
+    TRACE_FLOW_STRING("set_collection_class", "Entry");
 
-    if(item->type != COL_TYPE_COLLECTION) {
-        TRACE_INFO_NUMBER("Not a collectin object. Type is",item->type);
+    if (item->type != COL_TYPE_COLLECTION) {
+        TRACE_INFO_NUMBER("Not a collectin object. Type is", item->type);
         return EINVAL;
     }
 
-    header = (struct collection_header *)(item->data);
-    header->class = class;
-    TRACE_FLOW_STRING("set_collection_class","Exit");
+    header = (struct collection_header *)item->data;
+    header->cclass = cclass;
+    TRACE_FLOW_STRING("set_collection_class", "Exit");
     return EOK;
 }
 
 /* Get collection class */
 inline int get_collection_class(struct collection_item *item,
-                                unsigned *class)
+                                unsigned *cclass)
 {
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("get_collection_class","Entry");
+    TRACE_FLOW_STRING("get_collection_class", "Entry");
 
-    if(item->type != COL_TYPE_COLLECTION) {
-        TRACE_ERROR_NUMBER("Not a collection object. Type is",item->type);
+    if (item->type != COL_TYPE_COLLECTION) {
+        TRACE_ERROR_NUMBER("Not a collection object. Type is", item->type);
         return EINVAL;
     }
 
-    header = (struct collection_header *)(item->data);
-    *class  = header->class;
-    TRACE_FLOW_STRING("get_collection_class","Exit");
+    header = (struct collection_header *)item->data;
+    *cclass  = header->cclass;
+    TRACE_FLOW_STRING("get_collection_class", "Exit");
     return EOK;
 }
 
@@ -2344,38 +2499,40 @@ inline int get_collection_count(struct collection_item *item,
 {
     struct collection_header *header;
 
-    TRACE_FLOW_STRING("get_collection_count","Entry");
+    TRACE_FLOW_STRING("get_collection_count", "Entry");
 
-    if(item->type != COL_TYPE_COLLECTION) {
-        TRACE_ERROR_NUMBER("Not a collectin object. Type is",item->type);
+    if (item->type != COL_TYPE_COLLECTION) {
+        TRACE_ERROR_NUMBER("Not a collectin object. Type is", item->type);
         return EINVAL;
     }
 
-    header = (struct collection_header *)(item->data);
+    header = (struct collection_header *)item->data;
     *count  = header->count;
-    TRACE_FLOW_STRING("get_collection_count","Exit");
+    TRACE_FLOW_STRING("get_collection_count", "Exit");
     return EOK;
 
 }
 
 /* Convinience function to check if the collection is of the specific class */
 /* In case of internal error assumes that collection is not of the right class */
-inline int is_of_class(struct collection_item *item,unsigned class)
+inline int is_of_class(struct collection_item *item, unsigned cclass)
 {
     int error = EOK;
     unsigned ret_class = 0;
 
-    TRACE_FLOW_STRING("is_of_class invoked","");
+    TRACE_FLOW_STRING("is_of_class invoked", "");
 
-    error = get_collection_class(item,&ret_class);
-    if((error) || (ret_class != class)) return 0;
-    else return 1;
+    error = get_collection_class(item, &ret_class);
+    if (error || (ret_class != cclass))
+        return 0;
+    else
+        return 1;
 }
 
 /* Get propery */
 inline char *get_item_property(struct collection_item *ci,int *property_len)
 {
-    if(property_len != NULL) *property_len = ci->property_len;
+    if (property_len != NULL) *property_len = ci->property_len;
     return ci->property;
 }
 
@@ -2399,42 +2556,45 @@ void *get_item_data(struct collection_item *ci)
 
 
 /* Set time stamp in the collection - FIXME move to another level */
-int set_timestamp(struct collection_item *ci,struct collection_item **timestr_ref,struct collection_item **timeint_ref)
+int set_timestamp(struct collection_item *ci,
+                  struct collection_item **timestr_ref,
+                  struct collection_item **timeint_ref)
 {
     time_t utctime;
     struct tm time_struct;
     char time_array[TIME_ARRAY_SIZE+1];
     int len;
-    struct collection_item *timestr = (struct collection_item *)(NULL);
-    struct collection_item *timeint = (struct collection_item *)(NULL);
+    struct collection_item *timestr = NULL;
+    struct collection_item *timeint = NULL;
     int error = EOK;
 
-    TRACE_FLOW_STRING("set_timestamp","Entry point");
+    TRACE_FLOW_STRING("set_timestamp", "Entry point");
 
     utctime = time(NULL);
-    localtime_r(&utctime,&time_struct);
+    localtime_r(&utctime, &time_struct);
 
     len = strftime(time_array, TIME_ARRAY_SIZE, DATE_FORMAT, &time_struct);
-    if(len == 0) {
-        TRACE_ERROR_STRING("add_time","CODING ERROR - INCREASE THE BUFFER");
+    if (len == 0) {
+        TRACE_ERROR_STRING("add_time", "CODING ERROR - INCREASE THE BUFFER");
         return EMSGSIZE;
     }
 
-    TRACE_INFO_STRING("Timestamp:",time_array);
+    TRACE_INFO_STRING("Timestamp:", time_array);
 
     /* Check if we have the timestamp item already */
-    error = get_item(ci, TS_NAME, COL_TYPE_STRING,COL_TRAVERSE_IGNORE,&timestr);
-    if(error) {
-        TRACE_ERROR_NUMBER("search failed with error:",error);
+    error = get_item(ci, TS_NAME, COL_TYPE_STRING,
+                     COL_TRAVERSE_IGNORE, &timestr);
+    if (error) {
+        TRACE_ERROR_NUMBER("search failed with error:", error);
         return error;
     }
 
-    if(timestr != (struct collection_item *)(NULL)) {
+    if (timestr != NULL) {
         /* There is a timestamp */
         free(timestr->data);
         timestr->data = strdup(time_array);
-        if(timestr->data == NULL) {
-            TRACE_ERROR_NUMBER("failed to add timestamp property:",error);
+        if (timestr->data == NULL) {
+            TRACE_ERROR_NUMBER("failed to add timestamp property:", error);
             return ENOMEM;
         }
         timestr->length = len+1;
@@ -2442,35 +2602,38 @@ int set_timestamp(struct collection_item *ci,struct collection_item **timestr_re
     }
     else {
         /* Add timestamp to the collection */
-        error = add_str_property_with_ref(ci,NULL, TS_NAME,time_array,len+1,timestr_ref);
-        if(error) {
-            TRACE_ERROR_NUMBER("failed to add timestamp property:",error);
+        error = add_str_property_with_ref(ci, NULL, TS_NAME,
+                                          time_array, len+1, timestr_ref);
+        if (error) {
+            TRACE_ERROR_NUMBER("failed to add timestamp property:", error);
             return error;
         }
     }
 
     /* Check if we have the time item already */
-    error = get_item(ci, T_NAME, COL_TYPE_INTEGER,COL_TRAVERSE_IGNORE,&timeint);
-    if(error) {
-        TRACE_ERROR_NUMBER("search failed with error:",error);
+    error = get_item(ci, T_NAME, COL_TYPE_INTEGER,
+                     COL_TRAVERSE_IGNORE, &timeint);
+    if (error) {
+        TRACE_ERROR_NUMBER("search failed with error:", error);
         return error;
     }
 
-    if(timeint != (struct collection_item *)(NULL)) {
+    if (timeint != NULL) {
         /* There is a time property */
         *((int *)(timeint->data)) = utctime;
         *timeint_ref = timeint;
     }
     else {
         /* Add time to the collection */
-        error = add_int_property_with_ref(ci,NULL, T_NAME,utctime,timeint_ref);
-        if(error) {
-            TRACE_ERROR_NUMBER("failed to add time property:",error);
+        error = add_int_property_with_ref(ci, NULL, T_NAME,
+                                          utctime, timeint_ref);
+        if (error) {
+            TRACE_ERROR_NUMBER("failed to add time property:", error);
             return error;
         }
     }
 
-    TRACE_FLOW_STRING("set_timestamp","Exit point");
+    TRACE_FLOW_STRING("set_timestamp", "Exit point");
     return EOK;
 }
 
diff --git a/common/collection/collection.h b/common/collection/collection.h
index bccf3e3c..ddb74125 100644
--- a/common/collection/collection.h
+++ b/common/collection/collection.h
@@ -26,7 +26,8 @@
 #define EOK 0
 #endif
 
-#define COL_TYPE_STRING          0x00000001 /* For elements of type string the trailing 0 is counted into the length. */
+#define COL_TYPE_STRING          0x00000001 /* For elements of type string the
+                                               lenght includes the trailing 0 */
 #define COL_TYPE_BINARY          0x00000002
 #define COL_TYPE_INTEGER         0x00000004
 #define COL_TYPE_UNSIGNED        0x00000008
@@ -34,10 +35,18 @@
 #define COL_TYPE_ULONG           0x00000020
 #define COL_TYPE_DOUBLE          0x00000040
 #define COL_TYPE_BOOL            0x00000080
-#define COL_TYPE_COLLECTION      0x00000100 /* The item of this type denotes that starting element of a collection */
-#define COL_TYPE_COLLECTIONREF   0x00000200 /* The item of this type denotes a pointer to already existing external collection */
-#define COL_TYPE_END             0x10000000 /* Special type that denotes the end of the collection. Useful when traversing collection */
-#define COL_TYPE_ANY             0x0FFFFFFF /* Special type that denotes any. Useful when traversing collection */
+#define COL_TYPE_COLLECTION      0x00000100 /* The item of this type denotes
+                                               that starting element of a
+                                               collection */
+#define COL_TYPE_COLLECTIONREF   0x00000200 /* An item of this type is a pointer
+                                               to an existing external
+                                               collection */
+#define COL_TYPE_END             0x10000000 /* Special type that denotes the end
+                                               of the collection. Useful when
+                                               traversing collections */
+#define COL_TYPE_ANY             0x0FFFFFFF /* Special type that denotes any.
+                                               Useful when traversing
+                                               collections */
 
 /* Any data we deal with can't be longer than this */
 /* FIXME - make it compile time option */
@@ -48,31 +57,53 @@
 
 /* The modes that define how one collection can be added to another */
 
-#define COL_ADD_MODE_REFERENCE 0    /* One collection will contain a pointer of another */
-#define COL_ADD_MODE_EMBED     1    /* One collection will be donated to become a part of another collection.
-                                     * After that the donating connection handle should not be used or freed.
-                                     * It means that it can be donated only once. The donation attempt will
-                                     * fail if the collection is referenced by other collection. */
-#define COL_ADD_MODE_CLONE     2    /* Creates a deep copy of a collection with its sub collections */
+#define COL_ADD_MODE_REFERENCE 0    /* The collection will contain a pointer
+                                       to another */
+#define COL_ADD_MODE_EMBED     1    /* The collection will become part of
+                                       another collection.
+                                       After this operation the handle should
+                                       not be used or freed.
+                                       Can't be done more than once.
+                                       If the collection is referenced by
+                                       another collection, the operation will
+                                       fail. */
+#define COL_ADD_MODE_CLONE     2    /* Creates a deep copy of a collection with
+                                       its sub collections */
 
 
 /* Modes how the collection is traversed */
-#define COL_TRAVERSE_DEFAULT  0x00000000  /* No special flags - means it will go through all the items */
-#define COL_TRAVERSE_ONELEVEL 0x00000001  /* Flag to traverse only high level - ignored it IGNORE flag is specified */
-#define COL_TRAVERSE_END      0x00000002  /* Call handler once more when end of the collection is reached - good for processing nested collections */
-                                          /* Flag is implied for iterator unless FLAT flag is specified */
-#define COL_TRAVERSE_IGNORE   0x00000004  /* Ignore sub collections at all as if there are none */
-#define COL_TRAVERSE_FLAT     0x00000008  /* Flatten the collection - FIXME - not implemented yet */
-/* Additional iterator flags - not respected by traverse functions */
-#define COL_TRAVERSE_SHOWSUB  0x00010000  /* Include header of the sub collections - respected by iterator */
-                                          /* By default iterator returns just references and skips headers */
-                                          /* Ignored if ONELEVEL flag is specified and not ignored */
-                                          /* Ignored if FLAT flag is specified */
-#define COL_TRAVERSE_ONLYSUB  0x00020000  /* Show header of the sub collection instead of reference - respected by iterator */
-                                          /* Ignored if ONELEVEL flag is specified and not ignored */
-                                          /* Ignored if FLAT flag is specified */
-
-/* FIXME - move to event level - this does not belong to collection */
+#define COL_TRAVERSE_DEFAULT  0x00000000  /* Traverse all items */
+#define COL_TRAVERSE_ONELEVEL 0x00000001  /* Flag to traverse only top level
+                                             ignored if the IGNORE flag is
+                                             specified */
+#define COL_TRAVERSE_END      0x00000002  /* Call the handler once more when the
+                                             end of the collection is reached.
+                                             Good for processing nested
+                                             collections.
+                                             Implicit for iterators unless
+                                             the FLAT flag is specified */
+#define COL_TRAVERSE_IGNORE   0x00000004  /* Ignore sub collections as if none
+                                             is present */
+#define COL_TRAVERSE_FLAT     0x00000008  /* Flatten the collection.
+                                             FIXME: not implemented yet */
+
+/* Additional iterator flags
+ * NOTE: ignored by traverse functions */
+#define COL_TRAVERSE_SHOWSUB  0x00010000  /* Include headers of sub collections
+                                             By default iterators return just
+                                             references and skips headers.
+                                             Ignored if the ONELEVEL flag is
+                                             specified and not ignored.
+                                             Ignored if the FLAT flag is
+                                             specified. */
+#define COL_TRAVERSE_ONLYSUB  0x00020000  /* Show the header of the sub
+                                             collection instead of reference.
+                                             Ignored if the ONELEVEL flag is
+                                             specified and not ignored.
+                                             Ignored if the FLAT flag is
+                                             specified. */
+
+/* FIXME: move to event level - this does not belong to collection */
 /* Time stamp property name */
 #define TS_NAME         "stamp"
 /* Time property name */
@@ -105,49 +136,53 @@ struct collection_item;
 struct collection_iterator;
 #endif /* COLLECTION_PRIV_H */
 
-/* IMPORTANT - the collection is a set of items of different types.
+/* IMPORTANT - the collection is a set of items of different type.
  * There is always a header item in any collection that starts the collection.
- * Most of the functions in the interface (unless it is explicitly mentioned
- * otherwise) assume that the collection_item * argument points to the header element.
- * Passing in elements extracted from the middle of collection to the functions
+ * Most of the functions in the interface (unless explicitly stated otherwise)
+ * assume that the collection_item * argument points to the header element.
+ * Passing in elements extracted from the middle of a collection to functions
  * that expect header elements is illegal. There might be not enough checking
  * at the moment but this will be enforced in future versions of the library.
 
  * IMPORTANT - To better understand how collections work imagine travel bags.
- * They usually come in different sizes and one can put a bag in a bag when they put away
- * to the shelf in a garage or closet. Collection is such bag except that you
- * can put other bags into each other even if they are not empty.
+ * They usually come in different sizes and one can put a bag in a bag when
+ * they put away to the shelf in a garage or closet. Collection is such bag
+ * except that you can put other bags into each other even if they are not
+ * empty.
  * When you put items into a bag you do not see the contents of the bag.
  * You just hold the bag. How many other bags inside this bag you do not know.
  * But you might know that you put a "valet" somewhere there.
  * You ask the bag you hold: "find my valet and give it to me".
  * get_item function will return you the item that is you "valet".
- * You can then change something or just get information about the item you retrieved.
- * But in most cases you do not the valet itself. You want to get something from the vallet
- * or put something into it. IMO money would be an obvious choice.
- * To do this you use update_xxx_property functions.
- * There might be a bag somewhere deep and you might want to add something to it.
- * add_xxx_property_xxx functions allow you to specify sub collection you want the item
- * to be added to. If this sub collection argument is NULL top level collection is assumed.
- * The search in the collections users a dotted notation to refer to an item (or property)
- * You can search for "valet" and it will find any first instance of the "valet" in
- * your luggage. But you might have two valets. One is yours and another is your significant other's.
- * So you might say find "my.valet". It will find valet in your bad (collection) named "my".
- * This collection can be many levels deep inside other collections. You do not need to know
- * the full path to get to it. But if you have the full path you can use the fill path
- * like this "luggage.newbags.my.valet".
- * It is useful to be able to put bags into bags as well as get them out of each other.
- * When the collection is created the header keeps a reference count on how many
- * copies of the collection are known to the world. So one can put a collection into collection
- * and give up its access to it (embed) of still hold to the reference.
- * By embedding the collection the caller effectively gives up its responsibility
- * to destroy the collection after it is used.
- * By extracting reference from an internal collection the caller gains access to the
- * collection directly and thus has responsibility to destroy it after use.
+ * You can then change something or just get information about the item you
+ * retrieved. But in most cases you do not the valet itself. You want to get
+ * something from the vallet or put something into it. IMO money would be an
+ * obvious choice. To do this you use update_xxx_property functions.
+ * There might be a bag somewhere deep and you might want to add something to
+ * it. add_xxx_property_xxx functions allow you to specify sub collection you
+ * want the item to be added to. If this sub collection argument is NULL top
+ * level collection is assumed.
+ * The search in the collections users a dotted notation to refer to an item (or
+ * property). You can search for "valet" and it will find any first instance of
+ * the "valet" in your luggage. But you might have two valets. One is yours and
+ * another is your significant other's. So you might say find "my.valet".
+ * It will find valet in your bad (collection) named "my". This collection can
+ * be many levels deep inside other collections. You do not need to know the
+ * full path to get to it. But if you have the full path you can use the fill
+ * path like this "luggage.newbags.my.valet".
+ * It is useful to be able to put bags into bags as well as get them out of each
+ * other. When the collection is created the header keeps a reference count on
+ * how many copies of the collection are known to the world. So one can put a
+ * collection into collection and give up its access to it (embed) of still hold
+ * to the reference. By embedding the collection the caller effectively gives
+ * up its responsibility to destroy the collection after it is used.
+ * By extracting reference from an internal collection the caller gains access
+ * to the collection directly and thus has responsibility to destroy it after
+ * use.
  */
 
 /* Function that creates an named collection */
-int create_collection(struct collection_item **ci,char *name,unsigned class);
+int create_collection(struct collection_item **ci, char *name,unsigned cclass);
 
 /* Function that destroys a collection */
 void destroy_collection(struct collection_item *ci);
@@ -155,88 +190,131 @@ void destroy_collection(struct collection_item *ci);
 /* Family of functions that add properties to an event */
 /* See details about subcollection argument above. */
 /* Family includes the following convinience functions: */
-/* Add a string property to collection. Length should include the null terminating 0  */
-int add_str_property(struct collection_item *ci,char *subcollection, char *property,char *string,int length);
+/* Add a string property to collection. The length should include the
+ * terminating 0 */
+int add_str_property(struct collection_item *ci, char *subcollection,
+                     char *property, char *string, int length);
 /* Add a binary property to collection.  */
-int add_binary_property(struct collection_item *ci,char *subcollection, char *property,void *binary_data,int length);
+int add_binary_property(struct collection_item *ci, char *subcollection,
+                        char *property, void *binary_data, int length);
 /* Add an int property to collection. */
-int add_int_property(struct collection_item *ci,char *subcollection, char *property,int number);
+int add_int_property(struct collection_item *ci, char *subcollection,
+                     char *property, int number);
 /* Add an unsigned int property. */
-int add_unsigned_property(struct collection_item *ci,char *subcollection, char *property,unsigned int number);
+int add_unsigned_property(struct collection_item *ci, char *subcollection,
+                          char *property,unsigned int number);
 /* Add a long property. */
-int add_long_property(struct collection_item *ci,char *subcollection, char *property,long number);
+int add_long_property(struct collection_item *ci, char *subcollection,
+                      char *property, long number);
 /* Add an unsigned long property. */
-int add_ulong_property(struct collection_item *ci,char *subcollection, char *property,unsigned long number);
+int add_ulong_property(struct collection_item *ci, char *subcollection,
+                       char *property, unsigned long number);
 /* Add a double property. */
-int add_double_property(struct collection_item *ci,char *subcollection, char *property,double number);
+int add_double_property(struct collection_item *ci, char *subcollection,
+                        char *property,double number);
 /* Add a bool property. */
-int add_bool_property(struct collection_item *ci,char *subcollection, char *property,unsigned char logical);
+int add_bool_property(struct collection_item *ci, char *subcollection,
+                      char *property, unsigned char logical);
 
 /* Add any property */
-int add_any_property(struct collection_item *ci,    /* Collection to find things in */
+int add_any_property(struct collection_item *ci,    /* A collection of items */
                      char *subcollection,           /* Subcollection */
                      char *property,                /* Name */
-                     int type,                      /* Type of the passed in data */
-                     void *data,                    /* Pointer to the new data */
-                     int length);                   /* Length of the data. For strings should include trailing 0 */
-
-/* The functions that add an item and immediately return you this item in the ret_ref parameter */
-int add_str_property_with_ref(struct collection_item *ci,char *subcollection, char *property,char *string,int length,
+                     int type,                      /* Data type */
+                     void *data,                    /* Pointer to the data */
+                     int length);                   /* Length of the data. For
+                                                       strings it includes the
+                                                       trailing 0 */
+
+/* The functions that add an item and immediately return you this item
+ * in the ret_ref parameter */
+int add_str_property_with_ref(struct collection_item *ci,
+                              char *subcollection,
+                              char *property, char *string, int length,
                               struct collection_item **ret_ref);
-int add_binary_property_with_ref(struct collection_item *ci,char *subcollection, char *property,void *binary_data,int length,
+int add_binary_property_with_ref(struct collection_item *ci,
+                                 char *subcollection,
+                                 char *property, void *binary_data, int length,
                                  struct collection_item **ret_ref);
-int add_int_property_with_ref(struct collection_item *ci,char *subcollection, char *property,int number,
+int add_int_property_with_ref(struct collection_item *ci,
+                              char *subcollection,
+                              char *property, int number,
                               struct collection_item **ret_ref);
-int add_unsigned_property_with_ref(struct collection_item *ci,char *subcollection, char *property,unsigned int number,
+int add_unsigned_property_with_ref(struct collection_item *ci,
+                                   char *subcollection,
+                                   char *property,unsigned int number,
                                    struct collection_item **ret_ref);
-int add_long_property_with_ref(struct collection_item *ci,char *subcollection, char *property,long number,
+int add_long_property_with_ref(struct collection_item *ci,
+                               char *subcollection,
+                               char *property, long number,
                                struct collection_item **ret_ref);
-int add_ulong_property_with_ref(struct collection_item *ci,char *subcollection, char *property,unsigned long number,
+int add_ulong_property_with_ref(struct collection_item *ci,
+                                char *subcollection,
+                                char *property, unsigned long number,
                                 struct collection_item **ret_ref);
-int add_double_property_with_ref(struct collection_item *ci,char *subcollection, char *property,double number,
-                                 struct collection_item **ret_ref);
-int add_bool_property_with_ref(struct collection_item *ci,char *subcollection, char *property,unsigned char logical,
+int add_double_property_with_ref(struct collection_item *ci,
+                                 char *subcollection,
+                                 char *property, double number,
                                  struct collection_item **ret_ref);
-int add_any_property_with_ref(struct collection_item *ci,char *subcollection,char *property,int type,void *data,int length,
+int add_bool_property_with_ref(struct collection_item *ci,
+                               char *subcollection,
+                               char *property, unsigned char logical,
+                               struct collection_item **ret_ref);
+int add_any_property_with_ref(struct collection_item *ci,
+                              char *subcollection,
+                              char *property, int type, void *data, int length,
                               struct collection_item **ret_ref);
 
 /* FIXME - does not belong here - move to other place */
 /* Function to create a timestamp */
-/* Automatically adds/updates time and timestamp properties in the collection returning references */
+/* Automatically adds/updates time and timestamp properties in the
+ * collection returning references */
 int set_timestamp(struct collection_item *ci,
                   struct collection_item **timestr_ref,
                   struct collection_item **timeint_ref);
 
 
 /* Update functions */
-/* All update functions search the property using the search algorithm described at the top of the header file.
+/* All update functions search the property using the search algorithm
+ * described at the top of the header file.
  * Use same dotted notation to specify a property.
  */
-/* Update a string property in the collection. Length should include the null terminating 0  */
-int update_str_property(struct collection_item *ci, char *property,int mode_flags, char *string,int length);
+/* Update a string property in the collection.
+ * Length should include the terminating 0  */
+int update_str_property(struct collection_item *ci, char *property,
+                        int mode_flags, char *string,int length);
 /* Update a binary property in the collection.  */
-int update_binary_property(struct collection_item *ci, char *property,int mode_flags, void *binary_data,int length);
+int update_binary_property(struct collection_item *ci, char *property,
+                           int mode_flags, void *binary_data,int length);
 /* Update an int property in the collection. */
-int update_int_property(struct collection_item *ci, char *property,int mode_flags, int number);
+int update_int_property(struct collection_item *ci, char *property,
+                        int mode_flags, int number);
 /* Update an unsigned int property. */
-int update_unsigned_property(struct collection_item *ci, char *property,int mode_flags, unsigned int number);
+int update_unsigned_property(struct collection_item *ci, char *property,
+                             int mode_flags, unsigned int number);
 /* Update a long property. */
-int update_long_property(struct collection_item *ci, char *property,int mode_flags ,long number);
+int update_long_property(struct collection_item *ci, char *property,
+                         int mode_flags, long number);
 /* Update an unsigned long property. */
-int update_ulong_property(struct collection_item *ci, char *property,int mode_flags, unsigned long number);
+int update_ulong_property(struct collection_item *ci, char *property,
+                          int mode_flags, unsigned long number);
 /* Update a double property. */
-int update_double_property(struct collection_item *ci, char *property,int mode_flags, double number);
+int update_double_property(struct collection_item *ci, char *property,
+                           int mode_flags, double number);
 /* Update a double property. */
-int update_bool_property(struct collection_item *ci, char *property,int mode_flags, unsigned char logical);
+int update_bool_property(struct collection_item *ci, char *property,
+                         int mode_flags, unsigned char logical);
 
 
 /* Update property in the collection */
-int update_property(struct collection_item *ci,    /* Collection to find things in */
-                    char *property_to_find,        /* Name to match */
-                    int type,                      /* Type of the passed in data */
-                    void *new_data,                /* Pointer to the new data */
-                    int length,                    /* Length of the data. For strings should include trailing 0 */
-                    int mode_flags);               /* How to traverse the collection  */
+int update_property(struct collection_item *ci, /* A collection of items */
+                    char *property_to_find,     /* Name to match */
+                    int type,                   /* Data type */
+                    void *new_data,             /* Pointer to the data */
+                    int length,                 /* Length of the data. For
+                                                   strings, it includes the
+                                                   trailing 0 */
+                    int mode_flags);            /* How to traverse the collection  */
 
 
 
@@ -283,12 +361,12 @@ int traverse_collection(struct collection_item *ci,    /* Collection to traverse
    the data passed in custom_data and see if the item was found and
    that the action was performed.
  */
-int get_item_and_do(struct collection_item *ci,       /* Collection to find things in */
-                    char *property_to_find,           /* Name to match */
-                    int type,                         /* Type filter */
-                    int mode_flags,                   /* How to traverse the collection */
-                    item_fn item_handler,             /* Function to call when the item is found */
-                    void *custom_data);               /* Custom data passed around */
+int get_item_and_do(struct collection_item *ci,  /* A collection of items */
+                    char *property_to_find,      /* Name to match */
+                    int type,                    /* Type filter */
+                    int mode_flags,              /* How to traverse the collection */
+                    item_fn item_handler,        /* Function to call when the item is found */
+                    void *custom_data);          /* Custom data passed around */
 
 /* Convenience function to get individual item */
 /* Caller should be aware that this is not a copy of the item
@@ -354,7 +432,7 @@ int modify_double_item(struct collection_item *item,
                        double number);
 
 /* Delete property from the collection */
-int delete_property(struct collection_item *ci,    /* Collection to find things in */
+int delete_property(struct collection_item *ci,    /* A collection of items */
                     char *property_to_find,        /* Name to match */
                     int type,                      /* Type filter */
                     int mode_flags);               /* How to traverse the collection  */
@@ -381,18 +459,21 @@ int get_reference_from_item(struct collection_item *ci,          /* Reference el
 
 
 /* Bind iterator to a collection */
-int bind_iterator(struct collection_iterator **iterator,   /* The iterator to bind */
-                  struct collection_item *ci,              /* Collection to bind iterator to */
-                  int mode_flags);                         /* How the collection needs to be iterated */
+int bind_iterator(struct collection_iterator **iterator, /* The iterator to bind */
+                  struct collection_item *ci,            /* Collection to bind iterator to */
+                  int mode_flags);                       /* How the collection needs to be iterated */
 
 /* Unbind the iterator from the collection */
 void unbind_iterator(struct collection_iterator *iterator);
 
 /* Get items from the collection one by one following the tree */
-int iterate_collection(struct collection_iterator *iterator, struct collection_item **item);
+int iterate_collection(struct collection_iterator *iterator,
+                       struct collection_item **item);
 
-/* Stop processing this subcollection and move to the next item in the collection 'level' levels up.*/
-/* 'Level' parameter indicates how many levels up you want to jump. If 0 - call is a no op.
+/* Stop processing this subcollection and move to the next item in the
+ * collection 'level' levels up.
+ * The 'Level' parameter indicates how many levels up you want to jump.
+ * If 0 - call is a no op.
  * If the depth is less than requested level function will return error EINVAL.
  */
 int iterate_up(struct collection_iterator *iterator, int level);
@@ -403,24 +484,26 @@ int get_iterator_depth(struct collection_iterator *iterator, int *depth);
 /* FIXME - Do we need to be able to rewind iterator? */
 
 /* Set collection class */
-int set_collection_class(struct collection_item *item,      /* Collection */
-                         unsigned class);                   /* Class of the collection */
+int set_collection_class(struct collection_item *item, /* Collection */
+                         unsigned cclass);             /* Collection class */
 
 /* Get collection class */
-int get_collection_class(struct collection_item *item,      /* Collection */
-                         unsigned *class);                  /* Class of the collection */
+int get_collection_class(struct collection_item *item, /* Collection */
+                         unsigned *cclass);            /* Collection class */
 
 
 /* Get collection count */
-int get_collection_count(struct collection_item *item,      /* Collection */
-                         unsigned *count);                  /* Count of elements in this collection.
-                                                             * Each subcollection is counted as 1 element.
-                                                             */
+int get_collection_count(struct collection_item *item, /* Collection */
+                         unsigned *count);             /* Number of elements in
+                                                          this collection.
+                                                          Each subcollection is
+                                                          counted as 1 element.
+                                                        */
 
 /* Convenience function to check if the collection is of the specific class */
 /* In case of internal error assumes that collection is not of the right class */
-int is_of_class(struct collection_item *item,      /* Collection */
-                unsigned class);                   /* Class of the collection */
+int is_of_class(struct collection_item *item,  /* Collection */
+                unsigned cclass);              /* Class of the collection */
 
 
 
diff --git a/common/collection/collection_priv.h b/common/collection/collection_priv.h
index 8dd6d802..38d9012a 100644
--- a/common/collection/collection_priv.h
+++ b/common/collection/collection_priv.h
@@ -63,7 +63,7 @@ struct collection_header {
     struct collection_item *last;
     unsigned reference_count;
     unsigned count;
-    unsigned class;
+    unsigned cclass;
 };
 
 #endif
diff --git a/common/collection/collection_tools.c b/common/collection/collection_tools.c
index ed44707d..63c03760 100644
--- a/common/collection/collection_tools.c
+++ b/common/collection/collection_tools.c
@@ -41,109 +41,112 @@ int debug_handle(char *property,
     int i;
     int nest_level;
 
-    TRACE_FLOW_STRING("debug_handle","Entry.");
+    TRACE_FLOW_STRING("debug_handle", "Entry.");
 
 
     nest_level = *(int *)(custom_data);
-    TRACE_INFO_NUMBER("We are getting this pointer:",custom_data);
-    TRACE_INFO_NUMBER("Nest level:",nest_level);
-
-    switch(type) {
-        case COL_TYPE_STRING:
-                                printf("%*s %s[%d] str: %s (%d)\n",
-                                       (nest_level-1)*4,"",
-                                       property,
-                                       length,
-                                       (char *)(data),
-                                       (int)(nest_level));
-                                break;
-        case COL_TYPE_BINARY:
-                                printf("%*s %s[%d] bin: ",
-                                       (nest_level-1)*4,"",
-                                       property,
-                                       length);
-                                for(i=0;i<length;i++) printf("%02X",*((unsigned char *)(data+i)));
-                                printf(" (%d)\n",(int)(nest_level));
-                                break;
-        case COL_TYPE_INTEGER:
-                                printf("%*s %s[%d] int: %d (%d)\n",
-                                       (nest_level-1)*4,"",
-                                       property,
-                                       length,
-                                       *((int *)(data)),
-                                       nest_level);
-                                break;
-        case COL_TYPE_UNSIGNED:
-                                printf("%*s %s[%d] uint: %u (%d)\n",
-                                       (nest_level-1)*4,"",
-                                       property,
-                                       length,
-                                       *((unsigned int *)(data)),
-                                       nest_level);
-                                break;
-        case COL_TYPE_LONG:
-                                printf("%*s %s[%d] long: %ld (%d)\n",
-                                       (nest_level-1)*4,"",
-                                       property,
-                                       length,
-                                       *((long *)(data)),
-                                       nest_level);
-                                break;
-        case COL_TYPE_ULONG:
-                                printf("%*s %s[%d] ulong: %lu (%d)\n",
-                                       (nest_level-1)*4,"",
-                                       property,
-                                       length,
-                                       *((unsigned long *)(data)),
-                                       nest_level);
-                                break;
-        case COL_TYPE_DOUBLE:
-                                printf("%*s %s[%d] double: %.4f (%d)\n",
-                                       (nest_level-1)*4,"",
-                                       property,
-                                       length,
-                                       *((double *)(data)),
-                                       nest_level);
-                                break;
-        case COL_TYPE_BOOL:
-                                printf("%*s %s[%d] bool: %s (%d)\n",
-                                       (nest_level-1)*4,"",
-                                       property,
-                                       length,
-                                       (*((unsigned char *)(data)) == '\0') ? "flase" : "true",
-                                       (int)(nest_level));
-                                break;
-        case COL_TYPE_COLLECTION:
-                                nest_level++;
-                                printf("%*s %s[%d] header: count %d, ref_count %d class %d data: ",
-                                       (nest_level-1)*4,"",
-                                       property,
-                                       length,
-                                       ((struct collection_header *)(data))->count,
-                                       ((struct collection_header *)(data))->reference_count,
-                                       ((struct collection_header *)(data))->class);
-                                for(i=0;i<length;i++) printf("%02X",*((unsigned char *)(data+i)));
-                                printf(" (%d)\n",(int)(nest_level));
-                                break;
-        case COL_TYPE_COLLECTIONREF:
-                                printf("%*s %s[%d] external link: ",
-                                       (nest_level-1)*4,"",
-                                       property,
-                                       length);
-                                for(i=0;i<length;i++) printf("%02X",*((unsigned char *)(data+i)));
-                                printf(" (%d)\n",(int)(nest_level));
-                                break;
-        case COL_TYPE_END:
-                                nest_level--;
-                                /* printf("Reduced nest level\n");*/
-                                break;
-        default:
-                                printf("Not implemented yet.\n");
-                                break;
+    TRACE_INFO_NUMBER("We are getting this pointer:", custom_data);
+    TRACE_INFO_NUMBER("Nest level:", nest_level);
+
+    switch (type) {
+    case COL_TYPE_STRING:
+        printf("%*s %s[%d] str: %s (%d)\n",
+               (nest_level -1) * 4, "",
+               property,
+               length,
+               (char *)(data),
+               nest_level);
+        break;
+    case COL_TYPE_BINARY:
+        printf("%*s %s[%d] bin: ",
+               (nest_level -1) * 4, "",
+               property,
+               length);
+        for (i = 0; i < length; i++)
+            printf("%02X", ((unsigned char *)(data))[i]);
+        printf(" (%d)\n", nest_level);
+        break;
+    case COL_TYPE_INTEGER:
+        printf("%*s %s[%d] int: %d (%d)\n",
+               (nest_level -1) * 4, "",
+               property,
+               length,
+               *((int *)(data)),
+               nest_level);
+        break;
+    case COL_TYPE_UNSIGNED:
+        printf("%*s %s[%d] uint: %u (%d)\n",
+               (nest_level -1) * 4, "",
+               property,
+               length,
+               *((unsigned int *)(data)),
+               nest_level);
+        break;
+    case COL_TYPE_LONG:
+        printf("%*s %s[%d] long: %ld (%d)\n",
+               (nest_level -1) * 4, "",
+               property,
+               length,
+               *((long *)(data)),
+               nest_level);
+        break;
+    case COL_TYPE_ULONG:
+        printf("%*s %s[%d] ulong: %lu (%d)\n",
+               (nest_level -1) * 4, "",
+               property,
+               length,
+               *((unsigned long *)(data)),
+               nest_level);
+        break;
+    case COL_TYPE_DOUBLE:
+        printf("%*s %s[%d] double: %.4f (%d)\n",
+               (nest_level -1) * 4, "",
+               property,
+               length,
+               *((double *)(data)),
+               nest_level);
+        break;
+    case COL_TYPE_BOOL:
+        printf("%*s %s[%d] bool: %s (%d)\n",
+               (nest_level -1) * 4, "",
+               property,
+               length,
+               (*((unsigned char *)(data)) == '\0') ? "flase" : "true",
+               nest_level);
+        break;
+    case COL_TYPE_COLLECTION:
+        nest_level++;
+        printf("%*s %s[%d] header: count %d, ref_count %d class %d data: ",
+               (nest_level -1) * 4, "",
+               property,
+               length,
+               ((struct collection_header *)(data))->count,
+               ((struct collection_header *)(data))->reference_count,
+               ((struct collection_header *)(data))->cclass);
+        for (i = 0; i < length; i++)
+            printf("%02X", ((unsigned char *)(data))[i]);
+        printf(" (%d)\n", nest_level);
+        break;
+    case COL_TYPE_COLLECTIONREF:
+        printf("%*s %s[%d] external link: ",
+               (nest_level -1) * 4, "",
+               property,
+               length);
+        for (i = 0; i < length; i++)
+            printf("%02X", ((unsigned char *)(data))[i]);
+        printf(" (%d)\n", nest_level);
+        break;
+    case COL_TYPE_END:
+        nest_level--;
+        /* printf("Reduced nest level\n");*/
+        break;
+    default:
+        printf("Not implemented yet.\n");
+        break;
     }
     *(int *)(custom_data) = nest_level;
-    TRACE_INFO_NUMBER("Nest level at the end:",nest_level);
-    TRACE_FLOW_STRING("debug_handle","Success exit.");
+    TRACE_INFO_NUMBER("Nest level at the end:", nest_level);
+    TRACE_FLOW_STRING("debug_handle", "Success exit.");
     return EOK;
 }
 
@@ -163,24 +166,25 @@ inline int debug_item(struct collection_item *item)
 
 
 /* Print collection for debugging purposes */
-int debug_collection(struct collection_item *handle,int flag)
+int debug_collection(struct collection_item *handle, int flag)
 {
     int error = EOK;
-    int nest_level=0;
+    int nest_level = 0;
 
-    TRACE_FLOW_STRING("debug_collection","Entry.");
+    TRACE_FLOW_STRING("debug_collection", "Entry.");
 
-    printf("DEBUG COLLECTION %s\n",handle->property);
+    printf("DEBUG COLLECTION %s\n", handle->property);
 
     flag |= COL_TRAVERSE_END;
 
-    printf("Traverse flags %d\n",flag);
+    printf("Traverse flags %d\n", flag);
 
     /* Traverse collection */
-    error = traverse_collection(handle,flag,debug_handle,(void *)(&nest_level));
-    if(error) printf("Error debuging collection %d\n",error);
+    error = traverse_collection(handle, flag,
+                                debug_handle, (void *)(&nest_level));
+    if (error) printf("Error debuging collection %d\n", error);
 
-    TRACE_FLOW_STRING("debug_collection","Exit.");
+    TRACE_FLOW_STRING("debug_collection", "Exit.");
     return error;
 }
 
@@ -188,16 +192,33 @@ int debug_collection(struct collection_item *handle,int flag)
 /* Return a static string based on type of the element */
 static inline const char *get_type(int type)
 {
-    switch(type) {
-        case COL_TYPE_STRING:     return COL_TYPE_NAME_STRING;
-        case COL_TYPE_INTEGER:    return COL_TYPE_NAME_INTEGER;
-        case COL_TYPE_UNSIGNED:   return COL_TYPE_NAME_UNSIGNED;
-        case COL_TYPE_LONG:       return COL_TYPE_NAME_LONG;
-        case COL_TYPE_ULONG:      return COL_TYPE_NAME_ULONG;
-        case COL_TYPE_BINARY:     return COL_TYPE_NAME_BINARY;
-        case COL_TYPE_DOUBLE:     return COL_TYPE_NAME_DOUBLE;
-        case COL_TYPE_BOOL:       return COL_TYPE_NAME_BOOL;
-        default:                  return COL_TYPE_NAME_UNKNOWN;
+    switch (type) {
+    case COL_TYPE_STRING:
+        return COL_TYPE_NAME_STRING;
+
+    case COL_TYPE_INTEGER:
+        return COL_TYPE_NAME_INTEGER;
+
+    case COL_TYPE_UNSIGNED:
+        return COL_TYPE_NAME_UNSIGNED;
+
+    case COL_TYPE_LONG:
+        return COL_TYPE_NAME_LONG;
+
+    case COL_TYPE_ULONG:
+        return COL_TYPE_NAME_ULONG;
+
+    case COL_TYPE_BINARY:
+        return COL_TYPE_NAME_BINARY;
+
+    case COL_TYPE_DOUBLE:
+        return COL_TYPE_NAME_DOUBLE;
+
+    case COL_TYPE_BOOL:
+        return COL_TYPE_NAME_BOOL;
+
+    default:
+        return COL_TYPE_NAME_UNKNOWN;
     }
 
 }
@@ -207,28 +228,32 @@ int get_data_len(int type, int length)
 {
     int len = 0;
 
-    TRACE_FLOW_STRING("util_get_item_len","Entry point");
-
-    switch(type) {
-        case COL_TYPE_INTEGER:
-        case COL_TYPE_UNSIGNED:
-        case COL_TYPE_LONG:
-        case COL_TYPE_ULONG:
-                                len = 15;
-                                break;
-        case COL_TYPE_STRING:
-        case COL_TYPE_BINARY:
-                                len = length * 2 + 2;
-                                break;
-        case COL_TYPE_DOUBLE:
-                                len = 64;
-                                break;
-        case COL_TYPE_BOOL:
-                                len = 6;
-                                break;
-        default:
-                                len = 0;
-                                break;
+    TRACE_FLOW_STRING("util_get_item_len", "Entry point");
+
+    switch (type) {
+    case COL_TYPE_INTEGER:
+    case COL_TYPE_UNSIGNED:
+    case COL_TYPE_LONG:
+    case COL_TYPE_ULONG:
+        len = 15;
+        break;
+
+    case COL_TYPE_STRING:
+    case COL_TYPE_BINARY:
+        len = length * 2 + 2;
+        break;
+
+    case COL_TYPE_DOUBLE:
+        len = 64;
+        break;
+
+    case COL_TYPE_BOOL:
+        len = 6;
+        break;
+
+    default:
+        len = 0;
+        break;
     }
 
     TRACE_FLOW_STRING("util_get_item_len","Exit point");
@@ -237,27 +262,27 @@ int get_data_len(int type, int length)
 }
 
 /* Copy data escaping characters */
-static int copy_esc(char *dest,char *source,char esc)
+static int copy_esc(char *dest, char *source, char esc)
 {
-    int i=0;
-    int j=0;
+    int i = 0;
+    int j = 0;
 
-    *(dest +j) = esc;
+    dest[j] = esc;
     j++;
 
-    while(*(source+i) != '\0') {
-        if((*(source+i) == '\\') ||
-           (*(source+i) == esc)) {
+    while (source[i]) {
+        if ((source[i] == '\\') ||
+            (source[i] == esc)) {
 
-            *(dest +j) = '\\';
+            dest[j] = '\\';
             j++;
 
         }
-        *(dest +j) = *(source +i);
+        dest[j] = source[i];
         i++;
         j++;
     }
-    *(dest +j) = esc;
+    dest[j] = esc;
     j++;
 
     return j;
@@ -266,30 +291,30 @@ static int copy_esc(char *dest,char *source,char esc)
 /* Grow buffer to accomodate more space */
 int grow_buffer(struct serial_data *buf_data, int len)
 {
-    void *tmp;
+    char *tmp;
 
-    TRACE_FLOW_STRING("grow_buffer","Entry point");
-    TRACE_INFO_NUMBER("Current length: ",buf_data->length);
-    TRACE_INFO_NUMBER("Increment length: ",len);
-    TRACE_INFO_NUMBER("Expected length: ",buf_data->length+len);
-    TRACE_INFO_NUMBER("Current size: ",buf_data->size);
+    TRACE_FLOW_STRING("grow_buffer", "Entry point");
+    TRACE_INFO_NUMBER("Current length: ", buf_data->length);
+    TRACE_INFO_NUMBER("Increment length: ", len);
+    TRACE_INFO_NUMBER("Expected length: ", buf_data->length+len);
+    TRACE_INFO_NUMBER("Current size: ", buf_data->size);
 
     /* Grow buffer if needed */
-    while(buf_data->length+len >= buf_data->size) {
+    while (buf_data->length+len >= buf_data->size) {
         errno = 0;
-        tmp = realloc(buf_data->buffer,buf_data->size+BLOCK_SIZE);
-        if(tmp == NULL) {
-            TRACE_ERROR_NUMBER("Error. Failed to allocate memory. Errno: ",errno);
+        tmp = realloc(buf_data->buffer, buf_data->size + BLOCK_SIZE);
+        if (tmp == NULL) {
+            TRACE_ERROR_NUMBER("Error. Failed to allocate memory. Errno: ", errno);
             return errno;
         }
-        buf_data->buffer = (char *)(tmp);
+        buf_data->buffer = tmp;
         buf_data->size += BLOCK_SIZE;
-        TRACE_INFO_NUMBER("New size: ",buf_data->size);
+        TRACE_INFO_NUMBER("New size: ", buf_data->size);
 
     }
 
-    TRACE_INFO_NUMBER("Final size: ",buf_data->size);
-    TRACE_FLOW_STRING("grow_buffer","Success Exit.");
+    TRACE_INFO_NUMBER("Final size: ", buf_data->size);
+    TRACE_FLOW_STRING("grow_buffer", "Success Exit.");
     return EOK;
 }
 
@@ -298,17 +323,17 @@ int put_marker(struct serial_data *buf_data, void *data, int len)
 {
     int error = EOK;
 
-    TRACE_FLOW_STRING("put_marker","Entry point");
-    TRACE_INFO_NUMBER("Marker length: ",len);
+    TRACE_FLOW_STRING("put_marker", "Entry point");
+    TRACE_INFO_NUMBER("Marker length: ", len);
 
     error = grow_buffer(buf_data, len);
-    if(error) {
-        TRACE_ERROR_NUMBER("grow_buffer failed with: ",error);
+    if (error) {
+        TRACE_ERROR_NUMBER("grow_buffer failed with: ", error);
         return error;
     }
-    memcpy(buf_data->buffer+buf_data->length,data,len);
-    buf_data->length+=len;
-    *(buf_data->buffer+buf_data->length) = '\0';
+    memcpy(buf_data->buffer + buf_data->length, data, len);
+    buf_data->length += len;
+    buf_data->buffer[buf_data->length] = '\0';
 
     TRACE_FLOW_STRING("put_marker","Success exit");
     return error;
@@ -337,21 +362,21 @@ int serialize(char *property_in,
     *dummy = 0;
 
     /* Check is there is buffer. If not allocate */
-    buf_data = (struct serial_data *)(custom_data);
-    if(buf_data == (struct serial_data *)(NULL)) {
-        TRACE_ERROR_STRING("Error.","Storage data is not passed in!");
+    buf_data = (struct serial_data *)custom_data;
+    if (buf_data == NULL) {
+        TRACE_ERROR_STRING("Error.", "Storage data is not passed in!");
         return EINVAL;
     }
-    if(buf_data->buffer == NULL) {
-        TRACE_INFO_STRING("First time use.","Allocating buffer.");
+    if (buf_data->buffer == NULL) {
+        TRACE_INFO_STRING("First time use.", "Allocating buffer.");
         errno = 0;
         buf_data->buffer = malloc(BLOCK_SIZE);
-        if(buf_data->buffer == NULL) {
-            TRACE_ERROR_NUMBER("Error. Failed to allocate memory. Errno: ",errno);
+        if (buf_data->buffer == NULL) {
+            TRACE_ERROR_NUMBER("Error. Failed to allocate memory. Errno: ", errno);
             return errno;
         }
-        *(buf_data->buffer)='\0';
-        buf_data->length=0;
+        buf_data->buffer[0] = '\0';
+        buf_data->length = 0;
         buf_data->size = BLOCK_SIZE;
     }
 
@@ -360,35 +385,37 @@ int serialize(char *property_in,
     TRACE_INFO_STRING("Buffer: ", buf_data->buffer);
 
     /* Check the beginning of the collection */
-    if(type == COL_TYPE_COLLECTION) {
+    if (type == COL_TYPE_COLLECTION) {
         TRACE_INFO_STRING("Serializing collection: ", property_in);
         TRACE_INFO_STRING("First header. ", "");
-        if((error=put_marker(buf_data,"(",1))) return error;
+        error = put_marker(buf_data, "(", 1);
+        if (error != EOK) return error;
         property = TEXT_COLLECTION;
         property_len = TEXT_COLLEN;
         data = property_in;
-        length = property_len_in+1;
-        type=COL_TYPE_STRING;
+        length = property_len_in + 1;
+        type = COL_TYPE_STRING;
         buf_data->nest_level++;
     }
     /* Check for subcollections */
-    else if(type==COL_TYPE_COLLECTIONREF) {
+    else if (type == COL_TYPE_COLLECTIONREF) {
         /* Skip */
-        TRACE_FLOW_STRING("serialize","skip reference return");
+        TRACE_FLOW_STRING("serialize", "skip reference return");
         return EOK;
     }
     /* Check for the end of the collection */
-    else if(type==COL_TYPE_END) {
-        if((buf_data->length>0) &&
-           (*(buf_data->buffer+buf_data->length-1) == ',')) {
+    else if (type == COL_TYPE_END) {
+        if ((buf_data->length > 0) &&
+            (buf_data->buffer[buf_data->length-1] == ',')) {
             buf_data->length--;
-            *(buf_data->buffer+buf_data->length) = '\0';
+            buf_data->buffer[buf_data->length] = '\0';
         }
-        if(buf_data->nest_level>0) {
+        if (buf_data->nest_level > 0) {
             buf_data->nest_level--;
-            if((error=put_marker(buf_data,")",1))) return error;
+            error = put_marker(buf_data, ")", 1);
+            if (error != EOK) return error;
         }
-        TRACE_FLOW_STRING("serialize","end collection item processed returning");
+        TRACE_FLOW_STRING("serialize", "end collection item processed returning");
         return EOK;
     }
     else {
@@ -402,9 +429,9 @@ int serialize(char *property_in,
     TRACE_INFO_NUMBER("Property length: ", property_len);
 
     /* Start with property and "=" */
-    if((error=put_marker(buf_data,property,property_len)) ||
-       (error=put_marker(buf_data,"=",1))) {
-        TRACE_ERROR_NUMBER("put_marker returned error: ",error);
+    if ((error = put_marker(buf_data, property, property_len)) ||
+        (error = put_marker(buf_data, "=", 1))) {
+        TRACE_ERROR_NUMBER("put_marker returned error: ", error);
         return error;
     }
     /* Get projected length of the item */
@@ -413,60 +440,77 @@ int serialize(char *property_in,
     TRACE_INFO_STRING("Buffer so far: ", buf_data->buffer);
 
     /* Make sure we have enough space */
-    if((error=grow_buffer(buf_data,len))) {
-        TRACE_ERROR_NUMBER("grow_buffer returned error: ",error);
+    if ((error = grow_buffer(buf_data, len))) {
+        TRACE_ERROR_NUMBER("grow_buffer returned error: ", error);
         return error;
     }
 
     /* Add the value */
-    switch(type) {
-        case COL_TYPE_STRING:
-                                /* Escape double quotes */
-                                len = copy_esc(buf_data->buffer+buf_data->length,(char *)(data),'"');
-                                break;
-        case COL_TYPE_BINARY:
-                                *(buf_data->buffer+buf_data->length) = '\'';
-                                for(i=0;i<length;i++) sprintf(buf_data->buffer+buf_data->length+i*2 + 1,"%02X",*((unsigned char *)(data+i)));
-                                len = length * 2 + 1;
-                                *(buf_data->buffer+buf_data->length + len) = '\'';
-                                len++;
-                                break;
-        case COL_TYPE_INTEGER:
-                                len = sprintf(buf_data->buffer+buf_data->length,"%d",*((int *)(data)));
-                                break;
-        case COL_TYPE_UNSIGNED:
-                                len = sprintf(buf_data->buffer+buf_data->length,"%u",*((unsigned int *)(data)));
-                                break;
-        case COL_TYPE_LONG:
-                                len = sprintf(buf_data->buffer+buf_data->length,"%ld",*((long *)(data)));
-                                break;
-        case COL_TYPE_ULONG:
-                                len = sprintf(buf_data->buffer+buf_data->length,"%lu",*((unsigned long *)(data)));
-                                break;
-        case COL_TYPE_DOUBLE:
-                                len = sprintf(buf_data->buffer+buf_data->length,"%.4f",*((double *)(data)));
-                                break;
-        case COL_TYPE_BOOL:
-                                len = sprintf(buf_data->buffer+buf_data->length,"%s",(*((unsigned char *)(data)) == '\0') ? "false" : "true");
-                                break;
-        default:
-                                *(buf_data->buffer+buf_data->length) = '\0';
-                                len = 0;
-                                break;
+    switch (type) {
+    case COL_TYPE_STRING:
+        /* Escape double quotes */
+        len = copy_esc(&buf_data->buffer[buf_data->length], (char *)(data), '"');
+        break;
+
+    case COL_TYPE_BINARY:
+        buf_data->buffer[buf_data->length] = '\'';
+        for (i = 0; i < length; i++)
+            sprintf(&buf_data->buffer[buf_data->length + i *2] + 1,
+                    "%02X", (unsigned int)(((unsigned char *)(data))[i]));
+        len = length * 2 + 1;
+        buf_data->buffer[buf_data->length + len] = '\'';
+        len++;
+        break;
+
+    case COL_TYPE_INTEGER:
+        len = sprintf(&buf_data->buffer[buf_data->length],
+                      "%d", *((int *)(data)));
+        break;
+
+    case COL_TYPE_UNSIGNED:
+        len = sprintf(&buf_data->buffer[buf_data->length],
+                      "%u", *((unsigned int *)(data)));
+        break;
+
+    case COL_TYPE_LONG:
+        len = sprintf(&buf_data->buffer[buf_data->length],
+                      "%ld", *((long *)(data)));
+        break;
+
+    case COL_TYPE_ULONG:
+        len = sprintf(&buf_data->buffer[buf_data->length],
+                      "%lu", *((unsigned long *)(data)));
+        break;
+
+    case COL_TYPE_DOUBLE:
+        len = sprintf(&buf_data->buffer[buf_data->length],
+                      "%.4f", *((double *)(data)));
+        break;
+
+    case COL_TYPE_BOOL:
+        len = sprintf(&buf_data->buffer[buf_data->length],
+                      "%s", (*((unsigned char *)(data))) ? "true" : "false");
+        break;
+
+    default:
+        buf_data->buffer[buf_data->length] = '\0';
+        len = 0;
+        break;
     }
 
     /* Adjust length */
-    buf_data->length+=len;
-    *(buf_data->buffer+buf_data->length) = '\0';
+    buf_data->length += len;
+    buf_data->buffer[buf_data->length] = '\0';
 
     /* Always put a comma at the end */
-    if((error=put_marker(buf_data,",",1))) {
-        TRACE_ERROR_NUMBER("put_marker returned error: ",error);
+    error = put_marker(buf_data, ",", 1);
+    if (error != EOK) {
+        TRACE_ERROR_NUMBER("put_marker returned error: ", error);
         return error;
     }
 
-    TRACE_INFO_STRING("Data: ",buf_data->buffer);
-    TRACE_FLOW_STRING("serialize","Exit point");
+    TRACE_INFO_STRING("Data: ", buf_data->buffer);
+    TRACE_FLOW_STRING("serialize", "Exit point");
     return EOK;
 
 }
@@ -481,15 +525,19 @@ int print_collection(struct collection_item *handle)
 
     printf("COLLECTION:\n");
 
-    buf_data.buffer=NULL;
-    buf_data.length=0;
-    buf_data.size=0;
-    buf_data.nest_level=0;
+    buf_data.buffer = NULL;
+    buf_data.length = 0;
+    buf_data.size = 0;
+    buf_data.nest_level = 0;
 
     /* Traverse collection */
-    error = traverse_collection(handle,COL_TRAVERSE_DEFAULT | COL_TRAVERSE_END ,serialize,(void *)(&buf_data));
-    if(error) printf("Error traversing collection %d\n",error);
-    else printf("%s\n",buf_data.buffer);
+    error = traverse_collection(handle,
+                                COL_TRAVERSE_DEFAULT | COL_TRAVERSE_END ,
+                                serialize, (void *)(&buf_data));
+    if (error)
+        printf("Error traversing collection %d\n", error);
+    else
+        printf("%s\n", buf_data.buffer);
 
     free(buf_data.buffer);
 
@@ -500,41 +548,42 @@ int print_collection(struct collection_item *handle)
 /* Print the collection using iterator */
 int print_collection2(struct collection_item *handle)
 {
-    struct collection_iterator *iterator = (struct collection_iterator *)(NULL);
+    struct collection_iterator *iterator = NULL;
     int error = EOK;
-    struct collection_item *item = (struct collection_item *)(NULL);
-    int nest_level=0;
+    struct collection_item *item = NULL;
+    int nest_level = 0;
     int dummy = 0;
     int line = 1;
 
     TRACE_FLOW_STRING("print_collection2", "Entry");
 
     /* If we have something to print print it */
-    if(handle == (struct collection_item *)(NULL)) {
-        TRACE_ERROR_STRING("No error list","");
+    if (handle == NULL) {
+        TRACE_ERROR_STRING("No error list", "");
         return EINVAL;
     }
 
     /* Bind iterator */
-    error =  bind_iterator(&iterator,handle,COL_TRAVERSE_DEFAULT|COL_TRAVERSE_END|COL_TRAVERSE_SHOWSUB);
-    if(error) {
-        TRACE_ERROR_NUMBER("Error (bind):",error);
+    error = bind_iterator(&iterator, handle,
+                          COL_TRAVERSE_DEFAULT| COL_TRAVERSE_END| COL_TRAVERSE_SHOWSUB);
+    if (error) {
+        TRACE_ERROR_NUMBER("Error (bind):", error);
         return error;
     }
 
     do {
         /* Loop through a collection */
         error = iterate_collection(iterator, &item);
-        if(error) {
-            TRACE_ERROR_NUMBER("Error (iterate):",error);
+        if (error) {
+            TRACE_ERROR_NUMBER("Error (iterate):", error);
             unbind_iterator(iterator);
             return error;
         }
 
         /* Are we done ? */
-        if(item == (struct collection_item *)(NULL)) break;
+        if (item == NULL) break;
 
-        if(item->type != COL_TYPE_END) printf("%05d",line);
+        if (item->type != COL_TYPE_END) printf("%05d", line);
 
         debug_handle(item->property,
                      item->property_len,
@@ -564,21 +613,25 @@ int print_item(struct collection_item *handle, char *name)
 
     printf("FIND ITEM:\n");
 
-    buf_data.buffer=NULL;
-    buf_data.length=0;
-    buf_data.size=0;
-    buf_data.nest_level=0;
+    buf_data.buffer = NULL;
+    buf_data.length = 0;
+    buf_data.size = 0;
+    buf_data.nest_level = 0;
 
-    error =  get_item_and_do(handle, name, COL_TYPE_ANY,COL_TRAVERSE_DEFAULT, serialize,&buf_data);
-    if(error) printf("Error searching collection %d\n",error);
+    error =  get_item_and_do(handle, name, COL_TYPE_ANY,
+                             COL_TRAVERSE_DEFAULT, serialize, &buf_data);
+    if(error) printf("Error searching collection %d\n", error);
     else {
-        if(buf_data.buffer != NULL) {
-            if(buf_data.length> 0) buf_data.length--;
-            *(buf_data.buffer+buf_data.length)= '\0',
-            printf("%s\n",buf_data.buffer);
+        if (buf_data.buffer != NULL) {
+            if (buf_data.length > 0) buf_data.length--;
+            buf_data.buffer[buf_data.length] = '\0',
+            printf("%s\n", buf_data.buffer);
             free(buf_data.buffer);
         }
-        else printf("Name %s is not found in the collection %s.\n",name,handle->property);
+        else {
+            printf("Name %s is not found in the collection %s.\n",
+                   name, handle->property);
+        }
     }
 
     TRACE_FLOW_NUMBER("print_item returning", error);