[linux.git] / net / irda / irias_object.c

/*********************************************************************
 *
 * Filename:      irias_object.c
 * Version:       0.3
 * Description:   IAS object database and functions
 * Status:        Experimental.
 * Author:        Dag Brattli <[email protected]>
 * Created at:    Thu Oct  1 22:50:04 1998
 * Modified at:   Wed Dec 15 11:23:16 1999
 * Modified by:   Dag Brattli <[email protected]>
 *
 *     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
 *     published by the Free Software Foundation; either version 2 of
 *     the License, or (at your option) any later version.
 *
 *     Neither Dag Brattli nor University of Tromsø admit liability nor
 *     provide warranty for any of this software. This material is
 *     provided "AS-IS" and at no charge.
 *
 ********************************************************************/

#include <linux/slab.h>
#include <linux/string.h>
#include <linux/socket.h>
#include <linux/module.h>

#include <net/irda/irda.h>
#include <net/irda/irias_object.h>

hashbin_t *irias_objects;

/*
 *  Used when a missing value needs to be returned
 */
struct ias_value irias_missing = { IAS_MISSING, 0, 0, 0, {0}};


/*
 * Function ias_new_object (name, id)
 *
 *    Create a new IAS object
 *
 */
struct ias_object *irias_new_object( char *name, int id)
{
	struct ias_object *obj;

	IRDA_DEBUG( 4, "%s()\n", __func__);

	obj = kzalloc(sizeof(struct ias_object), GFP_ATOMIC);
	if (obj == NULL) {
		IRDA_WARNING("%s(), Unable to allocate object!\n",
			     __func__);
		return NULL;
	}

	obj->magic = IAS_OBJECT_MAGIC;
	obj->name = kstrndup(name, IAS_MAX_CLASSNAME, GFP_ATOMIC);
	if (!obj->name) {
		IRDA_WARNING("%s(), Unable to allocate name!\n",
			     __func__);
		kfree(obj);
		return NULL;
	}
	obj->id = id;

	/* Locking notes : the attrib spinlock has lower precendence
	 * than the objects spinlock. Never grap the objects spinlock
	 * while holding any attrib spinlock (risk of deadlock). Jean II */
	obj->attribs = hashbin_new(HB_LOCK);

	if (obj->attribs == NULL) {
		IRDA_WARNING("%s(), Unable to allocate attribs!\n",
			     __func__);
		kfree(obj->name);
		kfree(obj);
		return NULL;
	}

	return obj;
}
EXPORT_SYMBOL(irias_new_object);

/*
 * Function irias_delete_attrib (attrib)
 *
 *    Delete given attribute and deallocate all its memory
 *
 */
static void __irias_delete_attrib(struct ias_attrib *attrib)
{
	IRDA_ASSERT(attrib != NULL, return;);
	IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);

	kfree(attrib->name);

	irias_delete_value(attrib->value);
	attrib->magic = ~IAS_ATTRIB_MAGIC;

	kfree(attrib);
}

void __irias_delete_object(struct ias_object *obj)
{
	IRDA_ASSERT(obj != NULL, return;);
	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);

	kfree(obj->name);

	hashbin_delete(obj->attribs, (FREE_FUNC) __irias_delete_attrib);

	obj->magic = ~IAS_OBJECT_MAGIC;

	kfree(obj);
}

/*
 * Function irias_delete_object (obj)
 *
 *    Remove object from hashbin and deallocate all attributes associated with
 *    with this object and the object itself
 *
 */
int irias_delete_object(struct ias_object *obj)
{
	struct ias_object *node;

	IRDA_ASSERT(obj != NULL, return -1;);
	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);

	/* Remove from list */
	node = hashbin_remove_this(irias_objects, (irda_queue_t *) obj);
	if (!node)
		IRDA_DEBUG( 0, "%s(), object already removed!\n",
			    __func__);

	/* Destroy */
	__irias_delete_object(obj);

	return 0;
}
EXPORT_SYMBOL(irias_delete_object);

/*
 * Function irias_delete_attrib (obj)
 *
 *    Remove attribute from hashbin and, if it was the last attribute of
 *    the object, remove the object as well.
 *
 */
