Skip to content

Commit 911be95

Browse files
Xie,Qisgbihu
Xie,Qi
authored and
sgbihu
committed
fix KW issue for class BLEDescriptor, BLECharacteristic and port.c
1 parent e57cd86 commit 911be95

File tree

16 files changed

+265
-100
lines changed

16 files changed

+265
-100
lines changed

‎libraries/BLE/src/BLECharacteristic.cpp

Lines changed: 48 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -10,22 +10,23 @@
1010

1111
BLECharacteristic::BLECharacteristic():
1212
_bledev(), _internal(NULL), _properties(0),
13-
_value_size(0), _value(NULL),_event_handlers(NULL)
13+
_value_size(0), _value(NULL)
1414
{
1515
memset(_uuid_cstr, 0, sizeof(_uuid_cstr));
16+
memset(_event_handlers, 0, sizeof(_event_handlers));
1617
}
1718

1819
BLECharacteristic::BLECharacteristic(const char* uuid,
1920
unsigned char properties,
2021
unsigned short valueSize):
21-
_bledev(), _internal(NULL), _properties(properties), _value(NULL),
22-
_event_handlers(NULL)
22+
_bledev(), _internal(NULL), _properties(properties), _value(NULL)
2323
{
2424
bt_uuid_128 bt_uuid_tmp;
2525
_value_size = valueSize > BLE_MAX_ATTR_LONGDATA_LEN ? BLE_MAX_ATTR_LONGDATA_LEN : valueSize;
2626
BLEUtils::uuidString2BT(uuid, (bt_uuid_t *)&bt_uuid_tmp);
2727
BLEUtils::uuidBT2String((const bt_uuid_t *)&bt_uuid_tmp, _uuid_cstr);
2828
_bledev.setAddress(*BLEUtils::bleGetLoalAddress());
29+
memset(_event_handlers, 0, sizeof(_event_handlers));
2930
}
3031

3132
BLECharacteristic::BLECharacteristic(const char* uuid,
@@ -39,25 +40,60 @@ BLECharacteristic::BLECharacteristic(const char* uuid,
3940
BLECharacteristic::BLECharacteristic(BLECharacteristicImp *characteristicImp,
4041
const BLEDevice *bleDev):
4142
_bledev(bleDev), _internal(characteristicImp),
42-
_value(NULL),_event_handlers(NULL)
43+
_value(NULL)
4344
{
4445
BLEUtils::uuidBT2String(characteristicImp->bt_uuid(), _uuid_cstr);
4546
_properties = characteristicImp->properties();
4647
_value_size = characteristicImp->valueSize();
48+
memset(_event_handlers, 0, sizeof(_event_handlers));
49+
}
50+
51+
BLECharacteristic::BLECharacteristic(const BLECharacteristic& rhs)
52+
{
53+
_value = (unsigned char*)malloc(rhs._value_size); // Sid. KW: _value should not make local here
54+
if (_value) {
55+
memcpy(_value, rhs._value, rhs._value_size);
56+
_value_size = rhs._value_size;
57+
} else {
58+
_value_size = 0;
59+
}
60+
memcpy(_uuid_cstr, rhs._uuid_cstr, sizeof(_uuid_cstr));
61+
_properties = rhs._properties;
62+
memcpy(_event_handlers, rhs._event_handlers, sizeof(_event_handlers));
63+
_internal = rhs._internal;
64+
_bledev = BLEDevice(&rhs._bledev);
65+
}
66+
67+
BLECharacteristic& BLECharacteristic::operator= (const BLECharacteristic& rhs)
68+
{
69+
if (this != &rhs)
70+
{
71+
if (_value)
72+
{
73+
free(_value);
74+
}
75+
_value = (unsigned char*)malloc(rhs._value_size);
76+
if (_value)
77+
{
78+
memcpy(_value, rhs._value, rhs._value_size);
79+
_value_size = rhs._value_size;
80+
} else {
81+
_value_size = 0;
82+
}
83+
memcpy(_uuid_cstr, rhs._uuid_cstr, sizeof(_uuid_cstr));
84+
_properties = rhs._properties;
85+
memcpy(_event_handlers, rhs._event_handlers, sizeof(_event_handlers));
86+
_internal = rhs._internal;
87+
_bledev = BLEDevice(&rhs._bledev);
88+
}
89+
return *this;
4790
}
4891

4992
BLECharacteristic::~BLECharacteristic()
5093
{
5194
if (_value)
5295
{
5396
free(_value);
54-
_value = NULL;
55-
}
56-
57-
if (_event_handlers != NULL)
58-
{
59-
free(_event_handlers);
60-
_event_handlers = NULL;
6197
}
6298
}
6399

@@ -433,15 +469,7 @@ void BLECharacteristic::setEventHandler(BLECharacteristicEvent event,
433469
}
434470
else
435471
{
436-
if (_event_handlers == NULL)
437-
{
438-
_event_handlers = (BLECharacteristicEventHandler*)malloc(sizeof(BLECharacteristicEventHandler) * BLECharacteristicEventLast);
439-
}
440-
441-
if (_event_handlers != NULL)
442-
{
443-
_event_handlers[event] = eventHandler;
444-
}
472+
_event_handlers[event] = eventHandler;
445473
}
446474
}
447475

‎libraries/BLE/src/BLECharacteristic.h

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -84,6 +84,10 @@ class BLECharacteristic: public BLEAttributeWithValue
8484
unsigned char properties,
8585
const char* value);
8686

