Change the handling method of the offset length

Change-Id: I0581a9ca1c21d9f8ea9b44223cf998841bd2f943
Signed-off-by: saerome kim <saerome.kim@samsung.com>

diff --git a/lib/zbl_zcl.c b/lib/zbl_zcl.c
old mode 100755 (executable)
new mode 100644 (file)
index 7b75f10..26c6507
--- a/lib/zbl_zcl.c
+++ b/lib/zbl_zcl.c
@@ -13,6 +13,10 @@
 #include "zb_common.h"
 #include "zcl/zb_zcl_type.h"
 
+#define ZB_GUARD_CHAR 1
+#define ZB_ZCL_OCTAT_SIZE 1
+#define ZB_ZCL_LONG_OCTAT_SIZE 2
+
 API const char* zb_get_zcl_error_message(int id)
 {
        const char* status_name = NULL;
@@ -564,12 +568,12 @@ API int zb_get_value_from_read_attr_status_record(read_attr_status_record_h hand
                        free(v->str);
                        return ZIGBEE_ERROR_NO_DATA;
                }
-               v->str->v = calloc(v->str->n+1, 1);
+               v->str->v = calloc(v->str->n + ZB_GUARD_CHAR, sizeof(char));
                if (NULL == v->str->v) {
                        free(v->str);
                        return ZIGBEE_ERROR_OUT_OF_MEMORY;
                }
-               memcpy(v->str->v, h->value+sizeof(v->str->n), v->str->n);
+               memcpy(v->str->v, h->value + ZB_ZCL_OCTAT_SIZE, v->str->n);
 
                v->type = type;
                v->size = v->str->n;
@@ -587,12 +591,12 @@ API int zb_get_value_from_read_attr_status_record(read_attr_status_record_h hand
                        free(v->wstr);
                        return ZIGBEE_ERROR_NO_DATA;
                }
-               v->wstr->v = calloc(v->wstr->n+1, 1);
+               v->wstr->v = calloc(v->wstr->n + ZB_GUARD_CHAR, sizeof(char));
                if (NULL == v->wstr->v) {
                        free(v->wstr);
                        return ZIGBEE_ERROR_OUT_OF_MEMORY;
                }
-               memcpy(v->wstr->v, h->value+sizeof(v->wstr->n), v->wstr->n);
+               memcpy(v->wstr->v, h->value + ZB_ZCL_LONG_OCTAT_SIZE, v->wstr->n);
 
                v->type = type;
                v->size = v->wstr->n;
@@ -618,22 +622,22 @@ API int zb_set_value_to_read_attr_status_record(read_attr_status_record_h handle
 
        len = zb_get_data_size(type);
        if (0 < len) {
-               h->value = calloc(len, sizeof(char));
+               h->value = calloc(len + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                memcpy(h->value, v->val, len);
        } else if (ZB_ZCL_OCTAT_STRING == type || ZB_ZCL_CHRACTER_STRING == type) {
                RETV_IF(NULL == v->str, ZIGBEE_ERROR_NO_DATA);
-               h->value = calloc(v->str->n + sizeof(char), sizeof(char));
+               h->value = calloc(v->str->n + ZB_ZCL_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                h->value[0] = v->str->n;
-               memcpy(h->value + sizeof(char), v->str->v + sizeof(char), v->str->n);
+               memcpy(h->value + ZB_ZCL_OCTAT_SIZE, v->str->v + ZB_ZCL_OCTAT_SIZE, v->str->n);
        } else if (ZB_ZCL_LONG_OCTAT_STRING == type || ZB_ZCL_LONG_CHRACTER_STRING == type) {
                RETV_IF(NULL == v->wstr, ZIGBEE_ERROR_NO_DATA);
-               h->value = calloc(v->wstr->n + sizeof(short), sizeof(char));
+               h->value = calloc(v->wstr->n + ZB_ZCL_LONG_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                h->value[0] = v->wstr->n & 0xff;
                h->value[1] = (v->wstr->n >> 8) & 0xff ;
-               memcpy(h->value + sizeof(short), v->wstr->v + 2, v->wstr->n);
+               memcpy(h->value + ZB_ZCL_LONG_OCTAT_SIZE, v->wstr->v + ZB_ZCL_LONG_OCTAT_SIZE, v->wstr->n);
        } else
                return ZIGBEE_ERROR_NOT_SUPPORTED;
 
@@ -703,9 +707,9 @@ API int zb_set_value(zb_value_h handle, unsigned char type, unsigned char *value
                RETV_IF(NULL == h->str, ZIGBEE_ERROR_OUT_OF_MEMORY);
                h->str->n = count;
                /* The first 1 byte indicate invalid or length of string */
-               h->str->v = calloc(h->str->n + sizeof(h->str->n), sizeof(unsigned char));
+               h->str->v = calloc(h->str->n + ZB_ZCL_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == h->str->v, ZIGBEE_ERROR_OUT_OF_MEMORY);
-               memcpy(h->str->v, value+sizeof(h->str->n), h->str->n);
+               memcpy(h->str->v, value + ZB_ZCL_OCTAT_SIZE, h->str->n);
 
                h->type = type;
                h->size = count;
@@ -721,9 +725,9 @@ API int zb_set_value(zb_value_h handle, unsigned char type, unsigned char *value
                RETV_IF(NULL == h->wstr, ZIGBEE_ERROR_OUT_OF_MEMORY);
                h->wstr->n = count;
                /* The first 2 byte indicate invalid or length of string */
-               h->wstr->v = calloc(h->wstr->n + sizeof(h->wstr->n), sizeof(wchar_t));
+               h->wstr->v = calloc(h->wstr->n + ZB_ZCL_LONG_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(wchar_t));
                RETV_IF(NULL == h->wstr->v, ZIGBEE_ERROR_OUT_OF_MEMORY);
-               memcpy(h->wstr->v, value+sizeof(h->wstr->n), h->wstr->n);
+               memcpy(h->wstr->v, value + ZB_ZCL_LONG_OCTAT_SIZE, h->wstr->n);
 
                h->type = type;
                h->size = count;
@@ -746,21 +750,21 @@ API int zb_get_value(zb_value_h handle, unsigned char *type, unsigned char **val
 
        len = zb_get_data_size(h->type);
        if (0 < len) {
-               s = calloc(h->size + 1 , sizeof(char));
+               s = calloc(h->size + ZB_GUARD_CHAR , sizeof(char));
                RETV_IF(NULL == s, ZIGBEE_ERROR_OUT_OF_MEMORY);
                memcpy(s, h->val, len);
                *count = len;
        } else if (ZB_ZCL_OCTAT_STRING == h->type || ZB_ZCL_CHRACTER_STRING == h->type) {
                RETV_IF(NULL == h->str, ZIGBEE_ERROR_NO_DATA);
-               s = calloc(sizeof(char), h->str->n);
+               s = calloc(h->str->n + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == s, ZIGBEE_ERROR_OUT_OF_MEMORY);
-               memcpy(s, h->str->v + sizeof(char), h->str->n);
+               memcpy(s, h->str->v + ZB_ZCL_OCTAT_SIZE, h->str->n);
                *count = h->str->n;
        } else if (ZB_ZCL_LONG_OCTAT_STRING == h->type || ZB_ZCL_LONG_CHRACTER_STRING == h->type) {
                RETV_IF(NULL == h->wstr, ZIGBEE_ERROR_NO_DATA);
-               s = calloc(sizeof(char), h->wstr->n);
+               s = calloc(h->wstr->n + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == s, ZIGBEE_ERROR_OUT_OF_MEMORY);
-               memcpy(s, h->wstr->v + 2, h->wstr->n);
+               memcpy(s, h->wstr->v + ZB_ZCL_LONG_OCTAT_SIZE, h->wstr->n);
                *count = h->wstr->n;
        } else
                return ZIGBEE_ERROR_NOT_SUPPORTED;
@@ -914,22 +918,22 @@ API int zb_set_buf_to_write_attr_record(write_attr_record_h handle,
 
        len = zb_get_data_size(type);
        if (0 < len) {
-               h->value = calloc(count + 1 , sizeof(char));
+               h->value = calloc(count + ZB_GUARD_CHAR , sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                memcpy(h->value, value, count);
        } else if (ZB_ZCL_OCTAT_STRING == type || ZB_ZCL_CHRACTER_STRING == type) {
-               h->value = calloc(count + sizeof(unsigned char) + 1, sizeof(char));
+               h->value = calloc(count + ZB_ZCL_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                /* The first 1 byte indicate invalid or length of string */
                h->value[0] = count & 0xff;
-               memcpy(h->value + sizeof(unsigned char), value + sizeof(unsigned char), count);
+               memcpy(h->value + ZB_ZCL_OCTAT_SIZE, value + ZB_ZCL_OCTAT_SIZE, count);
        } else if (ZB_ZCL_LONG_OCTAT_STRING == h->type || ZB_ZCL_LONG_CHRACTER_STRING == h->type) {
-               h->value = calloc(count + sizeof(unsigned short)  + 1, sizeof(char));
+               h->value = calloc(count + ZB_ZCL_LONG_OCTAT_SIZE  + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                /* The first 2 byte indicate invalid or length of string */
                h->value[0] = count & 0xff;
                h->value[1] = (count >> 8) & 0xff ;
-               memcpy(h->value + sizeof(unsigned short), value + sizeof(unsigned short), count);
+               memcpy(h->value + ZB_ZCL_LONG_OCTAT_SIZE, value + ZB_ZCL_LONG_OCTAT_SIZE, count);
        } else
                return ZIGBEE_ERROR_NOT_SUPPORTED;
 
@@ -952,7 +956,7 @@ API int zb_set_value_to_write_attr_record(write_attr_record_h handle, zb_value_h
 
        len = zb_get_data_size(v->type);
        if (0 < len) {
-               h->value = calloc(v->size + 1 , sizeof(char));
+               h->value = calloc(v->size + ZB_GUARD_CHAR , sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                memcpy(h->value, v->val, v->size);
                h->type = v->type;
@@ -960,21 +964,21 @@ API int zb_set_value_to_write_attr_record(write_attr_record_h handle, zb_value_h
                RETV_IF(NULL == v->str, ZIGBEE_ERROR_NO_DATA);
                /* 1 byte string size exception case */
                RETV_IF(0xff - 1 < v->str->n, ZIGBEE_ERROR_PARAMETER_OUT_OF_RANGE);
-               h->value = calloc(v->str->n + sizeof(char), sizeof(char));
+               h->value = calloc(v->str->n + ZB_ZCL_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                /* The first 1 byte indicate invalid or length of string */
                h->value[0] = v->str->n & 0xff;
-               memcpy(h->value + sizeof(char), v->str->v + sizeof(char), v->str->n);
+               memcpy(h->value + ZB_ZCL_OCTAT_SIZE, v->str->v + ZB_ZCL_OCTAT_SIZE, v->str->n);
        } else if (ZB_ZCL_LONG_OCTAT_STRING == h->type || ZB_ZCL_LONG_CHRACTER_STRING == h->type) {
                RETV_IF(NULL == v->wstr, ZIGBEE_ERROR_NO_DATA);
                /* 2 byte string size exception case */
                RETV_IF(0xffff - 1 < v->wstr->n, ZIGBEE_ERROR_PARAMETER_OUT_OF_RANGE);
-               h->value = calloc(v->wstr->n + sizeof(short), sizeof(char));
+               h->value = calloc(v->wstr->n + ZB_ZCL_LONG_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                /* The first 2 byte indicate invalid or length of string */
                h->value[0] = v->wstr->n & 0xff;
                h->value[1] = (v->wstr->n >> 8) & 0xff ;
-               memcpy(h->value + sizeof(short), v->wstr->v + 2, v->wstr->n);
+               memcpy(h->value + ZB_ZCL_LONG_OCTAT_SIZE, v->wstr->v + ZB_ZCL_LONG_OCTAT_SIZE, v->wstr->n);
        } else
                return ZIGBEE_ERROR_NOT_SUPPORTED;
 
@@ -1661,12 +1665,12 @@ API int zb_get_value_from_attr_report(attr_report_h handle, zb_value_h value)
                        free(v->str);
                        return ZIGBEE_ERROR_NO_DATA;
                }
-               v->str->v = calloc(v->str->n+1, 1);
+               v->str->v = calloc(v->str->n + ZB_ZCL_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(char));
                if (NULL == v->str->v) {
                        free(v->str);
                        return ZIGBEE_ERROR_OUT_OF_MEMORY;
                }
-               memcpy(v->str->v, h->value+sizeof(v->str->n), v->str->n);
+               memcpy(v->str->v, h->value + ZB_ZCL_OCTAT_SIZE, v->str->n);
 
                v->type = h->type;
                v->size = v->str->n;
@@ -1684,12 +1688,12 @@ API int zb_get_value_from_attr_report(attr_report_h handle, zb_value_h value)
                        free(v->wstr);
                        return ZIGBEE_ERROR_NO_DATA;
                }
-               v->wstr->v = calloc(v->wstr->n+1, 1);
+               v->wstr->v = calloc(v->wstr->n + ZB_ZCL_LONG_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(char));
                if (NULL == v->wstr->v) {
                        free(v->wstr);
                        return ZIGBEE_ERROR_OUT_OF_MEMORY;
                }
-               memcpy(v->wstr->v, h->value+sizeof(v->wstr->n), v->wstr->n);
+               memcpy(v->wstr->v, h->value + ZB_ZCL_LONG_OCTAT_SIZE, v->wstr->n);
 
                v->type = h->type;
                v->size = v->wstr->n;
@@ -1716,25 +1720,25 @@ API int zb_set_value_to_attr_report(attr_report_h handle, zb_value_h value)
 
        len = zb_get_data_size(v->type);
        if (0 < len) {
-               h->value = calloc(v->size + 1 , sizeof(char));
+               h->value = calloc(v->size + ZB_GUARD_CHAR , sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                memcpy(h->value, v->val, v->size);
                h->type = v->type;
        } else if (ZB_ZCL_OCTAT_STRING == h->type || ZB_ZCL_CHRACTER_STRING == h->type) {
                RETV_IF(NULL == v->str, ZIGBEE_ERROR_NO_DATA);
-               h->value = calloc(v->str->n + sizeof(char), sizeof(char));
+               h->value = calloc(v->str->n + ZB_ZCL_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                /* The first 1 byte indicate invalid or length of string */
                h->value[0] = v->str->n & 0xff;
-               memcpy(h->value + sizeof(char), v->str->v + sizeof(char), v->str->n);
+               memcpy(h->value + ZB_ZCL_OCTAT_SIZE, v->str->v + ZB_ZCL_OCTAT_SIZE, v->str->n);
        } else if (ZB_ZCL_LONG_OCTAT_STRING == h->type || ZB_ZCL_LONG_CHRACTER_STRING == h->type) {
                RETV_IF(NULL == v->wstr, ZIGBEE_ERROR_NO_DATA);
-               h->value = calloc(v->wstr->n + sizeof(short), sizeof(char));
+               h->value = calloc(v->wstr->n + ZB_ZCL_LONG_OCTAT_SIZE + ZB_GUARD_CHAR, sizeof(char));
                RETV_IF(NULL == h->value, ZIGBEE_ERROR_OUT_OF_MEMORY);
                /* The first 2 byte indicate invalid or length of string */
                h->value[0] = v->wstr->n & 0xff;
                h->value[1] = (v->wstr->n >> 8) & 0xff ;
-               memcpy(h->value + sizeof(short), v->wstr->v + 2, v->wstr->n);
+               memcpy(h->value + ZB_ZCL_LONG_OCTAT_SIZE, v->wstr->v + ZB_ZCL_LONG_OCTAT_SIZE, v->wstr->n);
        } else
                return ZIGBEE_ERROR_NOT_SUPPORTED;