mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-04-25 09:02:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

rename central_device_db into le_device_db

Browse Source
This commit is contained in:
matthias.ringwald@gmail.com 2015-03-02 21:30:12 +00:00
parent d2d764240d
commit c5d3944d90
9 changed files with 112 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
ble/att_server.c
View File

@ -80,7 +80,7 @@ static bd_addr_t att_client_address;
static uint16_t att_request_size = 0; static uint16_t att_request_size = 0;
static uint8_t att_request_buffer[HCI_ACL_PAYLOAD_SIZE]; static uint8_t att_request_buffer[HCI_ACL_PAYLOAD_SIZE];
static int att_ir_central_device_db_index = -1; static int att_ir_le_device_db_index = -1;
static int att_ir_lookup_active = 0; static int att_ir_lookup_active = 0;
static int att_handle_value_indication_handle = 0; static int att_handle_value_indication_handle = 0;
@ -162,14 +162,14 @@ static void att_event_packet_handler (uint8_t packet_type, uint16_t channel, uin
break; break;
case SM_IDENTITY_RESOLVING_SUCCEEDED: case SM_IDENTITY_RESOLVING_SUCCEEDED:
att_ir_lookup_active = 0; att_ir_lookup_active = 0;
att_ir_central_device_db_index = ((sm_event_t*) packet)->central_device_db_index; att_ir_le_device_db_index = ((sm_event_t*) packet)->central_device_db_index;
log_info("SM_IDENTITY_RESOLVING_SUCCEEDED id %u", att_ir_central_device_db_index); log_info("SM_IDENTITY_RESOLVING_SUCCEEDED id %u", att_ir_le_device_db_index);
att_run(); att_run();
break; break;
case SM_IDENTITY_RESOLVING_FAILED: case SM_IDENTITY_RESOLVING_FAILED:
log_info("SM_IDENTITY_RESOLVING_FAILED"); log_info("SM_IDENTITY_RESOLVING_FAILED");
att_ir_lookup_active = 0; att_ir_lookup_active = 0;
att_ir_central_device_db_index = -1; att_ir_le_device_db_index = -1;
att_run(); att_run();
break; break;
@ -203,7 +203,7 @@ static void att_signed_write_handle_cmac_result(uint8_t hash[8]){
// update sequence number // update sequence number
uint32_t counter_packet = READ_BT_32(att_request_buffer, att_request_size-12); uint32_t counter_packet = READ_BT_32(att_request_buffer, att_request_size-12);
central_device_db_remote_counter_set(att_ir_central_device_db_index, counter_packet+1); le_device_db_remote_counter_set(att_ir_le_device_db_index, counter_packet+1);
att_server_state = ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED; att_server_state = ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED;
att_run(); att_run();
} }
@ -229,7 +229,7 @@ static void att_run(void){
if (att_ir_lookup_active){ if (att_ir_lookup_active){
return; return;
} }
if (att_ir_central_device_db_index < 0){ if (att_ir_le_device_db_index < 0){
log_info("ATT Signed Write, CSRK not available"); log_info("ATT Signed Write, CSRK not available");
att_server_state = ATT_SERVER_IDLE; att_server_state = ATT_SERVER_IDLE;
return; return;
@ -237,7 +237,7 @@ static void att_run(void){
// check counter // check counter
uint32_t counter_packet = READ_BT_32(att_request_buffer, att_request_size-12); uint32_t counter_packet = READ_BT_32(att_request_buffer, att_request_size-12);
uint32_t counter_db = central_device_db_remote_counter_get(att_ir_central_device_db_index); uint32_t counter_db = le_device_db_remote_counter_get(att_ir_le_device_db_index);
log_info("ATT Signed Write, DB counter %u, packet counter %u", counter_db, counter_packet); log_info("ATT Signed Write, DB counter %u, packet counter %u", counter_db, counter_packet);
if (counter_packet < counter_db){ if (counter_packet < counter_db){
log_info("ATT Signed Write, db reports higher counter, abort"); log_info("ATT Signed Write, db reports higher counter, abort");
@ -247,7 +247,7 @@ static void att_run(void){
// signature is { sequence counter, secure hash } // signature is { sequence counter, secure hash }
sm_key_t csrk; sm_key_t csrk;
central_device_db_csrk_get(att_ir_central_device_db_index, csrk); le_device_db_csrk_get(att_ir_le_device_db_index, csrk);
att_server_state = ATT_SERVER_W4_SIGNED_WRITE_VALIDATION; att_server_state = ATT_SERVER_W4_SIGNED_WRITE_VALIDATION;
log_info("Orig Signature: "); log_info("Orig Signature: ");
hexdump( &att_request_buffer[att_request_size-8], 8); hexdump( &att_request_buffer[att_request_size-8], 8);

44
ble/central_device_db.h
View File

@ -35,8 +35,8 @@
* *
*/ */
#ifndef __CENTRAL_DEVICE_DB_H #ifndef __LE_DEVICE_DB_H
#define __CENTRAL_DEVICE_DB_H #define __LE_DEVICE_DB_H
#include <btstack/utils.h> #include <btstack/utils.h>
@ -46,25 +46,25 @@ extern "C" {
/** /**
A Central Device DB is only required for signed writes LE Device DB for pure LE Peripherals is only required for signed writes
Per bonded device, it stores the Identity Resolving Key (IRK), the Connection Signature Resolving Key (CSRK) Per bonded device, it can store
and the last used counter - it stores the Identity Resolving Key (IRK) and its address to resolve private addresses
- it stores the LTK + EDIV, RAND. EDIV + RAND allow a LE Perihperal to reconstruct the LTK
The IRK is necessary to identify a device that uses private addresses - it stores the Connection Signature Resolving Key (CSRK) and the last used counter.
The CSRK is used to generate the signatur on the remote device and is needed to verify the signature itself The CSRK is used to generate the signatur on the remote device and is needed to verify the signature itself
The Counter is necessary to prevent reply attacks The Counter is necessary to prevent reply attacks
*/ */
// Central Device db interface // LE Device db interface
/** /**
* @brief init * @brief init
*/ */
void central_device_db_init(); void le_device_db_init();
/** /**
* @brief add device to db * @brief add device to db
@ -72,13 +72,13 @@ void central_device_db_init();
* @param irk of the device * @param irk of the device
* @returns index if successful, -1 otherwise * @returns index if successful, -1 otherwise
*/ */
int central_device_db_add(int addr_type, bd_addr_t addr, sm_key_t irk); int le_device_db_add(int addr_type, bd_addr_t addr, sm_key_t irk);
/** /**
* @brief get number of devices in db for enumeration * @brief get number of devices in db for enumeration
* @returns number of device in db * @returns number of device in db
*/ */
int central_device_db_count(void); int le_device_db_count(void);
/** /**
* @brief get device information: addr type and address needed to identify device * @brief get device information: addr type and address needed to identify device
@ -86,7 +86,7 @@ int central_device_db_count(void);
* @param addr_type, address of the device as output * @param addr_type, address of the device as output
* @param irk of the device * @param irk of the device
*/ */
void central_device_db_info(int index, int * addr_type, bd_addr_t addr, sm_key_t irk); void le_device_db_info(int index, int * addr_type, bd_addr_t addr, sm_key_t irk);
/** /**
@ -96,7 +96,7 @@ void central_device_db_info(int index, int * addr_type, bd_addr_t addr, sm_key_t
* @brief rand * @brief rand
* @brief ltk * @brief ltk
*/ */
void central_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8], sm_key_t ltk); void le_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8], sm_key_t ltk);
/** /**
* @brief get remote encryption info * @brief get remote encryption info
@ -105,58 +105,58 @@ void central_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8],
* @brief rand * @brief rand
* @brief ltk * @brief ltk
*/ */
void central_device_db_encryption_get(int index, uint16_t * ediv, uint8_t rand[8], sm_key_t ltk); void le_device_db_encryption_get(int index, uint16_t * ediv, uint8_t rand[8], sm_key_t ltk);
/** /**
* @brief set signing key for this device * @brief set signing key for this device
* @param index * @param index
* @param signing key as input * @param signing key as input
*/ */
void central_device_db_csrk_set(int index, sm_key_t csrk); void le_device_db_csrk_set(int index, sm_key_t csrk);
/** /**
* @brief get signing key for this device * @brief get signing key for this device
* @param index * @param index
* @param signing key as output * @param signing key as output
*/ */
void central_device_db_csrk_get(int index, sm_key_t csrk); void le_device_db_csrk_get(int index, sm_key_t csrk);
/** /**
* @brief query last used/seen signing counter * @brief query last used/seen signing counter
* @param index * @param index
* @returns next expected counter, 0 after devices was added * @returns next expected counter, 0 after devices was added
*/ */
uint32_t central_device_db_remote_counter_get(int index); uint32_t le_device_db_remote_counter_get(int index);
/** /**
* @brief update signing counter * @brief update signing counter
* @param index * @param index
* @param counter to store * @param counter to store
*/ */
void central_device_db_remote_counter_set(int index, uint32_t counter); void le_device_db_remote_counter_set(int index, uint32_t counter);
/** /**
* @brief query last used/seen signing counter * @brief query last used/seen signing counter
* @param index * @param index
* @returns next expected counter, 0 after devices was added * @returns next expected counter, 0 after devices was added
*/ */
uint32_t central_device_db_local_counter_get(int index); uint32_t le_device_db_local_counter_get(int index);
/** /**
* @brief update signing counter * @brief update signing counter
* @param index * @param index
* @param counter to store * @param counter to store
*/ */
void central_device_db_local_counter_set(int index, uint32_t counter); void le_device_db_local_counter_set(int index, uint32_t counter);
/** /**
* @brief free device * @brief free device
* @param index * @param index
*/ */
void central_device_db_remove(int index); void le_device_db_remove(int index);
#if defined __cplusplus #if defined __cplusplus
} }
#endif #endif
#endif // __CENTRAL_DEVICE_DB_H #endif // __LE_DEVICE_DB_H

24
ble/central_device_db_dummy.c
View File

@ -37,15 +37,15 @@
#include "central_device_db.h" #include "central_device_db.h"
// Central Device db interface // Central Device db interface
void central_device_db_init(){} void le_device_db_init(){}
// @returns index if successful, -1 otherwise // @returns index if successful, -1 otherwise
int central_device_db_add(int addr_type, bd_addr_t addr, sm_key_t irk){ int le_device_db_add(int addr_type, bd_addr_t addr, sm_key_t irk){
return -1; return -1;
} }
// @returns number of device in db // @returns number of device in db
int central_device_db_count(void){ int le_device_db_count(void){
return 0; return 0;
} }
@ -56,7 +56,7 @@ int central_device_db_count(void){
* @brief rand * @brief rand
* @brief ltk * @brief ltk
*/ */
void central_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8], sm_key_t ltk){} void le_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8], sm_key_t ltk){}
/** /**
* @brief get remote encryption info * @brief get remote encryption info
@ -65,30 +65,30 @@ void central_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8],
* @brief rand * @brief rand
* @brief ltk * @brief ltk
*/ */
void central_device_db_encryption_get(int index, uint16_t * ediv, uint8_t rand[8], sm_key_t ltk){} void le_device_db_encryption_get(int index, uint16_t * ediv, uint8_t rand[8], sm_key_t ltk){}
// get device information: addr type and address // get device information: addr type and address
void central_device_db_info(int index, int * addr_type, bd_addr_t addr, sm_key_t csrk){} void le_device_db_info(int index, int * addr_type, bd_addr_t addr, sm_key_t csrk){}
// get signature key // get signature key
void central_device_db_csrk_get(int index, sm_key_t csrk){} void le_device_db_csrk_get(int index, sm_key_t csrk){}
// query last used/seen signing counter // query last used/seen signing counter
uint32_t central_device_db_remote_counter_get(int index){ uint32_t le_device_db_remote_counter_get(int index){
return 0xffffffff; return 0xffffffff;
} }
// update signing counter // update signing counter
void central_device_db_local_counter_set(int index, uint32_t counter){} void le_device_db_local_counter_set(int index, uint32_t counter){}
// query last used/seen signing counter // query last used/seen signing counter
uint32_t central_device_db_local_counter_get(int index){ uint32_t le_device_db_local_counter_get(int index){
return 0xffffffff; return 0xffffffff;
} }
// update signing counter // update signing counter
void central_device_db_remote_counter_set(int index, uint32_t counter){} void le_device_db_remote_counter_set(int index, uint32_t counter){}
// free device // free device
void central_device_db_remove(int index){} void le_device_db_remove(int index){}

