Tcp Class Reference

General-purpose TCP socket wrapper with optional TLS support via mbedTLS (altcp). More...

#include <Tcp.h>

Collaboration diagram for Tcp:

Public Member Functions
	Tcp ()
	Tcp (int sockfd)
	For accepted sockets.
	~Tcp ()
	Tcp (const Tcp &)=delete
Tcp &	operator= (const Tcp &)=delete
	Tcp (Tcp &&other) noexcept
Tcp &	operator= (Tcp &&other) noexcept
std::string	getPeerIp () const
void	setRootCACertificate (const std::string &pem)
	Set the Root CA certificate to be used for client TLS connections (PEM format).
void	setServerTlsConfig (const std::string &certPem, const std::string &keyPem)
	Set the certificate and key to use for server-side TLS (PEM format).
bool	connect (const char *host, int port, bool useTls=false)
	Connect to a remote host.
int	send (const char *buffer, size_t size)
	Send data over the connection.
int	recv (char *buffer, size_t size, uint32_t timeout_ms)
	Receive data from the connection.
int	close ()
	Close the connection and free resources.
bool	bindAndListen (int port)
	Bind and listen on a port for incoming connections (for server use).
bool	bindAndListenPlain (int port)
bool	bindAndListenTls (int port)
Tcp *	accept ()
	Accept a new incoming connection (for server use).
bool	isValid () const
	Check if the socket is valid.
bool	isConnected () const
	Check if the socket is connected.
int	getSocketFd () const
	Get the raw socket file descriptor (may be -1 for TLS-only connection).
void	setHostname (const char *name)
const char *	getHostname () const

Private Member Functions
bool	connectPlain (const ip_addr_t &ip, int port)
bool	connectTls (const ip_addr_t &ip, int port)

Static Private Member Functions
static err_t	tlsRecvCallback (void *arg, struct altcp_pcb *conn, struct pbuf *p, err_t err)
static err_t	acceptCallback (void *arg, struct altcp_pcb *new_conn, err_t err)

Private Attributes
int	sockfd = -1
bool	connected = false
bool	use_tls = false
bool	is_server_socket = false
int	connectResult = ERR_OK
std::string	root_ca_cert
struct pbuf *	recv_buffer = nullptr
	Buffer for TLS receive.
size_t	recv_offset = 0
std::string	server_tls_cert
std::string	server_tls_key
struct altcp_tls_config *	server_tls_config = nullptr
TaskHandle_t	connectingTask = nullptr
	Task handle for async operations.
TaskHandle_t	waiting_task = nullptr
	Task handle for async operations.
altcp_pcb *	pending_client = nullptr
	For TLS: set by acceptCallback.
char	hostname [64] = {0}
	Hostname for TLS connections.

Static Private Attributes
static constexpr size_t	MAX_TLS_SEGMENT_SIZE = 1460

Detailed Description

Definition at line 39 of file Tcp.h.

Constructor & Destructor Documentation

Tcp() [1/4]

Tcp::Tcp

(

)

Definition at line 24 of file Tcp.cpp.

    : sockfd(-1), connected(false), use_tls(false)
#if PICO_TCP_ENABLE_TLS
      ,
      tls_config(nullptr), server_tls_config(nullptr),
      tls_pcb(nullptr)
#endif
{
}

Referenced by accept().

Here is the caller graph for this function:

Tcp() [2/4]

Tcp::Tcp ( int  sockfd )

explicit

Definition at line 34 of file Tcp.cpp.

    : sockfd(fd), connected(true), use_tls(false)
#if PICO_TCP_ENABLE_TLS
      ,
      tls_config(nullptr), server_tls_config(nullptr),
      tls_pcb(nullptr)
#endif
{
}

~Tcp()

Tcp::~Tcp

(

)

Definition at line 44 of file Tcp.cpp.

{
    close();
}

References close().

Here is the call graph for this function:

Tcp() [3/4]

Tcp::Tcp ( const Tcp &  )

delete

Tcp() [4/4]

Tcp::Tcp ( Tcp &&  other )

noexcept

Definition at line 49 of file Tcp.cpp.

{
    *this = std::move(other);
}

Member Function Documentation

accept()

Tcp * Tcp::accept

(

)

Returns

Tcp for the accepted client.

Definition at line 491 of file Tcp.cpp.

