fix stack depth & memory issues when using telnet

components/display/core/gds_text.c

@@ -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 );

components/platform_config/platform_config.c

@@ -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

components/platform_console/app_squeezelite/cmd_squeezelite.c

@@ -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(){
+static void squeezelite_thread(void *arg){
-	int * exit_code;
-	static bool isRunning=false;
-	if(isRunning) {
-		ESP_LOGE(TAG,"Squeezelite already running. Exiting!");
-		return NULL;
-	}
-	isRunning=true;
 	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_LOGI(TAG ,"Calling squeezelite");
-    esp_pthread_cfg_t cfg = esp_pthread_get_default_config();
+	main(thread_parms.argc,thread_parms.argv);
-    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_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();
+	xTaskCreateStatic(squeezelite_thread, "squeezelite", SQUEEZELITE_THREAD_STACK_SIZE, 
-    cfg.thread_name= "squeezelite";
+					  NULL, CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT, xStack, &xTaskBuffer);
-    cfg.inherit_cfg = true;
-    esp_pthread_set_cfg(&cfg);
-	pthread_create(&thread_squeezelite, NULL, squeezelite_thread,NULL);
 	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;
-
 }

components/platform_console/cmd_nvs.c

@@ -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();

components/platform_console/platform_console.c

@@ -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 = {
+	esp_vfs_t vfs = { };
-			.flags = ESP_VFS_FLAG_DEFAULT,
+	vfs.flags = ESP_VFS_FLAG_DEFAULT;
-			.open = stdin_dummy,
+	vfs.open = stdin_dummy;
-			.read = stdin_read,
+	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);

components/telnet/telnet.c

@@ -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");
+	val = get_nvs_value_alloc(NVS_TYPE_STR, "telnet_block");
-	if(val){
+	if (val){
-		send_chunk=atol(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");
+	val = get_nvs_value_alloc(NVS_TYPE_STR, "telnet_buffer");
-	if(val){
+	if (val){
-		log_buf_size=atol(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 = {
+	esp_vfs_t vfs = { };
-			.flags = ESP_VFS_FLAG_DEFAULT,
+	vfs.flags = ESP_VFS_FLAG_DEFAULT;
-			.write = &stdout_write,
+	vfs.write = &stdout_write;
-			.open = &stdout_open,
+	vfs.open = &stdout_open;
-			.fstat = &stdout_fstat,
+	vfs.fstat = &stdout_fstat;
-		};
 
-	if(bMirrorToUART){
+	if (bMirrorToUART) uart_fd = open("/dev/uart/0", O_RDWR);
-		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", "wb", stdout);
-	freopen("/dev/pkspstdout", "w", stderr);
+	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));
+	while (1) {
-	if (rc < 0) {
+		serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-		ESP_LOGE(TAG, "bind: %d (%s)", errno, strerror(errno));
+		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);
+	while (1) {
-	if (rc < 0) {
-		ESP_LOGE(TAG, "listen: %d (%s)", errno, strerror(errno));
-		close(serverSocket);
-		return;
-	}
-
-	while(1) {
 		socklen_t len = sizeof(serverAddr);
-		rc = accept(serverSocket, (struct sockaddr *)&serverAddr, &len);
+		int sock = accept(serverSocket, (struct sockaddr *)&serverAddr, &len);
-		if (rc < 0 ){
+
-			ESP_LOGE(TAG, "accept: %d (%s)", errno, strerror(errno));
+		if (sock >= 0) {
-			return;
+			partnerSocket = sock;
-		}
+			ESP_LOGI(TAG, "We have a new client connection %d", sock);
-		else {
-			partnerSocket = rc;
-			ESP_LOGD(TAG, "We have a new client connection!");
 			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(
+static void handle_telnet_events(telnet_t *thisTelnet, telnet_event_t *event, void *userData) {
-		telnet_t *thisTelnet,
-		telnet_event_t *event,
-		void *userData) {
-	int rc;
 	struct telnetUserData *telnetUserData = (struct telnetUserData *)userData;
+
 	switch(event->type) {
 	case TELNET_EV_SEND:
-		rc = send(telnetUserData->sockfd, event->data.buffer, event->data.size, 0);
+		send(telnetUserData->sockfd, event->data.buffer, event->data.size, 0);
-		if (rc < 0) {
-			//printf("ERROR: (telnet) send: %d (%s)", errno, strerror(errno));
-		}
 		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[] = {
+	pTelnetUserData->rxbuf = (char *) heap_caps_malloc(TELNET_RX_BUF, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
-    { TELNET_TELOPT_ECHO,      TELNET_WONT, TELNET_DO },
+	pTelnetUserData->tnHandle = tnHandle;
-    { TELNET_TELOPT_TTYPE,     TELNET_WILL, TELNET_DONT },
+	pTelnetUserData->sockfd = partnerSocket;
-    { 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);
+	bool pending = true;
-  pTelnetUserData->tnHandle = tnHandle;
-  pTelnetUserData->sockfd = partnerSocket;
 
-  // flush all the log buffer on connect
+	while(1) {
-  process_logs(log_buf_size, false);
+		fd_set rfds, wfds;
+		struct timeval timeout = {0, 200*1000};
 
-  while(1) {
+		FD_ZERO(&rfds);
-  	//ESP_LOGD(tag, "waiting for data");
+		FD_SET(partnerSocket, &rfds);
-  	ssize_t len = recv(partnerSocket, pTelnetUserData->rxbuf, TELNET_RX_BUF, MSG_DONTWAIT);
+
-  	if (len >0 ) {
+		FD_ZERO(&wfds);
-		telnet_recv(tnHandle, pTelnetUserData->rxbuf, len);
+		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
+	// flush the buffer and send item
-	if (buf_handle == NULL) {
+	if (buf_handle) {
-		printf("%s() ABORT. file handle _log_remote_fp is NULL\n",
-				__FUNCTION__);
-	} else {
-		// flush the buffer if needed
 		process_logs(size, true);
-		//Send an item
+		xRingbufferSend(buf_handle, data, size, 0);
-		UBaseType_t res = xRingbufferSend(buf_handle, data, size, pdMS_TO_TICKS(10));
-		assert(res == pdTRUE);
-
 	}
-	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) {

components/tools/tools.h

@@ -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

components/wifi-manager/network_manager.h

@@ -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
 

components/wifi-manager/wifi_manager_http_server.c

@@ -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 rest_server_context_t *rest_context;
-EXT_RAM_ATTR RingbufHandle_t messaging=NULL;
+EXT_RAM_ATTR RingbufHandle_t messaging;
 
 httpd_handle_t get_http_server(int *port) {
 	if (port) *port = _port;