*
* Faster, check boundary... Jean II
*/
-static char *strndup(char *str, int max)
+static char *strndup(char *str, size_t max)
{
char *new_str;
int len;
/* Allocate new string */
new_str = kmalloc(len + 1, GFP_ATOMIC);
if (new_str == NULL) {
- WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+ IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
return NULL;
}
IRDA_DEBUG( 4, "%s()\n", __FUNCTION__);
- obj = (struct ias_object *) kmalloc(sizeof(struct ias_object),
- GFP_ATOMIC);
+ obj = kzalloc(sizeof(struct ias_object), GFP_ATOMIC);
if (obj == NULL) {
- WARNING("%s(), Unable to allocate object!\n",
- __FUNCTION__);
+ IRDA_WARNING("%s(), Unable to allocate object!\n",
+ __FUNCTION__);
return NULL;
}
- memset(obj, 0, sizeof( struct ias_object));
obj->magic = IAS_OBJECT_MAGIC;
obj->name = strndup(name, IAS_MAX_CLASSNAME);
obj->attribs = hashbin_new(HB_LOCK);
if (obj->attribs == NULL) {
- WARNING("%s(), Unable to allocate attribs!\n", __FUNCTION__);
+ IRDA_WARNING("%s(), Unable to allocate attribs!\n",
+ __FUNCTION__);
kfree(obj);
return NULL;
}
* Delete given attribute and deallocate all its memory
*
*/
-void __irias_delete_attrib(struct ias_attrib *attrib)
+static void __irias_delete_attrib(struct ias_attrib *attrib)
{
- ASSERT(attrib != NULL, return;);
- ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
+ IRDA_ASSERT(attrib != NULL, return;);
+ IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
- if (attrib->name)
- kfree(attrib->name);
+ kfree(attrib->name);
irias_delete_value(attrib->value);
attrib->magic = ~IAS_ATTRIB_MAGIC;
void __irias_delete_object(struct ias_object *obj)
{
- ASSERT(obj != NULL, return;);
- ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+ IRDA_ASSERT(obj != NULL, return;);
+ IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
- if (obj->name)
- kfree(obj->name);
+ kfree(obj->name);
hashbin_delete(obj->attribs, (FREE_FUNC) __irias_delete_attrib);
{
struct ias_object *node;
- ASSERT(obj != NULL, return -1;);
- ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
+ IRDA_ASSERT(obj != NULL, return -1;);
+ IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
/* Remove from list */
node = hashbin_remove_this(irias_objects, (irda_queue_t *) obj);
{
struct ias_attrib *node;
- ASSERT(obj != NULL, return -1;);
- ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
- ASSERT(attrib != NULL, return -1;);
+ IRDA_ASSERT(obj != NULL, return -1;);
+ IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
+ IRDA_ASSERT(attrib != NULL, return -1;);
/* Remove attribute from object */
node = hashbin_remove_this(obj->attribs, (irda_queue_t *) attrib);
*/
void irias_insert_object(struct ias_object *obj)
{
- ASSERT(obj != NULL, return;);
- ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+ IRDA_ASSERT(obj != NULL, return;);
+ IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
hashbin_insert(irias_objects, (irda_queue_t *) obj, 0, obj->name);
}
*/
struct ias_object *irias_find_object(char *name)
{
- ASSERT(name != NULL, return NULL;);
+ IRDA_ASSERT(name != NULL, return NULL;);
/* Unsafe (locking), object might change */
return hashbin_lock_find(irias_objects, 0, name);
{
struct ias_attrib *attrib;
- ASSERT(obj != NULL, return NULL;);
- ASSERT(obj->magic == IAS_OBJECT_MAGIC, return NULL;);
- ASSERT(name != NULL, return NULL;);
+ IRDA_ASSERT(obj != NULL, return NULL;);
+ IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return NULL;);
+ IRDA_ASSERT(name != NULL, return NULL;);
attrib = hashbin_lock_find(obj->attribs, 0, name);
if (attrib == NULL)
/* Unsafe (locking), attrib might change */
return attrib;
}
-EXPORT_SYMBOL(irias_find_attrib);
/*
* Function irias_add_attribute (obj, attrib)
* Add attribute to object
*
*/
-void irias_add_attrib( struct ias_object *obj, struct ias_attrib *attrib,
- int owner)
+static void irias_add_attrib(struct ias_object *obj, struct ias_attrib *attrib,
+ int owner)
{
- ASSERT(obj != NULL, return;);
- ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+ IRDA_ASSERT(obj != NULL, return;);
+ IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
- ASSERT(attrib != NULL, return;);
- ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
+ IRDA_ASSERT(attrib != NULL, return;);
+ IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
/* Set if attrib is owned by kernel or user space */
attrib->value->owner = owner;
/* Find object */
obj = hashbin_lock_find(irias_objects, 0, obj_name);
if (obj == NULL) {
- WARNING("%s: Unable to find object: %s\n", __FUNCTION__,
- obj_name);
+ IRDA_WARNING("%s: Unable to find object: %s\n", __FUNCTION__,
+ obj_name);
return -1;
}
/* Find attribute */
attrib = hashbin_find(obj->attribs, 0, attrib_name);
if (attrib == NULL) {
- WARNING("%s: Unable to find attribute: %s\n", __FUNCTION__,
- attrib_name);
+ IRDA_WARNING("%s: Unable to find attribute: %s\n",
+ __FUNCTION__, attrib_name);
spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
return -1;
}
{
struct ias_attrib *attrib;
- ASSERT(obj != NULL, return;);
- ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
- ASSERT(name != NULL, return;);
+ IRDA_ASSERT(obj != NULL, return;);
+ IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+ IRDA_ASSERT(name != NULL, return;);
- attrib = (struct ias_attrib *) kmalloc(sizeof(struct ias_attrib),
- GFP_ATOMIC);
+ attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
if (attrib == NULL) {
- WARNING("%s: Unable to allocate attribute!\n", __FUNCTION__);
+ IRDA_WARNING("%s: Unable to allocate attribute!\n",
+ __FUNCTION__);
return;
}
- memset(attrib, 0, sizeof( struct ias_attrib));
attrib->magic = IAS_ATTRIB_MAGIC;
attrib->name = strndup(name, IAS_MAX_ATTRIBNAME);
{
struct ias_attrib *attrib;
- ASSERT(obj != NULL, return;);
- ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+ IRDA_ASSERT(obj != NULL, return;);
+ IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
- ASSERT(name != NULL, return;);
- ASSERT(octets != NULL, return;);
+ IRDA_ASSERT(name != NULL, return;);
+ IRDA_ASSERT(octets != NULL, return;);
- attrib = (struct ias_attrib *) kmalloc(sizeof(struct ias_attrib),
- GFP_ATOMIC);
+ attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
if (attrib == NULL) {
- WARNING("%s: Unable to allocate attribute!\n", __FUNCTION__);
+ IRDA_WARNING("%s: Unable to allocate attribute!\n",
+ __FUNCTION__);
return;
}
- memset(attrib, 0, sizeof( struct ias_attrib));
attrib->magic = IAS_ATTRIB_MAGIC;
attrib->name = strndup(name, IAS_MAX_ATTRIBNAME);
{
struct ias_attrib *attrib;
- ASSERT(obj != NULL, return;);
- ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+ IRDA_ASSERT(obj != NULL, return;);
+ IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
- ASSERT(name != NULL, return;);
- ASSERT(value != NULL, return;);
+ IRDA_ASSERT(name != NULL, return;);
+ IRDA_ASSERT(value != NULL, return;);
- attrib = (struct ias_attrib *) kmalloc(sizeof( struct ias_attrib),
- GFP_ATOMIC);
+ attrib = kzalloc(sizeof( struct ias_attrib), GFP_ATOMIC);
if (attrib == NULL) {
- WARNING("%s: Unable to allocate attribute!\n", __FUNCTION__);
+ IRDA_WARNING("%s: Unable to allocate attribute!\n",
+ __FUNCTION__);
return;
}
- memset(attrib, 0, sizeof( struct ias_attrib));
attrib->magic = IAS_ATTRIB_MAGIC;
attrib->name = strndup(name, IAS_MAX_ATTRIBNAME);
{
struct ias_value *value;
- value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+ value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
if (value == NULL) {
- WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+ IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
return NULL;
}
- memset(value, 0, sizeof(struct ias_value));
value->type = IAS_INTEGER;
value->len = 4;
{
struct ias_value *value;
- value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+ value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
if (value == NULL) {
- WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+ IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
return NULL;
}
- memset( value, 0, sizeof( struct ias_value));
value->type = IAS_STRING;
value->charset = CS_ASCII;
return value;
}
-EXPORT_SYMBOL(irias_new_string_value);
/*
* Function irias_new_octseq_value (octets, len)
{
struct ias_value *value;
- value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+ value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
if (value == NULL) {
- WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+ IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
return NULL;
}
- memset(value, 0, sizeof(struct ias_value));
value->type = IAS_OCT_SEQ;
/* Check length */
len = IAS_MAX_OCTET_STRING;
value->len = len;
- value->t.oct_seq = kmalloc(len, GFP_ATOMIC);
+ value->t.oct_seq = kmemdup(octseq, len, GFP_ATOMIC);
if (value->t.oct_seq == NULL){
- WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+ IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
kfree(value);
return NULL;
}
- memcpy(value->t.oct_seq, octseq , len);
return value;
}
-EXPORT_SYMBOL(irias_new_octseq_value);
struct ias_value *irias_new_missing_value(void)
{
struct ias_value *value;
- value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+ value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
if (value == NULL) {
- WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+ IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
return NULL;
}
- memset(value, 0, sizeof(struct ias_value));
value->type = IAS_MISSING;
- value->len = 0;
return value;
}
{
IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
- ASSERT(value != NULL, return;);
+ IRDA_ASSERT(value != NULL, return;);
switch (value->type) {
case IAS_INTEGER: /* Fallthrough */
/* No need to deallocate */
break;
case IAS_STRING:
- /* If string, deallocate string */
- if (value->t.string != NULL)
- kfree(value->t.string);
+ /* Deallocate string */
+ kfree(value->t.string);
break;
case IAS_OCT_SEQ:
- /* If byte stream, deallocate byte stream */
- if (value->t.oct_seq != NULL)
- kfree(value->t.oct_seq);
+ /* Deallocate byte stream */
+ kfree(value->t.oct_seq);
break;
default:
IRDA_DEBUG(0, "%s(), Unknown value type!\n", __FUNCTION__);