Tcp.h

Go to the documentation of this file.

 
#pragma once
#include <FreeRTOS.h>
#include <queue.h>
#include <string>
#include <vector>
#include <cstdint>
#include <lwip/ip_addr.h>
#include <lwip/sockets.h>
#if PICO_TCP_ENABLE_TLS
#include <lwip/altcp.h>
#include <lwip/altcp_tls.h>
#endif
 
 
enum class SocketEvent : uint8_t {
    Connect = 0,
    Recv    = 1,
    Sent    = 2,
    Error   = 3
};
 
enum NotifyIndex {
    NotifyRecv = 0,
    NotifyAccept = 1,
    NotifyConnect = 2,
};
 
class Tcp {
public:
    Tcp();
    explicit Tcp(int sockfd); 
    ~Tcp();
 
    // Disable copy
    Tcp(const Tcp&) = delete;
    Tcp& operator=(const Tcp&) = delete;
 
    // Enable move
    Tcp(Tcp&& other) noexcept;
    Tcp& operator=(Tcp&& other) noexcept;
 
    // Accessors
    std::string getPeerIp() const;
 
    void setRootCACertificate(const std::string& pem);
 
    void setServerTlsConfig(const std::string& certPem, const std::string& keyPem);
 
    bool connect(const char* host, int port, bool useTls = false);
    #if PICO_TCP_ENABLE_TLS
    bool connectTls(const char* host, int port);
    static err_t onConnected(void* arg, struct altcp_pcb* conn, err_t err);
    static void onError(void* arg, err_t err);
    #endif
 
    int send(const char* buffer, size_t size);
 
    int recv(char *buffer, size_t size, uint32_t timeout_ms);
 
    int close();
 
    bool bindAndListen(int port);
    bool bindAndListenPlain(int port);
    bool bindAndListenTls(int port);
 
    Tcp* accept();
 
    #if PICO_TCP_ENABLE_TLS
    bool isValid() const { return sockfd >= 0 || tls_pcb != nullptr; }
    #else
    bool isValid() const { return sockfd >= 0; }
    #endif
    
    bool isConnected() const { return connected; }
 
    int getSocketFd() const { return sockfd; }
 
    void setHostname(const char* name) {
        if (name) {
            strncpy(hostname, name, sizeof(hostname) - 1);
            hostname[sizeof(hostname) - 1] = '\0';
        }
    }
    const char* getHostname() const { return hostname; }
 
private:
    // Internal helpers
    bool connectPlain(const ip_addr_t& ip, int port);
    bool connectTls(const ip_addr_t& ip, int port);
 
    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);
 
    int sockfd = -1;
    bool connected = false;
    bool use_tls = false;
    bool is_server_socket = false;
    int connectResult = ERR_OK;
 
    std::string root_ca_cert;
 
    #if PICO_TCP_ENABLE_TLS
    // TLS state (client)
    struct altcp_tls_config* tls_config = nullptr;
    struct altcp_pcb* tls_pcb = nullptr;
    #endif
    struct pbuf* recv_buffer = nullptr; 
    size_t recv_offset = 0;
 
    // TLS server config
    std::string server_tls_cert;
    std::string server_tls_key;
    struct altcp_tls_config* server_tls_config = nullptr;
 
    // buffering receive pbufs using callabck and queue
    static constexpr size_t MAX_TLS_SEGMENT_SIZE = 1460; // Typical MSS size
 
    TaskHandle_t connectingTask = nullptr; 
    TaskHandle_t waiting_task = nullptr; 
    altcp_pcb* pending_client = nullptr; 
 
    char hostname[64] = {0}; 
 
};