int irias_delete_attrib(struct ias_object *obj, struct ias_attrib *attrib,
			int cleanobject)
{
	struct ias_attrib *node;

	IRDA_ASSERT(obj != NULL, return -1;);
	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
	IRDA_ASSERT(attrib != NULL, return -1;);

	/* Remove attribute from object */
	node = hashbin_remove_this(obj->attribs, (irda_queue_t *) attrib);
	if (!node)
		return 0; /* Already removed or non-existent */

	/* Deallocate attribute */
	__irias_delete_attrib(node);

	/* Check if object has still some attributes, destroy it if none.
	 * At first glance, this look dangerous, as the kernel reference
	 * various IAS objects. However, we only use this function on
	 * user attributes, not kernel attributes, so there is no risk
	 * of deleting a kernel object this way. Jean II */
	node = (struct ias_attrib *) hashbin_get_first(obj->attribs);
	if (cleanobject && !node)
		irias_delete_object(obj);

	return 0;
}

/*
 * Function irias_insert_object (obj)
 *
 *    Insert an object into the LM-IAS database
 *
 */
void irias_insert_object(struct ias_object *obj)
{
	IRDA_ASSERT(obj != NULL, return;);
	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);

	hashbin_insert(irias_objects, (irda_queue_t *) obj, 0, obj->name);
}
EXPORT_SYMBOL(irias_insert_object);

/*
 * Function irias_find_object (name)
 *
 *    Find object with given name
 *
 */
struct ias_object *irias_find_object(char *name)
{
	IRDA_ASSERT(name != NULL, return NULL;);

	/* Unsafe (locking), object might change */
	return hashbin_lock_find(irias_objects, 0, name);
}
EXPORT_SYMBOL(irias_find_object);

/*
 * Function irias_find_attrib (obj, name)
 *
 *    Find named attribute in object
 *
 */
struct ias_attrib *irias_find_attrib(struct ias_object *obj, char *name)
{
	struct ias_attrib *attrib;

	IRDA_ASSERT(obj != NULL, return NULL;);
	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return NULL;);
	IRDA_ASSERT(name != NULL, return NULL;);

	attrib = hashbin_lock_find(obj->attribs, 0, name);
	if (attrib == NULL)
		return NULL;

	/* Unsafe (locking), attrib might change */
	return attrib;
}

/*
 * Function irias_add_attribute (obj, attrib)
 *
 *    Add attribute to object
 *
 */
static void irias_add_attrib(struct ias_object *obj, struct ias_attrib *attrib,
			     int owner)
{
	IRDA_ASSERT(obj != NULL, return;);
	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);

	IRDA_ASSERT(attrib != NULL, return;);
	IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);

	/* Set if attrib is owned by kernel or user space */
	attrib->value->owner = owner;

	hashbin_insert(obj->attribs, (irda_queue_t *) attrib, 0, attrib->name);
}

/*
 * Function irias_object_change_attribute (obj_name, attrib_name, new_value)
 *
 *    Change the value of an objects attribute.
 *
 */
int irias_object_change_attribute(char *obj_name, char *attrib_name,
				  struct ias_value *new_value)
{
	struct ias_object *obj;
	struct ias_attrib *attrib;
	unsigned long flags;

	/* Find object */
	obj = hashbin_lock_find(irias_objects, 0, obj_name);
	if (obj == NULL) {
		IRDA_WARNING("%s: Unable to find object: %s\n", __func__,
			     obj_name);
		return -1;
	}

	/* Slightly unsafe (obj might get removed under us) */
	spin_lock_irqsave(&obj->attribs->hb_spinlock, flags);

	/* Find attribute */
	attrib = hashbin_find(obj->attribs, 0, attrib_name);
	if (attrib == NULL) {
		IRDA_WARNING("%s: Unable to find attribute: %s\n",
			     __func__, attrib_name);
		spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
		return -1;
	}

	if ( attrib->value->type != new_value->type) {
		IRDA_DEBUG( 0, "%s(), changing value type not allowed!\n",
			    __func__);
		spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
		return -1;
	}

	/* Delete old value */
	irias_delete_value(attrib->value);

	/* Insert new value */
	attrib->value = new_value;

	/* Success */
	spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
	return 0;
}
EXPORT_SYMBOL(irias_object_change_attribute);

/*
 * Function irias_object_add_integer_attrib (obj, name, value)
 *
 *    Add an integer attribute to an LM-IAS object
 *
 */
