HttpServer Class Reference

HTTP Server that listens for incoming connections and dispatches requests. More...

#include <HttpServer.h>

Collaboration diagram for HttpServer:

Public Member Functions
	HttpServer (int port, Router &router)
	Construct a new HttpServer instance.
bool	start ()
	Start the HTTP server as a FreeRTOS task.
bool	initNetwork ()
	Initialize the network stack (wait for DHCP or static IP).
void	run ()
	Main server loop: initializes, binds, and begins accepting connections.
Tcp *	initListener ()
	Create, bind, and listen on the server.
void	handleClient (Tcp *conn)
	Accept a client connection and handle it directly (not task-based).
void	startHandlingClient (Tcp *conn)
	Spawn a task to handle the client connection.
HttpRequest	receiveRequest (Tcp *conn, char *method, char *path, std::string &body, size_t &contentLength, std::unordered_map< std::string, std::string > &headers)
	Receive an HTTP request and parse key components.
Router &	getRouter ()
	Return the router associated with the server.

Static Public Member Functions
static void	startServerTask (void *pvParameters)
	Launch the HTTP server task (used by FreeRTOS).
static void	handleClientTask (void *pvParameters)
	Handle client logic inside a FreeRTOS task.

Private Attributes
int	port
	Accept client connections in a blocking loop and spawn handlers.
Router &	router
	Reference to router for dispatching requests.
Tcp	listener

Static Private Attributes
static constexpr int	BUFFER_SIZE = 1460
static constexpr int	BOUNDARY_MAX_LEN = 128
static StackType_t	xStack [HTTP_STACK_SIZE]
	Stack for static FreeRTOS task.
static StaticTask_t	xTaskBuffer
	Task control block buffer.

Detailed Description

Definition at line 28 of file HttpServer.h.

Constructor & Destructor Documentation

HttpServer()

HttpServer::HttpServer	(	int	port,
		Router &	router
	)

Construct a new HttpServer instance.

Parameters

port	Port number to listen on.
router	Reference to the Router for handling requests.

Parameters

port	Port number to listen on.
router	Reference to the Router for handling requests.

Definition at line 78 of file HttpServer.cpp.

    : port(port), router(router)
{
}

Member Function Documentation

getRouter()

Router & HttpServer::getRouter ( )

inline

Returns

Router reference.

Definition at line 96 of file HttpServer.h.

{ return router; }

References router.

handleClient()

void HttpServer::handleClient

(

Tcp *

conn

)

Accept a client connection and handle it directly (not task-based).

Tcp* TCP connection instance

Tcp* TCP connection instance

Definition at line 219 of file HttpServer.cpp.

{
    int64_t start = to_ms_since_boot(get_absolute_time());
    int64_t lastActivity = start;
    const int64_t idleTimeoutMs = HTTP_IDLE_TIMEOUT; //  idle timeout - kill connection if no data received
 
 
    HttpRequest req = HttpRequest::receive(conn);
    if (req.getMethod().empty())
    {
        TRACE("[HttpServer] Empty HTTP method — client either closed connection or it is Safari trying to reuse closed socket\n");
        return;
    }
    TRACE("HttpRequest received: %s, %s\n", req.getMethod().c_str(), req.getPath().c_str());
    TRACE("HttpRequest content length: %s\n", req.getContentLength());
    TRACE("HttpRequest content type: %s\n", req.getContentType());
    TRACE("HttpRequest boundary: %s\n", req.getBoundary());
    TRACE("HttpRequest is multipart: %s\n", (req.isMultipart() ? "true" : "false"));
    TRACE("HttpRequest header count: %d\n", req.getHeaders().size());
    TRACE("HttpRequest url: %s\n", req.getUri().c_str());
    TRACE("HttpRequest path: %s\n", req.getPath().c_str());
    TRACE("HttpRequest query: %s\n", req.getQuery().c_str());
 
    for (const auto& param : req.getQueryParams())
    {
        TRACE("HttpRequest query parameter %s : %s\n", param.first.c_str(), param.second.c_str());
    }
 
    for (const auto& param : req.getFormParams())
    {
        TRACE("HttpRequest form parameter %s : %s\n", param.first.c_str(), param.second.c_str());
    }
 
    for (const auto& cookie : req.getCookies())
    {
        TRACE("HttpRequest cookie %s : %s\n", cookie.first.c_str(), cookie.second.c_str());
    }
 
    if (req.getContentLength() > 0)
    {
        TRACE("HttpRequest body length: %d\n", req.getBody().length());
        TRACE("HttpRequest start of body index: %d\n", req.getHeaderEnd());
    }
 
    TRACE("HttpRequest headers:\n");
    for (const auto& headr : req.getHeaders())
    {
        TRACE("%s : %s\n", headr.first.c_str(), headr.second.c_str());
    }
 
    TRACE("HttpRequest body: %s\n", req.getBody().c_str());
 
    QUIET_PRINTF("[HttpServer] Client request received: %s, path: %s\n", req.getMethod().c_str(), req.getPath().c_str());
 
    HttpResponse res(conn);
    TRACE("HttpResponse created\n");
    res.setHeader("Connection", "close"); // Close the connection 
 
    bool ok = router.handleRequest(req, res);
    TRACE("HttpRequest handled: %s\n", ok ? "true" : "false");
 
    if (!ok)
    {
        JsonResponse::sendError(res, 404, "NOT_FOUND", "route: " + std::string(req.getUri()));
    }
 
    lastActivity = to_ms_since_boot(get_absolute_time());
 
    if (req.getHeader("Connection") == "close")
    {
        TRACE("[HttpServer] Client requested Connection: close, closing connection\n");
        return;
    }
 
    if (to_ms_since_boot(get_absolute_time()) - lastActivity > idleTimeoutMs)
    {
        printf("[HttpServer] Idle timeout reached, closing connection\n");
        return;
    }
 
    conn->close();
    int64_t end = to_ms_since_boot(get_absolute_time());
    TRACE("[HttpServer] Client handled in %lld ms\n", end - start);
}

