summaryrefslogtreecommitdiff
path: root/common/collection/collection.c
diff options
context:
space:
mode:
Diffstat (limited to 'common/collection/collection.c')
-rw-r--r--common/collection/collection.c1743
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,&timestr);
- if(error) {
- TRACE_ERROR_NUMBER("search failed with error:",error);
+ error = get_item(ci, TS_NAME, COL_TYPE_STRING,
+ COL_TRAVERSE_IGNORE, &timestr);
+ if (error) {
+ TRACE_ERROR_NUMBER("search failed with error:", error);
return error;
}
- if(timestr != (struct collection_item *)(NULL)) {
+ if (timestr != NULL) {
/* There is a timestamp */
free(timestr->data);
timestr->data = strdup(time_array);
- if(timestr->data == NULL) {
- TRACE_ERROR_NUMBER("failed to add timestamp property:",error);
+ if (timestr->data == NULL) {
+ TRACE_ERROR_NUMBER("failed to add timestamp property:", error);
return ENOMEM;
}
timestr->length = len+1;
@@ -2442,35 +2602,38 @@ int set_timestamp(struct collection_item *ci,struct collection_item **timestr_re
}
else {
/* Add timestamp to the collection */
- error = add_str_property_with_ref(ci,NULL, TS_NAME,time_array,len+1,timestr_ref);
- if(error) {
- TRACE_ERROR_NUMBER("failed to add timestamp property:",error);
+ error = add_str_property_with_ref(ci, NULL, TS_NAME,
+ time_array, len+1, timestr_ref);
+ if (error) {
+ TRACE_ERROR_NUMBER("failed to add timestamp property:", error);
return error;
}
}
/* Check if we have the time item already */
- error = get_item(ci, T_NAME, COL_TYPE_INTEGER,COL_TRAVERSE_IGNORE,&timeint);
- if(error) {
- TRACE_ERROR_NUMBER("search failed with error:",error);
+ error = get_item(ci, T_NAME, COL_TYPE_INTEGER,
+ COL_TRAVERSE_IGNORE, &timeint);
+ if (error) {
+ TRACE_ERROR_NUMBER("search failed with error:", error);
return error;
}
- if(timeint != (struct collection_item *)(NULL)) {
+ if (timeint != NULL) {
/* There is a time property */
*((int *)(timeint->data)) = utctime;
*timeint_ref = timeint;
}
else {
/* Add time to the collection */
- error = add_int_property_with_ref(ci,NULL, T_NAME,utctime,timeint_ref);
- if(error) {
- TRACE_ERROR_NUMBER("failed to add time property:",error);
+ error = add_int_property_with_ref(ci, NULL, T_NAME,
+ utctime, timeint_ref);
+ if (error) {
+ TRACE_ERROR_NUMBER("failed to add time property:", error);
return error;
}
}
- TRACE_FLOW_STRING("set_timestamp","Exit point");
+ TRACE_FLOW_STRING("set_timestamp", "Exit point");
return EOK;
}