void irias_add_integer_attrib(struct ias_object *obj, char *name, int value,
			      int owner)
{
	struct ias_attrib *attrib;

	IRDA_ASSERT(obj != NULL, return;);
	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
	IRDA_ASSERT(name != NULL, return;);

	attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
	if (attrib == NULL) {
		IRDA_WARNING("%s: Unable to allocate attribute!\n",
			     __func__);
		return;
	}

	attrib->magic = IAS_ATTRIB_MAGIC;
	attrib->name = kstrndup(name, IAS_MAX_ATTRIBNAME, GFP_ATOMIC);

	/* Insert value */
	attrib->value = irias_new_integer_value(value);
	if (!attrib->name || !attrib->value) {
		IRDA_WARNING("%s: Unable to allocate attribute!\n",
			     __func__);
		if (attrib->value)
			irias_delete_value(attrib->value);
		kfree(attrib->name);
		kfree(attrib);
		return;
	}

	irias_add_attrib(obj, attrib, owner);
}
EXPORT_SYMBOL(irias_add_integer_attrib);

 /*
 * Function irias_add_octseq_attrib (obj, name, octet_seq, len)
 *
 *    Add a octet sequence attribute to an LM-IAS object
 *
 */

void irias_add_octseq_attrib(struct ias_object *obj, char *name, __u8 *octets,
			     int len, int owner)
{
	struct ias_attrib *attrib;

	IRDA_ASSERT(obj != NULL, return;);
	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);

	IRDA_ASSERT(name != NULL, return;);
	IRDA_ASSERT(octets != NULL, return;);

	attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
	if (attrib == NULL) {
		IRDA_WARNING("%s: Unable to allocate attribute!\n",
			     __func__);
		return;
	}

	attrib->magic = IAS_ATTRIB_MAGIC;
	attrib->name = kstrndup(name, IAS_MAX_ATTRIBNAME, GFP_ATOMIC);

	attrib->value = irias_new_octseq_value( octets, len);
	if (!attrib->name || !attrib->value) {
		IRDA_WARNING("%s: Unable to allocate attribute!\n",
			     __func__);
		if (attrib->value)
			irias_delete_value(attrib->value);
		kfree(attrib->name);
		kfree(attrib);
		return;
	}

	irias_add_attrib(obj, attrib, owner);
}
EXPORT_SYMBOL(irias_add_octseq_attrib);

/*
 * Function irias_object_add_string_attrib (obj, string)
 *
 *    Add a string attribute to an LM-IAS object
 *
 */
void irias_add_string_attrib(struct ias_object *obj, char *name, char *value,
			     int owner)
{
	struct ias_attrib *attrib;

	IRDA_ASSERT(obj != NULL, return;);
	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);

	IRDA_ASSERT(name != NULL, return;);
	IRDA_ASSERT(value != NULL, return;);

	attrib = kzalloc(sizeof( struct ias_attrib), GFP_ATOMIC);
	if (attrib == NULL) {
		IRDA_WARNING("%s: Unable to allocate attribute!\n",
			     __func__);
		return;
	}

	attrib->magic = IAS_ATTRIB_MAGIC;
	attrib->name = kstrndup(name, IAS_MAX_ATTRIBNAME, GFP_ATOMIC);

	attrib->value = irias_new_string_value(value);
	if (!attrib->name || !attrib->value) {
		IRDA_WARNING("%s: Unable to allocate attribute!\n",
			     __func__);
		if (attrib->value)
			irias_delete_value(attrib->value);
		kfree(attrib->name);
		kfree(attrib);
		return;
	}

	irias_add_attrib(obj, attrib, owner);
}
EXPORT_SYMBOL(irias_add_string_attrib);

/*
 * Function irias_new_integer_value (integer)
 *
 *    Create new IAS integer value
 *
 */
struct ias_value *irias_new_integer_value(int integer)
{
	struct ias_value *value;

	value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
	if (value == NULL) {
		IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
		return NULL;
	}

	value->type = IAS_INTEGER;
	value->len = 4;
	value->t.integer = integer;

	return value;
}
EXPORT_SYMBOL(irias_new_integer_value);

/*
 * Function irias_new_string_value (string)
 *
 *    Create new IAS string value
 *
 * Per IrLMP 1.1, 4.3.3.2, strings are up to 256 chars - Jean II
 */
struct ias_value *irias_new_string_value(char *string)
{
	struct ias_value *value;

	value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
	if (value == NULL) {
		IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
		return NULL;
	}

	value->type = IAS_STRING;
	value->charset = CS_ASCII;
	value->t.string = kstrndup(string, IAS_MAX_STRING, GFP_ATOMIC);
	if (!value->t.string) {
		IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
		kfree(value);
		return NULL;
	}

	value->len = strlen(value->t.string);

	return value;
}

/*
 * Function irias_new_octseq_value (octets, len)
 *
 *    Create new IAS octet-sequence value
 *
 * Per IrLMP 1.1, 4.3.3.2, octet-sequence are up to 1024 bytes - Jean II
 */
