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.
void	enableTLS (const std::string &certPem, const std::string &keyPem)
	Enable TLS/HTTPS support with certificate and private key.
bool	isTLSEnabled () const
	Check if TLS is enabled for this server.
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
bool	tlsEnabled = false
std::string	serverCert
std::string	serverKey

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

enableTLS()

void HttpServer::enableTLS	(	const std::string &	certPem,
		const std::string &	keyPem
	)

Enable TLS/HTTPS support with certificate and private key.

Parameters

certPem	Server certificate in PEM format
keyPem	Private key in PEM format

Note

Must be called before start() to take effect

Parameters

certPem	Server certificate in PEM format
keyPem	Private key in PEM format

Note

Must be called before start() to take effect

Definition at line 84 of file HttpServer.cpp.

{
    serverCert = certPem;
    serverKey = keyPem;
    tlsEnabled = true;
    printf("[HttpServer] TLS enabled for HTTPS support\n");
}

References serverCert, serverKey, and tlsEnabled.

getRouter()

Router & HttpServer::getRouter ( )

inline

Returns

Router reference.

Definition at line 110 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 245 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 192 of file HttpServer.cpp.

{
    // Configure TLS if enabled
    if (tlsEnabled) {
        printf("[HttpServer] Configuring TLS server with certificate and key\n");
        listener.setServerTlsConfig(serverCert, serverKey);
    }
 
    if (!listener.bindAndListen(port)) {
        return nullptr;
    }
 
    printf("[HttpServer] Server listening on port %d (%s)\n",
           port, tlsEnabled ? "HTTPS" : "HTTP");
 
    // 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, port, serverCert, serverKey, Tcp::setServerTlsConfig(), and tlsEnabled.

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 170 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:

isTLSEnabled()

bool HttpServer::isTLSEnabled

(

)

const

Check if TLS is enabled for this server.

Returns

true if TLS is configured and enabled

Returns

true if TLS is configured and enabled

Definition at line 93 of file HttpServer.cpp.

{
    return tlsEnabled;
}

References tlsEnabled.

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 118 of file HttpServer.cpp.

{
 
    printf("[HttpServer] Starting %s Server on port %d\n",
           tlsEnabled ? "HTTPS" : "HTTP", 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(), tlsEnabled, 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 99 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 213 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 106 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 134 of file HttpServer.h.

BUFFER_SIZE

constexpr int HttpServer::BUFFER_SIZE = 1460

staticconstexprprivate

Definition at line 133 of file HttpServer.h.

listener

Tcp HttpServer::listener

private

Definition at line 127 of file HttpServer.h.

Referenced by initListener(), and run().

port

int HttpServer::port

private

Port number to listen on.

Definition at line 124 of file HttpServer.h.

Referenced by initListener(), and run().

router

Router& HttpServer::router

private

Definition at line 125 of file HttpServer.h.

Referenced by getRouter(), and handleClient().

serverCert

std::string HttpServer::serverCert

private

Definition at line 131 of file HttpServer.h.

Referenced by enableTLS(), and initListener().

serverKey

std::string HttpServer::serverKey

private

Definition at line 132 of file HttpServer.h.

Referenced by enableTLS(), and initListener().

tlsEnabled

bool HttpServer::tlsEnabled = false

private

Definition at line 130 of file HttpServer.h.

Referenced by enableTLS(), initListener(), isTLSEnabled(), and run().

xStack

StackType_t HttpServer::xStack

staticprivate

Definition at line 136 of file HttpServer.h.

Referenced by start().

xTaskBuffer

StaticTask_t HttpServer::xTaskBuffer

staticprivate

Definition at line 137 of file HttpServer.h.

Referenced by start().

---

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

• HttpServer.h
• HttpServer.cpp