{
    if (use_tls)
    {
        #if PICO_TCP_ENABLE_TLS
        pending_client = nullptr;
        waiting_task = xTaskGetCurrentTaskHandle();
        ulTaskNotifyTakeIndexed(NotifyAccept, pdTRUE, portMAX_DELAY);
        waiting_task = nullptr;
 
        if (pending_client)
        {
            Tcp *client = new Tcp();
            client->tls_pcb = pending_client;
            client->use_tls = true;
            client->connected = true;
            pending_client = nullptr;
            return client;
        }
        return nullptr;
        #else
        printf("[Tcp] TLS not enabled in this build\n");
        return nullptr;
        #endif
    }
 
    // For plain TCP, use lwIP accept directly
    struct sockaddr_in client_addr{};
    socklen_t addr_len = sizeof(client_addr);
 
    int client_fd = lwip_accept(sockfd, reinterpret_cast<struct sockaddr *>(&client_addr), &addr_len);
    TRACE("[Tcp] Accept returned new socket: %d\n", client_fd);
 
    if (client_fd >= 0)
    {
        // Set receive timeout
        struct timeval recv_timeout = {.tv_sec = 0, .tv_usec = 100000};
        lwip_setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, &recv_timeout, sizeof(recv_timeout));
 
        // Optional: Force-close on disconnect (RST on close)
        struct linger so_linger = {.l_onoff = 1, .l_linger = 0};
        lwip_setsockopt(client_fd, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger));
 
        Tcp *client = new Tcp(client_fd);
        return client;
    }
 
    printf("[Tcp] Accept timeout, no client.\n");
    return nullptr;
}

References connected, NotifyAccept, pending_client, sockfd, Tcp(), TRACE, use_tls, and waiting_task.

Referenced by HttpServer::run().

Here is the call graph for this function:

Here is the caller graph for this function:

acceptCallback()

err_t Tcp::acceptCallback ( void *  arg, struct altcp_pcb *  new_conn, err_t  err  )

staticprivate

Definition at line 471 of file Tcp.cpp.

{
    auto *self = static_cast<Tcp *>(arg);
 
    if (err != ERR_OK || !new_conn || !self)
    {
        return ERR_VAL;
    }
 
    self->pending_client = new_conn;
 
    if (self->waiting_task)
    {
        xTaskNotifyGiveIndexed(self->waiting_task, NotifyAccept); // Notify waiting task
        self->waiting_task = nullptr;
    }
 
    return ERR_OK;
}

References NotifyAccept, and pending_client.

bindAndListen()

bool Tcp::bindAndListen

(

int

port

)

Definition at line 542 of file Tcp.cpp.

{
    #if PICO_TCP_ENABLE_TLS
    return server_tls_config ? bindAndListenTls(port) : bindAndListenPlain(port);
    #else
    return bindAndListenPlain(port);
    #endif
}

References bindAndListenPlain(), bindAndListenTls(), and server_tls_config.

Referenced by HttpServer::initListener().

Here is the call graph for this function:

Here is the caller graph for this function:

bindAndListenPlain()

bool Tcp::bindAndListenPlain

(

int

port

)

Definition at line 552 of file Tcp.cpp.

{
    sockfd = lwip_socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        printf("[Tcp] Failed to create socket\n");
        return false;
    }
 
    int opt = 1;
    int flags = fcntl(sockfd, F_GETFL, 0);
    fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
 
    struct sockaddr_in addr = {};
    addr.sin_family = AF_INET;
    addr.sin_port = lwip_htons(port);
    addr.sin_addr.s_addr = PP_HTONL(INADDR_ANY);
 
    if (lwip_bind(sockfd, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) < 0)
    {
        printf("[Tcp] Failed to bind socket\n");
        lwip_close(sockfd);
        sockfd = -1;
        return false;
    }
 
    if (lwip_listen(sockfd, 10) < 0)
    {
        printf("[Tcp] Failed to listen on socket\n");
        lwip_close(sockfd);
        sockfd = -1;
        return false;
    }
 
    TRACE("[Tcp] Listening on port: %d, (socket: %d)\n", port, sockfd);
 
    use_tls = false;
    connected = true;
    return true;
}

References connected, sockfd, TRACE, and use_tls.

Referenced by bindAndListen().

Here is the caller graph for this function:

bindAndListenTls()

bool Tcp::bindAndListenTls

(

int

port

)

Referenced by bindAndListen().

Here is the caller graph for this function:

close()

int Tcp::close

(

)

Definition at line 443 of file Tcp.cpp.

{
    int result = 0;
    #if PICO_TCP_ENABLE_TLS
    if (use_tls && tls_pcb)
    {
        altcp_close(tls_pcb);
        tls_pcb = nullptr;
    }
    else 
    #endif
    if (sockfd >= 0)
    {
        result = lwip_close(sockfd);
        sockfd = -1;
    }
    recv_offset = 0;
    waiting_task = nullptr;
    if (recv_buffer)
    {
        pbuf_free(recv_buffer);
        recv_buffer = nullptr;
    }
 
    connected = false;
    return result;
}

