patch-2.2.15 linux/net/irda/irias_object.c

• Lines: 601
• Date: Fri Apr 21 12:47:16 2000
• Orig file: v2.2.14/net/irda/irias_object.c
• Orig date: Sat Aug 14 02:25:47 1999

diff -u --new-file --recursive --exclude-from ../../exclude v2.2.14/net/irda/irias_object.c linux/net/irda/irias_object.c
@@ -6,10 +6,10 @@
  * Status:        Experimental.
  * Author:        Dag Brattli <dagb@cs.uit.no>
  * Created at:    Thu Oct  1 22:50:04 1998
- * Modified at:   Mon Mar 22 13:22:35 1999
+ * Modified at:   Wed Dec 15 11:23:16 1999
  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  * 
- *     Copyright (c) 1998 Dag Brattli, All Rights Reserved.
+ *     Copyright (c) 1998-1999 Dag Brattli, All Rights Reserved.
  *      
  *     This program is free software; you can redistribute it and/or 
  *     modify it under the terms of the GNU General Public License as 
@@ -24,7 +24,6 @@
 
 #include <linux/string.h>
 #include <linux/socket.h>
-#include <linux/irda.h>
 
 #include <net/irda/irda.h>
 #include <net/irda/irmod.h>
@@ -35,9 +34,7 @@
 /*
  *  Used when a missing value needs to be returned
  */
-struct ias_value missing = {
-        IAS_MISSING,	0,	0,	{ 0 }
-};
+struct ias_value missing = { IAS_MISSING, 0, 0, {0}};
 
 /*
  * Function strdup (str)
@@ -45,20 +42,20 @@
  *    My own kernel version of strdup!
  *
  */
-char *strdup( char *str)
+char *strdup(char *str)
 {
 	char *new_str;
 	
-	if ( str == NULL)
+	if (str == NULL)
 		return NULL;
 
-	ASSERT( strlen( str) < 64, return NULL;);
+	ASSERT(strlen( str) < 64, return NULL;);
 	
-        new_str = kmalloc( strlen( str)+1, GFP_ATOMIC);
-        if ( new_str == NULL)
+        new_str = kmalloc(strlen(str)+1, GFP_ATOMIC);
+        if (new_str == NULL)
 		return NULL;
 	
-	strcpy( new_str, str);
+	strcpy(new_str, str);
 	
 	return new_str;
 }