100
ble/central_device_db_memory.c
View File

@ -42,7 +42,7 @@
#include "debug.h" #include "debug.h"
// Central Device db implemenation using static memory // Central Device db implemenation using static memory
typedef struct central_device_memory_db { typedef struct le_device_memory_db {
// Identification // Identification
int addr_type; int addr_type;
@ -62,40 +62,40 @@ typedef struct central_device_memory_db {
// Signed Writes to remote (local CSRK is fixed) // Signed Writes to remote (local CSRK is fixed)
uint32_t local_counter; uint32_t local_counter;
} central_device_memory_db_t; } le_device_memory_db_t;
#define CENTRAL_DEVICE_MEMORY_SIZE 4 #define LE_DEVICE_MEMORY_SIZE 4
#define INVALID_ENTRY_ADDR_TYPE 0xff #define INVALID_ENTRY_ADDR_TYPE 0xff
static central_device_memory_db_t central_devices[CENTRAL_DEVICE_MEMORY_SIZE]; static le_device_memory_db_t le_devices[LE_DEVICE_MEMORY_SIZE];
void central_device_db_init(){ void le_device_db_init(){
int i; int i;
for (i=0;i<CENTRAL_DEVICE_MEMORY_SIZE;i++){ for (i=0;i<LE_DEVICE_MEMORY_SIZE;i++){
central_device_db_remove(i); le_device_db_remove(i);
} }
} }
// @returns number of device in db // @returns number of device in db
int central_device_db_count(void){ int le_device_db_count(void){
int i; int i;
int counter = 0; int counter = 0;
for (i=0;i<CENTRAL_DEVICE_MEMORY_SIZE;i++){ for (i=0;i<LE_DEVICE_MEMORY_SIZE;i++){
if (central_devices[i].addr_type != INVALID_ENTRY_ADDR_TYPE) counter++; if (le_devices[i].addr_type != INVALID_ENTRY_ADDR_TYPE) counter++;
} }
return counter; return counter;
} }
// free device // free device
void central_device_db_remove(int index){ void le_device_db_remove(int index){
central_devices[index].addr_type = INVALID_ENTRY_ADDR_TYPE; le_devices[index].addr_type = INVALID_ENTRY_ADDR_TYPE;
} }
int central_device_db_add(int addr_type, bd_addr_t addr, sm_key_t irk){ int le_device_db_add(int addr_type, bd_addr_t addr, sm_key_t irk){
int i; int i;
int index = -1; int index = -1;
for (i=0;i<CENTRAL_DEVICE_MEMORY_SIZE;i++){ for (i=0;i<LE_DEVICE_MEMORY_SIZE;i++){
if (central_devices[i].addr_type == INVALID_ENTRY_ADDR_TYPE){ if (le_devices[i].addr_type == INVALID_ENTRY_ADDR_TYPE){
index = i; index = i;
break; break;
} }
@ -106,20 +106,20 @@ int central_device_db_add(int addr_type, bd_addr_t addr, sm_key_t irk){
log_info("Central Device DB adding type %u - %s", addr_type, bd_addr_to_str(addr)); log_info("Central Device DB adding type %u - %s", addr_type, bd_addr_to_str(addr));
log_key("irk", irk); log_key("irk", irk);
central_devices[index].addr_type = addr_type; le_devices[index].addr_type = addr_type;
memcpy(central_devices[index].addr, addr, 6); memcpy(le_devices[index].addr, addr, 6);
memcpy(central_devices[index].irk, irk, 16); memcpy(le_devices[index].irk, irk, 16);
central_devices[index].remote_counter = 0; le_devices[index].remote_counter = 0;
return index; return index;
} }
// get device information: addr type and address // get device information: addr type and address
void central_device_db_info(int index, int * addr_type, bd_addr_t addr, sm_key_t irk){ void le_device_db_info(int index, int * addr_type, bd_addr_t addr, sm_key_t irk){
if (addr_type) *addr_type = central_devices[index].addr_type; if (addr_type) *addr_type = le_devices[index].addr_type;
if (addr) memcpy(addr, central_devices[index].addr, 6); if (addr) memcpy(addr, le_devices[index].addr, 6);
if (irk) memcpy(irk, central_devices[index].irk, 16); if (irk) memcpy(irk, le_devices[index].irk, 16);
} }
/** /**
@ -129,10 +129,10 @@ void central_device_db_info(int index, int * addr_type, bd_addr_t addr, sm_key_t
* @brief rand * @brief rand
* @brief ltk * @brief ltk
*/ */
void central_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8], sm_key_t ltk){ void le_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8], sm_key_t ltk){
central_devices[index].ediv = ediv; le_devices[index].ediv = ediv;
if (rand) memcpy(central_devices[index].rand, rand, 8); if (rand) memcpy(le_devices[index].rand, rand, 8);
if (ltk) memcpy(central_devices[index].ltk, ltk, 16); if (ltk) memcpy(le_devices[index].ltk, ltk, 16);
} }
/** /**
@ -142,48 +142,48 @@ void central_device_db_encryption_set(int index, uint16_t ediv, uint8_t rand[8],
* @brief rand * @brief rand
* @brief ltk * @brief ltk
*/ */
void central_device_db_encryption_get(int index, uint16_t * ediv, uint8_t rand[8], sm_key_t ltk){ void le_device_db_encryption_get(int index, uint16_t * ediv, uint8_t rand[8], sm_key_t ltk){
if (ediv) *ediv = central_devices[index].ediv; if (ediv) *ediv = le_devices[index].ediv;
if (rand) memcpy(rand, central_devices[index].rand, 8); if (rand) memcpy(rand, le_devices[index].rand, 8);
if (ltk) memcpy(ltk, central_devices[index].ltk, 16); if (ltk) memcpy(ltk, le_devices[index].ltk, 16);
} }
// get signature key // get signature key
void central_device_db_csrk_get(int index, sm_key_t csrk){ void le_device_db_csrk_get(int index, sm_key_t csrk){
if (csrk) memcpy(csrk, central_devices[index].csrk, 16); if (csrk) memcpy(csrk, le_devices[index].csrk, 16);
} }
void central_device_db_csrk_set(int index, sm_key_t csrk){ void le_device_db_csrk_set(int index, sm_key_t csrk){
if (csrk) memcpy(central_devices[index].csrk, csrk, 16); if (csrk) memcpy(le_devices[index].csrk, csrk, 16);
} }
// query last used/seen signing counter // query last used/seen signing counter
uint32_t central_device_db_remote_counter_get(int index){ uint32_t le_device_db_remote_counter_get(int index){
return central_devices[index].remote_counter; return le_devices[index].remote_counter;
} }
// update signing counter // update signing counter
void central_device_db_remote_counter_set(int index, uint32_t counter){ void le_device_db_remote_counter_set(int index, uint32_t counter){
central_devices[index].remote_counter = counter; le_devices[index].remote_counter = counter;
} }
// query last used/seen signing counter // query last used/seen signing counter
uint32_t central_device_db_local_counter_get(int index){ uint32_t le_device_db_local_counter_get(int index){
return central_devices[index].local_counter; return le_devices[index].local_counter;
} }
// update signing counter // update signing counter
void central_device_db_local_counter_set(int index, uint32_t counter){ void le_device_db_local_counter_set(int index, uint32_t counter){
central_devices[index].local_counter = counter; le_devices[index].local_counter = counter;
} }
void central_device_db_dump(){ void le_device_db_dump(){
log_info("Central Device DB dump, devices: %u", central_device_db_count); log_info("Central Device DB dump, devices: %u", le_device_db_count);
int i; int i;
for (i=0;i<CENTRAL_DEVICE_MEMORY_SIZE;i++){ for (i=0;i<LE_DEVICE_MEMORY_SIZE;i++){
if (central_devices[i].addr_type == INVALID_ENTRY_ADDR_TYPE) continue; if (le_devices[i].addr_type == INVALID_ENTRY_ADDR_TYPE) continue;
log_info("%u: %u %s", i, central_devices[i].addr_type, bd_addr_to_str(central_devices[i].addr)); log_info("%u: %u %s", i, le_devices[i].addr_type, bd_addr_to_str(le_devices[i].addr));
log_key("irk", central_devices[i].irk); log_key("irk", le_devices[i].irk);
log_key("csrk", central_devices[i].csrk); log_key("csrk", le_devices[i].csrk);
} }
} }

