diff options
Diffstat (limited to 'common/collection/collection.c')
| -rw-r--r-- | common/collection/collection.c | 1743 |
1 files changed, 953 insertions, 790 deletions
diff --git a/common/collection/collection.c b/common/collection/collection.c index 4a5b5044..79e4421f 100644 --- a/common/collection/collection.c +++ b/common/collection/collection.c @@ -89,27 +89,27 @@ typedef int (*internal_item_fn)(struct collection_item *head, void *custom_data, int *stop); -/******************** SUPPLIMENTARY FUNCTIONS ****************************/ +/******************** SUPPLEMENTARY FUNCTIONS ****************************/ /* BASIC OPERATIONS */ /* Function that checks if property can be added */ static int validate_property(char *property) { - TRACE_FLOW_STRING("validate_property","Entry point."); + TRACE_FLOW_STRING("validate_property", "Entry point."); /* Only alpha numeric characters are allowed in names of the properties */ int invalid = 0; char *check; check = property; - while(*check != '\0') { - if((!isalnum((int)(*check))) && (!ispunct((int)(*check)))) { + while (*check != '\0') { + if ((!isalnum(*check)) && (!ispunct(*check))) { invalid = 1; break; } check++; } - TRACE_FLOW_NUMBER("validate_property. Returning ",invalid); + TRACE_FLOW_NUMBER("validate_property. Returning ", invalid); return invalid; } @@ -120,10 +120,10 @@ static void delete_item(struct collection_item *item) { TRACE_FLOW_STRING("delete_item","Entry point."); - if(item == (struct collection_item *)NULL) return; + if (item == NULL) return; - if(item->property != NULL) free(item->property); - if(item->data != NULL) free(item->data); + if (item->property != NULL) free(item->property); + if (item->data != NULL) free(item->data); free(item); @@ -131,42 +131,43 @@ static void delete_item(struct collection_item *item) } /* A generic function to allocate a property item */ -static int allocate_item(struct collection_item **ci,char *property,void *item_data,int length, int type) +static int allocate_item(struct collection_item **ci, char *property, + void *item_data,int length, int type) { struct collection_item *item = NULL; int error = 0; errno = 0; - TRACE_FLOW_STRING("allocate_item","Entry point."); - TRACE_INFO_NUMBER("Will be using type:",type); + TRACE_FLOW_STRING("allocate_item", "Entry point."); + TRACE_INFO_NUMBER("Will be using type:", type); /* Check the length */ - if(length >= COL_MAX_DATA) { - TRACE_ERROR_STRING("allocate_item","Data to long."); + if (length >= COL_MAX_DATA) { + TRACE_ERROR_STRING("allocate_item", "Data to long."); return EMSGSIZE; } - if(validate_property(property)) { - TRACE_ERROR_STRING("Invalid chracters in the property name",property); + if (validate_property(property)) { + TRACE_ERROR_STRING("Invalid chracters in the property name", property); return EINVAL; } /* Allocate memory for the structure */ - item = (struct collection_item *)(malloc(sizeof(struct collection_item))); - if(item == (struct collection_item *)(NULL)) { + item = (struct collection_item *)malloc(sizeof(struct collection_item)); + if (item == NULL) { error = errno; - TRACE_ERROR_STRING("allocate_item","Malloc failed."); + TRACE_ERROR_STRING("allocate_item", "Malloc failed."); return error; } /* After we initialize "next" we can use delete_item() in case of error */ - item->next = (struct collection_item *)(NULL); + item->next = NULL; /* Copy property */ item->property = strdup(property); - if(item->property == NULL) { + if (item->property == NULL) { error = errno; - TRACE_ERROR_STRING("allocate_item","Failed to dup property."); + TRACE_ERROR_STRING("allocate_item", "Failed to dup property."); delete_item(item); return error; } @@ -175,71 +176,74 @@ static int allocate_item(struct collection_item **ci,char *property,void *item_d /* Deal with data */ item->data = malloc(length); - if(item->data == NULL) { - TRACE_ERROR_STRING("allocate_item","Failed to dup data."); + if (item->data == NULL) { + TRACE_ERROR_STRING("allocate_item", "Failed to dup data."); delete_item(item); return errno; } - memcpy(item->data,item_data,length); + memcpy(item->data, item_data, length); /* Deal with other properties of the item */ - TRACE_INFO_NUMBER("About to set type to:",type); + TRACE_INFO_NUMBER("About to set type to:", type); item->type = type; item->length = length; /* Make sure that data is NULL terminated in case of string */ - if(type == COL_TYPE_STRING) *(((char *)(item->data))+length-1) = '\0'; + if (type == COL_TYPE_STRING) ((char *)(item->data))[length-1] = '\0'; *ci = item; - TRACE_INFO_STRING("Item property",item->property); - TRACE_INFO_NUMBER("Item property type",item->type); - TRACE_INFO_NUMBER("Item data length",item->length); - TRACE_FLOW_STRING("allocate_item","Success exit."); + TRACE_INFO_STRING("Item property", item->property); + TRACE_INFO_NUMBER("Item property type", item->type); + TRACE_INFO_NUMBER("Item data length", item->length); + TRACE_FLOW_STRING("allocate_item", "Success exit."); return 0; } /* Add item to the end of collection */ /* Can add itself to itself - nice...*/ -static int add_item_to_collection(struct collection_item *collection,struct collection_item *item) +static int add_item_to_collection(struct collection_item *collection, + struct collection_item *item) { struct collection_header *header; - TRACE_FLOW_STRING("add_item_to_collection","Entry point."); + TRACE_FLOW_STRING("add_item_to_collection", "Entry point."); - if(collection == (struct collection_item *)(NULL)) { - TRACE_INFO_STRING("add_item_to_collection","Collection accepting is NULL"); - if((item != (struct collection_item *)(NULL)) && - (item->type == COL_TYPE_COLLECTION)) { + if (collection == NULL) { + TRACE_INFO_STRING("add_item_to_collection", + "Collection accepting is NULL"); + if ((item != NULL) && (item->type == COL_TYPE_COLLECTION)) { /* This is a special case of self creation */ - TRACE_INFO_STRING("add_item_to_collection","Adding header item to new collection."); + TRACE_INFO_STRING("add_item_to_collection", + "Adding header item to new collection."); collection = item; } } /* We can add items only to collections */ - if(collection->type != COL_TYPE_COLLECTION) { - TRACE_ERROR_STRING("add_item_to_collection","Attempt to add item to non collection."); - TRACE_ERROR_STRING("Collection name:",collection->property); - TRACE_ERROR_NUMBER("Collection type:",collection->type); + if (collection->type != COL_TYPE_COLLECTION) { + TRACE_ERROR_STRING("add_item_to_collection", + "Attempt to add item to non collection."); + TRACE_ERROR_STRING("Collection name:", collection->property); + TRACE_ERROR_NUMBER("Collection type:", collection->type); return EINVAL; } - header = (struct collection_header *)(collection->data); + header = (struct collection_header *)collection->data; /* Link new item to the last item in the list if there any */ - if(header->last != (struct collection_item *)(NULL)) (header->last)->next = item; + if (header->last != NULL) header->last->next = item; /* Make sure we save a new last element */ header->last = item; header->count++; - TRACE_INFO_STRING("Collection:",collection->property); - TRACE_INFO_STRING("Just added item is:",item->property); - TRACE_INFO_NUMBER("Item type.",item->type); - TRACE_INFO_NUMBER("Number of items in collection now is.",header->count); + TRACE_INFO_STRING("Collection:", collection->property); + TRACE_INFO_STRING("Just added item is:", item->property); + TRACE_INFO_NUMBER("Item type.", item->type); + TRACE_INFO_NUMBER("Number of items in collection now is.", header->count); - TRACE_FLOW_STRING("add_item_to_collection","Success exit."); + TRACE_FLOW_STRING("add_item_to_collection", "Success exit."); return EOK; } @@ -255,15 +259,15 @@ inline static int is_in_item_handler(char *property, void *found, int *dummy) { - TRACE_FLOW_STRING("is_in_item_handler","Entry."); - TRACE_INFO_STRING("Property:",property); - TRACE_INFO_NUMBER("Property length:",property_len); - TRACE_INFO_NUMBER("Type:",type); - TRACE_INFO_NUMBER("Length:",length); + TRACE_FLOW_STRING("is_in_item_handler", "Entry."); + TRACE_INFO_STRING("Property:", property); + TRACE_INFO_NUMBER("Property length:", property_len); + TRACE_INFO_NUMBER("Type:", type); + TRACE_INFO_NUMBER("Length:", length); *((int *)(found)) = COL_MATCH; - TRACE_FLOW_STRING("is_in_item_handler","Success Exit."); + TRACE_FLOW_STRING("is_in_item_handler", "Success Exit."); return EOK; } @@ -277,11 +281,11 @@ inline static int get_subcollection(char *property, void *found, int *dummy) { - TRACE_FLOW_STRING("get_subcollection","Entry."); - TRACE_INFO_STRING("Property:",property); - TRACE_INFO_NUMBER("Property length:",property_len); - TRACE_INFO_NUMBER("Type:",type); - TRACE_INFO_NUMBER("Length:",length); + TRACE_FLOW_STRING("get_subcollection", "Entry."); + TRACE_INFO_STRING("Property:", property); + TRACE_INFO_NUMBER("Property length:", property_len); + TRACE_INFO_NUMBER("Type:", type); + TRACE_INFO_NUMBER("Length:", length); *((struct collection_item **)(found)) = *((struct collection_item **)(data)); @@ -294,7 +298,8 @@ inline static int get_subcollection(char *property, /* ADD PROPERTY */ -/* Add a single property to a collection. Returns a pointer to a newly allocated property */ +/* Add a single property to a collection. + * Returns a pointer to a newly allocated property */ static struct collection_item *add_property(struct collection_item *collection, char *subcollection, char *property, @@ -303,63 +308,68 @@ static struct collection_item *add_property(struct collection_item *collection, int type, int *error) { - struct collection_item *item = (struct collection_item *) NULL; - struct collection_item *acceptor = (struct collection_item *)(NULL); + struct collection_item *item = NULL; + struct collection_item *acceptor = NULL; - TRACE_FLOW_STRING("add_property","Entry."); + TRACE_FLOW_STRING("add_property", "Entry."); /* Allocate item */ - TRACE_INFO_NUMBER("Property type to add",type); - *error = allocate_item(&item,property,item_data,length, type); - if(*error) return (struct collection_item *)(NULL); + TRACE_INFO_NUMBER("Property type to add", type); + *error = allocate_item(&item, property, item_data, length, type); + if (*error) return NULL; - TRACE_INFO_STRING("Created item:",item->property); - TRACE_INFO_NUMBER("Item has type:",item->type); + TRACE_INFO_STRING("Created item:", item->property); + TRACE_INFO_NUMBER("Item has type:", item->type); /* Add item to collection */ - if(subcollection == NULL) acceptor = collection; + if (subcollection == NULL) { + acceptor = collection; + } else { - TRACE_INFO_STRING("Subcollection id not null, searching",subcollection); - *error = find_item_and_do(collection, subcollection, COL_TYPE_COLLECTIONREF, + TRACE_INFO_STRING("Subcollection id not null, searching", subcollection); + *error = find_item_and_do(collection, subcollection, + COL_TYPE_COLLECTIONREF, COL_TRAVERSE_DEFAULT, - get_subcollection,(void *)(&acceptor),COLLECTION_ACTION_FIND); - if(*error) { - TRACE_ERROR_NUMBER("Search for subcollection returned error:",*error); + get_subcollection, (void *)(&acceptor), + COLLECTION_ACTION_FIND); + if (*error) { + TRACE_ERROR_NUMBER("Search for subcollection returned error:", *error); delete_item(item); - return (struct collection_item *)(NULL); + return NULL; } - if(acceptor == (struct collection_item *)(NULL)) { - TRACE_ERROR_STRING("Search for subcollection returned NULL pointer",""); + if (acceptor == NULL) { + TRACE_ERROR_STRING("Search for subcollection returned NULL pointer", ""); delete_item(item); - *error=ENOENT; - return (struct collection_item *)(NULL); + *error = ENOENT; + return NULL; } } - *error = add_item_to_collection(acceptor,item); - if(*error) { - TRACE_ERROR_NUMBER("Failed to add item to collection error:",*error); + *error = add_item_to_collection(acceptor, item); + if (*error) { + TRACE_ERROR_NUMBER("Failed to add item to collection error:", *error); delete_item(item); - return (struct collection_item *)(NULL); + return NULL; } - TRACE_FLOW_STRING("add_property","Success Exit."); + TRACE_FLOW_STRING("add_property", "Success Exit."); return item; } /* CLEANUP */ /* Cleans the collection tree including current item. */ -/* After the execution passed in variable should not be used - memory is gone!!! */ +/* The passed in variable should not be used after the call + * as memory is freed!!! */ static void delete_collection(struct collection_item *ci) { struct collection_item *other_collection; - TRACE_FLOW_STRING("delete_collection","Entry."); + TRACE_FLOW_STRING("delete_collection", "Entry."); - if(ci == (struct collection_item *)(NULL)) { - TRACE_FLOW_STRING("delete_collection","Nothing to do Exit."); + if (ci == NULL) { + TRACE_FLOW_STRING("delete_collection", "Nothing to do Exit."); return; } @@ -369,14 +379,15 @@ static void delete_collection(struct collection_item *ci) /* Handle external or embedded collection */ if(ci->type == COL_TYPE_COLLECTIONREF) { - /* Our data is a pointer to a whole external collection so dereference it or delete */ + /* Our data is a pointer to a whole external collection so dereference + * it or delete */ other_collection = *((struct collection_item **)(ci->data)); destroy_collection(other_collection); } /* Delete this item */ delete_item(ci); - TRACE_FLOW_STRING("delete_collection","Exit."); + TRACE_FLOW_STRING("delete_collection", "Exit."); } @@ -408,21 +419,21 @@ static int create_path_data(struct path_data **name_path, int error = EOK; struct path_data *new_name_path; - TRACE_FLOW_STRING("create_path_data","Entry."); + TRACE_FLOW_STRING("create_path_data", "Entry."); - TRACE_INFO_STRING("Constructing path from name:",name); - TRACE_INFO_STRING("Constructing path from property:",property); + TRACE_INFO_STRING("Constructing path from name:", name); + TRACE_INFO_STRING("Constructing path from property:", property); /* Allocate structure */ errno = 0; - new_name_path = (struct path_data *)(malloc(sizeof(struct path_data))); - if(new_name_path == (struct path_data *)(NULL)) return errno; + new_name_path = (struct path_data *)malloc(sizeof(struct path_data)); + if (new_name_path == NULL) return errno; - new_name_path->name=malloc(length+property_len+2); - if(new_name_path->name == NULL) { + new_name_path->name = malloc(length + property_len + 2); + if (new_name_path->name == NULL) { error = errno; - TRACE_ERROR_NUMBER("Failed to allocate memory for new path name. Errno",error); - free((void *)(new_name_path)); + TRACE_ERROR_NUMBER("Failed to allocate memory for new path name. Errno", error); + free(new_name_path); return error; } @@ -430,26 +441,26 @@ static int create_path_data(struct path_data **name_path, new_name_path->length = 0; if(length > 0) { - memcpy(new_name_path->name,name,length); + memcpy(new_name_path->name, name, length); new_name_path->length = length; - *(new_name_path->name+new_name_path->length) = '.'; + new_name_path->name[new_name_path->length] = '.'; new_name_path->length++; - *(new_name_path->name+new_name_path->length) = '\0'; - TRACE_INFO_STRING("Name so far:",new_name_path->name); - TRACE_INFO_NUMBER("Len so far:",new_name_path->length); + new_name_path->name[new_name_path->length] = '\0'; + TRACE_INFO_STRING("Name so far:", new_name_path->name); + TRACE_INFO_NUMBER("Len so far:", new_name_path->length); } - memcpy(new_name_path->name+new_name_path->length,property,property_len); + memcpy(&new_name_path->name[new_name_path->length], property, property_len); new_name_path->length += property_len; - *(new_name_path->name + new_name_path->length) = '\0'; + new_name_path->name[new_name_path->length] = '\0'; /* Link to the chain */ new_name_path->previous_path = *name_path; *name_path = new_name_path; - TRACE_INFO_STRING("Constructed path",new_name_path->name); + TRACE_INFO_STRING("Constructed path", new_name_path->name); - TRACE_FLOW_NUMBER("create_path_data. Returning:",error); + TRACE_FLOW_NUMBER("create_path_data. Returning:", error); return error; } @@ -462,13 +473,14 @@ static int match_item(struct collection_item *current, char *start; char *data_str; - TRACE_FLOW_STRING("match_item","Entry"); + TRACE_FLOW_STRING("match_item", "Entry"); - if(traverse_data->type_to_match & current->type) { + if (traverse_data->type_to_match & current->type) { /* Check if there is any value to match */ - if((traverse_data->name_to_find == NULL) || - (*(traverse_data->name_to_find) == '\0')) { - TRACE_INFO_STRING("match_item","Returning MATCH because there is no search criteria!"); + if ((traverse_data->name_to_find == NULL) || + (*(traverse_data->name_to_find) == '\0')) { + TRACE_INFO_STRING("match_item", + "Returning MATCH because there is no search criteria!"); return COL_MATCH; } @@ -477,26 +489,27 @@ static int match_item(struct collection_item *current, start = current->property; data_str = start + current->property_len; - TRACE_INFO_STRING("Searching for:",traverse_data->name_to_find); - TRACE_INFO_STRING("Item name:",current->property); - TRACE_INFO_STRING("Current path:",traverse_data->current_path->name); - TRACE_INFO_NUMBER("Searching:",toupper(*find_str)); - TRACE_INFO_NUMBER("Have:",toupper(*data_str)); + TRACE_INFO_STRING("Searching for:", traverse_data->name_to_find); + TRACE_INFO_STRING("Item name:", current->property); + TRACE_INFO_STRING("Current path:", traverse_data->current_path->name); + TRACE_INFO_NUMBER("Searching:", toupper(*find_str)); + TRACE_INFO_NUMBER("Have:", toupper(*data_str)); /* We start pointing to 0 so the loop will be executed at least once */ - while(toupper(*data_str) == toupper(*find_str)) { + while (toupper(*data_str) == toupper(*find_str)) { TRACE_INFO_STRING("Loop iteration:",""); - if(data_str == start) { - if(find_str > traverse_data->name_to_find) { - if(*(find_str-1) == '.') { - /* We matched the property but the search string is longer */ - /* so we need to continue matching */ - TRACE_INFO_STRING("match_item","Need to continue matching"); + if (data_str == start) { + if (find_str > traverse_data->name_to_find) { + if (*(find_str-1) == '.') { + /* We matched the property but the search string is + * longer so we need to continue matching */ + TRACE_INFO_STRING("match_item", + "Need to continue matching"); start = traverse_data->current_path->name; - data_str = start + traverse_data->current_path->length - 1; - find_str-=2; + data_str = &start[traverse_data->current_path->length - 1]; + find_str -= 2; continue; } else { @@ -509,13 +522,13 @@ static int match_item(struct collection_item *current, return COL_MATCH; } } - else if((find_str == traverse_data->name_to_find) && - (*(data_str-1) == '.')) return COL_MATCH; + else if ((find_str == traverse_data->name_to_find) && + (*(data_str-1) == '.')) return COL_MATCH; data_str--; find_str--; - TRACE_INFO_NUMBER("Searching:",toupper(*find_str)); - TRACE_INFO_NUMBER("Have:",toupper(*data_str)); + TRACE_INFO_NUMBER("Searching:", toupper(*find_str)); + TRACE_INFO_NUMBER("Have:", toupper(*data_str)); } } @@ -530,20 +543,21 @@ static void delete_path_data(struct path_data *path) { TRACE_FLOW_STRING("delete_path_data","Entry."); - if(path!= (struct path_data *)(NULL)) { - TRACE_INFO_STRING("delete_path_data","Item to delete exits."); - if(path->previous_path != (struct path_data *)(NULL)) { - TRACE_INFO_STRING("delete_path_data","But previous item to delete exits to. Nesting."); + if (path != NULL) { + TRACE_INFO_STRING("delete_path_data", "Item to delete exits."); + if (path->previous_path != NULL) { + TRACE_INFO_STRING("delete_path_data", + "But previous item to delete exits to. Nesting."); delete_path_data(path->previous_path); } - if(path->name != NULL) { - TRACE_INFO_STRING("delete_path_data Deleting path:",path->name); + if (path->name != NULL) { + TRACE_INFO_STRING("delete_path_data Deleting path:", path->name); free(path->name); } - TRACE_INFO_STRING("delete_path_data","Deleting path element"); - free((void *)(path)); + TRACE_INFO_STRING("delete_path_data", "Deleting path element"); + free(path); } - TRACE_FLOW_STRING("delete_path_data","Exit"); + TRACE_FLOW_STRING("delete_path_data", "Exit"); } @@ -567,71 +581,75 @@ static int walk_items(struct collection_item *ci, int stop = 0; int error = EOK; - TRACE_FLOW_STRING("walk_items","Entry."); - TRACE_INFO_NUMBER("Mode flags:",mode_flags); + TRACE_FLOW_STRING("walk_items", "Entry."); + TRACE_INFO_NUMBER("Mode flags:", mode_flags); current = ci; - while(current != (struct collection_item *)(NULL)) { + while (current) { - TRACE_INFO_STRING("Processing item:",current->property); - TRACE_INFO_NUMBER("Item type:",current->type); + TRACE_INFO_STRING("Processing item:", current->property); + TRACE_INFO_NUMBER("Item type:", current->type); - if(current->type == COL_TYPE_COLLECTIONREF) { + if (current->type == COL_TYPE_COLLECTIONREF) { - TRACE_INFO_STRING("Subcollection:",current->property); + TRACE_INFO_STRING("Subcollection:", current->property); - if((mode_flags & COL_TRAVERSE_IGNORE) == 0) { + if ((mode_flags & COL_TRAVERSE_IGNORE) == 0) { - TRACE_INFO_STRING("Subcollection is not ignored.",""); + TRACE_INFO_STRING("Subcollection is not ignored.", ""); /* We are not ignoring sub collections */ - error = traverse_handler(ci,parent,current,traverse_data,user_item_handler,custom_data,&stop); - if(stop != 0) { - TRACE_INFO_STRING("Traverse handler returned STOP.",""); + error = traverse_handler(ci, parent, current, traverse_data, + user_item_handler, custom_data, &stop); + if (stop != 0) { + TRACE_INFO_STRING("Traverse handler returned STOP.", ""); error = EINTR_INTERNAL; } /* Check what error we got */ - if(error == EINTR_INTERNAL) { - TRACE_FLOW_NUMBER("Internal error - means we are stopping.",error); + if (error == EINTR_INTERNAL) { + TRACE_FLOW_NUMBER("Internal error - means we are stopping.", error); return error; } - else if(error) { - TRACE_ERROR_NUMBER("Traverse handler returned error.",error); + else if (error) { + TRACE_ERROR_NUMBER("Traverse handler returned error.", error); return error; } - if((mode_flags & COL_TRAVERSE_ONELEVEL) == 0) { + if ((mode_flags & COL_TRAVERSE_ONELEVEL) == 0) { TRACE_INFO_STRING("Before diving into sub collection",""); sub = *((struct collection_item **)(current->data)); - TRACE_INFO_STRING("Sub collection name",sub->property); - TRACE_INFO_NUMBER("Header type",sub->type); + TRACE_INFO_STRING("Sub collection name", sub->property); + TRACE_INFO_NUMBER("Header type", sub->type); /* We need to go into sub collections */ - error = walk_items(sub, mode_flags,traverse_handler,traverse_data, + error = walk_items(sub, mode_flags, + traverse_handler, traverse_data, user_item_handler, custom_data); - TRACE_INFO_STRING("Returned from sub collection processing",""); - TRACE_INFO_STRING("Done processing item:",current->property); - TRACE_INFO_NUMBER("Done processing item type:",current->type); + TRACE_INFO_STRING("Returned from sub collection processing", ""); + TRACE_INFO_STRING("Done processing item:", current->property); + TRACE_INFO_NUMBER("Done processing item type:", current->type); } } } else /* Call handler then move on */ - error = traverse_handler(ci,parent,current,traverse_data,user_item_handler,custom_data,&stop); + error = traverse_handler(ci, parent, current, + traverse_data, user_item_handler, + custom_data, &stop); /* If we are stopped - return EINTR_INTERNAL */ - if(stop != 0) { - TRACE_INFO_STRING("Traverse handler returned STOP.",""); + if (stop != 0) { + TRACE_INFO_STRING("Traverse handler returned STOP.", ""); error = EINTR_INTERNAL; } /* Check what error we got */ - if(error == EINTR_INTERNAL) { - TRACE_FLOW_NUMBER("Internal error - means we are stopping.",error); + if (error == EINTR_INTERNAL) { + TRACE_FLOW_NUMBER("Internal error - means we are stopping.", error); return error; } - else if(error) { - TRACE_ERROR_NUMBER("Traverse handler returned error.",error); + else if (error) { + TRACE_ERROR_NUMBER("Traverse handler returned error.", error); return error; } @@ -640,14 +658,16 @@ static int walk_items(struct collection_item *ci, } - TRACE_INFO_STRING("Out of loop",""); + TRACE_INFO_STRING("Out of loop", ""); - if((mode_flags & COL_TRAVERSE_END) != 0) { - TRACE_INFO_STRING("About to do the special end collection invocation of handler",""); - error = traverse_handler(ci,parent,current,traverse_data,user_item_handler,custom_data,&stop); + if ((mode_flags & COL_TRAVERSE_END) != 0) { + TRACE_INFO_STRING("About to do the special end collection invocation of handler", ""); + error = traverse_handler(ci, parent, current, + traverse_data, user_item_handler, + custom_data, &stop); } - TRACE_FLOW_NUMBER("walk_items. Returns: ",error); + TRACE_FLOW_NUMBER("walk_items. Returns: ", error); return error; } @@ -670,62 +690,64 @@ static int find_item_and_do(struct collection_item *ci, int error = EOK; struct find_name *traverse_data = NULL; - TRACE_FLOW_STRING("find_item_and_do","Entry."); + TRACE_FLOW_STRING("find_item_and_do", "Entry."); /* Item handler is always required */ - if((item_handler == (item_fn)(NULL)) && (action ==COLLECTION_ACTION_FIND)) { - TRACE_ERROR_NUMBER("No item handler - returning error!",EINVAL); + if ((item_handler == NULL) && + (action == COLLECTION_ACTION_FIND)) { + TRACE_ERROR_NUMBER("No item handler - returning error!", EINVAL); return EINVAL; } /* Make sure that there is anything to search */ type &= COL_TYPE_ANY; - if((ci == (struct collection_item *)(NULL)) || - ((property_to_find == NULL) && (type == 0)) || - ((*property_to_find == '\0') && (type == 0))) { - TRACE_ERROR_NUMBER("No item search criteria specified - returning error!",ENOKEY); + if ((ci == NULL) || + ((property_to_find == NULL) && (type == 0)) || + ((*property_to_find == '\0') && (type == 0))) { + TRACE_ERROR_NUMBER("No item search criteria specified - returning error!", ENOKEY); return ENOKEY; } /* Prepare data for traversal */ errno = 0; - traverse_data= (struct find_name *)(malloc(sizeof(struct find_name))); - if(traverse_data == (struct find_name *)(NULL)) { + traverse_data= (struct find_name *)malloc(sizeof(struct find_name)); + if (traverse_data == NULL) { error = errno; - TRACE_ERROR_NUMBER("Failed to allocate traverse data memory - returning error!",errno); + TRACE_ERROR_NUMBER("Failed to allocate traverse data memory - returning error!", errno); return error; } - TRACE_INFO_STRING("find_item_and_do","Filling in traverse data."); + TRACE_INFO_STRING("find_item_and_do", "Filling in traverse data."); traverse_data->name_to_find = property_to_find; traverse_data->name_len_to_find = strlen(property_to_find); traverse_data->type_to_match = type; traverse_data->given_name = NULL; traverse_data->given_len = 0; - traverse_data->current_path = (struct path_data *)(NULL); + traverse_data->current_path = NULL; traverse_data->action = action; mode_flags |= COL_TRAVERSE_END; - TRACE_INFO_STRING("find_item_and_do","About to walk the tree."); - TRACE_INFO_NUMBER("Traverse flags",mode_flags); + TRACE_INFO_STRING("find_item_and_do", "About to walk the tree."); + TRACE_INFO_NUMBER("Traverse flags", mode_flags); error = walk_items(ci, mode_flags, act_traverse_handler, (void *)traverse_data, item_handler, custom_data); - if(traverse_data->current_path != (struct path_data *)(NULL)) { - TRACE_INFO_STRING("find_item_and_do","Path was not cleared - deleting"); + if (traverse_data->current_path != NULL) { + TRACE_INFO_STRING("find_item_and_do", + "Path was not cleared - deleting"); delete_path_data(traverse_data->current_path); } - free((void *)(traverse_data)); + free(traverse_data); - if((error) && (error != EINTR_INTERNAL)) { - TRACE_ERROR_NUMBER("Walk items returned error. Returning: ",error); + if (error && (error != EINTR_INTERNAL)) { + TRACE_ERROR_NUMBER("Walk items returned error. Returning: ", error); return error; } else { - TRACE_FLOW_STRING("Walk items returned SUCCESS.",""); + TRACE_FLOW_STRING("Walk items returned SUCCESS.", ""); return EOK; } } @@ -734,30 +756,33 @@ static int find_item_and_do(struct collection_item *ci, static int update_current_item(struct collection_item *current, struct update_property *update_data) { - TRACE_FLOW_STRING("update_current_item","Entry"); + TRACE_FLOW_STRING("update_current_item", "Entry"); - /* If type is different or same but it is string or binary we need to replace the storage */ - if((current->type != update_data->type) || - ((current->type == update_data->type) && - ((current->type == COL_TYPE_STRING) || (current->type == COL_TYPE_BINARY)))) { - TRACE_INFO_STRING("Replacing item data buffer",""); + /* If type is different or same but it is string or binary we need to + * replace the storage */ + if ((current->type != update_data->type) || + ((current->type == update_data->type) && + ((current->type == COL_TYPE_STRING) || + (current->type == COL_TYPE_BINARY)))) { + TRACE_INFO_STRING("Replacing item data buffer", ""); free(current->data); current->data = malloc(update_data->length); - if(current->data == NULL) { - TRACE_ERROR_STRING("Failed to allocate memory",""); + if (current->data == NULL) { + TRACE_ERROR_STRING("Failed to allocate memory", ""); current->length = 0; return ENOMEM; } current->length = update_data->length; } - TRACE_INFO_STRING("Overwriting item data",""); - memcpy(current->data,update_data->data,current->length); + TRACE_INFO_STRING("Overwriting item data", ""); + memcpy(current->data, update_data->data, current->length); current->type = update_data->type; - if(current->type == COL_TYPE_STRING) *(((char *)(current->data))+current->length-1) = '\0'; + if (current->type == COL_TYPE_STRING) + ((char *)(current->data))[current->length-1] = '\0'; - TRACE_FLOW_STRING("update_current_item","Exit"); + TRACE_FLOW_STRING("update_current_item", "Exit"); return EOK; } @@ -775,9 +800,9 @@ inline static int simple_traverse_handler(struct collection_item *head, { int error = EOK; - TRACE_FLOW_STRING("simple_traverse_handler","Entry."); + TRACE_FLOW_STRING("simple_traverse_handler", "Entry."); - if(current == (struct collection_item *)(NULL)) current = &dummy; + if (current == NULL) current = &dummy; error = user_item_handler(current->property, current->property_len, @@ -787,7 +812,7 @@ inline static int simple_traverse_handler(struct collection_item *head, custom_data, stop); - TRACE_FLOW_NUMBER("simple_traverse_handler. Returning:",error); + TRACE_FLOW_NUMBER("simple_traverse_handler. Returning:", error); return error; } @@ -812,16 +837,17 @@ static int act_traverse_handler(struct collection_item *head, int property_len; struct update_property *update_data; - TRACE_FLOW_STRING("act_traverse_handler","Entry."); + TRACE_FLOW_STRING("act_traverse_handler", "Entry."); - traverse_data = (struct find_name *)(passed_traverse_data); + traverse_data = (struct find_name *)passed_traverse_data; /* We can be called when current points to NULL */ - if(current==(struct collection_item *)(NULL)) { - TRACE_INFO_STRING("act_traverse_handler","Special call at the end of the collection."); + if (current == NULL) { + TRACE_INFO_STRING("act_traverse_handler", + "Special call at the end of the collection."); temp = traverse_data->current_path; traverse_data->current_path = temp->previous_path; - temp->previous_path = (struct path_data *)(NULL); + temp->previous_path = NULL; delete_path_data(temp); traverse_data->given_name = NULL; traverse_data->given_len = 0; @@ -830,24 +856,25 @@ static int act_traverse_handler(struct collection_item *head, } /* Create new path at the beginning of a new sub collection */ - if(current->type == COL_TYPE_COLLECTION) { + if (current->type == COL_TYPE_COLLECTION) { - TRACE_INFO_STRING("act_traverse_handler","Processing collection handle."); + TRACE_INFO_STRING("act_traverse_handler", + "Processing collection handle."); /* Create new path */ - if(traverse_data->current_path != (struct path_data *)(NULL)) { - TRACE_INFO_STRING("Already have part of the path",""); - name = (traverse_data->current_path)->name; - length = (traverse_data->current_path)->length; - TRACE_INFO_STRING("Path:",name); - TRACE_INFO_NUMBER("Path len:",length); + if (traverse_data->current_path != NULL) { + TRACE_INFO_STRING("Already have part of the path", ""); + name = traverse_data->current_path->name; + length = traverse_data->current_path->length; + TRACE_INFO_STRING("Path:", name); + TRACE_INFO_NUMBER("Path len:", length); } else { name = NULL; length = 0; } - if(traverse_data->given_name != NULL) { + if (traverse_data->given_name != NULL) { property = traverse_data->given_name; property_len = traverse_data->given_len; } @@ -856,101 +883,108 @@ static int act_traverse_handler(struct collection_item *head, property_len = current->property_len; } - TRACE_INFO_STRING("act_traverse_handler","About to create path data."); + TRACE_INFO_STRING("act_traverse_handler", "About to create path data."); error = create_path_data(&(traverse_data->current_path), - name, length, property,property_len); + name, length, property, property_len); TRACE_INFO_NUMBER("create_path_data returned:", error); return error; } /* Handle the collection pointers */ - if(current->type == COL_TYPE_COLLECTIONREF) { + if (current->type == COL_TYPE_COLLECTIONREF) { traverse_data->given_name = current->property; traverse_data->given_len = current->property_len; - TRACE_INFO_STRING("Saved given name:",traverse_data->given_name); + TRACE_INFO_STRING("Saved given name:", traverse_data->given_name); } - TRACE_INFO_STRING("Processing item with property:",current->property); + TRACE_INFO_STRING("Processing item with property:", current->property); /* Do here what we do with items */ - if(match_item(current,traverse_data)) { - TRACE_INFO_STRING("Matched item:",current->property); - switch(traverse_data->action) { - case COLLECTION_ACTION_FIND: - TRACE_INFO_STRING("It is a find action - calling handler.",""); - if(user_item_handler != (item_fn)(NULL)) { - /* Call user handler */ - error = user_item_handler(current->property, - current->property_len, - current->type, - current->data, - current->length, - custom_data, - stop); - - TRACE_INFO_NUMBER("Handler returned:",error); - TRACE_INFO_NUMBER("Handler set STOP to:",*stop); + if (match_item(current, traverse_data)) { + TRACE_INFO_STRING("Matched item:", current->property); + switch (traverse_data->action) { + case COLLECTION_ACTION_FIND: + TRACE_INFO_STRING("It is a find action - calling handler.", ""); + if (user_item_handler != NULL) { + /* Call user handler */ + error = user_item_handler(current->property, + current->property_len, + current->type, + current->data, + current->length, + custom_data, + stop); + + TRACE_INFO_NUMBER("Handler returned:", error); + TRACE_INFO_NUMBER("Handler set STOP to:", *stop); - } - break; - case COLLECTION_ACTION_GET: - TRACE_INFO_STRING("It is a get action.",""); - if(custom_data != NULL) *((struct collection_item **)(custom_data)) = current; - break; - case COLLECTION_ACTION_DEL: - TRACE_INFO_STRING("It is a delete action.",""); - /* Make sure we tell the caller we found a match */ - if(custom_data != NULL) *(int *)(custom_data) = COL_MATCH; - /* Dereference external collections */ - if(current->type == COL_TYPE_COLLECTIONREF) { - TRACE_INFO_STRING("Dereferencing a referenced collection.",""); - other = *((struct collection_item **)(current->data)); - header = (struct collection_header *)(other->data); - destroy_collection(other); - } + } + break; - /* Adjust header of the collection */ - header = (struct collection_header *)(head->data); - (header->count)--; - if(current->next == (struct collection_item *)(NULL)) header->last = previous; + case COLLECTION_ACTION_GET: + TRACE_INFO_STRING("It is a get action.", ""); + if (custom_data != NULL) + *((struct collection_item **)(custom_data)) = current; + break; - /* Unlink and delete iteam */ - /* Previous can't be NULL here becuase we never delete header elements */ - previous->next = current->next; - delete_item(current); - TRACE_INFO_STRING("Did the delete of the item.",""); - break; - case COLLECTION_ACTION_UPDATE: - TRACE_INFO_STRING("It is an update action.",""); - if((current->type == COL_TYPE_COLLECTION) || - (current->type == COL_TYPE_COLLECTIONREF)) { - TRACE_ERROR_STRING("Can't update collections it is an error for now",""); - return EINVAL; - } + case COLLECTION_ACTION_DEL: + TRACE_INFO_STRING("It is a delete action.", ""); + /* Make sure we tell the caller we found a match */ + if (custom_data != NULL) + *(int *)custom_data = COL_MATCH; + /* Dereference external collections */ + if (current->type == COL_TYPE_COLLECTIONREF) { + TRACE_INFO_STRING("Dereferencing a referenced collection.", ""); + other = *((struct collection_item **)current->data); + header = (struct collection_header *)other->data; + destroy_collection(other); + } - /* Make sure we tell the caller we found a match */ - if(custom_data != NULL) { - update_data = (struct update_property *) custom_data; - update_data-> found = COL_MATCH; - error = update_current_item(current, update_data); - } - else { - TRACE_ERROR_STRING("Error - update data is required",""); - return EINVAL; - } + /* Adjust header of the collection */ + header = (struct collection_header *)head->data; + header->count--; + if (current->next == NULL) + header->last = previous; + + /* Unlink and delete iteam */ + /* Previous can't be NULL here becuase we never delete + * header elements */ + previous->next = current->next; + delete_item(current); + TRACE_INFO_STRING("Did the delete of the item.", ""); + break; - TRACE_INFO_STRING("Did the delete of the item.",""); - break; - default: - break; + case COLLECTION_ACTION_UPDATE: + TRACE_INFO_STRING("It is an update action.", ""); + if((current->type == COL_TYPE_COLLECTION) || + (current->type == COL_TYPE_COLLECTIONREF)) { + TRACE_ERROR_STRING("Can't update collections it is an error for now", ""); + return EINVAL; + } + + /* Make sure we tell the caller we found a match */ + if (custom_data != NULL) { + update_data = (struct update_property *)custom_data; + update_data->found = COL_MATCH; + error = update_current_item(current, update_data); + } + else { + TRACE_ERROR_STRING("Error - update data is required", ""); + return EINVAL; + } + + TRACE_INFO_STRING("Did the delete of the item.", ""); + break; + default: + break; } /* Force interrupt if we found */ *stop = 1; } - TRACE_FLOW_NUMBER("act_traverse_handler returning",error); + TRACE_FLOW_NUMBER("act_traverse_handler returning", error); return error; } @@ -967,80 +1001,85 @@ static int copy_traverse_handler(struct collection_item *head, int error = EOK; struct collection_item *parent; struct collection_item *item; - struct collection_item *new_collection = (struct collection_item *)(NULL); + struct collection_item *new_collection = NULL; - TRACE_FLOW_STRING("copy_traverse_handler","Entry."); + TRACE_FLOW_STRING("copy_traverse_handler", "Entry."); - parent = (struct collection_item *)(passed_traverse_data); + parent = (struct collection_item *)passed_traverse_data; /* Skip current element but rather work with next if it is not NULL */ item = current->next; - if(item == (struct collection_item *)(NULL)) return error; + if (item == NULL) return error; /* Check if this is a special case of sub collection */ - if(item->type == COL_TYPE_COLLECTIONREF) { - TRACE_INFO_STRING("Found a subcollection we need to copy. Name:",item->property); + if (item->type == COL_TYPE_COLLECTIONREF) { + TRACE_INFO_STRING("Found a subcollection we need to copy. Name:", + item->property); error = copy_collection(&new_collection, *((struct collection_item **)(item->data)), item->property); - if(error) { - TRACE_ERROR_NUMBER("Copy subcollection returned error:",error); + if (error) { + TRACE_ERROR_NUMBER("Copy subcollection returned error:", error); return error; } - /* Add new item to a collection - all references are now sub collections */ - (void)add_property(parent,NULL,item->property,(void *)(&new_collection), - sizeof(struct collection_item **), - COL_TYPE_COLLECTIONREF, &error); - if(error) { - TRACE_ERROR_NUMBER("Add property returned error:",error); + /* Add new item to a collection + * all references are now sub collections */ + add_property(parent, NULL, item->property, + (void *)(&new_collection), + sizeof(struct collection_item **), + COL_TYPE_COLLECTIONREF, &error); + if (error) { + TRACE_ERROR_NUMBER("Add property returned error:", error); return error; } } else { - (void)add_property(parent,NULL,item->property,item->data, - item->length,item->type,&error); - if(error) { - TRACE_ERROR_NUMBER("Add property returned error:",error); + add_property(parent, NULL, item->property, + item->data, item->length, item->type, &error); + if (error) { + TRACE_ERROR_NUMBER("Add property returned error:", error); return error; } } - TRACE_FLOW_NUMBER("copy_traverse_handler returning",error); + TRACE_FLOW_NUMBER("copy_traverse_handler returning", error); return error; } -/********************* MAIN INTERFACE FUNCTIONS ***********************************/ +/********************* MAIN INTERFACE FUNCTIONS *****************************/ /* CREATE */ /* Function that creates an named collection of a given class*/ -int create_collection(struct collection_item **ci,char *name, unsigned class) +int create_collection(struct collection_item **ci, char *name, unsigned cclass) { - struct collection_item *handle = (struct collection_item *)(NULL); + struct collection_item *handle = NULL; struct collection_header header; - int error=EOK; + int error = EOK; - TRACE_FLOW_STRING("create_collection","Entry."); + TRACE_FLOW_STRING("create_collection", "Entry."); /* Prepare header */ - header.last = (struct collection_item *)(NULL); + header.last = NULL; header.reference_count = 1; header.count = 0; - header.class = class; + header.cclass = cclass; /* Create a collection type property */ - handle = add_property((struct collection_item *)(NULL),NULL,name,&header,sizeof(header), COL_TYPE_COLLECTION, &error); - if(error) return error; + handle = add_property(NULL, NULL, name, + &header, sizeof(header), + COL_TYPE_COLLECTION, &error); + if (error) return error; *ci = handle; - TRACE_FLOW_STRING("create_collection","Success Exit."); + TRACE_FLOW_STRING("create_collection", "Success Exit."); return 0; } @@ -1052,28 +1091,31 @@ void destroy_collection(struct collection_item *ci) { struct collection_header *header; - TRACE_FLOW_STRING("destroy_collection","Entry."); + TRACE_FLOW_STRING("destroy_collection", "Entry."); /* Do not try to delete NULL */ - if(ci == (struct collection_item *)(NULL)) return; + if (ci == NULL) return; /* You can delete only whole collection not a part of it */ - if(ci->type != COL_TYPE_COLLECTION) { - TRACE_ERROR_STRING("Attempt to delete a non collection - BAD!",""); - TRACE_ERROR_NUMBER("Actual type is:",ci->type); + if (ci->type != COL_TYPE_COLLECTION) { + TRACE_ERROR_STRING("Attempt to delete a non collection - BAD!", ""); + TRACE_ERROR_NUMBER("Actual type is:", ci->type); return; } /* Collection can be referenced by other collection */ header = (struct collection_header *)(ci->data); - if(header->reference_count>1) { - TRACE_INFO_STRING("Dereferencing a referenced collection.",""); - (header->reference_count)--; - TRACE_INFO_NUMBER("Number after dereferencing.",header->reference_count); + if (header->reference_count > 1) { + TRACE_INFO_STRING("Dereferencing a referenced collection.", ""); + header->reference_count--; + TRACE_INFO_NUMBER("Number after dereferencing.", + header->reference_count); + } + else { + delete_collection(ci); } - else delete_collection(ci); - TRACE_FLOW_STRING("destroy_collection","Exit."); + TRACE_FLOW_STRING("destroy_collection", "Exit."); } @@ -1082,272 +1124,313 @@ void destroy_collection(struct collection_item *ci) /* Add a string property. If length equals 0, the length is determined based on the string. Lenght INCLUDES the terminating 0 */ -inline int add_str_property(struct collection_item *ci,char *subcollection, char *property,char *string,int length) +inline int add_str_property(struct collection_item *ci, char *subcollection, + char *property,char *string,int length) { int error = EOK; - TRACE_FLOW_STRING("add_str_property","Entry."); + TRACE_FLOW_STRING("add_str_property", "Entry."); + + if (length == 0) + length = strlen(string) + 1; - if(length == 0) length = strlen(string) + 1; - (void)(add_property(ci,subcollection,property,(void *)(string),length, COL_TYPE_STRING, &error)); + add_property(ci, subcollection, property, + (void *)(string), length, COL_TYPE_STRING, &error); - TRACE_FLOW_NUMBER("add_str_property returning",error); + TRACE_FLOW_NUMBER("add_str_property returning", error); return error; } /* Add a binary property. */ -inline int add_binary_property(struct collection_item *ci,char *subcollection, char *property,void *binary_data,int length) +inline int add_binary_property(struct collection_item *ci, char *subcollection, + char *property, void *binary_data, int length) { int error = EOK; - TRACE_FLOW_STRING("add_binary_property","Entry."); + TRACE_FLOW_STRING("add_binary_property", "Entry."); - (void)(add_property(ci,subcollection,property,binary_data,length, COL_TYPE_BINARY, &error)); + add_property(ci, subcollection, property, + binary_data, length, COL_TYPE_BINARY, &error); - TRACE_FLOW_NUMBER("add_binary_property returning",error); + TRACE_FLOW_NUMBER("add_binary_property returning", error); return error; } /* Add an int property. */ -inline int add_int_property(struct collection_item *ci,char *subcollection, char *property,int number) +inline int add_int_property(struct collection_item *ci, char *subcollection, + char *property,int number) { int error = EOK; - TRACE_FLOW_STRING("add_int_property","Entry."); + TRACE_FLOW_STRING("add_int_property", "Entry."); - (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_INTEGER, &error)); + add_property(ci, subcollection, property, + (void *)(&number), sizeof(int), + COL_TYPE_INTEGER, &error); - TRACE_FLOW_NUMBER("add_int_property returning",error); + TRACE_FLOW_NUMBER("add_int_property returning", error); return error; } /* Add an unsigned int property. */ -inline int add_unsigned_property(struct collection_item *ci,char *subcollection, char *property,unsigned int number) +inline int add_unsigned_property(struct collection_item *ci, + char *subcollection, + char *property, unsigned int number) { int error = EOK; - TRACE_FLOW_STRING("add_unsigned_property","Entry."); + TRACE_FLOW_STRING("add_unsigned_property", "Entry."); - (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_UNSIGNED, &error)); + add_property(ci, subcollection, property, + (void *)(&number), sizeof(int), COL_TYPE_UNSIGNED, &error); - TRACE_FLOW_NUMBER("add_unsigned_property returning",error); + TRACE_FLOW_NUMBER("add_unsigned_property returning", error); return error; } /* Add an long property. */ -inline int add_long_property(struct collection_item *ci,char *subcollection, char *property,long number) +inline int add_long_property(struct collection_item *ci, char *subcollection, + char *property,long number) { int error = EOK; - TRACE_FLOW_STRING("add_long_property","Entry."); + TRACE_FLOW_STRING("add_long_property", "Entry."); - (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_LONG, &error)); + add_property(ci, subcollection, property, + (void *)(&number), sizeof(long), COL_TYPE_LONG, &error); - TRACE_FLOW_NUMBER("add_long_property returning",error); + TRACE_FLOW_NUMBER("add_long_property returning", error); return error; } /* Add an unsigned long property. */ -inline int add_ulong_property(struct collection_item *ci,char *subcollection, char *property,unsigned long number) +inline int add_ulong_property(struct collection_item *ci, char *subcollection, + char *property, unsigned long number) { int error = EOK; - TRACE_FLOW_STRING("add_ulong_property","Entry."); + TRACE_FLOW_STRING("add_ulong_property", "Entry."); - (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_ULONG, &error)); + add_property(ci, subcollection, property, + (void *)(&number), sizeof(long), + COL_TYPE_ULONG, &error); - TRACE_FLOW_NUMBER("add_ulong_property returning",error); + TRACE_FLOW_NUMBER("add_ulong_property returning", error); return error; } /* Add a double property. */ -inline int add_double_property(struct collection_item *ci,char *subcollection, char *property,double number) +inline int add_double_property(struct collection_item *ci, char *subcollection, + char *property,double number) { int error = EOK; - TRACE_FLOW_STRING("add_double_property","Entry."); + TRACE_FLOW_STRING("add_double_property", "Entry."); - (void)(add_property(ci,subcollection,property,(void *)(&number),sizeof(double), COL_TYPE_DOUBLE, &error)); + add_property(ci, subcollection, property, + (void *)(&number), sizeof(double), COL_TYPE_DOUBLE, &error); - TRACE_FLOW_NUMBER("add_double_property returning",error); + TRACE_FLOW_NUMBER("add_double_property returning", error); return error; } /* Add a bool property. */ -inline int add_bool_property(struct collection_item *ci,char *subcollection, char *property,unsigned char logical) +inline int add_bool_property(struct collection_item *ci, char *subcollection, + char *property,unsigned char logical) { int error = EOK; - TRACE_FLOW_STRING("add_bool_property","Entry."); + TRACE_FLOW_STRING("add_bool_property", "Entry."); - (void)(add_property(ci,subcollection,property,(void *)(&logical),sizeof(unsigned char), COL_TYPE_BOOL, &error)); + add_property(ci, subcollection, property, + (void *)(&logical), sizeof(unsigned char), + COL_TYPE_BOOL, &error); - TRACE_FLOW_NUMBER("add_bool_property returning",error); + TRACE_FLOW_NUMBER("add_bool_property returning", error); return error; } /* A function to add a property */ inline int add_any_property(struct collection_item *ci, - char *subcollection, - char *property, - int type, - void *data, - int length) + char *subcollection, char *property, + int type, void *data, int length) { int error = EOK; - TRACE_FLOW_STRING("add_any_property","Entry."); + TRACE_FLOW_STRING("add_any_property", "Entry."); - (void)(add_property(ci,subcollection,property,data,length, type, &error)); + add_property(ci, subcollection, property, data, length, type, &error); - TRACE_FLOW_NUMBER("add_any_property returning",error); + TRACE_FLOW_NUMBER("add_any_property returning", error); return error; } /* Add a string property. If length equals 0, the length is determined based on the string. Lenght INCLUDES the terminating 0 */ -inline int add_str_property_with_ref(struct collection_item *ci,char *subcollection, - char *property,char *string,int length, +inline int add_str_property_with_ref(struct collection_item *ci, + char *subcollection, char *property, + char *string, int length, struct collection_item **ref_ret) { int error = EOK; struct collection_item *item; - TRACE_FLOW_STRING("add_str_property_with_ref","Entry."); + TRACE_FLOW_STRING("add_str_property_with_ref", "Entry."); - if(length == 0) length = strlen(string) + 1; - item = add_property(ci,subcollection,property,(void *)(string),length, COL_TYPE_STRING, &error); + if (length == 0) length = strlen(string) + 1; - if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item; + item = add_property(ci, subcollection, property, + (void *)(string), length, COL_TYPE_STRING, &error); - TRACE_FLOW_NUMBER("add_str_property_with_ref returning",error); + if (ref_ret != NULL) *ref_ret = item; + + TRACE_FLOW_NUMBER("add_str_property_with_ref returning", error); return error; } /* Add a binary property. */ -inline int add_binary_property_with_ref(struct collection_item *ci,char *subcollection, - char *property,void *binary_data,int length, +inline int add_binary_property_with_ref(struct collection_item *ci, + char *subcollection, char *property, + void *binary_data, int length, struct collection_item **ref_ret) { int error = EOK; struct collection_item *item; - TRACE_FLOW_STRING("add_binary_property_with_ref","Entry."); + TRACE_FLOW_STRING("add_binary_property_with_ref", "Entry."); - item = add_property(ci,subcollection,property,binary_data,length, COL_TYPE_BINARY, &error); + item = add_property(ci, subcollection, property, + binary_data, length, COL_TYPE_BINARY, &error); - if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item; + if (ref_ret != NULL) *ref_ret = item; - TRACE_FLOW_NUMBER("add_binary_property_with_ref returning",error); + TRACE_FLOW_NUMBER("add_binary_property_with_ref returning", error); return error; } /* Add an int property. */ -inline int add_int_property_with_ref(struct collection_item *ci,char *subcollection, - char *property,int number, +inline int add_int_property_with_ref(struct collection_item *ci, + char *subcollection, char *property, + int number, struct collection_item **ref_ret) { int error = EOK; struct collection_item *item; - TRACE_FLOW_STRING("add_int_property_with_ref","Entry."); + TRACE_FLOW_STRING("add_int_property_with_ref", "Entry."); - item = add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_INTEGER, &error); + item = add_property(ci, subcollection, property, + (void *)(&number), sizeof(int), + COL_TYPE_INTEGER, &error); - if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item; + if (ref_ret != NULL) *ref_ret = item; - TRACE_FLOW_NUMBER("add_int_property_with_ref returning",error); + TRACE_FLOW_NUMBER("add_int_property_with_ref returning", error); return error; } /* Add an unsigned int property. */ -inline int add_unsigned_property_with_ref(struct collection_item *ci,char *subcollection, - char *property,unsigned int number, +inline int add_unsigned_property_with_ref(struct collection_item *ci, + char *subcollection, char *property, + unsigned int number, struct collection_item **ref_ret) { int error = EOK; struct collection_item *item; - TRACE_FLOW_STRING("add_unsigned_property_with_ref","Entry."); + TRACE_FLOW_STRING("add_unsigned_property_with_ref", "Entry."); - item = add_property(ci,subcollection,property,(void *)(&number),sizeof(int), COL_TYPE_UNSIGNED, &error); + item = add_property(ci, subcollection, property, + (void *)(&number), sizeof(int), + COL_TYPE_UNSIGNED, &error); - if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item; + if (ref_ret != NULL) *ref_ret = item; - TRACE_FLOW_NUMBER("add_unsigned_property_with_ref returning",error); + TRACE_FLOW_NUMBER("add_unsigned_property_with_ref returning", error); return error; } /* Add an long property. */ -inline int add_long_property_with_ref(struct collection_item *ci,char *subcollection, - char *property,long number, +inline int add_long_property_with_ref(struct collection_item *ci, + char *subcollection, char *property, + long number, struct collection_item **ref_ret) { int error = EOK; struct collection_item *item; - TRACE_FLOW_STRING("add_long_property_with_ref","Entry."); + TRACE_FLOW_STRING("add_long_property_with_ref", "Entry."); - item = add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_LONG, &error); + item = add_property(ci, subcollection, property, + (void *)(&number), sizeof(long), COL_TYPE_LONG, &error); - if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item; + if (ref_ret != NULL) *ref_ret = item; - TRACE_FLOW_NUMBER("add_long_property_with_ref returning",error); + TRACE_FLOW_NUMBER("add_long_property_with_ref returning", error); return error; } /* Add an unsigned long property. */ -inline int add_ulong_property_with_ref(struct collection_item *ci,char *subcollection, - char *property,unsigned long number, +inline int add_ulong_property_with_ref(struct collection_item *ci, + char *subcollection, char *property, + unsigned long number, struct collection_item **ref_ret) { int error = EOK; struct collection_item *item; - TRACE_FLOW_STRING("add_ulong_property_with_ref","Entry."); + TRACE_FLOW_STRING("add_ulong_property_with_ref", "Entry."); - item = add_property(ci,subcollection,property,(void *)(&number),sizeof(long), COL_TYPE_ULONG, &error); + item = add_property(ci, subcollection, property, + (void *)(&number), sizeof(long), + COL_TYPE_ULONG, &error); - if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item; + if (ref_ret != NULL) *ref_ret = item; - TRACE_FLOW_NUMBER("add_ulong_property_with_ref returning",error); + TRACE_FLOW_NUMBER("add_ulong_property_with_ref returning", error); return error; } /* Add a double property. */ -inline int add_double_property_with_ref(struct collection_item *ci,char *subcollection, - char *property,double number, +inline int add_double_property_with_ref(struct collection_item *ci, + char *subcollection, char *property, + double number, struct collection_item **ref_ret) { int error = EOK; struct collection_item *item; - TRACE_FLOW_STRING("add_double_property_with_ref","Entry."); + TRACE_FLOW_STRING("add_double_property_with_ref", "Entry."); - item = add_property(ci,subcollection,property,(void *)(&number),sizeof(double), COL_TYPE_DOUBLE, &error); + item = add_property(ci, subcollection, property, + (void *)(&number), sizeof(double), + COL_TYPE_DOUBLE, &error); - if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item; + if (ref_ret != NULL) *ref_ret = item; - TRACE_FLOW_NUMBER("add_double_property_with_ref returning",error); + TRACE_FLOW_NUMBER("add_double_property_with_ref returning", error); return error; } /* Add a bool property. */ -inline int add_bool_property_with_ref(struct collection_item *ci,char *subcollection, - char *property,unsigned char logical, +inline int add_bool_property_with_ref(struct collection_item *ci, + char *subcollection, char *property, + unsigned char logical, struct collection_item **ref_ret) { int error = EOK; struct collection_item *item; - TRACE_FLOW_STRING("add_bool_property_with_ref","Entry."); + TRACE_FLOW_STRING("add_bool_property_with_ref", "Entry."); - item = add_property(ci,subcollection,property,(void *)(&logical),sizeof(unsigned char), COL_TYPE_BOOL, &error); + item = add_property(ci, subcollection, property, + (void *)(&logical), sizeof(unsigned char), + COL_TYPE_BOOL, &error); - if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item; + if (ref_ret != NULL) *ref_ret = item; - TRACE_FLOW_NUMBER("add_bool_property_with_ref returning",error); + TRACE_FLOW_NUMBER("add_bool_property_with_ref returning", error); return error; } @@ -1363,13 +1446,14 @@ inline int add_any_property_with_ref(struct collection_item *ci, int error = EOK; struct collection_item *item; - TRACE_FLOW_STRING("add_any_property_with_ref","Entry."); + TRACE_FLOW_STRING("add_any_property_with_ref", "Entry."); - item = add_property(ci,subcollection,property,data,length, type, &error); + item = add_property(ci, subcollection, property, + data, length, type, &error); - if(ref_ret != (struct collection_item **)(NULL)) *ref_ret = item; + if (ref_ret != NULL) *ref_ret = item; - TRACE_FLOW_NUMBER("add_any_property_with_ref returning",error); + TRACE_FLOW_NUMBER("add_any_property_with_ref returning", error); return error; } @@ -1381,35 +1465,37 @@ inline int add_any_property_with_ref(struct collection_item *ci, /* Referenced collections of the donor are copied as sub collections. */ int copy_collection(struct collection_item **collection_copy, struct collection_item *collection_to_copy, - char *name_to_use) { - + char *name_to_use) +{ int error = EOK; - struct collection_item *new_collection = (struct collection_item *)(NULL); + struct collection_item *new_collection = NULL; char *name; struct collection_header *header; - TRACE_FLOW_STRING("copy_collection","Entry."); + TRACE_FLOW_STRING("copy_collection", "Entry."); /* Determine what name to use */ - if(name_to_use != NULL) name = name_to_use; - else name = collection_to_copy->property; + if (name_to_use != NULL) + name = name_to_use; + else + name = collection_to_copy->property; - header = (struct collection_header *)(collection_to_copy->data); + header = (struct collection_header *)collection_to_copy->data; /* Create a new collection */ - error = create_collection(&new_collection,name,header->class); - if(error) { - TRACE_ERROR_NUMBER("Create_cllection failed returning",error); + error = create_collection(&new_collection, name, header->cclass); + if (error) { + TRACE_ERROR_NUMBER("Create_cllection failed returning", error); return error; } - error = walk_items(collection_to_copy, COL_TRAVERSE_ONELEVEL, copy_traverse_handler, - new_collection, NULL, NULL); + error = walk_items(collection_to_copy, COL_TRAVERSE_ONELEVEL, + copy_traverse_handler, new_collection, NULL, NULL); - if(!error) *collection_copy = new_collection; + if (!error) *collection_copy = new_collection; else destroy_collection(new_collection); - TRACE_FLOW_NUMBER("copy_collection returning",error); + TRACE_FLOW_NUMBER("copy_collection returning", error); return error; } @@ -1422,42 +1508,46 @@ int get_collection_reference(struct collection_item *ci, /* High level char *collection_to_find) /* Name to of the collection */ { struct collection_header *header; - struct collection_item *subcollection = (struct collection_item *)(NULL); + struct collection_item *subcollection = NULL; int error = EOK; - TRACE_FLOW_STRING("get_collection_reference","Entry."); + TRACE_FLOW_STRING("get_collection_reference", "Entry."); - if((ci == (struct collection_item *)(NULL)) || - (ci->type != COL_TYPE_COLLECTION) || - (acceptor == (struct collection_item **)(NULL)) || - (collection_to_find == NULL)) { + if ((ci == NULL) || + (ci->type != COL_TYPE_COLLECTION) || + (acceptor == NULL) || + (collection_to_find == NULL)) { TRACE_ERROR_NUMBER("Invalid parameter - returning error",EINVAL); return EINVAL; } /* Find a sub collection */ - TRACE_INFO_STRING("We are given subcollection name - search it:",collection_to_find); - error = find_item_and_do(ci,collection_to_find,COL_TYPE_COLLECTIONREF, + TRACE_INFO_STRING("We are given subcollection name - search it:", + collection_to_find); + error = find_item_and_do(ci, collection_to_find, + COL_TYPE_COLLECTIONREF, COL_TRAVERSE_DEFAULT, - get_subcollection,(void *)(&subcollection),COLLECTION_ACTION_FIND); - if(error) { - TRACE_ERROR_NUMBER("Search failed returning error",error); + get_subcollection, + (void *)(&subcollection), + COLLECTION_ACTION_FIND); + if (error) { + TRACE_ERROR_NUMBER("Search failed returning error", error); return error; } - if(subcollection == (struct collection_item *)(NULL)) { - TRACE_ERROR_STRING("Search for subcollection returned NULL pointer",""); + if (subcollection == NULL) { + TRACE_ERROR_STRING("Search for subcollection returned NULL pointer", ""); return ENOENT; } - header = (struct collection_header *)(subcollection->data); - TRACE_INFO_NUMBER("Count:",header->count); - TRACE_INFO_NUMBER("Ref count:",header->reference_count); - (header->reference_count)++; - TRACE_INFO_NUMBER("Ref count after increment:",header->reference_count); + header = (struct collection_header *)subcollection->data; + TRACE_INFO_NUMBER("Count:", header->count); + TRACE_INFO_NUMBER("Ref count:", header->reference_count); + header->reference_count++; + TRACE_INFO_NUMBER("Ref count after increment:", header->reference_count); *acceptor = subcollection; - TRACE_FLOW_STRING("get_collection_reference","Success Exit."); + TRACE_FLOW_STRING("get_collection_reference", "Success Exit."); return EOK; } @@ -1466,27 +1556,27 @@ int get_reference_from_item(struct collection_item *ci, struct collection_item **acceptor) { struct collection_header *header; - struct collection_item *subcollection = (struct collection_item *)(NULL); + struct collection_item *subcollection = NULL; - TRACE_FLOW_STRING("get_reference_from_item","Entry."); + TRACE_FLOW_STRING("get_reference_from_item", "Entry."); - if((ci == (struct collection_item *)(NULL)) || - (ci->type != COL_TYPE_COLLECTIONREF) || - (acceptor == (struct collection_item **)(NULL))) { + if ((ci == NULL) || + (ci->type != COL_TYPE_COLLECTIONREF) || + (acceptor == NULL)) { TRACE_ERROR_NUMBER("Invalid parameter - returning error",EINVAL); return EINVAL; } - subcollection = *((struct collection_item **)(ci->data)); + subcollection = *((struct collection_item **)ci->data); - header = (struct collection_header *)(subcollection->data); - TRACE_INFO_NUMBER("Count:",header->count); - TRACE_INFO_NUMBER("Ref count:",header->reference_count); - (header->reference_count)++; - TRACE_INFO_NUMBER("Ref count after increment:",header->reference_count); + header = (struct collection_header *)subcollection->data; + TRACE_INFO_NUMBER("Count:", header->count); + TRACE_INFO_NUMBER("Ref count:", header->reference_count); + header->reference_count++; + TRACE_INFO_NUMBER("Ref count after increment:", header->reference_count); *acceptor = subcollection; - TRACE_FLOW_STRING("get_reference_from_item","Success Exit."); + TRACE_FLOW_STRING("get_reference_from_item", "Success Exit."); return EOK; } @@ -1504,121 +1594,143 @@ int add_collection_to_collection( struct collection_item *collection_to_add, /* Collection to add */ int mode) /* How this collection needs to be added */ { - struct collection_item *acceptor = (struct collection_item *)(NULL); + struct collection_item *acceptor = NULL; char *name_to_use; struct collection_header *header; struct collection_item *collection_copy; int error = EOK; - TRACE_FLOW_STRING("add_collection_to_collection","Entry."); + TRACE_FLOW_STRING("add_collection_to_collection", "Entry."); - if((ci == (struct collection_item *)(NULL)) || - (ci->type != COL_TYPE_COLLECTION) || - (collection_to_add == (struct collection_item *)(NULL)) || - (collection_to_add->type != COL_TYPE_COLLECTION)) { + if ((ci == NULL) || + (ci->type != COL_TYPE_COLLECTION) || + (collection_to_add == NULL) || + (collection_to_add->type != COL_TYPE_COLLECTION)) { /* Need to debug here */ - TRACE_ERROR_NUMBER("Missing parameter - returning error",EINVAL); + TRACE_ERROR_NUMBER("Missing parameter - returning error", EINVAL); return EINVAL; } - if(sub_collection_name != NULL) { + if (sub_collection_name != NULL) { /* Find a sub collection */ - TRACE_INFO_STRING("We are given subcollection name - search it:",sub_collection_name); - error = find_item_and_do(ci,sub_collection_name,COL_TYPE_COLLECTIONREF, + TRACE_INFO_STRING("We are given subcollection name - search it:", + sub_collection_name); + error = find_item_and_do(ci, sub_collection_name, + COL_TYPE_COLLECTIONREF, COL_TRAVERSE_DEFAULT, - get_subcollection,(void *)(&acceptor),COLLECTION_ACTION_FIND); - if(error) { - TRACE_ERROR_NUMBER("Search failed returning error",error); + get_subcollection, + (void *)(&acceptor), + COLLECTION_ACTION_FIND); + if (error) { + TRACE_ERROR_NUMBER("Search failed returning error", error); return error; } - if(acceptor == (struct collection_item *)(NULL)) { - TRACE_ERROR_STRING("Search for subcollection returned NULL pointer",""); + if (acceptor == NULL) { + TRACE_ERROR_STRING("Search for subcollection returned NULL pointer", ""); return ENOENT; } } - else acceptor = ci; + else { + acceptor = ci; + } - if(as_property != NULL) + if (as_property != NULL) name_to_use = as_property; else name_to_use = collection_to_add->property; - TRACE_INFO_STRING("Going to use name:",name_to_use); - - - switch(mode) { - case COL_ADD_MODE_REFERENCE: - TRACE_INFO_STRING("We are adding a reference.",""); - TRACE_INFO_NUMBER("Type of the header element:",collection_to_add->type); - TRACE_INFO_STRING("Header name we are adding.",collection_to_add->property); - /* Create a pointer to external collection */ - /* For future thread safety: Transaction start -> */ - (void)(add_property(acceptor,NULL,name_to_use,(void *)(&collection_to_add), - sizeof(struct collection_item **), - COL_TYPE_COLLECTIONREF, &error)); - - TRACE_INFO_NUMBER("Type of the header element after add_property:",collection_to_add->type); - TRACE_INFO_STRING("Header name we just added.",collection_to_add->property); - if(error) { - TRACE_ERROR_NUMBER("Adding property failed with error:",error); - return error; - } - header = (struct collection_header *)(collection_to_add->data); - TRACE_INFO_NUMBER("Count:",header->count); - TRACE_INFO_NUMBER("Ref count:",header->reference_count); - (header->reference_count)++; - TRACE_INFO_NUMBER("Ref count after increment:",header->reference_count); - /* -> Transaction end */ - break; - case COL_ADD_MODE_EMBED: - TRACE_INFO_STRING("We are embedding the collection.",""); - /* First check if the passed in collection is referenced more than once */ - TRACE_INFO_NUMBER("Type of the header element we are adding:",collection_to_add->type); - TRACE_INFO_STRING("Header name we are adding.",collection_to_add->property); - TRACE_INFO_NUMBER("Type of the header element we are adding to:",acceptor->type); - TRACE_INFO_STRING("Header name we are adding to.",acceptor->property); - - (void)(add_property(acceptor,NULL,name_to_use,(void *)(&collection_to_add), - sizeof(struct collection_item **), - COL_TYPE_COLLECTIONREF, &error)); - - TRACE_INFO_NUMBER("Adding property returned:",error); - break; - - case COL_ADD_MODE_CLONE: - TRACE_INFO_STRING("We are cloning the collection.",""); - TRACE_INFO_STRING("Name we will use.",name_to_use); - - /* For future thread safety: Transaction start -> */ - error = copy_collection(&collection_copy, collection_to_add, name_to_use); - if(error) return error; - - TRACE_INFO_STRING("We have a collection copy.", collection_copy->property); - TRACE_INFO_NUMBER("Collection type.", collection_copy->type); - TRACE_INFO_STRING("Acceptor collection.", acceptor->property); - TRACE_INFO_NUMBER("Acceptor collection type.", acceptor->type); - - (void)(add_property(acceptor,NULL,name_to_use,(void *)(&collection_copy), - sizeof(struct collection_item **), - COL_TYPE_COLLECTIONREF, &error)); - - /* -> Transaction end */ - TRACE_INFO_NUMBER("Adding property returned:",error); - break; - - default: error = EINVAL; - } - - TRACE_FLOW_NUMBER("add_collection_to_collection returning:",error); + TRACE_INFO_STRING("Going to use name:", name_to_use); + + + switch (mode) { + case COL_ADD_MODE_REFERENCE: + TRACE_INFO_STRING("We are adding a reference.", ""); + TRACE_INFO_NUMBER("Type of the header element:", + collection_to_add->type); + TRACE_INFO_STRING("Header name we are adding.", + collection_to_add->property); + /* Create a pointer to external collection */ + /* For future thread safety: Transaction start -> */ + add_property(acceptor, NULL, name_to_use, + (void *)(&collection_to_add), + sizeof(struct collection_item **), + COL_TYPE_COLLECTIONREF, &error); + + TRACE_INFO_NUMBER("Type of the header element after add_property:", + collection_to_add->type); + TRACE_INFO_STRING("Header name we just added.", + collection_to_add->property); + if (error) { + TRACE_ERROR_NUMBER("Adding property failed with error:", error); + return error; + } + header = (struct collection_header *)collection_to_add->data; + TRACE_INFO_NUMBER("Count:", header->count); + TRACE_INFO_NUMBER("Ref count:", header->reference_count); + header->reference_count++; + TRACE_INFO_NUMBER("Ref count after increment:", + header->reference_count); + /* -> Transaction end */ + break; + + case COL_ADD_MODE_EMBED: + TRACE_INFO_STRING("We are embedding the collection.", ""); + /* First check if the passed in collection is referenced more than once */ + TRACE_INFO_NUMBER("Type of the header element we are adding:", + collection_to_add->type); + TRACE_INFO_STRING("Header name we are adding.", + collection_to_add->property); + TRACE_INFO_NUMBER("Type of the header element we are adding to:", + acceptor->type); + TRACE_INFO_STRING("Header name we are adding to.", + acceptor->property); + + add_property(acceptor, NULL, name_to_use, + (void *)(&collection_to_add), + sizeof(struct collection_item **), + COL_TYPE_COLLECTIONREF, &error); + + TRACE_INFO_NUMBER("Adding property returned:", error); + break; + + case COL_ADD_MODE_CLONE: + TRACE_INFO_STRING("We are cloning the collection.", ""); + TRACE_INFO_STRING("Name we will use.", name_to_use); + + /* For future thread safety: Transaction start -> */ + error = copy_collection(&collection_copy, + collection_to_add, name_to_use); + if (error) return error; + + TRACE_INFO_STRING("We have a collection copy.", collection_copy->property); + TRACE_INFO_NUMBER("Collection type.", collection_copy->type); + TRACE_INFO_STRING("Acceptor collection.", acceptor->property); + TRACE_INFO_NUMBER("Acceptor collection type.", acceptor->type); + + add_property(acceptor, NULL, name_to_use, + (void *)(&collection_copy), + sizeof(struct collection_item **), + COL_TYPE_COLLECTIONREF, &error); + + /* -> Transaction end */ + TRACE_INFO_NUMBER("Adding property returned:", error); + break; + + default: + error = EINVAL; + } + + TRACE_FLOW_NUMBER("add_collection_to_collection returning:", error); return error; } /* TRAVERSING */ -/* Function to traverse the entire collection including optionally sub collections */ +/* Function to traverse the entire collection including optionally + * sub collections */ inline int traverse_collection(struct collection_item *ci, int mode_flags, item_fn item_handler, @@ -1626,17 +1738,17 @@ inline int traverse_collection(struct collection_item *ci, { int error = EOK; - TRACE_FLOW_STRING("traverse_collection","Entry."); + TRACE_FLOW_STRING("traverse_collection", "Entry."); error = walk_items(ci, mode_flags, simple_traverse_handler, NULL, item_handler, custom_data); - if((error != 0) && (error != EINTR_INTERNAL)) { - TRACE_ERROR_NUMBER("Error walking tree",error); + if ((error != 0) && (error != EINTR_INTERNAL)) { + TRACE_ERROR_NUMBER("Error walking tree", error); return error; } - TRACE_FLOW_STRING("traverse_collection","Success exit."); + TRACE_FLOW_STRING("traverse_collection", "Success exit."); return EOK; } @@ -1654,10 +1766,13 @@ inline int is_item_in_collection(struct collection_item *ci, TRACE_FLOW_STRING("is_item_in_collection","Entry."); *found = COL_NOMATCH; - error = find_item_and_do(ci,property_to_find,type,mode_flags, - is_in_item_handler,(void *)found,COLLECTION_ACTION_FIND); + error = find_item_and_do(ci, property_to_find, + type, mode_flags, + is_in_item_handler, + (void *)found, + COLLECTION_ACTION_FIND); - TRACE_FLOW_NUMBER("is_item_in_collection returning",error); + TRACE_FLOW_NUMBER("is_item_in_collection returning", error); return error; } @@ -1676,9 +1791,13 @@ inline int get_item_and_do(struct collection_item *ci, /* Collection to fi TRACE_FLOW_STRING("get_item_and_do","Entry."); - error = find_item_and_do(ci,property_to_find,type,mode_flags,item_handler,custom_data,COLLECTION_ACTION_FIND); + error = find_item_and_do(ci, property_to_find, + type, mode_flags, + item_handler, + custom_data, + COLLECTION_ACTION_FIND); - TRACE_FLOW_NUMBER("get_item_and_do returning",error); + TRACE_FLOW_NUMBER("get_item_and_do returning", error); return error; } @@ -1693,11 +1812,14 @@ inline int get_item(struct collection_item *ci, /* Collection to find thin int error = EOK; - TRACE_FLOW_STRING("get_item","Entry."); + TRACE_FLOW_STRING("get_item", "Entry."); - error = find_item_and_do(ci,property_to_find,type,mode_flags,NULL,(void *)(item),COLLECTION_ACTION_GET); + error = find_item_and_do(ci, property_to_find, + type, mode_flags, + NULL, (void *)item, + COLLECTION_ACTION_GET); - TRACE_FLOW_NUMBER("get_item returning",error); + TRACE_FLOW_NUMBER("get_item returning", error); return error; } @@ -1711,13 +1833,18 @@ inline int delete_property(struct collection_item *ci, /* Collection to find int error = EOK; int found; - TRACE_FLOW_STRING("delete_property","Entry."); + TRACE_FLOW_STRING("delete_property", "Entry."); found = COL_NOMATCH; - error = find_item_and_do(ci,property_to_find,type,mode_flags,NULL,(void *)(&found),COLLECTION_ACTION_DEL); + error = find_item_and_do(ci, property_to_find, + type, mode_flags, + NULL, (void *)(&found), + COLLECTION_ACTION_DEL); - if((error == EOK) && (found == COL_NOMATCH)) error = ENOENT; - TRACE_FLOW_NUMBER("delete_property returning",error); + if ((error == EOK) && (found == COL_NOMATCH)) + error = ENOENT; + + TRACE_FLOW_NUMBER("delete_property returning", error); return error; } @@ -1734,20 +1861,26 @@ int update_property(struct collection_item *ci, /* Collection to find things int error = EOK; struct update_property update_data; - TRACE_FLOW_STRING("update_property","Entry."); + TRACE_FLOW_STRING("update_property", "Entry."); update_data.type = type; update_data.data = new_data; update_data.length = length; update_data.found = COL_NOMATCH; - error = find_item_and_do(ci,property_to_find,type,mode_flags,NULL,(void *)(&update_data),COLLECTION_ACTION_UPDATE); + error = find_item_and_do(ci, property_to_find, + type, mode_flags, + NULL, (void *)(&update_data), + COLLECTION_ACTION_UPDATE); + + if ((error == EOK) && (update_data.found == COL_NOMATCH)) + error = ENOENT; - if((error == EOK) && (update_data.found == COL_NOMATCH)) error = ENOENT; - TRACE_FLOW_NUMBER("update_property returning",error); + TRACE_FLOW_NUMBER("update_property returning", error); return error; } -/* Update a string property in the collection. Length should include the null terminating 0 */ +/* Update a string property in the collection. + * Length should include the terminating 0 */ inline int update_str_property(struct collection_item *ci, char *property, int mode_flags, @@ -1755,12 +1888,13 @@ inline int update_str_property(struct collection_item *ci, int length) { int error = EOK; - TRACE_FLOW_STRING("update_str_property","Entry."); + TRACE_FLOW_STRING("update_str_property", "Entry."); - if(length == 0) length = strlen(string) + 1; - error = update_property(ci,property, COL_TYPE_STRING, (void *)(string),length,mode_flags); + if (length == 0) length = strlen(string) + 1; + error = update_property(ci, property, COL_TYPE_STRING, + (void *)string, length, mode_flags); - TRACE_FLOW_NUMBER("update_str_property Returning",error); + TRACE_FLOW_NUMBER("update_str_property Returning", error); return error; } @@ -1772,11 +1906,12 @@ inline int update_binary_property(struct collection_item *ci, int length) { int error = EOK; - TRACE_FLOW_STRING("update_binary_property","Entry."); + TRACE_FLOW_STRING("update_binary_property", "Entry."); - error = update_property(ci,property, COL_TYPE_BINARY, binary_data, length, mode_flags); + error = update_property(ci, property, COL_TYPE_BINARY, + binary_data, length, mode_flags); - TRACE_FLOW_NUMBER("update_binary_property Returning",error); + TRACE_FLOW_NUMBER("update_binary_property Returning", error); return error; } @@ -1787,25 +1922,28 @@ inline int update_int_property(struct collection_item *ci, int number) { int error = EOK; - TRACE_FLOW_STRING("update_int_property","Entry."); + TRACE_FLOW_STRING("update_int_property", "Entry."); - error = update_property(ci,property, COL_TYPE_INTEGER, (void *)(&number), sizeof(int), mode_flags); + error = update_property(ci, property, COL_TYPE_INTEGER, + (void *)(&number), sizeof(int), mode_flags); - TRACE_FLOW_NUMBER("update_int_property Returning",error); + TRACE_FLOW_NUMBER("update_int_property Returning", error); return error; } /* Update an unsigned int property. */ inline int update_unsigned_property(struct collection_item *ci, - char *property,int mode_flags, + char *property, int mode_flags, unsigned int number) { int error = EOK; - TRACE_FLOW_STRING("update_unsigned_property","Entry."); + TRACE_FLOW_STRING("update_unsigned_property", "Entry."); - error = update_property(ci,property, COL_TYPE_UNSIGNED, (void *)(&number), sizeof(unsigned int), mode_flags); + error = update_property(ci, property, COL_TYPE_UNSIGNED, + (void *)(&number), sizeof(unsigned int), + mode_flags); - TRACE_FLOW_NUMBER("update_unsigned_property Returning",error); + TRACE_FLOW_NUMBER("update_unsigned_property Returning", error); return error; } /* Update a long property. */ @@ -1815,11 +1953,12 @@ inline int update_long_property(struct collection_item *ci, long number) { int error = EOK; - TRACE_FLOW_STRING("update_long_property","Entry."); + TRACE_FLOW_STRING("update_long_property", "Entry."); - error = update_property(ci,property, COL_TYPE_LONG, (void *)(&number), sizeof(long), mode_flags); + error = update_property(ci, property, COL_TYPE_LONG, + (void *)(&number), sizeof(long), mode_flags); - TRACE_FLOW_NUMBER("update_long_property Returning",error); + TRACE_FLOW_NUMBER("update_long_property Returning", error); return error; } @@ -1831,11 +1970,13 @@ inline int update_ulong_property(struct collection_item *ci, unsigned long number) { int error = EOK; - TRACE_FLOW_STRING("update_ulong_property","Entry."); + TRACE_FLOW_STRING("update_ulong_property", "Entry."); - error = update_property(ci,property, COL_TYPE_ULONG, (void *)(&number), sizeof(unsigned long), mode_flags); + error = update_property(ci, property, COL_TYPE_ULONG, + (void *)(&number), sizeof(unsigned long), + mode_flags); - TRACE_FLOW_NUMBER("update_ulong_property Returning",error); + TRACE_FLOW_NUMBER("update_ulong_property Returning", error); return error; } @@ -1846,11 +1987,12 @@ inline int update_double_property(struct collection_item *ci, double number) { int error = EOK; - TRACE_FLOW_STRING("update_double_property","Entry."); + TRACE_FLOW_STRING("update_double_property", "Entry."); - error = update_property(ci,property, COL_TYPE_DOUBLE, (void *)(&number), sizeof(double), mode_flags); + error = update_property(ci, property, COL_TYPE_DOUBLE, + (void *)(&number), sizeof(double), mode_flags); - TRACE_FLOW_NUMBER("update_double_property Returning",error); + TRACE_FLOW_NUMBER("update_double_property Returning", error); return error; } @@ -1861,11 +2003,13 @@ inline int update_bool_property(struct collection_item *ci, unsigned char logical) { int error = EOK; - TRACE_FLOW_STRING("update_bool_property","Entry."); + TRACE_FLOW_STRING("update_bool_property", "Entry."); - error = update_property(ci,property, COL_TYPE_BOOL, (void *)(&logical), sizeof(unsigned char), mode_flags); + error = update_property(ci, property, COL_TYPE_BOOL, + (void *)(&logical), sizeof(unsigned char), + mode_flags); - TRACE_FLOW_NUMBER("update_bool_property Returning",error); + TRACE_FLOW_NUMBER("update_bool_property Returning", error); return error; } @@ -1876,33 +2020,34 @@ int modify_item(struct collection_item *item, void *data, int length) { - TRACE_FLOW_STRING("modify_item","Entry"); + TRACE_FLOW_STRING("modify_item", "Entry"); - if((item == (struct collection_item *)(NULL)) || - (item->type == COL_TYPE_COLLECTION) || - (item->type == COL_TYPE_COLLECTIONREF)) { - TRACE_ERROR_NUMBER("Invalid argument or invalid argument type",EINVAL); + if ((item == NULL) || + (item->type == COL_TYPE_COLLECTION) || + (item->type == COL_TYPE_COLLECTIONREF)) { + TRACE_ERROR_NUMBER("Invalid argument or invalid argument type", EINVAL); return EINVAL; } - if(property != NULL) { + if (property != NULL) { free(item->property); item->property=strdup(property); - if(item->property == NULL) { - TRACE_ERROR_STRING("Failed to allocate memory",""); + if (item->property == NULL) { + TRACE_ERROR_STRING("Failed to allocate memory", ""); return ENOMEM; } } - /* If type is different or same but it is string or binary we need to replace the storage */ - if((item->type != type) || - ((item->type == type) && - ((item->type == COL_TYPE_STRING) || (item->type == COL_TYPE_BINARY)))) { - TRACE_INFO_STRING("Replacing item data buffer",""); + /* If type is different or same but it is string or binary we need to + * replace the storage */ + if ((item->type != type) || + ((item->type == type) && + ((item->type == COL_TYPE_STRING) || (item->type == COL_TYPE_BINARY)))) { + TRACE_INFO_STRING("Replacing item data buffer", ""); free(item->data); item->data = malloc(length); - if(item->data == NULL) { - TRACE_ERROR_STRING("Failed to allocate memory",""); + if (item->data == NULL) { + TRACE_ERROR_STRING("Failed to allocate memory", ""); item->length = 0; return ENOMEM; } @@ -1910,13 +2055,14 @@ int modify_item(struct collection_item *item, } - TRACE_INFO_STRING("Overwriting item data",""); - memcpy(item->data,data,item->length); + TRACE_INFO_STRING("Overwriting item data", ""); + memcpy(item->data, data, item->length); item->type = type; - if(item->type == COL_TYPE_STRING) *(((char *)(item->data))+item->length-1) = '\0'; + if (item->type == COL_TYPE_STRING) + ((char *)(item->data))[item->length - 1] = '\0'; - TRACE_FLOW_STRING("modify_item","Exit"); + TRACE_FLOW_STRING("modify_item", "Exit"); return EOK; } @@ -1931,14 +2077,16 @@ inline int modify_str_item(struct collection_item *item, int len; int error; - TRACE_FLOW_STRING("modify_str_item","Entry"); + TRACE_FLOW_STRING("modify_str_item", "Entry"); - if(length != 0) len = length; - else len = strlen(string) + 1; + if (length != 0) + len = length; + else + len = strlen(string) + 1; - error = modify_item(item,property,COL_TYPE_STRING,(void *)string,len); + error = modify_item(item, property, COL_TYPE_STRING, (void *)string, len); - TRACE_FLOW_STRING("modify_str_item","Exit"); + TRACE_FLOW_STRING("modify_str_item", "Exit"); return error; } @@ -1950,11 +2098,11 @@ inline int modify_binary_item(struct collection_item *item, { int error; - TRACE_FLOW_STRING("modify_binary_item","Entry"); + TRACE_FLOW_STRING("modify_binary_item", "Entry"); - error = modify_item(item,property,COL_TYPE_BINARY,binary_data,length); + error = modify_item(item, property, COL_TYPE_BINARY, binary_data, length); - TRACE_FLOW_STRING("modify_binary_item","Exit"); + TRACE_FLOW_STRING("modify_binary_item", "Exit"); return error; } @@ -1965,11 +2113,11 @@ inline int modify_bool_item(struct collection_item *item, { int error; - TRACE_FLOW_STRING("modify_bool_item","Entry"); + TRACE_FLOW_STRING("modify_bool_item", "Entry"); - error = modify_item(item,property,COL_TYPE_BOOL,(void *)(&logical),1); + error = modify_item(item, property, COL_TYPE_BOOL, (void *)(&logical), 1); - TRACE_FLOW_STRING("modify_bool_item","Exit"); + TRACE_FLOW_STRING("modify_bool_item", "Exit"); return error; } @@ -1982,9 +2130,10 @@ inline int modify_int_item(struct collection_item *item, TRACE_FLOW_STRING("modify_int_item","Entry"); - error = modify_item(item,property,COL_TYPE_INTEGER,(void *)(&number),sizeof(int)); + error = modify_item(item, property, COL_TYPE_INTEGER, + (void *)(&number), sizeof(int)); - TRACE_FLOW_STRING("modify_int_item","Exit"); + TRACE_FLOW_STRING("modify_int_item", "Exit"); return error; } @@ -1995,11 +2144,12 @@ inline int modify_long_item(struct collection_item *item, { int error; - TRACE_FLOW_STRING("modify_long_item","Entry"); + TRACE_FLOW_STRING("modify_long_item", "Entry"); - error = modify_item(item,property,COL_TYPE_LONG,(void *)(&number),sizeof(long)); + error = modify_item(item, property, COL_TYPE_LONG, + (void *)(&number), sizeof(long)); - TRACE_FLOW_STRING("modify_long_item","Exit"); + TRACE_FLOW_STRING("modify_long_item", "Exit"); return error; } @@ -2010,11 +2160,12 @@ inline int modify_ulong_item(struct collection_item *item, { int error; - TRACE_FLOW_STRING("modify_ulong_item","Entry"); + TRACE_FLOW_STRING("modify_ulong_item", "Entry"); - error = modify_item(item,property,COL_TYPE_ULONG,(void *)(&number),sizeof(unsigned long)); + error = modify_item(item, property, COL_TYPE_ULONG, + (void *)(&number), sizeof(unsigned long)); - TRACE_FLOW_STRING("modify_ulong_item","Exit"); + TRACE_FLOW_STRING("modify_ulong_item", "Exit"); return error; } @@ -2024,11 +2175,12 @@ inline int modify_unsigned_item(struct collection_item *item, { int error; - TRACE_FLOW_STRING("modify_unsigned_item","Entry"); + TRACE_FLOW_STRING("modify_unsigned_item", "Entry"); - error = modify_item(item,property,COL_TYPE_UNSIGNED,(void *)(&number),sizeof(unsigned)); + error = modify_item(item, property, COL_TYPE_UNSIGNED, + (void *)(&number), sizeof(unsigned)); - TRACE_FLOW_STRING("modify_unsigned_item","Exit"); + TRACE_FLOW_STRING("modify_unsigned_item", "Exit"); return error; } @@ -2038,11 +2190,12 @@ inline int modify_double_item(struct collection_item *item, { int error; - TRACE_FLOW_STRING("modify_double_item","Entry"); + TRACE_FLOW_STRING("modify_double_item", "Entry"); - error = modify_item(item,property,COL_TYPE_DOUBLE,(void *)(&number),sizeof(double)); + error = modify_item(item, property, COL_TYPE_DOUBLE, + (void *)(&number), sizeof(double)); - TRACE_FLOW_STRING("modify_double_item","Exit"); + TRACE_FLOW_STRING("modify_double_item", "Exit"); return error; } @@ -2053,20 +2206,20 @@ static int grow_stack(struct collection_iterator *iterator, unsigned desired) int grow_by = 0; struct collection_item **temp; - TRACE_FLOW_STRING("grow_stack","Entry."); + TRACE_FLOW_STRING("grow_stack", "Entry."); - if(desired > iterator->stack_size) { + if (desired > iterator->stack_size) { grow_by = (((desired - iterator->stack_size) / STACK_DEPTH_BLOCK) + 1) * STACK_DEPTH_BLOCK; errno = 0; - temp = (struct collection_item **)(realloc(iterator->stack,grow_by * sizeof(struct collection_item *))); - if(temp == (struct collection_item **)(NULL)) { - TRACE_ERROR_NUMBER("Failed to allocate memory",ENOMEM); + temp = (struct collection_item **)realloc(iterator->stack, grow_by * sizeof(struct collection_item *)); + if (temp == NULL) { + TRACE_ERROR_NUMBER("Failed to allocate memory", ENOMEM); return ENOMEM; } iterator->stack = temp; iterator->stack_size += grow_by; } - TRACE_FLOW_STRING("grow_stack","Exit."); + TRACE_FLOW_STRING("grow_stack", "Exit."); return EOK; } @@ -2079,83 +2232,81 @@ int bind_iterator(struct collection_iterator **iterator, { int error; struct collection_header *header; - struct collection_iterator *iter = (struct collection_iterator *)(NULL); + struct collection_iterator *iter = NULL; - TRACE_FLOW_STRING("bind_iterator","Entry."); + TRACE_FLOW_STRING("bind_iterator", "Entry."); /* Do some argument checking first */ - if((iterator == (struct collection_iterator **)(NULL)) || - (ci == (struct collection_item *)(NULL))) { - TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL); + if ((iterator == NULL) || (ci == NULL)) { + TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL); return EINVAL; } iter = (struct collection_iterator *)malloc(sizeof(struct collection_iterator)); - if(iter == (struct collection_iterator *)(NULL)) { - TRACE_ERROR_NUMBER("Error allocating memory for the iterator.",ENOMEM); + if (iter == NULL) { + TRACE_ERROR_NUMBER("Error allocating memory for the iterator.", ENOMEM); return ENOMEM; } /* Allocate memory for the stack */ - iter->stack = (struct collection_item **)(NULL); + iter->stack = NULL; iter->stack_size = 0; iter->stack_depth = 0; iter->flags = mode_flags; /* Allocate memory for stack */ - error = grow_stack(iter,1); + error = grow_stack(iter, 1); if(error) { free(iter); - TRACE_ERROR_NUMBER("Error growing stack.",error); + TRACE_ERROR_NUMBER("Error growing stack.", error); return error; } /* Make sure that we tie iterator to the collection */ - header = (struct collection_header *)(ci->data); - (header->reference_count)++; + header = (struct collection_header *)ci->data; + header->reference_count++; iter->top = ci; *(iter->stack) = ci; iter->stack_depth++; *iterator = iter; - TRACE_FLOW_STRING("bind_iterator","Exit"); + TRACE_FLOW_STRING("bind_iterator", "Exit"); return EOK; } -/* Stop processing this subcollection and move to the next item in the collection 'level' levels up.*/ +/* Stop processing this subcollection and move to the next item in the + * collection 'level' levels up.*/ inline int iterate_up(struct collection_iterator *iterator, int level) { - TRACE_FLOW_STRING("iterate_up","Entry"); + TRACE_FLOW_STRING("iterate_up", "Entry"); - if((iterator == (struct collection_iterator *)(NULL)) || - (level >= iterator->stack_depth)) { - TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL); + if ((iterator == NULL) || (level >= iterator->stack_depth)) { + TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL); return EINVAL; } - TRACE_INFO_NUMBER("Going up:",level); + TRACE_INFO_NUMBER("Going up:", level); iterator->stack_depth--; - TRACE_INFO_NUMBER("Stack depth at the end:",iterator->stack_depth); - TRACE_FLOW_STRING("iterate_up","Exit"); + TRACE_INFO_NUMBER("Stack depth at the end:", iterator->stack_depth); + TRACE_FLOW_STRING("iterate_up", "Exit"); return EOK; } /* How deep are we relative to the top level.*/ inline int get_iterator_depth(struct collection_iterator *iterator, int *depth) { - TRACE_FLOW_STRING("iterate_up","Entry"); + TRACE_FLOW_STRING("iterate_up", "Entry"); - if((iterator == (struct collection_iterator *)(NULL)) || - (depth == (int *)(NULL))) { - TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL); + if ((iterator == NULL) || (depth == NULL)) { + TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL); return EINVAL; } *depth = iterator->stack_depth -1; - TRACE_INFO_NUMBER("Stack depth at the end:",iterator->stack_depth); + TRACE_INFO_NUMBER("Stack depth at the end:", iterator->stack_depth); TRACE_FLOW_STRING("iterate_up","Exit"); return EOK; } @@ -2164,177 +2315,181 @@ inline int get_iterator_depth(struct collection_iterator *iterator, int *depth) /* Unbind the iterator from the collection */ inline void unbind_iterator(struct collection_iterator *iterator) { - TRACE_FLOW_STRING("unbind_iterator","Entry."); - if(iterator != (struct collection_iterator *)(NULL)) { + TRACE_FLOW_STRING("unbind_iterator", "Entry."); + if (iterator != NULL) { destroy_collection(iterator->top); - if(iterator->stack != (struct collection_item **)(NULL)) free(iterator->stack); + if (iterator->stack != NULL) free(iterator->stack); free(iterator); } - TRACE_FLOW_STRING("unbind_iterator","Exit"); + TRACE_FLOW_STRING("unbind_iterator", "Exit"); } /* Get items from the collection one by one following the tree */ -int iterate_collection(struct collection_iterator *iterator, struct collection_item **item) +int iterate_collection(struct collection_iterator *iterator, + struct collection_item **item) { int error; struct collection_item *current; struct collection_item *other; - TRACE_FLOW_STRING("iterate_collection","Entry."); + TRACE_FLOW_STRING("iterate_collection", "Entry."); /* Check if we have storage for item */ - if(item == (struct collection_item **)(NULL)) { - TRACE_ERROR_NUMBER("Invalid parameter.",EINVAL); + if (item == NULL) { + TRACE_ERROR_NUMBER("Invalid parameter.", EINVAL); return EINVAL; } - while(1) { + while (1) { - TRACE_INFO_NUMBER("Stack depth:",iterator->stack_depth); + TRACE_INFO_NUMBER("Stack depth:", iterator->stack_depth); /* Are we done? */ - if(iterator->stack_depth == 0) { - TRACE_FLOW_STRING("We are done.",""); - *item = (struct collection_item *)(NULL); + if (iterator->stack_depth == 0) { + TRACE_FLOW_STRING("We are done.", ""); + *item = NULL; return EOK; } /* Is current item available */ - current = *(iterator->stack + iterator->stack_depth - 1); + current = iterator->stack[iterator->stack_depth - 1]; /* We are not done so check if we have an item */ - if(current != (struct collection_item *)(NULL)) { + if (current != NULL) { - TRACE_INFO_STRING("Current item:",current->property); - TRACE_INFO_NUMBER("Current item type:",current->type); + TRACE_INFO_STRING("Current item:", current->property); + TRACE_INFO_NUMBER("Current item type:", current->type); /* Is this a collection reference */ - if(current->type == COL_TYPE_COLLECTIONREF) { + if (current->type == COL_TYPE_COLLECTIONREF) { /* We do follow references? */ - TRACE_INFO_STRING("Current item:","collection reference"); - if((iterator->flags & COL_TRAVERSE_IGNORE) == 0) { + TRACE_INFO_STRING("Current item:", "collection reference"); + if ((iterator->flags & COL_TRAVERSE_IGNORE) == 0) { /* We should not ignore - then move on */ - TRACE_INFO_STRING("Collection references are not ignored",""); - error = grow_stack(iterator,iterator->stack_depth + 1); - if(error) { - TRACE_ERROR_NUMBER("Error growing stack.",error); + TRACE_INFO_STRING("Collection references are not ignored", ""); + error = grow_stack(iterator, iterator->stack_depth + 1); + if (error) { + TRACE_ERROR_NUMBER("Error growing stack.", error); return error; } /* Do we need to go deeper than one level ? */ - if((iterator->flags & COL_TRAVERSE_ONELEVEL) == 0) { - TRACE_INFO_STRING("Need to go deeper",""); + if ((iterator->flags & COL_TRAVERSE_ONELEVEL) == 0) { + TRACE_INFO_STRING("Need to go deeper", ""); /* We need to go deeper... */ /* Do we need to show headers but not reference? */ - if((iterator->flags & COL_TRAVERSE_ONLYSUB) != 0) { - TRACE_INFO_STRING("Instructed to show header not reference",""); - other = *((struct collection_item **)(current->data)); - *(iterator->stack + iterator->stack_depth) = other->next; + if ((iterator->flags & COL_TRAVERSE_ONLYSUB) != 0) { + TRACE_INFO_STRING("Instructed to show header not reference", ""); + other = *((struct collection_item **)current->data); + iterator->stack[iterator->stack_depth] = other->next; *item = other; } /* Do we need to show both? */ - else if((iterator->flags & COL_TRAVERSE_SHOWSUB) != 0) { + else if ((iterator->flags & COL_TRAVERSE_SHOWSUB) != 0) { TRACE_INFO_STRING("Instructed to show header and reference",""); - *(iterator->stack + iterator->stack_depth) = *((struct collection_item **)(current->data)); + iterator->stack[iterator->stack_depth] = *((struct collection_item **)(current->data)); *item = current; } /* We need to show reference only */ else { - TRACE_INFO_STRING("Instructed to show reference only",""); - other = *((struct collection_item **)(current->data)); - TRACE_INFO_STRING("Sub collection:",other->property); - TRACE_INFO_NUMBER("Sub collection type:",other->type); - *(iterator->stack + iterator->stack_depth) = other->next; - if(other->next != (struct collection_item *)(NULL)) { - TRACE_INFO_STRING("Will show this item next time:",(other->next)->property); - TRACE_INFO_NUMBER("Will show this item next time type:",(other->next)->type); + TRACE_INFO_STRING("Instructed to show reference only", ""); + other = *((struct collection_item **)current->data); + TRACE_INFO_STRING("Sub collection:", other->property); + TRACE_INFO_NUMBER("Sub collection type:", other->type); + iterator->stack[iterator->stack_depth] = other->next; + if (other->next != NULL) { + TRACE_INFO_STRING("Will show this item next time:", other->next->property); + TRACE_INFO_NUMBER("Will show this item next time type:", other->next->type); } *item = current; } - TRACE_INFO_STRING("We return item:",(*item)->property); - TRACE_INFO_NUMBER("We return item type:",(*item)->type); - TRACE_INFO_STRING("Moving to the next item on the previous item in stack",""); - *(iterator->stack + iterator->stack_depth - 1) = current->next; - (iterator->stack_depth)++; + TRACE_INFO_STRING("We return item:", (*item)->property); + TRACE_INFO_NUMBER("We return item type:", (*item)->type); + TRACE_INFO_STRING("Moving to the next item on the previous item in stack", ""); + iterator->stack[iterator->stack_depth - 1] = current->next; + iterator->stack_depth++; } else { - TRACE_INFO_STRING("Instructed to parse just one level",""); + TRACE_INFO_STRING("Instructed to parse just one level", ""); /* On one level - just return current */ *item = current; - TRACE_INFO_STRING("Moving to the next item on one level",""); - *(iterator->stack + iterator->stack_depth - 1) = current->next; + TRACE_INFO_STRING("Moving to the next item on one level", ""); + iterator->stack[iterator->stack_depth - 1] = current->next; } break; } else { /* We need to ignore references so move to the next item */ - TRACE_INFO_STRING("Stepping over the reference",""); - *(iterator->stack + iterator->stack_depth - 1) = current->next; + TRACE_INFO_STRING("Stepping over the reference", ""); + iterator->stack[iterator->stack_depth - 1] = current->next; continue; } } else { /* Got a normal item - return it and move to the next one */ - TRACE_INFO_STRING("Simple item",""); + TRACE_INFO_STRING("Simple item", ""); *item = current; - *(iterator->stack + iterator->stack_depth - 1) = current->next; + iterator->stack[iterator->stack_depth - 1] = current->next; break; } } else { /* Item is NULL */ - TRACE_INFO_STRING("Finished level","moving to upper level"); + TRACE_INFO_STRING("Finished level", "moving to upper level"); iterator->stack_depth--; - TRACE_INFO_NUMBER("Stack depth at the end:",iterator->stack_depth); - if((iterator->flags & COL_TRAVERSE_END) != 0) { + TRACE_INFO_NUMBER("Stack depth at the end:", iterator->stack_depth); + if ((iterator->flags & COL_TRAVERSE_END) != 0) { /* Return dummy entry to indicate the end of the collection */ - TRACE_INFO_STRING("Finished level","told to return END"); + TRACE_INFO_STRING("Finished level", "told to return END"); *item = &dummy; break; } - else continue; /* Move to next level */ + else { + /* Move to next level */ + continue; + } } } - TRACE_FLOW_STRING("iterate_collection","Exit"); + TRACE_FLOW_STRING("iterate_collection", "Exit"); return EOK; } /* Set collection class */ -inline int set_collection_class(struct collection_item *item, unsigned class) +inline int set_collection_class(struct collection_item *item, unsigned cclass) { struct collection_header *header; - TRACE_FLOW_STRING("set_collection_class","Entry"); + TRACE_FLOW_STRING("set_collection_class", "Entry"); - if(item->type != COL_TYPE_COLLECTION) { - TRACE_INFO_NUMBER("Not a collectin object. Type is",item->type); + if (item->type != COL_TYPE_COLLECTION) { + TRACE_INFO_NUMBER("Not a collectin object. Type is", item->type); return EINVAL; } - header = (struct collection_header *)(item->data); - header->class = class; - TRACE_FLOW_STRING("set_collection_class","Exit"); + header = (struct collection_header *)item->data; + header->cclass = cclass; + TRACE_FLOW_STRING("set_collection_class", "Exit"); return EOK; } /* Get collection class */ inline int get_collection_class(struct collection_item *item, - unsigned *class) + unsigned *cclass) { struct collection_header *header; - TRACE_FLOW_STRING("get_collection_class","Entry"); + TRACE_FLOW_STRING("get_collection_class", "Entry"); - if(item->type != COL_TYPE_COLLECTION) { - TRACE_ERROR_NUMBER("Not a collection object. Type is",item->type); + if (item->type != COL_TYPE_COLLECTION) { + TRACE_ERROR_NUMBER("Not a collection object. Type is", item->type); return EINVAL; } - header = (struct collection_header *)(item->data); - *class = header->class; - TRACE_FLOW_STRING("get_collection_class","Exit"); + header = (struct collection_header *)item->data; + *cclass = header->cclass; + TRACE_FLOW_STRING("get_collection_class", "Exit"); return EOK; } @@ -2344,38 +2499,40 @@ inline int get_collection_count(struct collection_item *item, { struct collection_header *header; - TRACE_FLOW_STRING("get_collection_count","Entry"); + TRACE_FLOW_STRING("get_collection_count", "Entry"); - if(item->type != COL_TYPE_COLLECTION) { - TRACE_ERROR_NUMBER("Not a collectin object. Type is",item->type); + if (item->type != COL_TYPE_COLLECTION) { + TRACE_ERROR_NUMBER("Not a collectin object. Type is", item->type); return EINVAL; } - header = (struct collection_header *)(item->data); + header = (struct collection_header *)item->data; *count = header->count; - TRACE_FLOW_STRING("get_collection_count","Exit"); + TRACE_FLOW_STRING("get_collection_count", "Exit"); return EOK; } /* Convinience function to check if the collection is of the specific class */ /* In case of internal error assumes that collection is not of the right class */ -inline int is_of_class(struct collection_item *item,unsigned class) +inline int is_of_class(struct collection_item *item, unsigned cclass) { int error = EOK; unsigned ret_class = 0; - TRACE_FLOW_STRING("is_of_class invoked",""); + TRACE_FLOW_STRING("is_of_class invoked", ""); - error = get_collection_class(item,&ret_class); - if((error) || (ret_class != class)) return 0; - else return 1; + error = get_collection_class(item, &ret_class); + if (error || (ret_class != cclass)) + return 0; + else + return 1; } /* Get propery */ inline char *get_item_property(struct collection_item *ci,int *property_len) { - if(property_len != NULL) *property_len = ci->property_len; + if (property_len != NULL) *property_len = ci->property_len; return ci->property; } @@ -2399,42 +2556,45 @@ void *get_item_data(struct collection_item *ci) /* Set time stamp in the collection - FIXME move to another level */ -int set_timestamp(struct collection_item *ci,struct collection_item **timestr_ref,struct collection_item **timeint_ref) +int set_timestamp(struct collection_item *ci, + struct collection_item **timestr_ref, + struct collection_item **timeint_ref) { time_t utctime; struct tm time_struct; char time_array[TIME_ARRAY_SIZE+1]; int len; - struct collection_item *timestr = (struct collection_item *)(NULL); - struct collection_item *timeint = (struct collection_item *)(NULL); + struct collection_item *timestr = NULL; + struct collection_item *timeint = NULL; int error = EOK; - TRACE_FLOW_STRING("set_timestamp","Entry point"); + TRACE_FLOW_STRING("set_timestamp", "Entry point"); utctime = time(NULL); - localtime_r(&utctime,&time_struct); + localtime_r(&utctime, &time_struct); len = strftime(time_array, TIME_ARRAY_SIZE, DATE_FORMAT, &time_struct); - if(len == 0) { - TRACE_ERROR_STRING("add_time","CODING ERROR - INCREASE THE BUFFER"); + if (len == 0) { + TRACE_ERROR_STRING("add_time", "CODING ERROR - INCREASE THE BUFFER"); return EMSGSIZE; } - TRACE_INFO_STRING("Timestamp:",time_array); + TRACE_INFO_STRING("Timestamp:", time_array); /* Check if we have the timestamp item already */ - error = get_item(ci, TS_NAME, COL_TYPE_STRING,COL_TRAVERSE_IGNORE,×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; } |