Move HttpDaemon logic into httpd.cpp

Refactors `HttpDaemon` by moving constructor and request callback implementation out of the header into a new `httpd.cpp` translation unit. The handler table is replaced with explicit raw storage in a dedicated `.httpd` section and constructed via placement new, with `GetHandler()`/`std::launder` used for safe access. Also tightens class lifetime semantics by deleting copy/move operations and trims now-unneeded header includes.

Author: vanvught

lib-remoteconfig/include/httpd/httpd.h

@@ -30,15 +30,12 @@
 #define HTTPD_HTTPD_H_
 
 #include <cstdint>
-#include <cassert>
-#include <new>
 
 #include "core/protocol/iana.h"
 #include "httpdhandlerequest.h"
 #include "network_tcp.h"
 #include "apps/mdns.h"
 #include "../../lib-network/config/net_config.h"
-#include "firmware/debug/debug_debug.h"
 
 namespace httpd {
 inline constexpr auto kPort =
@@ -57,41 +54,34 @@ inline constexpr auto kService =
 
 class HttpDaemon {
    public:
-    HttpDaemon() {
-        DEBUG_ENTRY();
-        assert(is_listening_ == false);
-
-        is_listening_ = network::tcp::Listen(httpd::kPort, Data);
-        assert(is_listening_ == true);
-
-        // IMPORTANT:
-        // Connection handles are GLOBAL indices into s_Tcbs[].
-        // Therefore the HTTP request handler table must also be global-sized.
-        for (uint32_t i = 0; i < TCP_MAX_TCBS_ALLOWED; ++i) {
-            // Each HttpDeamonHandleRequest corresponds to ONE possible TCB slot.
-            // It can be addressed directly by conn_handle.
-            new (&s_handle_request[i]) HttpDeamonHandleRequest(i);
-        }
-
-        network::apps::mdns::ServiceRecordAdd(nullptr, httpd::kService);
-
-        DEBUG_EXIT();
-    }
+    HttpDaemon();
 
+    // The daemon and its handlers live for the lifetime of the firmware.
     ~HttpDaemon() = default;
 
-   private:
-    static void Data(network::tcp::ConnHandle conn_handle, const uint8_t* buffer, uint32_t size, [[maybe_unused]] void* context) {
-        assert(conn_handle < TCP_MAX_TCBS_ALLOWED);
-        s_handle_request[conn_handle].HandleRequest(size, const_cast<char*>(reinterpret_cast<const char*>(buffer)));
-    }
+    HttpDaemon(const HttpDaemon&) = delete;
+    HttpDaemon& operator=(const HttpDaemon&) = delete;
+    HttpDaemon(HttpDaemon&&) = delete;
+    HttpDaemon& operator=(HttpDaemon&&) = delete;
 
-#if defined(GD32F207RG) || defined(GD32F450VE) || defined(GD32F470ZK)
-#define SECTION_HTTPD __attribute__((section(".httpd")))
-#else
-#define SECTION_HTTPD
-#endif
-    static inline HttpDeamonHandleRequest s_handle_request[TCP_MAX_TCBS_ALLOWED] __attribute__((aligned(4))) SECTION_HTTPD;
+   private:
+    /**
+     * Raw storage for one HttpDeamonHandleRequest.
+     *
+     * The storage itself has trivial initialization, so it can safely be
+     * placed in a NOLOAD linker section. The actual handler object is created
+     * explicitly with placement new in HttpDaemon::HttpDaemon().
+     */
+    struct HandlerStorage {
+        alignas(HttpDeamonHandleRequest) unsigned char data[sizeof(HttpDeamonHandleRequest)];
+    };
+
+    [[nodiscard]]
+    static HttpDeamonHandleRequest& GetHandler(uint32_t index);
+
+    static void Data(network::tcp::ConnHandle conn_handle, const uint8_t* buffer, uint32_t size, void* context);
+
+    static HandlerStorage s_handle_request_storage[TCP_MAX_TCBS_ALLOWED];
 
     bool is_listening_{false};
 };

lib-remoteconfig/src/httpd/httpd.cpp

@@ -0,0 +1,102 @@
+/**
+ * @file httpd.cpp
+ *  @brief HTTP daemon class for managing HTTP server tasks.
+ *
+ * This class handles HTTP requests and integrates with the network and mDNS subsystems.
+ * It uses placement new to construct and destruct request handlers explicitly.
+ */
+/* Copyright (C) 2025-2026 by Arjan van Vught mailto:info@gd32-dmx.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <cassert>
+#include <new>
+
+#include "firmware/debug/debug_debug.h"
+#include "httpd/httpd.h"
+#include "network_tcp.h"
+#include "apps/mdns.h"
+#include "../../lib-network/config/net_config.h"
+
+/*
+ * Define the storage exactly once, outside the header.
+ *
+ * gnu::used:
+ *   Ensures that the compiler emits the object.
+ *
+ * .httpd:
+ *   Is collected by the linker script into the dedicated HTTP RAM section.
+ *
+ * The linker script should contain:
+ *
+ *   .http (NOLOAD) :
+ *   {
+ *       . = ALIGN(4);
+ *       _shttp = .;
+ *       KEEP(*(.http))
+ *       KEEP(*(.http.*))
+ *       KEEP(*(.httpd))
+ *       KEEP(*(.httpd.*))
+ *       . = ALIGN(4);
+ *       _ehttp = .;
+ *   } > RAM2
+ */
+[[gnu::section(".httpd"), gnu::aligned(alignof(HttpDeamonHandleRequest)), gnu::used]]
+HttpDaemon::HandlerStorage HttpDaemon::s_handle_request_storage[TCP_MAX_TCBS_ALLOWED];
+
+HttpDaemon::HttpDaemon() {
+    DEBUG_ENTRY();
+
+    assert(!is_listening_);
+
+    is_listening_ = network::tcp::Listen(httpd::kPort, Data);
+    assert(is_listening_);
+
+    /*
+     * Connection handles are global indices into s_Tcbs[].
+     * Therefore the request-handler table must have one entry for every
+     * possible global TCB slot.
+     */
+    for (uint32_t i = 0; i < TCP_MAX_TCBS_ALLOWED; ++i) {
+        // Construct exactly one handler in each raw-storage slot.
+        ::new (static_cast<void*>(s_handle_request_storage[i].data)) HttpDeamonHandleRequest(i);
+    }
+
+    network::apps::mdns::ServiceRecordAdd(nullptr, httpd::kService);
+
+    DEBUG_EXIT();
+}
+
+HttpDeamonHandleRequest& HttpDaemon::GetHandler(uint32_t index) {
+    assert(index < TCP_MAX_TCBS_ALLOWED);
+
+    /*
+     * std::launder is appropriate after constructing an object in raw storage
+     * and subsequently obtaining a pointer through the storage address.
+     */
+    return *std::launder(reinterpret_cast<HttpDeamonHandleRequest*>(s_handle_request_storage[index].data));
+}
+
+void HttpDaemon::Data(network::tcp::ConnHandle conn_handle, const uint8_t* buffer, uint32_t size, [[maybe_unused]] void* context) {
+    assert(conn_handle < TCP_MAX_TCBS_ALLOWED);
+    assert(buffer != nullptr);
+
+    GetHandler(conn_handle).HandleRequest(size, const_cast<char*>(reinterpret_cast<const char*>(buffer)));
+}