struct ias_value *irias_new_octseq_value(__u8 *octseq , int len)
{
	struct ias_value *value;

	value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
	if (value == NULL) {
		IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
		return NULL;
	}

	value->type = IAS_OCT_SEQ;
	/* Check length */
	if(len > IAS_MAX_OCTET_STRING)
		len = IAS_MAX_OCTET_STRING;
	value->len = len;

	value->t.oct_seq = kmemdup(octseq, len, GFP_ATOMIC);
	if (value->t.oct_seq == NULL){
		IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
		kfree(value);
		return NULL;
	}
	return value;
}

struct ias_value *irias_new_missing_value(void)
{
	struct ias_value *value;

	value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
	if (value == NULL) {
		IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
		return NULL;
	}

	value->type = IAS_MISSING;

	return value;
}

/*
 * Function irias_delete_value (value)
 *
 *    Delete IAS value
 *
 */
void irias_delete_value(struct ias_value *value)
{
	IRDA_DEBUG(4, "%s()\n", __func__);

	IRDA_ASSERT(value != NULL, return;);

	switch (value->type) {
	case IAS_INTEGER: /* Fallthrough */
	case IAS_MISSING:
		/* No need to deallocate */
		break;
	case IAS_STRING:
		/* Deallocate string */
		kfree(value->t.string);
		break;
	case IAS_OCT_SEQ:
		/* Deallocate byte stream */
		 kfree(value->t.oct_seq);
		 break;
	default:
		IRDA_DEBUG(0, "%s(), Unknown value type!\n", __func__);
		break;
	}
	kfree(value);
}
EXPORT_SYMBOL(irias_delete_value);
Commit	Line	Data
1da177e4 LT	1	/*********************************************************************
	2	*
	3	* Filename: irias_object.c
	4	* Version: 0.3
	5	* Description: IAS object database and functions
	6	* Status: Experimental.
	7	* Author: Dag Brattli <[email protected]>
	8	* Created at: Thu Oct 1 22:50:04 1998
	9	* Modified at: Wed Dec 15 11:23:16 1999
	10	* Modified by: Dag Brattli <[email protected]>
	11	*
	12	* Copyright (c) 1998-1999 Dag Brattli, All Rights Reserved.
	13	*
	14	* This program is free software; you can redistribute it and/or
	15	* modify it under the terms of the GNU General Public License as
	16	* published by the Free Software Foundation; either version 2 of
	17	* the License, or (at your option) any later version.
	18	*
96de0e25	19	* Neither Dag Brattli nor University of Tromsø admit liability nor
1da177e4 LT	20	* provide warranty for any of this software. This material is
	21	* provided "AS-IS" and at no charge.
	22	*
	23	********************************************************************/
	24
5a0e3ad6	25	#include <linux/slab.h>
1da177e4 LT	26	#include <linux/string.h>
	27	#include <linux/socket.h>
	28	#include <linux/module.h>
	29
	30	#include <net/irda/irda.h>
	31	#include <net/irda/irias_object.h>
	32
	33	hashbin_t *irias_objects;
	34
	35	/*
	36	* Used when a missing value needs to be returned
	37	*/
	38	struct ias_value irias_missing = { IAS_MISSING, 0, 0, 0, {0}};
	39
