303 lines
9.3 KiB
C++
303 lines
9.3 KiB
C++
// some code snippets taken from
|
|
// https://github.com/nkolban/esp32-snippets/tree/master/BLE/scanner
|
|
|
|
#include "blescan.h"
|
|
|
|
#define BT_BD_ADDR_HEX(addr) \
|
|
addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]
|
|
|
|
// local Tag for logging
|
|
static const char TAG[] = "bluetooth";
|
|
|
|
#ifdef VERBOSE
|
|
const char *bt_addr_t_to_string(esp_ble_addr_type_t type) {
|
|
switch (type) {
|
|
case BLE_ADDR_TYPE_PUBLIC:
|
|
return "BLE_ADDR_TYPE_PUBLIC";
|
|
case BLE_ADDR_TYPE_RANDOM:
|
|
return "BLE_ADDR_TYPE_RANDOM";
|
|
case BLE_ADDR_TYPE_RPA_PUBLIC:
|
|
return "BLE_ADDR_TYPE_RPA_PUBLIC";
|
|
case BLE_ADDR_TYPE_RPA_RANDOM:
|
|
return "BLE_ADDR_TYPE_RPA_RANDOM";
|
|
default:
|
|
return "Unknown addr_t";
|
|
}
|
|
} // bt_addr_t_to_string
|
|
|
|
const char *btsig_gap_type(uint32_t gap_type) {
|
|
switch (gap_type) {
|
|
case 0x01:
|
|
return "Flags";
|
|
case 0x02:
|
|
return "Incomplete List of 16-bit Service Class UUIDs";
|
|
case 0x03:
|
|
return "Complete List of 16-bit Service Class UUIDs";
|
|
case 0x04:
|
|
return "Incomplete List of 32-bit Service Class UUIDs";
|
|
case 0x05:
|
|
return "Complete List of 32-bit Service Class UUIDs";
|
|
case 0x06:
|
|
return "Incomplete List of 128-bit Service Class UUIDs";
|
|
case 0x07:
|
|
return "Complete List of 128-bit Service Class UUIDs";
|
|
case 0x08:
|
|
return "Shortened Local Name";
|
|
case 0x09:
|
|
return "Complete Local Name";
|
|
case 0x0A:
|
|
return "Tx Power Level";
|
|
case 0x0D:
|
|
return "Class of Device";
|
|
case 0x0E:
|
|
return "Simple Pairing Hash C/C-192";
|
|
case 0x0F:
|
|
return "Simple Pairing Randomizer R/R-192";
|
|
case 0x10:
|
|
return "Device ID/Security Manager TK Value";
|
|
case 0x11:
|
|
return "Security Manager Out of Band Flags";
|
|
case 0x12:
|
|
return "Slave Connection Interval Range";
|
|
case 0x14:
|
|
return "List of 16-bit Service Solicitation UUIDs";
|
|
case 0x1F:
|
|
return "List of 32-bit Service Solicitation UUIDs";
|
|
case 0x15:
|
|
return "List of 128-bit Service Solicitation UUIDs";
|
|
case 0x16:
|
|
return "Service Data - 16-bit UUID";
|
|
case 0x20:
|
|
return "Service Data - 32-bit UUID";
|
|
case 0x21:
|
|
return "Service Data - 128-bit UUID";
|
|
case 0x22:
|
|
return "LE Secure Connections Confirmation Value";
|
|
case 0x23:
|
|
return "LE Secure Connections Random Value";
|
|
case 0x24:
|
|
return "URI";
|
|
case 0x25:
|
|
return "Indoor Positioning";
|
|
case 0x26:
|
|
return "Transport Discovery Data";
|
|
case 0x17:
|
|
return "Public Target Address";
|
|
case 0x18:
|
|
return "Random Target Address";
|
|
case 0x19:
|
|
return "Appearance";
|
|
case 0x1A:
|
|
return "Advertising Interval";
|
|
case 0x1B:
|
|
return "LE Bluetooth Device Address";
|
|
case 0x1C:
|
|
return "LE Role";
|
|
case 0x1D:
|
|
return "Simple Pairing Hash C-256";
|
|
case 0x1E:
|
|
return "Simple Pairing Randomizer R-256";
|
|
case 0x3D:
|
|
return "3D Information Data";
|
|
case 0xFF:
|
|
return "Manufacturer Specific Data";
|
|
|
|
default:
|
|
return "Unknown type";
|
|
}
|
|
} // btsig_gap_type
|
|
#endif
|
|
|
|
// using IRAM_ATTR here to speed up callback function
|
|
IRAM_ATTR void gap_callback_handler(esp_gap_ble_cb_event_t event,
|
|
esp_ble_gap_cb_param_t *param) {
|
|
|
|
esp_ble_gap_cb_param_t *p = (esp_ble_gap_cb_param_t *)param;
|
|
|
|
#if (COUNT_ENS)
|
|
// UUID of Exposure Notification Service (ENS)
|
|
// https://blog.google/documents/70/Exposure_Notification_-_Bluetooth_Specification_v1.2.2.pdf
|
|
static const char ensMagicBytes[] = "\x16\x6f\xfd";
|
|
#endif
|
|
|
|
#ifdef VERBOSE
|
|
ESP_LOGV(TAG, "BT payload rcvd -> type: 0x%.2x -> %s", *p->scan_rst.ble_adv,
|
|
btsig_gap_type(*p->scan_rst.ble_adv));
|
|
#endif
|
|
|
|
switch (event) {
|
|
case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
|
|
// restart scan
|
|
esp_ble_gap_start_scanning(BLESCANTIME);
|
|
break;
|
|
|
|
case ESP_GAP_BLE_SCAN_RESULT_EVT:
|
|
// evaluate scan results
|
|
if (p->scan_rst.search_evt ==
|
|
ESP_GAP_SEARCH_INQ_CMPL_EVT) // Inquiry complete, scan is done
|
|
{ // restart scan
|
|
esp_ble_gap_start_scanning(BLESCANTIME);
|
|
return;
|
|
}
|
|
|
|
if (p->scan_rst.search_evt ==
|
|
ESP_GAP_SEARCH_INQ_RES_EVT) // Inquiry result for a peer device
|
|
{ // evaluate sniffed packet
|
|
#ifdef VERBOSE
|
|
ESP_LOGV(TAG, "Device address (bda): %02x:%02x:%02x:%02x:%02x:%02x",
|
|
BT_BD_ADDR_HEX(p->scan_rst.bda));
|
|
ESP_LOGV(TAG, "Addr_type : %s",
|
|
bt_addr_t_to_string(p->scan_rst.ble_addr_type));
|
|
ESP_LOGV(TAG, "RSSI : %d", p->scan_rst.rssi);
|
|
#endif
|
|
|
|
#if (MACFILTER)
|
|
if ((p->scan_rst.ble_addr_type == BLE_ADDR_TYPE_RANDOM) ||
|
|
(p->scan_rst.ble_addr_type == BLE_ADDR_TYPE_RPA_RANDOM)) {
|
|
#ifdef VERBOSE
|
|
ESP_LOGV(TAG, "BT device filtered");
|
|
#endif
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
// add this device mac to processing queue
|
|
|
|
#if (COUNT_ENS)
|
|
// check for ens signature
|
|
if (cfg.enscount) {
|
|
if (strstr((const char *)p->scan_rst.ble_adv, ensMagicBytes) != NULL)
|
|
mac_add((uint8_t *)p->scan_rst.bda, p->scan_rst.rssi,
|
|
MAC_SNIFF_BLE_ENS);
|
|
else
|
|
mac_add((uint8_t *)p->scan_rst.bda, p->scan_rst.rssi, MAC_SNIFF_BLE);
|
|
}
|
|
#else
|
|
mac_add((uint8_t *)p->scan_rst.bda, p->scan_rst.rssi, MAC_SNIFF_BLE);
|
|
#endif
|
|
|
|
/* to be improved in macfilter:
|
|
// you can search for elements in the payload using the
|
|
// function esp_ble_resolve_adv_data()
|
|
//
|
|
// Like this, that scans for the "Complete name" (looking inside the
|
|
payload buffer)
|
|
// uint8_t len;
|
|
// uint8_t *data = esp_ble_resolve_adv_data(p->scan_rst.ble_adv,
|
|
ESP_BLE_AD_TYPE_NAME_CMPL, &len);
|
|
|
|
filter BLE devices using their advertisements to get filter alternative
|
|
to vendor OUI if macfiltering is on, we ...
|
|
- want to count: mobile phones and tablets
|
|
- don't want to count: beacons, peripherals (earphones, headsets,
|
|
printers), cars and machines see
|
|
https://github.com/nkolban/ESP32_BLE_Arduino/blob/master/src/BLEAdvertisedDevice.cpp
|
|
|
|
http://www.libelium.com/products/meshlium/smartphone-detection/
|
|
|
|
https://www.question-defense.com/2013/01/12/bluetooth-cod-bluetooth-class-of-deviceclass-of-service-explained
|
|
|
|
https://www.bluetooth.com/specifications/assigned-numbers/baseband
|
|
|
|
"The Class of Device (CoD) in case of Bluetooth which allows us to
|
|
differentiate the type of device (smartphone, handsfree, computer,
|
|
LAN/network AP). With this parameter we can differentiate among
|
|
pedestrians and vehicles."
|
|
|
|
*/
|
|
|
|
} // evaluate sniffed packet
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
} // switch
|
|
} // gap_callback_handler
|
|
|
|
esp_err_t register_ble_callback(bool unregister = false) {
|
|
|
|
if (unregister) {
|
|
|
|
ESP_LOGI(TAG, "Unregister GAP callback...");
|
|
esp_ble_gap_stop_scanning();
|
|
esp_ble_gap_register_callback(NULL);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ESP_LOGI(TAG, "Register GAP callback...");
|
|
|
|
// This function is called when gap event occurs, such as scan result.
|
|
// register the scan callback function to the gap module
|
|
esp_ble_gap_register_callback(&gap_callback_handler);
|
|
|
|
static esp_ble_scan_params_t ble_scan_params = {
|
|
.scan_type = BLE_SCAN_TYPE_PASSIVE,
|
|
.own_addr_type = BLE_ADDR_TYPE_RANDOM,
|
|
.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL,
|
|
|
|
/*
|
|
#if (MACFILTER)
|
|
.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_WLIST_PRA_DIR,
|
|
// ADV_IND, ADV_NONCONN_IND, ADV_SCAN_IND packets are used
|
|
for broadcasting
|
|
// data in broadcast applications (e.g., Beacons), so we
|
|
don't want them in
|
|
// macfilter mode
|
|
#else
|
|
.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL,
|
|
#endif
|
|
*/
|
|
|
|
.scan_interval =
|
|
(uint16_t)(cfg.blescantime * 10 / 0.625), // Time = N * 0.625 msec
|
|
.scan_window =
|
|
(uint16_t)(BLESCANWINDOW / 0.625), // Time = N * 0.625 msec
|
|
.scan_duplicate = BLE_SCAN_DUPLICATE_ENABLE};
|
|
|
|
ESP_LOGI(TAG, "Set GAP scan parameters");
|
|
|
|
// This function is called to set scan parameters.
|
|
esp_ble_gap_set_scan_params(&ble_scan_params);
|
|
}
|
|
|
|
return ESP_OK;
|
|
|
|
} // register_ble_callback
|
|
|
|
void start_BLEscan(void) {
|
|
#if (BLECOUNTER)
|
|
ESP_LOGI(TAG, "Initializing bluetooth scanner ...");
|
|
// Initialize BT controller to allocate task and other resource.
|
|
if (btStart()) { // enable bt_controller
|
|
esp_coex_preference_set(ESP_COEX_PREFER_BT);
|
|
esp_bluedroid_init();
|
|
esp_bluedroid_enable();
|
|
// Register callback function for capturing bluetooth packets
|
|
register_ble_callback(false);
|
|
ESP_LOGI(TAG, "Bluetooth scanner started");
|
|
} else {
|
|
ESP_LOGE(TAG, "Bluetooth controller start failed. Resetting device");
|
|
do_reset(true);
|
|
}
|
|
#endif // BLECOUNTER
|
|
} // start_BLEscan
|
|
|
|
void stop_BLEscan(void) {
|
|
#if (BLECOUNTER)
|
|
ESP_LOGI(TAG, "Shutting down bluetooth scanner ...");
|
|
register_ble_callback(true); // unregister capture function
|
|
ESP_LOGD(TAG, "bluedroid disable...");
|
|
esp_bluedroid_disable();
|
|
ESP_LOGD(TAG, "bluedroid deinit...");
|
|
esp_bluedroid_deinit();
|
|
if (!btStop()) { // disable bt_controller
|
|
ESP_LOGE(TAG, "Bluetooth controller stop failed. Resetting device");
|
|
do_reset(true);
|
|
}
|
|
esp_coex_preference_set(ESP_COEX_PREFER_WIFI);
|
|
ESP_LOGI(TAG, "Bluetooth scanner stopped");
|
|
#endif // BLECOUNTER
|
|
} // stop_BLEscan
|