?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target: Do not use LOG_USER() for error messages
[openocd.git] / src / server / telnet_server.c
blob938bc5b0624972e52cf207326fbac5d6a82a85ae
1 // SPDX-License-Identifier: GPL-2.0-or-later
2
3 /***************************************************************************
4 * Copyright (C) 2005 by Dominic Rath *
5 * Dominic.Rath@gmx.de *
6 * *
7 * Copyright (C) 2007-2010 Øyvind Harboe *
8 * oyvind.harboe@zylin.com *
9 * *
10 * Copyright (C) 2008 by Spencer Oliver *
11 * spen@spen-soft.co.uk *
12 ***************************************************************************/
13
14 #ifdef HAVE_CONFIG_H
15 #include "config.h"
16 #endif
17
18 #include "telnet_server.h"
19 #include <target/target_request.h>
20 #include <helper/configuration.h>
21 #include <helper/list.h>
22
23 static char *telnet_port;
24
25 static char *negotiate =
26 "\xFF\xFB\x03" /* IAC WILL Suppress Go Ahead */
27 "\xFF\xFB\x01" /* IAC WILL Echo */
28 "\xFF\xFD\x03" /* IAC DO Suppress Go Ahead */
29 "\xFF\xFE\x01"; /* IAC DON'T Echo */
30
31 #define CTRL(c) (c - '@')
32 #define TELNET_HISTORY ".openocd_history"
33
34 /* The only way we can detect that the socket is closed is the first time
35 * we write to it, we will fail. Subsequent write operations will
36 * succeed. Shudder!
37 */
38 static int telnet_write(struct connection *connection, const void *data,
39 int len)
40 {
41 struct telnet_connection *t_con = connection->priv;
42 if (t_con->closed)
43 return ERROR_SERVER_REMOTE_CLOSED;
44
45 if (connection_write(connection, data, len) == len)
46 return ERROR_OK;
47 t_con->closed = true;
48 return ERROR_SERVER_REMOTE_CLOSED;
49 }
50
51 /* output an audible bell */
52 static int telnet_bell(struct connection *connection)
53 {
54 /* ("\a" does not work, at least on windows) */
55 return telnet_write(connection, "\x07", 1);
56 }
57
58 static int telnet_prompt(struct connection *connection)
59 {
60 struct telnet_connection *t_con = connection->priv;
61
62 return telnet_write(connection, t_con->prompt, strlen(t_con->prompt));
63 }
64
65 static int telnet_outputline(struct connection *connection, const char *line)
66 {
67 int len;
68
69 /* process lines in buffer */
70 while (*line) {
71 char *line_end = strchr(line, '\n');
72
73 if (line_end)
74 len = line_end-line;
75 else
76 len = strlen(line);
77
78 telnet_write(connection, line, len);
79 if (line_end) {
80 telnet_write(connection, "\r\n", 2);
81 line += len + 1;
82 } else
83 line += len;
84 }
85
86 return ERROR_OK;
87 }
88
89 static int telnet_output(struct command_context *cmd_ctx, const char *line)
90 {
91 struct connection *connection = cmd_ctx->output_handler_priv;
92
93 return telnet_outputline(connection, line);
94 }
95
96 static void telnet_log_callback(void *priv, const char *file, unsigned line,
97 const char *function, const char *string)
98 {
99 struct connection *connection = priv;
100 struct telnet_connection *t_con = connection->priv;
101 size_t i;
102 size_t tmp;
103
104 /* If the prompt is not visible, simply output the message. */
105 if (!t_con->prompt_visible) {
106 telnet_outputline(connection, string);
107 return;
108 }
109
110 /* Clear the command line. */
111 tmp = strlen(t_con->prompt) + t_con->line_size;
112
113 for (i = 0; i < tmp; i += 16)
114 telnet_write(connection, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
115 MIN(tmp - i, 16));
116
117 for (i = 0; i < tmp; i += 16)
118 telnet_write(connection, " ", MIN(tmp - i, 16));
119
120 for (i = 0; i < tmp; i += 16)
121 telnet_write(connection, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
122 MIN(tmp - i, 16));
123
124 telnet_outputline(connection, string);
125
126 /* Put the command line to its previous state. */
127 telnet_prompt(connection);
128 telnet_write(connection, t_con->line, t_con->line_size);
129
130 for (i = t_con->line_cursor; i < t_con->line_size; i++)
131 telnet_write(connection, "\b", 1);
132 }
133
134 static void telnet_load_history(struct telnet_connection *t_con)
135 {
136 FILE *histfp;
137 char buffer[TELNET_BUFFER_SIZE];
138 int i = 0;
139
140 char *history = get_home_dir(TELNET_HISTORY);
141
142 if (!history) {
143 LOG_INFO("unable to get user home directory, telnet history will be disabled");
144 return;
145 }
146
147 histfp = fopen(history, "rb");
148
149 if (histfp) {
150
151 while (fgets(buffer, sizeof(buffer), histfp)) {
152
153 char *p = strchr(buffer, '\n');
154 if (p)
155 *p = '\0';
156 if (buffer[0] && i < TELNET_LINE_HISTORY_SIZE)
157 t_con->history[i++] = strdup(buffer);
158 }
159
160 t_con->next_history = i;
161 t_con->next_history %= TELNET_LINE_HISTORY_SIZE;
162 /* try to set to last entry - 1, that way we skip over any exit/shutdown cmds */
163 t_con->current_history = t_con->next_history > 0 ? i - 1 : 0;
164 fclose(histfp);
165 }
166
167 free(history);
168 }
169
170 static void telnet_save_history(struct telnet_connection *t_con)
171 {
172 FILE *histfp;
173 int i;
174 int num;
175
176 char *history = get_home_dir(TELNET_HISTORY);
177
178 if (!history) {
179 LOG_INFO("unable to get user home directory, telnet history will be disabled");
180 return;
181 }
182
183 histfp = fopen(history, "wb");
184
185 if (histfp) {
186
187 num = TELNET_LINE_HISTORY_SIZE;
188 i = t_con->current_history + 1;
189 i %= TELNET_LINE_HISTORY_SIZE;
190
191 while (!t_con->history[i] && num > 0) {
192 i++;
193 i %= TELNET_LINE_HISTORY_SIZE;
194 num--;
195 }
196
197 if (num > 0) {
198 for (; num > 0; num--) {
199 fprintf(histfp, "%s\n", t_con->history[i]);
200 i++;
201 i %= TELNET_LINE_HISTORY_SIZE;
202 }
203 }
204 fclose(histfp);
205 }
206
207 free(history);
208 }
209
210 static int telnet_new_connection(struct connection *connection)
211 {
212 struct telnet_connection *telnet_connection;
213 struct telnet_service *telnet_service = connection->service->priv;
214
215 telnet_connection = calloc(1, sizeof(struct telnet_connection));
216
217 if (!telnet_connection) {
218 LOG_ERROR("Failed to allocate telnet connection.");
219 return ERROR_FAIL;
220 }
221
222 connection->priv = telnet_connection;
223
224 /* initialize telnet connection information */
225 telnet_connection->prompt = strdup("> ");
226 telnet_connection->prompt_visible = true;
227 telnet_connection->state = TELNET_STATE_DATA;
228
229 /* output goes through telnet connection */
230 command_set_output_handler(connection->cmd_ctx, telnet_output, connection);
231
232 /* negotiate telnet options */
233 telnet_write(connection, negotiate, strlen(negotiate));
234
235 /* print connection banner */
236 if (telnet_service->banner) {
237 telnet_write(connection, telnet_service->banner, strlen(telnet_service->banner));
238 telnet_write(connection, "\r\n", 2);
239 }
240
241 /* the prompt is always placed at the line beginning */
242 telnet_write(connection, "\r", 1);
243 telnet_prompt(connection);
244
245 telnet_load_history(telnet_connection);
246
247 log_add_callback(telnet_log_callback, connection);
248
249 return ERROR_OK;
250 }
251
252 static void telnet_clear_line(struct connection *connection,
253 struct telnet_connection *t_con)
254 {
255 /* move to end of line */
256 if (t_con->line_cursor < t_con->line_size)
257 telnet_write(connection,
258 t_con->line + t_con->line_cursor,
259 t_con->line_size - t_con->line_cursor);
260
261 /* backspace, overwrite with space, backspace */
262 while (t_con->line_size > 0) {
263 telnet_write(connection, "\b \b", 3);
264 t_con->line_size--;
265 }
266 t_con->line_cursor = 0;
267 }
268
269 static void telnet_history_go(struct connection *connection, int idx)
270 {
271 struct telnet_connection *t_con = connection->priv;
272
273 if (t_con->history[idx]) {
274 telnet_clear_line(connection, t_con);
275 t_con->line_size = strlen(t_con->history[idx]);
276 t_con->line_cursor = t_con->line_size;
277 memcpy(t_con->line, t_con->history[idx], t_con->line_size);
278 telnet_write(connection, t_con->line, t_con->line_size);
279 t_con->current_history = idx;
280 }
281 t_con->state = TELNET_STATE_DATA;
282 }
283
284 static void telnet_history_up(struct connection *connection)
285 {
286 struct telnet_connection *t_con = connection->priv;
287
288 size_t last_history = (t_con->current_history > 0) ?
289 t_con->current_history - 1 :
290 TELNET_LINE_HISTORY_SIZE-1;
291 telnet_history_go(connection, last_history);
292 }
293
294 static void telnet_history_down(struct connection *connection)
295 {
296 struct telnet_connection *t_con = connection->priv;
297 size_t next_history;
298
299 next_history = (t_con->current_history + 1) % TELNET_LINE_HISTORY_SIZE;
300 telnet_history_go(connection, next_history);
301 }
302
303 static void telnet_history_add(struct connection *connection)
304 {
305 struct telnet_connection *t_con = connection->priv;
306
307 /* save only non-blank not repeating lines in the history */
308 char *prev_line = t_con->history[(t_con->current_history > 0) ?
309 t_con->current_history - 1 : TELNET_LINE_HISTORY_SIZE-1];
310
311 if (*t_con->line && (!prev_line || strcmp(t_con->line, prev_line))) {
312 /* if the history slot is already taken, free it */
313 free(t_con->history[t_con->next_history]);
314
315 /* add line to history */
316 t_con->history[t_con->next_history] = strdup(t_con->line);
317
318 /* wrap history at TELNET_LINE_HISTORY_SIZE */
319 t_con->next_history = (t_con->next_history + 1) % TELNET_LINE_HISTORY_SIZE;
320
321 /* current history line starts at the new entry */
322 t_con->current_history = t_con->next_history;
323
324 free(t_con->history[t_con->current_history]);
325 t_con->history[t_con->current_history] = strdup("");
326 }
327 }
328
329 static int telnet_history_print(struct connection *connection)
330 {
331 struct telnet_connection *tc;
332
333 tc = connection->priv;
334
335 for (size_t i = 1; i < TELNET_LINE_HISTORY_SIZE; i++) {
336 char *line;
337
338 /*
339 * The tc->next_history line contains empty string (unless NULL), thus
340 * it is not printed.
341 */
342 line = tc->history[(tc->next_history + i) % TELNET_LINE_HISTORY_SIZE];
343
344 if (line) {
345 telnet_write(connection, line, strlen(line));
346 telnet_write(connection, "\r\n\x00", 3);
347 }
348 }
349
350 tc->line_size = 0;
351 tc->line_cursor = 0;
352
353 /* The prompt is always placed at the line beginning. */
354 telnet_write(connection, "\r", 1);
355
356 return telnet_prompt(connection);
357 }
358
359 static void telnet_move_cursor(struct connection *connection, size_t pos)
360 {
361 struct telnet_connection *tc = connection->priv;
362 size_t tmp;
363
364 if (pos == tc->line_cursor) /* nothing to do */
365 return;
366
367 if (pos > tc->line_size) /* out of bounds */
368 return;
369
370 if (pos < tc->line_cursor) {
371 tmp = tc->line_cursor - pos;
372
373 for (size_t i = 0; i < tmp; i += 16)
374 telnet_write(connection, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
375 MIN(tmp - i, 16));
376 } else {
377 tmp = pos - tc->line_cursor;
378
379 for (size_t i = 0; i < tmp; i += 16)
380 telnet_write(connection, tc->line + tc->line_cursor + i,
381 MIN(tmp - i, 16));
382 }
383
384 tc->line_cursor = pos;
385 }
386
387 /* check buffer size leaving one spare character for string null termination */
388 static inline bool telnet_can_insert(struct connection *connection, size_t len)
389 {
390 struct telnet_connection *t_con = connection->priv;
391
392 return t_con->line_size + len < TELNET_LINE_MAX_SIZE;
393 }
394
395 /* write to telnet console, and update the telnet_connection members
396 * this function is capable of inserting in the middle of a line
397 * please ensure that data does not contain special characters (\n, \r, \t, \b ...)
398 *
399 * returns false when it fails to insert the requested data
400 */
401 static bool telnet_insert(struct connection *connection, const void *data, size_t len)
402 {
403 struct telnet_connection *t_con = connection->priv;
404
405 if (!telnet_can_insert(connection, len)) {
406 telnet_bell(connection);
407 return false;
408 }
409
410 if (t_con->line_cursor < t_con->line_size) {
411 /* we have some content after the cursor */
412 memmove(t_con->line + t_con->line_cursor + len,
413 t_con->line + t_con->line_cursor,
414 t_con->line_size - t_con->line_cursor);
415 }
416
417 strncpy(t_con->line + t_con->line_cursor, data, len);
418
419 telnet_write(connection,
420 t_con->line + t_con->line_cursor,
421 t_con->line_size + len - t_con->line_cursor);
422
423 t_con->line_size += len;
424 t_con->line_cursor += len;
425
426 for (size_t i = t_con->line_cursor; i < t_con->line_size; i++)
427 telnet_write(connection, "\b", 1);
428
429 return true;
430 }
431
432 static void telnet_delete_character(struct connection *connection)
433 {
434 struct telnet_connection *t_con = connection->priv;
435
436 if (t_con->line_cursor == 0)
437 return;
438
439 if (t_con->line_cursor != t_con->line_size) {
440 size_t i;
441 telnet_write(connection, "\b", 1);
442 t_con->line_cursor--;
443 t_con->line_size--;
444 memmove(t_con->line + t_con->line_cursor,
445 t_con->line + t_con->line_cursor + 1,
446 t_con->line_size -
447 t_con->line_cursor);
448
449 telnet_write(connection,
450 t_con->line + t_con->line_cursor,
451 t_con->line_size -
452 t_con->line_cursor);
453 telnet_write(connection, " \b", 2);
454 for (i = t_con->line_cursor; i < t_con->line_size; i++)
455 telnet_write(connection, "\b", 1);
456 } else {
457 t_con->line_size--;
458 t_con->line_cursor--;
459 /* back space: move the 'printer' head one char
460 * back, overwrite with space, move back again */
461 telnet_write(connection, "\b \b", 3);
462 }
463 }
464
465 static void telnet_remove_character(struct connection *connection)
466 {
467 struct telnet_connection *t_con = connection->priv;
468
469 if (t_con->line_cursor < t_con->line_size) {
470 size_t i;
471 t_con->line_size--;
472 /* remove char from line buffer */
473 memmove(t_con->line + t_con->line_cursor,
474 t_con->line + t_con->line_cursor + 1,
475 t_con->line_size - t_con->line_cursor);
476
477 /* print remainder of buffer */
478 telnet_write(connection, t_con->line + t_con->line_cursor,
479 t_con->line_size - t_con->line_cursor);
480 /* overwrite last char with whitespace */
481 telnet_write(connection, " \b", 2);
482
483 /* move back to cursor position*/
484 for (i = t_con->line_cursor; i < t_con->line_size; i++)
485 telnet_write(connection, "\b", 1);
486 }
487 }
488
489 static int telnet_exec_line(struct connection *connection)
490 {
491 struct telnet_connection *t_con = connection->priv;
492 struct command_context *command_context = connection->cmd_ctx;
493 int retval;
494
495 telnet_write(connection, "\r\n\x00", 3);
496
497 if (strcmp(t_con->line, "history") == 0) {
498 retval = telnet_history_print(connection);
499
500 if (retval != ERROR_OK)
501 return retval;
502
503 return ERROR_OK;
504 }
505
506 telnet_history_add(connection);
507
508 t_con->line_size = 0;
509
510 /* to suppress prompt in log callback during command execution */
511 t_con->prompt_visible = false;
512
513 if (strcmp(t_con->line, "shutdown") == 0)
514 telnet_save_history(t_con);
515
516 retval = command_run_line(command_context, t_con->line);
517
518 t_con->line_cursor = 0;
519 t_con->prompt_visible = true;
520
521 if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
522 return ERROR_SERVER_REMOTE_CLOSED;
523
524 /* the prompt is always placed at the line beginning */
525 telnet_write(connection, "\r", 1);
526
527 retval = telnet_prompt(connection);
528 if (retval == ERROR_SERVER_REMOTE_CLOSED)
529 return ERROR_SERVER_REMOTE_CLOSED;
530
531 return ERROR_OK;
532 }
533
534 static void telnet_cut_line_to_end(struct connection *connection)
535 {
536 struct telnet_connection *t_con = connection->priv;
537
538 /* FIXME: currently this function does not save to clipboard */
539
540 if (t_con->line_cursor < t_con->line_size) {
541 /* overwrite with space, until end of line, move back */
542 for (size_t i = t_con->line_cursor; i < t_con->line_size; i++)
543 telnet_write(connection, " ", 1);
544 for (size_t i = t_con->line_cursor; i < t_con->line_size; i++)
545 telnet_write(connection, "\b", 1);
546 t_con->line[t_con->line_cursor] = '\0';
547 t_con->line_size = t_con->line_cursor;
548 }
549 }
550
551 static void telnet_interrupt(struct connection *connection)
552 {
553 struct telnet_connection *t_con = connection->priv;
554
555 /* print '^C' at line end, and display a new command prompt */
556 telnet_move_cursor(connection, t_con->line_size);
557 telnet_write(connection, "^C\n\r", 4);
558 t_con->line_cursor = 0;
559 t_con->line_size = 0;
560 telnet_prompt(connection);
561 }
562
563 static void telnet_auto_complete(struct connection *connection)
564 {
565 struct telnet_connection *t_con = connection->priv;
566 struct command_context *command_context = connection->cmd_ctx;
567
568 struct cmd_match {
569 char *cmd;
570 struct list_head lh;
571 };
572
573 LIST_HEAD(matches);
574
575 /* - user command sequence, either at line beginning
576 * or we start over after these characters ';', '[', '{'
577 * - user variable sequence, start after the character '$'
578 * and do not contain white spaces */
579 bool is_variable_auto_completion = false;
580 bool have_spaces = false;
581 size_t seq_start = (t_con->line_cursor == 0) ? 0 : (t_con->line_cursor - 1);
582 while (1) {
583 char c = t_con->line[seq_start];
584
585 if (c == ';' || c == '[' || c == '{') {
586 seq_start++;
587 break;
588 } else if (c == ' ') {
589 have_spaces = true;
590 } else if (c == '$' && !have_spaces) {
591 is_variable_auto_completion = true;
592 seq_start++;
593 break;
594 }
595
596 if (seq_start == 0)
597 break;
598
599 seq_start--;
600 }
601
602 /* user command position in the line, ignore leading spaces */
603 size_t usr_cmd_pos = seq_start;
604 while ((usr_cmd_pos < t_con->line_cursor) && isspace(t_con->line[usr_cmd_pos]))
605 usr_cmd_pos++;
606
607 /* check user command length */
608 if (t_con->line_cursor < usr_cmd_pos) {
609 telnet_bell(connection);
610 return;
611 }
612 size_t usr_cmd_len = t_con->line_cursor - usr_cmd_pos;
613
614 /* optimize multiple spaces in the user command,
615 * because info commands does not tolerate multiple spaces */
616 size_t optimized_spaces = 0;
617 char query[usr_cmd_len + 1];
618 for (size_t i = 0; i < usr_cmd_len; i++) {
619 if ((i < usr_cmd_len - 1) && isspace(t_con->line[usr_cmd_pos + i])
620 && isspace(t_con->line[usr_cmd_pos + i + 1])) {
621 optimized_spaces++;
622 continue;
623 }
624
625 query[i - optimized_spaces] = t_con->line[usr_cmd_pos + i];
626 }
627
628 usr_cmd_len -= optimized_spaces;
629 query[usr_cmd_len] = '\0';
630
631 /* filter commands */
632 char *query_cmd;
633
634 if (is_variable_auto_completion)
635 query_cmd = alloc_printf("lsort [info vars {%s*}]", query);
636 else
637 query_cmd = alloc_printf("_telnet_autocomplete_helper {%s*}", query);
638
639 if (!query_cmd) {
640 LOG_ERROR("Out of memory");
641 return;
642 }
643
644 int retval = Jim_EvalSource(command_context->interp, __FILE__, __LINE__, query_cmd);
645 free(query_cmd);
646 if (retval != JIM_OK)
647 return;
648
649 Jim_Obj *list = Jim_GetResult(command_context->interp);
650 Jim_IncrRefCount(list);
651
652 /* common prefix length of the matched commands */
653 size_t common_len = 0;
654 char *first_match = NULL; /* used to compute the common prefix length */
655
656 int len = Jim_ListLength(command_context->interp, list);
657 for (int i = 0; i < len; i++) {
658 Jim_Obj *elem = Jim_ListGetIndex(command_context->interp, list, i);
659 Jim_IncrRefCount(elem);
660
661 char *name = (char *)Jim_GetString(elem, NULL);
662
663 /* validate the command */
664 bool ignore_cmd = false;
665 if (!is_variable_auto_completion) {
666 Jim_Cmd *jim_cmd = Jim_GetCommand(command_context->interp, elem, JIM_NONE);
667
668 if (!jim_cmd) {
669 /* Why we are here? Let's ignore it! */
670 ignore_cmd = true;
671 } else if (jimcmd_is_oocd_command(jim_cmd)) {
672 struct command *cmd = jimcmd_privdata(jim_cmd);
673
674 if (cmd && !cmd->handler && !cmd->jim_handler) {
675 /* Initial part of a multi-word command. Ignore it! */
676 ignore_cmd = true;
677 } else if (cmd && cmd->mode == COMMAND_CONFIG) {
678 /* Not executable after config phase. Ignore it! */
679 ignore_cmd = true;
680 }
681 }
682 }
683
684 /* save the command in the prediction list */
685 if (!ignore_cmd) {
686 struct cmd_match *match = calloc(1, sizeof(struct cmd_match));
687 if (!match) {
688 LOG_ERROR("Out of memory");
689 Jim_DecrRefCount(command_context->interp, elem);
690 break; /* break the for loop */
691 }
692
693 if (list_empty(&matches)) {
694 common_len = strlen(name);
695 first_match = name;
696 } else {
697 size_t new_common_len = usr_cmd_len; /* save some loops */
698
699 while (new_common_len < common_len && first_match[new_common_len] == name[new_common_len])
700 new_common_len++;
701
702 common_len = new_common_len;
703 }
704
705 match->cmd = name;
706 list_add_tail(&match->lh, &matches);
707 }
708
709 Jim_DecrRefCount(command_context->interp, elem);
710 }
711 /* end of command filtering */
712
713 /* proceed with auto-completion */
714 if (list_empty(&matches))
715 telnet_bell(connection);
716 else if (common_len == usr_cmd_len && list_is_singular(&matches) && t_con->line_cursor == t_con->line_size)
717 telnet_insert(connection, " ", 1);
718 else if (common_len > usr_cmd_len) {
719 int completion_size = common_len - usr_cmd_len;
720 if (telnet_insert(connection, first_match + usr_cmd_len, completion_size)) {
721 /* in bash this extra space is only added when the cursor in at the end of line */
722 if (list_is_singular(&matches) && t_con->line_cursor == t_con->line_size)
723 telnet_insert(connection, " ", 1);
724 }
725 } else if (!list_is_singular(&matches)) {
726 telnet_write(connection, "\n\r", 2);
727
728 struct cmd_match *match;
729 list_for_each_entry(match, &matches, lh) {
730 telnet_write(connection, match->cmd, strlen(match->cmd));
731 telnet_write(connection, "\n\r", 2);
732 }
733
734 telnet_prompt(connection);
735 telnet_write(connection, t_con->line, t_con->line_size);
736
737 /* restore the terminal visible cursor location */
738 for (size_t i = t_con->line_cursor; i < t_con->line_size; i++)
739 telnet_write(connection, "\b", 1);
740 }
741
742 /* destroy the command_list */
743 struct cmd_match *tmp, *match;
744 list_for_each_entry_safe(match, tmp, &matches, lh)
745 free(match);
746
747 Jim_DecrRefCount(command_context->interp, list);
748 }
749
750 static int telnet_input(struct connection *connection)
751 {
752 int bytes_read;
753 unsigned char buffer[TELNET_BUFFER_SIZE];
754 unsigned char *buf_p;
755 struct telnet_connection *t_con = connection->priv;
756
757 bytes_read = connection_read(connection, buffer, TELNET_BUFFER_SIZE);
758
759 if (bytes_read == 0)
760 return ERROR_SERVER_REMOTE_CLOSED;
761 else if (bytes_read == -1) {
762 LOG_ERROR("error during read: %s", strerror(errno));
763 return ERROR_SERVER_REMOTE_CLOSED;
764 }
765
766 buf_p = buffer;
767 while (bytes_read) {
768 switch (t_con->state) {
769 case TELNET_STATE_DATA:
770 if (*buf_p == 0xff) {
771 t_con->state = TELNET_STATE_IAC;
772 } else {
773 if (isprint(*buf_p)) { /* printable character */
774 telnet_insert(connection, buf_p, 1);
775 } else { /* non-printable */
776 if (*buf_p == 0x1b) { /* escape */
777 t_con->state = TELNET_STATE_ESCAPE;
778 t_con->last_escape = '\x00';
779 } else if ((*buf_p == 0xd) || (*buf_p == 0xa)) { /* CR/LF */
780 int retval;
781
782 /* skip over combinations with CR/LF and NUL characters */
783 if ((bytes_read > 1) && ((*(buf_p + 1) == 0xa) ||
784 (*(buf_p + 1) == 0xd))) {
785 buf_p++;
786 bytes_read--;
787 }
788 if ((bytes_read > 1) && (*(buf_p + 1) == 0)) {
789 buf_p++;
790 bytes_read--;
791 }
792 t_con->line[t_con->line_size] = 0;
793
794 retval = telnet_exec_line(connection);
795 if (retval != ERROR_OK)
796 return retval;
797 } else if ((*buf_p == 0x7f) || (*buf_p == 0x8)) { /* delete character */
798 telnet_delete_character(connection);
799 } else if (*buf_p == 0x15) { /* clear line */
800 telnet_clear_line(connection, t_con);
801 } else if (*buf_p == CTRL('B')) { /* cursor left */
802 telnet_move_cursor(connection, t_con->line_cursor - 1);
803 t_con->state = TELNET_STATE_DATA;
804 } else if (*buf_p == CTRL('C')) { /* interrupt */
805 telnet_interrupt(connection);
806 } else if (*buf_p == CTRL('F')) { /* cursor right */
807 telnet_move_cursor(connection, t_con->line_cursor + 1);
808 t_con->state = TELNET_STATE_DATA;
809 } else if (*buf_p == CTRL('P')) { /* cursor up */
810 telnet_history_up(connection);
811 } else if (*buf_p == CTRL('N')) { /* cursor down */
812 telnet_history_down(connection);
813 } else if (*buf_p == CTRL('A')) { /* move the cursor to the beginning of the line */
814 telnet_move_cursor(connection, 0);
815 } else if (*buf_p == CTRL('E')) { /* move the cursor to the end of the line */
816 telnet_move_cursor(connection, t_con->line_size);
817 } else if (*buf_p == CTRL('K')) { /* kill line to end */
818 telnet_cut_line_to_end(connection);
819 } else if (*buf_p == '\t') {
820 telnet_auto_complete(connection);
821 } else {
822 LOG_DEBUG("unhandled nonprintable: %2.2x", *buf_p);
823 }
824 }
825 }
826 break;
827 case TELNET_STATE_IAC:
828 switch (*buf_p) {
829 case 0xfe:
830 t_con->state = TELNET_STATE_DONT;
831 break;
832 case 0xfd:
833 t_con->state = TELNET_STATE_DO;
834 break;
835 case 0xfc:
836 t_con->state = TELNET_STATE_WONT;
837 break;
838 case 0xfb:
839 t_con->state = TELNET_STATE_WILL;
840 break;
841 }
842 break;
843 case TELNET_STATE_SB:
844 break;
845 case TELNET_STATE_SE:
846 break;
847 case TELNET_STATE_WILL:
848 case TELNET_STATE_WONT:
849 case TELNET_STATE_DO:
850 case TELNET_STATE_DONT:
851 t_con->state = TELNET_STATE_DATA;
852 break;
853 case TELNET_STATE_ESCAPE:
854 if (t_con->last_escape == '[') {
855 if (*buf_p == 'D') { /* cursor left */
856 telnet_move_cursor(connection, t_con->line_cursor - 1);
857 t_con->state = TELNET_STATE_DATA;
858 } else if (*buf_p == 'C') { /* cursor right */
859 telnet_move_cursor(connection, t_con->line_cursor + 1);
860 t_con->state = TELNET_STATE_DATA;
861 } else if (*buf_p == 'A') { /* cursor up */
862 telnet_history_up(connection);
863 } else if (*buf_p == 'B') { /* cursor down */
864 telnet_history_down(connection);
865 } else if (*buf_p == 'F') { /* end key */
866 telnet_move_cursor(connection, t_con->line_size);
867 t_con->state = TELNET_STATE_DATA;
868 } else if (*buf_p == 'H') { /* home key */
869 telnet_move_cursor(connection, 0);
870 t_con->state = TELNET_STATE_DATA;
871 } else if (*buf_p == '3') {
872 t_con->last_escape = *buf_p;
873 } else {
874 t_con->state = TELNET_STATE_DATA;
875 }
876 } else if (t_con->last_escape == '3') {
877 /* Remove character */
878 if (*buf_p == '~') {
879 telnet_remove_character(connection);
880 t_con->state = TELNET_STATE_DATA;
881 } else
882 t_con->state = TELNET_STATE_DATA;
883 } else if (t_con->last_escape == '\x00') {
884 if (*buf_p == '[')
885 t_con->last_escape = *buf_p;
886 else
887 t_con->state = TELNET_STATE_DATA;
888 } else {
889 LOG_ERROR("BUG: unexpected value in t_con->last_escape");
890 t_con->state = TELNET_STATE_DATA;
891 }
892
893 break;
894 default:
895 LOG_ERROR("unknown telnet state");
896 return ERROR_FAIL;
897 }
898
899 bytes_read--;
900 buf_p++;
901 }
902
903 return ERROR_OK;
904 }
905
906 static int telnet_connection_closed(struct connection *connection)
907 {
908 struct telnet_connection *t_con = connection->priv;
909 int i;
910
911 log_remove_callback(telnet_log_callback, connection);
912
913 free(t_con->prompt);
914 t_con->prompt = NULL;
915
916 /* save telnet history */
917 telnet_save_history(t_con);
918
919 for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++) {
920 free(t_con->history[i]);
921 t_con->history[i] = NULL;
922 }
923
924 /* if this connection registered a debug-message receiver delete it */
925 delete_debug_msg_receiver(connection->cmd_ctx, NULL);
926
927 free(connection->priv);
928 connection->priv = NULL;
929
930 return ERROR_OK;
931 }
932
933 static const struct service_driver telnet_service_driver = {
934 .name = "telnet",
935 .new_connection_during_keep_alive_handler = NULL,
936 .new_connection_handler = telnet_new_connection,
937 .input_handler = telnet_input,
938 .connection_closed_handler = telnet_connection_closed,
939 .keep_client_alive_handler = NULL,
940 };
941
942 int telnet_init(char *banner)
943 {
944 if (strcmp(telnet_port, "disabled") == 0) {
945 LOG_INFO("telnet server disabled");
946 return ERROR_OK;
947 }
948
949 struct telnet_service *telnet_service =
950 malloc(sizeof(struct telnet_service));
951
952 if (!telnet_service) {
953 LOG_ERROR("Failed to allocate telnet service.");
954 return ERROR_FAIL;
955 }
956
957 telnet_service->banner = banner;
958
959 int ret = add_service(&telnet_service_driver, telnet_port, CONNECTION_LIMIT_UNLIMITED,
960 telnet_service);
961
962 if (ret != ERROR_OK) {
963 free(telnet_service);
964 return ret;
965 }
966
967 return ERROR_OK;
968 }
969
970 /* daemon configuration command telnet_port */
971 COMMAND_HANDLER(handle_telnet_port_command)
972 {
973 return CALL_COMMAND_HANDLER(server_pipe_command, &telnet_port);
974 }
975
976 COMMAND_HANDLER(handle_exit_command)
977 {
978 return ERROR_COMMAND_CLOSE_CONNECTION;
979 }
980
981 static const struct command_registration telnet_command_handlers[] = {
982 {
983 .name = "exit",
984 .handler = handle_exit_command,
985 .mode = COMMAND_EXEC,
986 .usage = "",
987 .help = "exit telnet session",
988 },
989 {
990 .name = "telnet_port",
991 .handler = handle_telnet_port_command,
992 .mode = COMMAND_CONFIG,
993 .help = "Specify port on which to listen "
994 "for incoming telnet connections. "
995 "Read help on 'gdb_port'.",
996 .usage = "[port_num]",
997 },
998 COMMAND_REGISTRATION_DONE
999 };
1000
1001 int telnet_register_commands(struct command_context *cmd_ctx)
1002 {
1003 telnet_port = strdup("4444");
1004 return register_commands(cmd_ctx, NULL, telnet_command_handlers);
1005 }
1006
1007 void telnet_service_free(void)
1008 {
1009 free(telnet_port);
1010 }
Official OpenOCD Mirror