References Tcp::close(), HttpRequest::getBody(), HttpRequest::getBoundary(), HttpRequest::getContentLength(), HttpRequest::getContentType(), HttpRequest::getCookies(), HttpRequest::getFormParams(), HttpRequest::getHeader(), HttpRequest::getHeaderEnd(), HttpRequest::getHeaders(), HttpRequest::getMethod(), HttpRequest::getPath(), HttpRequest::getQuery(), HttpRequest::getQueryParams(), HttpRequest::getUri(), Router::handleRequest(), HTTP_IDLE_TIMEOUT, HttpRequest::isMultipart(), QUIET_PRINTF, HttpRequest::receive(), router, JsonResponse::sendError(), HttpResponse::setHeader(), start(), and TRACE.

Referenced by startHandlingClient().

Here is the call graph for this function:

Here is the caller graph for this function:

handleClientTask()

static void HttpServer::handleClientTask ( void *  pvParameters )

static

Parameters

pvParameters

Pointer to TaskParams (including Tcp*)

Referenced by startHandlingClient().

Here is the caller graph for this function:

initListener()

Tcp * HttpServer::initListener

(

)

Returns

Tcp* TCP connection instance

Definition at line 176 of file HttpServer.cpp.

{
    if (!listener.bindAndListen(port)) {
        return nullptr;
    }
    // Once server is listening
    Event e(SystemNotification::HttpServerStarted);
    AppContext::get<EventManager>()->postEvent(e); // tell others that we are up
    return &listener;
}

References Tcp::bindAndListen(), AppContext::getTypeKey(), HttpServerStarted, listener, and port.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

initNetwork()

bool HttpServer::initNetwork

(

)

Initialize the network stack (wait for DHCP or static IP).

Returns

true if successful.

Returns

true if successful.

Definition at line 154 of file HttpServer.cpp.

{
    struct netif *netif;
 
    //TRACE("Waiting for DHCP lease...\n");
 
    while (true)
    {
        netif = netif_list;
        if (netif && netif->ip_addr.addr != 0)
        {
            break;
        }
        vTaskDelay(pdMS_TO_TICKS(10));
    }
 
    //TRACE("Assigned IP Address: %s\n", ip4addr_ntoa(&netif->ip_addr));
    return true;
}

Referenced by run().

Here is the caller graph for this function:

receiveRequest()

HttpRequest HttpServer::receiveRequest	(	Tcp *	conn,
		char *	method,
		char *	path,
		std::string &	body,
		size_t &	contentLength,
		std::unordered_map< std::string, std::string > &	headers
	)

Parameters

Tcp*	TCP connection instance
method	Output buffer for method.
path	Output buffer for path.
body	Output body content.
contentLength	Output content length.
headers	Output map of parsed headers.

Returns

Parsed HttpRequest object.

run()

void HttpServer::run

(

)

Main server loop: initializes, binds, and begins accepting connections.

Definition at line 103 of file HttpServer.cpp.