References connected, recv_buffer, recv_offset, sockfd, use_tls, and waiting_task.

Referenced by HttpServer::handleClient(), HttpServer::startHandlingClient(), and ~Tcp().

Here is the caller graph for this function:

connect()

bool Tcp::connect	(	const char *	host,
		int	port,
		bool	useTls = false
	)

Parameters

host	Hostname or IP address.
port	Port number.

Returns

true on success, false on failure.

Definition at line 116 of file Tcp.cpp.

{
    strncpy(hostname, host, sizeof(hostname) - 1);
    this->use_tls = use_tls;
    ip_addr_t ip;
    if (!resolveHostnameBlocking(host, &ip))
    {
        printf("[Tcp] DNS resolution failed for %s\n", host);
        return false;
    }
#if PICO_TCP_ENABLE_TLS
    return use_tls ? connectTls(ip, port) : connectPlain(ip, port);
#else
    return connectPlain(ip, port);
#endif
}

References connectPlain(), connectTls(), hostname, resolveHostnameBlocking(), and use_tls.

Here is the call graph for this function:

connectPlain()

bool Tcp::connectPlain ( const ip_addr_t &  ip, int  port  )

private

Definition at line 133 of file Tcp.cpp.

{
    struct sockaddr_in addr = {};
    addr.sin_family = AF_INET;
    addr.sin_port = lwip_htons(port);
    addr.sin_addr.s_addr = ip.addr;
 
    sockfd = lwip_socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        printf("[Tcp] Failed to create socket\n");
        return false;
    }
 
    if (lwip_connect(sockfd, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) < 0)
    {
        printf("[Tcp] Failed to connect to server\n");
        lwip_close(sockfd);
        sockfd = -1;
        return false;
    }
    TRACE("[Tcp] Connected to server (plain)\n");
    connected = true;
    use_tls = false;
    return true;
}

References connected, sockfd, TRACE, and use_tls.

Referenced by connect().

Here is the caller graph for this function:

connectTls()

bool Tcp::connectTls ( const ip_addr_t &  ip, int  port  )

private

Referenced by connect().

Here is the caller graph for this function:

getHostname()

const char * Tcp::getHostname ( ) const

inline

Definition at line 132 of file Tcp.h.

{ return hostname; }

References hostname.

getPeerIp()

std::string Tcp::getPeerIp

(

)

const

Definition at line 79 of file Tcp.cpp.

{
    sockaddr_in addr;
    socklen_t len = sizeof(addr);
    if (lwip_getpeername(sockfd, reinterpret_cast<sockaddr *>(&addr), &len) == 0)
    {
        ip_addr_t ip;
        ip.addr = addr.sin_addr.s_addr;
        return std::string(ipaddr_ntoa(&ip));
    }
    return "0.0.0.0";
}

References sockfd.

getSocketFd()

int Tcp::getSocketFd ( ) const

inline

Definition at line 124 of file Tcp.h.

{ return sockfd; }

References sockfd.

Referenced by getClientIpFromTcp(), HttpResponse::getSocket(), and HttpRequest::receive().

Here is the caller graph for this function:

isConnected()

bool Tcp::isConnected ( ) const

inline

Definition at line 119 of file Tcp.h.

{ return connected; }

References connected.

Referenced by MultipartParser::sendHttpResponse().

Here is the caller graph for this function:

isValid()

bool Tcp::isValid ( ) const

inline

Definition at line 113 of file Tcp.h.

{ return sockfd >= 0; }

References sockfd.

operator=() [1/2]

Tcp & Tcp::operator= ( const Tcp &  )

delete

operator=() [2/2]

Tcp & Tcp::operator= ( Tcp &&  other )

noexcept

Definition at line 54 of file Tcp.cpp.

{
    if (this != &other)
    {
        sockfd = other.sockfd;
    #if PICO_TCP_ENABLE_TLS
        tls_pcb = other.tls_pcb;
        tls_config = other.tls_config;
        server_tls_config = other.server_tls_config;
    #endif
        connected = other.connected;
        use_tls = other.use_tls;
        recv_buffer = other.recv_buffer;
 
        other.sockfd = -1;
    #if PICO_TCP_ENABLE_TLS
        other.tls_pcb = nullptr;
        other.tls_config = nullptr;
        other.server_tls_config = nullptr;
    #endif    
        other.recv_buffer = nullptr;
    }
    return *this;
}

References sockfd.

recv()

int Tcp::recv	(	char *	buffer,
		size_t	size,
		uint32_t	timeout_ms
	)

