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