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