ci(pre-commit): Apply automatic fixes

Author: pre-commit-ci-lite[bot]

libraries/BLE/examples/Server_secure_static_passkey/Server_secure_static_passkey.ino

@@ -80,10 +80,8 @@ void setup() {
   // Check the BLECharacteristic.h file for more information.
   secure_properties |= BLECharacteristic::PROPERTY_READ_ENC | BLECharacteristic::PROPERTY_WRITE_ENC;
 
-  BLECharacteristic *pSecureCharacteristic =
-    pService->createCharacteristic(SECURE_CHARACTERISTIC_UUID, secure_properties);
-  BLECharacteristic *pUnsecureCharacteristic =
-    pService->createCharacteristic(UNSECURE_CHARACTERISTIC_UUID, unsecure_properties);
+  BLECharacteristic *pSecureCharacteristic = pService->createCharacteristic(SECURE_CHARACTERISTIC_UUID, secure_properties);
+  BLECharacteristic *pUnsecureCharacteristic = pService->createCharacteristic(UNSECURE_CHARACTERISTIC_UUID, unsecure_properties);
 
   // Bluedroid uses permissions to secure characteristics.
   // This is the same as using the properties above.

libraries/BLE/src/BLECharacteristic.cpp

@@ -574,9 +574,7 @@ void BLECharacteristic::handleGATTServerEvent(esp_gatts_cb_event_t event, esp_ga
 
           if (BLEDevice::m_securityCallbacks != nullptr) {
             log_i("Authorization required for write operation. Checking authorization...");
-            authorized = BLEDevice::m_securityCallbacks->onAuthorizationRequest(
-              param->write.conn_id, m_handle, false
-            );
+            authorized = BLEDevice::m_securityCallbacks->onAuthorizationRequest(param->write.conn_id, m_handle, false);
           } else {
             log_w("onAuthorizationRequest not implemented. Rejecting write authorization request");
           }
@@ -656,9 +654,7 @@ void BLECharacteristic::handleGATTServerEvent(esp_gatts_cb_event_t event, esp_ga
 
           if (BLEDevice::m_securityCallbacks != nullptr) {
             log_i("Authorization required for read operation. Checking authorization...");
-            authorized = BLEDevice::m_securityCallbacks->onAuthorizationRequest(
-              param->read.conn_id, m_handle, true
-            );
+            authorized = BLEDevice::m_securityCallbacks->onAuthorizationRequest(param->read.conn_id, m_handle, true);
           } else {
             log_w("onAuthorizationRequest not implemented. Rejecting read authorization request");
           }

libraries/BLE/src/BLECharacteristic.h

@@ -140,14 +140,14 @@ class BLECharacteristic {
 
 #if defined(CONFIG_BLUEDROID_ENABLED)
   static const uint32_t PROPERTY_READ = 1 << 0;
-  static const uint32_t PROPERTY_READ_ENC = 0; // Not supported by Bluedroid. Use setAccessPermissions() instead.
-  static const uint32_t PROPERTY_READ_AUTHEN = 0; // Not supported by Bluedroid. Use setAccessPermissions() instead.
-  static const uint32_t PROPERTY_READ_AUTHOR = 0; // Not supported by Bluedroid. Use setAccessPermissions() instead.
+  static const uint32_t PROPERTY_READ_ENC = 0;     // Not supported by Bluedroid. Use setAccessPermissions() instead.
+  static const uint32_t PROPERTY_READ_AUTHEN = 0;  // Not supported by Bluedroid. Use setAccessPermissions() instead.
+  static const uint32_t PROPERTY_READ_AUTHOR = 0;  // Not supported by Bluedroid. Use setAccessPermissions() instead.
   static const uint32_t PROPERTY_WRITE = 1 << 1;
   static const uint32_t PROPERTY_WRITE_NR = 1 << 5;
-  static const uint32_t PROPERTY_WRITE_ENC = 0; // Not supported by Bluedroid. Use setAccessPermissions() instead.
-  static const uint32_t PROPERTY_WRITE_AUTHEN = 0; // Not supported by Bluedroid. Use setAccessPermissions() instead.
-  static const uint32_t PROPERTY_WRITE_AUTHOR = 0; // Not supported by Bluedroid. Use setAccessPermissions() instead.
+  static const uint32_t PROPERTY_WRITE_ENC = 0;     // Not supported by Bluedroid. Use setAccessPermissions() instead.
+  static const uint32_t PROPERTY_WRITE_AUTHEN = 0;  // Not supported by Bluedroid. Use setAccessPermissions() instead.
+  static const uint32_t PROPERTY_WRITE_AUTHOR = 0;  // Not supported by Bluedroid. Use setAccessPermissions() instead.
   static const uint32_t PROPERTY_NOTIFY = 1 << 2;
   static const uint32_t PROPERTY_BROADCAST = 1 << 3;
   static const uint32_t PROPERTY_INDICATE = 1 << 4;

libraries/BLE/src/BLEClient.cpp

@@ -1008,7 +1008,7 @@ int BLEClient::handleGAPEvent(struct ble_gap_event *event, void *arg) {
           break;
         }
 
-        if(BLESecurity::m_securityEnabled) {
+        if (BLESecurity::m_securityEnabled) {
           BLESecurity::startSecurity(client->m_conn_id);
         }
 
@@ -1174,7 +1174,7 @@ int BLEClient::handleGAPEvent(struct ble_gap_event *event, void *arg) {
         pkey.action = event->passkey.params.action;
         pkey.passkey = BLESecurity::getPassKey();  // This is the passkey to be entered on peer
 
-        if(!BLESecurity::m_passkeySet) {
+        if (!BLESecurity::m_passkeySet) {
           log_w("No passkey set");
         }
 

libraries/BLE/src/BLEDevice.cpp

@@ -723,13 +723,10 @@ BLEStack BLEDevice::getBLEStack() {
 
 String BLEDevice::getBLEStackString() {
   switch (getBLEStack()) {
-    case BLEStack::BLUEDROID:
-      return "Bluedroid";
-    case BLEStack::NIMBLE:
-      return "NimBLE";
+    case BLEStack::BLUEDROID: return "Bluedroid";
+    case BLEStack::NIMBLE:    return "NimBLE";
     case BLEStack::UNKNOWN:
-    default:
-      return "Unknown";
+    default:                  return "Unknown";
   }
 }
 
@@ -829,7 +826,7 @@ void BLEDevice::gapEventHandler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_par
     case ESP_GAP_BLE_OOB_REQ_EVT:  /* OOB request event */ log_i("ESP_GAP_BLE_OOB_REQ_EVT"); break;
     case ESP_GAP_BLE_LOCAL_IR_EVT: /* BLE local IR event */ log_i("ESP_GAP_BLE_LOCAL_IR_EVT"); break;
     case ESP_GAP_BLE_LOCAL_ER_EVT: /* BLE local ER event */ log_i("ESP_GAP_BLE_LOCAL_ER_EVT"); break;
-    case ESP_GAP_BLE_NC_REQ_EVT:   /*  NUMERIC CONFIRMATION  */
+    case ESP_GAP_BLE_NC_REQ_EVT: /*  NUMERIC CONFIRMATION  */
     {
       log_i("ESP_GAP_BLE_NC_REQ_EVT");
 #ifdef CONFIG_BLE_SMP_ENABLE  // Check that BLE SMP (security) is configured in make menuconfig
@@ -840,8 +837,7 @@ void BLEDevice::gapEventHandler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_par
         esp_ble_confirm_reply(param->ble_security.ble_req.bd_addr, false);
       }
 #endif  // CONFIG_BLE_SMP_ENABLE
-    }
-      break;
+    } break;
     case ESP_GAP_BLE_PASSKEY_REQ_EVT: /* passkey request event */
     {
       log_i("ESP_GAP_BLE_PASSKEY_REQ_EVT: ");
@@ -867,8 +863,7 @@ void BLEDevice::gapEventHandler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_par
 
       esp_ble_passkey_reply(param->ble_security.ble_req.bd_addr, true, passkey);
 #endif  // CONFIG_BLE_SMP_ENABLE
-    }
-      break;
+    } break;
       /*
 			 * TODO should we add white/black list comparison?
 			 */
@@ -885,8 +880,7 @@ void BLEDevice::gapEventHandler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_par
         esp_ble_gap_security_rsp(param->ble_security.ble_req.bd_addr, true);
       }
 #endif  // CONFIG_BLE_SMP_ENABLE
-    }
-      break;
+    } break;
       /*
 			  *
 			  */
@@ -897,7 +891,7 @@ void BLEDevice::gapEventHandler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_par
 #ifdef CONFIG_BLE_SMP_ENABLE  // Check that BLE SMP (security) is configured in make menuconfig
       uint32_t passkey = param->ble_security.key_notif.passkey;
 
-      if(!BLESecurity::m_passkeySet) {
+      if (!BLESecurity::m_passkeySet) {
         log_w("No passkey set");
       }
 
@@ -912,17 +906,15 @@ void BLEDevice::gapEventHandler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_par
         BLEDevice::m_securityCallbacks->onPassKeyNotify(passkey);
       }
 #endif  // CONFIG_BLE_SMP_ENABLE
-    }
-      break;
+    } break;
     case ESP_GAP_BLE_KEY_EVT:
     {
       //shows the ble key type info share with peer device to the user.
       log_d("ESP_GAP_BLE_KEY_EVT");
 #ifdef CONFIG_BLE_SMP_ENABLE  // Check that BLE SMP (security) is configured in make menuconfig
       log_i("key type = %s", BLESecurity::esp_key_type_to_str(param->ble_security.ble_key.key_type));
 #endif  // CONFIG_BLE_SMP_ENABLE
-    }
-      break;
+    } break;
     case ESP_GAP_BLE_AUTH_CMPL_EVT:
     {
       log_i("ESP_GAP_BLE_AUTH_CMPL_EVT");
@@ -931,8 +923,7 @@ void BLEDevice::gapEventHandler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_par
         BLEDevice::m_securityCallbacks->onAuthenticationComplete(param->ble_security.auth_cmpl);
       }
 #endif  // CONFIG_BLE_SMP_ENABLE
