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