telnet.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405
  1. /**
  2. * Test the telnet functions.
  3. *
  4. * Perform a test using the telnet functions.
  5. * This code exports two new global functions:
  6. *
  7. * void telnet_listenForClients(void (*callback)(uint8_t *buffer, size_t size))
  8. * void telnet_sendData(uint8_t *buffer, size_t size)
  9. *
  10. * For additional details and documentation see:
  11. * * Free book on ESP32 - https://leanpub.com/kolban-ESP32
  12. *
  13. *
  14. * Neil Kolban <kolban1@kolban.com>
  15. *
  16. * ****************************
  17. * Additional portions were taken from
  18. * https://github.com/PocketSprite/8bkc-sdk/blob/master/8bkc-components/8bkc-hal/vfs-stdout.c
  19. *
  20. */
  21. #include <stdlib.h> // Required for libtelnet.h
  22. #include <esp_log.h>
  23. #include "libtelnet.h"
  24. #include "stdbool.h"
  25. #include <lwip/def.h>
  26. #include <lwip/sockets.h>
  27. #include <errno.h>
  28. #include <string.h>
  29. #include "sdkconfig.h"
  30. #include "freertos/ringbuf.h"
  31. #include "esp_app_trace.h"
  32. #include "telnet.h"
  33. #include "esp_vfs.h"
  34. #include "esp_vfs_dev.h"
  35. #include "esp_attr.h"
  36. #include "soc/uart_struct.h"
  37. #include "driver/uart.h"
  38. #include "config.h"
  39. #include "nvs_utilities.h"
  40. #include "platform_esp32.h"
  41. #include "trace.h"
  42. /************************************
  43. * Globals
  44. */
  45. #define TELNET_STACK_SIZE 8048
  46. #define TELNET_RX_BUF 1024
  47. const static char TAG[] = "telnet";
  48. static int uart_fd=0;
  49. RingbufHandle_t buf_handle;
  50. //static SemaphoreHandle_t xSemaphore = NULL;
  51. static size_t send_chunk=300;
  52. static size_t log_buf_size=2000; //32-bit aligned size
  53. static bool bIsEnabled=false;
  54. static int partnerSocket=0;
  55. static telnet_t *tnHandle;
  56. extern bool bypass_wifi_manager;
  57. /************************************
  58. * Forward declarations
  59. */
  60. static void telnet_task(void *data);
  61. static ssize_t stdout_read(int fd, void* data, size_t size);
  62. static int stdout_open(const char * path, int flags, int mode);
  63. static int stdout_close(int fd);
  64. static int stdout_fstat(int fd, struct stat * st);
  65. static ssize_t stdout_write(int fd, const void * data, size_t size);
  66. static char *eventToString(telnet_event_type_t type);
  67. static void handle_telnet_conn();
  68. static void process_logs( UBaseType_t bytes, bool is_write_op);
  69. static bool bMirrorToUART=false;
  70. struct telnetUserData {
  71. int sockfd;
  72. telnet_t *tnHandle;
  73. char * rxbuf;
  74. };
  75. bool is_serial_suppressed(){
  76. return bIsEnabled?!bMirrorToUART:false ;
  77. }
  78. void init_telnet(){
  79. char *val= get_nvs_value_alloc(NVS_TYPE_STR, "telnet_enable");
  80. if (!val || strlen(val) == 0 || !strcasestr("YXD",val) ) {
  81. ESP_LOGI(TAG,"Telnet support disabled");
  82. if(val) free(val);
  83. return;
  84. }
  85. // if wifi manager is bypassed, there will possibly be no wifi available
  86. //
  87. bMirrorToUART = (strcasestr("D",val)!=NULL);
  88. if(!bMirrorToUART && bypass_wifi_manager){
  89. // This isn't supposed to happen, as telnet won't start if wifi manager isn't
  90. // started. So this is a safeguard only.
  91. ESP_LOGW(TAG,"Wifi manager is not active. Forcing console on Serial output.");
  92. }
  93. FREE_AND_NULL(val);
  94. val=get_nvs_value_alloc(NVS_TYPE_STR, "telnet_block");
  95. if(val){
  96. send_chunk=atol(val);
  97. free(val);
  98. send_chunk=send_chunk>0?send_chunk:500;
  99. }
  100. val=get_nvs_value_alloc(NVS_TYPE_STR, "telnet_buffer");
  101. if(val){
  102. log_buf_size=atol(val);
  103. free(val);
  104. log_buf_size=log_buf_size>0?log_buf_size:4000;
  105. }
  106. // Create the semaphore to guard a shared resource.
  107. //vSemaphoreCreateBinary( xSemaphore );
  108. // Redirect the output to our telnet handler as soon as possible
  109. StaticRingbuffer_t *buffer_struct = (StaticRingbuffer_t *)malloc(sizeof(StaticRingbuffer_t) );
  110. // All non-split ring buffer must have their memory alignment set to 32 bits.
  111. uint8_t *buffer_storage = (uint8_t *)heap_caps_malloc(sizeof(uint8_t)*log_buf_size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT );
  112. buf_handle = xRingbufferCreateStatic(log_buf_size, RINGBUF_TYPE_BYTEBUF, buffer_storage, buffer_struct);
  113. if (buf_handle == NULL) {
  114. ESP_LOGE(TAG,"Failed to create ring buffer for telnet!");
  115. return;
  116. }
  117. ESP_LOGI(TAG, "***Redirecting log output to telnet");
  118. const esp_vfs_t vfs = {
  119. .flags = ESP_VFS_FLAG_DEFAULT,
  120. .write = &stdout_write,
  121. .open = &stdout_open,
  122. .fstat = &stdout_fstat,
  123. .close = &stdout_close,
  124. .read = &stdout_read,
  125. };
  126. if(bMirrorToUART){
  127. uart_fd=open("/dev/uart/0", O_RDWR);
  128. }
  129. ESP_ERROR_CHECK(esp_vfs_register("/dev/pkspstdout", &vfs, NULL));
  130. freopen("/dev/pkspstdout", "w", stdout);
  131. freopen("/dev/pkspstdout", "w", stderr);
  132. bIsEnabled=true;
  133. }
  134. void start_telnet(void * pvParameter){
  135. static bool isStarted=false;
  136. StaticTask_t *xTaskBuffer = (StaticTask_t*) heap_caps_malloc(sizeof(StaticTask_t), (MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT));
  137. StackType_t *xStack = heap_caps_malloc(TELNET_STACK_SIZE,(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT));
  138. if(!isStarted && bIsEnabled) {
  139. xTaskCreateStatic( (TaskFunction_t) &telnet_task, "telnet", TELNET_STACK_SIZE, NULL, ESP_TASK_MAIN_PRIO , xStack, xTaskBuffer);
  140. isStarted=true;
  141. }
  142. }
  143. static void telnet_task(void *data) {
  144. int serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  145. struct sockaddr_in serverAddr;
  146. serverAddr.sin_family = AF_INET;
  147. serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  148. serverAddr.sin_port = htons(23);
  149. int rc = bind(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
  150. if (rc < 0) {
  151. ESP_LOGE(TAG, "bind: %d (%s)", errno, strerror(errno));
  152. close(serverSocket);
  153. return;
  154. }
  155. rc = listen(serverSocket, 5);
  156. if (rc < 0) {
  157. ESP_LOGE(TAG, "listen: %d (%s)", errno, strerror(errno));
  158. close(serverSocket);
  159. return;
  160. }
  161. while(1) {
  162. socklen_t len = sizeof(serverAddr);
  163. rc = accept(serverSocket, (struct sockaddr *)&serverAddr, &len);
  164. if (rc < 0 ){
  165. ESP_LOGE(TAG, "accept: %d (%s)", errno, strerror(errno));
  166. return;
  167. }
  168. else {
  169. partnerSocket = rc;
  170. ESP_LOGD(TAG, "We have a new client connection!");
  171. handle_telnet_conn();
  172. ESP_LOGD(TAG, "Telnet connection terminated");
  173. }
  174. }
  175. close(serverSocket);
  176. vTaskDelete(NULL);
  177. }
  178. /**
  179. * Convert a telnet event type to its string representation.
  180. */
  181. static char *eventToString(telnet_event_type_t type) {
  182. switch(type) {
  183. case TELNET_EV_COMPRESS:
  184. return "TELNET_EV_COMPRESS";
  185. case TELNET_EV_DATA:
  186. return "TELNET_EV_DATA";
  187. case TELNET_EV_DO:
  188. return "TELNET_EV_DO";
  189. case TELNET_EV_DONT:
  190. return "TELNET_EV_DONT";
  191. case TELNET_EV_ENVIRON:
  192. return "TELNET_EV_ENVIRON";
  193. case TELNET_EV_ERROR:
  194. return "TELNET_EV_ERROR";
  195. case TELNET_EV_IAC:
  196. return "TELNET_EV_IAC";
  197. case TELNET_EV_MSSP:
  198. return "TELNET_EV_MSSP";
  199. case TELNET_EV_SEND:
  200. return "TELNET_EV_SEND";
  201. case TELNET_EV_SUBNEGOTIATION:
  202. return "TELNET_EV_SUBNEGOTIATION";
  203. case TELNET_EV_TTYPE:
  204. return "TELNET_EV_TTYPE";
  205. case TELNET_EV_WARNING:
  206. return "TELNET_EV_WARNING";
  207. case TELNET_EV_WILL:
  208. return "TELNET_EV_WILL";
  209. case TELNET_EV_WONT:
  210. return "TELNET_EV_WONT";
  211. case TELNET_EV_ZMP:
  212. return "TELNET_EV_ZMP";
  213. }
  214. return "Unknown type";
  215. } // eventToString
  216. /**
  217. * Telnet handler.
  218. */
  219. void process_received_data(const char * buffer, size_t size){
  220. //ESP_LOGD(tag, "received data, len=%d", event->data.size);
  221. char * command = malloc(size+1);
  222. const char * c=buffer;
  223. // scrub from any escape command
  224. if(*c == '\e'){
  225. while(*(c++) !='n'){
  226. --size;
  227. };
  228. --size;
  229. }
  230. memcpy(command,c,size);
  231. command[size]='\0';
  232. if(command[0]!='\r' && command[0]!='\n'){
  233. // echo the command buffer out to uart and run
  234. if(bMirrorToUART){
  235. write(uart_fd, command, size);
  236. }
  237. run_command((char *)command);
  238. }
  239. free(command);
  240. }
  241. static void handle_telnet_events(
  242. telnet_t *thisTelnet,
  243. telnet_event_t *event,
  244. void *userData) {
  245. int rc;
  246. struct telnetUserData *telnetUserData = (struct telnetUserData *)userData;
  247. switch(event->type) {
  248. case TELNET_EV_SEND:
  249. rc = send(telnetUserData->sockfd, event->data.buffer, event->data.size, 0);
  250. if (rc < 0) {
  251. //printf("ERROR: (telnet) send: %d (%s)", errno, strerror(errno));
  252. }
  253. break;
  254. case TELNET_EV_DATA:
  255. process_received_data(event->data.buffer, event->data.size);
  256. break;
  257. case TELNET_EV_TTYPE:
  258. printf("telnet event: %s\n", eventToString(event->type));
  259. telnet_ttype_send(telnetUserData->tnHandle);
  260. break;
  261. default:
  262. printf("telnet event: %s\n", eventToString(event->type));
  263. break;
  264. } // End of switch event type
  265. } // myhandle_telnet_events
  266. static void process_logs( UBaseType_t bytes, bool is_write_op){
  267. //Receive an item from no-split ring buffer
  268. size_t item_size;
  269. UBaseType_t uxItemsWaiting;
  270. UBaseType_t uxBytesToSend=bytes;
  271. vRingbufferGetInfo(buf_handle, NULL, NULL, NULL, NULL, &uxItemsWaiting);
  272. bool is_space_available = ((log_buf_size-uxItemsWaiting)>=bytes && log_buf_size>uxItemsWaiting);
  273. if( is_space_available && (is_write_op || partnerSocket == 0) ){
  274. // there's still some room left in the buffer, and we're either
  275. // processing a write operation or telnet isn't connected yet.
  276. return;
  277. }
  278. if(is_write_op && !is_space_available && uxBytesToSend==0){
  279. // flush at least the size of a full chunk
  280. uxBytesToSend = send_chunk;
  281. }
  282. while(uxBytesToSend>0){
  283. char *item = (char *)xRingbufferReceiveUpTo(buf_handle, &item_size, pdMS_TO_TICKS(50), uxBytesToSend);
  284. //Check received data
  285. if (item != NULL) {
  286. uxBytesToSend-=item_size;
  287. if(partnerSocket!=0){
  288. telnet_send_text(tnHandle, item, item_size);
  289. }
  290. //Return Item
  291. vRingbufferReturnItem(buf_handle, (void *)item);
  292. }
  293. else{
  294. break;
  295. }
  296. }
  297. }
  298. static void handle_telnet_conn() {
  299. static const telnet_telopt_t my_telopts[] = {
  300. { TELNET_TELOPT_ECHO, TELNET_WONT, TELNET_DO },
  301. { TELNET_TELOPT_TTYPE, TELNET_WILL, TELNET_DONT },
  302. { TELNET_TELOPT_COMPRESS2, TELNET_WONT, TELNET_DO },
  303. { TELNET_TELOPT_ZMP, TELNET_WONT, TELNET_DO },
  304. { TELNET_TELOPT_MSSP, TELNET_WONT, TELNET_DO },
  305. { TELNET_TELOPT_BINARY, TELNET_WILL, TELNET_DO },
  306. { TELNET_TELOPT_NAWS, TELNET_WILL, TELNET_DONT },
  307. {TELNET_TELOPT_LINEMODE, TELNET_WONT, TELNET_DO },
  308. { -1, 0, 0 }
  309. };
  310. struct telnetUserData *pTelnetUserData = (struct telnetUserData *)malloc(sizeof(struct telnetUserData));
  311. tnHandle = telnet_init(my_telopts, handle_telnet_events, 0, pTelnetUserData);
  312. pTelnetUserData->rxbuf = (char *) heap_caps_malloc(TELNET_RX_BUF, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
  313. pTelnetUserData->tnHandle = tnHandle;
  314. pTelnetUserData->sockfd = partnerSocket;
  315. // flush all the log buffer on connect
  316. process_logs(log_buf_size, false);
  317. while(1) {
  318. //ESP_LOGD(tag, "waiting for data");
  319. ssize_t len = recv(partnerSocket, pTelnetUserData->rxbuf, TELNET_RX_BUF, MSG_DONTWAIT);
  320. if (len >0 ) {
  321. telnet_recv(tnHandle, pTelnetUserData->rxbuf, len);
  322. }
  323. else if (errno != EAGAIN && errno !=EWOULDBLOCK ){
  324. telnet_free(tnHandle);
  325. tnHandle = NULL;
  326. free(pTelnetUserData->rxbuf);
  327. pTelnetUserData->rxbuf=NULL;
  328. free(pTelnetUserData);
  329. partnerSocket = 0;
  330. return;
  331. }
  332. process_logs(send_chunk, false);
  333. taskYIELD();
  334. }
  335. } // handle_telnet_conn
  336. // ******************* stdout/stderr Redirection to ringbuffer
  337. static ssize_t stdout_write(int fd, const void * data, size_t size) {
  338. // #1 Write to ringbuffer
  339. if (buf_handle == NULL) {
  340. printf("%s() ABORT. file handle _log_remote_fp is NULL\n",
  341. __FUNCTION__);
  342. } else {
  343. // flush the buffer if needed
  344. process_logs(size, true);
  345. //Send an item
  346. UBaseType_t res = xRingbufferSend(buf_handle, data, size, pdMS_TO_TICKS(10));
  347. assert(res == pdTRUE);
  348. }
  349. return bMirrorToUART?write(uart_fd, data, size):size;
  350. }
  351. static ssize_t stdout_read(int fd, void* data, size_t size) {
  352. //return read(fd, data, size);
  353. return 0;
  354. }
  355. static int stdout_open(const char * path, int flags, int mode) {
  356. return 0;
  357. }
  358. static int stdout_close(int fd) {
  359. return 0;
  360. }
  361. static int stdout_fstat(int fd, struct stat * st) {
  362. st->st_mode = S_IFCHR;
  363. return 0;
  364. }