mirror of
https://github.com/sle118/squeezelite-esp32.git
synced 2025-12-11 05:57:05 +03:00
283 lines
9.2 KiB
C
283 lines
9.2 KiB
C
/**
|
|
* Test the telnet functions.
|
|
*
|
|
* Perform a test using the telnet functions.
|
|
* This code exports two new global functions:
|
|
*
|
|
* void telnet_listenForClients(void (*callback)(uint8_t *buffer, size_t size))
|
|
* void telnet_sendData(uint8_t *buffer, size_t size)
|
|
*
|
|
* For additional details and documentation see:
|
|
* * Free book on ESP32 - https://leanpub.com/kolban-ESP32
|
|
*
|
|
*
|
|
* Neil Kolban <kolban1@kolban.com>
|
|
*
|
|
* ****************************
|
|
* Additional portions were taken from
|
|
* https://github.com/PocketSprite/8bkc-sdk/blob/master/8bkc-components/8bkc-hal/vfs-stdout.c
|
|
*
|
|
*/
|
|
#include "telnet.h"
|
|
#include "Config.h"
|
|
#include "accessors.h"
|
|
#include "config.h"
|
|
#include "driver/uart.h"
|
|
#include "esp_app_trace.h"
|
|
#include "esp_attr.h"
|
|
#include "esp_vfs.h"
|
|
#include "esp_vfs_dev.h"
|
|
#include "freertos/ringbuf.h"
|
|
#include "libtelnet.h"
|
|
#include "messaging.h"
|
|
#include "platform_esp32.h"
|
|
#include "sdkconfig.h"
|
|
#include "soc/uart_struct.h"
|
|
#include "stdbool.h"
|
|
#include "tools.h"
|
|
#include <errno.h>
|
|
#include <esp_log.h>
|
|
#include <lwip/def.h>
|
|
#include <lwip/sockets.h>
|
|
#include <stdlib.h> // Required for libtelnet.h
|
|
#include <string.h>
|
|
/************************************
|
|
* Globals
|
|
*/
|
|
|
|
#define TELNET_STACK_SIZE 4096
|
|
#define TELNET_RX_BUF 1024
|
|
|
|
struct telnetUserData {
|
|
int sockfd;
|
|
telnet_t* tnHandle;
|
|
char* rxbuf;
|
|
};
|
|
|
|
const static char TAG[] = "telnet";
|
|
static int uart_fd;
|
|
static RingbufHandle_t buf_handle;
|
|
static size_t send_chunk = 512;
|
|
static size_t log_buf_size = 4 * 1024;
|
|
static bool bIsEnabled = false;
|
|
static int partnerSocket;
|
|
static telnet_t* tnHandle;
|
|
|
|
/************************************
|
|
* Forward declarations
|
|
*/
|
|
static void telnet_task(void* data);
|
|
static int stdout_open(const char* path, int flags, int mode);
|
|
static int stdout_fstat(int fd, struct stat* st);
|
|
static ssize_t stdout_write(int fd, const void* data, size_t size);
|
|
static void handle_telnet_conn();
|
|
static size_t process_logs(UBaseType_t bytes, bool make_room);
|
|
static sys_telnet_config* telnet_svc = NULL;
|
|
|
|
void init_telnet() {
|
|
if (!sys_services_config_TELNET(telnet_svc) || telnet_svc->enable == sys_telnet_output_SERIAL_ONLY) {
|
|
ESP_LOGI(TAG, "Telnet support disabled");
|
|
return;
|
|
}
|
|
ESP_LOGI(TAG, "Starting Telnet service");
|
|
ESP_LOGD(TAG, "Getting values from configuration");
|
|
if (telnet_svc->block > 0) send_chunk = telnet_svc->block;
|
|
if (telnet_svc->block > 0) log_buf_size = telnet_svc->buffer;
|
|
ESP_LOGD(TAG, "Allocating memory for the ring buffer and storage. send_chunk: %d, log_buf_size: %d", send_chunk, log_buf_size);
|
|
|
|
// Redirect the output to our telnet handler as soon as possible
|
|
StaticRingbuffer_t* buffer_struct = (StaticRingbuffer_t*)heap_caps_malloc(sizeof(StaticRingbuffer_t), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
|
// All non-split ring buffer must have their memory alignment set to 32 bits.
|
|
uint8_t* buffer_storage = (uint8_t*)heap_caps_malloc(sizeof(uint8_t) * log_buf_size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
|
buf_handle = xRingbufferCreateStatic(log_buf_size, RINGBUF_TYPE_BYTEBUF, buffer_storage, buffer_struct);
|
|
if (buf_handle == NULL || buffer_struct == NULL) {
|
|
ESP_LOGE(TAG, "Failed to create ring buffer for telnet!");
|
|
messaging_post_message(MESSAGING_ERROR, MESSAGING_CLASS_SYSTEM, "Failed to allocate memory for telnet buffer");
|
|
return;
|
|
}
|
|
|
|
if (telnet_svc->enable == sys_telnet_output_TELNET) {
|
|
ESP_LOGI(TAG, "***Redirecting log output to telnet");
|
|
} else {
|
|
ESP_LOGI(TAG, "Instantiating telnet service");
|
|
}
|
|
|
|
esp_vfs_t vfs = {};
|
|
vfs.flags = ESP_VFS_FLAG_DEFAULT;
|
|
vfs.write = &stdout_write;
|
|
vfs.open = &stdout_open;
|
|
vfs.fstat = &stdout_fstat;
|
|
|
|
if (telnet_svc->enable == sys_telnet_output_TELNET_SERIAL) uart_fd = open("/dev/uart/0", O_RDWR);
|
|
|
|
ESP_ERROR_CHECK(esp_vfs_register("/dev/pkspstdout", &vfs, NULL));
|
|
freopen("/dev/pkspstdout", "w", stdout);
|
|
freopen("/dev/pkspstdout", "w", stderr);
|
|
|
|
bIsEnabled = true;
|
|
}
|
|
|
|
void start_telnet(void* pvParameter) {
|
|
static bool isStarted = false;
|
|
|
|
if (isStarted || !bIsEnabled) return;
|
|
|
|
isStarted = true;
|
|
|
|
StaticTask_t* xTaskBuffer = (StaticTask_t*)heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
|
|
StackType_t* xStack = heap_caps_malloc(TELNET_STACK_SIZE, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
|
|
|
xTaskCreateStatic((TaskFunction_t)&telnet_task, "telnet", TELNET_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN, xStack, xTaskBuffer);
|
|
}
|
|
|
|
static void telnet_task(void* data) {
|
|
int serverSocket;
|
|
struct sockaddr_in serverAddr;
|
|
serverAddr.sin_family = AF_INET;
|
|
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
serverAddr.sin_port = htons(23);
|
|
|
|
while (1) {
|
|
serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
|
if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) >= 0 && listen(serverSocket, 1) >= 0) break;
|
|
close(serverSocket);
|
|
ESP_LOGI(TAG, "can't bind Telnet socket");
|
|
vTaskDelay(pdMS_TO_TICKS(1000));
|
|
}
|
|
|
|
while (1) {
|
|
socklen_t len = sizeof(serverAddr);
|
|
int sock = accept(serverSocket, (struct sockaddr*)&serverAddr, &len);
|
|
|
|
if (sock >= 0) {
|
|
partnerSocket = sock;
|
|
ESP_LOGI(TAG, "We have a new client connection %d", sock);
|
|
handle_telnet_conn();
|
|
ESP_LOGI(TAG, "Telnet connection terminated %d", sock);
|
|
} else {
|
|
ESP_LOGW(TAG, "accept: %d (%s)", errno, strerror(errno));
|
|
}
|
|
}
|
|
|
|
// we should not be here
|
|
close(serverSocket);
|
|
vTaskDelete(NULL);
|
|
}
|
|
|
|
/**
|
|
* Telnet handler.
|
|
*/
|
|
static void handle_telnet_events(telnet_t* thisTelnet, telnet_event_t* event, void* userData) {
|
|
struct telnetUserData* telnetUserData = (struct telnetUserData*)userData;
|
|
|
|
switch (event->type) {
|
|
case TELNET_EV_SEND:
|
|
send(telnetUserData->sockfd, event->data.buffer, event->data.size, 0);
|
|
break;
|
|
case TELNET_EV_DATA:
|
|
console_push(event->data.buffer, event->data.size);
|
|
break;
|
|
case TELNET_EV_TTYPE:
|
|
telnet_ttype_send(telnetUserData->tnHandle);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static size_t process_logs(UBaseType_t bytes, bool make_room) {
|
|
UBaseType_t pending;
|
|
|
|
vRingbufferGetInfo(buf_handle, NULL, NULL, NULL, NULL, &pending);
|
|
|
|
// nothing to do or we can do
|
|
if (!partnerSocket || (make_room && log_buf_size - pending > bytes)) return pending;
|
|
|
|
// can't send more than what we have
|
|
if (bytes > pending) bytes = pending;
|
|
|
|
while (bytes > 0) {
|
|
size_t size;
|
|
char* item = (char*)xRingbufferReceiveUpTo(buf_handle, &size, pdMS_TO_TICKS(50), bytes);
|
|
|
|
if (!item || !partnerSocket) break;
|
|
|
|
bytes -= size;
|
|
telnet_send_text(tnHandle, item, size);
|
|
|
|
vRingbufferReturnItem(buf_handle, (void*)item);
|
|
}
|
|
|
|
return pending - bytes;
|
|
}
|
|
|
|
static void handle_telnet_conn() {
|
|
static const telnet_telopt_t my_telopts[] = {{TELNET_TELOPT_ECHO, TELNET_WONT, TELNET_DO}, {TELNET_TELOPT_TTYPE, TELNET_WILL, TELNET_DONT},
|
|
{TELNET_TELOPT_COMPRESS2, TELNET_WONT, TELNET_DO}, {TELNET_TELOPT_ZMP, TELNET_WONT, TELNET_DO}, {TELNET_TELOPT_MSSP, TELNET_WONT, TELNET_DO},
|
|
{TELNET_TELOPT_BINARY, TELNET_WILL, TELNET_DO}, {TELNET_TELOPT_NAWS, TELNET_WILL, TELNET_DONT},
|
|
{TELNET_TELOPT_LINEMODE, TELNET_WONT, TELNET_DO}, {-1, 0, 0}};
|
|
struct telnetUserData* pTelnetUserData =
|
|
(struct telnetUserData*)heap_caps_malloc(sizeof(struct telnetUserData), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
|
tnHandle = telnet_init(my_telopts, handle_telnet_events, 0, pTelnetUserData);
|
|
|
|
pTelnetUserData->rxbuf = (char*)heap_caps_malloc(TELNET_RX_BUF, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
|
pTelnetUserData->tnHandle = tnHandle;
|
|
pTelnetUserData->sockfd = partnerSocket;
|
|
|
|
bool pending = true;
|
|
|
|
while (1) {
|
|
fd_set rfds, wfds;
|
|
struct timeval timeout = {0, 200 * 1000};
|
|
|
|
FD_ZERO(&rfds);
|
|
FD_SET(partnerSocket, &rfds);
|
|
|
|
FD_ZERO(&wfds);
|
|
if (pending) FD_SET(partnerSocket, &wfds);
|
|
|
|
int res = select(partnerSocket + 1, &rfds, &wfds, NULL, &timeout);
|
|
if (res < 0) break;
|
|
|
|
if (FD_ISSET(partnerSocket, &rfds)) {
|
|
int len = recv(partnerSocket, pTelnetUserData->rxbuf, TELNET_RX_BUF, 0);
|
|
if (!len) break;
|
|
telnet_recv(tnHandle, pTelnetUserData->rxbuf, len);
|
|
}
|
|
|
|
if (FD_ISSET(partnerSocket, &wfds)) {
|
|
pending = process_logs(send_chunk, false) > 0;
|
|
} else {
|
|
pending = true;
|
|
}
|
|
}
|
|
|
|
telnet_free(tnHandle);
|
|
tnHandle = NULL;
|
|
|
|
free(pTelnetUserData->rxbuf);
|
|
free(pTelnetUserData);
|
|
|
|
close(partnerSocket);
|
|
partnerSocket = 0;
|
|
}
|
|
|
|
// ******************* stdout/stderr Redirection to ringbuffer
|
|
static ssize_t stdout_write(int fd, const void* data, size_t size) {
|
|
// flush the buffer and send item
|
|
if (buf_handle) {
|
|
process_logs(size, true);
|
|
xRingbufferSend(buf_handle, data, size, 0);
|
|
}
|
|
|
|
// mirror to uart if required
|
|
return (telnet_svc->enable == sys_telnet_output_TELNET_SERIAL || !buf_handle) ? write(uart_fd, data, size) : size;
|
|
}
|
|
|
|
static int stdout_open(const char* path, int flags, int mode) { return 0; }
|
|
|
|
static int stdout_fstat(int fd, struct stat* st) {
|
|
st->st_mode = S_IFCHR;
|
|
return 0;
|
|
}
|