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