87+
BLECharacteristic(const BLECharacteristic&);
88+
89+
BLECharacteristic& operator=(const BLECharacteristic&);
90+
8791
virtual ~BLECharacteristic();
8892

8993
/**
@@ -518,7 +522,7 @@ class BLECharacteristic: public BLEAttributeWithValue
518522
unsigned short _value_size; // The value size
519523
unsigned char* _value; // The value. Will delete after create the _internal
520524

521-
BLECharacteristicEventHandler* _event_handlers;
525+
BLECharacteristicEventHandler _event_handlers[BLECharacteristicEventLast]; // Sid. Define the arr as in BLECharacteristicImp.h
522526
};
523527

524528
#endif

‎libraries/BLE/src/BLEDescriptor.cpp

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -66,6 +66,41 @@ BLEDescriptor::BLEDescriptor(const char* uuid,
6666
BLEDescriptor(uuid, (const unsigned char*)value, strlen(value))
6767
{}
6868

69+
BLEDescriptor::BLEDescriptor(const BLEDescriptor& rhs)
70+
{
71+
_value = (unsigned char*)malloc(rhs._value_size); // Sid. KW: allocate memory for _value, not local
72+
if (_value) {
73+
memcpy(_value, rhs._value, rhs._value_size);
74+
_value_size = rhs._value_size;
75+
} else {
76+
_value_size = 0;
77+
}
78+
memcpy(_uuid_cstr, rhs._uuid_cstr, sizeof(_uuid_cstr));
79+
_properties = rhs._properties;
80+
_bledev = BLEDevice(&rhs._bledev);
81+
}
82+
83+
BLEDescriptor& BLEDescriptor::operator= (const BLEDescriptor& rhs)
84+
{
85+
if (this != &rhs)
86+
{
87+
if (_value)
88+
{
89+
free(_value);
90+
}
91+
_value = (unsigned char*)malloc(rhs._value_size);
92+
if (_value)
93+
{
94+
memcpy(_value, rhs._value, rhs._value_size);
95+
_value_size = rhs._value_size;
96+
memcpy(_uuid_cstr, rhs._uuid_cstr, sizeof(_uuid_cstr));
97+
_properties = rhs._properties;
98+
_bledev = BLEDevice(&rhs._bledev);
99+
}
100+
}
101+
return *this;
102+
}
103+
69104
BLEDescriptor::~BLEDescriptor()
70105
{
71106
if (_value)

‎libraries/BLE/src/BLEDescriptor.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,8 @@ class BLEDescriptor
3232
BLEDescriptor(const char* uuid, const char* value); // create a descriptor the specified uuid and string value
3333

3434
BLEDescriptor(BLEDescriptorImp* descriptorImp, const BLEDevice *bleDev);
35+
BLEDescriptor(const BLEDescriptor&);
36+
BLEDescriptor& operator=(const BLEDescriptor&);
3537

3638
virtual ~BLEDescriptor();
3739

‎libraries/BLE/src/internal/BLECallbacks.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -137,7 +137,8 @@ uint8_t profile_read_rsp_process(bt_conn_t *conn,
137137
// Get characteristic by handle params->single.handle
138138
chrc = BLEProfileManager::instance()->characteristic(bleDevice, params->single.handle);
139139

140-
chrc->setValue((const unsigned char *)data, length);
140+
if (chrc) // KW issue: may be NULL and will be dereferenced
141+
chrc->setValue((const unsigned char *)data, length);
141142
pr_debug(LOG_MODULE_BLE, "%s-%d", __FUNCTION__, __LINE__);
142143
return BT_GATT_ITER_STOP;
143144
}

‎libraries/BLE/src/internal/BLECharacteristicImp.cpp

Lines changed: 24 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -44,12 +44,15 @@ BLECharacteristicImp::BLECharacteristicImp(const bt_uuid_t* uuid,
4444
{
4545
_value_size = BLE_MAX_ATTR_DATA_LEN;// Set as MAX value. TODO: long read/write need to twist
4646
_value = (unsigned char*)malloc(_value_size);
47-
if (_value_size > BLE_MAX_ATTR_DATA_LEN)
48-
{
49-
_value_buffer = (unsigned char*)malloc(_value_size);
50-
}
51-
52-
memset(_value, 0, _value_size);
47+
48+
// TODO: Enable when max value is not set.
49+
// if (_value_size > BLE_MAX_ATTR_DATA_LEN)
50+
// {
51+
// _value_buffer = (unsigned char*)malloc(_value_size);
52+
// }
53+
54+
if (_value)
55+
memset(_value, 0, _value_size);
5356

5457
memset(&_ccc_cfg, 0, sizeof(_ccc_cfg));
5558
memset(&_ccc_value, 0, sizeof(_ccc_value));
@@ -144,16 +147,8 @@ BLECharacteristicImp::BLECharacteristicImp(BLECharacteristic& characteristic,
144147
_sub_params.value |= BT_GATT_CCC_INDICATE;
145148
}
146149
_gatt_chrc.uuid = (bt_uuid_t*)this->bt_uuid();//&_characteristic_uuid;//this->uuid();
147-
if (NULL != characteristic._event_handlers)
148-
{
149-
memcpy(_event_handlers,
150-
characteristic._event_handlers,
151-
sizeof(_event_handlers));
152-
}
153-
else
154-
{
155-
memset(_event_handlers, 0, sizeof(_event_handlers));
156-
}
150+
151+
memcpy(_event_handlers, characteristic._event_handlers, sizeof(_event_handlers));
157152

158153
_sub_params.notify = profile_notify_process;
159154

@@ -174,12 +169,12 @@ BLECharacteristicImp::~BLECharacteristicImp()
174169
releaseDescriptors();
175170
if (_value) {
176171
free(_value);
177-
_value = NULL;
172+
_value = (unsigned char *)NULL;
178173
}
179174
if (_value_buffer)
180175
{
181176
free(_value_buffer);
182-
_value_buffer = NULL;
177+
_value_buffer = (unsigned char *)NULL;
183178
}
184179
}
185180

@@ -203,10 +198,11 @@ bool BLECharacteristicImp::writeValue(const byte value[], int length)
203198
{
204199
// Notify for peripheral.
205200
status = bt_gatt_notify(NULL, _attr_chrc_value, value, length, NULL);
206-
if (0 == status)
207-
{
201+
// Sid. KW found status is always 0
202+
// if (!status)
203+
// {
208204
retVal = true;
209-
}
205+
// }
210206
}
211207

212208
//Not schedule write request for central
@@ -229,10 +225,11 @@ bool BLECharacteristicImp::writeValue(const byte value[], int length, int offset
229225
{
230226
// Notify for peripheral.
231227
status = bt_gatt_notify(NULL, _attr_chrc_value, value, length, NULL);
232-
if (0 == status)
233-
{
228+
// Sid. KW found status is always 0.
229+
// if (!status)
230+
// {
234231
retVal = true;
235-
}
232+
// }
236233
}
237234

238235
//Not schedule write request for central
@@ -612,7 +609,8 @@ void BLECharacteristicImp::setBuffer(const uint8_t value[],
612609
uint16_t length,
613610
uint16_t offset)
614611
{
615-
if (length + offset > _value_size) {
612+
if ((length + offset > _value_size) ||
613+
((unsigned char *)NULL == _value_buffer)) {
616614
// Ignore the data
617615
return;
618616
}
@@ -627,6 +625,7 @@ void BLECharacteristicImp::syncupBuffer2Value()
627625

628626
void BLECharacteristicImp::discardBuffer()
629627
{
628+
if(_value_buffer)
630629
memcpy(_value_buffer, _value, _value_size);
631630
}
632631

‎libraries/BLE/src/internal/BLEDescriptorImp.cpp

Lines changed: 51 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,10 @@ BLEDescriptorImp::BLEDescriptorImp(BLEDevice& bledevice,
3434
_value_length = descriptor.valueLength();
3535
_value = (unsigned char*)malloc(_value_length);
3636

37-
memcpy(_value, descriptor.value(), _value_length);
37+
if (_value)
38+
memcpy(_value, descriptor.value(), _value_length);
39+
else
40+
_value_length = 0;
3841
}
3942

4043
BLEDescriptorImp::BLEDescriptorImp(const bt_uuid_t* uuid,
@@ -48,13 +51,57 @@ BLEDescriptorImp::BLEDescriptorImp(const bt_uuid_t* uuid,
4851
_value_length = BLE_MAX_ATTR_DATA_LEN;
4952
_value = (unsigned char*)malloc(_value_length);
5053

51-
memset(_value, 0, _value_length);
54+
if (_value)
55+
memset(_value, 0, _value_length);
56+
else
57+
_value_length = 0;
58+
}
59+
60+
61+
BLEDescriptorImp::BLEDescriptorImp(const BLEDescriptorImp& rhs) :
62+
BLEAttribute(rhs)
63+
{
64+
_value_length = rhs._value_length;
65+
_value = (unsigned char *)malloc(_value_length);
66+
if (_value)
67+
memcpy(_value, rhs._value, sizeof(_value_length));
68+
else
69+
_value_length = 0;
70+
71+
_value_handle = rhs._value_handle;
72+
_properties = rhs._properties;
73+
_descriptor_uuid = rhs._descriptor_uuid;
74+
_bledev = BLEDevice(&rhs._bledev);
75+
}
76+
77+
78+
BLEDescriptorImp& BLEDescriptorImp::operator=(const BLEDescriptorImp& that)
79+
{
80+
if (this != &that) {
81+
82+
BLEAttribute::operator=(that);
83+
if (_value)
84+
free(_value);
85+
86+
_value_length = that._value_length;
87+
_value = (unsigned char *)malloc(_value_length);
88+
if (_value)
89+
memcpy(_value, that._value, sizeof(_value_length));
90+
else
91+
_value_length = 0;
92+
93+
_value_handle = that._value_handle;
94+
_properties = that._properties;
95+
_descriptor_uuid = that._descriptor_uuid;
96+
_bledev = BLEDevice(&that._bledev);
97+
}
98+
return *this;
5299
}
53100

54101
BLEDescriptorImp::~BLEDescriptorImp() {
55-
if (_value) {
102+
if (_value != (unsigned char *)NULL) {
56103
free(_value);
57-
_value = NULL;
104+
_value = (unsigned char *)NULL;
58105
}
59106
}
60107

‎libraries/BLE/src/internal/BLEDescriptorImp.h

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,10 @@ class BLEDescriptorImp: public BLEAttribute{
4040
uint16_t handle,
4141
BLEDevice& bledevice);
4242

43+
BLEDescriptorImp(const BLEDescriptorImp& rhs);
44+
45+
BLEDescriptorImp& operator=(const BLEDescriptorImp& that);
46+
4347
virtual ~BLEDescriptorImp();
4448

4549
/**

0 commit comments

Comments
 (0)