{
 
    printf("[HttpServer] Starting HTTP Server on port %d\n", port);
 
    if (!initNetwork())
    {
        return;
    }
 
    Tcp* listener = initListener();
    if (!listener)
    {
        printf("[HttpServer] Failed to initialize listener\n");
        return;
    }
 
    AppContext::get<EventManager>()->postEvent({SystemNotification::HttpServerStarted});
 
    // Optional: store listener as a class member if needed later
    while (true)
    {
        TRACE("[HttpServer] Waiting for client connection...\n");
        Tcp* conn = listener->accept();
        if (conn)
        {
            QUIET_PRINTF("\n===== HTTP CLIENT ACCEPTED ====\n");
            QUIET_PRINTF("[HttpServer] Accepted client connection\n");
            startHandlingClient(conn);
            vTaskDelay(pdMS_TO_TICKS(10));
            
            QUIET_PRINTF("[HttpServer] Client connection handled\n");
            QUIET_PRINTF("===============================\n\n");
            #if !defined(HTTP_SERVER_USE_TASK_PER_CLIENT)
                delete conn;
            #endif
        }
        else
        {
            warning("[HttpServer] Failed to accept client connection\n");
            vTaskDelay(pdMS_TO_TICKS(10)); // Wait before retrying 
        }
 
    }
 
    // Note: we never reach here in this model
    delete listener;
}

References Tcp::accept(), AppContext::getTypeKey(), HttpServerStarted, initListener(), initNetwork(), listener, port, QUIET_PRINTF, startHandlingClient(), TRACE, and warning().

Referenced by startServerTask().

Here is the call graph for this function:

Here is the caller graph for this function:

start()

bool HttpServer::start

(

)

Start the HTTP server as a FreeRTOS task.

Returns

true if task created successfully.

Returns

true if task created successfully.

Definition at line 84 of file HttpServer.cpp.

{
    clientSemaphore = xSemaphoreCreateCounting(MAX_CONCURRENT_CLIENTS, MAX_CONCURRENT_CLIENTS);
    return xTaskCreateStatic(startServerTask, "HttpServer", HTTP_STACK_SIZE, this, 5, xStack, &xTaskBuffer);
}

References clientSemaphore, HTTP_STACK_SIZE, MAX_CONCURRENT_CLIENTS, startServerTask(), xStack, and xTaskBuffer.

Referenced by handleClient(), and App::onEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

startHandlingClient()

void HttpServer::startHandlingClient

(

Tcp *

conn

)

Parameters

Tcp*	TCP connection instance.

Definition at line 187 of file HttpServer.cpp.

{
#ifdef HTTP_SERVER_USE_TASK_PER_CLIENT
    if (xSemaphoreTake(clientSemaphore, pdMS_TO_TICKS(100)) == pdPASS)
    {
        TaskParams *params = new TaskParams{this, conn};
 
        if (xTaskCreate(handleClientTask, "HttpClient", 4096, params, 4, NULL) == pdPASS)
        {
            TRACE("Client task created successfully");
        }
        else
        {
            TRACE("Failed to create client task");
            conn->close();
            delete params;
            xSemaphoreGive(clientSemaphore);
        }
    }
    else
    {
        TRACE("Max concurrent clients reached, closing connection");
        conn->close();
        // Optional: return a "503 Service Unavailable" if desired
    }
#else
    handleClient(conn);
 
#endif
}

References clientSemaphore, Tcp::close(), handleClient(), handleClientTask(), and TRACE.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

startServerTask()

void HttpServer::startServerTask ( void *  pvParameters )

static

Launch the HTTP server task (used by FreeRTOS).

Parameters

pvParameters

Pointer to HttpServer instance.

Parameters

pvParameters

Pointer to HttpServer instance.

Definition at line 91 of file HttpServer.cpp.

{
    HttpServer *server = static_cast<HttpServer *>(pvParameters);
    server->run();
    vTaskDelete(NULL);
}

References run().

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

BOUNDARY_MAX_LEN

constexpr int HttpServer::BOUNDARY_MAX_LEN = 128

staticconstexprprivate

Definition at line 115 of file HttpServer.h.

BUFFER_SIZE

constexpr int HttpServer::BUFFER_SIZE = 1460

staticconstexprprivate

Definition at line 114 of file HttpServer.h.

listener

Tcp HttpServer::listener

private

Definition at line 113 of file HttpServer.h.

Referenced by initListener(), and run().

port

int HttpServer::port

private

Port number to listen on.

Definition at line 110 of file HttpServer.h.

Referenced by initListener(), and run().

router

Router& HttpServer::router

private

Definition at line 111 of file HttpServer.h.

Referenced by getRouter(), and handleClient().

xStack

StackType_t HttpServer::xStack

staticprivate

Definition at line 117 of file HttpServer.h.

Referenced by start().

xTaskBuffer

StaticTask_t HttpServer::xTaskBuffer

staticprivate

Definition at line 118 of file HttpServer.h.

Referenced by start().

---

The documentation for this class was generated from the following files:

• HttpServer.h
• HttpServer.cpp