URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [irda/] [irias_object.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*********************************************************************
 *
 * 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/string.h>
#include <linux/socket.h>
 
#include <net/irda/irda.h>
#include <net/irda/irmod.h>
#include <net/irda/irias_object.h>
 
hashbin_t *objects = NULL;
 
/*
 *  Used when a missing value needs to be returned
 */
struct ias_value missing = { IAS_MISSING, 0, 0, 0, {0}};
 
/*
 * Function strndup (str, max)
 *
 *    My own kernel version of strndup!
 *
 * Faster, check boundary... Jean II
 */
char *strndup(char *str, int max)
{
        char *new_str;
        int len;
 
        /* Check string */
        if (str == NULL)
                return NULL;
        /* Check length, truncate */
        len = strlen(str);
        if(len > max)
                len = max;
 
        /* Allocate new string */
        new_str = kmalloc(len + 1, GFP_ATOMIC);
        if (new_str == NULL) {
                WARNING("%s(), Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
 
        /* Copy and truncate */
        memcpy(new_str, str, len);
        new_str[len] = '\0';
 
        return new_str;
}
 
/*
 * 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", __FUNCTION__);
 
        obj = (struct ias_object *) kmalloc(sizeof(struct ias_object),
                                            GFP_ATOMIC);
        if (obj == NULL) {
                IRDA_DEBUG(0, "%s(), Unable to allocate object!\n", __FUNCTION__);
                return NULL;
        }
        memset(obj, 0, sizeof( struct ias_object));
 
        obj->magic = IAS_OBJECT_MAGIC;
        obj->name = strndup(name, IAS_MAX_CLASSNAME);
        obj->id = id;
 
        obj->attribs = hashbin_new(HB_LOCAL);
 
        return obj;
}
 
/*
 * Function irias_delete_attrib (attrib)
 *
 *    Delete given attribute and deallocate all its memory
 *
 */
void __irias_delete_attrib(struct ias_attrib *attrib)
{
        ASSERT(attrib != NULL, return;);
        ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
 
        if (attrib->name)
                kfree(attrib->name);
 
        irias_delete_value(attrib->value);
        attrib->magic = ~IAS_ATTRIB_MAGIC;
 
        kfree(attrib);
}
 
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);
 
        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 assosiated with
 *    with this object and the object itself
 *
 */
int irias_delete_object(struct ias_object *obj)
{
        struct ias_object *node;
 
        ASSERT(obj != NULL, return -1;);
        ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
 
        node = hashbin_remove(objects, 0, obj->name);
        if (!node)
                return 0; /* Already removed */
 
        __irias_delete_object(node);
 
        return 0;
}
 
/*
 * 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)
{
        struct ias_attrib *node;
 
        ASSERT(obj != NULL, return -1;);
        ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
        ASSERT(attrib != NULL, return -1;);
 
        /* Remove attribute from object */
        node = hashbin_remove(obj->attribs, 0, attrib->name);
        if (!node)
                return 0; /* Already removed or non-existent */
 
        /* Deallocate attribute */
        __irias_delete_attrib(node);
 
        /* Check if object has still some attributes */
        node = (struct ias_attrib *) hashbin_get_first(obj->attribs);
        if (!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)
{
        ASSERT(obj != NULL, return;);
        ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
        hashbin_insert(objects, (irda_queue_t *) obj, 0, obj->name);
}
 
/*
 * Function irias_find_object (name)
 *
 *    Find object with given name
 *
 */
struct ias_object *irias_find_object(char *name)
{
        ASSERT(name != NULL, return NULL;);
 
        return hashbin_find(objects, 0, name);
}
 
/*
 * 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;
 
        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)
                return NULL;
 
        return attrib;
}
 
/*
 * Function irias_add_attribute (obj, attrib)
 *
 *    Add attribute to object
 *
 */
void irias_add_attrib( struct ias_object *obj, struct ias_attrib *attrib,
                       int owner)
{
        ASSERT(obj != NULL, return;);
        ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
        ASSERT(attrib != NULL, return;);
        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;
 
        /* Find object */
        obj = hashbin_find(objects, 0, obj_name);
        if (obj == NULL) {
                WARNING("%s(), Unable to find object: %s\n", __FUNCTION__,
                        obj_name);
                return -1;
        }
 
        /* Find attribute */
        attrib = hashbin_find(obj->attribs, 0, attrib_name);
        if (attrib == NULL) {
                WARNING("%s(), Unable to find attribute: %s\n", __FUNCTION__,
                        attrib_name);
                return -1;
        }
 
        if ( attrib->value->type != new_value->type) {
                IRDA_DEBUG( 0, "%s(), changing value type not allowed!\n", __FUNCTION__);
                return -1;
        }
 
        /* Delete old value */
        irias_delete_value(attrib->value);
 
        /* Insert new value */
        attrib->value = new_value;
 
        /* Success */
        return 0;
}
 
/*
 * 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;
 
        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("%s(), Unable to allocate attribute!\n", __FUNCTION__);
                return;
        }
        memset(attrib, 0, sizeof( struct ias_attrib));
 
        attrib->magic = IAS_ATTRIB_MAGIC;
        attrib->name = strndup(name, IAS_MAX_ATTRIBNAME);
 
        /* Insert value */
        attrib->value = irias_new_integer_value(value);
 
        irias_add_attrib(obj, attrib, owner);
}
 
 /*
 * 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;
 
        ASSERT(obj != NULL, return;);
        ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
        ASSERT(name != NULL, return;);
        ASSERT(octets != NULL, return;);
 
        attrib = (struct ias_attrib *) kmalloc(sizeof(struct ias_attrib),
                                               GFP_ATOMIC);
        if (attrib == NULL) {
                WARNING("%s(), Unable to allocate attribute!\n", __FUNCTION__);
                return;
        }
        memset(attrib, 0, sizeof( struct ias_attrib));
 
        attrib->magic = IAS_ATTRIB_MAGIC;
        attrib->name = strndup(name, IAS_MAX_ATTRIBNAME);
 
        attrib->value = irias_new_octseq_value( octets, len);
 
        irias_add_attrib(obj, attrib, owner);
}
 
/*
 * 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;
 
        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) {
                WARNING("%s(), Unable to allocate attribute!\n", __FUNCTION__);
                return;
        }
        memset(attrib, 0, sizeof( struct ias_attrib));
 
        attrib->magic = IAS_ATTRIB_MAGIC;
        attrib->name = strndup(name, IAS_MAX_ATTRIBNAME);
 
        attrib->value = irias_new_string_value(value);
 
        irias_add_attrib(obj, attrib, owner);
}
 
/*
 * 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 = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
        if (value == NULL) {
                WARNING("%s(), Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
        memset(value, 0, sizeof(struct ias_value));
 
        value->type = IAS_INTEGER;
        value->len = 4;
        value->t.integer = integer;
 
        return 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 = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
        if (value == NULL) {
                WARNING("%s(), Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
        memset( value, 0, sizeof( struct ias_value));
 
        value->type = IAS_STRING;
        value->charset = CS_ASCII;
        value->t.string = strndup(string, IAS_MAX_STRING);
        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 = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
        if (value == NULL) {
                WARNING("%s(), Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
        memset(value, 0, sizeof(struct ias_value));
 
        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 = kmalloc(len, GFP_ATOMIC);
        if (value->t.oct_seq == NULL){
                WARNING("%s(), Unable to kmalloc!\n", __FUNCTION__);
                kfree(value);
                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("%s(), Unable to kmalloc!\n", __FUNCTION__);
                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)
{
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
        ASSERT(value != NULL, return;);
 
        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);
                break;
        case IAS_OCT_SEQ:
                /* If byte stream, deallocate byte stream */
                 if (value->t.oct_seq != NULL)
                         kfree(value->t.oct_seq);
                 break;
        default:
                IRDA_DEBUG(0, "%s(), Unknown value type!\n", __FUNCTION__);
                break;
        }
        kfree(value);
}
 
 
 

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [irda/] [irias_object.c] - Blame information for rev 1765

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