ci(pre-commit): Apply automatic fixes

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

src/ESPAsyncWebServer.h

@@ -1401,7 +1401,7 @@ class AsyncWebServerResponse {
    * @brief write next portion of response data to send buffs
    * this method (re)fills tcp send buffers, it could be called either at will
    * or from a tcp_recv/tcp_poll callbacks from AsyncTCP
-   * 
+   *
    * @param request - used to access client object
    * @param len - size of acknowledged data from the remote side (TCP window update, not TCP ack!)
    * @param time - time passed between last sent and received packet

src/WebRequest.cpp

@@ -33,61 +33,61 @@ AsyncWebServerRequest::AsyncWebServerRequest(AsyncWebServer *s, AsyncClient *c)
     [](void *r, AsyncClient *c, int8_t error) {
       (void)c;
       // async_ws_log_e("AsyncWebServerRequest::_onError");
-      static_cast<AsyncWebServerRequest*>(r)->_onError(error);
+      static_cast<AsyncWebServerRequest *>(r)->_onError(error);
     },
     this
   );
   c->onAck(
     [](void *r, AsyncClient *c, size_t len, uint32_t time) {
       (void)c;
       // async_ws_log_e("AsyncWebServerRequest::_onAck");
-      static_cast<AsyncWebServerRequest*>(r)->_onAck(len, time);
+      static_cast<AsyncWebServerRequest *>(r)->_onAck(len, time);
     },
     this
   );
   c->onDisconnect(
     [](void *r, AsyncClient *c) {
       // async_ws_log_e("AsyncWebServerRequest::_onDisconnect");
-      static_cast<AsyncWebServerRequest*>(r)->_onDisconnect();
+      static_cast<AsyncWebServerRequest *>(r)->_onDisconnect();
     },
     this
   );
   c->onTimeout(
     [](void *r, AsyncClient *c, uint32_t time) {
       (void)c;
       // async_ws_log_e("AsyncWebServerRequest::_onTimeout");
-      static_cast<AsyncWebServerRequest*>(r)->_onTimeout(time);
+      static_cast<AsyncWebServerRequest *>(r)->_onTimeout(time);
     },
     this
   );
   c->onData(
     [](void *r, AsyncClient *c, void *buf, size_t len) {
       (void)c;
       // async_ws_log_e("AsyncWebServerRequest::_onData");
-      static_cast<AsyncWebServerRequest*>(r)->_onData(buf, len);
+      static_cast<AsyncWebServerRequest *>(r)->_onData(buf, len);
     },
     this
   );
   c->onPoll(
     [](void *r, AsyncClient *c) {
       (void)c;
       // async_ws_log_e("AsyncWebServerRequest::_onPoll");
-      static_cast<AsyncWebServerRequest*>(r)->_onPoll();
+      static_cast<AsyncWebServerRequest *>(r)->_onPoll();
     },
     this
   );
 }
 
 AsyncWebServerRequest::~AsyncWebServerRequest() {
-  if (_client){
+  if (_client) {
     // usually it is _client's disconnect triggers object destruct, but for completeness we define behavior
     // if for some reason *this will be desturcted while client is still connected
     _client->onDisconnect(nullptr);
     delete _client;
     _client = nullptr;
   }
 
-  if (_response){
+  if (_response) {
     delete _response;
     _response = nullptr;
   }
@@ -224,13 +224,15 @@ void AsyncWebServerRequest::_onPoll() {
 
 void AsyncWebServerRequest::_onAck(size_t len, uint32_t time) {
   // os_printf("a:%u:%u\n", len, time);
-  if (!_response) return;
+  if (!_response) {
+    return;
+  }
 
   if (!_response->_finished()) {
     _response->_ack(this, len, time);
     // recheck if response has just completed, close connection
     if (_response->_finished()) {
-      _client->close(); // this will trigger _onDisconnect() and object destruction
+      _client->close();  // this will trigger _onDisconnect() and object destruction
     }
   }
 }

src/WebResponseImpl.h

@@ -35,7 +35,9 @@ class AsyncBasicResponse : public AsyncWebServerResponse {
   AsyncBasicResponse(int code, const String &contentType, const String &content = emptyString)
     : AsyncBasicResponse(code, contentType.c_str(), content.c_str()) {}
   void _respond(AsyncWebServerRequest *request) override final;
-  size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time) override final { return write_send_buffs(request, len, time); };
+  size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time) override final {
+    return write_send_buffs(request, len, time);
+  };
   bool _sourceValid() const override final {
     return true;
   }
@@ -45,14 +47,13 @@ class AsyncBasicResponse : public AsyncWebServerResponse {
    * @brief write next portion of response data to send buffs
    * this method (re)fills tcp send buffers, it could be called either at will
    * or from a tcp_recv/tcp_poll callbacks from AsyncTCP
-   * 
+   *
    * @param request - used to access client object
    * @param len - size of acknowledged data from the remote side (TCP window update, not TCP ack!)
    * @param time - time passed between last sent and received packet
    * @return size_t amount of response data placed to TCP send buffs for delivery (defined by sdkconfig value CONFIG_LWIP_TCP_SND_BUF_DEFAULT)
    */
   size_t write_send_buffs(AsyncWebServerRequest *request, size_t len, uint32_t time);
-
 };
 
 class AsyncAbstractResponse : public AsyncWebServerResponse {
@@ -73,7 +74,7 @@ class AsyncAbstractResponse : public AsyncWebServerResponse {
   // so by gaining performance in one place, we'll lose it in another.
   std::vector<uint8_t> _cache;
   // intermediate buffer to copy outbound data to, also it will keep pending data between _send calls
-  std::unique_ptr< std::array<uint8_t, ASYNC_RESPONCE_BUFF_SIZE> > _send_buffer;
+  std::unique_ptr<std::array<uint8_t, ASYNC_RESPONCE_BUFF_SIZE> > _send_buffer;
   // buffer data size specifiers
   size_t _send_buffer_offset{0}, _send_buffer_len{0};
   size_t _readDataFromCacheOrContent(uint8_t *data, const size_t len);
@@ -85,7 +86,7 @@ class AsyncAbstractResponse : public AsyncWebServerResponse {
    * @brief write next portion of response data to send buffs
    * this method (re)fills tcp send buffers, it could be called either at will
    * or from a tcp_recv/tcp_poll callbacks from AsyncTCP
-   * 
+   *
    * @param request - used to access client object
    * @param len - size of acknowledged data from the remote side (TCP window update, not TCP ack!)
    * @param time - time passed between last sent and received packet
@@ -97,7 +98,9 @@ class AsyncAbstractResponse : public AsyncWebServerResponse {
   AsyncAbstractResponse(AwsTemplateProcessor callback = nullptr);
   virtual ~AsyncAbstractResponse() {}
   void _respond(AsyncWebServerRequest *request) override final;
-  size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time) override final { return write_send_buffs(request, len, time); };
+  size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time) override final {
+    return write_send_buffs(request, len, time);
+  };
   virtual bool _sourceValid() const {
     return false;
   }

src/WebResponses.cpp

@@ -286,9 +286,9 @@ size_t AsyncBasicResponse::write_send_buffs(AsyncWebServerRequest *request, size
     size_t const pcb_written = request->client()->add(_assembled_headers.c_str() + _writtenHeadersLength, _assembled_headers.length() - _writtenHeadersLength);
     _writtenLength += pcb_written;
     _writtenHeadersLength += pcb_written;
-    if (_writtenHeadersLength < _assembled_headers.length()){
+    if (_writtenHeadersLength < _assembled_headers.length()) {
       // we were not able to fit all headers in current buff, send this part here and return later for the rest
-      if (!request->client()->send()){
+      if (!request->client()->send()) {
         // something is wrong, what should we do here?
         request->client()->close();
         return 0;
@@ -303,10 +303,10 @@ size_t AsyncBasicResponse::write_send_buffs(AsyncWebServerRequest *request, size
 
   if (_state == RESPONSE_CONTENT) {
     size_t const pcb_written = request->client()->write(_content.c_str() + _sentLength, _content.length() - _sentLength);
-    _writtenLength += pcb_written;    // total written data (hdrs + body)
-    _sentLength += pcb_written;       // body written data
-    payloadlen += pcb_written;        // data writtent in current buff
-    if (_sentLength >= _content.length()){
+    _writtenLength += pcb_written;  // total written data (hdrs + body)
+    _sentLength += pcb_written;     // body written data
+    payloadlen += pcb_written;      // data writtent in current buff
+    if (_sentLength >= _content.length()) {
       // we've just sent all the (remainder) data in current buff, complete the response
       _state = RESPONSE_END;
     }
@@ -322,7 +322,7 @@ size_t AsyncBasicResponse::write_send_buffs(AsyncWebServerRequest *request, size
 
 /*
  * Abstract Response
- * 
+ *
  */
 AsyncAbstractResponse::AsyncAbstractResponse(AwsTemplateProcessor callback) : _callback(callback) {
   // In case of template processing, we're unable to determine real response size
@@ -363,7 +363,7 @@ size_t AsyncAbstractResponse::write_send_buffs(AsyncWebServerRequest *request, s
     _in_flight -= std::min(len, _in_flight);
   }
 
-  if (_chunked || !_sendContentLength || (_sentLength > CONFIG_LWIP_TCP_WND_DEFAULT) ) {
+  if (_chunked || !_sendContentLength || (_sentLength > CONFIG_LWIP_TCP_WND_DEFAULT)) {
     if (!_in_flight_credit || (ASYNC_RESPONCE_BUFF_SIZE > request->client()->space())) {
       // async_ws_log_d("defer user call in_flight:%u, tcpwin:%u", _in_flight, request->client()->space());
       // take the credit back since we are ignoring this ack and rely on other inflight data acks
@@ -386,13 +386,13 @@ size_t AsyncAbstractResponse::write_send_buffs(AsyncWebServerRequest *request, s
     size_t const pcb_written = request->client()->add(_assembled_headers.c_str() + _writtenHeadersLength, _assembled_headers.length() - _writtenHeadersLength);
     _writtenLength += pcb_written;
     _writtenHeadersLength += pcb_written;
-    if (_writtenHeadersLength < _assembled_headers.length()){
-      // we were not able to fit all headers in current buff, send this part here and return later for the rest
-      #if ASYNCWEBSERVER_USE_CHUNK_INFLIGHT
+    if (_writtenHeadersLength < _assembled_headers.length()) {
+// we were not able to fit all headers in current buff, send this part here and return later for the rest
+#if ASYNCWEBSERVER_USE_CHUNK_INFLIGHT
       _in_flight += pcb_written;
       --_in_flight_credit;  // take a credit
-      #endif
-      if (!request->client()->send()){
+#endif
+      if (!request->client()->send()) {
         // something is wrong, what should we do here?
         request->client()->close();
         return 0;
@@ -408,82 +408,87 @@ size_t AsyncAbstractResponse::write_send_buffs(AsyncWebServerRequest *request, s
   // send content body
   if (_state == RESPONSE_CONTENT) {
     do {
-      if (_send_buffer_len && _send_buffer){
+      if (_send_buffer_len && _send_buffer) {
         // data is pending in buffer from a previous call or previous iteration
-        size_t const added_len = request->client()->add(reinterpret_cast<char*>(_send_buffer->data() + _send_buffer_offset), _send_buffer_len - _send_buffer_offset);
-        if (added_len != _send_buffer_len - _send_buffer_offset){
+        size_t const added_len =
+          request->client()->add(reinterpret_cast<char *>(_send_buffer->data() + _send_buffer_offset), _send_buffer_len - _send_buffer_offset);
+        if (added_len != _send_buffer_len - _send_buffer_offset) {
           // we were not able to add entire buffer's content to tcp buffs, leave it for later
           // (this should not happen normally unless connection's TCP window suddenly changed from remote or mem pressure)
           _send_buffer_offset += added_len;
           break;
-        } else
-          _send_buffer_len = _send_buffer_offset = 0;   // consider buffer empty
+        } else {
+          _send_buffer_len = _send_buffer_offset = 0;  // consider buffer empty
+        }
         payloadlen += added_len;
       }
 
       auto tcp_win = request->client()->space();
-      if (tcp_win == 0 || _state == RESPONSE_END)
+      if (tcp_win == 0 || _state == RESPONSE_END) {
         break;  // no room left or no more data
+      }
 
       if ((_chunked || !_sendContentLength) && (tcp_win < CONFIG_LWIP_TCP_MSS / 2)) {
         // available window size is not enough to send a new chunk sized half of tcp mss, let's wait for better chance and reduce pressure to AsyncTCP's event Q
         break;
       }
 
-      if (!_send_buffer){
+      if (!_send_buffer) {
         auto p = new (std::nothrow) std::array<uint8_t, ASYNC_RESPONCE_BUFF_SIZE>;
-        if (p){
+        if (p) {
           _send_buffer.reset(p);
           _send_buffer_len = _send_buffer_offset = 0;
-        } else
-          break;   // OOM
+        } else {
+          break;  // OOM
+        }
       }
 
       if (_chunked) {
         // HTTP 1.1 allows leading zeros in chunk length. Or spaces may be added.
         // See https://datatracker.ietf.org/doc/html/rfc9112#section-7.1
-        size_t const readLen = _fillBufferAndProcessTemplates(_send_buffer->data() + 6, std::min(_send_buffer->size(), tcp_win) - 8);  // reserve 8 bytes for chunk size data
+        size_t const readLen =
+          _fillBufferAndProcessTemplates(_send_buffer->data() + 6, std::min(_send_buffer->size(), tcp_win) - 8);  // reserve 8 bytes for chunk size data
         if (readLen != RESPONSE_TRY_AGAIN) {
-          sprintf(reinterpret_cast<char*>(_send_buffer->data()), "%04x\r\n", readLen);   // print chunk size in buffer
+          sprintf(reinterpret_cast<char *>(_send_buffer->data()), "%04x\r\n", readLen);  // print chunk size in buffer
           _send_buffer->at(readLen + 6) = '\r';
           _send_buffer->at(readLen + 7) = '\n';
-          _send_buffer_len += readLen + 8;      // set buffers's size to match added data
-          _sentLength += readLen;               // data is not sent yet, but we won't get a chance to count this later properly for chunked data
-          if (!readLen){
+          _send_buffer_len += readLen + 8;  // set buffers's size to match added data
+          _sentLength += readLen;           // data is not sent yet, but we won't get a chance to count this later properly for chunked data
+          if (!readLen) {
             // last chunk?
             _state = RESPONSE_END;
           }
         }
       } else {
         size_t const readLen = _fillBufferAndProcessTemplates(_send_buffer->data(), std::min(_send_buffer->size(), tcp_win));
-        if (readLen == 0){
+        if (readLen == 0) {
           // no more data to send
           _state = RESPONSE_END;
         } else if (readLen != RESPONSE_TRY_AGAIN) {
-          _send_buffer_len += readLen;          // set buffers's size to match added data
-          _sentLength += readLen;               // data is not sent yet, but we need it to uderstand that it would be last block
-          if (_sendContentLength && (_sentLength == _contentLength)){
+          _send_buffer_len += readLen;  // set buffers's size to match added data
+          _sentLength += readLen;       // data is not sent yet, but we need it to uderstand that it would be last block
+          if (_sendContentLength && (_sentLength == _contentLength)) {
             // it was last piece of content
             _state = RESPONSE_END;
           }
         }
       }
-    } while(_send_buffer_len);    // go on till we have something in buffer pending to send
+    } while (_send_buffer_len);  // go on till we have something in buffer pending to send
 
     // execute sending whatever we have in sock buffs now
     request->client()->send();
     _writtenLength += payloadlen;
-  #if ASYNCWEBSERVER_USE_CHUNK_INFLIGHT
+#if ASYNCWEBSERVER_USE_CHUNK_INFLIGHT
     _in_flight += payloadlen;
     --_in_flight_credit;  // take a credit
-  #endif
-    if (_send_buffer_len == 0){
+#endif
+    if (_send_buffer_len == 0) {
       // buffer empty, we can release mem, otherwise need to keep it till next run (should not happen under normal conditions)
       _send_buffer.reset();
     }
     return payloadlen;
-  } // (_state == RESPONSE_CONTENT)
-  
+  }  // (_state == RESPONSE_CONTENT)
+
   // implicit check
   if (_state == RESPONSE_WAIT_ACK) {
     // we do not need to wait for any acks actually if we won't send any more data,
@@ -517,7 +522,7 @@ size_t AsyncAbstractResponse::_fillBufferAndProcessTemplates(uint8_t *data, size
   // Now we've read 'len' bytes, either from cache or from file
   // Search for template placeholders
   uint8_t *pTemplateStart = data;
-  while ((pTemplateStart < &data[len]) && (pTemplateStart = (uint8_t *)memchr(pTemplateStart, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart + 1)) ) {
+  while ((pTemplateStart < &data[len]) && (pTemplateStart = (uint8_t *)memchr(pTemplateStart, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart + 1))) {
     // data[0] ... data[len - 1]
     uint8_t *pTemplateEnd =
       (pTemplateStart < &data[len - 1]) ? (uint8_t *)memchr(pTemplateStart + 1, TEMPLATE_PLACEHOLDER, &data[len - 1] - pTemplateStart) : nullptr;