1da177e4 LT	40
	41	/*
	42	* Function ias_new_object (name, id)
	43	*
	44	* Create a new IAS object
	45	*
	46	*/
	47	struct ias_object irias_new_object( char name, int id)
	48	{
6819bc2e	49	struct ias_object *obj;
1da177e4	50
0dc47877	51	IRDA_DEBUG( 4, "%s()\n", __func__);
1da177e4	52
0da974f4	53	obj = kzalloc(sizeof(struct ias_object), GFP_ATOMIC);
1da177e4 LT	54	if (obj == NULL) {
1da177e4 LT	55	IRDA_WARNING("%s(), Unable to allocate object!\n",
0dc47877	56	__func__);
1da177e4 LT	57	return NULL;
1da177e4 LT	58	}
1da177e4 LT	59
1da177e4 LT	60	obj->magic = IAS_OBJECT_MAGIC;
1e66df3e	61	obj->name = kstrndup(name, IAS_MAX_CLASSNAME, GFP_ATOMIC);
bb5aa427 AM	62	if (!obj->name) {
bb5aa427 AM	63	IRDA_WARNING("%s(), Unable to allocate name!\n",
0dc47877	64	__func__);
bb5aa427 AM	65	kfree(obj);
	66	return NULL;
	67	}
1da177e4 LT	68	obj->id = id;
	69
	70	/* Locking notes : the attrib spinlock has lower precendence
	71	* than the objects spinlock. Never grap the objects spinlock
	72	* while holding any attrib spinlock (risk of deadlock). Jean II */
	73	obj->attribs = hashbin_new(HB_LOCK);
	74
	75	if (obj->attribs == NULL) {
	76	IRDA_WARNING("%s(), Unable to allocate attribs!\n",
0dc47877	77	__func__);
bb5aa427	78	kfree(obj->name);
1da177e4 LT	79	kfree(obj);
	80	return NULL;
	81	}
	82
	83	return obj;
	84	}
	85	EXPORT_SYMBOL(irias_new_object);
	86
	87	/*
	88	* Function irias_delete_attrib (attrib)
	89	*
	90	* Delete given attribute and deallocate all its memory
	91	*
	92	*/
	93	static void __irias_delete_attrib(struct ias_attrib *attrib)
	94	{
	95	IRDA_ASSERT(attrib != NULL, return;);
	96	IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
	97
a51482bd	98	kfree(attrib->name);
1da177e4 LT	99
	100	irias_delete_value(attrib->value);
	101	attrib->magic = ~IAS_ATTRIB_MAGIC;
	102
	103	kfree(attrib);
	104	}
	105
	106	void __irias_delete_object(struct ias_object *obj)
	107	{
	108	IRDA_ASSERT(obj != NULL, return;);
	109	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
	110
a51482bd	111	kfree(obj->name);
1da177e4 LT	112
	113	hashbin_delete(obj->attribs, (FREE_FUNC) __irias_delete_attrib);
	114
	115	obj->magic = ~IAS_OBJECT_MAGIC;
	116
	117	kfree(obj);
	118	}
	119
	120	/*
	121	* Function irias_delete_object (obj)
	122	*
	123	* Remove object from hashbin and deallocate all attributes associated with
	124	* with this object and the object itself
	125	*
	126	*/
	127	int irias_delete_object(struct ias_object *obj)
	128	{
	129	struct ias_object *node;
	130
	131	IRDA_ASSERT(obj != NULL, return -1;);
	132	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
	133
	134	/* Remove from list */
	135	node = hashbin_remove_this(irias_objects, (irda_queue_t *) obj);
	136	if (!node)
	137	IRDA_DEBUG( 0, "%s(), object already removed!\n",
0dc47877	138	__func__);
1da177e4 LT	139
	140	/* Destroy */
	141	__irias_delete_object(obj);
	142
	143	return 0;
	144	}
	145	EXPORT_SYMBOL(irias_delete_object);
	146
	147	/*
	148	* Function irias_delete_attrib (obj)
	149	*
	150	* Remove attribute from hashbin and, if it was the last attribute of
	151	* the object, remove the object as well.
	152	*
	153	*/
	154	int irias_delete_attrib(struct ias_object obj, struct ias_attrib attrib,
	155	int cleanobject)
	156	{
	157	struct ias_attrib *node;
	158
	159	IRDA_ASSERT(obj != NULL, return -1;);
	160	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
	161	IRDA_ASSERT(attrib != NULL, return -1;);
	162
	163	/* Remove attribute from object */
	164	node = hashbin_remove_this(obj->attribs, (irda_queue_t *) attrib);
	165	if (!node)
	166	return 0; /* Already removed or non-existent */
	167
	168	/* Deallocate attribute */
	169	__irias_delete_attrib(node);
	170
	171	/* Check if object has still some attributes, destroy it if none.
	172	* At first glance, this look dangerous, as the kernel reference
	173	* various IAS objects. However, we only use this function on
	174	* user attributes, not kernel attributes, so there is no risk
	175	* of deleting a kernel object this way. Jean II */
	176	node = (struct ias_attrib *) hashbin_get_first(obj->attribs);
	177	if (cleanobject && !node)
	178	irias_delete_object(obj);
	179
	180	return 0;
	181	}
	182
	183	/*
	184	* Function irias_insert_object (obj)
	185	*
	186	* Insert an object into the LM-IAS database
	187	*
	188	*/
	189	void irias_insert_object(struct ias_object *obj)
	190	{
	191	IRDA_ASSERT(obj != NULL, return;);
	192	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
	193
	194	hashbin_insert(irias_objects, (irda_queue_t *) obj, 0, obj->name);
	195	}
	196	EXPORT_SYMBOL(irias_insert_object);
	197
	198	/*
	199	* Function irias_find_object (name)
	200	*
	201	* Find object with given name
	202	*
203	*/
204	struct ias_object irias_find_object(char name)
205	{
206	IRDA_ASSERT(name != NULL, return NULL;);
207
208	/* Unsafe (locking), object might change */
209	return hashbin_lock_find(irias_objects, 0, name);
210	}
211	EXPORT_SYMBOL(irias_find_object);
212
213	/*
214	* Function irias_find_attrib (obj, name)
215	*
216	* Find named attribute in object
217	*
218	*/
219	struct ias_attrib irias_find_attrib(struct ias_object obj, char *name)
220	{
221	struct ias_attrib *attrib;
222
223	IRDA_ASSERT(obj != NULL, return NULL;);
224	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return NULL;);
225	IRDA_ASSERT(name != NULL, return NULL;);
226
227	attrib = hashbin_lock_find(obj->attribs, 0, name);
228	if (attrib == NULL)
229	return NULL;
230
231	/* Unsafe (locking), attrib might change */
232	return attrib;
233	}
1da177e4 LT	234
	235	/*
	236	* Function irias_add_attribute (obj, attrib)
	237	*
	238	* Add attribute to object
	239	*
	240	*/
	241	static void irias_add_attrib(struct ias_object obj, struct ias_attrib attrib,
	242	int owner)
	243	{
	244	IRDA_ASSERT(obj != NULL, return;);
	245	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
	246
	247	IRDA_ASSERT(attrib != NULL, return;);
	248	IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
	249
	250	/* Set if attrib is owned by kernel or user space */
	251	attrib->value->owner = owner;
	252
	253	hashbin_insert(obj->attribs, (irda_queue_t *) attrib, 0, attrib->name);
	254	}
	255
	256	/*
	257	* Function irias_object_change_attribute (obj_name, attrib_name, new_value)
	258	*
	259	* Change the value of an objects attribute.
	260	*
	261	*/
	262	int irias_object_change_attribute(char obj_name, char attrib_name,
	263	struct ias_value *new_value)
	264	{
	265	struct ias_object *obj;
	266	struct ias_attrib *attrib;
	267	unsigned long flags;
	268
	269	/* Find object */
	270	obj = hashbin_lock_find(irias_objects, 0, obj_name);
	271	if (obj == NULL) {
0dc47877	272	IRDA_WARNING("%s: Unable to find object: %s\n", __func__,
1da177e4 LT	273	obj_name);
	274	return -1;
	275	}
	276
	277	/* Slightly unsafe (obj might get removed under us) */
	278	spin_lock_irqsave(&obj->attribs->hb_spinlock, flags);
	279
	280	/* Find attribute */
	281	attrib = hashbin_find(obj->attribs, 0, attrib_name);
	282	if (attrib == NULL) {
	283	IRDA_WARNING("%s: Unable to find attribute: %s\n",
0dc47877	284	__func__, attrib_name);
1da177e4 LT	285	spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
	286	return -1;
	287	}
	288
	289	if ( attrib->value->type != new_value->type) {
	290	IRDA_DEBUG( 0, "%s(), changing value type not allowed!\n",
0dc47877	291	__func__);
1da177e4 LT	292	spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
	293	return -1;
	294	}
	295
	296	/* Delete old value */
	297	irias_delete_value(attrib->value);
	298
	299	/* Insert new value */
	300	attrib->value = new_value;
	301
	302	/* Success */
	303	spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
	304	return 0;
	305	}
	306	EXPORT_SYMBOL(irias_object_change_attribute);
	307
	308	/*
	309	* Function irias_object_add_integer_attrib (obj, name, value)
	310	*
	311	* Add an integer attribute to an LM-IAS object
	312	*
	313	*/
	314	void irias_add_integer_attrib(struct ias_object obj, char name, int value,
	315	int owner)
	316	{
	317	struct ias_attrib *attrib;
	318
	319	IRDA_ASSERT(obj != NULL, return;);
	320	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
	321	IRDA_ASSERT(name != NULL, return;);
	322
0da974f4	323	attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
1da177e4 LT	324	if (attrib == NULL) {
1da177e4 LT	325	IRDA_WARNING("%s: Unable to allocate attribute!\n",
0dc47877	326	__func__);
1da177e4 LT	327	return;
1da177e4 LT	328	}
1da177e4 LT	329
1da177e4 LT	330	attrib->magic = IAS_ATTRIB_MAGIC;
1e66df3e	331	attrib->name = kstrndup(name, IAS_MAX_ATTRIBNAME, GFP_ATOMIC);
1da177e4 LT	332
	333	/* Insert value */
	334	attrib->value = irias_new_integer_value(value);
bb5aa427 AM	335	if (!attrib->name \|\| !attrib->value) {
bb5aa427 AM	336	IRDA_WARNING("%s: Unable to allocate attribute!\n",
0dc47877	337	__func__);
bb5aa427 AM	338	if (attrib->value)
	339	irias_delete_value(attrib->value);
	340	kfree(attrib->name);
	341	kfree(attrib);
	342	return;
	343	}
1da177e4 LT	344
	345	irias_add_attrib(obj, attrib, owner);
	346	}
	347	EXPORT_SYMBOL(irias_add_integer_attrib);
	348
	349	/*
	350	* Function irias_add_octseq_attrib (obj, name, octet_seq, len)
	351	*
	352	* Add a octet sequence attribute to an LM-IAS object
	353	*
	354	*/
	355
	356	void irias_add_octseq_attrib(struct ias_object obj, char name, __u8 *octets,
	357	int len, int owner)
	358	{
	359	struct ias_attrib *attrib;
	360
	361	IRDA_ASSERT(obj != NULL, return;);
	362	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
	363
	364	IRDA_ASSERT(name != NULL, return;);
	365	IRDA_ASSERT(octets != NULL, return;);
	366
0da974f4	367	attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
1da177e4 LT	368	if (attrib == NULL) {
1da177e4 LT	369	IRDA_WARNING("%s: Unable to allocate attribute!\n",
0dc47877	370	__func__);
1da177e4 LT	371	return;
1da177e4 LT	372	}
1da177e4 LT	373
1da177e4 LT	374	attrib->magic = IAS_ATTRIB_MAGIC;
1e66df3e	375	attrib->name = kstrndup(name, IAS_MAX_ATTRIBNAME, GFP_ATOMIC);
1da177e4 LT	376
1da177e4 LT	377	attrib->value = irias_new_octseq_value( octets, len);
bb5aa427 AM	378	if (!attrib->name \|\| !attrib->value) {
bb5aa427 AM	379	IRDA_WARNING("%s: Unable to allocate attribute!\n",
0dc47877	380	__func__);
bb5aa427 AM	381	if (attrib->value)
	382	irias_delete_value(attrib->value);
	383	kfree(attrib->name);
	384	kfree(attrib);
	385	return;
	386	}
1da177e4 LT	387
	388	irias_add_attrib(obj, attrib, owner);
	389	}
	390	EXPORT_SYMBOL(irias_add_octseq_attrib);
	391
	392	/*
	393	* Function irias_object_add_string_attrib (obj, string)
	394	*
	395	* Add a string attribute to an LM-IAS object
	396	*
	397	*/
	398	void irias_add_string_attrib(struct ias_object obj, char name, char *value,
	399	int owner)
	400	{
	401	struct ias_attrib *attrib;
	402
	403	IRDA_ASSERT(obj != NULL, return;);
	404	IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
	405
	406	IRDA_ASSERT(name != NULL, return;);
	407	IRDA_ASSERT(value != NULL, return;);
	408
0da974f4	409	attrib = kzalloc(sizeof( struct ias_attrib), GFP_ATOMIC);
1da177e4 LT	410	if (attrib == NULL) {
1da177e4 LT	411	IRDA_WARNING("%s: Unable to allocate attribute!\n",
0dc47877	412	__func__);
1da177e4 LT	413	return;
1da177e4 LT	414	}
1da177e4 LT	415
1da177e4 LT	416	attrib->magic = IAS_ATTRIB_MAGIC;
1e66df3e	417	attrib->name = kstrndup(name, IAS_MAX_ATTRIBNAME, GFP_ATOMIC);
1da177e4 LT	418
1da177e4 LT	419	attrib->value = irias_new_string_value(value);
bb5aa427 AM	420	if (!attrib->name \|\| !attrib->value) {
bb5aa427 AM	421	IRDA_WARNING("%s: Unable to allocate attribute!\n",
0dc47877	422	__func__);
bb5aa427 AM	423	if (attrib->value)
	424	irias_delete_value(attrib->value);
	425	kfree(attrib->name);
	426	kfree(attrib);
	427	return;
	428	}
1da177e4 LT	429
	430	irias_add_attrib(obj, attrib, owner);
	431	}
	432	EXPORT_SYMBOL(irias_add_string_attrib);
	433
	434	/*
	435	* Function irias_new_integer_value (integer)
	436	*
	437	* Create new IAS integer value
	438	*
	439	*/
	440	struct ias_value *irias_new_integer_value(int integer)
	441	{
	442	struct ias_value *value;
	443
0da974f4	444	value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
1da177e4	445	if (value == NULL) {
0dc47877	446	IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
1da177e4 LT	447	return NULL;
1da177e4 LT	448	}
1da177e4 LT	449
	450	value->type = IAS_INTEGER;
	451	value->len = 4;
	452	value->t.integer = integer;
	453
	454	return value;
	455	}
	456	EXPORT_SYMBOL(irias_new_integer_value);
	457
	458	/*
	459	* Function irias_new_string_value (string)
	460	*
	461	* Create new IAS string value
	462	*
	463	* Per IrLMP 1.1, 4.3.3.2, strings are up to 256 chars - Jean II
	464	*/
	465	struct ias_value irias_new_string_value(char string)
	466	{
	467	struct ias_value *value;
	468
0da974f4	469	value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
1da177e4	470	if (value == NULL) {
0dc47877	471	IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
1da177e4 LT	472	return NULL;
1da177e4 LT	473	}
1da177e4 LT	474
	475	value->type = IAS_STRING;
	476	value->charset = CS_ASCII;
1e66df3e	477	value->t.string = kstrndup(string, IAS_MAX_STRING, GFP_ATOMIC);
bb5aa427	478	if (!value->t.string) {
0dc47877	479	IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
bb5aa427 AM	480	kfree(value);
	481	return NULL;
	482	}
	483
1da177e4 LT	484	value->len = strlen(value->t.string);
	485
	486	return value;
	487	}
