Dynamically allocate characteristic and descriptor data buffers

sandeepmistry · sandeepmistry · commit c6924337ea3c · 2015-12-04T12:14:39.000-05:00
diff --git a/libraries/CurieBle/src/BLECharacteristic.cpp b/libraries/CurieBle/src/BLECharacteristic.cpp
@@ -28,15 +28,16 @@ BLECharacteristic::BLECharacteristic(const char* uuid,
                       const unsigned short maxLength) :
     BLEAttribute(uuid, BLETypeCharacteristic),
     _properties(properties),
-    _data_len(0),
+    _value_length(0),
     _written(false),
     _cccd_value(0),
     _value_handle(0),
     _cccd_handle(0),
     _user_description(NULL),
     _presentation_format(NULL)
 {
-    _max_len = maxLength > BLE_MAX_ATTR_DATA_LEN ? BLE_MAX_ATTR_DATA_LEN : maxLength;
+    _value_size = maxLength > BLE_MAX_ATTR_DATA_LEN ? BLE_MAX_ATTR_DATA_LEN : maxLength;
+    _value = (unsigned char*)malloc(_value_length);
 
     memset(_event_handlers, 0, sizeof(_event_handlers));
 }
@@ -49,6 +50,14 @@ BLECharacteristic::BLECharacteristic(const char* uuid,
     setValue((const uint8_t*)value, strlen(value));
 }
 
