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");
  }