1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007-2010 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
23 ***************************************************************************/
29 #include "telnet_server.h"
30 #include <target/target_request.h>
31 #include <helper/configuration.h>
33 static char *telnet_port
;
35 static char *negotiate
=
36 "\xFF\xFB\x03" /* IAC WILL Suppress Go Ahead */
37 "\xFF\xFB\x01" /* IAC WILL Echo */
38 "\xFF\xFD\x03" /* IAC DO Suppress Go Ahead */
39 "\xFF\xFE\x01"; /* IAC DON'T Echo */
41 #define CTRL(c) (c - '@')
42 #define TELNET_HISTORY ".openocd_history"
44 /* The only way we can detect that the socket is closed is the first time
45 * we write to it, we will fail. Subsequent write operations will
48 static int telnet_write(struct connection
*connection
, const void *data
,
51 struct telnet_connection
*t_con
= connection
->priv
;
53 return ERROR_SERVER_REMOTE_CLOSED
;
55 if (connection_write(connection
, data
, len
) == len
)
58 return ERROR_SERVER_REMOTE_CLOSED
;
61 static int telnet_prompt(struct connection
*connection
)
63 struct telnet_connection
*t_con
= connection
->priv
;
65 return telnet_write(connection
, t_con
->prompt
, strlen(t_con
->prompt
));
68 static int telnet_outputline(struct connection
*connection
, const char *line
)
72 /* process lines in buffer */
74 char *line_end
= strchr(line
, '\n');
81 telnet_write(connection
, line
, len
);
83 telnet_write(connection
, "\r\n", 2);
92 static int telnet_output(struct command_context
*cmd_ctx
, const char *line
)
94 struct connection
*connection
= cmd_ctx
->output_handler_priv
;
96 return telnet_outputline(connection
, line
);
99 static void telnet_log_callback(void *priv
, const char *file
, unsigned line
,
100 const char *function
, const char *string
)
102 struct connection
*connection
= priv
;
103 struct telnet_connection
*t_con
= connection
->priv
;
107 /* If the prompt is not visible, simply output the message. */
108 if (!t_con
->prompt_visible
) {
109 telnet_outputline(connection
, string
);
113 /* Clear the command line. */
114 tmp
= strlen(t_con
->prompt
) + t_con
->line_size
;
116 for (i
= 0; i
< tmp
; i
+= 16)
117 telnet_write(connection
, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
120 for (i
= 0; i
< tmp
; i
+= 16)
121 telnet_write(connection
, " ", MIN(tmp
- i
, 16));
123 for (i
= 0; i
< tmp
; i
+= 16)
124 telnet_write(connection
, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
127 telnet_outputline(connection
, string
);
129 /* Put the command line to its previous state. */
130 telnet_prompt(connection
);
131 telnet_write(connection
, t_con
->line
, t_con
->line_size
);
133 for (i
= t_con
->line_cursor
; i
< t_con
->line_size
; i
++)
134 telnet_write(connection
, "\b", 1);
137 static void telnet_load_history(struct telnet_connection
*t_con
)
140 char buffer
[TELNET_BUFFER_SIZE
];
143 char *history
= get_home_dir(TELNET_HISTORY
);
145 if (history
== NULL
) {
146 LOG_INFO("unable to get user home directory, telnet history will be disabled");
150 histfp
= fopen(history
, "rb");
154 while (fgets(buffer
, sizeof(buffer
), histfp
) != NULL
) {
156 char *p
= strchr(buffer
, '\n');
159 if (buffer
[0] && i
< TELNET_LINE_HISTORY_SIZE
)
160 t_con
->history
[i
++] = strdup(buffer
);
163 t_con
->next_history
= i
;
164 t_con
->next_history
%= TELNET_LINE_HISTORY_SIZE
;
165 /* try to set to last entry - 1, that way we skip over any exit/shutdown cmds */
166 t_con
->current_history
= t_con
->next_history
> 0 ? i
- 1 : 0;
173 static void telnet_save_history(struct telnet_connection
*t_con
)
179 char *history
= get_home_dir(TELNET_HISTORY
);
181 if (history
== NULL
) {
182 LOG_INFO("unable to get user home directory, telnet history will be disabled");
186 histfp
= fopen(history
, "wb");
190 num
= TELNET_LINE_HISTORY_SIZE
;
191 i
= t_con
->current_history
+ 1;
192 i
%= TELNET_LINE_HISTORY_SIZE
;
194 while (t_con
->history
[i
] == NULL
&& num
> 0) {
196 i
%= TELNET_LINE_HISTORY_SIZE
;
201 for (; num
> 0; num
--) {
202 fprintf(histfp
, "%s\n", t_con
->history
[i
]);
204 i
%= TELNET_LINE_HISTORY_SIZE
;
213 static int telnet_new_connection(struct connection
*connection
)
215 struct telnet_connection
*telnet_connection
;
216 struct telnet_service
*telnet_service
= connection
->service
->priv
;
219 telnet_connection
= malloc(sizeof(struct telnet_connection
));
221 if (!telnet_connection
) {
222 LOG_ERROR("Failed to allocate telnet connection.");
226 connection
->priv
= telnet_connection
;
228 /* initialize telnet connection information */
229 telnet_connection
->closed
= false;
230 telnet_connection
->line_size
= 0;
231 telnet_connection
->line_cursor
= 0;
232 telnet_connection
->prompt
= strdup("> ");
233 telnet_connection
->prompt_visible
= true;
234 telnet_connection
->state
= TELNET_STATE_DATA
;
236 /* output goes through telnet connection */
237 command_set_output_handler(connection
->cmd_ctx
, telnet_output
, connection
);
239 /* negotiate telnet options */
240 telnet_write(connection
, negotiate
, strlen(negotiate
));
242 /* print connection banner */
243 if (telnet_service
->banner
) {
244 telnet_write(connection
, telnet_service
->banner
, strlen(telnet_service
->banner
));
245 telnet_write(connection
, "\r\n", 2);
248 /* the prompt is always placed at the line beginning */
249 telnet_write(connection
, "\r", 1);
250 telnet_prompt(connection
);
252 /* initialize history */
253 for (i
= 0; i
< TELNET_LINE_HISTORY_SIZE
; i
++)
254 telnet_connection
->history
[i
] = NULL
;
255 telnet_connection
->next_history
= 0;
256 telnet_connection
->current_history
= 0;
257 telnet_load_history(telnet_connection
);
259 log_add_callback(telnet_log_callback
, connection
);
264 static void telnet_clear_line(struct connection
*connection
,
265 struct telnet_connection
*t_con
)
267 /* move to end of line */
268 if (t_con
->line_cursor
< t_con
->line_size
)
269 telnet_write(connection
,
270 t_con
->line
+ t_con
->line_cursor
,
271 t_con
->line_size
- t_con
->line_cursor
);
273 /* backspace, overwrite with space, backspace */
274 while (t_con
->line_size
> 0) {
275 telnet_write(connection
, "\b \b", 3);
278 t_con
->line_cursor
= 0;
281 static void telnet_history_go(struct connection
*connection
, int idx
)
283 struct telnet_connection
*t_con
= connection
->priv
;
285 if (t_con
->history
[idx
]) {
286 telnet_clear_line(connection
, t_con
);
287 t_con
->line_size
= strlen(t_con
->history
[idx
]);
288 t_con
->line_cursor
= t_con
->line_size
;
289 memcpy(t_con
->line
, t_con
->history
[idx
], t_con
->line_size
);
290 telnet_write(connection
, t_con
->line
, t_con
->line_size
);
291 t_con
->current_history
= idx
;
293 t_con
->state
= TELNET_STATE_DATA
;
296 static void telnet_history_up(struct connection
*connection
)
298 struct telnet_connection
*t_con
= connection
->priv
;
300 size_t last_history
= (t_con
->current_history
> 0) ?
301 t_con
->current_history
- 1 :
302 TELNET_LINE_HISTORY_SIZE
-1;
303 telnet_history_go(connection
, last_history
);
306 static void telnet_history_down(struct connection
*connection
)
308 struct telnet_connection
*t_con
= connection
->priv
;
311 next_history
= (t_con
->current_history
+ 1) % TELNET_LINE_HISTORY_SIZE
;
312 telnet_history_go(connection
, next_history
);
315 static int telnet_history_print(struct connection
*connection
)
317 struct telnet_connection
*tc
;
319 tc
= connection
->priv
;
321 for (size_t i
= 1; i
< TELNET_LINE_HISTORY_SIZE
; i
++) {
325 * The tc->next_history line contains empty string (unless NULL), thus
328 line
= tc
->history
[(tc
->next_history
+ i
) % TELNET_LINE_HISTORY_SIZE
];
331 telnet_write(connection
, line
, strlen(line
));
332 telnet_write(connection
, "\r\n\x00", 3);
339 /* The prompt is always placed at the line beginning. */
340 telnet_write(connection
, "\r", 1);
342 return telnet_prompt(connection
);
345 static void telnet_move_cursor(struct connection
*connection
, size_t pos
)
347 struct telnet_connection
*tc
;
350 tc
= connection
->priv
;
352 if (pos
< tc
->line_cursor
) {
353 tmp
= tc
->line_cursor
- pos
;
355 for (size_t i
= 0; i
< tmp
; i
+= 16)
356 telnet_write(connection
, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
359 tmp
= pos
- tc
->line_cursor
;
361 for (size_t i
= 0; i
< tmp
; i
+= 16)
362 telnet_write(connection
, tc
->line
+ tc
->line_cursor
+ i
,
366 tc
->line_cursor
= pos
;
369 static int telnet_input(struct connection
*connection
)
372 unsigned char buffer
[TELNET_BUFFER_SIZE
];
373 unsigned char *buf_p
;
374 struct telnet_connection
*t_con
= connection
->priv
;
375 struct command_context
*command_context
= connection
->cmd_ctx
;
377 bytes_read
= connection_read(connection
, buffer
, TELNET_BUFFER_SIZE
);
380 return ERROR_SERVER_REMOTE_CLOSED
;
381 else if (bytes_read
== -1) {
382 LOG_ERROR("error during read: %s", strerror(errno
));
383 return ERROR_SERVER_REMOTE_CLOSED
;
388 switch (t_con
->state
) {
389 case TELNET_STATE_DATA
:
391 t_con
->state
= TELNET_STATE_IAC
;
393 if (isprint(*buf_p
)) { /* printable character */
394 /* watch buffer size leaving one spare character for
395 * string null termination */
396 if (t_con
->line_size
== TELNET_LINE_MAX_SIZE
-1) {
397 /* output audible bell if buffer is full
398 * "\a" does not work, at least on windows */
399 telnet_write(connection
, "\x07", 1);
400 } else if (t_con
->line_cursor
== t_con
->line_size
) {
401 telnet_write(connection
, buf_p
, 1);
402 t_con
->line
[t_con
->line_size
++] = *buf_p
;
403 t_con
->line_cursor
++;
406 memmove(t_con
->line
+ t_con
->line_cursor
+ 1,
407 t_con
->line
+ t_con
->line_cursor
,
408 t_con
->line_size
- t_con
->line_cursor
);
409 t_con
->line
[t_con
->line_cursor
] = *buf_p
;
411 telnet_write(connection
,
412 t_con
->line
+ t_con
->line_cursor
,
413 t_con
->line_size
- t_con
->line_cursor
);
414 t_con
->line_cursor
++;
415 for (i
= t_con
->line_cursor
; i
< t_con
->line_size
; i
++)
416 telnet_write(connection
, "\b", 1);
418 } else { /* non-printable */
419 if (*buf_p
== 0x1b) { /* escape */
420 t_con
->state
= TELNET_STATE_ESCAPE
;
421 t_con
->last_escape
= '\x00';
422 } else if ((*buf_p
== 0xd) || (*buf_p
== 0xa)) { /* CR/LF */
425 /* skip over combinations with CR/LF and NUL characters */
426 if ((bytes_read
> 1) && ((*(buf_p
+ 1) == 0xa) ||
427 (*(buf_p
+ 1) == 0xd))) {
431 if ((bytes_read
> 1) && (*(buf_p
+ 1) == 0)) {
435 t_con
->line
[t_con
->line_size
] = 0;
437 telnet_write(connection
, "\r\n\x00", 3);
439 if (strcmp(t_con
->line
, "history") == 0) {
440 retval
= telnet_history_print(connection
);
442 if (retval
!= ERROR_OK
)
448 /* save only non-blank not repeating lines in the history */
449 char *prev_line
= t_con
->history
[(t_con
->current_history
> 0) ?
450 t_con
->current_history
- 1 : TELNET_LINE_HISTORY_SIZE
-1];
451 if (*t_con
->line
&& (prev_line
== NULL
||
452 strcmp(t_con
->line
, prev_line
))) {
453 /* if the history slot is already taken, free it */
454 free(t_con
->history
[t_con
->next_history
]);
456 /* add line to history */
457 t_con
->history
[t_con
->next_history
] = strdup(t_con
->line
);
459 /* wrap history at TELNET_LINE_HISTORY_SIZE */
460 t_con
->next_history
= (t_con
->next_history
+ 1) %
461 TELNET_LINE_HISTORY_SIZE
;
463 /* current history line starts at the new entry */
464 t_con
->current_history
=
467 free(t_con
->history
[t_con
->current_history
]);
468 t_con
->history
[t_con
->current_history
] = strdup("");
471 t_con
->line_size
= 0;
473 /* to suppress prompt in log callback during command execution */
474 t_con
->prompt_visible
= false;
476 if (strcmp(t_con
->line
, "shutdown") == 0)
477 telnet_save_history(t_con
);
479 retval
= command_run_line(command_context
, t_con
->line
);
481 t_con
->line_cursor
= 0;
482 t_con
->prompt_visible
= true;
484 if (retval
== ERROR_COMMAND_CLOSE_CONNECTION
)
485 return ERROR_SERVER_REMOTE_CLOSED
;
487 /* the prompt is always * placed at the line beginning */
488 telnet_write(connection
, "\r", 1);
490 retval
= telnet_prompt(connection
);
491 if (retval
== ERROR_SERVER_REMOTE_CLOSED
)
492 return ERROR_SERVER_REMOTE_CLOSED
;
494 } else if ((*buf_p
== 0x7f) || (*buf_p
== 0x8)) { /* delete character */
495 if (t_con
->line_cursor
> 0) {
496 if (t_con
->line_cursor
!= t_con
->line_size
) {
498 telnet_write(connection
, "\b", 1);
499 t_con
->line_cursor
--;
501 memmove(t_con
->line
+ t_con
->line_cursor
,
502 t_con
->line
+ t_con
->line_cursor
+ 1,
506 telnet_write(connection
,
507 t_con
->line
+ t_con
->line_cursor
,
510 telnet_write(connection
, " \b", 2);
511 for (i
= t_con
->line_cursor
; i
< t_con
->line_size
; i
++)
512 telnet_write(connection
, "\b", 1);
515 t_con
->line_cursor
--;
516 /* back space: move the 'printer' head one char
517 * back, overwrite with space, move back again */
518 telnet_write(connection
, "\b \b", 3);
521 } else if (*buf_p
== 0x15) /* clear line */
522 telnet_clear_line(connection
, t_con
);
523 else if (*buf_p
== CTRL('B')) { /* cursor left */
524 if (t_con
->line_cursor
> 0) {
525 telnet_write(connection
, "\b", 1);
526 t_con
->line_cursor
--;
528 t_con
->state
= TELNET_STATE_DATA
;
529 } else if (*buf_p
== CTRL('F')) { /* cursor right */
530 if (t_con
->line_cursor
< t_con
->line_size
)
531 telnet_write(connection
, t_con
->line
+ t_con
->line_cursor
++, 1);
532 t_con
->state
= TELNET_STATE_DATA
;
533 } else if (*buf_p
== CTRL('P')) /* cursor up */
534 telnet_history_up(connection
);
535 else if (*buf_p
== CTRL('N')) /* cursor down */
536 telnet_history_down(connection
);
537 else if (*buf_p
== CTRL('A'))
538 telnet_move_cursor(connection
, 0);
539 else if (*buf_p
== CTRL('E'))
540 telnet_move_cursor(connection
, t_con
->line_size
);
541 else if (*buf_p
== CTRL('K')) { /* kill line to end */
542 if (t_con
->line_cursor
< t_con
->line_size
) {
543 /* overwrite with space, until end of line, move back */
544 for (size_t i
= t_con
->line_cursor
; i
< t_con
->line_size
; i
++)
545 telnet_write(connection
, " ", 1);
546 for (size_t i
= t_con
->line_cursor
; i
< t_con
->line_size
; i
++)
547 telnet_write(connection
, "\b", 1);
548 t_con
->line
[t_con
->line_cursor
] = '\0';
549 t_con
->line_size
= t_con
->line_cursor
;
552 LOG_DEBUG("unhandled nonprintable: %2.2x", *buf_p
);
556 case TELNET_STATE_IAC
:
559 t_con
->state
= TELNET_STATE_DONT
;
562 t_con
->state
= TELNET_STATE_DO
;
565 t_con
->state
= TELNET_STATE_WONT
;
568 t_con
->state
= TELNET_STATE_WILL
;
572 case TELNET_STATE_SB
:
574 case TELNET_STATE_SE
:
576 case TELNET_STATE_WILL
:
577 case TELNET_STATE_WONT
:
578 case TELNET_STATE_DO
:
579 case TELNET_STATE_DONT
:
580 t_con
->state
= TELNET_STATE_DATA
;
582 case TELNET_STATE_ESCAPE
:
583 if (t_con
->last_escape
== '[') {
584 if (*buf_p
== 'D') { /* cursor left */
585 if (t_con
->line_cursor
> 0) {
586 telnet_write(connection
, "\b", 1);
587 t_con
->line_cursor
--;
589 t_con
->state
= TELNET_STATE_DATA
;
590 } else if (*buf_p
== 'C') { /* cursor right */
591 if (t_con
->line_cursor
< t_con
->line_size
)
592 telnet_write(connection
,
593 t_con
->line
+ t_con
->line_cursor
++, 1);
594 t_con
->state
= TELNET_STATE_DATA
;
595 } else if (*buf_p
== 'A') { /* cursor up */
596 telnet_history_up(connection
);
597 } else if (*buf_p
== 'B') { /* cursor down */
598 telnet_history_down(connection
);
599 } else if (*buf_p
== '3')
600 t_con
->last_escape
= *buf_p
;
602 t_con
->state
= TELNET_STATE_DATA
;
603 } else if (t_con
->last_escape
== '3') {
604 /* Remove character */
606 if (t_con
->line_cursor
< t_con
->line_size
) {
609 /* remove char from line buffer */
610 memmove(t_con
->line
+ t_con
->line_cursor
,
611 t_con
->line
+ t_con
->line_cursor
+ 1,
612 t_con
->line_size
- t_con
->line_cursor
);
614 /* print remainder of buffer */
615 telnet_write(connection
, t_con
->line
+ t_con
->line_cursor
,
616 t_con
->line_size
- t_con
->line_cursor
);
617 /* overwrite last char with whitespace */
618 telnet_write(connection
, " \b", 2);
620 /* move back to cursor position*/
621 for (i
= t_con
->line_cursor
; i
< t_con
->line_size
; i
++)
622 telnet_write(connection
, "\b", 1);
625 t_con
->state
= TELNET_STATE_DATA
;
627 t_con
->state
= TELNET_STATE_DATA
;
628 } else if (t_con
->last_escape
== '\x00') {
630 t_con
->last_escape
= *buf_p
;
632 t_con
->state
= TELNET_STATE_DATA
;
634 LOG_ERROR("BUG: unexpected value in t_con->last_escape");
635 t_con
->state
= TELNET_STATE_DATA
;
640 LOG_ERROR("unknown telnet state");
651 static int telnet_connection_closed(struct connection
*connection
)
653 struct telnet_connection
*t_con
= connection
->priv
;
656 log_remove_callback(telnet_log_callback
, connection
);
659 t_con
->prompt
= NULL
;
661 /* save telnet history */
662 telnet_save_history(t_con
);
664 for (i
= 0; i
< TELNET_LINE_HISTORY_SIZE
; i
++) {
665 free(t_con
->history
[i
]);
666 t_con
->history
[i
] = NULL
;
669 /* if this connection registered a debug-message receiver delete it */
670 delete_debug_msg_receiver(connection
->cmd_ctx
, NULL
);
672 free(connection
->priv
);
673 connection
->priv
= NULL
;
678 int telnet_init(char *banner
)
680 if (strcmp(telnet_port
, "disabled") == 0) {
681 LOG_INFO("telnet server disabled");
685 struct telnet_service
*telnet_service
=
686 malloc(sizeof(struct telnet_service
));
688 if (!telnet_service
) {
689 LOG_ERROR("Failed to allocate telnet service.");
693 telnet_service
->banner
= banner
;
695 int ret
= add_service("telnet", telnet_port
, CONNECTION_LIMIT_UNLIMITED
,
696 telnet_new_connection
, telnet_input
, telnet_connection_closed
,
699 if (ret
!= ERROR_OK
) {
700 free(telnet_service
);
707 /* daemon configuration command telnet_port */
708 COMMAND_HANDLER(handle_telnet_port_command
)
710 return CALL_COMMAND_HANDLER(server_pipe_command
, &telnet_port
);
713 COMMAND_HANDLER(handle_exit_command
)
715 return ERROR_COMMAND_CLOSE_CONNECTION
;
718 static const struct command_registration telnet_command_handlers
[] = {
721 .handler
= handle_exit_command
,
722 .mode
= COMMAND_EXEC
,
724 .help
= "exit telnet session",
727 .name
= "telnet_port",
728 .handler
= handle_telnet_port_command
,
729 .mode
= COMMAND_CONFIG
,
730 .help
= "Specify port on which to listen "
731 "for incoming telnet connections. "
732 "Read help on 'gdb_port'.",
733 .usage
= "[port_num]",
735 COMMAND_REGISTRATION_DONE
738 int telnet_register_commands(struct command_context
*cmd_ctx
)
740 telnet_port
= strdup("4444");
741 return register_commands(cmd_ctx
, NULL
, telnet_command_handlers
);
744 void telnet_service_free(void)
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)