[bug]: Fix use-after-free in ephemeral_bridging_function after a bad merge.

- Restore correct ownership transfer in EventBridge.cpp by reintroducing local_bridge, ensuring doWork() is called on a valid object and preventing use-after-free.
- Minor doc and formatting updates,

Signed-off-by: Goran Mišković <schkovich@users.noreply.github.com>

Author: schkovich

include/TcpClientContext.hpp

@@ -581,7 +581,7 @@ namespace async_tcp {
             }
 
             void setOnErrorCallback(const std::function<void(err_t err)> &cb) {
-                _errorCb = cb; // Set the error callback
+                _errorCb = cb;
             }
 
             void setOnReceiveCallback(

include/TcpWriteHandler.hpp

@@ -20,7 +20,6 @@
 #include "TcpClient.hpp"
 #include <functional>
 #include <memory>
-#include <string>
 
 namespace async_tcp {
 
@@ -71,7 +70,6 @@ namespace async_tcp {
              * @param ctx Context manager for execution
              * @param data Pointer to binary data chunk to write
              * @param size Size of data chunk to write
-             * @param remaining Total remaining bytes to write (including this chunk)
              * @param io TCP client to use
              */
             static void create(const AsyncCtx & ctx,

src/EventBridge.cpp

@@ -3,16 +3,24 @@
  * @brief Implementation of the EventBridge class for bridging between C-style
  * async context and C++ event handling.
  *
- * This file implements the EventBridge class, which provides a foundation for event handlers with proper core affinity in the AsyncTcpClient library.
- * It supports explicit initialization and registration of worker types:
+ * This file implements the EventBridge class, which provides a foundation for
+ * event handlers with proper core affinity in the AsyncTcpClient library. It
+ * supports explicit initialization and registration of worker types:
  *
- * 1. Persistent "when pending" workers - Registered via initialisePerpetualBridge().
- *    These remain registered with the context manager until explicitly removed. Registration is no longer automatic in the constructor.
+ * 1. Persistent "when pending" workers - Registered via
+ * initialisePerpetualBridge(). These remain registered with the context manager
+ * until explicitly removed. Registration is no longer automatic in the
+ * constructor.
  *
  * 2. Ephemeral "at time" workers - Registered via initialiseEphemeralBridge().
- *    These execute once at a specific time and are automatically removed from the context manager after execution. They can optionally manage their own lifecycle through self-ownership.
+ *    These execute once at a specific time and are automatically removed from
+ * the context manager after execution. They can optionally manage their own
+ * lifecycle through self-ownership.
  *
- * The implementation manages worker registration, lifecycle, and event execution, following the Template Method pattern. It provides thread-safe execution with core affinity guarantees and a clean separation between async mechanisms and business logic.
+ * The implementation manages worker registration, lifecycle, and event
+ * execution, following the Template Method pattern. It provides thread-safe
+ * execution with core affinity guarantees and a clean separation between async
+ * mechanisms and business logic.
  *
  * @ingroup AsyncTCPClient
  */
@@ -81,9 +89,10 @@ namespace async_tcp {
                                      async_work_on_timeout *worker) { // NOLINT
         (void)context;
         if (worker && worker->user_data) {
-            const auto pBridge = static_cast<EventBridge *>(worker->user_data);
-            pBridge->doWork();
-            pBridge->releaseOwnership();
+            const auto local_bridge =
+                static_cast<EventBridge *>(worker->user_data)
+                    ->releaseOwnership();
+            local_bridge->doWork();
         } else {
             DEBUGV("\033[1;31m[AC-%d][%llu][ERROR] "
                    "EventBridge::ephemeral_bridging_function - invalid worker "

src/TcpClient.cpp

@@ -196,8 +196,7 @@ namespace async_tcp {
         assert(m_writer && "TcpWriter must be configured for async operations");
 
         // Atomically check if no write is in progress and set it to true if so
-        bool expected = false;
-        if (!m_writer->tryStartWrite(expected)) {
+        if (bool expected = false; !m_writer->tryStartWrite(expected)) {
             DEBUGWIRE("[TcpClient] Write operation already in progress, rejecting new write\n");
             return PICO_ERROR_RESOURCE_IN_USE;
         }

src/TcpWriteHandler.cpp

@@ -12,7 +12,6 @@
  */
 
 #include "TcpWriteHandler.hpp"
-#include "lwip/tcp.h"
 
 namespace async_tcp {
 
@@ -25,7 +24,7 @@ namespace async_tcp {
 
     void TcpWriteHandler::onWork() {
         if (!m_data || m_size == 0) {
-            // No valid data to write - let the cleanup mechanism handle destruction
+            // No valid data to write - let the cleanup mechanism handle destruction.
             return;
         }