diff --git a/.github/workflows/compile-examples.yml b/.github/workflows/compile-examples.yml index 903abc44..059e70f1 100644 --- a/.github/workflows/compile-examples.yml +++ b/.github/workflows/compile-examples.yml @@ -12,6 +12,9 @@ on: - ".github/workflows/compile-examples.yml" - "examples/**" - "src/**" + schedule: + # Run every Tuesday at 8 AM UTC to catch breakage caused by changes to external resources (libraries, platforms). + - cron: "0 8 * * TUE" workflow_dispatch: jobs: diff --git a/extras/test/src/test_characteristic/test_permissions.cpp b/extras/test/src/test_characteristic/test_permissions.cpp new file mode 100644 index 00000000..cd658580 --- /dev/null +++ b/extras/test/src/test_characteristic/test_permissions.cpp @@ -0,0 +1,126 @@ +/* + This file is part of the ArduinoBLE library. + Copyright (c) 2018 Arduino SA. All rights reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include + +#define private public +#define protected public + +#include "FakeBLELocalDevice.h" +#include "BLEAdvertisingData.h" +#include "BLETypedCharacteristics.h" +#include "BLELocalCharacteristic.h" +#include "BLEStringCharacteristic.h" +#include "BLEProperty.h" +#include + +int property[] = { + BLEBroadcast, + BLERead, + BLEWriteWithoutResponse, + BLEWrite, + BLENotify, + BLEIndicate, + BLEAuthSignedWrite, + BLEExtProp, + BLERead | BLEWrite | BLENotify +}; + +int permission[] = { + BLEEncryption, + BLEAuthentication, + BLEAuthorization, + BLEEncryption | BLEAuthentication +}; + +const char uuid[][31] = { + "1 Bool", + "2 Char", + "3 UnsignedChar", + "4 Byte", + "5 Short", + "6 UnsignedShort", + "7 Word", + "8 Int", + "9 UnsignedInt", + "A Long", + "B UnsignedLong", + "C Float", + "D Double", + "E String" +}; + +std::unique_ptr createCharacteristic(const char* uuid, unsigned int properties) +{ + switch(uuid[0]) + { + case '1': + return std::unique_ptr(new BLEBoolCharacteristic(uuid, properties)); + case '2': + return std::unique_ptr(new BLECharCharacteristic(uuid, properties)); + case '3': + return std::unique_ptr(new BLEUnsignedCharCharacteristic(uuid, properties)); + case '4': + return std::unique_ptr(new BLEByteCharacteristic(uuid, properties)); + case '5': + return std::unique_ptr(new BLEShortCharacteristic(uuid, properties)); + case '6': + return std::unique_ptr(new BLEUnsignedShortCharacteristic(uuid, properties)); + case '7': + return std::unique_ptr(new BLEWordCharacteristic(uuid, properties)); + case '8': + return std::unique_ptr(new BLEIntCharacteristic(uuid, properties)); + case '9': + return std::unique_ptr(new BLEUnsignedIntCharacteristic(uuid, properties)); + case 'A': + return std::unique_ptr(new BLELongCharacteristic(uuid, properties)); + case 'B': + return std::unique_ptr(new BLEUnsignedLongCharacteristic(uuid, properties)); + case 'C': + return std::unique_ptr(new BLEFloatCharacteristic(uuid, properties)); + case 'D': + return std::unique_ptr(new BLEDoubleCharacteristic(uuid, properties)); + case 'E': + return std::unique_ptr(new BLEStringCharacteristic(uuid, properties, 2)); + default: + break; + } + return nullptr; +} + +TEST_CASE("Test characteristic properties and permissions", "[ArduinoBLE::BLECharacteristic]") +{ + WHEN("Create a characteristic") + { + for(int i = 0; i < sizeof(property)/sizeof(int); i++) + { + for(int j = 0; j < sizeof(permission)/sizeof(int); j++) + { + for(int k = 0; k < 14; k++) + { + std::unique_ptr ptr = createCharacteristic(uuid[k], property[i] | permission[j]); + REQUIRE(ptr != nullptr); + REQUIRE(ptr->properties() == (property[i])); + BLELocalCharacteristic * local = ptr->local(); + REQUIRE(local->permissions() == (permission[j] >> 8)); + } + } + } + } +} diff --git a/extras/test/src/test_characteristic/test_writeValue.cpp b/extras/test/src/test_characteristic/test_writeValue.cpp new file mode 100644 index 00000000..6c7e1cd1 --- /dev/null +++ b/extras/test/src/test_characteristic/test_writeValue.cpp @@ -0,0 +1,389 @@ +/* + This file is part of the ArduinoBLE library. + Copyright (c) 2018 Arduino SA. All rights reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#include + +#define private public +#define protected public + +#include "FakeBLELocalDevice.h" +#include "BLEAdvertisingData.h" +#include "BLETypedCharacteristics.h" +#include "BLELocalCharacteristic.h" +#include "BLEStringCharacteristic.h" +#include "BLEProperty.h" + + +TEST_CASE("Test characteristic writeValue", "[ArduinoBLE::BLECharacteristic]") +{ + WHEN("Create a bool characteristic") + { + BLEBoolCharacteristic boolCharacteristic("Bool", BLEBroadcast| BLEIndicate | BLENotify ); + bool v = false;; + int written = boolCharacteristic.writeValue(v); + REQUIRE( written == sizeof(bool) ); + + boolCharacteristic.broadcast(); + written = boolCharacteristic.writeValue(v); + REQUIRE( written == sizeof(bool) ); + + BLEDevice device; + boolCharacteristic.local()->writeCccdValue(device, 0x002); + written = boolCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + boolCharacteristic.local()->writeCccdValue(device, 0x001); + written = boolCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a boolean characteristic") + { + BLEBooleanCharacteristic booleanCharacteristic("Boolean", BLEBroadcast| BLEIndicate | BLENotify); + bool v = false; + int written = booleanCharacteristic.writeValue(v); + REQUIRE( written == sizeof(bool) ); + + booleanCharacteristic.broadcast(); + written = booleanCharacteristic.writeValue(v); + REQUIRE( written == sizeof(bool) ); + + BLEDevice device; + booleanCharacteristic.local()->writeCccdValue(device, 0x002); + written = booleanCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + booleanCharacteristic.local()->writeCccdValue(device, 0x001); + written = booleanCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a char characteristic") + { + BLECharCharacteristic charCharacteristic("Char", BLEBroadcast| BLEIndicate | BLENotify); + char v = 'a'; + int written = charCharacteristic.writeValue(v); + REQUIRE( written == sizeof(char) ); + + charCharacteristic.broadcast(); + written = charCharacteristic.writeValue(v); + REQUIRE( written == sizeof(char) ); + + BLEDevice device; + charCharacteristic.local()->writeCccdValue(device, 0x002); + written = charCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + charCharacteristic.local()->writeCccdValue(device, 0x001); + written = charCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a unsigned char characteristic") + { + BLEUnsignedCharCharacteristic unsignedCharCharacteristic("UnsignedChar", BLEBroadcast| BLEIndicate | BLENotify); + unsigned char v = 0x01; + int written = unsignedCharCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned char) ); + + unsignedCharCharacteristic.broadcast(); + written = unsignedCharCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned char) ); + + BLEDevice device; + unsignedCharCharacteristic.local()->writeCccdValue(device, 0x002); + written = unsignedCharCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + unsignedCharCharacteristic.local()->writeCccdValue(device, 0x001); + written = unsignedCharCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a byte characteristic") + { + BLEByteCharacteristic byteCharacteristic("Byte", BLEBroadcast| BLEIndicate | BLENotify); + byte v = 0x01; + int written = byteCharacteristic.writeValue(v); + REQUIRE( written == sizeof(byte) ); + + byteCharacteristic.broadcast(); + written = byteCharacteristic.writeValue(v); + REQUIRE( written == sizeof(byte) ); + + BLEDevice device; + byteCharacteristic.local()->writeCccdValue(device, 0x002); + written = byteCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + byteCharacteristic.local()->writeCccdValue(device, 0x001); + written = byteCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a short characteristic") + { + BLEShortCharacteristic shortCharacteristic("Short", BLEBroadcast| BLEIndicate | BLENotify); + short v = -1; + int written = shortCharacteristic.writeValue(v); + REQUIRE( written == sizeof(short) ); + + shortCharacteristic.broadcast(); + written = shortCharacteristic.writeValue(v); + REQUIRE( written == sizeof(short) ); + + BLEDevice device; + shortCharacteristic.local()->writeCccdValue(device, 0x002); + written = shortCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + shortCharacteristic.local()->writeCccdValue(device, 0x001); + written = shortCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a unsigned short characteristic") + { + BLEUnsignedShortCharacteristic unsignedShortCharacteristic("UnsignedShort", BLEBroadcast| BLEIndicate | BLENotify); + unsigned short v = 1; + int written = unsignedShortCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned short) ); + + unsignedShortCharacteristic.broadcast(); + written = unsignedShortCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned short) ); + + BLEDevice device; + unsignedShortCharacteristic.local()->writeCccdValue(device, 0x002); + written = unsignedShortCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + unsignedShortCharacteristic.local()->writeCccdValue(device, 0x001); + written = unsignedShortCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a word characteristic") + { + BLEWordCharacteristic wordCharacteristic("Word", BLEBroadcast| BLEIndicate | BLENotify); + word v = -1; + int written = wordCharacteristic.writeValue(v); + REQUIRE( written == sizeof(word) ); + + wordCharacteristic.broadcast(); + written = wordCharacteristic.writeValue(v); + REQUIRE( written == sizeof(word) ); + + BLEDevice device; + wordCharacteristic.local()->writeCccdValue(device, 0x002); + written = wordCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + wordCharacteristic.local()->writeCccdValue(device, 0x001); + written = wordCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a int characteristic") + { + BLEIntCharacteristic intCharacteristic("Int", BLEBroadcast| BLEIndicate | BLENotify); + int v = -1; + int written = intCharacteristic.writeValue(v); + REQUIRE( written == sizeof(int) ); + + intCharacteristic.broadcast(); + written = intCharacteristic.writeValue(v); + REQUIRE( written == sizeof(int) ); + + BLEDevice device; + intCharacteristic.local()->writeCccdValue(device, 0x002); + written = intCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + intCharacteristic.local()->writeCccdValue(device, 0x001); + written = intCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a unsigned int characteristic") + { + BLEUnsignedIntCharacteristic unsignedIntCharacteristic("UnsignedInt", BLEBroadcast| BLEIndicate | BLENotify); + unsigned int v = 1; + int written = unsignedIntCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned int) ); + + unsignedIntCharacteristic.broadcast(); + written = unsignedIntCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned int) ); + + BLEDevice device; + unsignedIntCharacteristic.local()->writeCccdValue(device, 0x002); + written = unsignedIntCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + unsignedIntCharacteristic.local()->writeCccdValue(device, 0x001); + written = unsignedIntCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a long characteristic") + { + BLELongCharacteristic longCharacteristic("Long", BLEBroadcast| BLEIndicate | BLENotify); + long v = -1; + int written = longCharacteristic.writeValue(v); + REQUIRE( written == sizeof(long) ); + + longCharacteristic.broadcast(); + written = longCharacteristic.writeValue(v); + REQUIRE( written == sizeof(long) ); + + BLEDevice device; + longCharacteristic.local()->writeCccdValue(device, 0x002); + written = longCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + longCharacteristic.local()->writeCccdValue(device, 0x001); + written = longCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a unsigned long characteristic") + { + BLEUnsignedLongCharacteristic unsignedLongCharacteristic("UnsignedLong", BLEBroadcast| BLEIndicate | BLENotify); + unsigned long v = 1; + int written = unsignedLongCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned long) ); + + unsignedLongCharacteristic.broadcast(); + written = unsignedLongCharacteristic.writeValue(v); + REQUIRE( written == sizeof(unsigned long) ); + + BLEDevice device; + unsignedLongCharacteristic.local()->writeCccdValue(device, 0x002); + written = unsignedLongCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + unsignedLongCharacteristic.local()->writeCccdValue(device, 0x001); + written = unsignedLongCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a float characteristic") + { + BLEFloatCharacteristic floatCharacteristic("Float", BLEBroadcast| BLEIndicate | BLENotify); + float v = -1.0f; + int written = floatCharacteristic.writeValue(v); + REQUIRE( written == sizeof(float) ); + + floatCharacteristic.broadcast(); + written = floatCharacteristic.writeValue(v); + REQUIRE( written == sizeof(float) ); + + BLEDevice device; + floatCharacteristic.local()->writeCccdValue(device, 0x002); + written = floatCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + floatCharacteristic.local()->writeCccdValue(device, 0x001); + written = floatCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a double characteristic") + { + BLEDoubleCharacteristic doubleCharacteristic("Double", BLEBroadcast| BLEIndicate | BLENotify); + double v = -1.0; + int written = doubleCharacteristic.writeValue(v); + REQUIRE( written == sizeof(double) ); + + doubleCharacteristic.broadcast(); + written = doubleCharacteristic.writeValue(v); + REQUIRE( written == sizeof(double) ); + + BLEDevice device; + doubleCharacteristic.local()->writeCccdValue(device, 0x002); + written = doubleCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + doubleCharacteristic.local()->writeCccdValue(device, 0x001); + written = doubleCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a string characteristic") + { + const int maxStringLength = 64; + BLEStringCharacteristic stringCharacteristic("String", BLEBroadcast| BLEIndicate | BLENotify, maxStringLength); + const char* v = "Hello"; + int written = stringCharacteristic.writeValue(v); + REQUIRE( written == min(strlen(v), maxStringLength) ); + + stringCharacteristic.broadcast(); + written = stringCharacteristic.writeValue(v); + REQUIRE( written == min(strlen(v), maxStringLength) ); + + BLEDevice device; + stringCharacteristic.local()->writeCccdValue(device, 0x002); + written = stringCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + stringCharacteristic.local()->writeCccdValue(device, 0x001); + written = stringCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + + WHEN("Create a too long string characteristic") + { + const int maxStringLength = 4; + BLEStringCharacteristic stringCharacteristic("String", BLEBroadcast| BLEIndicate | BLENotify, maxStringLength); + const char* v = "Hello"; + int written = stringCharacteristic.writeValue(v); + REQUIRE( written == min(strlen(v), maxStringLength) ); + + stringCharacteristic.broadcast(); + written = stringCharacteristic.writeValue(v); + REQUIRE( written == min(strlen(v), maxStringLength) ); + + BLEDevice device; + stringCharacteristic.local()->writeCccdValue(device, 0x002); + written = stringCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + stringCharacteristic.local()->writeCccdValue(device, 0x001); + written = stringCharacteristic.writeValue(v); + /* No peers connected */ + REQUIRE( written == 0 ); + } + +} diff --git a/keywords.txt b/keywords.txt index b908b573..150e6262 100644 --- a/keywords.txt +++ b/keywords.txt @@ -119,10 +119,6 @@ valueBE KEYWORD2 uuid KEYWORD2 addCharacteristic KEYWORD2 -wait KEYWORD2 -peek KEYWORD2 -write KEYWORD2 - ####################################### # Constants (LITERAL1) ####################################### diff --git a/library.properties b/library.properties index 1842c0ee..24c38d09 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=STM32duinoBLE -version=1.3.7 +version=1.4.0 author=Arduino, SRA maintainer=stm32duino sentence=Fork of ArduinoBLE library to add the support of STM32WB, SPBTLE-RF, SPBTLE-1S, BLUENRG-M2SP, BLUENRG-LP and BLUENRG-M0 BLE modules. diff --git a/src/BLEStringCharacteristic.cpp b/src/BLEStringCharacteristic.cpp index 76f0812c..a12e722d 100644 --- a/src/BLEStringCharacteristic.cpp +++ b/src/BLEStringCharacteristic.cpp @@ -19,7 +19,7 @@ #include "BLEStringCharacteristic.h" -BLEStringCharacteristic::BLEStringCharacteristic(const char* uuid, unsigned char properties, int valueSize) : +BLEStringCharacteristic::BLEStringCharacteristic(const char* uuid, unsigned int properties, int valueSize) : BLECharacteristic(uuid, properties, valueSize) { } diff --git a/src/BLEStringCharacteristic.h b/src/BLEStringCharacteristic.h index c9f28fca..65604846 100644 --- a/src/BLEStringCharacteristic.h +++ b/src/BLEStringCharacteristic.h @@ -27,7 +27,7 @@ class BLEStringCharacteristic : public BLECharacteristic { public: - BLEStringCharacteristic(const char* uuid, unsigned char properties, int valueSize); + BLEStringCharacteristic(const char* uuid, unsigned int properties, int valueSize); int writeValue(const String& value); int setValue(const String& value) { return writeValue(value); } diff --git a/src/local/BLELocalCharacteristic.cpp b/src/local/BLELocalCharacteristic.cpp index 207425bd..dc8a819d 100644 --- a/src/local/BLELocalCharacteristic.cpp +++ b/src/local/BLELocalCharacteristic.cpp @@ -126,15 +126,13 @@ int BLELocalCharacteristic::writeValue(const uint8_t value[], int length) if (_broadcast) { uint16_t serviceUuid = GATT.serviceUuidForCharacteristic(this); - - BLE.setAdvertisedServiceData(serviceUuid, value, length); - + BLE.setAdvertisedServiceData(serviceUuid, value, _valueLength); if (!ATT.connected() && GAP.advertising()) { BLE.advertise(); } } - return 1; + return _valueLength; } int BLELocalCharacteristic::writeValue(const char* value) diff --git a/src/utility/ATT.cpp b/src/utility/ATT.cpp index d19b9b92..4fe4b71a 100644 --- a/src/utility/ATT.cpp +++ b/src/utility/ATT.cpp @@ -553,6 +553,22 @@ bool ATTClass::disconnect() numDisconnects++; + BLEDevice bleDevice(_peers[i].addressType, _peers[i].address); + + // clear CCCD values on disconnect + for (uint16_t att = 0; att < GATT.attributeCount(); att++) { + BLELocalAttribute* attribute = GATT.attribute(att); + + if (attribute->type() == BLETypeCharacteristic) { + BLELocalCharacteristic* characteristic = (BLELocalCharacteristic*)attribute; + + characteristic->writeCccdValue(bleDevice, 0x0000); + } + } + + _longWriteHandle = 0x0000; + _longWriteValueLength = 0; + _peers[i].connectionHandle = 0xffff; _peers[i].role = 0x00; _peers[i].addressType = 0x00; @@ -582,7 +598,7 @@ BLEDevice ATTClass::central() return BLEDevice(); } -bool ATTClass::handleNotify(uint16_t handle, const uint8_t* value, int length) +int ATTClass::handleNotify(uint16_t handle, const uint8_t* value, int length) { int numNotifications = 0; @@ -610,10 +626,10 @@ bool ATTClass::handleNotify(uint16_t handle, const uint8_t* value, int length) numNotifications++; } - return (numNotifications > 0); + return (numNotifications > 0) ? length : 0; } -bool ATTClass::handleInd(uint16_t handle, const uint8_t* value, int length) +int ATTClass::handleInd(uint16_t handle, const uint8_t* value, int length) { int numIndications = 0; @@ -650,7 +666,7 @@ bool ATTClass::handleInd(uint16_t handle, const uint8_t* value, int length) numIndications++; } - return (numIndications > 0); + return (numIndications > 0) ? length : 0; } void ATTClass::error(uint16_t connectionHandle, uint8_t dlen, uint8_t data[]) diff --git a/src/utility/ATT.h b/src/utility/ATT.h index 5e41e1fa..2d69d2b5 100644 --- a/src/utility/ATT.h +++ b/src/utility/ATT.h @@ -83,8 +83,8 @@ class ATTClass { virtual BLEDevice central(); - virtual bool handleNotify(uint16_t handle, const uint8_t* value, int length); - virtual bool handleInd(uint16_t handle, const uint8_t* value, int length); + virtual int handleNotify(uint16_t handle, const uint8_t* value, int length); + virtual int handleInd(uint16_t handle, const uint8_t* value, int length); virtual void setEventHandler(BLEDeviceEvent event, BLEDeviceEventHandler eventHandler); diff --git a/src/utility/GATT.cpp b/src/utility/GATT.cpp index be914f6f..3550fd99 100644 --- a/src/utility/GATT.cpp +++ b/src/utility/GATT.cpp @@ -70,21 +70,31 @@ void GATTClass::begin() void GATTClass::end() { - if (_genericAccessService->release() == 0) + if (_genericAccessService && _genericAccessService->release() == 0) { delete(_genericAccessService); - - if (_deviceNameCharacteristic->release() == 0) + _genericAccessService = NULL; + } + + if (_deviceNameCharacteristic && _deviceNameCharacteristic->release() == 0) { delete(_deviceNameCharacteristic); - - if (_appearanceCharacteristic->release() == 0) + _deviceNameCharacteristic = NULL; + } + + if (_appearanceCharacteristic && _appearanceCharacteristic->release() == 0) { delete(_appearanceCharacteristic); - - if (_genericAttributeService->release() == 0) + _appearanceCharacteristic = NULL; + } + + if (_genericAttributeService && _genericAttributeService->release() == 0) { delete(_genericAttributeService); - - if (_servicesChangedCharacteristic->release() == 0) + _genericAttributeService = NULL; + } + + if (_servicesChangedCharacteristic && _servicesChangedCharacteristic->release() == 0) { delete(_servicesChangedCharacteristic); - + _servicesChangedCharacteristic = NULL; + } + clearAttributes(); } diff --git a/src/utility/HCI.cpp b/src/utility/HCI.cpp index 8ac2419a..ebe66a27 100644 --- a/src/utility/HCI.cpp +++ b/src/utility/HCI.cpp @@ -485,6 +485,7 @@ void HCIClass::leAddResolvingAddress(uint8_t addressType, uint8_t* peerAddress, addDevice.peerIRK[15-i] = peerIrk[i]; addDevice.localIRK[15-i] = localIrk[i]; } +#ifdef _BLE_TRACE_ Serial.print("ADDTYPE :"); btct.printBytes(&addDevice.peerAddressType,1); Serial.print("adddddd :"); @@ -493,6 +494,7 @@ void HCIClass::leAddResolvingAddress(uint8_t addressType, uint8_t* peerAddress, btct.printBytes(addDevice.peerIRK,16); Serial.print("localIRK :"); btct.printBytes(addDevice.localIRK,16); +#endif sendCommand(OGF_LE_CTL << 10 | 0x27, sizeof(addDevice), &addDevice); leStartResolvingAddresses(); @@ -516,6 +518,7 @@ int HCIClass::leReadPeerResolvableAddress(uint8_t peerAddressType, uint8_t* peer int res = sendCommand(OGF_LE_CTL << 10 | 0x2B, sizeof(request), &request); +#ifdef _BLE_TRACE_ Serial.print("res: 0x"); Serial.println(res, HEX); if(res==0){ @@ -528,6 +531,7 @@ int HCIClass::leReadPeerResolvableAddress(uint8_t peerAddressType, uint8_t* peer Serial.print("peer resolvable address: "); btct.printBytes(response->peerResolvableAddress,6); } + #endif return res; } @@ -566,7 +570,9 @@ int HCIClass::tryResolveAddress(uint8_t* BDAddr, uint8_t* address){ if(!HCI._getIRKs(&nIRKs, BDAddrType, BADDRs, IRKs)){ +#ifdef _BLE_TRACE_ Serial.println("error getting IRKs."); +#endif } for(int i=0; i0){ Serial.print(", 0x"); @@ -36,7 +37,13 @@ void BluetoothCryptoToolbox::printBytes(uint8_t bytes[], uint8_t length){ Serial.print(bytes[i],HEX); } Serial.print('\n'); +#else + (void)bytes; + (void)length; +#endif } + + int BluetoothCryptoToolbox::f5(uint8_t DHKey[],uint8_t N_master[], uint8_t N_slave[], uint8_t BD_ADDR_master[], uint8_t BD_ADDR_slave[], uint8_t MacKey[], uint8_t LTK[]) { @@ -126,17 +133,17 @@ int BluetoothCryptoToolbox::ah(uint8_t k[16], uint8_t r[3], uint8_t* result) } void BluetoothCryptoToolbox::testAh() { - uint8_t irk[16] = {0xec,0x02,0x34,0xa3,0x57,0xc8,0xad,0x05,0x34,0x10,0x10,0xa6,0x0a,0x39,0x7d,0x9b}; + uint8_t irk[16] = {0xec,0x02,0x34,0xa3,0x57,0xc8,0xad,0x05,0x34,0x10,0x10,0xa6,0x0a,0x39,0x7d,0x9b}; uint8_t expected_final[3] = {0x0d,0xfb,0xaa}; - uint8_t ourResult[3]; ah(irk, expected_final, ourResult); - +#ifdef _BLE_TRACE_ Serial.print("Expected : "); printBytes(&expected_final[3], 3); Serial.print("Actual : "); printBytes(ourResult, 3); +#endif } int BluetoothCryptoToolbox::g2(uint8_t U[], uint8_t V[], uint8_t X[], uint8_t Y[], uint8_t out[4]) @@ -160,19 +167,17 @@ void BluetoothCryptoToolbox::testg2(){ uint8_t X[16] = {0xd5,0xcb,0x84,0x54,0xd1,0x77,0x73,0x3e,0xff,0xff,0xb2,0xec,0x71,0x2b,0xae,0xab}; uint8_t Y[16] = {0xa6,0xe8,0xe7,0xcc,0x25,0xa7,0x5f,0x6e,0x21,0x65,0x83,0xf7,0xff,0x3d,0xc4,0xcf}; uint8_t out[4]; - - - uint32_t expected = 0; + g2(U,V,X,Y,out); uint32_t result = 0; for(int i=0; i<4; i++) result += out[i] << 8*i; - Serial.print("Expected : "); - Serial.println(expected); +#ifdef _BLE_TRACE_ + Serial.println("Expected : 0"); Serial.print("Result : "); Serial.println(result); Serial.println(); - +#endif } void BluetoothCryptoToolbox::AES_CMAC ( unsigned char *key, unsigned char *input, int length, @@ -264,8 +269,10 @@ int BluetoothCryptoToolbox::AES_128(uint8_t* key, uint8_t* data_in, uint8_t* dat int n = 0; int tries = 30; while(HCI.leEncrypt(key,data_in, &status, data_out)!=1&&n