@@ -73,21 +70,21 @@
 {
         struct ias_object *obj;
 	
-	DEBUG( 4, __FUNCTION__ "()\n");
+	IRDA_DEBUG( 4, __FUNCTION__ "()\n");
 
-	obj = (struct ias_object *) kmalloc( sizeof( struct ias_object), 
-					     GFP_ATOMIC);
-	if ( obj == NULL) {
-		DEBUG( 0, __FUNCTION__ "(), Unable to allocate object!\n");
+	obj = (struct ias_object *) kmalloc(sizeof(struct ias_object), 
+					    GFP_ATOMIC);
+	if (obj == NULL) {
+		IRDA_DEBUG(0, __FUNCTION__ "(), Unable to allocate object!\n");
 		return NULL;
 	}
-	memset( obj, 0, sizeof( struct ias_object));
+	memset(obj, 0, sizeof( struct ias_object));
 
 	obj->magic = IAS_OBJECT_MAGIC;
 	obj->name = strdup( name);
 	obj->id = id;
 
-	obj->attribs = hashbin_new( HB_LOCAL);
+	obj->attribs = hashbin_new(HB_LOCAL);
 	
 	return obj;
 }
@@ -98,59 +95,56 @@
  *    Delete given attribute and deallocate all its memory
  *
  */
-void __irias_delete_attrib( struct ias_attrib *attrib)
+void __irias_delete_attrib(struct ias_attrib *attrib)
 {
-	ASSERT( attrib != NULL, return;);
-	ASSERT( attrib->magic == IAS_ATTRIB_MAGIC, return;);
+	ASSERT(attrib != NULL, return;);
+	ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
 
-	if ( attrib->name)
-		kfree( attrib->name);
+	if (attrib->name)
+		kfree(attrib->name);
 
-	irias_delete_value( attrib->value);
+	irias_delete_value(attrib->value);
 	attrib->magic = ~IAS_ATTRIB_MAGIC;
 	
-	kfree( attrib);
+	kfree(attrib);
 }
 
-/*
- * Function irias_delete_object (obj)
- *
- *    Remove object from hashbin and deallocate all attributes assosiated with
- *    with this object and the object itself
- *
- */
-void __irias_delete_object( struct ias_object *obj) 
+void __irias_delete_object(struct ias_object *obj)
 {
-	ASSERT( obj != NULL, return;);
-	ASSERT( obj->magic == IAS_OBJECT_MAGIC, return;);
-	
-	if ( obj->name)
-		kfree( obj->name);
+	ASSERT(obj != NULL, return;);
+	ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+
+	if (obj->name)
+		kfree(obj->name);
 	
-	hashbin_delete( obj->attribs, (FREE_FUNC) __irias_delete_attrib);
+	hashbin_delete(obj->attribs, (FREE_FUNC) __irias_delete_attrib);
 	
 	obj->magic = ~IAS_OBJECT_MAGIC;
 	
-	kfree( obj);
+	kfree(obj);
 }
 
 /*
- * Function irias_remove_object (obj)
+ * Function irias_delete_object (obj)
  *
- *    Remove object with give name from the LM-IAS object database
+ *    Remove object from hashbin and deallocate all attributes assosiated with
+ *    with this object and the object itself
  *
  */
-void irias_delete_object( char *obj_name)
+int irias_delete_object(struct ias_object *obj) 
 {
-	struct ias_object *obj;
+	struct ias_object *node;
 
-	DEBUG( 4, __FUNCTION__ "()\n");
+	ASSERT(obj != NULL, return -1;);
+	ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
 
-	ASSERT( obj_name != NULL, return;);
+	node = hashbin_remove(objects, 0, obj->name);
+	if (!node)
+		return 0; /* Already removed */
 
-	obj = hashbin_remove( objects, 0, obj_name);
+	__irias_delete_object(node);
 
-	__irias_delete_object( obj);
+	return 0;
 }
 
 /*
@@ -159,14 +153,12 @@
  *    Insert an object into the LM-IAS database
  *
  */
-void irias_insert_object( struct ias_object *obj)
+void irias_insert_object(struct ias_object *obj)
 {
-	DEBUG( 4, __FUNCTION__ "()\n");
-	
-	ASSERT( obj != NULL, return;);
-	ASSERT( obj->magic == IAS_OBJECT_MAGIC, return;);
+	ASSERT(obj != NULL, return;);
+	ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 	
-	hashbin_insert( objects, (QUEUE *) obj, 0, obj->name);
+	hashbin_insert(objects, (queue_t *) obj, 0, obj->name);
 }
 
 /*
@@ -175,11 +167,11 @@
  *    Find object with given name
  *
  */
-struct ias_object *irias_find_object( char *name)
+struct ias_object *irias_find_object(char *name)
 {
-	ASSERT( name != NULL, return NULL;);
+	ASSERT(name != NULL, return NULL;);
 
-	return hashbin_find( objects, 0, name);
+	return hashbin_find(objects, 0, name);
 }
 
 /*
@@ -188,18 +180,16 @@
  *    Find named attribute in object
  *
  */
-struct ias_attrib *irias_find_attrib( struct ias_object *obj, char *name)
+struct ias_attrib *irias_find_attrib(struct ias_object *obj, char *name)
 {
 	struct ias_attrib *attrib;
 
-	DEBUG( 4, __FUNCTION__ "()\n");
+	ASSERT(obj != NULL, return NULL;);
+	ASSERT(obj->magic == IAS_OBJECT_MAGIC, return NULL;);
+	ASSERT(name != NULL, return NULL;);
 
-	ASSERT( obj != NULL, return NULL;);
-	ASSERT( obj->magic == IAS_OBJECT_MAGIC, return NULL;);
-	ASSERT( name != NULL, return NULL;);
-
-	attrib = hashbin_find( obj->attribs, 0, name);
-	if ( attrib == NULL)
+	attrib = hashbin_find(obj->attribs, 0, name);
+	if (attrib == NULL)
 		return NULL;
 
 	return attrib;
@@ -213,15 +203,13 @@
  */
 void irias_add_attrib( struct ias_object *obj, struct ias_attrib *attrib)
 {
-	DEBUG( 4, __FUNCTION__ "()\n");
-	
-	ASSERT( obj != NULL, return;);
-	ASSERT( obj->magic == IAS_OBJECT_MAGIC, return;);
+	ASSERT(obj != NULL, return;);
+	ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 	
-	ASSERT( attrib != NULL, return;);
-	ASSERT( attrib->magic == IAS_ATTRIB_MAGIC, return;);
+	ASSERT(attrib != NULL, return;);
+	ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
 
-	hashbin_insert( obj->attribs, (QUEUE *) attrib, 0, attrib->name);
+	hashbin_insert(obj->attribs, (queue_t *) attrib, 0, attrib->name);
 }
 
 /*
@@ -230,36 +218,36 @@
  *    Change the value of an objects attribute.
  *
  */
-int irias_object_change_attribute( char *obj_name, char *attrib_name, 
-				   struct ias_value *new_value) 
+int irias_object_change_attribute(char *obj_name, char *attrib_name, 
+				  struct ias_value *new_value) 
 {
 	struct ias_object *obj;
 	struct ias_attrib *attrib;
 
 	/* Find object */
-	obj = hashbin_find( objects, 0, obj_name);
-	if ( obj == NULL) {
-		DEBUG( 0, __FUNCTION__ "(), Unable to find object: %s\n",
-		       obj_name);
+	obj = hashbin_find(objects, 0, obj_name);
+	if (obj == NULL) {
+		WARNING(__FUNCTION__ "(), Unable to find object: %s\n",
+			obj_name);
 		return -1;
 	}
 
 	/* Find attribute */
-	attrib = hashbin_find( obj->attribs, 0, attrib_name);
-	if ( attrib == NULL) {
-		DEBUG( 0, __FUNCTION__ "(), Unable to find attribute: %s\n",
-		       attrib_name);
+	attrib = hashbin_find(obj->attribs, 0, attrib_name);
+	if (attrib == NULL) {
+		WARNING(__FUNCTION__ "(), Unable to find attribute: %s\n",
+			attrib_name);
 		return -1;
 	}
-
+	
 	if ( attrib->value->type != new_value->type) {
-		DEBUG( 0, __FUNCTION__ 
+		IRDA_DEBUG( 0, __FUNCTION__ 
 		       "(), changing value type not allowed!\n");
 		return -1;
 	}
 
 	/* Delete old value */
-	irias_delete_value( attrib->value);
+	irias_delete_value(attrib->value);
 	
 	/* Insert new value */
 	attrib->value = new_value;
@@ -274,33 +262,29 @@
  *    Add an integer attribute to an LM-IAS object
  *
  */
-void irias_add_integer_attrib( struct ias_object *obj, char *name, int value)
+void irias_add_integer_attrib(struct ias_object *obj, char *name, int value)
 {
 	struct ias_attrib *attrib;
 
-	DEBUG( 4, __FUNCTION__ "()\n");
-
-	ASSERT( obj != NULL, return;);
-	ASSERT( obj->magic == IAS_OBJECT_MAGIC, return;);
-	ASSERT( name != NULL, return;);
-	
-	attrib = (struct ias_attrib *) kmalloc( sizeof( struct ias_attrib), 
-						GFP_ATOMIC);
-	if ( attrib == NULL) {
-		DEBUG( 0, __FUNCTION__ 
-		       "(), Unable to allocate attribute!\n");
+	ASSERT(obj != NULL, return;);
+	ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+	ASSERT(name != NULL, return;);
+	
+	attrib = (struct ias_attrib *) kmalloc(sizeof(struct ias_attrib), 
+					       GFP_ATOMIC);
+	if (attrib == NULL) {
+		WARNING(__FUNCTION__ "(), Unable to allocate attribute!\n");
 		return;
 	}
-	memset( attrib, 0, sizeof( struct ias_attrib));
+	memset(attrib, 0, sizeof( struct ias_attrib));
 
 	attrib->magic = IAS_ATTRIB_MAGIC;
-	attrib->name = strdup( name);
-/* 	attrib->attr = NULL; */
+	attrib->name = strdup(name);
 
 	/* Insert value */
-	attrib->value = irias_new_integer_value( value);
+	attrib->value = irias_new_integer_value(value);
 	
-	irias_add_attrib( obj, attrib);
+	irias_add_attrib(obj, attrib);
 }
 
  /*
@@ -310,38 +294,32 @@
  *
  */
 
-void irias_add_octseq_attrib( struct ias_object *obj, char *name, 
-			      __u8 *octets, int len)
+void irias_add_octseq_attrib(struct ias_object *obj, char *name, __u8 *octets,
+			     int len)
 {
 	struct ias_attrib *attrib;
 	
-	DEBUG( 0, __FUNCTION__ "()\n");
-	
-	DEBUG( 0, __FUNCTION__ ": name=%s\n", name);
-	DEBUG( 0, __FUNCTION__ ": len=%d\n", len);
+	ASSERT(obj != NULL, return;);
+	ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 	
-	ASSERT( obj != NULL, return;);
-	ASSERT( obj->magic == IAS_OBJECT_MAGIC, return;);
+	ASSERT(name != NULL, return;);
+	ASSERT(octets != NULL, return;);
 	
-	ASSERT( name != NULL, return;);
-	ASSERT( octets != NULL, return;);
-	ASSERT( len < 55, return;);          /* FIXME: must be 1024, but... */
-	
-	attrib = (struct ias_attrib *) kmalloc( sizeof( struct ias_attrib), 
-						GFP_ATOMIC);
-	if ( attrib == NULL) {
-		DEBUG( 0, __FUNCTION__ 
-		       "(), Unable to allocate attribute!\n");
+	attrib = (struct ias_attrib *) kmalloc(sizeof(struct ias_attrib), 
+					       GFP_ATOMIC);
+	if (attrib == NULL) {
+		WARNING(__FUNCTION__ 
+			"(), Unable to allocate attribute!\n");
 		return;
 	}
-	memset( attrib, 0, sizeof( struct ias_attrib));
+	memset(attrib, 0, sizeof( struct ias_attrib));
 	
 	attrib->magic = IAS_ATTRIB_MAGIC;
 	attrib->name = strdup( name);
 	
 	attrib->value = irias_new_octseq_value( octets, len);
 	
-	irias_add_attrib( obj, attrib);
+	irias_add_attrib(obj, attrib);
 }
 
 /*
@@ -350,36 +328,30 @@
  *    Add a string attribute to an LM-IAS object
  *
  */
-void irias_add_string_attrib( struct ias_object *obj, char *name, char *value)
+void irias_add_string_attrib(struct ias_object *obj, char *name, char *value)
 {
 	struct ias_attrib *attrib;
 
-	DEBUG( 4, __FUNCTION__ "()\n");
+	ASSERT(obj != NULL, return;);
+	ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
-	DEBUG( 4, __FUNCTION__ ": name=%s\n", name);
-	DEBUG( 4, __FUNCTION__ ": name=%s\n", value);
+	ASSERT(name != NULL, return;);
+	ASSERT(value != NULL, return;);
 	
-	ASSERT( obj != NULL, return;);
-	ASSERT( obj->magic == IAS_OBJECT_MAGIC, return;);
-
-	ASSERT( name != NULL, return;);
-	ASSERT( value != NULL, return;);
-	
-	attrib = (struct ias_attrib *) kmalloc( sizeof( struct ias_attrib), 
-						GFP_ATOMIC);
-	if ( attrib == NULL) {
-		DEBUG( 0, __FUNCTION__ 
-		       "(), Unable to allocate attribute!\n");
+	attrib = (struct ias_attrib *) kmalloc(sizeof( struct ias_attrib), 
+					       GFP_ATOMIC);
+	if (attrib == NULL) {
+		WARNING(__FUNCTION__ "(), Unable to allocate attribute!\n");
 		return;
 	}
-	memset( attrib, 0, sizeof( struct ias_attrib));
+	memset(attrib, 0, sizeof( struct ias_attrib));
 
 	attrib->magic = IAS_ATTRIB_MAGIC;
-	attrib->name = strdup( name);
+	attrib->name = strdup(name);
 
-	attrib->value = irias_new_string_value( value);
+	attrib->value = irias_new_string_value(value);
 
-	irias_add_attrib( obj, attrib);
+	irias_add_attrib(obj, attrib);
 }
 
 /*
@@ -388,16 +360,16 @@
  *    Create new IAS integer value
  *
  */
-struct ias_value *irias_new_integer_value( int integer)
+struct ias_value *irias_new_integer_value(int integer)
 {
 	struct ias_value *value;
 
-	value = kmalloc( sizeof( struct ias_value), GFP_ATOMIC);
-	if ( value == NULL) {
-		DEBUG( 0, __FUNCTION__ "(), Unable to kmalloc!\n");
+	value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+	if (value == NULL) {
+		WARNING(__FUNCTION__ "(), Unable to kmalloc!\n");
 		return NULL;
 	}
-	memset( value, 0, sizeof( struct ias_value));
+	memset(value, 0, sizeof(struct ias_value));
 
 	value->type = IAS_INTEGER;
 	value->len = 4;
@@ -412,21 +384,21 @@
  *    Create new IAS string value
  *
  */
-struct ias_value *irias_new_string_value( char *string)
+struct ias_value *irias_new_string_value(char *string)
 {
 	struct ias_value *value;
 
-	value = kmalloc( sizeof( struct ias_value), GFP_ATOMIC);
-	if ( value == NULL) {
-		DEBUG( 0, __FUNCTION__ "(), Unable to kmalloc!\n");
+	value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+	if (value == NULL) {
+		WARNING(__FUNCTION__ "(), Unable to kmalloc!\n");
 		return NULL;
 	}
 	memset( value, 0, sizeof( struct ias_value));
 
 	value->type = IAS_STRING;
 	value->charset = CS_ASCII;
-	value->len = strlen( string);
-	value->t.string = strdup( string);
+	value->len = strlen(string);
+	value->t.string = strdup(string);
 
 	return value;
 }
@@ -438,63 +410,78 @@
  *    Create new IAS octet-sequence value
  *
  */
-struct ias_value *irias_new_octseq_value( __u8 *octseq , int len)
+struct ias_value *irias_new_octseq_value(__u8 *octseq , int len)
 {
 	struct ias_value *value;
 
-	ASSERT(len <= 55, return NULL;); /*FIXME: must be 1024, but.....*/
-
-	value = kmalloc( sizeof( struct ias_value), GFP_ATOMIC);
-	if ( value == NULL) {
-		DEBUG( 0, __FUNCTION__ "(), Unable to kmalloc!\n");
+	value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+	if (value == NULL) {
+		WARNING(__FUNCTION__ "(), Unable to kmalloc!\n");
 		return NULL;
 	}
-	memset( value, 0, sizeof( struct ias_value));
+	memset(value, 0, sizeof(struct ias_value));
 
 	value->type = IAS_OCT_SEQ;
 	value->len = len;
 
 	value->t.oct_seq = kmalloc(len, GFP_ATOMIC);
-	if( value->t.oct_seq == NULL){
-		DEBUG(0, __FUNCTION__"(), Unable to kmalloc!\n");
+	if (value->t.oct_seq == NULL){
+		WARNING(__FUNCTION__"(), Unable to kmalloc!\n");
 		return NULL;
 	}
 	memcpy(value->t.oct_seq, octseq , len);
 	return value;
 }
 
+struct ias_value *irias_new_missing_value(void)
+{
+	struct ias_value *value;
+
+	value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+	if (value == NULL) {
+		WARNING(__FUNCTION__ "(), Unable to kmalloc!\n");
+		return NULL;
+	}
+	memset(value, 0, sizeof(struct ias_value));
+
+	value->type = IAS_MISSING;
+	value->len = 0;
+
+	return value;
+}
+
 /*
  * Function irias_delete_value (value)
  *
  *    Delete IAS value
  *
  */
-void irias_delete_value( struct ias_value *value)
+void irias_delete_value(struct ias_value *value)
 {
-	DEBUG( 4, __FUNCTION__ "()\n");
+	IRDA_DEBUG(4, __FUNCTION__ "()\n");
 
-	ASSERT( value != NULL, return;);
+	ASSERT(value != NULL, return;);
 
-	switch( value->type) {
+	switch (value->type) {
 	case IAS_INTEGER: /* Fallthrough */
 	case IAS_MISSING:
 		/* No need to deallocate */
 		break;
 	case IAS_STRING:
 		/* If string, deallocate string */
-		if ( value->t.string != NULL)
-			kfree( value->t.string);
+		if (value->t.string != NULL)
+			kfree(value->t.string);
 		break;
 	case IAS_OCT_SEQ:
 		/* If byte stream, deallocate byte stream */
-		 if ( value->t.oct_seq != NULL)
+		 if (value->t.oct_seq != NULL)
 			 kfree(value->t.oct_seq);
 		 break;
 	default:
-		DEBUG( 0, __FUNCTION__ "(), Unknown value type!\n");
+		IRDA_DEBUG(0, __FUNCTION__ "(), Unknown value type!\n");
 		break;
 	}
-	kfree( value);
+	kfree(value);
 }