- rename log functions to stop conflicts under win32 (wingdi)
[openocd.git] / src / server / telnet_server.c
index 96bbe1d2632d47734fed0e27664c038b30193595..fc3f2116a46d162a3390ac819eca3611e1f26b8f 100644 (file)
@@ -47,9 +47,9 @@ static char *negotiate =
                "\xFF\xFB\x01"          /* IAC WILL Echo */
                "\xFF\xFD\x03"          /* IAC DO Suppress Go Ahead */
                "\xFF\xFE\x01";         /* IAC DON'T Echo */
-               
+
 #define CTRL(c) (c - '@')
-       
+
 /* The only way we can detect that the socket is closed is the first time
  * we write to it, we will fail. Subsequent write operations will
  * succeed. Shudder!
@@ -72,17 +72,18 @@ int telnet_prompt(connection_t *connection)
 {
        telnet_connection_t *t_con = connection->priv;
 
+       telnet_write(connection, "\r", 1); /* the prompt is always placed at the line beginning */
        return telnet_write(connection, t_con->prompt, strlen(t_con->prompt));
 }
 
 int telnet_outputline(connection_t *connection, const char *line)
 {
        int len;
-       
+
        /* process lines in buffer */
        while (*line) {
                char *line_end = strchr(line, '\n');
-               
+
                if (line_end)
                        len = line_end-line;
                else
@@ -99,27 +100,45 @@ int telnet_outputline(connection_t *connection, const char *line)
                        line += len;
                }
        }
-       
+
        return ERROR_OK;
 }
 
 int telnet_output(struct command_context_s *cmd_ctx, char* line)
 {
        connection_t *connection = cmd_ctx->output_handler_priv;
-       
+
        return telnet_outputline(connection, line);
 }
 
-void telnet_log_callback(void *priv, const char *file, int line, 
+void telnet_log_callback(void *priv, const char *file, int line,
                const char *function, const char *string)
 {
        connection_t *connection = priv;
-       
-       telnet_write(connection, "\b\b  \b\b", strlen("\b\b  \b\b"));
+       telnet_connection_t *t_con = connection->priv;
+       int i;
+
+       /* if there is no prompt, simply output the message */
+       if (t_con->line_cursor < 0)
+       {
+               telnet_outputline(connection, string);
+               return;
+       }
+
+       /* clear the command line */
+       telnet_write(connection, "\r", 1);
+       for (i = strlen(t_con->prompt) + t_con->line_size; i>0; i-=16)
+               telnet_write(connection, "                ", i>16 ? 16 : i);
+       telnet_write(connection, "\r", 1);
 
+       /* output the message */
        telnet_outputline(connection, string);
-       
+
+       /* put the command line to its previous state */
        telnet_prompt(connection);
+       telnet_write(connection, t_con->line, t_con->line_size);
+       for (i=t_con->line_size; i>t_con->line_cursor; i--)
+               telnet_write(connection, "\b", 1);
 }
 
 int telnet_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
@@ -141,9 +160,9 @@ int telnet_new_connection(connection_t *connection)
        telnet_connection_t *telnet_connection = malloc(sizeof(telnet_connection_t));
        telnet_service_t *telnet_service = connection->service->priv;
        int i;
-       
+
        connection->priv = telnet_connection;
-       
+
        /* initialize telnet connection information */
        telnet_connection->closed = 0;
        telnet_connection->line_size = 0;
@@ -151,22 +170,22 @@ int telnet_new_connection(connection_t *connection)
        telnet_connection->option_size = 0;
        telnet_connection->prompt = strdup("> ");
        telnet_connection->state = TELNET_STATE_DATA;
-       
+
        /* output goes through telnet connection */
        command_set_output_handler(connection->cmd_ctx, telnet_output, connection);
-       
+
        /* negotiate telnet options */
        telnet_write(connection, negotiate, strlen(negotiate));
-       
+
        /* print connection banner */
        if (telnet_service->banner)
        {
                telnet_write(connection, telnet_service->banner, strlen(telnet_service->banner));
                telnet_write(connection, "\r\n\0", 3);
        }
-       
+
        telnet_prompt(connection);
-       
+
        /* initialize history */
        for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++)
        {
@@ -176,11 +195,11 @@ int telnet_new_connection(connection_t *connection)
        telnet_connection->current_history = 0;
 
        target_register_event_callback(telnet_target_callback_event_handler, connection->cmd_ctx);
-       
+
        log_add_callback(telnet_log_callback, connection);
 
 
-       
+
        return ERROR_OK;
 }
 