22
ble/sm.c
View File

@ -919,12 +919,12 @@ static void sm_run(void){
// -- Continue with CSRK device lookup by public or resolvable private address // -- Continue with CSRK device lookup by public or resolvable private address
if (sm_central_device_test >= 0){ if (sm_central_device_test >= 0){
log_info("Central Device Lookup: device %u/%u", sm_central_device_test, central_device_db_count()); log_info("Central Device Lookup: device %u/%u", sm_central_device_test, le_device_db_count());
while (sm_central_device_test < central_device_db_count()){ while (sm_central_device_test < le_device_db_count()){
int addr_type; int addr_type;
bd_addr_t addr; bd_addr_t addr;
sm_key_t irk; sm_key_t irk;
central_device_db_info(sm_central_device_test, &addr_type, addr, irk); le_device_db_info(sm_central_device_test, &addr_type, addr, irk);
log_info("device type %u, addr: %s", addr_type, bd_addr_to_str(addr)); log_info("device type %u, addr: %s", addr_type, bd_addr_to_str(addr));
if (sm_central_device_addr_type == addr_type && memcmp(addr, sm_central_device_address, 6) == 0){ if (sm_central_device_addr_type == addr_type && memcmp(addr, sm_central_device_address, 6) == 0){
@ -954,7 +954,7 @@ static void sm_run(void){
return; return;
} }
if (sm_central_device_test >= central_device_db_count()){ if (sm_central_device_test >= le_device_db_count()){
log_info("Central Device Lookup: not found"); log_info("Central Device Lookup: not found");
sm_central_device_test = -1; sm_central_device_test = -1;
sm_csrk_connection_source->sm_csrk_lookup_state = CSRK_LOOKUP_IDLE; sm_csrk_connection_source->sm_csrk_lookup_state = CSRK_LOOKUP_IDLE;
@ -1581,7 +1581,7 @@ static void sm_event_packet_handler (uint8_t packet_type, uint16_t channel, uint
sm_conn->sm_connection_encrypted = 0; sm_conn->sm_connection_encrypted = 0;
sm_conn->sm_connection_authenticated = 0; sm_conn->sm_connection_authenticated = 0;
sm_conn->sm_connection_authorization_state = AUTHORIZATION_UNKNOWN; sm_conn->sm_connection_authorization_state = AUTHORIZATION_UNKNOWN;
sm_conn->sm_central_db_index = -1; sm_conn->sm_le_db_index = -1;
// prepare CSRK lookup (does not involve setup) // prepare CSRK lookup (does not involve setup)
sm_conn->sm_csrk_lookup_state = CSRK_LOOKUP_W4_READY; sm_conn->sm_csrk_lookup_state = CSRK_LOOKUP_W4_READY;
@ -1883,23 +1883,23 @@ static void sm_packet_handler(uint8_t packet_type, uint16_t handle, uint8_t *pac
// store, if: it's a public address, or, we got an IRK // store, if: it's a public address, or, we got an IRK
if (setup->sm_peer_addr_type == 0 || (setup->sm_key_distribution_received_set & SM_KEYDIST_FLAG_IDENTITY_INFORMATION)) { if (setup->sm_peer_addr_type == 0 || (setup->sm_key_distribution_received_set & SM_KEYDIST_FLAG_IDENTITY_INFORMATION)) {
sm_conn->sm_central_db_index = central_device_db_add(setup->sm_peer_addr_type, setup->sm_peer_address, setup->sm_peer_irk); sm_conn->sm_le_db_index = le_device_db_add(setup->sm_peer_addr_type, setup->sm_peer_address, setup->sm_peer_irk);
} }
if (sm_conn->sm_central_db_index >= 0){ if (sm_conn->sm_le_db_index >= 0){
central_device_db_local_counter_set(sm_conn->sm_central_db_index, 0); le_device_db_local_counter_set(sm_conn->sm_le_db_index, 0);
// store CSRK // store CSRK
if (setup->sm_key_distribution_received_set & SM_KEYDIST_FLAG_SIGNING_IDENTIFICATION){ if (setup->sm_key_distribution_received_set & SM_KEYDIST_FLAG_SIGNING_IDENTIFICATION){
central_device_db_csrk_set(sm_conn->sm_central_db_index, setup->sm_peer_csrk); le_device_db_csrk_set(sm_conn->sm_le_db_index, setup->sm_peer_csrk);
central_device_db_remote_counter_set(sm_conn->sm_central_db_index, 0); le_device_db_remote_counter_set(sm_conn->sm_le_db_index, 0);
} }
// store encryption information as Central // store encryption information as Central
if (sm_conn->sm_role == 0 if (sm_conn->sm_role == 0
&& setup->sm_key_distribution_received_set & SM_KEYDIST_FLAG_ENCRYPTION_INFORMATION && setup->sm_key_distribution_received_set & SM_KEYDIST_FLAG_ENCRYPTION_INFORMATION
&& setup->sm_key_distribution_received_set & SM_KEYDIST_FLAG_MASTER_IDENTIFICATION){ && setup->sm_key_distribution_received_set & SM_KEYDIST_FLAG_MASTER_IDENTIFICATION){
central_device_db_encryption_set(sm_conn->sm_central_db_index, setup->sm_peer_ediv, setup->sm_peer_rand, setup->sm_peer_ltk); le_device_db_encryption_set(sm_conn->sm_le_db_index, setup->sm_peer_ediv, setup->sm_peer_rand, setup->sm_peer_ltk);
} }
} }

4
example/embedded/ancs_client.c
View File

@ -183,8 +183,8 @@ int btstack_main(int argc, const char * argv[]){
// set up l2cap_le // set up l2cap_le
l2cap_init(); l2cap_init();
// setup central device db // setup le device db
central_device_db_init(); le_device_db_init();
// setup SM: Display only // setup SM: Display only
sm_init(); sm_init();

4
example/embedded/ble_peripheral.c
View File

@ -967,8 +967,8 @@ int btstack_main(int argc, const char * argv[]){
// set up l2cap_le // set up l2cap_le
l2cap_init(); l2cap_init();
// setup central device db // setup le device db
central_device_db_init(); le_device_db_init();
// setup SM: Display only // setup SM: Display only
sm_init(); sm_init();

4
example/embedded/spp_and_le_counter.c
View File

@ -281,8 +281,8 @@ int btstack_main(void)
hci_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO); hci_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
// setup central device db // setup le device db
central_device_db_init(); le_device_db_init();
// setup SM: Display only // setup SM: Display only
sm_init(); sm_init();

1
src/hci.h
View File

@ -456,6 +456,7 @@ typedef struct sm_connection {
authorization_state_t sm_connection_authorization_state; authorization_state_t sm_connection_authorization_state;
uint16_t sm_local_ediv; uint16_t sm_local_ediv;
uint8_t sm_local_rand[8]; uint8_t sm_local_rand[8];
int sm_le_db_index;
} sm_connection_t; } sm_connection_t;
typedef struct { typedef struct {