Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-10 21:47:04 +03:00
Code Issues Packages Projects Releases Wiki Activity

refactoring, improvements and bug fixes for telnet

Browse Source
This commit is contained in:
Sebastien
2020-02-12 17:52:45 -05:00
parent 6b9a1420bf
commit 1af1fd1639
2 changed files with 178 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

380
components/telnet/telnet.c
View File

@@ -40,127 +40,46 @@
#include "platform_esp32.h" #include "platform_esp32.h"
#define TELNET_STACK_SIZE 8048 /************************************
* Globals
*/
#define TELNET_STACK_SIZE 8048
#define TELNET_RX_BUF 1024
const static char tag[] = "telnet";
static int uart_fd=0;
RingbufHandle_t buf_handle; RingbufHandle_t buf_handle;
SemaphoreHandle_t xSemaphore = NULL; SemaphoreHandle_t xSemaphore = NULL;
static size_t send_chunk=300; static size_t send_chunk=300;
static size_t log_buf_size=2000; //32-bit aligned size static size_t log_buf_size=2000; //32-bit aligned size
static bool bIsEnabled=false; static bool bIsEnabled=false;
const static char tag[] = "telnet"; static int partnerSocket=0;
int _log_vprintf(const char *fmt, va_list args);
void telnet_esp32_listenForClients();
int telnet_esp32_vprintf(const char *fmt, va_list va);
static void telnetTask(void *data);
static int uart_fd=0;
// The global tnHandle ... since we are only processing ONE telnet
// client at a time, this can be a global static.
static telnet_t *tnHandle; static telnet_t *tnHandle;
static void handleLogBuffer(int partnerSocket, UBaseType_t bytes);
/************************************
* Forward declarations
*/
static void telnet_task(void *data);
static ssize_t stdout_read(int fd, void* data, size_t size);
static int stdout_open(const char * path, int flags, int mode);
static int stdout_close(int fd);
static int stdout_fstat(int fd, struct stat * st);
static ssize_t stdout_write(int fd, const void * data, size_t size);
static char *eventToString(telnet_event_type_t type);
static void handle_telnet_conn();
static void process_logs( UBaseType_t bytes);
struct telnetUserData { struct telnetUserData {
int sockfd; int sockfd;
telnet_t *tnHandle;
char * rxbuf;
}; };
static void telnetTask(void *data) {
ESP_LOGD(tag, ">> telnetTask");
telnet_esp32_listenForClients();
ESP_LOGD(tag, "<< telnetTask");
vTaskDelete(NULL);
}
void start_telnet(void * pvParameter){
static bool isStarted=false;
StaticTask_t *xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
StackType_t *xStack = malloc(TELNET_STACK_SIZE);
if(!isStarted && bIsEnabled) {
xTaskCreateStatic( (TaskFunction_t) &telnetTask, "telnet", TELNET_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, xTaskBuffer);
isStarted=true;
}
}
static ssize_t stdout_write(int fd, const void * data, size_t size) {
if (xSemaphoreTake(xSemaphore, (TickType_t) 10) == pdTRUE) {
// #1 Write to ringbuffer
if (buf_handle == NULL) {
printf("%s() ABORT. file handle _log_remote_fp is NULL\n",
__FUNCTION__);
} else {
//Send an item
UBaseType_t res = xRingbufferSend(buf_handle, data, size,
pdMS_TO_TICKS(100));
if (res != pdTRUE) {
// flush some entries
handleLogBuffer(0, size);
res = xRingbufferSend(buf_handle, data, size,
pdMS_TO_TICKS(100));
if (res != pdTRUE) {
printf("%s() ABORT. Unable to store log entry in buffer\n",
__FUNCTION__);
}
}
}
xSemaphoreGive(xSemaphore);
} else {
// We could not obtain the semaphore and can therefore not access
// the shared resource safely.
}
return write(uart_fd, data, size);
}
static ssize_t stdout_read(int fd, void* data, size_t size) {
return read(fd, data, size);
}
static int stdout_open(const char * path, int flags, int mode) {
return 0;
}
static int stdout_close(int fd) {
return 0;
}
static int stdout_fstat(int fd, struct stat * st) {
st->st_mode = S_IFCHR;
return 0;
}
void kchal_stdout_register() {
const esp_vfs_t vfs = {
.flags = ESP_VFS_FLAG_DEFAULT,
.write = &stdout_write,
.open = &stdout_open,
.fstat = &stdout_fstat,
.close = &stdout_close,
.read = &stdout_read,
};
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);
//printf("8bkc_hal_stdout_register: Custom stdout/stderr handler installed.\n");
}
/*********************************
* Telnet Support
*/
void init_telnet(){ void init_telnet(){
char *val= get_nvs_value_alloc(NVS_TYPE_STR, "telnet_enable"); char *val= get_nvs_value_alloc(NVS_TYPE_STR, "telnet_enable");
if (!val || strlen(val) == 0 || !strcasestr("YX",val) ) {
if (!val || !strcasestr("YX",val) ) {
ESP_LOGI(tag,"Telnet support disabled"); ESP_LOGI(tag,"Telnet support disabled");
if(val) free(val); if(val) free(val);
return; return;
@@ -177,28 +96,79 @@ void init_telnet(){
free(val); free(val);
log_buf_size=log_buf_size>0?log_buf_size:4000; log_buf_size=log_buf_size>0?log_buf_size:4000;
} }
bIsEnabled=true;
// Create the semaphore to guard a shared resource. // Create the semaphore to guard a shared resource.
vSemaphoreCreateBinary( xSemaphore ); vSemaphoreCreateBinary( xSemaphore );
// First thing we need to do here is to redirect the output to our telnet handler // Redirect the output to our telnet handler as soon as possible
//Allocate ring buffer data structure and storage area into external RAM
StaticRingbuffer_t *buffer_struct = (StaticRingbuffer_t *)heap_caps_malloc(sizeof(StaticRingbuffer_t), MALLOC_CAP_SPIRAM); StaticRingbuffer_t *buffer_struct = (StaticRingbuffer_t *)heap_caps_malloc(sizeof(StaticRingbuffer_t), MALLOC_CAP_SPIRAM);
uint8_t *buffer_storage = (uint8_t *)heap_caps_malloc(sizeof(uint8_t)*log_buf_size, MALLOC_CAP_SPIRAM); uint8_t *buffer_storage = (uint8_t *)heap_caps_malloc(sizeof(uint8_t)*log_buf_size, MALLOC_CAP_SPIRAM);
//Create a ring buffer with manually allocated memory
buf_handle = xRingbufferCreateStatic(log_buf_size, RINGBUF_TYPE_BYTEBUF, buffer_storage, buffer_struct); buf_handle = xRingbufferCreateStatic(log_buf_size, RINGBUF_TYPE_BYTEBUF, buffer_storage, buffer_struct);
if (buf_handle == NULL) { if (buf_handle == NULL) {
ESP_LOGE(tag,"Failed to create ring buffer for telnet!"); ESP_LOGE(tag,"Failed to create ring buffer for telnet!");
return; return;
} }
ESP_LOGI(tag, "***Redirecting log output to telnet"); ESP_LOGI(tag, "***Redirecting log output to telnet");
//esp_log_set_vprintf(&_log_vprintf); const esp_vfs_t vfs = {
kchal_stdout_register(); .flags = ESP_VFS_FLAG_DEFAULT,
.write = &stdout_write,
.open = &stdout_open,
.fstat = &stdout_fstat,
.close = &stdout_close,
.read = &stdout_read,
};
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;
StaticTask_t *xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
StackType_t *xStack = malloc(TELNET_STACK_SIZE);
if(!isStarted && bIsEnabled) {
xTaskCreateStatic( (TaskFunction_t) &telnet_task, "telnet", TELNET_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, xTaskBuffer);
isStarted=true;
}
}
static void telnet_task(void *data) {
int serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
struct sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddr.sin_port = htons(23);
int rc = bind(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
if (rc < 0) {
ESP_LOGE(tag, "bind: %d (%s)", errno, strerror(errno));
return;
}
rc = listen(serverSocket, 5);
if (rc < 0) {
ESP_LOGE(tag, "listen: %d (%s)", errno, strerror(errno));
return;
}
while(1) {
socklen_t len = sizeof(serverAddr);
rc = accept(serverSocket, (struct sockaddr *)&serverAddr, &len);
if (rc < 0 ){
ESP_LOGE(tag, "accept: %d (%s)", errno, strerror(errno));
return;
}
else {
partnerSocket = rc;
ESP_LOGD(tag, "We have a new client connection!");
handle_telnet_conn();
ESP_LOGD(tag, "Telnet connection terminated");
}
}
vTaskDelete(NULL);
}
/** /**
* Convert a telnet event type to its string representation. * Convert a telnet event type to its string representation.
*/ */
@@ -238,49 +208,33 @@ static char *eventToString(telnet_event_type_t type) {
return "Unknown type"; return "Unknown type";
} // eventToString } // eventToString
/**
* Send data to the telnet partner.
*/
void telnet_esp32_sendData(uint8_t *buffer, size_t size) {
if (tnHandle != NULL) {
telnet_send(tnHandle, (char *)buffer, size);
}
} // telnet_esp32_sendData
/**
* Send a vprintf formatted output to the telnet partner.
*/
int telnet_esp32_vprintf(const char *fmt, va_list va) {
if (tnHandle == NULL) {
return 0;
}
return telnet_vprintf(tnHandle, fmt, va);
} // telnet_esp32_vprintf
/** /**
* Telnet handler. * Telnet handler.
*/ */
void processReceivedData(const char * buffer, size_t size){ void process_received_data(const char * buffer, size_t size){
//ESP_LOGD(tag, "received data, len=%d", event->data.size); //ESP_LOGD(tag, "received data, len=%d", event->data.size);
char * command = malloc(size+1); char * command = malloc(size+1);
memcpy(command,buffer,size); const char * c=buffer;
command[size]='\0';
// todo: implement conditional remote echo
//telnet_esp32_sendData((uint8_t *)command, size);
if(command[0]!='\r' && command[0]!='\n'){
// some telnet clients will send data and crlf in two separate buffers
printf(command);
printf("\r\n");
run_command((char *)command);
// scrub from any escape command
if(*c == '\e'){
while(*(c++) !='n'){
--size;
};
--size;
}
memcpy(command,c,size);
command[size]='\0';
if(command[0]!='\r' && command[0]!='\n'){
// echo the command buffer out to uart and run
write(uart_fd, command, size);
run_command((char *)command);
} }
free(command); free(command);
} }
static void telnetHandler( static void handle_telnet_events(
telnet_t *thisTelnet, telnet_t *thisTelnet,
telnet_event_t *event, telnet_event_t *event,
void *userData) { void *userData) {
@@ -295,23 +249,33 @@ static void telnetHandler(
break; break;
case TELNET_EV_DATA: case TELNET_EV_DATA:
processReceivedData(event->data.buffer, event->data.size); process_received_data(event->data.buffer, event->data.size);
break; break;
case TELNET_EV_TTYPE:
printf("telnet event: %s\n", eventToString(event->type));
telnet_ttype_send(telnetUserData->tnHandle);
break;
default: default:
printf("telnet event: %s\n", eventToString(event->type)); printf("telnet event: %s\n", eventToString(event->type));
break; break;
} // End of switch event type } // End of switch event type
} // myTelnetHandler } // myhandle_telnet_events
static void handleLogBuffer(int partnerSocket, UBaseType_t count){ static void process_logs(UBaseType_t count){
//Receive an item from no-split ring buffer //Receive an item from no-split ring buffer
size_t item_size; size_t item_size;
UBaseType_t uxItemsWaiting; UBaseType_t uxItemsWaiting;
UBaseType_t uxBytesToSend=count; UBaseType_t uxBytesToSend=count;
vRingbufferGetInfo(buf_handle, NULL, NULL, NULL, NULL, &uxItemsWaiting); vRingbufferGetInfo(buf_handle, NULL, NULL, NULL, NULL, &uxItemsWaiting);
if(count == 0){
// this sends the entire buffer to the remote client
uxBytesToSend = uxItemsWaiting;
}
if( partnerSocket ==0 && (uxItemsWaiting*100 / log_buf_size) <75){ if( partnerSocket ==0 && (uxItemsWaiting*100 / log_buf_size) <75){
// We still have some room in the ringbuffer and there's no telnet // We still have some room in the ringbuffer and there's no telnet
// connection yet, so bail out for now. // connection yet, so bail out for now.
@@ -321,14 +285,12 @@ static void handleLogBuffer(int partnerSocket, UBaseType_t count){
while(uxBytesToSend>0){ while(uxBytesToSend>0){
char *item = (char *)xRingbufferReceiveUpTo(buf_handle, &item_size, pdMS_TO_TICKS(50), uxBytesToSend); char *item = (char *)xRingbufferReceiveUpTo(buf_handle, &item_size, pdMS_TO_TICKS(50), uxBytesToSend);
//Check received data
//Check received data
if (item != NULL) { if (item != NULL) {
uxBytesToSend-=item_size; uxBytesToSend-=item_size;
if(partnerSocket!=0) if(partnerSocket!=0){
telnet_esp32_sendData((uint8_t *)item, item_size); telnet_send_text(tnHandle, item, item_size);
else{
//printf("%s() flushing %u bytes from log buffer\n", __FUNCTION__, item_size);
} }
//Return Item //Return Item
vRingbufferReturnItem(buf_handle, (void *)item); vRingbufferReturnItem(buf_handle, (void *)item);
@@ -339,81 +301,95 @@ static void handleLogBuffer(int partnerSocket, UBaseType_t count){
} }
} }
static void doTelnet(int partnerSocket) { static void handle_telnet_conn() {
//ESP_LOGD(tag, ">> doTelnet");
static const telnet_telopt_t my_telopts[] = { static const telnet_telopt_t my_telopts[] = {
{ TELNET_TELOPT_ECHO, TELNET_WILL, TELNET_DONT }, { TELNET_TELOPT_ECHO, TELNET_WONT, TELNET_DO },
{ TELNET_TELOPT_TTYPE, TELNET_WILL, TELNET_DONT }, { TELNET_TELOPT_TTYPE, TELNET_WILL, TELNET_DONT },
{ TELNET_TELOPT_COMPRESS2, TELNET_WONT, TELNET_DO }, { TELNET_TELOPT_COMPRESS2, TELNET_WONT, TELNET_DO },
{ TELNET_TELOPT_ZMP, TELNET_WONT, TELNET_DO }, { TELNET_TELOPT_ZMP, TELNET_WONT, TELNET_DO },
{ TELNET_TELOPT_MSSP, TELNET_WONT, TELNET_DO }, { TELNET_TELOPT_MSSP, TELNET_WONT, TELNET_DO },
{ TELNET_TELOPT_BINARY, TELNET_WILL, TELNET_DO }, { TELNET_TELOPT_BINARY, TELNET_WILL, TELNET_DO },
{ TELNET_TELOPT_NAWS, TELNET_WILL, TELNET_DONT }, { TELNET_TELOPT_NAWS, TELNET_WILL, TELNET_DONT },
{TELNET_TELOPT_LINEMODE, TELNET_WONT, TELNET_DO },
{ -1, 0, 0 } { -1, 0, 0 }
}; };
struct telnetUserData *pTelnetUserData = (struct telnetUserData *)malloc(sizeof(struct telnetUserData)); struct telnetUserData *pTelnetUserData = (struct telnetUserData *)malloc(sizeof(struct telnetUserData));
tnHandle = telnet_init(my_telopts, handle_telnet_events, 0, pTelnetUserData);
pTelnetUserData->rxbuf = (char *) heap_caps_malloc(TELNET_RX_BUF, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
pTelnetUserData->tnHandle = tnHandle;
pTelnetUserData->sockfd = partnerSocket; pTelnetUserData->sockfd = partnerSocket;
// flush all the log buffer on connect
process_logs(0);
tnHandle = telnet_init(my_telopts, telnetHandler, 0, pTelnetUserData);
uint8_t buffer[1024];
while(1) { while(1) {
//ESP_LOGD(tag, "waiting for data"); //ESP_LOGD(tag, "waiting for data");
ssize_t len = recv(partnerSocket, (char *)buffer, sizeof(buffer), MSG_DONTWAIT); ssize_t len = recv(partnerSocket, pTelnetUserData->rxbuf, TELNET_RX_BUF, MSG_DONTWAIT);
if (len >0 ) { if (len >0 ) {
//ESP_LOGD(tag, "received %d bytes", len); telnet_recv(tnHandle, pTelnetUserData->rxbuf, len);
telnet_recv(tnHandle, (char *)buffer, len);
} }
else if (errno != EAGAIN && errno !=EWOULDBLOCK ){ else if (errno != EAGAIN && errno !=EWOULDBLOCK ){
telnet_free(tnHandle); telnet_free(tnHandle);
tnHandle = NULL; tnHandle = NULL;
free(pTelnetUserData->rxbuf);
pTelnetUserData->rxbuf=NULL;
free(pTelnetUserData); free(pTelnetUserData);
partnerSocket = 0;
return; return;
} }
handleLogBuffer(partnerSocket, send_chunk); process_logs(send_chunk);
taskYIELD(); taskYIELD();
} }
} // doTelnet } // handle_telnet_conn
/** // ******************* stdout/stderr Redirection to ringbuffer
* Listen for telnet clients and handle them. static ssize_t stdout_write(int fd, const void * data, size_t size) {
*/ if (xSemaphoreTake(xSemaphore, (TickType_t) 10) == pdTRUE) {
void telnet_esp32_listenForClients() { // #1 Write to ringbuffer
//ESP_LOGD(tag, ">> telnet_listenForClients"); if (buf_handle == NULL) {
int serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); printf("%s() ABORT. file handle _log_remote_fp is NULL\n",
__FUNCTION__);
} else {
//Send an item
UBaseType_t res = xRingbufferSend(buf_handle, data, size,
pdMS_TO_TICKS(100));
if (res != pdTRUE) {
// flush some entries
process_logs(size);
res = xRingbufferSend(buf_handle, data, size,
pdMS_TO_TICKS(100));
if (res != pdTRUE) {
struct sockaddr_in serverAddr; printf("%s() ABORT. Unable to store log entry in buffer\n",
serverAddr.sin_family = AF_INET; __FUNCTION__);
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY); }
serverAddr.sin_port = htons(23); }
int rc = bind(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
if (rc < 0) {
ESP_LOGE(tag, "bind: %d (%s)", errno, strerror(errno));
return;
}
rc = listen(serverSocket, 5);
if (rc < 0) {
ESP_LOGE(tag, "listen: %d (%s)", errno, strerror(errno));
return;
}
while(1) {
socklen_t len = sizeof(serverAddr);
rc = accept(serverSocket, (struct sockaddr *)&serverAddr, &len);
if (rc < 0 ){
ESP_LOGE(tag, "accept: %d (%s)", errno, strerror(errno));
return;
}
else {
int partnerSocket = rc;
ESP_LOGD(tag, "We have a new client connection!");
doTelnet(partnerSocket);
ESP_LOGD(tag, "Telnet connection terminated");
} }
xSemaphoreGive(xSemaphore);
} else {
// We could not obtain the semaphore and can therefore not access
// the shared resource safely.
} }
} // listenForNewClient return write(uart_fd, data, size);
}
static ssize_t stdout_read(int fd, void* data, size_t size) {
return read(fd, data, size);
}
static int stdout_open(const char * path, int flags, int mode) {
return 0;
}
static int stdout_close(int fd) {
return 0;
}
static int stdout_fstat(int fd, struct stat * st) {
st->st_mode = S_IFCHR;
return 0;
}

1
components/telnet/telnet.h
View File

@@ -1,4 +1,3 @@
void init_telnet(); void init_telnet();
void start_telnet(void * pvParameter); void start_telnet(void * pvParameter);
void telnet_esp32_sendData(uint8_t *buffer, size_t size);