@@ -208,17 +227,17 @@ int telnet_input(connection_t *connection)
        char *buf_p;
        telnet_connection_t *t_con = connection->priv;
        command_context_t *command_context = connection->cmd_ctx;
-       
+
        bytes_read = read_socket(connection->fd, buffer, TELNET_BUFFER_SIZE);
-       
+
        if (bytes_read == 0)
                return ERROR_SERVER_REMOTE_CLOSED;
        else if (bytes_read == -1)
        {
-               ERROR("error during read: %s", strerror(errno));
+               LOG_ERROR("error during read: %s", strerror(errno));
                return ERROR_SERVER_REMOTE_CLOSED;
        }
-       
+
        buf_p = buffer;
        while (bytes_read)
        {
@@ -233,9 +252,15 @@ int telnet_input(connection_t *connection)
                                {
                                        if (isprint(*buf_p)) /* printable character */
                                        {
-                                               telnet_write(connection, buf_p, 1);
-                                               if (t_con->line_cursor == t_con->line_size)
+                                               /* watch buffer size leaving one spare character for string null termination */
+                                               if (t_con->line_size == TELNET_LINE_MAX_SIZE-1)
+                                               {
+                                                       /* output audible bell if buffer is full */
+                                                       telnet_write(connection, "\x07", 1); /* "\a" does not work, at least on windows */
+                                               }
+                                               else if (t_con->line_cursor == t_con->line_size)
                                                {
+                                                       telnet_write(connection, buf_p, 1);
                                                        t_con->line[t_con->line_size++] = *buf_p;
                                                        t_con->line_cursor++;
                                                }
@@ -243,9 +268,10 @@ int telnet_input(connection_t *connection)
                                                {
                                                        int i;
                                                        memmove(t_con->line + t_con->line_cursor + 1, t_con->line + t_con->line_cursor, t_con->line_size - t_con->line_cursor);
-                                                       t_con->line[t_con->line_cursor++] = *buf_p;
+                                                       t_con->line[t_con->line_cursor] = *buf_p;
                                                        t_con->line_size++;
                                                        telnet_write(connection, t_con->line + t_con->line_cursor, t_con->line_size - t_con->line_cursor);
+                                                       t_con->line_cursor++;
                                                        for (i = t_con->line_cursor; i < t_con->line_size; i++)
                                                        {
                                                                telnet_write(connection, "\b", 1);
@@ -262,77 +288,79 @@ int telnet_input(connection_t *connection)
                                                else if ((*buf_p == 0xd) || (*buf_p == 0xa)) /* CR/LF */
                                                {
                                                        int retval;
-                                                       
-                                                       /* skip over combinations with CR/LF + NUL */
-                                                       if (((*(buf_p + 1) == 0xa) || (*(buf_p + 1) == 0xd)) && (bytes_read > 1))
+
+                                                       /* skip over combinations with CR/LF and NUL characters */
+                                                       if ((bytes_read > 1) && ((*(buf_p + 1) == 0xa) || (*(buf_p + 1) == 0xd)))
                                                        {
                                                                buf_p++;
                                                                bytes_read--;
                                                        }
-                                                       if ((*(buf_p + 1) == 0) && (bytes_read > 1))
+                                                       if ((bytes_read > 1) && (*(buf_p + 1) == 0))
                                                        {
                                                                buf_p++;
                                                                bytes_read--;
                                                        }
                                                        t_con->line[t_con->line_size] = 0;
-                                                       
+
                                                        telnet_write(connection, "\r\n\x00", 3);
-                                                       
+
                                                        if (strcmp(t_con->line, "history") == 0)
                                                        {
                                                                int i;
-                                                               for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++)
+                                                               for (i = 1; i < TELNET_LINE_HISTORY_SIZE; i++)
                                                                {
-                                                                       if (t_con->history[i])
+                                                                       /* the t_con->next_history line contains empty string (unless NULL), thus it is not printed */
+                                                                       char *history_line = t_con->history[(t_con->next_history + i) % TELNET_LINE_HISTORY_SIZE];
+                                                                       if (history_line)
                                                                        {
-                                                                               telnet_write(connection, t_con->history[i], strlen(t_con->history[i]));
+                                                                               telnet_write(connection, history_line, strlen(history_line));
                                                                                telnet_write(connection, "\r\n\x00", 3);
                                                                        }
                                                                }
-                                                               telnet_prompt(connection);
                                                                t_con->line_size = 0;
                                                                t_con->line_cursor = 0;
                                                                continue;
                                                        }
-                                                       
-                                                       retval = command_run_line(command_context, t_con->line);
-                                                       
-                                                       if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
-                                                       {
-                                                               return ERROR_SERVER_REMOTE_CLOSED;
-                                                       }
-                                                       
-                                                       /* Save only non-blank lines in the history */
-                                                       if (t_con->line_size > 0)
+
+                                                       /* save only non-blank not repeating lines in the history */
+                                                       char *prev_line = t_con->history[(t_con->current_history > 0) ? t_con->current_history - 1 : TELNET_LINE_HISTORY_SIZE-1];
+                                                       if (*t_con->line && (prev_line == NULL || strcmp(t_con->line, prev_line)))
                                                        {
                                                                /* if the history slot is already taken, free it */
                                                                if (t_con->history[t_con->next_history])
                                                                {
                                                                        free(t_con->history[t_con->next_history]);
                                                                }
-               
+
                                                                /* add line to history */
                                                                t_con->history[t_con->next_history] = strdup(t_con->line);
 
                                                                /* wrap history at TELNET_LINE_HISTORY_SIZE */
                                                                t_con->next_history = (t_con->next_history + 1) % TELNET_LINE_HISTORY_SIZE;
-                                                       
+
                                                                /* current history line starts at the new entry */
                                                                t_con->current_history = t_con->next_history;
-                                                       
+
                                                                if (t_con->history[t_con->current_history])
                                                                {
                                                                        free(t_con->history[t_con->current_history]);
                                                                }
                                                                t_con->history[t_con->current_history] = strdup("");
                                                        }
-                                                       
-                                                       int t = telnet_prompt(connection);
-                                                       if (t == ERROR_SERVER_REMOTE_CLOSED)
-                                                               return t;
-                                                       
+
                                                        t_con->line_size = 0;
+
+                                                       t_con->line_cursor = -1; /* to supress prompt in log callback during command execution */
+                                                       retval = command_run_line(command_context, t_con->line);
                                                        t_con->line_cursor = 0;
+
+                                                       if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
+                                                               return ERROR_SERVER_REMOTE_CLOSED;
+
+                                                       retval = telnet_prompt(connection);
+                                                       if (retval == ERROR_SERVER_REMOTE_CLOSED)
+                                                               return ERROR_SERVER_REMOTE_CLOSED;
+
                                                }
                                                else if ((*buf_p == 0x7f) || (*buf_p == 0x8)) /* delete character */
                                                {
@@ -345,7 +373,7 @@ int telnet_input(connection_t *connection)
                                                                        t_con->line_cursor--;
                                                                        t_con->line_size--;
                                                                        memmove(t_con->line + t_con->line_cursor, t_con->line + t_con->line_cursor + 1, t_con->line_size - t_con->line_cursor);
-                                                                       
+
                                                                        telnet_write(connection, t_con->line + t_con->line_cursor, t_con->line_size - t_con->line_cursor);
                                                                        telnet_write(connection, " \b", 2);
                                                                        for (i = t_con->line_cursor; i < t_con->line_size; i++)
@@ -385,7 +413,7 @@ int telnet_input(connection_t *connection)
                                                }
                                                else
                                                {
-                                                       DEBUG("unhandled nonprintable: %2.2x", *buf_p);
+                                                       LOG_DEBUG("unhandled nonprintable: %2.2x", *buf_p);
                                                }
                                        }
                                }
@@ -445,7 +473,7 @@ int telnet_input(connection_t *connection)
                                                        telnet_clear_line(connection, t_con);
                                                        t_con->line_size = strlen(t_con->history[last_history]);
                                                        t_con->line_cursor = t_con->line_size;
-                                                       memcpy(t_con->line, t_con->history[last_history], t_con->line_size + 1);
+                                                       memcpy(t_con->line, t_con->history[last_history], t_con->line_size);
                                                        telnet_write(connection, t_con->line, t_con->line_size);
                                                        t_con->current_history = last_history;
                                                }
@@ -459,7 +487,7 @@ int telnet_input(connection_t *connection)
                                                        telnet_clear_line(connection, t_con);
                                                        t_con->line_size = strlen(t_con->history[next_history]);
                                                        t_con->line_cursor = t_con->line_size;
-                                                       memcpy(t_con->line, t_con->history[next_history], t_con->line_size + 1);
+                                                       memcpy(t_con->line, t_con->history[next_history], t_con->line_size);
                                                        telnet_write(connection, t_con->line, t_con->line_size);
                                                        t_con->current_history = next_history;
                                                }