+BLECharacteristic::~BLECharacteristic()
+{
+    if (_value) {
+        free(_value);
+        _value = NULL;
+    }
+}
+
 unsigned char
 BLECharacteristic::properties() const
 {
@@ -63,15 +72,15 @@ BLECharacteristic::setValue(const unsigned char value[], uint16_t length)
      _setValue(value, length);
 
     if (_value_handle) {
-        status = ble_client_gatts_set_attribute_value(_value_handle, _data_len, _data, 0);
+        status = ble_client_gatts_set_attribute_value(_value_handle, _value_length, _value, 0);
         if (BLE_STATUS_SUCCESS != status) {
             return false;
         }
 
         if (subscribed()) {
             boolean_t indication = (_cccd_value & BLE_CCCD_INDICATE_EN_MASK);
 
-            status = ble_client_gatts_send_notif_ind(_value_handle, _data_len, _data, 0, indication);
+            status = ble_client_gatts_send_notif_ind(_value_handle, _value_length, _value, 0, indication);
             if (BLE_STATUS_SUCCESS != status) {
                 return false;
             }
@@ -96,25 +105,25 @@ BLECharacteristic::setValue(BLECentral& central, const unsigned char* value, uns
 unsigned short
 BLECharacteristic::valueSize() const
 {
-    return _max_len;
+    return _value_size;
 }
 
 const unsigned char*
 BLECharacteristic::value() const
 {
-    return _data;
+    return _value;
 }
 
 unsigned short
 BLECharacteristic::valueLength() const
 {
-    return _data_len;
+    return _value_length;
 }
 
 unsigned char
 BLECharacteristic::operator[] (int offset) const
 {
-    return _data[offset];
+    return _value[offset];
 }
 
 bool
@@ -170,9 +179,9 @@ BLECharacteristic::add(uint16_t serviceHandle)
         char_data.perms.rd = GAP_SEC_NO_PERMISSION;
     }
 
-    char_data.init_len = _data_len;
-    char_data.max_len = _max_len;
-    char_data.p_value = _data;
+    char_data.init_len = _value_length;
+    char_data.max_len = _value_size;
+    char_data.p_value = _value;
 
     if (_user_description) {
         user_desc.buffer = (uint8_t*)_user_description->value();
@@ -247,10 +256,10 @@ BLECharacteristic::setPresentationFormat(BLEDescriptor *descriptor)
 void
 BLECharacteristic::_setValue(const uint8_t value[], uint16_t length)
 {
-    if (length > _max_len) {
-        length = _max_len;
+    if (length > _value_size) {
+        length = _value_size;
     }
 
-    memcpy(_data, value, length);
-    _data_len = length;
+    memcpy(_value, value, length);
+    _value_length = length;
 }
diff --git a/libraries/CurieBle/src/BLECharacteristic.h b/libraries/CurieBle/src/BLECharacteristic.h
@@ -81,6 +81,8 @@ class BLECharacteristic : public BLEAttribute {
                       const unsigned char properties,
                       const char* value);
 
+    virtual ~BLECharacteristic();
+
     /**
      * Set the current value of the Characteristic
      *
@@ -100,7 +102,7 @@ class BLECharacteristic : public BLEAttribute {
     unsigned char properties(void) const;
 
     /**
-     * Get the size of the Characteristic
+     * Get the (maximum) size of the Characteristic
      *
      * @return unsigned size of characateristic in bytes
      */
@@ -114,7 +116,7 @@ class BLECharacteristic : public BLEAttribute {
     const unsigned char* value(void) const;
 
     /**
-     * Get the length of the value of the Characteristic
+     * Get the current length of the value of the Characteristic
      *
      * @return unsigned short size of characateristic value in bytes
      */
@@ -164,9 +166,9 @@ class BLECharacteristic : public BLEAttribute {
 
 private:
     unsigned char _properties;
-    unsigned short _max_len;
-    unsigned char  _data[BLE_MAX_ATTR_DATA_LEN];
-    unsigned short _data_len;
+    unsigned short _value_size;
+    unsigned short _value_length;
+    unsigned char* _value;
     bool _written;
 
     uint16_t _cccd_value;
diff --git a/libraries/CurieBle/src/BLEDescriptor.cpp b/libraries/CurieBle/src/BLEDescriptor.cpp
@@ -27,9 +27,17 @@ BLEDescriptor::BLEDescriptor(const char* uuid, const unsigned char value[], unsi
     if (valueLength > BLE_MAX_ATTR_DATA_LEN) {
         valueLength = BLE_MAX_ATTR_DATA_LEN;
     }
-    _data_len = valueLength;
+    _value_length = valueLength;
+    _value = (unsigned char*)malloc(_value_length);
 
-    memcpy(_data, value, _data_len);
+    memcpy(_value, value, _value_length);
+}
+
+BLEDescriptor::~BLEDescriptor() {
+    if (_value) {
+        free(_value);
+        _value = NULL;
+    }
 }
 
 BLEDescriptor::BLEDescriptor(const char* uuid, const char* value) :
@@ -40,19 +48,19 @@ BLEDescriptor::BLEDescriptor(const char* uuid, const char* value) :
 const unsigned char*
 BLEDescriptor::BLEDescriptor::value() const
 {
-    return _data;
+    return _value;
 }
 
 unsigned short
 BLEDescriptor::valueLength() const
 {
-    return _data_len;
+    return _value_length;
 }
 
 unsigned char
 BLEDescriptor::operator[] (int offset) const
 {
-    return _data[offset];
+    return _value[offset];
 }
 
 bool
@@ -66,8 +74,8 @@ BLEDescriptor::add(uint16_t serviceHandle)
 
     desc.p_uuid = &uuid;
 
-    desc.p_value = _data;
-    desc.length = _data_len;
+    desc.p_value = _value;
+    desc.length = _value_length;
 
     // this class only supports read-only descriptors
     desc.perms.rd = GAP_SEC_MODE_1 | GAP_SEC_LEVEL_1;
diff --git a/libraries/CurieBle/src/BLEDescriptor.h b/libraries/CurieBle/src/BLEDescriptor.h
@@ -36,6 +36,8 @@ class BLEDescriptor : public BLEAttribute {
      */
     BLEDescriptor(const char* uuid, const unsigned char value[], unsigned short valueLength);
 
+    virtual ~BLEDescriptor();
+
     /**
      * Constructor for BLE Descriptor
      *
@@ -68,8 +70,8 @@ class BLEDescriptor : public BLEAttribute {
     friend BLEPeripheral;
 
 private:
-    uint8_t _data[BLE_MAX_ATTR_DATA_LEN];
-    uint16_t _data_len;
+    unsigned short _value_length;
+    unsigned char* _value;
 };
 
 #endif // _BLE_DESCRIPTOR_H_INCLUDED

Original file line number	Diff line number	Diff line change
`@@ -28,15 +28,16 @@ BLECharacteristic::BLECharacteristic(const char* uuid,`
`28`	`28`	`const unsigned short maxLength) :`
`29`	`29`	`BLEAttribute(uuid, BLETypeCharacteristic),`
`30`	`30`	`_properties(properties),`
`31`		`- _data_len(0),`
	`31`	`+ _value_length(0),`
`32`	`32`	`_written(false),`
`33`	`33`	`_cccd_value(0),`
`34`	`34`	`_value_handle(0),`
`35`	`35`	`_cccd_handle(0),`
`36`	`36`	`_user_description(NULL),`
`37`	`37`	`_presentation_format(NULL)`
`38`	`38`	`{`
`39`		`- _max_len = maxLength > BLE_MAX_ATTR_DATA_LEN ? BLE_MAX_ATTR_DATA_LEN : maxLength;`
	`39`	`+ _value_size = maxLength > BLE_MAX_ATTR_DATA_LEN ? BLE_MAX_ATTR_DATA_LEN : maxLength;`
	`40`	`+ _value = (unsigned char*)malloc(_value_length);`
`40`	`41`
`41`	`42`	`memset(_event_handlers, 0, sizeof(_event_handlers));`
`42`	`43`	`}`
`@@ -49,6 +50,14 @@ BLECharacteristic::BLECharacteristic(const char* uuid,`
`49`	`50`	`setValue((const uint8_t*)value, strlen(value));`
`50`	`51`	`}`
`51`	`52`
	`53`	`+BLECharacteristic::~BLECharacteristic()`
	`54`	`+{`
	`55`	`+ if (_value) {`
	`56`	`+ free(_value);`
	`57`	`+ _value = NULL;`
	`58`	`+ }`
	`59`	`+}`
	`60`	`+`
`52`	`61`	`unsigned char`
`53`	`62`	`BLECharacteristic::properties() const`
`54`	`63`	`{`
`@@ -63,15 +72,15 @@ BLECharacteristic::setValue(const unsigned char value[], uint16_t length)`
`63`	`72`	`_setValue(value, length);`
`64`	`73`
`65`	`74`	`if (_value_handle) {`
`66`		`- status = ble_client_gatts_set_attribute_value(_value_handle, _data_len, _data, 0);`
	`75`	`+ status = ble_client_gatts_set_attribute_value(_value_handle, _value_length, _value, 0);`
`67`	`76`	`if (BLE_STATUS_SUCCESS != status) {`
`68`	`77`	`return false;`
`69`	`78`	`}`
`70`	`79`
`71`	`80`	`if (subscribed()) {`
`72`	`81`	`boolean_t indication = (_cccd_value & BLE_CCCD_INDICATE_EN_MASK);`
`73`	`82`
`74`		`- status = ble_client_gatts_send_notif_ind(_value_handle, _data_len, _data, 0, indication);`
	`83`	`+ status = ble_client_gatts_send_notif_ind(_value_handle, _value_length, _value, 0, indication);`
`75`	`84`	`if (BLE_STATUS_SUCCESS != status) {`
`76`	`85`	`return false;`
`77`	`86`	`}`
`@@ -96,25 +105,25 @@ BLECharacteristic::setValue(BLECentral& central, const unsigned char* value, uns`
`96`	`105`	`unsigned short`
`97`	`106`	`BLECharacteristic::valueSize() const`
`98`	`107`	`{`
`99`		`- return _max_len;`
	`108`	`+ return _value_size;`
`100`	`109`	`}`
`101`	`110`
`102`	`111`	`const unsigned char*`
`103`	`112`	`BLECharacteristic::value() const`
`104`	`113`	`{`
`105`		`- return _data;`
	`114`	`+ return _value;`
`106`	`115`	`}`
`107`	`116`
`108`	`117`	`unsigned short`
`109`	`118`	`BLECharacteristic::valueLength() const`
`110`	`119`	`{`
`111`		`- return _data_len;`
	`120`	`+ return _value_length;`
`112`	`121`	`}`
`113`	`122`
`114`	`123`	`unsigned char`
`115`	`124`	`BLECharacteristic::operator[] (int offset) const`
`116`	`125`	`{`
`117`		`- return _data[offset];`
	`126`	`+ return _value[offset];`
`118`	`127`	`}`
`119`	`128`
`120`	`129`	`bool`
`@@ -170,9 +179,9 @@ BLECharacteristic::add(uint16_t serviceHandle)`
`170`	`179`	`char_data.perms.rd = GAP_SEC_NO_PERMISSION;`
`171`	`180`	`}`
`172`	`181`
`173`		`- char_data.init_len = _data_len;`
`174`		`- char_data.max_len = _max_len;`
`175`		`- char_data.p_value = _data;`
	`182`	`+ char_data.init_len = _value_length;`
	`183`	`+ char_data.max_len = _value_size;`
	`184`	`+ char_data.p_value = _value;`
`176`	`185`
`177`	`186`	`if (_user_description) {`
`178`	`187`	`user_desc.buffer = (uint8_t*)_user_description->value();`
`@@ -247,10 +256,10 @@ BLECharacteristic::setPresentationFormat(BLEDescriptor *descriptor)`
`247`	`256`	`void`
`248`	`257`	`BLECharacteristic::_setValue(const uint8_t value[], uint16_t length)`
`249`	`258`	`{`
`250`		`- if (length > _max_len) {`
`251`		`- length = _max_len;`
	`259`	`+ if (length > _value_size) {`
	`260`	`+ length = _value_size;`
`252`	`261`	`}`
`253`	`262`
`254`		`- memcpy(_data, value, length);`
`255`		`- _data_len = length;`
	`263`	`+ memcpy(_value, value, length);`
	`264`	`+ _value_length = length;`
`256`	`265`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,9 +27,17 @@ BLEDescriptor::BLEDescriptor(const char* uuid, const unsigned char value[], unsi`
`27`	`27`	`if (valueLength > BLE_MAX_ATTR_DATA_LEN) {`
`28`	`28`	`valueLength = BLE_MAX_ATTR_DATA_LEN;`
`29`	`29`	`}`
`30`		`- _data_len = valueLength;`
	`30`	`+ _value_length = valueLength;`
	`31`	`+ _value = (unsigned char*)malloc(_value_length);`
`31`	`32`
`32`		`- memcpy(_data, value, _data_len);`
	`33`	`+ memcpy(_value, value, _value_length);`
	`34`	`+}`
	`35`	`+`
	`36`	`+BLEDescriptor::~BLEDescriptor() {`
	`37`	`+ if (_value) {`
	`38`	`+ free(_value);`
	`39`	`+ _value = NULL;`
	`40`	`+ }`
`33`	`41`	`}`
`34`	`42`
`35`	`43`	`BLEDescriptor::BLEDescriptor(const char* uuid, const char* value) :`
`@@ -40,19 +48,19 @@ BLEDescriptor::BLEDescriptor(const char* uuid, const char* value) :`
`40`	`48`	`const unsigned char*`
`41`	`49`	`BLEDescriptor::BLEDescriptor::value() const`
`42`	`50`	`{`
`43`		`- return _data;`
	`51`	`+ return _value;`
`44`	`52`	`}`
`45`	`53`
`46`	`54`	`unsigned short`
`47`	`55`	`BLEDescriptor::valueLength() const`
`48`	`56`	`{`
`49`		`- return _data_len;`
	`57`	`+ return _value_length;`
`50`	`58`	`}`
`51`	`59`
`52`	`60`	`unsigned char`
`53`	`61`	`BLEDescriptor::operator[] (int offset) const`
`54`	`62`	`{`
`55`		`- return _data[offset];`
	`63`	`+ return _value[offset];`
`56`	`64`	`}`
`57`	`65`
`58`	`66`	`bool`
`@@ -66,8 +74,8 @@ BLEDescriptor::add(uint16_t serviceHandle)`
`66`	`74`
`67`	`75`	`desc.p_uuid = &uuid;`
`68`	`76`
`69`		`- desc.p_value = _data;`
`70`		`- desc.length = _data_len;`
	`77`	`+ desc.p_value = _value;`
	`78`	`+ desc.length = _value_length;`
`71`	`79`
`72`	`80`	`// this class only supports read-only descriptors`
`73`	`81`	`desc.perms.rd = GAP_SEC_MODE_1 \| GAP_SEC_LEVEL_1;`