OpenCores
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

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
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.