@@ -485,19 +513,19 @@ int telnet_input(connection_t *connection)
                                                        t_con->line_size--;
                                                        /* remove char from line buffer */
                                                        memmove(t_con->line + t_con->line_cursor, t_con->line + t_con->line_cursor + 1, t_con->line_size - t_con->line_cursor);
-                                                       
+
                                                        /* print remainder of buffer */
                                                        telnet_write(connection, t_con->line + t_con->line_cursor, t_con->line_size - t_con->line_cursor);
                                                        /* overwrite last char with whitespace */
                                                        telnet_write(connection, " \b", 2);
-                                                       
+
                                                        /* move back to cursor position*/
                                                        for (i = t_con->line_cursor; i < t_con->line_size; i++)
                                                        {
                                                                telnet_write(connection, "\b", 1);
                                                        }
                                                }
-                                                       
+
                                                t_con->state = TELNET_STATE_DATA;
                                        }
                                        else
@@ -518,20 +546,20 @@ int telnet_input(connection_t *connection)
                                }
                                else
                                {
-                                       ERROR("BUG: unexpected value in t_con->last_escape");
+                                       LOG_ERROR("BUG: unexpected value in t_con->last_escape");
                                        t_con->state = TELNET_STATE_DATA;
                                }
-                               
+
                                break;
                        default:
-                               ERROR("unknown telnet state");
+                               LOG_ERROR("unknown telnet state");
                                exit(-1);
                }
 
                bytes_read--;
                buf_p++;
        }
-       
+
        return ERROR_OK;
 }
 
@@ -539,15 +567,15 @@ int telnet_connection_closed(connection_t *connection)
 {
        telnet_connection_t *t_con = connection->priv;
        int i;
-       
+
        log_remove_callback(telnet_log_callback, connection);
-       
+
        if (t_con->prompt)
        {
                free(t_con->prompt);
                t_con->prompt = NULL;
        }
-       
+
        for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++)
        {
                if (t_con->history[i])
@@ -556,10 +584,10 @@ int telnet_connection_closed(connection_t *connection)
                        t_con->history[i] = NULL;
                }
        }
-       
+
        /* if this connection registered a debug-message receiver delete it */
        delete_debug_msg_receiver(connection->cmd_ctx, NULL);
-       
+
        if (connection->priv)
        {
                free(connection->priv);
@@ -567,9 +595,9 @@ int telnet_connection_closed(connection_t *connection)
        }
        else
        {
-               ERROR("BUG: connection->priv == NULL");
+               LOG_ERROR("BUG: connection->priv == NULL");
        }
-       
+
        target_unregister_event_callback(telnet_target_callback_event_handler, connection->cmd_ctx);
 
        return ERROR_OK;
@@ -579,25 +607,28 @@ int telnet_set_prompt(connection_t *connection, char *prompt)
 {
        telnet_connection_t *t_con = connection->priv;
 
+       if (t_con->prompt != NULL)
+               free(t_con->prompt);
+
        t_con->prompt = strdup(prompt);
-       
+
        return ERROR_OK;
 }
 
 int telnet_init(char *banner)
 {
        telnet_service_t *telnet_service = malloc(sizeof(telnet_service_t));
-       
+
        if (telnet_port == 0)
        {
-               WARNING("no telnet port specified, using default port 4444");
+               LOG_WARNING("no telnet port specified, using default port 4444");
                telnet_port = 4444;
        }
-       
+
        telnet_service->banner = banner;
-       
+
        add_service("telnet", CONNECTION_TELNET, telnet_port, 1, telnet_new_connection, telnet_input, telnet_connection_closed, telnet_service);
-       
+
        return ERROR_OK;
 }
 
@@ -605,10 +636,10 @@ int telnet_register_commands(command_context_t *command_context)
 {
        register_command(command_context, NULL, "exit", handle_exit_command,
                                         COMMAND_EXEC, "exit telnet session");
-       
+
        register_command(command_context, NULL, "telnet_port", handle_telnet_port_command,
                                         COMMAND_CONFIG, "");
-       
+
        return ERROR_OK;
 }
 

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)