-    }
-      break;
+    } break;
     default:
     {
       break;
@@ -964,8 +955,6 @@ void BLEDevice::setCustomGattsHandler(gatts_event_handler handler) {
   m_customGattsHandler = handler;
 }
 
-
-
 #endif
 
 /***************************************************************************

libraries/BLE/src/BLESecurity.cpp

@@ -149,9 +149,9 @@ uint32_t BLESecurity::setPassKey(bool staticPasskey, uint32_t passkey) {
   log_d("setPassKey: staticPasskey=%d, passkey=%d", staticPasskey, passkey);
   m_staticPasskey = staticPasskey;
 
-  if(m_staticPasskey) {
+  if (m_staticPasskey) {
     m_passkey = passkey;
-    if(m_passkey == BLE_SM_DEFAULT_PASSKEY) {
+    if (m_passkey == BLE_SM_DEFAULT_PASSKEY) {
       log_w("*WARNING* Using default passkey: %06d", BLE_SM_DEFAULT_PASSKEY);
       log_w("*WARNING* Please use a random passkey or set a different static passkey");
     }
@@ -174,7 +174,7 @@ uint32_t BLESecurity::setPassKey(bool staticPasskey, uint32_t passkey) {
 // If using a random passkey, it will generate a new random passkey if m_regenOnConnect is true.
 // Otherwise, it will return the current passkey being used.
 uint32_t BLESecurity::getPassKey() {
-  if(m_passkeySet && !m_staticPasskey && m_regenOnConnect) {
+  if (m_passkeySet && !m_staticPasskey && m_regenOnConnect) {
     m_passkey = generateRandomPassKey();
 #if defined(CONFIG_BLUEDROID_ENABLED)
     esp_ble_gap_set_security_param(ESP_BLE_SM_SET_STATIC_PASSKEY, &m_passkey, sizeof(uint32_t));
@@ -197,8 +197,8 @@ void BLESecurity::setAuthenticationMode(bool bonding, bool mitm, bool sc) {
   m_securityEnabled = (m_authReq != 0);
 #if defined(CONFIG_BLUEDROID_ENABLED)
   esp_ble_gap_set_security_param(ESP_BLE_SM_AUTHEN_REQ_MODE, &m_authReq, sizeof(uint8_t));
-  if(sc) {
-    if(mitm) {
+  if (sc) {
+    if (mitm) {
       setEncryptionLevel(ESP_BLE_SEC_ENCRYPT_MITM);
     } else {
       setEncryptionLevel(ESP_BLE_SEC_ENCRYPT_NO_MITM);
@@ -252,7 +252,9 @@ bool BLESecurityCallbacks::onConfirmPIN(uint32_t pin) {
 // It should return true if the authorization is granted, false otherwise.
 bool BLESecurityCallbacks::onAuthorizationRequest(uint16_t connHandle, uint16_t attrHandle, bool isRead) {
   Serial.println("BLESecurityCallbacks: *ATTENTION* Using unsecure onAuthorizationRequest. It will accept any authorization request.");
-  Serial.println("BLESecurityCallbacks: *ATTENTION* Please implement onAuthorizationRequest with a suitable authorization logic in your BLESecurityCallbacks class");
+  Serial.println(
+    "BLESecurityCallbacks: *ATTENTION* Please implement onAuthorizationRequest with a suitable authorization logic in your BLESecurityCallbacks class"
+  );
   return true;
 }
 
@@ -268,7 +270,7 @@ void BLESecurity::setEncryptionLevel(esp_ble_sec_act_t level) {
 
 bool BLESecurity::startSecurity(esp_bd_addr_t bd_addr, int *rcPtr) {
 #ifdef CONFIG_BLE_SMP_ENABLE
-  if(m_securityStarted) {
+  if (m_securityStarted) {
     log_w("Security already started for bd_addr=%s", BLEAddress(bd_addr).toString().c_str());
     return true;
   }
@@ -320,7 +322,7 @@ void BLESecurityCallbacks::onAuthenticationComplete(esp_ble_auth_cmpl_t param) {
 #if defined(CONFIG_NIMBLE_ENABLED)
 // This function initiates security for a given connection handle.
 bool BLESecurity::startSecurity(uint16_t connHandle, int *rcPtr) {
-  if(m_securityStarted) {
+  if (m_securityStarted) {
     log_w("Security already started for connHandle=%d", connHandle);
     return true;
   }

libraries/BLE/src/BLEServer.cpp

@@ -638,7 +638,7 @@ int BLEServer::handleGATTServerEvent(struct ble_gap_event *event, void *arg) {
           server->m_pServerCallbacks->onConnect(server, &desc);
         }
 
-        if(BLESecurity::m_securityEnabled && BLESecurity::m_forceSecurity) {
+        if (BLESecurity::m_securityEnabled && BLESecurity::m_forceSecurity) {
           BLESecurity::startSecurity(event->connect.conn_handle);
         }
 
@@ -828,7 +828,7 @@ int BLEServer::handleGATTServerEvent(struct ble_gap_event *event, void *arg) {
         pkey.action = event->passkey.params.action;
         pkey.passkey = BLESecurity::getPassKey();
 
-        if(!BLESecurity::m_passkeySet) {
+        if (!BLESecurity::m_passkeySet) {
           log_w("No passkey set");
         }
 
@@ -915,18 +915,16 @@ int BLEServer::handleGATTServerEvent(struct ble_gap_event *event, void *arg) {
     {
       log_d("BLE_GAP_EVENT_AUTHORIZE");
 
-      log_i("Authorization request: conn_handle=%d attr_handle=%d is_read=%d",
-            event->authorize.conn_handle,
-            event->authorize.attr_handle,
-            event->authorize.is_read);
+      log_i(
+        "Authorization request: conn_handle=%d attr_handle=%d is_read=%d", event->authorize.conn_handle, event->authorize.attr_handle, event->authorize.is_read
+      );
 
       bool authorized = false;
 
       if (BLEDevice::m_securityCallbacks != nullptr) {
         log_i("Asking for authorization from onAuthorizationRequest");
-        authorized = BLEDevice::m_securityCallbacks->onAuthorizationRequest(
-          event->authorize.conn_handle, event->authorize.attr_handle, event->authorize.is_read
-        );
+        authorized =
+          BLEDevice::m_securityCallbacks->onAuthorizationRequest(event->authorize.conn_handle, event->authorize.attr_handle, event->authorize.is_read);
       } else {
         log_w("onAuthorizationRequest not implemented. Rejecting authorization request");
       }