308 lines
8.5 KiB
C++
308 lines
8.5 KiB
C++
/**
|
|
* @file tcpSockets.hpp
|
|
* @author Gustice
|
|
* @brief Function wrapper for ESP-IDF socket implementation
|
|
*
|
|
* @copyright Copyright (c) 2024
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "esp_log.h"
|
|
#include "etherCommon.hpp"
|
|
#include "utils.hpp"
|
|
#include <functional>
|
|
#include <iostream>
|
|
|
|
/**
|
|
* @brief TCP-Socket wrapper for ESP-IDF socket implementation
|
|
*/
|
|
class TcpSocket {
|
|
public:
|
|
/// @brief Constructor
|
|
/// @note Socket not active until call of attach method
|
|
/// @param addr Server/Client address
|
|
TcpSocket(const IpAdr &addr)
|
|
: Local(addr) {
|
|
_listenSockId = socket(addr.ProtocolFamily, SOCK_STREAM, addr.IpProtocol);
|
|
if (_listenSockId < 0) {
|
|
ESP_LOGE("TCP", "Unable to create socket: errno %d", errno);
|
|
throw CoreException("Unable to create socket");
|
|
}
|
|
|
|
if (addr.ProtocolFamily == IPPROTO_IP) {
|
|
int opt = 1;
|
|
setsockopt(_listenSockId, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
|
|
}
|
|
|
|
if constexpr (USE_IPV4 && USE_IPV6) {
|
|
int opt = 1;
|
|
// Note that by default IPV6 binds to both protocols, it is must be disabled
|
|
// if both protocols used at the same time (used in CI)
|
|
setsockopt(_listenSockId, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt));
|
|
}
|
|
|
|
ESP_LOGI("TCP", "Socket created");
|
|
}
|
|
|
|
/// @brief Destructor
|
|
~TcpSocket() {
|
|
close(_listenSockId);
|
|
}
|
|
|
|
/// @brief Attach to configured socket
|
|
/// @note Blocks until successful or failed
|
|
/// @return true if successful
|
|
bool bindTo() {
|
|
int err = bind(_listenSockId, Local.asSockAddrPtr(), sizeof(sockaddr_storage));
|
|
if (err != 0) {
|
|
ESP_LOGE("TCP", "Socket unable to bind: errno %d", errno);
|
|
ESP_LOGE("TCP", "IPPROTO: %d", Local.ProtocolFamily);
|
|
throw CoreException("Socket unable to bind");
|
|
}
|
|
ESP_LOGI("TCP", "Socket bound, port %d", Local.getPort());
|
|
|
|
err = listen(_listenSockId, 1);
|
|
if (err != 0) {
|
|
ESP_LOGE("TCP", "Error occurred during listen: errno %d", errno);
|
|
throw CoreException("Error occurred during listen");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// @brief Get socket id for stream-operations
|
|
/// @return Id of socket
|
|
int getSocketId() {
|
|
return _listenSockId;
|
|
}
|
|
|
|
/// @brief Address of this station (server perspective)
|
|
const IpAdr &Local;
|
|
|
|
private:
|
|
int _listenSockId;
|
|
};
|
|
|
|
/**
|
|
* @brief TCP session
|
|
*/
|
|
class TcpSession : public SocketBase, public CharStream {
|
|
public:
|
|
/**
|
|
* @brief Configuration structure for Session
|
|
*/
|
|
struct Config {
|
|
int keepAlive;
|
|
int keepIdle;
|
|
int keepInterval;
|
|
int keepCount;
|
|
};
|
|
|
|
/// @brief Constructor
|
|
/// @note Constructor blocks
|
|
/// @param config Configuration for session
|
|
/// @param listener reference to socket
|
|
TcpSession(Config &config, TcpSocket &listener) : _other(IPADDR_ANY, 0) {
|
|
socklen_t addr_len = _other.Size;
|
|
_socket = accept(listener.getSocketId(), _other.asSockAddrPtr(), &addr_len);
|
|
if (_socket < 0) {
|
|
ESP_LOGE("TCP", "Unable to accept connection: errno %d", errno);
|
|
active = false;
|
|
throw CoreException("Unable to accept connection");
|
|
}
|
|
|
|
// Set tcp keepalive option
|
|
setsockopt(_socket, SOL_SOCKET, SO_KEEPALIVE, &config.keepAlive, sizeof(int));
|
|
setsockopt(_socket, IPPROTO_TCP, TCP_KEEPIDLE, &config.keepIdle, sizeof(int));
|
|
setsockopt(_socket, IPPROTO_TCP, TCP_KEEPINTVL, &config.keepInterval, sizeof(int));
|
|
setsockopt(_socket, IPPROTO_TCP, TCP_KEEPCNT, &config.keepCount, sizeof(int));
|
|
|
|
std::string addrStr;
|
|
if (_other.ProtocolFamily == listener.Local.ProtocolFamily) {
|
|
if (_other.getProtocolFamily() == PF_INET) {
|
|
addrStr = _other.getIp();
|
|
// } else if (_other.addrStore.ss_family == PF_INET6) {
|
|
// inet6_ntoa_r(((struct sockaddr_in6 *)&_other.addrStore)->sin6_addr, addrStr, sizeof(addrStr) - 1);
|
|
} else {
|
|
throw CoreException("Unknown case");
|
|
}
|
|
} else {
|
|
ESP_LOGW("TCP", "Wrong IP-version request");
|
|
active = false;
|
|
}
|
|
|
|
ESP_LOGI("TCP", "Socket accepted ip address: %s", addrStr.c_str());
|
|
|
|
active = true;
|
|
}
|
|
|
|
/// @brief Destructor
|
|
~TcpSession() {
|
|
if (_socket < 0)
|
|
return;
|
|
|
|
ESP_LOGD("TCP", "Tearing down socket");
|
|
shutdown(_socket, 0);
|
|
}
|
|
|
|
/// @brief Get IP of remote
|
|
/// @return
|
|
IpAdr getSource() {
|
|
return _other;
|
|
}
|
|
|
|
/// @brief Read string
|
|
/// @note This call blocks until data is received
|
|
/// @return read string
|
|
std::string read() override {
|
|
auto data = readRaw();
|
|
if (data.size() == 0) {
|
|
return "";
|
|
}
|
|
|
|
std::string ret((const char *)&data.data()[0]);
|
|
return ret;
|
|
}
|
|
|
|
/// @brief Write character to socket
|
|
/// @param b character to write
|
|
void write(char c) override {
|
|
if (!isActive()) {
|
|
return;
|
|
}
|
|
|
|
int written = send(_socket, &c, 1, 0);
|
|
if (written < 0) {
|
|
ESP_LOGE("TCP", "Error occurred during sending: errno %d", errno);
|
|
}
|
|
}
|
|
|
|
/// @brief Write string to specific socket
|
|
/// @param message payload
|
|
/// @param dest Destination for message
|
|
void write(std::string message) override {
|
|
if (!isActive()) {
|
|
return;
|
|
}
|
|
|
|
int written = send(_socket, message.c_str(), message.size(), 0);
|
|
if (written < 0) {
|
|
ESP_LOGE("TCP", "Error occurred during sending: errno %d", errno);
|
|
}
|
|
}
|
|
|
|
IpAdr getOther() {
|
|
return _other;
|
|
}
|
|
|
|
protected:
|
|
int _socket = 0;
|
|
IpAdr _other;
|
|
|
|
std::vector<uint8_t> readRaw() {
|
|
uint8_t data[128];
|
|
int len = recv(_socket, data, sizeof(data) - 1, 0);
|
|
|
|
if (len < 0) {
|
|
ESP_LOGE("TCP", "Error occurred during receiving: errno %d", errno);
|
|
active = false;
|
|
return {};
|
|
}
|
|
|
|
data[len] = 0;
|
|
if (len == 0) {
|
|
ESP_LOGW("TCP", "Connection closed");
|
|
active = false;
|
|
return {};
|
|
}
|
|
|
|
ESP_LOGD("TCP", "Received %d bytes: %s", len, data);
|
|
std::vector<uint8_t> vec(data, data + len + 1);
|
|
return vec;
|
|
}
|
|
};
|
|
|
|
constexpr TcpSession::Config DefaultTcpConfig{
|
|
.keepAlive = 1,
|
|
.keepIdle = 5,
|
|
.keepInterval = 5,
|
|
.keepCount = 3,
|
|
};
|
|
|
|
constexpr uint16_t TelnetPort = 23;
|
|
|
|
/**
|
|
* @brief TCP-Socket for Telnet-Applications
|
|
*/
|
|
class TelnetServer {
|
|
|
|
/**
|
|
* @brief Specialization of TCP-Session for Telnet
|
|
*/
|
|
class TelnetSession : public TcpSession {
|
|
|
|
public:
|
|
// Constructor
|
|
TelnetSession(Config &config, TcpSocket &listener) : TcpSession(config, listener) {
|
|
}
|
|
|
|
/// @brief Read string
|
|
/// @note This call blocks until data is received
|
|
/// @return read string
|
|
std::string read() override {
|
|
auto data = readRaw();
|
|
if (data.size() == 0) {
|
|
return "";
|
|
}
|
|
|
|
data.pop_back(); // 0-termination is not needed here
|
|
|
|
int i = 0;
|
|
while (data[i] == 0xFF) { // while telnet command
|
|
i += 3; // skip this command
|
|
}
|
|
|
|
if (i == data.size()) { // only configuration
|
|
send(_socket, data.data(), data.size(), 0);
|
|
return "";
|
|
}
|
|
|
|
std::string ret((const char *)&data[i]);
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
public:
|
|
/// @brief Constructor
|
|
/// @param addrFamily IPV4 or IPV6
|
|
TelnetServer(int addrFamily)
|
|
: Local(addrFamily == AF_INET ? IpAdr(INADDR_ANY, TelnetPort) : IpAdr(TelnetPort)),
|
|
Config(DefaultTcpConfig) {
|
|
}
|
|
|
|
/**
|
|
* @brief Start server
|
|
*
|
|
* @param initCall Callback for shell init
|
|
* @param cyclicCall Callback for cyclic polling
|
|
*/
|
|
void run(std::function<void(TcpSession &)> initCall, std::function<void(TcpSession &)> cyclicCall) {
|
|
TcpSocket socket(Local);
|
|
socket.bindTo();
|
|
while (true) {
|
|
// Run telnet-session as long socket is active else restart socket
|
|
ESP_LOGI("Telnet", "Socket waiting for connect");
|
|
TelnetSession session(Config, socket);
|
|
|
|
initCall(session);
|
|
while (session.isActive()) {
|
|
cyclicCall(session);
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
IpAdr Local;
|
|
TcpSession::Config Config;
|
|
};
|