1da177e4 LT	488
	489	/*
	490	* Function irias_new_octseq_value (octets, len)
	491	*
	492	* Create new IAS octet-sequence value
	493	*
	494	* Per IrLMP 1.1, 4.3.3.2, octet-sequence are up to 1024 bytes - Jean II
	495	*/
	496	struct ias_value irias_new_octseq_value(__u8 octseq , int len)
	497	{
	498	struct ias_value *value;
	499
0da974f4	500	value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
1da177e4	501	if (value == NULL) {
0dc47877	502	IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
1da177e4 LT	503	return NULL;
1da177e4 LT	504	}
1da177e4 LT	505
	506	value->type = IAS_OCT_SEQ;
	507	/* Check length */
	508	if(len > IAS_MAX_OCTET_STRING)
	509	len = IAS_MAX_OCTET_STRING;
	510	value->len = len;
	511
b3ab09f9	512	value->t.oct_seq = kmemdup(octseq, len, GFP_ATOMIC);
1da177e4	513	if (value->t.oct_seq == NULL){
0dc47877	514	IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
1da177e4 LT	515	kfree(value);
	516	return NULL;
	517	}
1da177e4 LT	518	return value;
1da177e4 LT	519	}
1da177e4 LT	520
	521	struct ias_value *irias_new_missing_value(void)
	522	{
	523	struct ias_value *value;
	524
0da974f4	525	value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
1da177e4	526	if (value == NULL) {
0dc47877	527	IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
1da177e4 LT	528	return NULL;
1da177e4 LT	529	}
1da177e4 LT	530
1da177e4 LT	531	value->type = IAS_MISSING;
1da177e4 LT	532
	533	return value;
	534	}
	535
	536	/*
	537	* Function irias_delete_value (value)
	538	*
	539	* Delete IAS value
	540	*
	541	*/
	542	void irias_delete_value(struct ias_value *value)
	543	{
0dc47877	544	IRDA_DEBUG(4, "%s()\n", __func__);
1da177e4 LT	545
	546	IRDA_ASSERT(value != NULL, return;);
	547
	548	switch (value->type) {
	549	case IAS_INTEGER: /* Fallthrough */
	550	case IAS_MISSING:
	551	/* No need to deallocate */
	552	break;
	553	case IAS_STRING:
a51482bd JJ	554	/* Deallocate string */
a51482bd JJ	555	kfree(value->t.string);
1da177e4 LT	556	break;
1da177e4 LT	557	case IAS_OCT_SEQ:
a51482bd JJ	558	/* Deallocate byte stream */
a51482bd JJ	559	kfree(value->t.oct_seq);
1da177e4 LT	560	break;
1da177e4 LT	561	default:
0dc47877	562	IRDA_DEBUG(0, "%s(), Unknown value type!\n", __func__);
1da177e4 LT	563	break;
	564	}
	565	kfree(value);
	566	}
	567	EXPORT_SYMBOL(irias_delete_value);