diff --git a/docs/Migration_guide.md b/docs/Migration_guide.md
index b655190..d1fcee8 100644
--- a/docs/Migration_guide.md
+++ b/docs/Migration_guide.md
@@ -383,18 +383,23 @@ The security callback methods are now incorporated in the `NimBLEServerCallbacks
The callback methods are:
-> `bool onConfirmPIN(uint32_t pin)`
+> `bool onConfirmPIN(const NimBLEConnInfo& connInfo, uint32_t pin)`
-Receives the pin when using numeric comparison authentication, `return true;` to accept.
+Receives the pin when using numeric comparison authentication.
+Call `NimBLEDevice::injectConfirmPIN(connInfo, true);` to accept or `NimBLEDevice::injectConfirmPIN(connInfo, false);` to reject.
-> `uint32_t onPassKeyRequest()`
+> `void onPassKeyEntry(const NimBLEConnInfo& connInfo)`
-For server callback; return the passkey expected from the client.
-For client callback; return the passkey to send to the server.
+Client callback; client should respond with the passkey (pin) by calling `NimBLEDevice::injectPassKey(connInfo, 123456);`
-> `void onAuthenticationComplete(NimBLEConnInfo& connInfo)`
+> `uint32_t onPassKeyDisplay()`
+
+Server callback; should return the passkey (pin) expected from the client.
+
+
+> `void onAuthenticationComplete(const NimBLEConnInfo& connInfo)`
Authentication complete, success or failed information is available from the `NimBLEConnInfo` methods.
diff --git a/examples/Advanced/NimBLE_Client/main/main.cpp b/examples/Advanced/NimBLE_Client/main/main.cpp
index aab186c..fe76dd0 100644
--- a/examples/Advanced/NimBLE_Client/main/main.cpp
+++ b/examples/Advanced/NimBLE_Client/main/main.cpp
@@ -39,20 +39,22 @@ class ClientCallbacks : public NimBLEClientCallbacks {
/********************* Security handled here **********************
****** Note: these are the same return values as defaults ********/
- uint32_t onPassKeyRequest(){
- printf("Client Passkey Request\n");
- /** return the passkey to send to the server */
- return 123456;
- }
+ void onPassKeyEntry(const NimBLEConnInfo& connInfo){
+ printf("Server Passkey Entry\n");
+ /** This should prompt the user to enter the passkey displayed
+ * on the peer device.
+ */
+ NimBLEDevice::injectPassKey(connInfo, 123456);
+ };
- bool onConfirmPIN(uint32_t pass_key){
- printf("The passkey YES/NO number: %" PRIu32"\n", pass_key);
- /** Return false if passkeys don't match. */
- return true;
- }
+ void onConfirmPIN(const NimBLEConnInfo& connInfo, uint32_t pass_key){
+ printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
+ /** Inject false if passkeys don't match. */
+ NimBLEDevice::injectConfirmPIN(connInfo, true);
+ };
/** Pairing process complete, we can check the results in connInfo */
- void onAuthenticationComplete(NimBLEConnInfo& connInfo){
+ void onAuthenticationComplete(const NimBLEConnInfo& connInfo){
if(!connInfo.isEncrypted()) {
printf("Encrypt connection failed - disconnecting\n");
/** Find the client with the connection handle provided in desc */
diff --git a/examples/Advanced/NimBLE_Server/main/main.cpp b/examples/Advanced/NimBLE_Server/main/main.cpp
index 8bf92e2..3effb54 100644
--- a/examples/Advanced/NimBLE_Server/main/main.cpp
+++ b/examples/Advanced/NimBLE_Server/main/main.cpp
@@ -44,21 +44,21 @@ class ServerCallbacks: public NimBLEServerCallbacks {
/********************* Security handled here **********************
****** Note: these are the same return values as defaults ********/
- uint32_t onPassKeyRequest(){
- printf("Server Passkey Request\n");
+ uint32_t onPassKeyDisplay(){
+ printf("Server Passkey Display\n");
/** This should return a random 6 digit number for security
* or make your own static passkey as done here.
*/
return 123456;
};
- bool onConfirmPIN(uint32_t pass_key){
- printf("The passkey YES/NO number: %" PRIu32"\n", pass_key);
- /** Return false if passkeys don't match. */
- return true;
+ void onConfirmPIN(const NimBLEConnInfo& connInfo, uint32_t pass_key){
+ printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
+ /** Inject false if passkeys don't match. */
+ NimBLEDevice::injectConfirmPIN(connInfo, true);
};
- void onAuthenticationComplete(NimBLEConnInfo& connInfo){
+ void onAuthenticationComplete(const NimBLEConnInfo& connInfo){
/** Check that encryption was successful, if not we disconnect the client */
if(!connInfo.isEncrypted()) {
NimBLEDevice::getServer()->disconnect(connInfo.getConnHandle());
diff --git a/examples/NimBLE_active_passive_scan/NimBLE_active_passive_scan.ino b/examples/NimBLE_active_passive_scan/NimBLE_active_passive_scan.ino
deleted file mode 100644
index 9dceb4e..0000000
--- a/examples/NimBLE_active_passive_scan/NimBLE_active_passive_scan.ino
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * NimBLE Scan active/passive switching demo
- *
- * Demonstrates the use of the scan callbacks while alternating between passive and active scanning.
- */
-
-#include "NimBLEDevice.h"
-int scanTime = 5 * 1000; // In milliseconds, 0 = scan forever
-BLEScan* pBLEScan;
-
-bool active = false;
-
-class scanCallbacks: public NimBLEScanCallbacks {
-
- void onDiscovered(NimBLEAdvertisedDevice* advertisedDevice) {
- Serial.printf("Discovered Advertised Device: %s \n", advertisedDevice->toString().c_str());
- }
-
- void onResult(NimBLEAdvertisedDevice* advertisedDevice) {
- Serial.printf("Advertised Device Result: %s \n", advertisedDevice->toString().c_str());
- }
-
- void onScanEnd(NimBLEScanResults results){
- Serial.println("Scan Ended");
- active = !active;
- pBLEScan->setActiveScan(active);
- Serial.printf("scan start, active = %u\n", active);
- pBLEScan->start(scanTime);
- }
-};
-
-
-
-void setup() {
- Serial.begin(115200);
- Serial.println("Scanning...");
-
- NimBLEDevice::init("");
- pBLEScan = NimBLEDevice::getScan();
- pBLEScan->setScanCallbacks(new scanCallbacks());
- pBLEScan->setActiveScan(active);
- pBLEScan->setInterval(100);
- pBLEScan->setWindow(99);
- pBLEScan->start(scanTime);
-}
-
-void loop() {
-}
diff --git a/examples/basic/BLE_client/main/main.cpp b/examples/basic/BLE_client/main/main.cpp
index 1830884..cfb80e9 100644
--- a/examples/basic/BLE_client/main/main.cpp
+++ b/examples/basic/BLE_client/main/main.cpp
@@ -51,17 +51,28 @@ class MyClientCallback : public BLEClientCallbacks {
}
/***************** New - Security handled here ********************
****** Note: these are the same return values as defaults ********/
- uint32_t onPassKeyRequest(){
- printf("Client PassKeyRequest\n");
- return 123456;
- }
- bool onConfirmPIN(uint32_t pass_key){
- printf("The passkey YES/NO number: %" PRIu32"\n", pass_key);
- return true;
- }
+ void onPassKeyEntry(const NimBLEConnInfo& connInfo){
+ printf("Server Passkey Entry\n");
+ /** This should prompt the user to enter the passkey displayed
+ * on the peer device.
+ */
+ NimBLEDevice::injectPassKey(connInfo, 123456);
+ };
- void onAuthenticationComplete(BLEConnInfo& connInfo){
- printf("Starting BLE work!\n");
+ void onConfirmPIN(const NimBLEConnInfo& connInfo, uint32_t pass_key){
+ printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
+ /** Inject false if passkeys don't match. */
+ NimBLEDevice::injectConfirmPIN(connInfo, true);
+ };
+
+ /** Pairing process complete, we can check the results in connInfo */
+ void onAuthenticationComplete(const NimBLEConnInfo& connInfo){
+ if(!connInfo.isEncrypted()) {
+ printf("Encrypt connection failed - disconnecting\n");
+ /** Find the client with the connection handle provided in desc */
+ NimBLEDevice::getClientByID(connInfo.getConnHandle())->disconnect();
+ return;
+ }
}
/*******************************************************************/
};
diff --git a/examples/basic/BLE_notify/main/main.cpp b/examples/basic/BLE_notify/main/main.cpp
index e966f8b..d2d80bb 100644
--- a/examples/basic/BLE_notify/main/main.cpp
+++ b/examples/basic/BLE_notify/main/main.cpp
@@ -57,19 +57,29 @@ class MyServerCallbacks: public BLEServerCallbacks {
}
/***************** New - Security handled here ********************
****** Note: these are the same return values as defaults ********/
- uint32_t onPassKeyRequest(){
- printf("Server PassKeyRequest\n");
- return 123456;
- }
+ uint32_t onPassKeyDisplay(){
+ printf("Server Passkey Display\n");
+ /** This should return a random 6 digit number for security
+ * or make your own static passkey as done here.
+ */
+ return 123456;
+ };
- bool onConfirmPIN(uint32_t pass_key){
- printf("The passkey YES/NO number: %" PRIu32"\n", pass_key);
- return true;
- }
+ void onConfirmPIN(const NimBLEConnInfo& connInfo, uint32_t pass_key){
+ printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
+ /** Inject false if passkeys don't match. */
+ NimBLEDevice::injectConfirmPIN(connInfo, true);
+ };
- void onAuthenticationComplete(BLEConnInfo& connInfo){
- printf("Starting BLE work!\n");
- }
+ void onAuthenticationComplete(const NimBLEConnInfo& connInfo){
+ /** Check that encryption was successful, if not we disconnect the client */
+ if(!connInfo.isEncrypted()) {
+ NimBLEDevice::getServer()->disconnect(connInfo.getConnHandle());
+ printf("Encrypt connection failed - disconnecting client\n");
+ return;
+ }
+ printf("Starting BLE work!");
+ };
/*******************************************************************/
};
diff --git a/examples/basic/BLE_uart/main/main.cpp b/examples/basic/BLE_uart/main/main.cpp
index 3aa20fb..18df6fa 100644
--- a/examples/basic/BLE_uart/main/main.cpp
+++ b/examples/basic/BLE_uart/main/main.cpp
@@ -59,19 +59,29 @@ class MyServerCallbacks: public BLEServerCallbacks {
}
/***************** New - Security handled here ********************
****** Note: these are the same return values as defaults ********/
- uint32_t onPassKeyRequest(){
- printf("Server PassKeyRequest\n");
- return 123456;
- }
+ uint32_t onPassKeyDisplay(){
+ printf("Server Passkey Display\n");
+ /** This should return a random 6 digit number for security
+ * or make your own static passkey as done here.
+ */
+ return 123456;
+ };
- bool onConfirmPIN(uint32_t pass_key){
- printf("The passkey YES/NO number: %" PRIu32"\n", pass_key);
- return true;
- }
+ void onConfirmPIN(const NimBLEConnInfo& connInfo, uint32_t pass_key){
+ printf("The passkey YES/NO number: %" PRIu32 "\n", pass_key);
+ /** Inject false if passkeys don't match. */
+ NimBLEDevice::injectConfirmPIN(connInfo, true);
+ };
- void onAuthenticationComplete(BLEConnInfo& connInfo){
- printf("Starting BLE work!\n");
- }
+ void onAuthenticationComplete(const NimBLEConnInfo& connInfo){
+ /** Check that encryption was successful, if not we disconnect the client */
+ if(!connInfo.isEncrypted()) {
+ NimBLEDevice::getServer()->disconnect(connInfo.getConnHandle());
+ printf("Encrypt connection failed - disconnecting client\n");
+ return;
+ }
+ printf("Starting BLE work!");
+ };
/*******************************************************************/
};
diff --git a/src/NimBLEClient.cpp b/src/NimBLEClient.cpp
index 996b759..ceed193 100644
--- a/src/NimBLEClient.cpp
+++ b/src/NimBLEClient.cpp
@@ -1171,7 +1171,11 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event *event, void *arg) {
{
NimBLEConnInfo peerInfo;
rc = ble_gap_conn_find(event->enc_change.conn_handle, &peerInfo.m_desc);
- assert(rc == 0);
+ if (rc != 0) {
+ NIMBLE_LOGE(LOG_TAG, "Connection info not found");
+ rc = 0;
+ break;
+ }
if (event->enc_change.status == (BLE_HS_ERR_HCI_BASE + BLE_ERR_PINKEY_MISSING)) {
// Key is missing, try deleting.
@@ -1203,20 +1207,17 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event *event, void *arg) {
if(pClient->m_conn_id != event->passkey.conn_handle)
return 0;
- if (event->passkey.params.action == BLE_SM_IOACT_DISP) {
- pkey.action = event->passkey.params.action;
- pkey.passkey = NimBLEDevice::m_passkey; // This is the passkey to be entered on peer
- rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
- NIMBLE_LOGD(LOG_TAG, "ble_sm_inject_io result: %d", rc);
+ NimBLEConnInfo peerInfo;
+ rc = ble_gap_conn_find(event->passkey.conn_handle, &peerInfo.m_desc);
+ if (rc != 0) {
+ NIMBLE_LOGE(LOG_TAG, "Connection info not found");
+ rc = 0;
+ break;
+ }
- } else if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) {
+ if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) {
NIMBLE_LOGD(LOG_TAG, "Passkey on device's display: %" PRIu32, event->passkey.params.numcmp);
- pkey.action = event->passkey.params.action;
- pkey.numcmp_accept = pClient->m_pClientCallbacks->onConfirmPIN(event->passkey.params.numcmp);
-
- rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
- NIMBLE_LOGD(LOG_TAG, "ble_sm_inject_io result: %d", rc);
-
+ pClient->m_pClientCallbacks->onConfirmPIN(peerInfo, event->passkey.params.numcmp);
//TODO: Handle out of band pairing
} else if (event->passkey.params.action == BLE_SM_IOACT_OOB) {
static uint8_t tem_oob[16] = {0};
@@ -1229,12 +1230,7 @@ int NimBLEClient::handleGapEvent(struct ble_gap_event *event, void *arg) {
////////
} else if (event->passkey.params.action == BLE_SM_IOACT_INPUT) {
NIMBLE_LOGD(LOG_TAG, "Enter the passkey");
- pkey.action = event->passkey.params.action;
- pkey.passkey = pClient->m_pClientCallbacks->onPassKeyRequest();
-
- rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
- NIMBLE_LOGD(LOG_TAG, "ble_sm_inject_io result: %d", rc);
-
+ pClient->m_pClientCallbacks->onPassKeyEntry(peerInfo);
} else if (event->passkey.params.action == BLE_SM_IOACT_NONE) {
NIMBLE_LOGD(LOG_TAG, "No passkey action required");
}
@@ -1321,17 +1317,18 @@ bool NimBLEClientCallbacks::onConnParamsUpdateRequest(NimBLEClient* pClient, con
return true;
}
-uint32_t NimBLEClientCallbacks::onPassKeyRequest(){
- NIMBLE_LOGD("NimBLEClientCallbacks", "onPassKeyRequest: default: 123456");
- return 123456;
-}
+void NimBLEClientCallbacks::onPassKeyEntry(const NimBLEConnInfo& connInfo){
+ NIMBLE_LOGD("NimBLEClientCallbacks", "onPassKeyEntry: default: 123456");
+ NimBLEDevice::injectPassKey(connInfo, 123456);
+} //onPassKeyEntry
-void NimBLEClientCallbacks::onAuthenticationComplete(NimBLEConnInfo& peerInfo){
+void NimBLEClientCallbacks::onAuthenticationComplete(const NimBLEConnInfo& connInfo){
NIMBLE_LOGD("NimBLEClientCallbacks", "onAuthenticationComplete: default");
}
-bool NimBLEClientCallbacks::onConfirmPIN(uint32_t pin){
+
+void NimBLEClientCallbacks::onConfirmPIN(const NimBLEConnInfo& connInfo, uint32_t pin){
NIMBLE_LOGD("NimBLEClientCallbacks", "onConfirmPIN: default: true");
- return true;
+ NimBLEDevice::injectConfirmPIN(connInfo, true);
}
#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
diff --git a/src/NimBLEClient.h b/src/NimBLEClient.h
index 0306198..52f389e 100644
--- a/src/NimBLEClient.h
+++ b/src/NimBLEClient.h
@@ -147,23 +147,23 @@ public:
/**
* @brief Called when server requests a passkey for pairing.
- * @return The passkey to be sent to the server.
+ * @param [in] connInfo A reference to a NimBLEConnInfo instance containing the peer info.
*/
- virtual uint32_t onPassKeyRequest();
+ virtual void onPassKeyEntry(const NimBLEConnInfo& connInfo);
/**
* @brief Called when the pairing procedure is complete.
* @param [in] connInfo A reference to a NimBLEConnInfo instance containing the peer info.\n
* This can be used to check the status of the connection encryption/pairing.
*/
- virtual void onAuthenticationComplete(NimBLEConnInfo& connInfo);
+ virtual void onAuthenticationComplete(const NimBLEConnInfo& connInfo);
/**
* @brief Called when using numeric comparision for pairing.
+ * @param [in] connInfo A reference to a NimBLEConnInfo instance containing the peer info.
* @param [in] pin The pin to compare with the server.
- * @return True to accept the pin.
*/
- virtual bool onConfirmPIN(uint32_t pin);
+ virtual void onConfirmPIN(const NimBLEConnInfo& connInfo, uint32_t pin);
};
#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_CENTRAL */
diff --git a/src/NimBLEConnInfo.h b/src/NimBLEConnInfo.h
index c764c24..6b45127 100644
--- a/src/NimBLEConnInfo.h
+++ b/src/NimBLEConnInfo.h
@@ -13,44 +13,44 @@ friend class NimBLECharacteristic;
friend class NimBLEDescriptor;
ble_gap_conn_desc m_desc;
- NimBLEConnInfo() { m_desc = {}; }
- NimBLEConnInfo(ble_gap_conn_desc desc) { m_desc = desc; }
+ NimBLEConnInfo() { m_desc = {}; }
+ NimBLEConnInfo(ble_gap_conn_desc desc) { m_desc = desc; }
public:
/** @brief Gets the over-the-air address of the connected peer */
- NimBLEAddress getAddress() { return NimBLEAddress(m_desc.peer_ota_addr); }
+ NimBLEAddress getAddress() const { return NimBLEAddress(m_desc.peer_ota_addr); }
/** @brief Gets the ID address of the connected peer */
- NimBLEAddress getIdAddress() { return NimBLEAddress(m_desc.peer_id_addr); }
+ NimBLEAddress getIdAddress() const { return NimBLEAddress(m_desc.peer_id_addr); }
/** @brief Gets the connection handle of the connected peer */
- uint16_t getConnHandle() { return m_desc.conn_handle; }
+ uint16_t getConnHandle() const { return m_desc.conn_handle; }
/** @brief Gets the connection interval for this connection (in 1.25ms units) */
- uint16_t getConnInterval() { return m_desc.conn_itvl; }
+ uint16_t getConnInterval() const { return m_desc.conn_itvl; }
/** @brief Gets the supervision timeout for this connection (in 10ms units) */
- uint16_t getConnTimeout() { return m_desc.supervision_timeout; }
+ uint16_t getConnTimeout() const { return m_desc.supervision_timeout; }
/** @brief Gets the allowable latency for this connection (unit = number of intervals) */
- uint16_t getConnLatency() { return m_desc.conn_latency; }
+ uint16_t getConnLatency() const { return m_desc.conn_latency; }
/** @brief Gets the maximum transmission unit size for this connection (in bytes) */
- uint16_t getMTU() { return ble_att_mtu(m_desc.conn_handle); }
+ uint16_t getMTU() const { return ble_att_mtu(m_desc.conn_handle); }
/** @brief Check if we are in the master role in this connection */
- bool isMaster() { return (m_desc.role == BLE_GAP_ROLE_MASTER); }
+ bool isMaster() const { return (m_desc.role == BLE_GAP_ROLE_MASTER); }
/** @brief Check if we are in the slave role in this connection */
- bool isSlave() { return (m_desc.role == BLE_GAP_ROLE_SLAVE); }
+ bool isSlave() const { return (m_desc.role == BLE_GAP_ROLE_SLAVE); }
/** @brief Check if we are connected to a bonded peer */
- bool isBonded() { return (m_desc.sec_state.bonded == 1); }
+ bool isBonded() const { return (m_desc.sec_state.bonded == 1); }
/** @brief Check if the connection in encrypted */
- bool isEncrypted() { return (m_desc.sec_state.encrypted == 1); }
+ bool isEncrypted() const { return (m_desc.sec_state.encrypted == 1); }
/** @brief Check if the the connection has been authenticated */
- bool isAuthenticated() { return (m_desc.sec_state.authenticated == 1); }
+ bool isAuthenticated() const { return (m_desc.sec_state.authenticated == 1); }
/** @brief Gets the key size used to encrypt the connection */
uint8_t getSecKeySize() { return m_desc.sec_state.key_size; }
diff --git a/src/NimBLEDevice.cpp b/src/NimBLEDevice.cpp
index 37a971b..4244953 100644
--- a/src/NimBLEDevice.cpp
+++ b/src/NimBLEDevice.cpp
@@ -1156,6 +1156,43 @@ int NimBLEDevice::startSecurity(uint16_t conn_id) {
} // startSecurity
+/**
+ * @brief Inject the provided passkey into the Security Manager
+ * @param [in] peerInfo Connection information for the peer
+ * @param [in] pin The 6-digit pin to inject
+ * @return true if the passkey was injected successfully.
+ */
+bool NimBLEDevice::injectPassKey(const NimBLEConnInfo& peerInfo, uint32_t pin) {
+ int rc = 0;
+ struct ble_sm_io pkey = {0,0};
+
+ pkey.action = BLE_SM_IOACT_INPUT;
+ pkey.passkey = pin;
+
+ rc = ble_sm_inject_io(peerInfo.getConnHandle(), &pkey);
+ NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_INPUT; ble_sm_inject_io result: %d", rc);
+ return rc == 0;
+}
+
+
+/**
+ * @brief Inject the provided numeric comparison response into the Security Manager
+ * @param [in] peerInfo Connection information for the peer
+ * @param [in] accept Whether the user confirmed or declined the comparison
+ */
+bool NimBLEDevice::injectConfirmPIN(const NimBLEConnInfo& peerInfo, bool accept) {
+ int rc = 0;
+ struct ble_sm_io pkey = {0,0};
+
+ pkey.action = BLE_SM_IOACT_NUMCMP;
+ pkey.numcmp_accept = accept;
+
+ rc = ble_sm_inject_io(peerInfo.getConnHandle(), &pkey);
+ NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_NUMCMP; ble_sm_inject_io result: %d", rc);
+ return rc == 0;
+}
+
+
/**
* @brief Check if the device address is on our ignore list.
* @param [in] address The address to look for.
diff --git a/src/NimBLEDevice.h b/src/NimBLEDevice.h
index 4fdb25d..64bd4ed 100644
--- a/src/NimBLEDevice.h
+++ b/src/NimBLEDevice.h
@@ -136,6 +136,8 @@ public:
static void setSecurityPasskey(uint32_t pin);
static uint32_t getSecurityPasskey();
static int startSecurity(uint16_t conn_id);
+ static bool injectConfirmPIN(const NimBLEConnInfo& peerInfo, bool accept);
+ static bool injectPassKey(const NimBLEConnInfo& peerInfo, uint32_t pin);
static int setMTU(uint16_t mtu);
static uint16_t getMTU();
static bool isIgnored(const NimBLEAddress &address);
diff --git a/src/NimBLEServer.cpp b/src/NimBLEServer.cpp
index daa5f23..243ac24 100644
--- a/src/NimBLEServer.cpp
+++ b/src/NimBLEServer.cpp
@@ -263,6 +263,7 @@ void NimBLEServer::advertiseOnDisconnect(bool aod) {
} // advertiseOnDisconnect
#endif
+
/**
* @brief Return the number of connected clients.
* @return The number of connected clients.
@@ -528,19 +529,20 @@ int NimBLEServer::handleGapEvent(struct ble_gap_event *event, void *arg) {
// if the (static)passkey is the default, check the callback for custom value
// both values default to the same.
if(pkey.passkey == 123456) {
- pkey.passkey = pServer->m_pServerCallbacks->onPassKeyRequest();
+ pkey.passkey = pServer->m_pServerCallbacks->onPassKeyDisplay();
}
rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_DISP; ble_sm_inject_io result: %d", rc);
} else if (event->passkey.params.action == BLE_SM_IOACT_NUMCMP) {
NIMBLE_LOGD(LOG_TAG, "Passkey on device's display: %" PRIu32, event->passkey.params.numcmp);
- pkey.action = event->passkey.params.action;
- pkey.numcmp_accept = pServer->m_pServerCallbacks->onConfirmPIN(event->passkey.params.numcmp);
- rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
- NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_NUMCMP; ble_sm_inject_io result: %d", rc);
+ rc = ble_gap_conn_find(event->passkey.conn_handle, &peerInfo.m_desc);
+ if(rc != 0) {
+ return BLE_ATT_ERR_INVALID_HANDLE;
+ }
+ pServer->m_pServerCallbacks->onConfirmPIN(peerInfo, event->passkey.params.numcmp);
//TODO: Handle out of band pairing
} else if (event->passkey.params.action == BLE_SM_IOACT_OOB) {
static uint8_t tem_oob[16] = {0};
@@ -551,14 +553,6 @@ int NimBLEServer::handleGapEvent(struct ble_gap_event *event, void *arg) {
rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_OOB; ble_sm_inject_io result: %d", rc);
//////////////////////////////////
- } else if (event->passkey.params.action == BLE_SM_IOACT_INPUT) {
- NIMBLE_LOGD(LOG_TAG, "Enter the passkey");
- pkey.action = event->passkey.params.action;
- pkey.passkey = pServer->m_pServerCallbacks->onPassKeyRequest();
-
- rc = ble_sm_inject_io(event->passkey.conn_handle, &pkey);
- NIMBLE_LOGD(LOG_TAG, "BLE_SM_IOACT_INPUT; ble_sm_inject_io result: %d", rc);
-
} else if (event->passkey.params.action == BLE_SM_IOACT_NONE) {
NIMBLE_LOGD(LOG_TAG, "No passkey action required");
}
@@ -851,18 +845,18 @@ void NimBLEServerCallbacks::onMTUChange(uint16_t MTU, NimBLEConnInfo& connInfo)
NIMBLE_LOGD("NimBLEServerCallbacks", "onMTUChange(): Default");
} // onMTUChange
-uint32_t NimBLEServerCallbacks::onPassKeyRequest(){
- NIMBLE_LOGD("NimBLEServerCallbacks", "onPassKeyRequest: default: 123456");
+uint32_t NimBLEServerCallbacks::onPassKeyDisplay(){
+ NIMBLE_LOGD("NimBLEServerCallbacks", "onPassKeyDisplay: default: 123456");
return 123456;
-} //onPassKeyRequest
+} //onPassKeyDisplay
-void NimBLEServerCallbacks::onAuthenticationComplete(NimBLEConnInfo& connInfo){
+void NimBLEServerCallbacks::onConfirmPIN(const NimBLEConnInfo& connInfo, uint32_t pin){
+ NIMBLE_LOGD("NimBLEServerCallbacks", "onConfirmPIN: default: true");
+ NimBLEDevice::injectConfirmPIN(connInfo, true);
+} // onConfirmPIN
+
+void NimBLEServerCallbacks::onAuthenticationComplete(const NimBLEConnInfo& connInfo){
NIMBLE_LOGD("NimBLEServerCallbacks", "onAuthenticationComplete: default");
} // onAuthenticationComplete
-bool NimBLEServerCallbacks::onConfirmPIN(uint32_t pin){
- NIMBLE_LOGD("NimBLEServerCallbacks", "onConfirmPIN: default: true");
- return true;
-} // onConfirmPIN
-
#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
diff --git a/src/NimBLEServer.h b/src/NimBLEServer.h
index ea56ed7..5e635df 100644
--- a/src/NimBLEServer.h
+++ b/src/NimBLEServer.h
@@ -152,24 +152,25 @@ public:
virtual void onMTUChange(uint16_t MTU, NimBLEConnInfo& connInfo);
/**
- * @brief Called when a client requests a passkey for pairing.
+ * @brief Called when a client requests a passkey for pairing (display).
* @return The passkey to be sent to the client.
*/
- virtual uint32_t onPassKeyRequest();
+ virtual uint32_t onPassKeyDisplay();
+
+ /**
+ * @brief Called when using numeric comparision for pairing.
+ * @param [in] connInfo A reference to a NimBLEConnInfo instance with information
+ * Should be passed back to NimBLEDevice::injectConfirmPIN
+ * @param [in] pin The pin to compare with the client.
+ */
+ virtual void onConfirmPIN(const NimBLEConnInfo& connInfo, uint32_t pin);
/**
* @brief Called when the pairing procedure is complete.
* @param [in] connInfo A reference to a NimBLEConnInfo instance with information
* about the peer connection parameters.
*/
- virtual void onAuthenticationComplete(NimBLEConnInfo& connInfo);
-
- /**
- * @brief Called when using numeric comparision for pairing.
- * @param [in] pin The pin to compare with the client.
- * @return True to accept the pin.
- */
- virtual bool onConfirmPIN(uint32_t pin);
+ virtual void onAuthenticationComplete(const NimBLEConnInfo& connInfo);
}; // NimBLEServerCallbacks
#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */