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

fix stack depth & memory issues when using telnet

Browse Source
This commit is contained in:
Philippe G
2021-12-20 17:09:23 -08:00
parent a354e6248a
commit 088825102e
9 changed files with 184 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/display/core/gds_text.c
View File

@@ -125,7 +125,7 @@ bool GDS_TextLine(struct GDS_Device* Device, int N, int Pos, int Attr, char *Tex
*
*/
int GDS_GetTextWidth(struct GDS_Device* Device, int N, int Attr, char *Text) {
struct GDS_FontDef *Font = GDS_SetFont( Device, Device->Lines[N-1].Font );
const struct GDS_FontDef *Font = GDS_SetFont( Device, Device->Lines[N-1].Font );
if (Attr & GDS_TEXT_MONOSPACE) GDS_FontForceMonospace( Device, true );
int Width = GDS_FontMeasureString( Device, Text );

1
components/platform_config/platform_config.c
View File

@@ -38,6 +38,7 @@
#include "freertos/timers.h"
#include "freertos/event_groups.h"
#include "tools.h"
#include "trace.h"
#define CONFIG_COMMIT_DELAY 1000
#define LOCK_MAX_WAIT 20*CONFIG_COMMIT_DELAY

70
components/platform_console/app_squeezelite/cmd_squeezelite.c
View File

@@ -3,7 +3,6 @@
#include "application_name.h"
#include "esp_log.h"
#include "esp_console.h"
#include "esp_pthread.h"
#include "../cmd_system.h"
#include "argtable3/argtable3.h"
#include "freertos/FreeRTOS.h"
@@ -16,9 +15,7 @@
extern esp_err_t process_recovery_ota(const char * bin_url, char * bin_buffer, uint32_t length);
static const char * TAG = "squeezelite_cmd";
#define SQUEEZELITE_THREAD_STACK_SIZE (4*1024)
#define SQUEEZELITE_THREAD_STACK_SIZE (8*1024)
const __attribute__((section(".rodata_desc"))) esp_app_desc_t esp_app_desc = {
@@ -44,8 +41,7 @@ const __attribute__((section(".rodata_desc"))) esp_app_desc_t esp_app_desc = {
extern int main(int argc, char **argv);
static int launchsqueezelite(int argc, char **argv);
pthread_t thread_squeezelite;
pthread_t thread_squeezelite_runner;
/** Arguments used by 'squeezelite' function */
static struct {
struct arg_str *parameters;
@@ -55,57 +51,47 @@ static struct {
int argc;
char ** argv;
} thread_parms ;
static void * squeezelite_runner_thread(){
ESP_LOGI(TAG ,"Calling squeezelite");
main(thread_parms.argc,thread_parms.argv);
return NULL;
}
#define ADDITIONAL_SQUEEZELITE_ARGS 5
static void * squeezelite_thread(){
int * exit_code;
static bool isRunning=false;
if(isRunning) {
ESP_LOGE(TAG,"Squeezelite already running. Exiting!");
return NULL;
}
isRunning=true;
static void squeezelite_thread(void *arg){
ESP_LOGV(TAG ,"Number of args received: %u",thread_parms.argc );
ESP_LOGV(TAG ,"Values:");
for(int i = 0;i<thread_parms.argc; i++){
ESP_LOGV(TAG ," %s",thread_parms.argv[i]);
}
ESP_LOGV(TAG,"Starting Squeezelite runner Thread");
esp_pthread_cfg_t cfg = esp_pthread_get_default_config();
cfg.thread_name= "squeezelite-run";
cfg.inherit_cfg = true;
cfg.stack_size = SQUEEZELITE_THREAD_STACK_SIZE ;
esp_pthread_set_cfg(&cfg);
// no attribute if we want esp stack stack to prevail
pthread_create(&thread_squeezelite_runner, NULL, squeezelite_runner_thread,NULL);
// Wait for thread completion so we can free up memory.
pthread_join(thread_squeezelite_runner,(void **)&exit_code);
ESP_LOGI(TAG ,"Calling squeezelite");
main(thread_parms.argc,thread_parms.argv);
ESP_LOGV(TAG ,"Exited from squeezelite's main(). Freeing argv structure.");
for(int i=0;i<thread_parms.argc;i++){
ESP_LOGV(TAG ,"Freeing char buffer for parameter %u", i+1);
free(thread_parms.argv[i]);
}
ESP_LOGV(TAG ,"Freeing argv pointer");
free(thread_parms.argv);
isRunning=false;
ESP_LOGE(TAG, "Exited from squeezelite thread, something's wrong ... rebooting (wait 30s for user to take action)");
if(!wait_for_commit()){
ESP_LOGW(TAG,"Unable to commit configuration. ");
}
vTaskDelay( pdMS_TO_TICKS( 30*1000 ) );
esp_restart();
return NULL;
}
static int launchsqueezelite(int argc, char **argv)
{
static int launchsqueezelite(int argc, char **argv) {
static DRAM_ATTR StaticTask_t xTaskBuffer __attribute__ ((aligned (4)));
static EXT_RAM_ATTR StackType_t xStack[SQUEEZELITE_THREAD_STACK_SIZE] __attribute__ ((aligned (4)));
static bool isRunning = false;
if (isRunning) {
ESP_LOGE(TAG,"Squeezelite already running. Exiting!");
return -1;
}
ESP_LOGV(TAG ,"Begin");
isRunning = true;
ESP_LOGV(TAG, "Parameters:");
for(int i = 0;i<argc; i++){
@@ -129,16 +115,14 @@ static int launchsqueezelite(int argc, char **argv)
}
ESP_LOGD(TAG,"Starting Squeezelite Thread");
esp_pthread_cfg_t cfg = esp_pthread_get_default_config();
cfg.thread_name= "squeezelite";
cfg.inherit_cfg = true;
esp_pthread_set_cfg(&cfg);
pthread_create(&thread_squeezelite, NULL, squeezelite_thread,NULL);
xTaskCreateStatic(squeezelite_thread, "squeezelite", SQUEEZELITE_THREAD_STACK_SIZE,
NULL, CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT, xStack, &xTaskBuffer);
ESP_LOGD(TAG ,"Back to console thread!");
return 0;
}
void register_squeezelite(){
void register_squeezelite() {
squeezelite_args.parameters = arg_str0(NULL, NULL, "<parms>", "command line for squeezelite. -h for help, --defaults to launch with default values.");
squeezelite_args.end = arg_end(1);
const esp_console_cmd_t launch_squeezelite = {
@@ -149,10 +133,9 @@ void register_squeezelite(){
.argtable = &squeezelite_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&launch_squeezelite) );
}
esp_err_t start_ota(const char * bin_url, char * bin_buffer, uint32_t length)
{
esp_err_t start_ota(const char * bin_url, char * bin_buffer, uint32_t length) {
if(!bin_url){
ESP_LOGE(TAG,"missing URL parameter. Unable to start OTA");
return ESP_ERR_INVALID_ARG;
@@ -170,5 +153,4 @@ esp_err_t start_ota(const char * bin_url, char * bin_buffer, uint32_t length)
ESP_LOGW(TAG, "Rebooting to recovery to complete the installation");
return guided_factory();
return ESP_OK;
}

1
components/platform_console/cmd_nvs.c
View File

@@ -27,6 +27,7 @@ extern "C" {
#include "platform_console.h"
#include "messaging.h"
#include "tools.h"
#include "trace.h"
extern esp_err_t network_wifi_erase_legacy();
extern esp_err_t network_wifi_erase_known_ap();

11
components/platform_console/platform_console.c
View File

@@ -298,11 +298,10 @@ void initialize_console() {
xRingbufferAddToQueueSetRead(stdin_redir.handle, stdin_redir.queue_set);
xQueueAddToSet(uart_queue, stdin_redir.queue_set);
const esp_vfs_t vfs = {
.flags = ESP_VFS_FLAG_DEFAULT,
.open = stdin_dummy,
.read = stdin_read,
};
esp_vfs_t vfs = { };
vfs.flags = ESP_VFS_FLAG_DEFAULT;
vfs.open = stdin_dummy;
vfs.read = stdin_read;
ESP_ERROR_CHECK(esp_vfs_register("/dev/console", &vfs, NULL));
freopen("/dev/console", "r", stdin);
@@ -407,9 +406,9 @@ void console_start() {
esp_pthread_cfg_t cfg = esp_pthread_get_default_config();
cfg.thread_name= "console";
cfg.inherit_cfg = true;
cfg.stack_size = 4*1024;
if(is_recovery_running){
prompt = recovery_prompt;
cfg.stack_size = 4096 ;
}
MEMTRACE_PRINT_DELTA_MESSAGE("Creating console thread with stack size of 4096 bytes");
esp_pthread_set_cfg(&cfg);

342
components/telnet/telnet.c
View File

@@ -48,34 +48,34 @@
#define TELNET_STACK_SIZE 4096
#define TELNET_RX_BUF 1024
const static char TAG[] = "telnet";
static int uart_fd=0;
static RingbufHandle_t buf_handle;
static size_t send_chunk=300;
static size_t log_buf_size=2000; //32-bit aligned size
static bool bIsEnabled=false;
static int partnerSocket=0;
static telnet_t *tnHandle;
extern bool bypass_network_manager;
/************************************
* 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 char *eventToString(telnet_event_type_t type);
static void handle_telnet_conn();
static void process_logs( UBaseType_t bytes, bool is_write_op);
static bool bMirrorToUART=false;
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;
static bool bMirrorToUART;
/************************************
* 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);
void init_telnet(){
char *val= get_nvs_value_alloc(NVS_TYPE_STR, "telnet_enable");
@@ -86,26 +86,25 @@ void init_telnet(){
}
// if wifi manager is bypassed, there will possibly be no wifi available
//
bMirrorToUART = (strcasestr("D",val)!=NULL);
if(!bMirrorToUART && bypass_network_manager){
if (!bMirrorToUART && bypass_network_manager){
// This isn't supposed to happen, as telnet won't start if wifi manager isn't
// started. So this is a safeguard only.
ESP_LOGW(TAG,"Wifi manager is not active. Forcing console on Serial output.");
}
FREE_AND_NULL(val);
val=get_nvs_value_alloc(NVS_TYPE_STR, "telnet_block");
if(val){
send_chunk=atol(val);
val = get_nvs_value_alloc(NVS_TYPE_STR, "telnet_block");
if (val){
int size = atol(val);
if (size > 0) send_chunk = size;
free(val);
send_chunk=send_chunk>0?send_chunk:500;
}
val=get_nvs_value_alloc(NVS_TYPE_STR, "telnet_buffer");
if(val){
log_buf_size=atol(val);
val = get_nvs_value_alloc(NVS_TYPE_STR, "telnet_buffer");
if (val){
int size = atol(val);
if (size > 0) log_buf_size = size;
free(val);
log_buf_size=log_buf_size>0?log_buf_size:4000;
}
// 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);
@@ -120,20 +119,17 @@ void init_telnet(){
}
ESP_LOGI(TAG, "***Redirecting log output to telnet");
const esp_vfs_t vfs = {
.flags = ESP_VFS_FLAG_DEFAULT,
.write = &stdout_write,
.open = &stdout_open,
.fstat = &stdout_fstat,
};
esp_vfs_t vfs = { };
vfs.flags = ESP_VFS_FLAG_DEFAULT;
vfs.write = &stdout_write;
vfs.open = &stdout_open;
vfs.fstat = &stdout_fstat;
if(bMirrorToUART){
uart_fd=open("/dev/uart/0", O_RDWR);
}
if (bMirrorToUART) 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);
freopen("/dev/pkspstdout", "wb", stdout);
freopen("/dev/pkspstdout", "wb", stderr);
bIsEnabled=true;
}
@@ -141,219 +137,165 @@ void init_telnet(){
void start_telnet(void * pvParameter){
static bool isStarted=false;
if(isStarted || !bIsEnabled) return;
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);
isStarted=true;
}
static void telnet_task(void *data) {
int serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
int serverSocket;
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));
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);
return;
ESP_LOGI(TAG, "can't bind Telnet socket");
vTaskDelay(pdMS_TO_TICKS(1000));
}
rc = listen(serverSocket, 5);
if (rc < 0) {
ESP_LOGE(TAG, "listen: %d (%s)", errno, strerror(errno));
close(serverSocket);
return;
}
while(1) {
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!");
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_LOGD(TAG, "Telnet connection terminated");
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);
}
/**
* Convert a telnet event type to its string representation.
*/
static char *eventToString(telnet_event_type_t type) {
switch(type) {
case TELNET_EV_COMPRESS:
return "TELNET_EV_COMPRESS";
case TELNET_EV_DATA:
return "TELNET_EV_DATA";
case TELNET_EV_DO:
return "TELNET_EV_DO";
case TELNET_EV_DONT:
return "TELNET_EV_DONT";
case TELNET_EV_ENVIRON:
return "TELNET_EV_ENVIRON";
case TELNET_EV_ERROR:
return "TELNET_EV_ERROR";
case TELNET_EV_IAC:
return "TELNET_EV_IAC";
case TELNET_EV_MSSP:
return "TELNET_EV_MSSP";
case TELNET_EV_SEND:
return "TELNET_EV_SEND";
case TELNET_EV_SUBNEGOTIATION:
return "TELNET_EV_SUBNEGOTIATION";
case TELNET_EV_TTYPE:
return "TELNET_EV_TTYPE";
case TELNET_EV_WARNING:
return "TELNET_EV_WARNING";
case TELNET_EV_WILL:
return "TELNET_EV_WILL";
case TELNET_EV_WONT:
return "TELNET_EV_WONT";
case TELNET_EV_ZMP:
return "TELNET_EV_ZMP";
}
return "Unknown type";
} // eventToString
/**
* Telnet handler.
*/
static void handle_telnet_events(
telnet_t *thisTelnet,
telnet_event_t *event,
void *userData) {
int rc;
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:
rc = send(telnetUserData->sockfd, event->data.buffer, event->data.size, 0);
if (rc < 0) {
//printf("ERROR: (telnet) send: %d (%s)", errno, strerror(errno));
}
send(telnetUserData->sockfd, event->data.buffer, event->data.size, 0);
break;
case TELNET_EV_DATA:
console_push(event->data.buffer, event->data.size);
console_push(event->data.buffer, event->data.size);
break;
case TELNET_EV_TTYPE:
printf("telnet event: %s\n", eventToString(event->type));
telnet_ttype_send(telnetUserData->tnHandle);
break;
default:
printf("telnet event: %s\n", eventToString(event->type));
break;
} // End of switch event type
} // myhandle_telnet_events
static void process_logs( UBaseType_t bytes, bool is_write_op){
//Receive an item from no-split ring buffer
size_t item_size;
UBaseType_t uxItemsWaiting;
UBaseType_t uxBytesToSend=bytes;
vRingbufferGetInfo(buf_handle, NULL, NULL, NULL, NULL, &uxItemsWaiting);
bool is_space_available = ((log_buf_size-uxItemsWaiting)>=bytes && log_buf_size>uxItemsWaiting);
if( is_space_available && (is_write_op || partnerSocket == 0) ){
// there's still some room left in the buffer, and we're either
// processing a write operation or telnet isn't connected yet.
return;
}
if(is_write_op && !is_space_available && uxBytesToSend==0){
// flush at least the size of a full chunk
uxBytesToSend = send_chunk;
}
while(uxBytesToSend>0){
char *item = (char *)xRingbufferReceiveUpTo(buf_handle, &item_size, pdMS_TO_TICKS(50), uxBytesToSend);
//Check received data
if (item != NULL) {
uxBytesToSend-=item_size;
if(partnerSocket!=0){
telnet_send_text(tnHandle, item, item_size);
}
//Return Item
vRingbufferReturnItem(buf_handle, (void *)item);
}
else{
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);
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;
pTelnetUserData->rxbuf = (char *) heap_caps_malloc(TELNET_RX_BUF, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
pTelnetUserData->tnHandle = tnHandle;
pTelnetUserData->sockfd = partnerSocket;
bool pending = true;
// flush all the log buffer on connect
process_logs(log_buf_size, false);
while(1) {
fd_set rfds, wfds;
struct timeval timeout = {0, 200*1000};
while(1) {
//ESP_LOGD(tag, "waiting for data");
ssize_t len = recv(partnerSocket, pTelnetUserData->rxbuf, TELNET_RX_BUF, MSG_DONTWAIT);
if (len >0 ) {
telnet_recv(tnHandle, pTelnetUserData->rxbuf, len);
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;
}
}
else if (errno != EAGAIN && errno !=EWOULDBLOCK ){
telnet_free(tnHandle);
tnHandle = NULL;
free(pTelnetUserData->rxbuf);
pTelnetUserData->rxbuf=NULL;
free(pTelnetUserData);
partnerSocket = 0;
return;
}
process_logs(send_chunk, false);
taskYIELD();
}
telnet_free(tnHandle);
tnHandle = NULL;
} // handle_telnet_conn
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) {
// #1 Write to ringbuffer
if (buf_handle == NULL) {
printf("%s() ABORT. file handle _log_remote_fp is NULL\n",
__FUNCTION__);
} else {
// flush the buffer if needed
// flush the buffer and send item
if (buf_handle) {
process_logs(size, true);
//Send an item
UBaseType_t res = xRingbufferSend(buf_handle, data, size, pdMS_TO_TICKS(10));
assert(res == pdTRUE);
xRingbufferSend(buf_handle, data, size, 0);
}
return bMirrorToUART?write(uart_fd, data, size):size;
// mirror to uart if required
return (bMirrorToUART || !buf_handle) ? write(uart_fd, data, size) : size;
}
static int stdout_open(const char * path, int flags, int mode) {

8
components/tools/tools.h
View File

@@ -32,14 +32,6 @@ extern "C" {
#define ESP_LOG_DEBUG_EVENT(tag,e) ESP_LOGD(tag,"evt: " e)
#ifdef ENABLE_MEMTRACE
#define MEMTRACE_PRINT_DELTA() memtrace_print_delta(NULL,TAG,__FUNCTION__);
#define MEMTRACE_PRINT_DELTA_MESSAGE(x) memtrace_print_delta(x,TAG,__FUNCTION__);
#else
#define MEMTRACE_PRINT_DELTA()
#define MEMTRACE_PRINT_DELTA_MESSAGE(x) ESP_LOGD(TAG,"%s",x);
#endif
#ifndef FREE_AND_NULL
#define FREE_AND_NULL(x) if(x) { free(x); x=NULL; }
#endif

2
components/wifi-manager/network_manager.h
View File

@@ -413,7 +413,7 @@ char* network_manager_alloc_get_mac_string(uint8_t mac[6]);
#define network_handler_entry_print(State_Machine, begin)
#define network_handler_print(State_Machine, begin)
#define NETWORK_EXECUTE_CB(mch) network_execute_cb(mch,NULL)
#define NETWORK_PRINT_TRANSITION(prefix, source,target, event, print_source,caller )
#define NETWORK_PRINT_TRANSITION(begin, prefix, source,target, event, print_source,caller )
#define NETWORK_DEBUG_STATE_MACHINE(begin, cb_prefix,state_machine,print_from,caller)
#endif

6
components/wifi-manager/wifi_manager_http_server.c
View File

@@ -37,10 +37,10 @@
#include "tools.h"
static const char TAG[] = "http_server";
EXT_RAM_ATTR static httpd_handle_t _server = NULL;
EXT_RAM_ATTR static httpd_handle_t _server;
EXT_RAM_ATTR static int _port;
EXT_RAM_ATTR rest_server_context_t *rest_context = NULL;
EXT_RAM_ATTR RingbufHandle_t messaging=NULL;
EXT_RAM_ATTR rest_server_context_t *rest_context;
EXT_RAM_ATTR RingbufHandle_t messaging;
httpd_handle_t get_http_server(int *port) {
if (port) *port = _port;