Release 4.11 net/irda/irias_object.c

/*********************************************************************
 *
 * Filename:      irias_object.c
 * Version:       0.3
 * Description:   IAS object database and functions
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Thu Oct  1 22:50:04 1998
 * Modified at:   Wed Dec 15 11:23:16 1999
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 *
 *     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;

	obj = kzalloc(sizeof(struct ias_object), GFP_ATOMIC);
	if (obj == NULL) {
		net_warn_ratelimited("%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) {
		net_warn_ratelimited("%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) {
		net_warn_ratelimited("%s(), Unable to allocate attribs!\n",
				     __func__);
		kfree(obj->name);
		kfree(obj);
		return NULL;
	}

	return obj;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
76
52.78%
1
10.00%
Akinobu Mita
29
20.14%
1
10.00%
Jean Tourrilhes
27
18.75%
3
30.00%
Joe Perches
3
2.08%
1
10.00%
Jeremy Fitzhardinge
3
2.08%
1
10.00%
Harvey Harrison
3
2.08%
1
10.00%
Linus Torvalds
2
1.39%
1
10.00%
Panagiotis Issaris
1
0.69%
1
10.00%
Total
144
100.00%
10
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
48
94.12%
1
33.33%
Jean Tourrilhes
2
3.92%
1
33.33%
Adrian Bunk
1
1.96%
1
33.33%
Total
51
100.00%
3
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
53
96.36%
1
50.00%
Jean Tourrilhes
2
3.64%
1
50.00%
Total
55
100.00%
2
100.00%

/*
 * 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)
		pr_debug("%s(), object already removed!\n",
			 __func__);

	/* Destroy */
	__irias_delete_object(obj);

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
50
73.53%
2
25.00%
Jean Tourrilhes
15
22.06%
3
37.50%
Joe Perches
1
1.47%
1
12.50%
Harvey Harrison
1
1.47%
1
12.50%
Rusty Russell
1
1.47%
1
12.50%
Total
68
100.00%
8
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
96
86.49%
1
20.00%
Jean Tourrilhes
14
12.61%
3
60.00%
Linus Torvalds
1
0.90%
1
20.00%
Total
111
100.00%
5
100.00%

