From 436c370446338115c1acdb54da5faf4e350a59d4 Mon Sep 17 00:00:00 2001 From: Mathieu Carbou Date: Thu, 13 Nov 2025 11:05:48 +0100 Subject: [PATCH] Introduce cpplint --- .github/workflows/cpplint.yml | 46 +++++++++++++++++++++++++++++++++++ src/AsyncEventSource.cpp | 4 +++ src/AsyncEventSource.h | 13 +++++----- src/AsyncJson.cpp | 2 ++ src/AsyncJson.h | 10 ++++---- src/AsyncWebServerRequest.cpp | 3 +++ src/AsyncWebSocket.cpp | 16 +++++++----- src/AsyncWebSocket.h | 12 ++++----- src/BackPort_SHA1Builder.h | 7 ++---- src/ChunkPrint.h | 4 +-- src/ESPAsyncWebServer.h | 12 ++++----- src/Middleware.cpp | 2 ++ src/WebAuthentication.cpp | 7 +++--- src/WebAuthentication.h | 5 +--- src/WebHandlerImpl.h | 24 +++++++++--------- src/WebHandlers.cpp | 5 +++- src/WebRequest.cpp | 7 +++++- src/WebResponseImpl.h | 43 ++++++++++++++++---------------- src/WebResponses.cpp | 4 +++ src/WebServer.cpp | 3 +++ 20 files changed, 148 insertions(+), 81 deletions(-) create mode 100644 .github/workflows/cpplint.yml diff --git a/.github/workflows/cpplint.yml b/.github/workflows/cpplint.yml new file mode 100644 index 000000000..0f905a0d6 --- /dev/null +++ b/.github/workflows/cpplint.yml @@ -0,0 +1,46 @@ +# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json + +name: Cpplint + +on: + workflow_dispatch: + push: + branches: + - main + - release/* + pull_request: + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +jobs: + cpplint: + name: cpplint + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v5 + + - name: Cache + uses: actions/cache@v4 + with: + key: ${{ runner.os }}-cpplint + path: ~/.cache/pip + + - name: Pyhton + uses: actions/setup-python@v6 + with: + python-version: "3.13" + + - name: cpplint + run: | + python -m pip install --upgrade pip + pip install --upgrade cpplint + cpplint \ + --repository=. \ + --recursive \ + --filter=-build/c++11,-build/namespaces,-readability/braces,-readability/casting,-readability/todo,-runtime/explicit,-runtime/indentation_namespace,-runtime/int,-runtime/references,-whitespace/blank_line,,-whitespace/braces,-whitespace/comments,-whitespace/indent,-whitespace/line_length,-whitespace/newline,-whitespace/parens \ + lib \ + include \ + src diff --git a/src/AsyncEventSource.cpp b/src/AsyncEventSource.cpp index eb1ddc856..4a26ceec5 100644 --- a/src/AsyncEventSource.cpp +++ b/src/AsyncEventSource.cpp @@ -4,6 +4,10 @@ #include "AsyncEventSource.h" #include "AsyncWebServerLogging.h" +#include +#include +#include + #define ASYNC_SSE_NEW_LINE_CHAR (char)0xa using namespace asyncsrv; diff --git a/src/AsyncEventSource.h b/src/AsyncEventSource.h index 3d8a4d774..7504043a6 100644 --- a/src/AsyncEventSource.h +++ b/src/AsyncEventSource.h @@ -1,8 +1,7 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // Copyright 2016-2025 Hristo Gochkov, Mathieu Carbou, Emil Muratov -#ifndef ASYNCEVENTSOURCE_H_ -#define ASYNCEVENTSOURCE_H_ +#pragma once #include @@ -44,6 +43,10 @@ #endif #endif +#include +#include +#include + class AsyncEventSource; class AsyncEventSourceResponse; class AsyncEventSourceClient; @@ -312,8 +315,8 @@ class AsyncEventSource : public AsyncWebHandler { // system callbacks (do not call from user code!) void _addClient(AsyncEventSourceClient *client); void _handleDisconnect(AsyncEventSourceClient *client); - bool canHandle(AsyncWebServerRequest *request) const override final; - void handleRequest(AsyncWebServerRequest *request) override final; + bool canHandle(AsyncWebServerRequest *request) const final; + void handleRequest(AsyncWebServerRequest *request) final; }; class AsyncEventSourceResponse : public AsyncWebServerResponse { @@ -333,5 +336,3 @@ class AsyncEventSourceResponse : public AsyncWebServerResponse { return true; } }; - -#endif /* ASYNCEVENTSOURCE_H_ */ diff --git a/src/AsyncJson.cpp b/src/AsyncJson.cpp index 6c62b6906..25a1d84d1 100644 --- a/src/AsyncJson.cpp +++ b/src/AsyncJson.cpp @@ -4,6 +4,8 @@ #include "AsyncJson.h" #include "AsyncWebServerLogging.h" +#include + #if ASYNC_JSON_SUPPORT == 1 // Json content type response classes diff --git a/src/AsyncJson.h b/src/AsyncJson.h index 70e8b7566..3229d8554 100644 --- a/src/AsyncJson.h +++ b/src/AsyncJson.h @@ -113,14 +113,14 @@ class AsyncCallbackJsonWebHandler : public AsyncWebHandler { _onRequest = fn; } - bool canHandle(AsyncWebServerRequest *request) const override final; - void handleRequest(AsyncWebServerRequest *request) override final; + bool canHandle(AsyncWebServerRequest *request) const final; + void handleRequest(AsyncWebServerRequest *request) final; void handleUpload( __unused AsyncWebServerRequest *request, __unused const String &filename, __unused size_t index, __unused uint8_t *data, __unused size_t len, __unused bool final - ) override final {} - void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override final; - bool isRequestHandlerTrivial() const override final { + ) final {} + void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) final; + bool isRequestHandlerTrivial() const final { return !_onRequest; } }; diff --git a/src/AsyncWebServerRequest.cpp b/src/AsyncWebServerRequest.cpp index b2be0e8b2..b2a86f4fd 100644 --- a/src/AsyncWebServerRequest.cpp +++ b/src/AsyncWebServerRequest.cpp @@ -1,3 +1,6 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later +// Copyright 2016-2025 Hristo Gochkov, Mathieu Carbou, Emil Muratov + #include /** diff --git a/src/AsyncWebSocket.cpp b/src/AsyncWebSocket.cpp index 95574945b..1bd0a1603 100644 --- a/src/AsyncWebSocket.cpp +++ b/src/AsyncWebSocket.cpp @@ -4,8 +4,6 @@ #include "AsyncWebSocket.h" #include "AsyncWebServerLogging.h" -#include - #include #if defined(ESP32) @@ -21,6 +19,12 @@ #include #endif +#include +#include +#include +#include +#include + using namespace asyncsrv; size_t webSocketSendFrameWindow(AsyncClient *client) { @@ -48,10 +52,10 @@ size_t webSocketSendFrame(AsyncClient *client, bool final, uint8_t opcode, bool uint8_t headLen = 2; if (len && mask) { headLen += 4; - mbuf[0] = rand() % 0xFF; - mbuf[1] = rand() % 0xFF; - mbuf[2] = rand() % 0xFF; - mbuf[3] = rand() % 0xFF; + mbuf[0] = rand() % 0xFF; // NOLINT(runtime/threadsafe_fn) + mbuf[1] = rand() % 0xFF; // NOLINT(runtime/threadsafe_fn) + mbuf[2] = rand() % 0xFF; // NOLINT(runtime/threadsafe_fn) + mbuf[3] = rand() % 0xFF; // NOLINT(runtime/threadsafe_fn) } if (len > 125) { headLen += 2; diff --git a/src/AsyncWebSocket.h b/src/AsyncWebSocket.h index a3cc661f3..e314417b6 100644 --- a/src/AsyncWebSocket.h +++ b/src/AsyncWebSocket.h @@ -1,8 +1,7 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // Copyright 2016-2025 Hristo Gochkov, Mathieu Carbou, Emil Muratov -#ifndef ASYNCWEBSOCKET_H_ -#define ASYNCWEBSOCKET_H_ +#pragma once #include @@ -32,6 +31,9 @@ #include #include +#include +#include +#include #include #ifdef ESP8266 @@ -454,8 +456,8 @@ class AsyncWebSocket : public AsyncWebHandler { AsyncWebSocketClient *_newClient(AsyncWebServerRequest *request); void _handleDisconnect(AsyncWebSocketClient *client); void _handleEvent(AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len); - bool canHandle(AsyncWebServerRequest *request) const override final; - void handleRequest(AsyncWebServerRequest *request) override final; + bool canHandle(AsyncWebServerRequest *request) const final; + void handleRequest(AsyncWebServerRequest *request) final; // messagebuffer functions/objects. AsyncWebSocketMessageBuffer *makeBuffer(size_t size = 0); @@ -567,5 +569,3 @@ class AsyncWebSocketMessageHandler { } }; }; - -#endif /* ASYNCWEBSOCKET_H_ */ diff --git a/src/BackPort_SHA1Builder.h b/src/BackPort_SHA1Builder.h index e7eafbef9..5f2690616 100644 --- a/src/BackPort_SHA1Builder.h +++ b/src/BackPort_SHA1Builder.h @@ -12,12 +12,11 @@ // See the License for the specific language governing permissions and // limitations under the License. +#pragma once + #include #if ESP_IDF_VERSION_MAJOR < 5 -#ifndef SHA1Builder_h -#define SHA1Builder_h - #include #include @@ -39,6 +38,4 @@ class SHA1Builder { void getBytes(uint8_t *output); }; -#endif // SHA1Builder_h - #endif // ESP_IDF_VERSION_MAJOR < 5 diff --git a/src/ChunkPrint.h b/src/ChunkPrint.h index 04938b3f2..7e31b6af9 100644 --- a/src/ChunkPrint.h +++ b/src/ChunkPrint.h @@ -1,8 +1,7 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // Copyright 2016-2025 Hristo Gochkov, Mathieu Carbou, Emil Muratov -#ifndef CHUNKPRINT_H -#define CHUNKPRINT_H +#pragma once #include @@ -20,4 +19,3 @@ class ChunkPrint : public Print { return this->Print::write(buffer, size); } }; -#endif diff --git a/src/ESPAsyncWebServer.h b/src/ESPAsyncWebServer.h index d26741c0d..91f289fa4 100644 --- a/src/ESPAsyncWebServer.h +++ b/src/ESPAsyncWebServer.h @@ -1,8 +1,7 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // Copyright 2016-2025 Hristo Gochkov, Mathieu Carbou, Emil Muratov -#ifndef _ESPAsyncWebServer_H_ -#define _ESPAsyncWebServer_H_ +#pragma once #include #include @@ -12,7 +11,10 @@ #include #include #include +#include +#include #include +#include #include #if __has_include("ArduinoJson.h") @@ -45,8 +47,6 @@ #error Platform not supported #endif -#include "literals.h" - #include "AsyncWebServerVersion.h" #define ASYNCWEBSERVER_FORK_ESP32Async @@ -54,6 +54,8 @@ #include #endif +#include "./literals.h" + // See https://github.com/ESP32Async/ESPAsyncWebServer/commit/3d3456e9e81502a477f6498c44d0691499dda8f9#diff-646b25b11691c11dce25529e3abce843f0ba4bd07ab75ec9eee7e72b06dbf13fR388-R392 // This setting slowdown chunk serving but avoids crashing or deadlocks in the case where slow chunk responses are created, like file serving form SD Card #ifndef ASYNCWEBSERVER_USE_CHUNK_INFLIGHT @@ -1584,5 +1586,3 @@ class DefaultHeaders { #if ASYNC_JSON_SUPPORT == 1 #include #endif - -#endif /* _AsyncWebServer_H_ */ diff --git a/src/Middleware.cpp b/src/Middleware.cpp index ac651e2d5..0f108f822 100644 --- a/src/Middleware.cpp +++ b/src/Middleware.cpp @@ -4,6 +4,8 @@ #include "WebAuthentication.h" #include +#include + AsyncMiddlewareChain::~AsyncMiddlewareChain() { for (AsyncMiddleware *m : _middlewares) { if (m->_freeOnRemoval) { diff --git a/src/WebAuthentication.cpp b/src/WebAuthentication.cpp index b9a98d80e..98cfe4a86 100644 --- a/src/WebAuthentication.cpp +++ b/src/WebAuthentication.cpp @@ -8,9 +8,10 @@ #if defined(ESP32) || defined(TARGET_RP2040) || defined(TARGET_RP2350) || defined(PICO_RP2040) || defined(PICO_RP2350) #include #else -#include "md5.h" +#include #endif -#include "literals.h" + +#include "./literals.h" using namespace asyncsrv; @@ -84,7 +85,7 @@ String genRandomMD5() { #ifdef ESP8266 uint32_t r = RANDOM_REG32; #else - uint32_t r = rand(); + uint32_t r = rand(); // NOLINT(runtime/threadsafe_fn) #endif char *out = (char *)malloc(33); if (out == NULL || !getMD5((uint8_t *)(&r), 4, out)) { diff --git a/src/WebAuthentication.h b/src/WebAuthentication.h index 1711821f9..4221dc8cb 100644 --- a/src/WebAuthentication.h +++ b/src/WebAuthentication.h @@ -1,8 +1,7 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // Copyright 2016-2025 Hristo Gochkov, Mathieu Carbou, Emil Muratov -#ifndef WEB_AUTHENTICATION_H_ -#define WEB_AUTHENTICATION_H_ +#pragma once #include "Arduino.h" @@ -19,5 +18,3 @@ String generateDigestHash(const char *username, const char *password, const char String generateBasicHash(const char *username, const char *password); String genRandomMD5(); - -#endif diff --git a/src/WebHandlerImpl.h b/src/WebHandlerImpl.h index 77023bbb3..7b2494832 100644 --- a/src/WebHandlerImpl.h +++ b/src/WebHandlerImpl.h @@ -1,13 +1,13 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // Copyright 2016-2025 Hristo Gochkov, Mathieu Carbou, Emil Muratov -#ifndef ASYNCWEBSERVERHANDLERIMPL_H_ -#define ASYNCWEBSERVERHANDLERIMPL_H_ +#pragma once -#include -#include "stddef.h" +#include #include +#include + class AsyncStaticWebHandler : public AsyncWebHandler { using File = fs::File; using FS = fs::FS; @@ -29,8 +29,8 @@ class AsyncStaticWebHandler : public AsyncWebHandler { public: AsyncStaticWebHandler(const char *uri, FS &fs, const char *path, const char *cache_control); - bool canHandle(AsyncWebServerRequest *request) const override final; - void handleRequest(AsyncWebServerRequest *request) override final; + bool canHandle(AsyncWebServerRequest *request) const final; + void handleRequest(AsyncWebServerRequest *request) final; AsyncStaticWebHandler &setTryGzipFirst(bool value); AsyncStaticWebHandler &setIsDir(bool isDir); AsyncStaticWebHandler &setDefaultFile(const char *filename); @@ -77,13 +77,11 @@ class AsyncCallbackWebHandler : public AsyncWebHandler { _onBody = fn; } - bool canHandle(AsyncWebServerRequest *request) const override final; - void handleRequest(AsyncWebServerRequest *request) override final; - void handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len, bool final) override final; - void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override final; - bool isRequestHandlerTrivial() const override final { + bool canHandle(AsyncWebServerRequest *request) const final; + void handleRequest(AsyncWebServerRequest *request) final; + void handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len, bool final) final; + void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) final; + bool isRequestHandlerTrivial() const final { return !_onRequest; } }; - -#endif /* ASYNCWEBSERVERHANDLERIMPL_H_ */ diff --git a/src/WebHandlers.cpp b/src/WebHandlers.cpp index 8addf3113..9370a8ec7 100644 --- a/src/WebHandlers.cpp +++ b/src/WebHandlers.cpp @@ -5,6 +5,9 @@ #include "WebHandlerImpl.h" #include "AsyncWebServerLogging.h" +#include +#include + using namespace asyncsrv; AsyncWebHandler &AsyncWebHandler::setFilter(ArRequestFilterFunction fn) { @@ -76,7 +79,7 @@ AsyncStaticWebHandler &AsyncStaticWebHandler::setLastModified(struct tm *last_mo char result[30]; #ifdef ESP8266 auto formatP = PSTR("%a, %d %b %Y %H:%M:%S GMT"); - char format[strlen_P(formatP) + 1]; + char format[strlen_P(formatP) + 1]; // NOLINT(runtime/arrays) strcpy_P(format, formatP); #else static constexpr const char *format = "%a, %d %b %Y %H:%M:%S GMT"; diff --git a/src/WebRequest.cpp b/src/WebRequest.cpp index 607c7dc22..1865dd587 100644 --- a/src/WebRequest.cpp +++ b/src/WebRequest.cpp @@ -5,8 +5,13 @@ #include "WebAuthentication.h" #include "WebResponseImpl.h" #include "AsyncWebServerLogging.h" -#include "literals.h" + +#include #include +#include +#include + +#include "./literals.h" static inline bool isParamChar(char c) { return ((c) && ((c) != '{') && ((c) != '[') && ((c) != '&') && ((c) != '=')); diff --git a/src/WebResponseImpl.h b/src/WebResponseImpl.h index 9be9bc790..650a757d1 100644 --- a/src/WebResponseImpl.h +++ b/src/WebResponseImpl.h @@ -1,19 +1,20 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // Copyright 2016-2025 Hristo Gochkov, Mathieu Carbou, Emil Muratov -#ifndef ASYNCWEBSERVERRESPONSEIMPL_H_ -#define ASYNCWEBSERVERRESPONSEIMPL_H_ +#pragma once #ifdef Arduino_h // arduino is not compatible with std::vector #undef min #undef max #endif -#include "literals.h" #include + #include #include +#include "./literals.h" + #ifndef CONFIG_LWIP_TCP_MSS // as it is defined for ESP32's Arduino LWIP #define CONFIG_LWIP_TCP_MSS 1436 @@ -34,11 +35,11 @@ class AsyncBasicResponse : public AsyncWebServerResponse { explicit AsyncBasicResponse(int code, const char *contentType = asyncsrv::empty, const char *content = asyncsrv::empty); 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 { + void _respond(AsyncWebServerRequest *request) final; + size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time) final { return write_send_buffs(request, len, time); }; - bool _sourceValid() const override final { + bool _sourceValid() const final { return true; } @@ -97,8 +98,8 @@ class AsyncAbstractResponse : public AsyncWebServerResponse { public: 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 { + void _respond(AsyncWebServerRequest *request) final; + size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time) final { return write_send_buffs(request, len, time); }; virtual bool _sourceValid() const { @@ -134,10 +135,10 @@ class AsyncFileResponse : public AsyncAbstractResponse { ~AsyncFileResponse() { _content.close(); } - bool _sourceValid() const override final { + bool _sourceValid() const final { return !!(_content); } - size_t _fillBuffer(uint8_t *buf, size_t maxLen) override final; + size_t _fillBuffer(uint8_t *buf, size_t maxLen) final; }; class AsyncStreamResponse : public AsyncAbstractResponse { @@ -148,10 +149,10 @@ class AsyncStreamResponse : public AsyncAbstractResponse { AsyncStreamResponse(Stream &stream, const char *contentType, size_t len, AwsTemplateProcessor callback = nullptr); AsyncStreamResponse(Stream &stream, const String &contentType, size_t len, AwsTemplateProcessor callback = nullptr) : AsyncStreamResponse(stream, contentType.c_str(), len, callback) {} - bool _sourceValid() const override final { + bool _sourceValid() const final { return !!(_content); } - size_t _fillBuffer(uint8_t *buf, size_t maxLen) override final; + size_t _fillBuffer(uint8_t *buf, size_t maxLen) final; }; class AsyncCallbackResponse : public AsyncAbstractResponse { @@ -163,10 +164,10 @@ class AsyncCallbackResponse : public AsyncAbstractResponse { AsyncCallbackResponse(const char *contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr); AsyncCallbackResponse(const String &contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) : AsyncCallbackResponse(contentType.c_str(), len, callback, templateCallback) {} - bool _sourceValid() const override final { + bool _sourceValid() const final { return !!(_content); } - size_t _fillBuffer(uint8_t *buf, size_t maxLen) override final; + size_t _fillBuffer(uint8_t *buf, size_t maxLen) final; }; class AsyncChunkedResponse : public AsyncAbstractResponse { @@ -178,10 +179,10 @@ class AsyncChunkedResponse : public AsyncAbstractResponse { AsyncChunkedResponse(const char *contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr); AsyncChunkedResponse(const String &contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) : AsyncChunkedResponse(contentType.c_str(), callback, templateCallback) {} - bool _sourceValid() const override final { + bool _sourceValid() const final { return !!(_content); } - size_t _fillBuffer(uint8_t *buf, size_t maxLen) override final; + size_t _fillBuffer(uint8_t *buf, size_t maxLen) final; }; class AsyncProgmemResponse : public AsyncAbstractResponse { @@ -194,10 +195,10 @@ class AsyncProgmemResponse : public AsyncAbstractResponse { AsyncProgmemResponse(int code, const char *contentType, const uint8_t *content, size_t len, AwsTemplateProcessor callback = nullptr); AsyncProgmemResponse(int code, const String &contentType, const uint8_t *content, size_t len, AwsTemplateProcessor callback = nullptr) : AsyncProgmemResponse(code, contentType.c_str(), content, len, callback) {} - bool _sourceValid() const override final { + bool _sourceValid() const final { return true; } - size_t _fillBuffer(uint8_t *buf, size_t maxLen) override final; + size_t _fillBuffer(uint8_t *buf, size_t maxLen) final; }; class AsyncResponseStream : public AsyncAbstractResponse, public Print { @@ -207,10 +208,10 @@ class AsyncResponseStream : public AsyncAbstractResponse, public Print { public: AsyncResponseStream(const char *contentType, size_t bufferSize); AsyncResponseStream(const String &contentType, size_t bufferSize) : AsyncResponseStream(contentType.c_str(), bufferSize) {} - bool _sourceValid() const override final { + bool _sourceValid() const final { return (_state < RESPONSE_END); } - size_t _fillBuffer(uint8_t *buf, size_t maxLen) override final; + size_t _fillBuffer(uint8_t *buf, size_t maxLen) final; size_t write(const uint8_t *data, size_t len); size_t write(uint8_t data); /** @@ -221,5 +222,3 @@ class AsyncResponseStream : public AsyncAbstractResponse, public Print { } using Print::write; }; - -#endif /* ASYNCWEBSERVERRESPONSEIMPL_H_ */ diff --git a/src/WebResponses.cpp b/src/WebResponses.cpp index 22723e412..33bc01762 100644 --- a/src/WebResponses.cpp +++ b/src/WebResponses.cpp @@ -5,6 +5,10 @@ #include "WebResponseImpl.h" #include "AsyncWebServerLogging.h" +#include +#include +#include + #ifndef CONFIG_LWIP_TCP_WND_DEFAULT // as it is defined for esp32's LWIP #define CONFIG_LWIP_TCP_WND_DEFAULT 5760 diff --git a/src/WebServer.cpp b/src/WebServer.cpp index 79c94978a..724d2482d 100644 --- a/src/WebServer.cpp +++ b/src/WebServer.cpp @@ -4,6 +4,9 @@ #include "ESPAsyncWebServer.h" #include "WebHandlerImpl.h" +#include +#include + #if defined(ESP32) || defined(TARGET_RP2040) || defined(TARGET_RP2350) || defined(PICO_RP2040) || defined(PICO_RP2350) || defined(LIBRETINY) #include #elif defined(ESP8266)