Definition at line 389 of file Tcp.cpp.

{
    if (!use_tls)
    {
        TRACE("Plain recv: %zu bytes\n", size);
        int received = lwip_recv(sockfd, buffer, size, 0);
        if (received < 0)
        {
            TRACE("Plain recv error: %d, %s\n", errno, strerror(errno));
            return received;
        }
        return received;
    }
 
#if PICO_TCP_ENABLE_TLS
    if (!tls_pcb || !buffer || size == 0)
    {
        return -1;
    }
 
    // If no data available yet, block and wait for notify
    if (!recv_buffer)
    {
        waiting_task = xTaskGetCurrentTaskHandle();
        BaseType_t result = ulTaskNotifyTakeIndexed(NotifyRecv, pdTRUE, pdMS_TO_TICKS(timeout_ms));
        if (result == 0 || !recv_buffer)
            return 0; // timeout or nothing delivered
    }
 
    if (!recv_buffer)
    {
        return 0; // Nothing was delivered even after wakeup
    }
 
    // Copy as much as we can from the pbuf to the buffer
    size_t available = recv_buffer->tot_len - recv_offset;
    size_t to_copy = (size < available) ? size : available;
    pbuf_copy_partial(recv_buffer, buffer, to_copy, recv_offset);
    recv_offset += to_copy;
 
    // If we've consumed the full pbuf, release it
    if (recv_offset >= recv_buffer->tot_len)
    {
        pbuf_free(recv_buffer);
        recv_buffer = nullptr;
        recv_offset = 0;
    }
    return static_cast<int>(to_copy);
#else
    printf("[Tcp] TLS not enabled in this build\n");
    return -1;
#endif
}

References NotifyRecv, recv_buffer, recv_offset, sockfd, TRACE, use_tls, and waiting_task.

Referenced by HttpRequest::appendRemainingBody(), MultipartParser::handleMultipart(), HttpParser::receiveChunkedBodyToFile(), HttpParser::receiveChunkedBodyToString(), HttpParser::receiveFixedLengthBodyToFile(), HttpParser::receiveFixedLengthBodyToString(), HttpParser::receiveHeaderAndLeftover(), HttpParser::receiveUnknownLengthBodyToString(), and HttpRequest::receiveUntilHeadersComplete().

Here is the caller graph for this function:

send()

int Tcp::send	(	const char *	buffer,
		size_t	size
	)

Definition at line 279 of file Tcp.cpp.

{
    TRACE("[Tcp] Sending %zu bytes\n", size);
    #if PICO_TCP_ENABLE_TLS
    if ((!buffer && size > 0) || !connected || (use_tls && !tls_pcb))
#else
    if ((!buffer && size > 0) || !connected)
#endif
    {
        printf("[Tcp] Invalid buffer, size, or connection\n");
        return -1;
    }
 
    constexpr size_t chunkSize = HTTP_BUFFER_SIZE;
    size_t totalSent = 0;
 
    // absolute_time_t startTime = get_absolute_time(); // <-- your timing starts here
 
    while (totalSent < size)
    {
        size_t toSend = (size - totalSent > chunkSize) ? chunkSize : (size - totalSent);
    #if PICO_TCP_ENABLE_TLS
        if (use_tls && tls_pcb)
        {
 
            if (tls_pcb->state == nullptr)
            {
                printf("[Tcp] TLS connection is not established\n");
                return -1;
            }
 
            err_t err = altcp_write(tls_pcb, buffer + totalSent, toSend, TCP_WRITE_FLAG_COPY);
            if (err != ERR_OK)
            {
                printf("[Tcp] altcp_write failed: %d\n", err);
                return -1;
            }
            if (altcp_output(tls_pcb) != ERR_OK)
            {
                printf("[Tcp] altcp_output failed\n");
                return -1;
            }
        }
 
        else
    #endif        
        if (sockfd >= 0)
        {
            int ret = lwip_send(sockfd, buffer + totalSent, toSend, 0);
            if (ret <= 0)
            {
                warning("[Tcp] lwip_send failed: ", ret);
                return -1;
            }
        }
        else
        {
            printf("[Tcp] No valid socket or TLS connection\n");
            return -1;
        }
 
        vTaskDelay(pdMS_TO_TICKS(STREAM_SEND_DELAY_MS)); // Throttle per chunk
        totalSent += toSend;
    }
 
    // After sending ALL chunks: yield and delay for TCP flush
    taskYIELD();
    vTaskDelay(pdMS_TO_TICKS(20)); // Give lwIP time to transmit the data
 
    return static_cast<int>(size); // Report success
}