/*
 * 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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
38
92.68%
2
50.00%
Jean Tourrilhes
2
4.88%
1
25.00%
Rusty Russell
1
2.44%
1
25.00%
Total
41
100.00%
4
100.00%


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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
25
86.21%
1
25.00%
Jean Tourrilhes
3
10.34%
2
50.00%
Rusty Russell
1
3.45%
1
25.00%
Total
29
100.00%
4
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
63
92.65%
1
33.33%
Jean Tourrilhes
5
7.35%
2
66.67%
Total
68
100.00%
3
100.00%

/*
 * 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
70
93.33%
2
50.00%
Jean Tourrilhes
4
5.33%
1
25.00%
Adrian Bunk
1
1.33%
1
25.00%
Total
75
100.00%
4
100.00%

/*
 * 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) {
		net_warn_ratelimited("%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) {
		net_warn_ratelimited("%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) {
		pr_debug("%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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
126
65.28%
1
12.50%
Jean Tourrilhes
56
29.02%
2
25.00%
Martin Dalecki
4
2.07%
1
12.50%
Harvey Harrison
3
1.55%
1
12.50%
Joe Perches
3
1.55%
2
25.00%
Rusty Russell
1
0.52%
1
12.50%
Total
193
100.00%
8
100.00%


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) {
		net_warn_ratelimited("%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) {
		net_warn_ratelimited("%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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
100
62.50%
2
20.00%
Akinobu Mita
45
28.12%
1
10.00%
Jeremy Fitzhardinge
3
1.88%
1
10.00%
Jean Tourrilhes
3
1.88%
1
10.00%
Harvey Harrison
2
1.25%
1
10.00%
Martin Dalecki
2
1.25%
1
10.00%
Linus Torvalds
2
1.25%
1
10.00%
Joe Perches
2
1.25%
1
10.00%
Panagiotis Issaris
1
0.62%
1
10.00%
Total
160
100.00%
10
100.00%


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) {
		net_warn_ratelimited("%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) {
		net_warn_ratelimited("%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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
111
64.53%
2
20.00%
Akinobu Mita
45
26.16%
1
10.00%
Jean Tourrilhes
4
2.33%
1
10.00%
Jeremy Fitzhardinge
3
1.74%
1
10.00%
Harvey Harrison
2
1.16%
1
10.00%
Joe Perches
2
1.16%
1
10.00%
Martin Dalecki
2
1.16%
1
10.00%
Linus Torvalds
2
1.16%
1
10.00%
Panagiotis Issaris
1
0.58%
1
10.00%
Total
172
100.00%
10
100.00%


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) {
		net_warn_ratelimited("%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) {
		net_warn_ratelimited("%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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
106
63.47%
2
20.00%
Akinobu Mita
45
26.95%
1
10.00%
Jean Tourrilhes
4
2.40%
1
10.00%
Jeremy Fitzhardinge
3
1.80%
1
10.00%
Harvey Harrison
2
1.20%
1
10.00%
Joe Perches
2
1.20%
1
10.00%
Martin Dalecki
2
1.20%
1
10.00%
Linus Torvalds
2
1.20%
1
10.00%
Panagiotis Issaris
1
0.60%
1
10.00%
Total
167
100.00%
10
100.00%


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)
		return NULL;

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

	return value;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
59
98.33%
1
50.00%
Panagiotis Issaris
1
1.67%
1
50.00%
Total
60
100.00%
2
100.00%


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)
		return NULL;

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

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

	return value;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
66
61.68%
1
14.29%
Akinobu Mita
24
22.43%
1
14.29%
Linus Torvalds
11
10.28%
1
14.29%
Jeremy Fitzhardinge
3
2.80%
1
14.29%
Harvey Harrison
1
0.93%
1
14.29%
Panagiotis Issaris
1
0.93%
1
14.29%
Joe Perches
1
0.93%
1
14.29%
Total
107
100.00%
7
100.00%

/*
 * 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)
		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){
		net_warn_ratelimited("%s: Unable to kmalloc!\n", __func__);
		kfree(value);
		return NULL;
	}
	return value;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
85
77.98%
1
14.29%
Linus Torvalds
16
14.68%
1
14.29%
Arnaldo Carvalho de Melo
3
2.75%
1
14.29%
Martin Dalecki
2
1.83%
1
14.29%
Joe Perches
1
0.92%
1
14.29%
Panagiotis Issaris
1
0.92%
1
14.29%
Harvey Harrison
1
0.92%
1
14.29%
Total
109
100.00%
7
100.00%



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

	value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
	if (value == NULL)
		return NULL;

	value->type = IAS_MISSING;

	return value;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
44
97.78%
1
50.00%
Panagiotis Issaris
1
2.22%
1
50.00%
Total
45
100.00%
2
100.00%

/*
 * Function irias_delete_value (value)
 *
 *    Delete IAS value
 *
 */


void irias_delete_value(struct ias_value *value)
{
	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:
		pr_debug("%s(), Unknown value type!\n", __func__);
		break;
	}
	kfree(value);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
69
90.79%
1
16.67%
Jean Tourrilhes
3
3.95%
2
33.33%
Jesper Juhl
2
2.63%
1
16.67%
Harvey Harrison
1
1.32%
1
16.67%
Joe Perches
1
1.32%
1
16.67%
Total
76
100.00%
6
100.00%


EXPORT_SYMBOL(irias_delete_value);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
1327
72.16%
5
17.24%
Akinobu Mita
188
10.22%
1
3.45%
Jean Tourrilhes
144
7.83%
6
20.69%
Stephen Hemminger
54
2.94%
1
3.45%
Linus Torvalds
42
2.28%
3
10.34%
Joe Perches
16
0.87%
2
6.90%
Harvey Harrison
16
0.87%
1
3.45%
Jeremy Fitzhardinge
15
0.82%
1
3.45%
Martin Dalecki
12
0.65%
1
3.45%
Panagiotis Issaris
8
0.44%
1
3.45%
Rusty Russell
5
0.27%
1
3.45%
Arnaldo Carvalho de Melo
3
0.16%
1
3.45%
Tejun Heo
3
0.16%
1
3.45%
Adrian Bunk
2
0.11%
1
3.45%
Jesper Juhl
2
0.11%
1
3.45%
Steven Cole
1
0.05%
1
3.45%
Jan Engelhardt
1
0.05%
1
3.45%
Total
1839
100.00%
29
100.00%
Directory: net/irda

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.