aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--Bluetooth.cpp221
-rw-r--r--Bluetooth.h177
-rw-r--r--BluetoothImpl.h14
-rw-r--r--ByteBuffer.cpp23
-rw-r--r--CMakeLists.txt3
-rw-r--r--LinuxBluetooth.cpp457
-rw-r--r--main.cpp16
-rw-r--r--test/ByteBufferTest.cpp37
8 files changed, 512 insertions, 436 deletions
diff --git a/Bluetooth.cpp b/Bluetooth.cpp
index dd9e48e..e6d6d28 100644
--- a/Bluetooth.cpp
+++ b/Bluetooth.cpp
@@ -2,137 +2,170 @@
#include <iomanip>
#include <string.h>
#include "Bluetooth.h"
+#include "BluetoothImpl.h"
namespace trygvis {
- using namespace std;
+namespace bluetooth {
+using namespace std;
- // -----------------------------------------------------------------------
- // Mac
- // -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// Mac
+// -----------------------------------------------------------------------
- string Mac::str() const {
- std::ostringstream buf;
+string Mac::str() const {
+ std::ostringstream buf;
- buf
- << setw(2) << hex << setfill('0') << (int) bytes[0] << ":"
- << setw(2) << hex << setfill('0') << (int) bytes[1] << ":"
- << setw(2) << hex << setfill('0') << (int) bytes[2] << ":"
- << setw(2) << hex << setfill('0') << (int) bytes[3] << ":"
- << setw(2) << hex << setfill('0') << (int) bytes[4] << ":"
- << setw(2) << hex << setfill('0') << (int) bytes[5];
+ buf
+ << setw(2) << hex << setfill('0') << (int) bytes[0] << ":"
+ << setw(2) << hex << setfill('0') << (int) bytes[1] << ":"
+ << setw(2) << hex << setfill('0') << (int) bytes[2] << ":"
+ << setw(2) << hex << setfill('0') << (int) bytes[3] << ":"
+ << setw(2) << hex << setfill('0') << (int) bytes[4] << ":"
+ << setw(2) << hex << setfill('0') << (int) bytes[5];
- return buf.str();
- }
+ return buf.str();
+}
- bool Mac::operator==(Mac &other) const {
- const uint8_t* b = bytes;
- return memcmp(b, other.bytes, sizeof(bytes)) == 0;
- }
+bool Mac::operator==(Mac &other) const {
+ const uint8_t *b = bytes;
+ return memcmp(b, other.bytes, sizeof(bytes)) == 0;
+}
- bool Mac::operator!=(Mac &other) const {
- return !operator==(other);
- }
+bool Mac::operator!=(Mac &other) const {
+ return !operator==(other);
+}
- bool operator<(const Mac &a, const Mac &b) {
- return memcmp(a.bytes, b.bytes, sizeof(a.bytes)) < 0;
- }
+bool operator<(const Mac &a, const Mac &b) {
+ return memcmp(a.bytes, b.bytes, sizeof(a.bytes)) < 0;
+}
+
+void Mac::copy(uint8_t &_0, uint8_t &_1, uint8_t &_2, uint8_t &_3, uint8_t &_4, uint8_t &_5) const {
+ _0 = bytes[0];
+ _1 = bytes[1];
+ _2 = bytes[2];
+ _3 = bytes[3];
+ _4 = bytes[4];
+ _5 = bytes[5];
+}
- void Mac::copy(uint8_t &_0, uint8_t &_1, uint8_t &_2, uint8_t &_3, uint8_t &_4, uint8_t &_5) const {
- _0 = bytes[0];
- _1 = bytes[1];
- _2 = bytes[2];
- _3 = bytes[3];
- _4 = bytes[4];
- _5 = bytes[5];
+Mac Mac::parseMac(string s) throw(BluetoothException) {
+ unsigned int bytes[6];
+ int count = sscanf(s.c_str(), "%02x:%02x:%02x:%02x:%02x:%02x",
+ &bytes[0], &bytes[1], &bytes[2], &bytes[3], &bytes[4], &bytes[5]);
+
+ if (count != 6) {
+ throw BluetoothException("Unable to parse mac: " + s);
}
- Mac *Mac::parseMac(string s) throw(BluetoothException) {
- unsigned int bytes[6];
- int count = sscanf(s.c_str(), "%02x:%02x:%02x:%02x:%02x:%02x",
- &bytes[0], &bytes[1], &bytes[2], &bytes[3], &bytes[4], &bytes[5]);
+ return Mac((uint8_t) bytes[0], (uint8_t) bytes[1], (uint8_t) bytes[2], (uint8_t) bytes[3], (uint8_t) bytes[4], (uint8_t) bytes[5]);
+}
- if (count != 6) {
- throw BluetoothException("Unable to parse mac: " + s);
- }
+AttPdu::AttPdu(ByteBuffer &bytes) : bytes(bytes) {
+}
- return new Mac((uint8_t) bytes[0], (uint8_t) bytes[1], (uint8_t) bytes[2], (uint8_t) bytes[3], (uint8_t) bytes[4], (uint8_t) bytes[5]);
- }
+AttPdu::AttPdu(ByteBuffer &bytes, AttPduType type) : bytes(bytes) {
+ bytes.add8(type);
+}
- AttPdu::AttPdu(ByteBuffer &bytes) : bytes(bytes) {
- }
+AttPduType AttPdu::getType() {
+ return (AttPduType) bytes.get8(0);
+}
- AttPdu::AttPdu(ByteBuffer &bytes, AttPduType type) : bytes(bytes) {
- bytes.add8(type);
+void AttPdu::makeReadByGroupType(ByteBuffer &bytes, uint16_t startHandle, uint16_t endHandle, uint16_t uuid) {
+ bytes.setCursor(0);
+ bytes.add8(AttPduType::READ_BY_GROUP_TYPE_REQ);
+ bytes.add16le(startHandle);
+ bytes.add16le(endHandle);
+ bytes.add16le(uuid);
+}
+
+void AttPdu::checkType(ByteBuffer &bytes, AttPduType type) {
+ if (bytes.getSize() == 0) {
+ throw BluetoothException("PDU is too small");
}
- AttPduType AttPdu::getType() {
- return (AttPduType) bytes.get8(0);
+ bytes.setCursor(0);
+ AttPduType t = (AttPduType) bytes.get8();
+
+ if (t != type) {
+ throw BluetoothException("Unexpected type: " + t);
}
+}
- void AttPdu::makeReadByGroupType(ByteBuffer &bytes, uint16_t startHandle, uint16_t endHandle, uint16_t uuid) {
- bytes.setCursor(0);
- bytes.add8(AttPduType::READ_BY_GROUP_TYPE_REQ);
- bytes.add16le(startHandle);
- bytes.add16le(endHandle);
- bytes.add16le(uuid);
+vector<AttributeData> AttPdu::parseReadByGroupType(ByteBuffer &bytes) {
+ DF << "bytes: " << bytes.toString();
+
+ checkType(bytes, READ_BY_GROUP_TYPE_RES);
+
+ if (bytes.getSize() < 4) {
+ throw BluetoothException("Bad READ_BY_GROUP_TYPE_RES packet, expected at least 4 octets, got " + bytes.getSize());
}
- void AttPdu::checkType(ByteBuffer &bytes, AttPduType type) {
- if (bytes.getSize() == 0) {
- throw BluetoothException("PDU is too small");
- }
+ uint8_t length = bytes.get8();
+ DF << "length=" << (int) length;
- bytes.setCursor(0);
- AttPduType t = (AttPduType) bytes.get8();
+ size_t count = (bytes.getSize() - 2) / length;
+ DF << "count=" << count;
- if (t != type) {
- throw BluetoothException("Unexpected type: " + t);
- }
+ vector<AttributeData> values;
+ for (int i = 0; i < count; i++) {
+ values.push_back(AttributeData::fromByteBuffer(bytes, length));
}
- vector<AttributeData> AttPdu::parseReadByGroupType(ByteBuffer &bytes) {
- checkType(bytes, READ_BY_GROUP_TYPE_RES);
+ return values;
+}
- if (bytes.getSize() < 4) {
- throw BluetoothException("Bad READ_BY_GROUP_TYPE_RES packet, expected at least 4 octets, got " + bytes.getSize());
- }
+// -----------------------------------------------------------------------
+// AttributeData
+// -----------------------------------------------------------------------
- uint8_t length = bytes.get8();
- DF << "length=" << (int) length;
+AttributeData AttributeData::fromByteBuffer(ByteBuffer &bytes, uint8_t length) {
+ uint16_t handle = bytes.get16le();
+ uint16_t groupEndHandle = bytes.get16le();
- size_t count = (bytes.getSize() - 2) / length;
- DF << "count=" << count;
+ return AttributeData(handle, groupEndHandle, bytes.view(length - 4));
+}
- vector<AttributeData> values;
- for (int i = 0; i < count; i++) {
- values.push_back(AttributeData::fromByteBuffer(bytes, length));
- }
+AttributeData::AttributeData(uint16_t handle, uint16_t groupEndHandle, ByteBuffer value) :
+ handle(handle), groupEndHandle(groupEndHandle), value(value) {
+}
- return values;
- }
+AttributeData::~AttributeData() {
+}
- // -----------------------------------------------------------------------
- // AttributeData
- // -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// Adapter
+// -----------------------------------------------------------------------
- AttributeData AttributeData::fromByteBuffer(ByteBuffer &bytes, uint8_t length) {
- uint16_t handle = bytes.get16le();
- uint16_t groupEndHandle = bytes.get16le();
+BluetoothAdapter::BluetoothAdapter() {
+}
- return AttributeData(handle, groupEndHandle, bytes.view(length));
- }
+BluetoothAdapter::~BluetoothAdapter() {
+}
- AttributeData::AttributeData(uint16_t handle, uint16_t groupEndHandle, ByteBuffer value) :
- handle(handle), groupEndHandle(groupEndHandle), value(value) {
- }
+/*
+map<int, LinuxBluetoothAdapter *> adapters;
- AttributeData::~AttributeData() {
+BluetoothAdapter &getAdapter(int hciDevice) {
+ map<int, LinuxBluetoothAdapter *>::iterator it = adapters.find(hciDevice);
+
+ if (it == adapters.end()) {
+ LinuxBluetoothAdapter *adapter = new LinuxBluetoothAdapter(hciDevice);
+ adapters[hciDevice] = adapter;
+ return *adapter;
}
- // -----------------------------------------------------------------------
- // Adapter
- // -----------------------------------------------------------------------
+ return *it->second;
+}
+*/
- BluetoothAdapter::~BluetoothAdapter() {
- }
+BluetoothAdapter &getAdapter(int hciDevice) {
+ return getAdapterImpl(hciDevice);
+}
+
+void shutdown() {
+ shutdownImpl();
+}
+
+}
};
diff --git a/Bluetooth.h b/Bluetooth.h
index 15ef171..7ed7b8c 100644
--- a/Bluetooth.h
+++ b/Bluetooth.h
@@ -21,125 +21,130 @@
#define UUID_SECONDARY_SERVICE 0x2801
namespace trygvis {
- using namespace std;
+namespace bluetooth {
+using namespace std;
+
+class BluetoothAdapter;
+
+class BluetoothDevice;
+
+class BluetoothException : public runtime_error {
+public:
+ BluetoothException(const BluetoothAdapter *adapter, string const &what) :
+ runtime_error(what), adapter(adapter), device(nullptr) {
+ }
+
+ BluetoothException(const BluetoothDevice *device, string const &what) :
+ runtime_error(what), adapter(nullptr), device(device) {
+ }
+
+ BluetoothException(string const &what) :
+ runtime_error(what), adapter(nullptr), device(nullptr) {
+ }
+
+ const BluetoothAdapter *adapter;
+ const BluetoothDevice *device;
+};
+
+class Mac {
+public:
+ Mac(uint8_t _0, uint8_t _1, uint8_t _2, uint8_t _3, uint8_t _4, uint8_t _5) {
+ bytes[0] = _0;
+ bytes[1] = _1;
+ bytes[2] = _2;
+ bytes[3] = _3;
+ bytes[4] = _4;
+ bytes[5] = _5;
+ };
- class BluetoothAdapter;
+ string str() const;
- class BluetoothDevice;
+ bool operator==(Mac &other) const;
- class BluetoothException : public runtime_error {
- public:
- BluetoothException(const BluetoothAdapter *adapter, string const &what) :
- runtime_error(what), adapter(adapter), device(nullptr) {
- }
+ bool operator!=(Mac &other) const;
- BluetoothException(const BluetoothDevice *device, string const &what) :
- runtime_error(what), adapter(nullptr), device(device) {
- }
+ void copy(uint8_t &_0, uint8_t &_1, uint8_t &_2, uint8_t &_3, uint8_t &_4, uint8_t &_5) const;
- BluetoothException(string const &what) :
- runtime_error(what), adapter(nullptr), device(nullptr) {
- }
+ static Mac parseMac(string s) throw(BluetoothException);
- const BluetoothAdapter *adapter;
- const BluetoothDevice *device;
- };
+ friend bool operator<(const Mac &a, const Mac &b);
- class Mac {
- public:
- Mac(uint8_t _0, uint8_t _1, uint8_t _2, uint8_t _3, uint8_t _4, uint8_t _5) {
- bytes[0] = _0;
- bytes[1] = _1;
- bytes[2] = _2;
- bytes[3] = _3;
- bytes[4] = _4;
- bytes[5] = _5;
- };
+private:
+ uint8_t bytes[6];
+};
- string str() const;
+class BluetoothDevice {
+public:
+ virtual Mac const &mac() = 0;
- bool operator==(Mac &other) const;
+ virtual BluetoothAdapter &adapter() = 0;
- bool operator!=(Mac &other) const;
+ virtual void connect() = 0;
- void copy(uint8_t &_0, uint8_t &_1, uint8_t &_2, uint8_t &_3, uint8_t &_4, uint8_t &_5) const;
+ virtual void disconnect() = 0;
- static Mac *parseMac(string s) throw(BluetoothException);
+ virtual void discoverServices() = 0;
+};
- friend bool operator<(const Mac &a, const Mac &b);
- private:
- uint8_t bytes[6];
- };
+class BluetoothAdapter {
+public:
+ virtual void stopScan() = 0;
- class BluetoothDevice {
- public:
- virtual Mac const &mac() = 0;
+ virtual void runScan(void (callback)(BluetoothDevice &device)) = 0;
- virtual BluetoothAdapter &adapter() = 0;
+ virtual BluetoothDevice &getDevice(Mac &mac) = 0;
- virtual void connect() = 0;
+protected:
+ BluetoothAdapter();
- virtual void disconnect() = 0;
+ virtual ~BluetoothAdapter();
+};
- virtual void discoverServices() = 0;
- };
+enum AttPduType {
+ ERROR = 0x00,
+ READ_BY_GROUP_TYPE_REQ = 0x10,
+ READ_BY_GROUP_TYPE_RES = 0x11
+};
- class BluetoothAdapter {
- public:
- BluetoothAdapter() {
- };
+class AttributeData;
- virtual ~BluetoothAdapter();
+class AttPdu {
+public:
+ AttPdu(ByteBuffer &bytes);
- virtual void stopScan() = 0;
+ AttPdu(ByteBuffer &bytes, AttPduType type);
- virtual void runScan(void (callback)(BluetoothDevice &device)) = 0;
+ AttPduType getType();
- virtual BluetoothDevice &getDevice(Mac& mac) = 0;
- };
+ static vector<AttributeData> parseReadByGroupType(ByteBuffer &bytes);
- enum AttPduType {
- ERROR = 0x00,
- READ_BY_GROUP_TYPE_REQ = 0x10,
- READ_BY_GROUP_TYPE_RES = 0x11
- };
+ static void makeReadByGroupType(ByteBuffer &bytes, uint16_t startHandle, uint16_t endHandle, uint16_t uuid);
- class AttributeData;
+private:
+ static void checkType(ByteBuffer &bytes, AttPduType type);
- class AttPdu {
- public:
- AttPdu(ByteBuffer &bytes);
+ ByteBuffer &bytes;
+};
- AttPdu(ByteBuffer &bytes, AttPduType type);
+class AttributeData {
+public:
+ ~AttributeData();
- AttPduType getType();
+ static AttributeData fromByteBuffer(ByteBuffer &value, uint8_t length);
- static vector <AttributeData> parseReadByGroupType(ByteBuffer &bytes);
+ const uint16_t handle;
+ const uint16_t groupEndHandle;
+ const ByteBuffer value;
- static void makeReadByGroupType(ByteBuffer &bytes, uint16_t startHandle, uint16_t endHandle, uint16_t uuid);
+private:
+ AttributeData(uint16_t handle, uint16_t groupEndHandle, ByteBuffer value);
+};
- private:
- static void checkType(ByteBuffer &bytes, AttPduType type);
+BluetoothAdapter &getAdapter(int hciDevice);
- ByteBuffer &bytes;
- };
+void shutdown();
- class AttributeData {
- public:
- ~AttributeData();
-
- static AttributeData fromByteBuffer(ByteBuffer &value, uint8_t length);
-
- const uint16_t handle;
- const uint16_t groupEndHandle;
- const ByteBuffer value;
-
- private:
- AttributeData(uint16_t handle, uint16_t groupEndHandle, ByteBuffer value);
- };
-
-// BluetoothAdapter &getAdapter(int hciDevice);
- BluetoothAdapter *getAdapter(int hciDevice);
+}
}
#endif
diff --git a/BluetoothImpl.h b/BluetoothImpl.h
new file mode 100644
index 0000000..ba44853
--- /dev/null
+++ b/BluetoothImpl.h
@@ -0,0 +1,14 @@
+#ifndef BLUETOOTH_IMPL_H
+#define BLUETOOTH_IMPL_H
+
+namespace trygvis {
+namespace bluetooth {
+
+BluetoothAdapter &getAdapterImpl(int hciDevice);
+
+void shutdownImpl();
+
+}
+};
+
+#endif
diff --git a/ByteBuffer.cpp b/ByteBuffer.cpp
index f27deeb..a33589e 100644
--- a/ByteBuffer.cpp
+++ b/ByteBuffer.cpp
@@ -10,54 +10,55 @@ using namespace std;
ByteBuffer::ByteBuffer(uint8_t *bytes, size_t capacity, size_t size, size_t zero) :
bytes(bytes), capacity(capacity), size(size), cursor(zero), zero(zero) {
assert(zero <= size);
+ assert(size <= capacity);
}
ByteBuffer &ByteBuffer::add8(uint8_t value) {
checkAndUpdateSize(1);
- bytes[zero + cursor++] = value;
+ bytes[cursor++] = value;
return *this;
}
ByteBuffer &ByteBuffer::add16le(uint16_t value) {
checkAndUpdateSize(2);
- bytes[zero + cursor++] = (uint8_t) (value & 0xff);
- bytes[zero + cursor++] = (uint8_t) ((value >> 8) & 0xff);
+ bytes[cursor++] = (uint8_t) (value & 0xff);
+ bytes[cursor++] = (uint8_t) ((value >> 8) & 0xff);
return *this;
}
uint8_t ByteBuffer::get8(size_t index) {
canAccessIndex(index);
- return bytes[zero + cursor];
+ return bytes[cursor];
}
uint8_t ByteBuffer::get8() {
canAccessIndex(cursor);
- return bytes[zero + cursor++];
+ return bytes[cursor++];
}
uint16_t ByteBuffer::get16le() {
canAccessIndex(cursor + 1);
uint16_t value;
- value = bytes[zero + cursor++];
- value |= ((uint16_t) bytes[zero + cursor++]) << 8;
+ value = bytes[cursor++];
+ value |= ((uint16_t) bytes[cursor++]) << 8;
return value;
}
void ByteBuffer::copy(uint8_t *bytes, size_t length) {
- canAccessIndex(cursor + length);
+ canAccessIndex(length);
- memcpy(bytes, &this->bytes[zero + cursor], length);
+ memcpy(bytes, &this->bytes[cursor], length);
cursor += length;
}
ByteBuffer ByteBuffer::view(size_t length) {
canAccessIndex(cursor + length);
- size_t s = zero + cursor + length;
+ size_t s = cursor + length;
return ByteBuffer(bytes, s, s, cursor);
}
void ByteBuffer::checkAndUpdateSize(size_t newBytes) {
- size_t newSize = zero + cursor + newBytes;
+ size_t newSize = cursor + newBytes;
if (newSize >= capacity) {
throw ByteBufferException(string("Out of bounds! zero=") + to_string(zero) + ", cursor=" + to_string(cursor) + ", size=" + to_string(size) + ", capacity=" + to_string(capacity) + ", newSize=" + to_string(newSize));
}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1220f20..1098415 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,7 +27,10 @@ target_link_libraries(ble_toys ble)
enable_testing()
find_package(Boost COMPONENTS unit_test_framework REQUIRED)
+
+# If we can change directory here add_definition and test-specific stuff could be moved to the test directory
file(GLOB TEST_SRCS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} test/*.cpp)
+add_definitions(-DBOOST_TEST_DYN_LINK)
foreach(testSrc ${TEST_SRCS})
#Extract the filename without an extension (NAME_WE)
diff --git a/LinuxBluetooth.cpp b/LinuxBluetooth.cpp
index c30a2b7..5a00f53 100644
--- a/LinuxBluetooth.cpp
+++ b/LinuxBluetooth.cpp
@@ -18,323 +18,338 @@
#define MAX_MTU 256
namespace trygvis {
+namespace bluetooth {
+namespace linux {
- class LinuxBluetoothDevice;
+class LinuxBluetoothDevice;
- class LinuxBluetoothAdapter;
+class LinuxBluetoothAdapter;
- class LinuxBluetoothManager;
+class LinuxBluetoothManager;
- class LinuxBluetoothAdapter : public BluetoothAdapter {
- public:
- LinuxBluetoothAdapter(int hciDeviceId);
+class LinuxBluetoothAdapter : public BluetoothAdapter {
+public:
+ LinuxBluetoothAdapter(int hciDeviceId);
- ~LinuxBluetoothAdapter();
+ ~LinuxBluetoothAdapter();
- void runScan(void (*callback)(BluetoothDevice &device));
+ void runScan(void (*callback)(BluetoothDevice &device));
- BluetoothDevice &getDevice(Mac &mac) override;
+ BluetoothDevice &getDevice(Mac &mac) override;
- private:
- void startScan();
+private:
+ void startScan();
- void stopScan();
+ void stopScan();
- int hciDeviceId;
- int hciSocket;
- struct hci_filter hciFilter;
- bool scanning;
- };
+ int hciDeviceId;
+ int hciSocket;
+ struct hci_filter hciFilter;
+ bool scanning;
- class LinuxBluetoothDevice : public BluetoothDevice {
- public:
- LinuxBluetoothDevice(LinuxBluetoothAdapter &adapter, Mac mac);
+ map<Mac, LinuxBluetoothDevice *> devices;
+};
- Mac const &mac() override;
+class LinuxBluetoothDevice : public BluetoothDevice {
+public:
+ LinuxBluetoothDevice(LinuxBluetoothAdapter &adapter, Mac mac);
- LinuxBluetoothAdapter &adapter() override;
+ Mac const &mac() override;
- void connect() override;
+ LinuxBluetoothAdapter &adapter() override;
- void disconnect() override;
+ void connect() override;
- void discoverServices() override;
+ void disconnect() override;
- private:
- LinuxBluetoothAdapter &_adapter;
- Mac _mac;
- int l2cap;
- };
+ void discoverServices() override;
- // Utilities
+private:
+ LinuxBluetoothAdapter &_adapter;
+ Mac _mac;
+ int l2cap;
+};
- string errnoAsString() {
- return string(strerror(errno));
- };
+// Utilities
- // -----------------------------------------------------------------------
- // Mac
- // -----------------------------------------------------------------------
+string errnoAsString() {
+ return string(strerror(errno));
+};
- Mac parseMac(bdaddr_t &a) {
- return Mac(a.b[0], a.b[1], a.b[2], a.b[3], a.b[4], a.b[5]);
- }
+// -----------------------------------------------------------------------
+// Mac
+// -----------------------------------------------------------------------
- // -----------------------------------------------------------------------
- // Device
- // -----------------------------------------------------------------------
+Mac parseMac(bdaddr_t &a) {
+ return Mac(a.b[0], a.b[1], a.b[2], a.b[3], a.b[4], a.b[5]);
+}
- LinuxBluetoothDevice::LinuxBluetoothDevice(LinuxBluetoothAdapter &adapter, Mac mac) :
- _adapter(adapter), _mac(mac) {
- }
+// -----------------------------------------------------------------------
+// Device
+// -----------------------------------------------------------------------
- Mac const &LinuxBluetoothDevice::mac() {
- return _mac;
- }
+LinuxBluetoothDevice::LinuxBluetoothDevice(LinuxBluetoothAdapter &adapter, Mac mac) :
+ _adapter(adapter), _mac(mac) {
+}
- LinuxBluetoothAdapter &LinuxBluetoothDevice::adapter() {
- return _adapter;
- }
-
- void LinuxBluetoothDevice::connect() {
- struct sockaddr_l2 addr;
+Mac const &LinuxBluetoothDevice::mac() {
+ return _mac;
+}
- D << "connect: mac=" << _mac.str();
+LinuxBluetoothAdapter &LinuxBluetoothDevice::adapter() {
+ return _adapter;
+}
- l2cap = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
- if (l2cap < 0) {
- throw BluetoothException(this, "LinuxBluetoothDevice::connect(): socket(): " + errnoAsString());
- }
+void LinuxBluetoothDevice::connect() {
+ struct sockaddr_l2 addr;
- memset(&addr, 0, sizeof(addr));
- addr.l2_family = AF_BLUETOOTH;
- addr.l2_bdaddr = {{0, 0, 0, 0, 0, 0}};
- addr.l2_cid = htobs(ATT_CID);
- addr.l2_bdaddr_type = BDADDR_LE_PUBLIC;
+ D << "connect: mac=" << _mac.str();
- if (bind(l2cap, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
- close(l2cap);
- throw BluetoothException(this, "LinuxBluetoothDevice::connect(): bind(): " + errnoAsString());
- }
+ l2cap = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
+ if (l2cap < 0) {
+ throw BluetoothException(this, "LinuxBluetoothDevice::connect(): socket(): " + errnoAsString());
+ }
- struct bt_security btsec;
- memset(&btsec, 0, sizeof(btsec));
- btsec.level = BT_SECURITY_LOW;
- if (setsockopt(l2cap, SOL_BLUETOOTH, BT_SECURITY, &btsec, sizeof(btsec)) != 0) {
- close(l2cap);
- throw BluetoothException(this, "LinuxBluetoothDevice::connect(): setsockopt(): " + errnoAsString());
- }
+ memset(&addr, 0, sizeof(addr));
+ addr.l2_family = AF_BLUETOOTH;
+ addr.l2_bdaddr = {{0, 0, 0, 0, 0, 0}};
+ addr.l2_cid = htobs(ATT_CID);
+ addr.l2_bdaddr_type = BDADDR_LE_PUBLIC;
- memset(&addr, 0, sizeof(addr));
- addr.l2_family = AF_BLUETOOTH;
- addr.l2_cid = htobs(ATT_CID);
- addr.l2_bdaddr_type = BDADDR_LE_RANDOM;
- _mac.copy(addr.l2_bdaddr.b[5],
- addr.l2_bdaddr.b[4],
- addr.l2_bdaddr.b[3],
- addr.l2_bdaddr.b[2],
- addr.l2_bdaddr.b[1],
- addr.l2_bdaddr.b[0]);
-
- if (::connect(l2cap, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
- close(l2cap);
- throw BluetoothException(this, "LinuxBluetoothDevice::connect(): connect(): " + errnoAsString());
- }
+ if (bind(l2cap, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ close(l2cap);
+ throw BluetoothException(this, "LinuxBluetoothDevice::connect(): bind(): " + errnoAsString());
}
- void LinuxBluetoothDevice::disconnect() {
- DF << "mac=" << _mac.str();
+ struct bt_security btsec;
+ memset(&btsec, 0, sizeof(btsec));
+ btsec.level = BT_SECURITY_LOW;
+ if (setsockopt(l2cap, SOL_BLUETOOTH, BT_SECURITY, &btsec, sizeof(btsec)) != 0) {
close(l2cap);
+ throw BluetoothException(this, "LinuxBluetoothDevice::connect(): setsockopt(): " + errnoAsString());
}
- void LinuxBluetoothDevice::discoverServices() {
- DF;
+ memset(&addr, 0, sizeof(addr));
+ addr.l2_family = AF_BLUETOOTH;
+ addr.l2_cid = htobs(ATT_CID);
+ addr.l2_bdaddr_type = BDADDR_LE_RANDOM;
+ _mac.copy(addr.l2_bdaddr.b[5],
+ addr.l2_bdaddr.b[4],
+ addr.l2_bdaddr.b[3],
+ addr.l2_bdaddr.b[2],
+ addr.l2_bdaddr.b[1],
+ addr.l2_bdaddr.b[0]);
+
+ if (::connect(l2cap, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ close(l2cap);
+ throw BluetoothException(this, "LinuxBluetoothDevice::connect(): connect(): " + errnoAsString());
+ }
+}
- uint8_t buffer[MAX_MTU];
- ByteBuffer out = ByteBuffer(buffer, MAX_MTU, 0);
+void LinuxBluetoothDevice::disconnect() {
+ DF << "mac=" << _mac.str();
+ close(l2cap);
+}
- AttPdu::makeReadByGroupType(out, 0x0001, 0xffff, UUID_PRIMARY_SERVICE);
+void LinuxBluetoothDevice::discoverServices() {
+ DF;
- D << "pdu.size()=" << out.getSize();
- ssize_t written = write(l2cap, buffer, out.getSize());
+ uint8_t buffer[MAX_MTU];
+ ByteBuffer out = ByteBuffer(buffer, MAX_MTU, 0);
- D << "written=" << written;
+ AttPdu::makeReadByGroupType(out, 0x0001, 0xffff, UUID_PRIMARY_SERVICE);
- ssize_t r = read(l2cap, buffer, MAX_MTU);
- ByteBuffer in = ByteBuffer(buffer, MAX_MTU, r);
+ D << "pdu.size()=" << out.getSize();
+ ssize_t written = write(l2cap, buffer, out.getSize());
- D << "read: " << r << " bytes";
+ D << "written=" << written;
- vector<AttributeData> values = AttPdu::parseReadByGroupType(in);
+ ssize_t r = read(l2cap, buffer, MAX_MTU);
+ ByteBuffer in = ByteBuffer(buffer, MAX_MTU, r);
- D << "READ_BY_GROUP_TYPE response has " + to_string(values.size()) + " values";
+ D << "read: " << r << " bytes";
- for (auto &data: values) {
- D << "handle: " << data.handle << ", value: " << data.value.toString();
- }
- }
+ vector<AttributeData> values = AttPdu::parseReadByGroupType(in);
- // -----------------------------------------------------------------------
- // Adapter
- // -----------------------------------------------------------------------
+ D << "READ_BY_GROUP_TYPE response has " + to_string(values.size()) + " values";
+ for (auto &data: values) {
+ D << "handle: " << data.handle << ", groupEndHandle: " << data.groupEndHandle << ", value: " << data.value.toString();
+ }
+}
- LinuxBluetoothAdapter::LinuxBluetoothAdapter(int hciDeviceId) {
- DF << "hciDeviceId=" << hciDeviceId;
+// -----------------------------------------------------------------------
+// Adapter
+// -----------------------------------------------------------------------
- this->hciDeviceId = hciDeviceId;
- hciSocket = ::hci_open_dev(hciDeviceId);
+LinuxBluetoothAdapter::LinuxBluetoothAdapter(int hciDeviceId) :
+ scanning(false) {
+ DF << "hciDeviceId=" << hciDeviceId;
- D << "HCI socket: " << hciSocket;
+ this->hciDeviceId = hciDeviceId;
+ hciSocket = ::hci_open_dev(hciDeviceId);
- if (hciSocket == -1) {
- throw BluetoothException(this, "Could not open HCI device " + hciDeviceId);
- }
+ D << "HCI socket: " << hciSocket;
- hci_filter_clear(&hciFilter);
- hci_filter_set_ptype(HCI_EVENT_PKT, &hciFilter);
- hci_filter_set_event(EVT_LE_META_EVENT, &hciFilter);
- hci_filter_set_event(EVT_LE_ADVERTISING_REPORT, &hciFilter);
- setsockopt(hciSocket, SOL_HCI, HCI_FILTER, &hciFilter, sizeof(hciFilter));
+ if (hciSocket == -1) {
+ throw BluetoothException(this, "Could not open HCI device " + hciDeviceId);
}
- LinuxBluetoothAdapter::~LinuxBluetoothAdapter() {
- DF;
+ hci_filter_clear(&hciFilter);
+ hci_filter_set_ptype(HCI_EVENT_PKT, &hciFilter);
+ hci_filter_set_event(EVT_LE_META_EVENT, &hciFilter);
+ hci_filter_set_event(EVT_LE_ADVERTISING_REPORT, &hciFilter);
+ setsockopt(hciSocket, SOL_HCI, HCI_FILTER, &hciFilter, sizeof(hciFilter));
+}
- stopScan();
+LinuxBluetoothAdapter::~LinuxBluetoothAdapter() {
+ DF;
- close(hciSocket);
- }
+ stopScan();
- void LinuxBluetoothAdapter::startScan() {
- DF;
+ close(hciSocket);
- struct hci_dev_info di;
+ D << "Depeting " << devices.size() << " devices";
- if (hci_devinfo(hciDeviceId, &di) < 0) {
- throw BluetoothException(this, "hci_devinfo: " + hciDeviceId);
- }
+ for (auto &pair : devices) {
+ delete pair.second;
+ }
+}
- D << "hciDeviceId.dev_id=" << di.dev_id;
- D << "hciDeviceId.bdaddr=" << parseMac(di.bdaddr).str();
- D << "hciDeviceId.flags=" << hex << setw(8) << setfill('0') << di.flags;
- D << "hciDeviceId.flags RUNNING = " << hci_test_bit(HCI_RUNNING, &di.flags);
- D << "hciDeviceId.flags UP = " << hci_test_bit(HCI_UP, &di.flags);
- D << "hciDeviceId.flags PSCAN = " << hci_test_bit(HCI_PSCAN, &di.flags);
- D << "hciDeviceId.flags ISCAN = " << hci_test_bit(HCI_ISCAN, &di.flags);
- D << "hciDeviceId.name=" << di.name;
+void LinuxBluetoothAdapter::startScan() {
+ DF;
- int up = hci_test_bit(HCI_UP, &di.flags);
+ struct hci_dev_info di;
- if (!up) {
- throw BluetoothException(this, "HCI adapter is not up: " + hciDeviceId);
- }
+ if (hci_devinfo(hciDeviceId, &di) < 0) {
+ throw BluetoothException(this, "hci_devinfo: " + hciDeviceId);
+ }
- if (hci_le_set_scan_parameters(hciSocket, 0x01, htobs(0x0010), htobs(0x0010), 0x00, 0, 1000) < 0) {
- throw BluetoothException(this, "hci_le_set_scan_parameters: " + errnoAsString());
- }
+ D << "hciDeviceId.dev_id=" << di.dev_id;
+ D << "hciDeviceId.bdaddr=" << parseMac(di.bdaddr).str();
+ D << "hciDeviceId.flags=" << hex << setw(8) << setfill('0') << di.flags;
+ D << "hciDeviceId.flags RUNNING = " << hci_test_bit(HCI_RUNNING, &di.flags);
+ D << "hciDeviceId.flags UP = " << hci_test_bit(HCI_UP, &di.flags);
+ D << "hciDeviceId.flags PSCAN = " << hci_test_bit(HCI_PSCAN, &di.flags);
+ D << "hciDeviceId.flags ISCAN = " << hci_test_bit(HCI_ISCAN, &di.flags);
+ D << "hciDeviceId.name=" << di.name;
- if (hci_le_set_scan_enable(hciSocket, 1, 0, 1000)) {
- throw BluetoothException(this, "Could not start scanning: other" + errnoAsString());
- }
+ int up = hci_test_bit(HCI_UP, &di.flags);
- scanning = true;
+ if (!up) {
+ throw BluetoothException(this, "HCI adapter is not up: " + hciDeviceId);
}
- void LinuxBluetoothAdapter::stopScan() {
- DF;
+ if (hci_le_set_scan_parameters(hciSocket, 0x01, htobs(0x0010), htobs(0x0010), 0x00, 0, 1000) < 0) {
+ throw BluetoothException(this, "hci_le_set_scan_parameters: " + errnoAsString());
+ }
- if (!scanning) {
- return;
- }
+ if (hci_le_set_scan_enable(hciSocket, 1, 0, 1000)) {
+ throw BluetoothException(this, "Could not start scanning: other" + errnoAsString());
+ }
- scanning = false;
+ scanning = true;
+}
- if (hci_le_set_scan_enable(hciSocket, 0, 0, 1000) < 0) {
- W << "stopScan: hci_le_set_scan_enable: " << errnoAsString();
- }
+void LinuxBluetoothAdapter::stopScan() {
+ DF;
+
+ if (!scanning) {
+ return;
}
- BluetoothDevice &LinuxBluetoothAdapter::getDevice(Mac &mac) {
- static map<Mac, LinuxBluetoothDevice *> devices;
+ scanning = false;
- map<Mac, LinuxBluetoothDevice *>::iterator it = devices.find(mac);
+ if (hci_le_set_scan_enable(hciSocket, 0, 0, 1000) < 0) {
+ W << "stopScan: hci_le_set_scan_enable: " << errnoAsString();
+ }
+}
- if (it == devices.end()) {
- LinuxBluetoothDevice *device = new LinuxBluetoothDevice(*this, mac);
- devices[mac] = device;
- return *device;
- }
+BluetoothDevice &LinuxBluetoothAdapter::getDevice(Mac &mac) {
+ map<Mac, LinuxBluetoothDevice *>::iterator it = devices.find(mac);
- return *it->second;
+ if (it == devices.end()) {
+ LinuxBluetoothDevice *device = new LinuxBluetoothDevice(*this, mac);
+ devices[mac] = device;
+ return *device;
}
- void LinuxBluetoothAdapter::runScan(void (*callback)(BluetoothDevice &device)) {
- fd_set rfds;
- FD_ZERO(&rfds);
- FD_SET(hciSocket, &rfds);
+ return *it->second;
+}
- startScan();
+void LinuxBluetoothAdapter::runScan(void (*callback)(BluetoothDevice &device)) {
+ fd_set rfds;
+ FD_ZERO(&rfds);
+ FD_SET(hciSocket, &rfds);
- while (scanning) {
- // Linux can change tv, so it has to be reinitialized
- struct timeval tv;
- tv.tv_sec = 1;
- tv.tv_usec = 0;
+ startScan();
- int selected = select(hciSocket + 1, &rfds, NULL, NULL, &tv);
+ while (scanning) {
+ // Linux can change tv, so it has to be reinitialized
+ struct timeval tv;
+ tv.tv_sec = 1;
+ tv.tv_usec = 0;
- if (selected == -1) {
- throw BluetoothException(this, "select() failed");
- }
+ int selected = select(hciSocket + 1, &rfds, NULL, NULL, &tv);
- if (selected == 0) {
- D << "timeout";
- // Timeout, just continue
- continue;
- }
+ if (selected == -1) {
+ throw BluetoothException(this, "select() failed");
+ }
- unsigned char hciEventBuf[HCI_MAX_EVENT_SIZE];
+ if (selected == 0) {
+ D << "timeout";
+ // Timeout, just continue
+ continue;
+ }
- ssize_t len = read(hciSocket, hciEventBuf, sizeof(hciEventBuf));
- evt_le_meta_event *metaEvent = (evt_le_meta_event *) (hciEventBuf + (1 + HCI_EVENT_HDR_SIZE));
- len -= (1 + HCI_EVENT_HDR_SIZE);
+ unsigned char hciEventBuf[HCI_MAX_EVENT_SIZE];
- D << "metaEvent->subevent = " << std::hex << (int) metaEvent->subevent;
+ ssize_t len = read(hciSocket, hciEventBuf, sizeof(hciEventBuf));
+ evt_le_meta_event *metaEvent = (evt_le_meta_event *) (hciEventBuf + (1 + HCI_EVENT_HDR_SIZE));
+ len -= (1 + HCI_EVENT_HDR_SIZE);
- if (metaEvent->subevent == EVT_LE_ADVERTISING_REPORT) {
- le_advertising_info *advertisingInfo = (le_advertising_info *) (metaEvent->data + 1);
+ D << "metaEvent->subevent = " << std::hex << (int) metaEvent->subevent;
- Mac mac = parseMac(advertisingInfo->bdaddr);
+ if (metaEvent->subevent == EVT_LE_ADVERTISING_REPORT) {
+ le_advertising_info *advertisingInfo = (le_advertising_info *) (metaEvent->data + 1);
- BluetoothDevice &device = getDevice(mac);
+ Mac mac = parseMac(advertisingInfo->bdaddr);
- callback(device);
- }
+ BluetoothDevice &device = getDevice(mac);
+
+ callback(device);
}
}
+}
+
+}}}
- // -----------------------------------------------------------------------
- //
- // -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// Implementation of platform-specific method.
+// -----------------------------------------------------------------------
- /*
- map<int, LinuxBluetoothAdapter *> adapters;
+namespace trygvis {
+namespace bluetooth {
+using namespace trygvis::bluetooth::linux;
- BluetoothAdapter &getAdapter(int hciDevice) {
- map<int, LinuxBluetoothAdapter *>::iterator it = adapters.find(hciDevice);
+map<int, LinuxBluetoothAdapter *> adapters;
- if (it == adapters.end()) {
- LinuxBluetoothAdapter *adapter = new LinuxBluetoothAdapter(hciDevice);
- adapters[hciDevice] = adapter;
- return *adapter;
- }
+LinuxBluetoothAdapter &getAdapterImpl(int hciDevice) {
+ map<int, LinuxBluetoothAdapter *>::iterator it = adapters.find(hciDevice);
- return *it->second;
+ if (it == adapters.end()) {
+ LinuxBluetoothAdapter *adapter = new LinuxBluetoothAdapter(hciDevice);
+ adapters[hciDevice] = adapter;
+ return *adapter;
}
- */
- BluetoothAdapter *getAdapter(int hciDevice) {
- return new LinuxBluetoothAdapter(hciDevice);
+ return *it->second;
+}
+
+void shutdownImpl() {
+ for (auto &pair: adapters) {
+ delete pair.second;
}
-};
+}
+
+}}
diff --git a/main.cpp b/main.cpp
index 0ff7eed..2bdf486 100644
--- a/main.cpp
+++ b/main.cpp
@@ -3,9 +3,9 @@
#include "Bluetooth.h"
using namespace std;
-using namespace trygvis;
+using namespace trygvis::bluetooth;
-static Mac *targetMac;
+Mac *targetMac;
void scan_callback(BluetoothDevice &device) {
device.adapter().stopScan();
@@ -30,14 +30,14 @@ int main(int argc, char *argv[]) {
return EXIT_FAILURE;
}
- BluetoothAdapter *adapter = nullptr;
int e;
try {
- targetMac = Mac::parseMac(argv[1]);
+ Mac mac = Mac::parseMac(argv[1]);
+ targetMac = &mac;
- adapter = trygvis::getAdapter(0);
+ BluetoothAdapter &adapter = getAdapter(0);
- BluetoothDevice &device = adapter->getDevice(*targetMac);
+ BluetoothDevice &device = adapter.getDevice(mac);
scan_callback(device);
@@ -52,8 +52,6 @@ int main(int argc, char *argv[]) {
e = EXIT_FAILURE;
}
- if (adapter != nullptr) {
- delete adapter;
- }
+ shutdown();
return e;
}
diff --git a/test/ByteBufferTest.cpp b/test/ByteBufferTest.cpp
index f98a770..70a98ab 100644
--- a/test/ByteBufferTest.cpp
+++ b/test/ByteBufferTest.cpp
@@ -1,12 +1,20 @@
#include "ByteBuffer.h"
-#define BOOST_TEST_DYN_LINK
-
-//Define our Module name (prints at testing)
#define BOOST_TEST_MODULE "ByteBuffer"
#include <boost/test/unit_test.hpp>
+class Utils {
+public:
+ uint8_t bytes[1000];
+
+ Utils() {
+ for (int i = 0; i < sizeof(bytes); i++) {
+ bytes[i] = (uint8_t) i;
+ }
+ }
+};
+
void checkBuffer(ByteBuffer& buffer, size_t size, size_t capacity, size_t cursor) {
BOOST_CHECK(buffer.getSize() == size);
BOOST_CHECK(buffer.getCapacity() == capacity);
@@ -14,13 +22,8 @@ void checkBuffer(ByteBuffer& buffer, size_t size, size_t capacity, size_t cursor
}
BOOST_AUTO_TEST_CASE(empty_buffer) {
- uint8_t bytes[1000];
-
- for (int i = 0; i < sizeof(bytes); i++) {
- bytes[i] = (uint8_t) i;
- }
-
- ByteBuffer buffer(bytes, sizeof(bytes), 0, 0);
+ Utils u;
+ ByteBuffer buffer(u.bytes, sizeof(u.bytes), 0, 0);
checkBuffer(buffer, 0, 1000, 0);
@@ -32,13 +35,17 @@ BOOST_AUTO_TEST_CASE(empty_buffer) {
}
BOOST_AUTO_TEST_CASE(basic) {
- uint8_t bytes[1000];
+ Utils u;
+ ByteBuffer buffer(u.bytes, sizeof(u.bytes), 10, 0);
+ checkBuffer(buffer, 10, 1000, 0);
- for (int i = 0; i < sizeof(bytes); i++) {
- bytes[i] = (uint8_t) i;
- }
+ buffer.get8();
+ checkBuffer(buffer, 10, 1000, 1);
+}
- ByteBuffer buffer(bytes, sizeof(bytes), 10, 0);
+BOOST_AUTO_TEST_CASE(view) {
+ Utils u;
+ ByteBuffer buffer(u.bytes, sizeof(u.bytes), 10, 0);
checkBuffer(buffer, 10, 1000, 0);
buffer.get8();