From 7e0e2529c6b59e092317c9f4a95316b72e999336 Mon Sep 17 00:00:00 2001 From: Simo Sorce Date: Tue, 7 Apr 2009 14:25:28 -0400 Subject: Style fixes for /common --- common/collection/collection.c | 1743 +++++++++++++++++++--------------- common/collection/collection.h | 327 ++++--- common/collection/collection_priv.h | 2 +- common/collection/collection_tools.c | 585 ++++++------ common/ini/ini_config.c | 863 +++++++++-------- common/trace/trace.h | 75 +- 6 files changed, 1977 insertions(+), 1618 deletions(-) (limited to 'common') diff --git a/common/collection/collection.c b/common/collection/collection.c index 4a5b50443..79e4421ff 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,×tr); - if(error) { - TRACE_ERROR_NUMBER("search failed with error:",error); + error = get_item(ci, TS_NAME, COL_TYPE_STRING, + COL_TRAVERSE_IGNORE, ×tr); + 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 bccf3e3cf..ddb741258 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 8dd6d8022..38d9012a6 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 ed44707d6..63c037604 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;icount, - ((struct collection_header *)(data))->reference_count, - ((struct collection_header *)(data))->class); - for(i=0;icount, + ((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;ibuffer+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); diff --git a/common/ini/ini_config.c b/common/ini/ini_config.c index fafc565d7..01acdd694 100644 --- a/common/ini/ini_config.c +++ b/common/ini/ini_config.c @@ -68,19 +68,21 @@ /* Function to return parsing error */ inline const char *parsing_error_str(int parsing_error) { - char *placeholder= _("Unknown error."); - char *str_error[] = { _("Data is too long."), - _("No closing bracket."), - _("Section name is missing."), - _("Section name is too long."), - _("Equal sign is missing."), - _("Property name is missing."), - _("Property name is too long.") + const char *placeholder= _("Unknown error."); + const char *str_error[] = { _("Data is too long."), + _("No closing bracket."), + _("Section name is missing."), + _("Section name is too long."), + _("Equal sign is missing."), + _("Property name is missing."), + _("Property name is too long.") }; /* Check the range */ - if((parsing_error < 1) || (parsing_error > ERR_MAXPARSE)) return (const char *)placeholder; - else return (const char *)(str_error[parsing_error-1]); + if ((parsing_error < 1) || (parsing_error > ERR_MAXPARSE)) + return placeholder; + else + return str_error[parsing_error-1]; } #else @@ -88,8 +90,8 @@ inline const char *parsing_error_str(int parsing_error) inline const char *parsing_error_str(int parsing_error) { - char *placeholder= _("Parsing errors are not compiled."); - return (const char*)(placeholder); + const char *placeholder= _("Parsing errors are not compiled."); + return placeholder; } #endif @@ -104,19 +106,23 @@ static int add_or_update(struct collection_item *current_section, int type) { int found = COL_NOMATCH; - int error = EOK; + int error; TRACE_FLOW_STRING("add_or_update", "Entry"); - (void)is_item_in_collection(current_section,key,COL_TYPE_ANY,COL_TRAVERSE_IGNORE,&found); + error = is_item_in_collection(current_section, key, + COL_TYPE_ANY, COL_TRAVERSE_IGNORE, &found); - if(found == COL_MATCH) { + if (found == COL_MATCH) { TRACE_INFO_STRING("Updating...", ""); - error = update_property(current_section,key,type,value,length,COL_TRAVERSE_IGNORE); + error = update_property(current_section, + key, type, value, length, + COL_TRAVERSE_IGNORE); } else { TRACE_INFO_STRING("Adding...", ""); - error = add_any_property(current_section,NULL,key,type,value,length); + error = add_any_property(current_section, NULL, + key, type, value, length); } TRACE_FLOW_NUMBER("add_or_update returning", error); @@ -137,7 +143,7 @@ static int ini_to_collection(const char *filename, int section_count = 0; char *key = NULL; char *value = NULL; - struct collection_item *current_section = (struct collection_item *)(NULL); + struct collection_item *current_section = NULL; int length; int ext_err = -1; struct parse_error pe; @@ -148,17 +154,17 @@ static int ini_to_collection(const char *filename, /* Open file for reading */ file = fopen(filename,"r"); - if(file == NULL) { + if (file == NULL) { error = errno; TRACE_ERROR_NUMBER("Failed to open file - but this is OK", error); return EOK; } /* Open the collection of errors */ - if(error_list != (struct collection_item **)(NULL)) { - *error_list = (struct collection_item *)(NULL); - error = create_collection(error_list,(char *)filename,COL_CLASS_INI_PERROR); - if(error) { + if (error_list != NULL) { + *error_list = NULL; + error = create_collection(error_list, filename, COL_CLASS_INI_PERROR); + if (error) { TRACE_ERROR_NUMBER("Failed to create error collection", error); fclose(file); return EOK; @@ -167,112 +173,125 @@ static int ini_to_collection(const char *filename, } /* Read file lines */ - while((status = read_line(file,&key,&value,&length,&ext_err)) != RET_EOF) { + while (1) { + status = read_line(file, &key, &value, &length, &ext_err); + if (status == RET_EOF) break; line++; - switch(status) { - case RET_PAIR: - /* Do we have a section at the top of the file ? */ - if(section_count == 0) { - /* Check if collection already exists */ - error = get_collection_reference(ini_config,¤t_section,INI_DEFAULT_SECTION); - if(error != EOK) { - /* Create default collection */ - if((error=create_collection(¤t_section,INI_DEFAULT_SECTION,COL_CLASS_INI_SECTION)) || - (error=add_collection_to_collection(ini_config,NULL,NULL, - current_section, - COL_ADD_MODE_REFERENCE))) { - TRACE_ERROR_NUMBER("Failed to create collection", error); - fclose(file); - destroy_collection(current_section); - if(created) destroy_collection(*error_list); - return error; - } - } - section_count++; - } - - /* Put value into the collection */ - if((error=add_or_update(current_section,key,value,length,COL_TYPE_STRING))) { - TRACE_ERROR_NUMBER("Failed to add pair to collection", error); - fclose(file); - destroy_collection(current_section); - if(created) destroy_collection(*error_list); - return error; - } - break; - - case RET_SECTION: - /* Read a new section */ + switch (status) { + case RET_PAIR: + /* Do we have a section at the top of the file ? */ + if (section_count == 0) { + /* Check if collection already exists */ + error = get_collection_reference(ini_config, ¤t_section, + INI_DEFAULT_SECTION); + if (error != EOK) { + /* Create default collection */ + if ((error = create_collection(¤t_section, + INI_DEFAULT_SECTION, + COL_CLASS_INI_SECTION)) || + (error = add_collection_to_collection(ini_config, + NULL,NULL, + current_section, + COL_ADD_MODE_REFERENCE))) { + TRACE_ERROR_NUMBER("Failed to create collection", error); + fclose(file); destroy_collection(current_section); - current_section = (struct collection_item *)(NULL); - - error = get_collection_reference(ini_config,¤t_section,key); - if(error != EOK) { - /* Create default collection */ - if((error=create_collection(¤t_section,key,COL_CLASS_INI_SECTION)) || - (error=add_collection_to_collection(ini_config,NULL,NULL, - current_section, - COL_ADD_MODE_REFERENCE))) { - TRACE_ERROR_NUMBER("Failed to add collection", error); - fclose(file); - destroy_collection(current_section); - if(created) destroy_collection(*error_list); - return error; - } - } - section_count++; - break; - - case RET_EMPTY: - TRACE_INFO_STRING("Empty string", ""); - break; - - case RET_COMMENT: - TRACE_INFO_STRING("Comment", ""); - break; - - case RET_ERROR: - pe.line = line; - pe.error = ext_err; - error = add_binary_property(*error_list,NULL, ERROR_TXT,(void *)&pe,sizeof(pe)); - if(error) { - TRACE_ERROR_NUMBER("Failed to add error to collection", error); - fclose(file); - destroy_collection(current_section); - if(created) destroy_collection(*error_list); - return error; - } - /* Exit if there was an error parsing file */ - if(error_level != INI_STOP_ON_NONE) { - TRACE_ERROR_STRING("Invalid format of the file", ""); - destroy_collection(current_section); - fclose(file); - return EIO; - } - break; - case RET_INVALID: - default: - pe.line = line; - pe.error = ext_err; - error = add_binary_property(*error_list,NULL, WARNING_TXT,(void *)&pe,sizeof(pe)); - if(error) { - TRACE_ERROR_NUMBER("Failed to add warning to collection", error); - fclose(file); - destroy_collection(current_section); - if(created) destroy_collection(*error_list); - return error; - } - /* Exit if we are told to exit on warnings */ - if(error_level == INI_STOP_ON_ANY) { - TRACE_ERROR_STRING("Invalid format of the file", ""); - if(created) destroy_collection(current_section); - fclose(file); - return EIO; - } - TRACE_ERROR_STRING("Invalid string", ""); - break; + if (created) destroy_collection(*error_list); + return error; + } + } + section_count++; + } + + /* Put value into the collection */ + error = add_or_update(current_section, + key, value, length, COL_TYPE_STRING); + if (error != EOK) { + TRACE_ERROR_NUMBER("Failed to add pair to collection", error); + fclose(file); + destroy_collection(current_section); + if (created) destroy_collection(*error_list); + return error; + } + break; + + case RET_SECTION: + /* Read a new section */ + destroy_collection(current_section); + current_section = NULL; + + error = get_collection_reference(ini_config, ¤t_section, key); + if (error != EOK) { + /* Create default collection */ + if ((error = create_collection(¤t_section, key, + COL_CLASS_INI_SECTION)) || + (error = add_collection_to_collection(ini_config, + NULL, NULL, + current_section, + COL_ADD_MODE_REFERENCE))) { + TRACE_ERROR_NUMBER("Failed to add collection", error); + fclose(file); + destroy_collection(current_section); + if (created) destroy_collection(*error_list); + return error; + } + } + section_count++; + break; + + case RET_EMPTY: + TRACE_INFO_STRING("Empty string", ""); + break; + + case RET_COMMENT: + TRACE_INFO_STRING("Comment", ""); + break; + + case RET_ERROR: + pe.line = line; + pe.error = ext_err; + error = add_binary_property(*error_list, NULL, + ERROR_TXT, &pe, sizeof(pe)); + if (error) { + TRACE_ERROR_NUMBER("Failed to add error to collection", error); + fclose(file); + destroy_collection(current_section); + if (created) destroy_collection(*error_list); + return error; + } + /* Exit if there was an error parsing file */ + if (error_level != INI_STOP_ON_NONE) { + TRACE_ERROR_STRING("Invalid format of the file", ""); + destroy_collection(current_section); + fclose(file); + return EIO; + } + break; + + case RET_INVALID: + default: + pe.line = line; + pe.error = ext_err; + error = add_binary_property(*error_list, NULL, + WARNING_TXT, &pe, sizeof(pe)); + if (error) { + TRACE_ERROR_NUMBER("Failed to add warning to collection", error); + fclose(file); + destroy_collection(current_section); + if (created) destroy_collection(*error_list); + return error; + } + /* Exit if we are told to exit on warnings */ + if (error_level == INI_STOP_ON_ANY) { + TRACE_ERROR_STRING("Invalid format of the file", ""); + if (created) destroy_collection(current_section); + fclose(file); + return EIO; + } + TRACE_ERROR_STRING("Invalid string", ""); + break; } ext_err = -1; } @@ -304,39 +323,44 @@ int config_from_file(const char *application, TRACE_FLOW_STRING("config_from_file", "Entry"); - if((ini_config == (struct collection_item **)(NULL)) || - (application == NULL)) { + if ((ini_config == NULL) || + (application == NULL)) { TRACE_ERROR_NUMBER("Invalid argument", EINVAL); return EINVAL; } /* Create collection if needed */ - if(*ini_config == (struct collection_item *)(NULL)) { - if((error=create_collection(ini_config,(char *)application,COL_CLASS_INI_CONFIG))) { + if (*ini_config == NULL) { + error = create_collection(ini_config, + application, + COL_CLASS_INI_CONFIG); + if (error != EOK) { TRACE_ERROR_NUMBER("Failed to create collection", error); return error; } created = 1; } /* Is the collection of the right class? */ - else if(is_of_class(*ini_config,COL_CLASS_INI_CONFIG)) { + else if (is_of_class(*ini_config, COL_CLASS_INI_CONFIG)) { TRACE_ERROR_NUMBER("Wrong collection type", EINVAL); return EINVAL; } /* Do the actual work */ - error = ini_to_collection((char *)config_file, *ini_config,error_level, error_list); + error = ini_to_collection(config_file, *ini_config, + error_level, error_list); /* In case of error when we created collection - delete it */ - if((error) && (created)) { + if (error && created) { destroy_collection(*ini_config); - *ini_config = (struct collection_item *)(NULL); + *ini_config = NULL; } TRACE_FLOW_NUMBER("config_from_file. Returns", error); return error; } -/* Read default config file and then overwrite it with a specific one from the directory */ +/* Read default config file and then overwrite it with a specific one + * from the directory */ int config_for_app(const char *application, const char *config_file, const char *config_dir, @@ -344,131 +368,142 @@ int config_for_app(const char *application, int error_level, struct collection_item **error_set) { - int error=EOK; + int error = EOK; char *file_name; - struct collection_item *error_list_common = (struct collection_item *)(NULL); - struct collection_item *error_list_specific = (struct collection_item *)(NULL); - struct collection_item **pass_common = (struct collection_item **)(NULL); - struct collection_item **pass_specific = (struct collection_item **)(NULL); + struct collection_item *error_list_common = NULL; + struct collection_item *error_list_specific = NULL; + struct collection_item **pass_common = NULL; + struct collection_item **pass_specific = NULL; int created = 0; TRACE_FLOW_STRING("config_to_collection", "Entry"); - if(ini_config == (struct collection_item **)(NULL)) { + if (ini_config == NULL) { TRACE_ERROR_NUMBER("Failed to create collection", EINVAL); return EINVAL; } /* Prepare error collection pointers */ - if(error_set != (struct collection_item **)(NULL)) { + if (error_set != NULL) { TRACE_INFO_STRING("Error set is not NULL", "preparing error set"); pass_common = &error_list_common; pass_specific = &error_list_specific; - *error_set = (struct collection_item *)(NULL); + *error_set = NULL; /* Construct the overarching error collection */ - if((error=create_collection(error_set,FILE_ERROR_SET,COL_CLASS_INI_PESET))) { + error = create_collection(error_set, + FILE_ERROR_SET, + COL_CLASS_INI_PESET); + if (error != EOK) { TRACE_ERROR_NUMBER("Failed to create collection", error); return error; } } else { TRACE_INFO_STRING("No error set. Errors will not be captured", ""); - pass_common = (struct collection_item **)(NULL); - pass_specific = (struct collection_item **)(NULL); + pass_common = NULL; + pass_specific = NULL; } /* Create collection if needed */ - if(*ini_config == (struct collection_item *)(NULL)) { + if (*ini_config == NULL) { TRACE_INFO_STRING("New config collection. Allocate.", ""); - if((error=create_collection(ini_config,(char *)application,COL_CLASS_INI_CONFIG))) { + error = create_collection(ini_config, + application, + COL_CLASS_INI_CONFIG); + if (error != EOK) { TRACE_ERROR_NUMBER("Failed to create collection", error); destroy_collection(*error_set); - *error_set = (struct collection_item *)(NULL); + *error_set = NULL; return error; } } /* Is the collection of the right class? */ - else if(is_of_class(*ini_config,COL_CLASS_INI_CONFIG)) { + else if (is_of_class(*ini_config, COL_CLASS_INI_CONFIG)) { TRACE_ERROR_NUMBER("Wrong collection type", EINVAL); return EINVAL; } /* Read master file */ - if(config_file != NULL) { + if (config_file != NULL) { TRACE_INFO_STRING("Reading master file:", config_file); - if((error = ini_to_collection(config_file,*ini_config, error_level, pass_common))) { + error = ini_to_collection(config_file, *ini_config, + error_level, pass_common); + if (error != EOK) { TRACE_ERROR_NUMBER("Failed to read master file", error); /* In case of error when we created collection - delete it */ - if((error) && (created)) { + if(error && created) { destroy_collection(*ini_config); - *ini_config = (struct collection_item *)(NULL); + *ini_config = NULL; } /* We do not clear the error_set here */ return error; } /* Add error results if any to the overarching error collection */ - if((pass_common != (struct collection_item **)(NULL)) && - (*pass_common != (struct collection_item *)(NULL))) { + if ((pass_common != NULL) && (*pass_common != NULL)) { TRACE_INFO_STRING("Process erros resulting from file:", config_file); - error = add_collection_to_collection(*error_set,NULL,NULL,*pass_common,COL_ADD_MODE_EMBED); - if(error) { - if(created) { + error = add_collection_to_collection(*error_set, NULL, NULL, + *pass_common, + COL_ADD_MODE_EMBED); + if (error) { + if (created) { destroy_collection(*ini_config); - *ini_config = (struct collection_item *)(NULL); + *ini_config = NULL; } destroy_collection(*error_set); - *error_set = (struct collection_item *)(NULL); + *error_set = NULL; TRACE_ERROR_NUMBER("Failed to add error collection to another error collection", error); return error; } } } - if(config_dir != NULL) { + if (config_dir != NULL) { /* Get specific application file */ file_name = malloc(strlen(config_dir) + strlen(application) + NAME_OVERHEAD); - if(file_name == NULL) { + if (file_name == NULL) { error = errno; TRACE_ERROR_NUMBER("Failed to allocate memory for file name", error); /* In case of error when we created collection - delete it */ - if((error) && (created)) { + if(error && created) { destroy_collection(*ini_config); - *ini_config = (struct collection_item *)(NULL); + *ini_config = NULL; } destroy_collection(*error_set); - *error_set = (struct collection_item *)(NULL); + *error_set = NULL; return error; } - sprintf(file_name,"%s%s%s.conf",config_dir, SLASH, application); + sprintf(file_name, "%s%s%s.conf", config_dir, SLASH, application); TRACE_INFO_STRING("Opening file:", file_name); /* Read master file */ - error = ini_to_collection(file_name,*ini_config,error_level,pass_specific); + error = ini_to_collection(file_name, *ini_config, + error_level, pass_specific); free(file_name); - if(error) { + if (error) { TRACE_ERROR_NUMBER("Failed to read specific application file", error); /* In case of error when we created collection - delete it */ - if((error) && (created)) { + if (error && created) { destroy_collection(*ini_config); - *ini_config = (struct collection_item *)(NULL); + *ini_config = NULL; } /* We do not clear the error_set here */ return error; } /* Add error results if any to the overarching error collection */ - if((pass_specific != (struct collection_item **)(NULL)) && - (*pass_specific != (struct collection_item *)(NULL))) { + if ((pass_specific != NULL) && (*pass_specific != NULL)) { TRACE_INFO_STRING("Process erros resulting from file:", file_name); - error = add_collection_to_collection(*error_set,NULL,NULL,*pass_specific,COL_ADD_MODE_EMBED); - if(error){ - if(created) { + error = add_collection_to_collection(*error_set, NULL, NULL, + *pass_specific, + COL_ADD_MODE_EMBED); + if (error) { + if (created) { destroy_collection(*ini_config); - *ini_config = (struct collection_item *)(NULL); + *ini_config = NULL; } destroy_collection(*error_set); - *error_set = (struct collection_item *)(NULL); + *error_set = NULL; TRACE_ERROR_NUMBER("Failed to add error collection to another error collection", error); return error; } @@ -480,100 +515,100 @@ int config_for_app(const char *application, } /* Reads a line from the file */ -int read_line(FILE *file,char **key,char **value, int *length, int *ext_error) +int read_line(FILE *file, char **key,char **value, int *length, int *ext_error) { - char *res = NULL; + char *res; char buf[BUFFER_SIZE+1]; - int len = 0; - char *buffer = NULL; - int i = 0; - char *eq = NULL; + int len; + char *buffer; + int i; + char *eq; - TRACE_FLOW_STRING("read_line","Entry"); + TRACE_FLOW_STRING("read_line", "Entry"); *ext_error = 0; buffer = buf; /* Get data from file */ - res = fgets(buffer,BUFFER_SIZE,file); - if(res == NULL) { - TRACE_ERROR_STRING("Read nothing",""); + res = fgets(buffer, BUFFER_SIZE, file); + if (res == NULL) { + TRACE_ERROR_STRING("Read nothing", ""); return RET_EOF; } len = strlen(buffer); - if(len == 0) { - TRACE_ERROR_STRING("Nothing was read.",""); + if (len == 0) { + TRACE_ERROR_STRING("Nothing was read.", ""); return RET_EMPTY; } /* Added \r just in case we deal with Windows in future */ - if((*(buffer + len - 1) != '\n') && (*(buffer + len - 1) != '\r')) { - TRACE_ERROR_STRING("String it too big!",""); + if ((buffer[len - 1] != '\n') && (buffer[len - 1] != '\r')) { + TRACE_ERROR_STRING("String it too big!", ""); *ext_error = ERR_LONGDATA; return RET_ERROR; } /* Ingnore comments */ - if((*buffer == ';') || (*buffer == '#')) { - TRACE_FLOW_STRING("Comment",buf); + if ((*buffer == ';') || (*buffer == '#')) { + TRACE_FLOW_STRING("Comment", buf); return RET_COMMENT; } - TRACE_INFO_STRING("BUFFER before trimming:",buffer); + TRACE_INFO_STRING("BUFFER before trimming:", buffer); /* Trucate trailing spaces and CRs */ - while(isspace(*(buffer + len - 1))) { - *(buffer + len - 1) = '\0'; + while (isspace(buffer[len - 1])) { + buffer[len - 1] = '\0'; len--; } - TRACE_INFO_STRING("BUFFER after trimming trailing spaces:",buffer); + TRACE_INFO_STRING("BUFFER after trimming trailing spaces:", buffer); /* Trucate leading spaces */ - while(isspace(*buffer)) { + while (isspace(*buffer)) { buffer++; len--; } - TRACE_INFO_STRING("BUFFER after trimming leading spaces:",buffer); - TRACE_INFO_NUMBER("BUFFER length:",len); + TRACE_INFO_STRING("BUFFER after trimming leading spaces:", buffer); + TRACE_INFO_NUMBER("BUFFER length:", len); /* Empty line */ - if(len == 0) { - TRACE_FLOW_STRING("Empty line",buf); + if (len == 0) { + TRACE_FLOW_STRING("Empty line", buf); return RET_EMPTY; } /* Section */ - if(*buffer == '[') { - if(*(buffer+len-1) != ']') { - TRACE_ERROR_STRING("Invalid format for section",buf); + if (*buffer == '[') { + if (buffer[len-1] != ']') { + TRACE_ERROR_STRING("Invalid format for section", buf); *ext_error = ERR_NOCLOSESEC; return RET_ERROR; } buffer++; len--; - while(isspace(*(buffer))) { + while (isspace(*buffer)) { buffer++; len--; } - if(len == 0) { - TRACE_ERROR_STRING("Invalid format for section",buf); + if (len == 0) { + TRACE_ERROR_STRING("Invalid format for section", buf); *ext_error = ERR_NOSECTION; return RET_ERROR; } - *(buffer + len - 1) = '\0'; + buffer[len - 1] = '\0'; len--; - while(isspace(*(buffer + len - 1))) { - *(buffer + len - 1) = '\0'; + while (isspace(buffer[len - 1])) { + buffer[len - 1] = '\0'; len--; } - if(len >= MAX_KEY) { - TRACE_ERROR_STRING("Section name is too long",buf); + if (len >= MAX_KEY) { + TRACE_ERROR_STRING("Section name is too long", buf); *ext_error = ERR_SECTIONLONG; return RET_ERROR; } @@ -584,9 +619,9 @@ int read_line(FILE *file,char **key,char **value, int *length, int *ext_error) /* Assume we are dealing with the K-V here */ /* Find "=" */ - eq = strchr(buffer,'='); - if(eq == NULL) { - TRACE_ERROR_STRING("No equal sign",buf); + eq = strchr(buffer, '='); + if (eq == NULL) { + TRACE_ERROR_STRING("No equal sign", buf); *ext_error = ERR_NOEQUAL; return RET_BEST_EFFORT; } @@ -595,26 +630,26 @@ int read_line(FILE *file,char **key,char **value, int *length, int *ext_error) /* Strip spaces around "=" */ i = eq - buffer - 1; - while((i >= 0) && isspace(*(buffer + i))) i--; - if(i<0) { - TRACE_ERROR_STRING("No key",buf); + while ((i >= 0) && isspace(buffer[i])) i--; + if (i < 0) { + TRACE_ERROR_STRING("No key", buf); *ext_error = ERR_NOKEY; return RET_BEST_EFFORT; } /* Copy key into provided buffer */ if(i >= MAX_KEY) { - TRACE_ERROR_STRING("Section name is too long",buf); + TRACE_ERROR_STRING("Section name is too long", buf); *ext_error = ERR_LONGKEY; return RET_BEST_EFFORT; } *key = buffer; - *(buffer+i+1) = '\0'; - TRACE_INFO_STRING("KEY:",*key); + buffer[i + 1] = '\0'; + TRACE_INFO_STRING("KEY:", *key); eq++; len--; - while(isspace(*eq)) { + while (isspace(*eq)) { eq++; len--; } @@ -623,10 +658,10 @@ int read_line(FILE *file,char **key,char **value, int *length, int *ext_error) /* Make sure we include trailing 0 into data */ *length = len + 1; - TRACE_INFO_STRING("VALUE:",*value); - TRACE_INFO_NUMBER("LENGTH:",*length); + TRACE_INFO_STRING("VALUE:", *value); + TRACE_INFO_NUMBER("LENGTH:", *length); - TRACE_FLOW_STRING("read_line","Exit"); + TRACE_FLOW_STRING("read_line", "Exit"); return RET_PAIR; } @@ -637,64 +672,64 @@ void print_file_parsing_errors(FILE *file, { struct collection_iterator *iterator; int error; - struct collection_item *item = (struct collection_item *)(NULL); + struct collection_item *item = NULL; struct parse_error *pe; unsigned int count; TRACE_FLOW_STRING("print_file_parsing_errors", "Entry"); /* If we have something to print print it */ - if(error_list == (struct collection_item *)(NULL)) { + if (error_list == NULL) { TRACE_ERROR_STRING("No error list",""); return; } /* Make sure we go the right collection */ - if(!is_of_class(error_list,COL_CLASS_INI_PERROR)) { - TRACE_ERROR_STRING("Wrong collection class:",WRONG_COLLECTION); - fprintf(file,"%s\n",WRONG_COLLECTION); + if (!is_of_class(error_list, COL_CLASS_INI_PERROR)) { + TRACE_ERROR_STRING("Wrong collection class:", WRONG_COLLECTION); + fprintf(file,"%s\n", WRONG_COLLECTION); return; } /* Bind iterator */ - error = bind_iterator(&iterator,error_list,COL_TRAVERSE_DEFAULT); - if(error) { - TRACE_ERROR_STRING("Error (bind):",FAILED_TO_PROCCESS); - fprintf(file,"%s\n",FAILED_TO_PROCCESS); + error = bind_iterator(&iterator, error_list, COL_TRAVERSE_DEFAULT); + if (error) { + TRACE_ERROR_STRING("Error (bind):", FAILED_TO_PROCCESS); + fprintf(file, "%s\n", FAILED_TO_PROCCESS); return; } - do { + while(1) { /* Loop through a collection */ error = iterate_collection(iterator, &item); - if(error) { - TRACE_ERROR_STRING("Error (iterate):",FAILED_TO_PROCCESS); - fprintf(file,"%s\n",FAILED_TO_PROCCESS); + if (error) { + TRACE_ERROR_STRING("Error (iterate):", FAILED_TO_PROCCESS); + fprintf(file, "%s\n", FAILED_TO_PROCCESS); unbind_iterator(iterator); return; } /* Are we done ? */ - if(item == (struct collection_item *)(NULL)) break; + if (item == NULL) break; /* Process collection header */ - if(get_item_type(item) == COL_TYPE_COLLECTION) { + if (get_item_type(item) == COL_TYPE_COLLECTION) { get_collection_count(item, &count); - if(count > 1) fprintf(file,ERROR_HEADER,get_item_property(item,NULL)); + if (count > 1) + fprintf(file, ERROR_HEADER, get_item_property(item, NULL)); else break; } else { /* Put error into provided format */ pe = (struct parse_error *)(get_item_data(item)); - fprintf(file,LINE_FORMAT, - get_item_property(item,NULL), /* Error or warning */ + fprintf(file, LINE_FORMAT, + get_item_property(item, NULL), /* Error or warning */ pe->error, /* Error */ pe->line, /* Line */ parsing_error_str(pe->error)); /* Error str */ } } - while(1); /* Do not forget to unbind iterator - otherwise there will be a leak */ unbind_iterator(iterator); @@ -703,64 +738,65 @@ void print_file_parsing_errors(FILE *file, } -/* Print errors and warnings that were detected parsing configuration as a whole */ -void print_config_parsing_errors(FILE *file,struct collection_item *error_list) +/* Print errors and warnings that were detected while parsing + * the whole configuration */ +void print_config_parsing_errors(FILE *file, + struct collection_item *error_list) { struct collection_iterator *iterator; int error; - struct collection_item *item = (struct collection_item *)(NULL); - struct collection_item *file_errors = (struct collection_item *)(NULL); + struct collection_item *item = NULL; + struct collection_item *file_errors = NULL; TRACE_FLOW_STRING("print_config_parsing_errors", "Entry"); /* If we have something to print print it */ - if(error_list == (struct collection_item *)(NULL)) { - TRACE_ERROR_STRING("No error list",""); + if (error_list == NULL) { + TRACE_ERROR_STRING("No error list", ""); return; } /* Make sure we go the right collection */ - if(!is_of_class(error_list,COL_CLASS_INI_PESET)) { - TRACE_ERROR_STRING("Wrong collection class:",WRONG_COLLECTION); - fprintf(file,"%s\n",WRONG_COLLECTION); + if (!is_of_class(error_list, COL_CLASS_INI_PESET)) { + TRACE_ERROR_STRING("Wrong collection class:", WRONG_COLLECTION); + fprintf(file, "%s\n", WRONG_COLLECTION); return; } /* Bind iterator */ - error = bind_iterator(&iterator,error_list,COL_TRAVERSE_DEFAULT); - if(error) { - TRACE_ERROR_STRING("Error (bind):",FAILED_TO_PROCCESS); - fprintf(file,"%s\n",FAILED_TO_PROCCESS); + error = bind_iterator(&iterator, error_list, COL_TRAVERSE_DEFAULT); + if (error) { + TRACE_ERROR_STRING("Error (bind):", FAILED_TO_PROCCESS); + fprintf(file,"%s\n", FAILED_TO_PROCCESS); return; } - do { + while(1) { /* Loop through a collection */ error = iterate_collection(iterator, &item); - if(error) { - TRACE_ERROR_STRING("Error (iterate):",FAILED_TO_PROCCESS); - fprintf(file,"%s\n",FAILED_TO_PROCCESS); + if (error) { + TRACE_ERROR_STRING("Error (iterate):", FAILED_TO_PROCCESS); + fprintf(file, "%s\n", FAILED_TO_PROCCESS); unbind_iterator(iterator); return; } /* Are we done ? */ - if(item == (struct collection_item *)(NULL)) break; + if (item == NULL) break; /* Print per file sets of errors */ - if(get_item_type(item) == COL_TYPE_COLLECTIONREF) { + if (get_item_type(item) == COL_TYPE_COLLECTIONREF) { /* Extract a sub collection */ - error = get_reference_from_item(item,&file_errors); - if(error) { - TRACE_ERROR_STRING("Error (extract):",FAILED_TO_PROCCESS); - fprintf(file,"%s\n",FAILED_TO_PROCCESS); + error = get_reference_from_item(item, &file_errors); + if (error) { + TRACE_ERROR_STRING("Error (extract):", FAILED_TO_PROCCESS); + fprintf(file, "%s\n", FAILED_TO_PROCCESS); return; } - print_file_parsing_errors(file,file_errors); + print_file_parsing_errors(file, file_errors); destroy_collection(file_errors); } } - while(1); /* Do not forget to unbind iterator - otherwise there will be a leak */ unbind_iterator(iterator); @@ -776,56 +812,58 @@ int get_config_item(const char *section, struct collection_item **item) { int error = EOK; - struct collection_item *section_handle = (struct collection_item *)(NULL); + struct collection_item *section_handle = NULL; char *to_find; char default_section[] = INI_DEFAULT_SECTION; TRACE_FLOW_STRING("get_config_item", "Entry"); /* Do we have the accepting memory ? */ - if(item == (struct collection_item **)(NULL)) { + if (item == NULL) { TRACE_ERROR_NUMBER("No buffer - invalid argument.", EINVAL); return EINVAL; } /* Is the collection of a right type */ - if(!is_of_class(ini_config,COL_CLASS_INI_CONFIG)) { + if (!is_of_class(ini_config, COL_CLASS_INI_CONFIG)) { TRACE_ERROR_NUMBER("Wrong collection type", EINVAL); return EINVAL; } - *item = (struct collection_item *)(NULL); + *item = NULL; - if(section == NULL) to_find = default_section; - else to_find = (char *)section; + if (section == NULL) to_find = default_section; + else to_find = section; TRACE_INFO_STRING("Getting Name:", name); TRACE_INFO_STRING("In Section:", section); /* Get Subcollection */ - error = get_collection_reference(ini_config,§ion_handle,to_find); + error = get_collection_reference(ini_config, §ion_handle, to_find); /* Check error */ - if((error) && (error != ENOENT)) { + if (error && (error != ENOENT)) { TRACE_ERROR_NUMBER("Failed to get section", error); return error; } /* Did we find a section */ - if((error == ENOENT) || (section_handle == (struct collection_item *)(NULL))) { + if ((error == ENOENT) || (section_handle == NULL)) { /* We have not found section - return success */ TRACE_FLOW_STRING("get_value_from_config", "No such section"); return EOK; } /* Get item */ - error = get_item(section_handle,(char *)name, COL_TYPE_STRING, COL_TRAVERSE_ONELEVEL, item); + error = get_item(section_handle, name, + COL_TYPE_STRING, COL_TRAVERSE_ONELEVEL, item); TRACE_FLOW_NUMBER("get_config_item returning", error); return error; } /* Get long value from config item */ -long get_long_config_value(struct collection_item *item, int strict, long def, int *error) +long get_long_config_value(struct collection_item *item, + int strict, long def, int *error) { char *endptr, *str; long val = 0; @@ -833,17 +871,17 @@ long get_long_config_value(struct collection_item *item, int strict, long def, i TRACE_FLOW_STRING("get_long_config_value", "Entry"); /* Do we have the item ? */ - if((item == (struct collection_item *)(NULL)) || + if ((item == NULL) || (get_item_type(item) != COL_TYPE_STRING)) { TRACE_ERROR_NUMBER("Invalid argument.", EINVAL); - if(error) *error = EINVAL; + if (error) *error = EINVAL; return def; } - if(error) *error = EOK; + if (error) *error = EOK; /* Try to parse the value */ - str = (char *)(get_item_data(item)); + str = (char *)get_item_data(item); errno = 0; val = strtol(str, &endptr, 10); @@ -854,13 +892,13 @@ long get_long_config_value(struct collection_item *item, int strict, long def, i ((errno != 0) && (val == 0)) || (endptr == str)) { TRACE_ERROR_NUMBER("Conversion failed", EIO); - if(error) *error = EIO; + if (error) *error = EIO; return def; } - if ((strict) && (*endptr != '\0')) { + if (strict && (*endptr != '\0')) { TRACE_ERROR_NUMBER("More characters than expected", EIO); - if(error) *error = EIO; + if (error) *error = EIO; val = def; } @@ -869,25 +907,29 @@ long get_long_config_value(struct collection_item *item, int strict, long def, i } /* Get integer value from config item */ -inline int get_int_config_value(struct collection_item *item, int strict, int def, int *error) +inline int get_int_config_value(struct collection_item *item, + int strict, int def, int *error) { - return (int)get_long_config_value(item, strict, (long)def, error); + return get_long_config_value(item, strict, def, error); } /* Get unsigned integer value from config item */ -unsigned get_unsigned_config_value(struct collection_item *item, int strict, unsigned def, int *error) +unsigned get_unsigned_config_value(struct collection_item *item, + int strict, unsigned def, int *error) { - return (unsigned int)get_long_config_value(item, strict, (long)def, error); + return get_long_config_value(item, strict, def, error); } /* Get unsigned long value from config item */ -unsigned long get_ulong_config_value(struct collection_item *item, int strict, unsigned long def, int *error) +unsigned long get_ulong_config_value(struct collection_item *item, + int strict, unsigned long def, int *error) { - return (unsigned long)get_long_config_value(item, strict, (long)def, error); + return get_long_config_value(item, strict, def, error); } /* Get double value */ -double get_double_config_value(struct collection_item *item, int strict, double def, int *error) +double get_double_config_value(struct collection_item *item, + int strict, double def, int *error) { char *endptr, *str; double val = 0; @@ -895,32 +937,32 @@ double get_double_config_value(struct collection_item *item, int strict, double TRACE_FLOW_STRING("get_double_config_value", "Entry"); /* Do we have the item ? */ - if((item == (struct collection_item *)(NULL)) || - (get_item_type(item) != COL_TYPE_STRING)) { + if ((item == NULL) || + (get_item_type(item) != COL_TYPE_STRING)) { TRACE_ERROR_NUMBER("Invalid argument.", EINVAL); - if(error) *error = EINVAL; + if (error) *error = EINVAL; return def; } - if(error) *error = EOK; + if (error) *error = EOK; /* Try to parse the value */ - str = (char *)(get_item_data(item)); + str = (char *)get_item_data(item); errno = 0; val = strtod(str, &endptr); /* Check for various possible errors */ - if ((errno == ERANGE) || + if ((errno == ERANGE) || ((errno != 0) && (val == 0)) || (endptr == str)) { TRACE_ERROR_NUMBER("Conversion failed", EIO); - if(error) *error = EIO; + if (error) *error = EIO; return def; } - if ((strict) && (*endptr != '\0')) { + if (strict && (*endptr != '\0')) { TRACE_ERROR_NUMBER("More characters than expected", EIO); - if(error) *error = EIO; + if (error) *error = EIO; val = def; } @@ -929,7 +971,8 @@ double get_double_config_value(struct collection_item *item, int strict, double } /* Get boolean value */ -unsigned char get_bool_config_value(struct collection_item *item, unsigned char def, int *error) +unsigned char get_bool_config_value(struct collection_item *item, + unsigned char def, int *error) { char *str; int len; @@ -937,63 +980,64 @@ unsigned char get_bool_config_value(struct collection_item *item, unsigned char TRACE_FLOW_STRING("get_bool_config_value", "Entry"); /* Do we have the item ? */ - if((item == (struct collection_item *)(NULL)) || - (get_item_type(item) != COL_TYPE_STRING)) { + if ((item == NULL) || + (get_item_type(item) != COL_TYPE_STRING)) { TRACE_ERROR_NUMBER("Invalid argument.", EINVAL); - if(error) *error = EINVAL; + if (error) *error = EINVAL; return def; } - if(error) *error = EOK; + if (error) *error = EOK; - str = (char *)(get_item_data(item)); + str = (char *)get_item_data(item); len = get_item_length(item); /* Try to parse the value */ - if((strncasecmp(str,"true",len) == 0) || - (strncasecmp(str,"yes",len) == 0)) { + if ((strncasecmp(str, "true", len) == 0) || + (strncasecmp(str, "yes", len) == 0)) { TRACE_FLOW_STRING("Returning", "true"); return '\1'; } - else if((strncasecmp(str,"false",len) == 0) || - (strncasecmp(str,"no",len) == 0)) { + else if ((strncasecmp(str, "false", len) == 0) || + (strncasecmp(str, "no", len) == 0)) { TRACE_FLOW_STRING("Returning", "false"); return '\0'; } TRACE_ERROR_STRING("Returning", "error"); - if(error) *error = EIO; + if (error) *error = EIO; return def; } /* Return a string out of the value */ -inline char *get_string_config_value(struct collection_item *item, int dup, int *error) +char *get_string_config_value(struct collection_item *item, + int dup, int *error) { char *str = NULL; TRACE_FLOW_STRING("get_string_config_value", "Entry"); /* Do we have the item ? */ - if((item == (struct collection_item *)(NULL)) || - (get_item_type(item) != COL_TYPE_STRING)) { + if ((item == NULL) || + (get_item_type(item) != COL_TYPE_STRING)) { TRACE_ERROR_NUMBER("Invalid argument.", EINVAL); - if(error) *error = EINVAL; + if (error) *error = EINVAL; return NULL; } /* If we are told to dup the value */ - if(dup) { + if (dup) { errno = 0; - str = strdup((char *)(get_item_data(item))); - if(str == NULL) { + str = strdup((char *)get_item_data(item)); + if (str == NULL) { TRACE_ERROR_NUMBER("Failed to allocate memory.", ENOMEM); - if(error) *error = ENOMEM; + if (error) *error = ENOMEM; return NULL; } } - else str = (char *)(get_item_data(item)); + else str = (char *)get_item_data(item); - if(error) *error = EOK; + if (error) *error = EOK; TRACE_FLOW_STRING("get_string_config_value", "Exit"); return str; @@ -1005,7 +1049,8 @@ inline char *get_string_config_value(struct collection_item *item, int dup, int * Example: '0A2BFECC' * Case does not matter. */ -char *get_bin_config_value(struct collection_item *item, int *length, int *error) +char *get_bin_config_value(struct collection_item *item, + int *length, int *error) { int i; char *value = NULL; @@ -1018,67 +1063,71 @@ char *get_bin_config_value(struct collection_item *item, int *length, int *error TRACE_FLOW_STRING("get_bin_config_value", "Entry"); /* Do we have the item ? */ - if((item == (struct collection_item *)(NULL)) || - (get_item_type(item) != COL_TYPE_STRING)) { + if ((item == NULL) || + (get_item_type(item) != COL_TYPE_STRING)) { TRACE_ERROR_NUMBER("Invalid argument.", EINVAL); - if(error) *error = EINVAL; + if (error) *error = EINVAL; return NULL; } /* Check the length */ len = get_item_length(item)-1; - if((len/2) *2 != len) { - TRACE_ERROR_STRING("Invalid length for binary data","") - if(error) *error = EINVAL; + if ((len%2) != 0) { + TRACE_ERROR_STRING("Invalid length for binary data", ""); + if (error) *error = EINVAL; return NULL; } - str = (char *)(get_item_data(item)); + str = (char *)get_item_data(item); /* Is the format correct ? */ - if((*str != '\'') || - (*(str + len -1) != '\'')) { - TRACE_ERROR_STRING("String is not escaped","") - if(error) *error = EIO; + if ((*str != '\'') || + (str[len -1] != '\'')) { + TRACE_ERROR_STRING("String is not escaped",""); + if (error) *error = EIO; return NULL; } /* Check that all the symbols are ok */ buff = str + 1; len -= 2; - for(i=0;idata; start = buff; - for(i=0;ilength;i++) { + for(i = 0; i < item->length; i++) { growlen = 1; - for(j=0;j 0) { - if(isspace(*(start+len - 1))) len--; + while (len > 0) { + if (isspace(start[len - 1])) len--; else break; } - if(len > 0) { + if (len > 0) { /* Save block aside */ - memcpy(dest,start,len); + memcpy(dest, start, len); count++; - dest+=len; - *dest='\0'; + dest += len; + *dest = '\0'; dest++; len = 0; /* Move forward and trim spaces if any */ @@ -1155,12 +1205,12 @@ char **get_string_config_array(struct collection_item *item, char *sep, int *siz TRACE_INFO_STRING("Remaining buffer :", start); TRACE_INFO_STRING("Other pointer :", buff + i); k = 0; - while(((i+k) < item->length) && (isspace(*start))) { + while (((i + k) < item->length) && (isspace(*start))) { k++; start++; } TRACE_INFO_STRING("Remaining buffer after triming spaces:", start); - if(k) i+=k-1; + if (k) i += k - 1; /* Next iteration of the loop will add 1 */ } /* Break out of the inner loop */ @@ -1168,36 +1218,36 @@ char **get_string_config_array(struct collection_item *item, char *sep, int *siz break; } } - if(growlen) len++; + if (growlen) len++; } /* Copy the remaining piece */ - memcpy(dest,start,len); + memcpy(dest, start, len); count++; - dest+=len; - dest='\0'; + dest += len; + dest = '\0'; dest++; /* Now we know how many items are there in the list */ array = malloc((count + 1) * sizeof(char *)); - if(array == NULL) { + if (array == NULL) { free(copy); TRACE_ERROR_NUMBER("Failed to allocate memory.", ENOMEM); - if(error) *error = ENOMEM; + if (error) *error = ENOMEM; return NULL; } /* Loop again to fill in the pointers */ start = copy; - for(i=0;i