Merge git://oss.sgi.com:8090/xfs/xfs-2.6

[linux-drm-fsl-dcu.git] / net / irda / irias_object.c

diff --git a/net/irda/irias_object.c b/net/irda/irias_object.c
index 82e665c7999183b6300283370a1b463865bc5c7d..4adaae242b9e44b422b46f1fe3b4fd8422db1b0d 100644 (file)
--- a/net/irda/irias_object.c
+++ b/net/irda/irias_object.c
@@ -43,7 +43,7 @@ struct ias_value irias_missing = { IAS_MISSING, 0, 0, 0, {0}};
  *
  * 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;
@@ -57,8 +57,8 @@ static char *strndup(char *str, int max)
                len = max;
 
        /* Allocate new string */
-        new_str = kmalloc(len + 1, GFP_ATOMIC);
-        if (new_str == NULL) {
+       new_str = kmalloc(len + 1, GFP_ATOMIC);
+       if (new_str == NULL) {
                IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
@@ -78,20 +78,25 @@ static char *strndup(char *str, int max)
  */
 struct ias_object *irias_new_object( char *name, int id)
 {
-        struct ias_object *obj;
+       struct ias_object *obj;
 
        IRDA_DEBUG( 4, "%s()\n", __FUNCTION__);
 
-       obj = kmalloc(sizeof(struct ias_object), GFP_ATOMIC);
+       obj = kzalloc(sizeof(struct ias_object), GFP_ATOMIC);
        if (obj == NULL) {
                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);
+       if (!obj->name) {
+               IRDA_WARNING("%s(), Unable to allocate name!\n",
+                            __FUNCTION__);
+               kfree(obj);
+               return NULL;
+       }
        obj->id = id;
 
        /* Locking notes : the attrib spinlock has lower precendence
@@ -102,6 +107,7 @@ struct ias_object *irias_new_object( char *name, int id)
        if (obj->attribs == NULL) {
                IRDA_WARNING("%s(), Unable to allocate attribs!\n",
                             __FUNCTION__);
+               kfree(obj->name);
                kfree(obj);
                return NULL;
        }
@@ -346,19 +352,27 @@ void irias_add_integer_attrib(struct ias_object *obj, char *name, int value,
        IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
        IRDA_ASSERT(name != NULL, return;);
 
-       attrib = kmalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
+       attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
        if (attrib == NULL) {
                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);
 
        /* Insert value */
        attrib->value = irias_new_integer_value(value);
+       if (!attrib->name || !attrib->value) {
+               IRDA_WARNING("%s: Unable to allocate attribute!\n",
+                            __FUNCTION__);
+               if (attrib->value)
+                       irias_delete_value(attrib->value);
+               kfree(attrib->name);
+               kfree(attrib);
+               return;
+       }
 
        irias_add_attrib(obj, attrib, owner);
 }
@@ -382,18 +396,26 @@ void irias_add_octseq_attrib(struct ias_object *obj, char *name, __u8 *octets,
        IRDA_ASSERT(name != NULL, return;);
        IRDA_ASSERT(octets != NULL, return;);
 
-       attrib = kmalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
+       attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
        if (attrib == NULL) {
                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);
 
        attrib->value = irias_new_octseq_value( octets, len);
+       if (!attrib->name || !attrib->value) {
+               IRDA_WARNING("%s: Unable to allocate attribute!\n",
+                            __FUNCTION__);
+               if (attrib->value)
+                       irias_delete_value(attrib->value);
+               kfree(attrib->name);
+               kfree(attrib);
+               return;
+       }
 
        irias_add_attrib(obj, attrib, owner);
 }
@@ -416,18 +438,26 @@ void irias_add_string_attrib(struct ias_object *obj, char *name, char *value,
        IRDA_ASSERT(name != NULL, return;);
        IRDA_ASSERT(value != NULL, return;);
 
-       attrib = kmalloc(sizeof( struct ias_attrib), GFP_ATOMIC);
+       attrib = kzalloc(sizeof( struct ias_attrib), GFP_ATOMIC);
        if (attrib == NULL) {
                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);
 
        attrib->value = irias_new_string_value(value);
+       if (!attrib->name || !attrib->value) {
+               IRDA_WARNING("%s: Unable to allocate attribute!\n",
+                            __FUNCTION__);
+               if (attrib->value)
+                       irias_delete_value(attrib->value);
+               kfree(attrib->name);
+               kfree(attrib);
+               return;
+       }
 
        irias_add_attrib(obj, attrib, owner);
 }
@@ -443,12 +473,11 @@ struct ias_value *irias_new_integer_value(int integer)
 {
        struct ias_value *value;
 
-       value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+       value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
        if (value == NULL) {
                IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
-       memset(value, 0, sizeof(struct ias_value));
 
        value->type = IAS_INTEGER;
        value->len = 4;
@@ -469,16 +498,21 @@ struct ias_value *irias_new_string_value(char *string)
 {
        struct ias_value *value;
 
-       value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+       value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
        if (value == NULL) {
                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;
        value->t.string = strndup(string, IAS_MAX_STRING);
+       if (!value->t.string) {
+               IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+               kfree(value);
+               return NULL;
+       }
+
        value->len = strlen(value->t.string);
 
        return value;
@@ -495,12 +529,11 @@ struct ias_value *irias_new_octseq_value(__u8 *octseq , int len)
 {
        struct ias_value *value;
 
-       value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
+       value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
        if (value == NULL) {
                IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
-       memset(value, 0, sizeof(struct ias_value));
 
        value->type = IAS_OCT_SEQ;
        /* Check length */
@@ -508,13 +541,12 @@ struct ias_value *irias_new_octseq_value(__u8 *octseq , int len)
                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){
                IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
                kfree(value);
                return NULL;
        }
-       memcpy(value->t.oct_seq, octseq , len);
        return value;
 }
 
@@ -522,15 +554,13 @@ 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) {
                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;
 }