References connected, HTTP_BUFFER_SIZE, sockfd, STREAM_SEND_DELAY_MS, TRACE, use_tls, and warning().

Referenced by HttpResponse::send(), HttpResponse::sendHeaders(), MultipartParser::sendHttpResponse(), HttpResponse::start(), and HttpResponse::writeChunk().

Here is the call graph for this function:

Here is the caller graph for this function:

setHostname()

void Tcp::setHostname ( const char *  name )

inline

Definition at line 126 of file Tcp.h.

                                       {
        if (name) {
            strncpy(hostname, name, sizeof(hostname) - 1);
            hostname[sizeof(hostname) - 1] = '\0';
        }
    }

References hostname.

setRootCACertificate()

void Tcp::setRootCACertificate

(

const std::string &

pem

)

setServerTlsConfig()

void Tcp::setServerTlsConfig	(	const std::string &	certPem,
		const std::string &	keyPem
	)

tlsRecvCallback()

err_t Tcp::tlsRecvCallback ( void *  arg, struct altcp_pcb *  conn, struct pbuf *  p, err_t  err  )

staticprivate

Definition at line 351 of file Tcp.cpp.

{
    auto *self = static_cast<Tcp *>(arg);
    if (!self)
        return ERR_VAL;
 
    if (!p)
    {
        // Remote closed connection
        if (self->recv_buffer)
        {
            pbuf_free(self->recv_buffer);
            self->recv_buffer = nullptr;
        }
        self->recv_offset = 0;
        return ERR_OK;
    }
 
    // Drop if already have a pbuf (single-buffer policy for now)
    if (self->recv_buffer)
    {
        pbuf_free(p); // Drop additional pbuf to prevent overflow
        return ERR_OK;
    }
 
    self->recv_buffer = p;
    self->recv_offset = 0;
 
    // Notify any task waiting in recv()
    if (self->waiting_task)
    {
        xTaskNotifyGiveIndexed(self->waiting_task, NotifyRecv);
        self->waiting_task = nullptr;
    }
 
    return ERR_OK;
}

References NotifyRecv.

Member Data Documentation

connected

bool Tcp::connected = false

private

Definition at line 143 of file Tcp.h.

Referenced by accept(), bindAndListenPlain(), close(), connectPlain(), isConnected(), and send().

connectingTask

TaskHandle_t Tcp::connectingTask = nullptr

private

Definition at line 166 of file Tcp.h.

connectResult

int Tcp::connectResult = ERR_OK

private

Definition at line 146 of file Tcp.h.

hostname

char Tcp::hostname[64] = {0}

private

Definition at line 170 of file Tcp.h.

{0}; 

Referenced by connect(), getHostname(), and setHostname().

is_server_socket

bool Tcp::is_server_socket = false

private

Definition at line 145 of file Tcp.h.

MAX_TLS_SEGMENT_SIZE

constexpr size_t Tcp::MAX_TLS_SEGMENT_SIZE = 1460

staticconstexprprivate

Definition at line 164 of file Tcp.h.

pending_client

altcp_pcb* Tcp::pending_client = nullptr

private

Definition at line 168 of file Tcp.h.

Referenced by accept(), and acceptCallback().

recv_buffer

struct pbuf* Tcp::recv_buffer = nullptr

private

Definition at line 155 of file Tcp.h.

Referenced by close(), and recv().

recv_offset

size_t Tcp::recv_offset = 0

private

Definition at line 156 of file Tcp.h.

Referenced by close(), and recv().

root_ca_cert

std::string Tcp::root_ca_cert

private

Definition at line 148 of file Tcp.h.

server_tls_cert

std::string Tcp::server_tls_cert

private

Definition at line 159 of file Tcp.h.

server_tls_config

struct altcp_tls_config* Tcp::server_tls_config = nullptr

private

Definition at line 161 of file Tcp.h.

Referenced by bindAndListen().

server_tls_key

std::string Tcp::server_tls_key

private

Definition at line 160 of file Tcp.h.

sockfd

int Tcp::sockfd = -1

private

Definition at line 142 of file Tcp.h.

Referenced by accept(), bindAndListenPlain(), close(), connectPlain(), getPeerIp(), getSocketFd(), isValid(), operator=(), recv(), and send().

use_tls

bool Tcp::use_tls = false

private

Definition at line 144 of file Tcp.h.

Referenced by accept(), bindAndListenPlain(), close(), connect(), connectPlain(), recv(), and send().

waiting_task

TaskHandle_t Tcp::waiting_task = nullptr

private

Definition at line 167 of file Tcp.h.

Referenced by accept(), close(), and recv().

---

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

• Tcp.h
• Tcp.cpp