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
  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