Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
- rename log functions to stop conflicts under win32 (wingdi)
[openocd.git] / src / server / telnet_server.c
diff --git a/src/server/telnet_server.c b/src/server/telnet_server.c
index b573ec5c8332db286caa70bc0463ed297ce82c15..fc3f2116a46d162a3390ac819eca3611e1f26b8f 100644 (file)
--- a/src/server/telnet_server.c
+++ b/src/server/telnet_server.c
@@ -29,6 +29,7 @@
 #include "log.h"
 #include "command.h"
 #include "target.h"
 #include "log.h"
 #include "command.h"
 #include "target.h"
+#include "target_request.h"
 
 #include <stdlib.h>
 #include <unistd.h>
 
 #include <stdlib.h>
 #include <unistd.h>
@@ -46,47 +47,106 @@ static char *negotiate =
                "\xFF\xFB\x01"          /* IAC WILL Echo */
                "\xFF\xFD\x03"          /* IAC DO Suppress Go Ahead */
                "\xFF\xFE\x01";         /* IAC DON'T Echo */
                "\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 - '@')
 #define CTRL(c) (c - '@')
-       
-void telnet_prompt(connection_t *connection)
+
+/* 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!
+ */
+int telnet_write(connection_t *connection, const void *data, int len)
 {
        telnet_connection_t *t_con = connection->priv;
 {
        telnet_connection_t *t_con = connection->priv;
+       if (t_con->closed)
+               return ERROR_SERVER_REMOTE_CLOSED;
 
 
-       write_socket(connection->fd, t_con->prompt, strlen(t_con->prompt));
+       if (write_socket(connection->fd, data, len) == len)
+       {
+               return ERROR_OK;
+       }
+       t_con->closed = 1;
+       return ERROR_SERVER_REMOTE_CLOSED;
 }
 
 }
 
-int telnet_output(struct command_context_s *cmd_ctx, char* line)
+int telnet_prompt(connection_t *connection)
 {
 {
-       connection_t *connection = cmd_ctx->output_handler_priv;
-       
-       write_socket(connection->fd, line, strlen(line));
-       write_socket(connection->fd, "\r\n\0", 3);
-       
+       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
+                       len = strlen(line);
+
+               telnet_write(connection, line, len);
+               if (line_end)
+               {
+                       telnet_write(connection, "\r\n\0", 3);
+                       line += len+1;
+               }
+               else
+               {
+                       line += len;
+               }
+       }
+
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 
-int telnet_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
+int telnet_output(struct command_context_s *cmd_ctx, char* line)
 {
 {
-       struct command_context_s *cmd_ctx = priv;
        connection_t *connection = cmd_ctx->output_handler_priv;
        connection_t *connection = cmd_ctx->output_handler_priv;
+
+       return telnet_outputline(connection, line);
+}
+
+void telnet_log_callback(void *priv, const char *file, int line,
+               const char *function, const char *string)
+{
+       connection_t *connection = priv;
        telnet_connection_t *t_con = connection->priv;
        telnet_connection_t *t_con = connection->priv;
-       char buffer[512];
-       
+       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)
+{
        switch (event)
        {
                case TARGET_EVENT_HALTED:
        switch (event)
        {
                case TARGET_EVENT_HALTED:
-                       command_print(cmd_ctx, "Target %i halted", get_num_by_target(target));
-                       target->type->arch_state(target, buffer, 512);
-                       buffer[511] = 0;
-                       command_print(cmd_ctx, "%s", buffer);
-                       telnet_prompt(connection);
-                       t_con->suppress_prompt = 1;
-                       break;
-               case TARGET_EVENT_RESUMED:
-                       command_print(cmd_ctx, "Target %i resumed", get_num_by_target(target));
-                       telnet_prompt(connection);
-                       t_con->suppress_prompt = 1;
+                       target_arch_state(target);
                        break;
                default:
                        break;
                        break;
                default:
                        break;
@@ -100,32 +160,32 @@ 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;
        telnet_connection_t *telnet_connection = malloc(sizeof(telnet_connection_t));
        telnet_service_t *telnet_service = connection->service->priv;
        int i;
-       
+
        connection->priv = telnet_connection;
        connection->priv = telnet_connection;
-       
+
        /* initialize telnet connection information */
        /* initialize telnet connection information */
+       telnet_connection->closed = 0;
        telnet_connection->line_size = 0;
        telnet_connection->line_cursor = 0;
        telnet_connection->option_size = 0;
        telnet_connection->prompt = strdup("> ");
        telnet_connection->line_size = 0;
        telnet_connection->line_cursor = 0;
        telnet_connection->option_size = 0;
        telnet_connection->prompt = strdup("> ");
-       telnet_connection->suppress_prompt = 0;
        telnet_connection->state = TELNET_STATE_DATA;
        telnet_connection->state = TELNET_STATE_DATA;
-       
+
        /* output goes through telnet connection */
        command_set_output_handler(connection->cmd_ctx, telnet_output, connection);
        /* output goes through telnet connection */
        command_set_output_handler(connection->cmd_ctx, telnet_output, connection);
-       
+
        /* negotiate telnet options */
        /* negotiate telnet options */
-       write_socket(connection->fd, negotiate, strlen(negotiate));
-       
+       telnet_write(connection, negotiate, strlen(negotiate));
+
        /* print connection banner */
        if (telnet_service->banner)
        {
        /* print connection banner */
        if (telnet_service->banner)
        {
-               write_socket(connection->fd, telnet_service->banner, strlen(telnet_service->banner));
-               write_socket(connection->fd, "\r\n\0", 3);
+               telnet_write(connection, telnet_service->banner, strlen(telnet_service->banner));
+               telnet_write(connection, "\r\n\0", 3);
        }
        }
-       
+
        telnet_prompt(connection);
        telnet_prompt(connection);
-       
+
        /* initialize history */
        for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++)
        {
        /* initialize history */
        for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++)
        {
@@ -133,9 +193,13 @@ int telnet_new_connection(connection_t *connection)
        }
        telnet_connection->next_history = 0;
        telnet_connection->current_history = 0;
        }
        telnet_connection->next_history = 0;
        telnet_connection->current_history = 0;
-       
+
        target_register_event_callback(telnet_target_callback_event_handler, connection->cmd_ctx);
        target_register_event_callback(telnet_target_callback_event_handler, connection->cmd_ctx);
-       
+
+       log_add_callback(telnet_log_callback, connection);
+
+
+
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 
@@ -144,13 +208,13 @@ void telnet_clear_line(connection_t *connection, telnet_connection_t *t_con)
        /* move to end of line */
        if (t_con->line_cursor < t_con->line_size)
        {
        /* move to end of line */
        if (t_con->line_cursor < t_con->line_size)
        {
-               write_socket(connection->fd, t_con->line + t_con->line_cursor, 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);
        }
        }
-                                                       
+
        /* backspace, overwrite with space, backspace */
        while (t_con->line_size > 0)
        {
        /* backspace, overwrite with space, backspace */
        while (t_con->line_size > 0)
        {
-               write_socket(connection->fd, "\b \b", 3);
+               telnet_write(connection, "\b \b", 3);
                t_con->line_size--;
        }
        t_con->line_cursor = 0;
                t_con->line_size--;
        }
        t_con->line_cursor = 0;
@@ -163,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;
        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);
        bytes_read = read_socket(connection->fd, buffer, TELNET_BUFFER_SIZE);
-       
+
        if (bytes_read == 0)
                return ERROR_SERVER_REMOTE_CLOSED;
        else if (bytes_read == -1)
        {
        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;
        }
                return ERROR_SERVER_REMOTE_CLOSED;
        }
-       
+
        buf_p = buffer;
        while (bytes_read)
        {
        buf_p = buffer;
        while (bytes_read)
        {
@@ -188,9 +252,15 @@ int telnet_input(connection_t *connection)
                                {
                                        if (isprint(*buf_p)) /* printable character */
                                        {
                                {
                                        if (isprint(*buf_p)) /* printable character */
                                        {
-                                               write_socket(connection->fd, 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++;
                                                }
                                                        t_con->line[t_con->line_size++] = *buf_p;
                                                        t_con->line_cursor++;
                                                }
@@ -198,12 +268,13 @@ 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);
                                                {
                                                        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++;
                                                        t_con->line_size++;
-                                                       write_socket(connection->fd, t_con->line + t_con->line_cursor, 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);
+                                                       t_con->line_cursor++;
                                                        for (i = t_con->line_cursor; i < t_con->line_size; i++)
                                                        {
                                                        for (i = t_con->line_cursor; i < t_con->line_size; i++)
                                                        {
-                                                               write_socket(connection->fd, "\b", 1);
+                                                               telnet_write(connection, "\b", 1);
                                                        }
                                                }
                                        }
                                                        }
                                                }
                                        }
@@ -217,86 +288,79 @@ int telnet_input(connection_t *connection)
                                                else if ((*buf_p == 0xd) || (*buf_p == 0xa)) /* CR/LF */
                                                {
                                                        int retval;
                                                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--;
                                                        }
                                                        {
                                                                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;
                                                        {
                                                                buf_p++;
                                                                bytes_read--;
                                                        }
                                                        t_con->line[t_con->line_size] = 0;
-                                                       
-                                                       write_socket(connection->fd, "\r\n\x00", 3);
-                                                       
+
+                                                       telnet_write(connection, "\r\n\x00", 3);
+
                                                        if (strcmp(t_con->line, "history") == 0)
                                                        {
                                                                int i;
                                                        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)
                                                                        {
                                                                        {
-                                                                               write_socket(connection->fd, t_con->history[i], strlen(t_con->history[i]));
-                                                                               write_socket(connection->fd, "\r\n\x00", 3);
+                                                                               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;
                                                        }
                                                                t_con->line_size = 0;
                                                                t_con->line_cursor = 0;
                                                                continue;
                                                        }
-                                                       
-                                                       /* we're running a command, so we need a prompt
-                                                        * if the output handler is called, this gets set again */
-                                                       t_con->suppress_prompt = 0;
-                                                       if ((retval = command_run_line(command_context, t_con->line)) != ERROR_OK)
-                                                       {
-                                                               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]);
                                                                }
                                                        {
                                                                /* 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;
                                                                /* 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;
                                                                /* 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("");
                                                        }
                                                                if (t_con->history[t_con->current_history])
                                                                {
                                                                        free(t_con->history[t_con->current_history]);
                                                                }
                                                                t_con->history[t_con->current_history] = strdup("");
                                                        }
-                                                       
-                                                       if (!t_con->suppress_prompt)
-                                                       {
-                                                               telnet_prompt(connection);
-                                                       }
-                                                       else
-                                                       {
-                                                               t_con->suppress_prompt = 0;
-                                                       }
-                                                       
+
                                                        t_con->line_size = 0;
                                                        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;
                                                        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 */
                                                {
                                                }
                                                else if ((*buf_p == 0x7f) || (*buf_p == 0x8)) /* delete character */
                                                {
@@ -305,16 +369,16 @@ int telnet_input(connection_t *connection)
                                                                if (t_con->line_cursor != t_con->line_size)
                                                                {
                                                                        int i;
                                                                if (t_con->line_cursor != t_con->line_size)
                                                                {
                                                                        int i;
-                                                                       write_socket(connection->fd, "\b", 1);
+                                                                       telnet_write(connection, "\b", 1);
                                                                        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);
                                                                        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);
-                                                                       
-                                                                       write_socket(connection->fd, t_con->line + t_con->line_cursor, t_con->line_size - t_con->line_cursor);
-                                                                       write_socket(connection->fd, " \b", 2);
+
+                                                                       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++)
                                                                        {
                                                                        for (i = t_con->line_cursor; i < t_con->line_size; i++)
                                                                        {
-                                                                               write_socket(connection->fd, "\b", 1);
+                                                                               telnet_write(connection, "\b", 1);
                                                                        }
                                                                }
                                                                else
                                                                        }
                                                                }
                                                                else
@@ -322,7 +386,7 @@ int telnet_input(connection_t *connection)
                                                                        t_con->line_size--;
                                                                        t_con->line_cursor--;
                                                                        /* back space: move the 'printer' head one char back, overwrite with space, move back again */
                                                                        t_con->line_size--;
                                                                        t_con->line_cursor--;
                                                                        /* back space: move the 'printer' head one char back, overwrite with space, move back again */
-                                                                       write_socket(connection->fd, "\b \b", 3);
+                                                                       telnet_write(connection, "\b \b", 3);
                                                                }
                                                        }
                                                }
                                                                }
                                                        }
                                                }
@@ -334,7 +398,7 @@ int telnet_input(connection_t *connection)
                                                {
                                                        if (t_con->line_cursor > 0)
                                                        {
                                                {
                                                        if (t_con->line_cursor > 0)
                                                        {
-                                                               write_socket(connection->fd, "\b", 1);
+                                                               telnet_write(connection, "\b", 1);
                                                                t_con->line_cursor--;
                                                        }
                                                        t_con->state = TELNET_STATE_DATA;
                                                                t_con->line_cursor--;
                                                        }
                                                        t_con->state = TELNET_STATE_DATA;
@@ -343,13 +407,13 @@ int telnet_input(connection_t *connection)
                                                {
                                                        if (t_con->line_cursor < t_con->line_size)
                                                        {
                                                {
                                                        if (t_con->line_cursor < t_con->line_size)
                                                        {
-                                                               write_socket(connection->fd, t_con->line + t_con->line_cursor++, 1);
+                                                               telnet_write(connection, t_con->line + t_con->line_cursor++, 1);
                                                        }
                                                        t_con->state = TELNET_STATE_DATA;
                                                }
                                                else
                                                {
                                                        }
                                                        t_con->state = TELNET_STATE_DATA;
                                                }
                                                else
                                                {
-                                                       DEBUG("unhandled nonprintable: %2.2x", *buf_p);
+                                                       LOG_DEBUG("unhandled nonprintable: %2.2x", *buf_p);
                                                }
                                        }
                                }
                                                }
                                        }
                                }
@@ -388,7 +452,7 @@ int telnet_input(connection_t *connection)
                                        {
                                                if (t_con->line_cursor > 0)
                                                {
                                        {
                                                if (t_con->line_cursor > 0)
                                                {
-                                                       write_socket(connection->fd, "\b", 1);
+                                                       telnet_write(connection, "\b", 1);
                                                        t_con->line_cursor--;
                                                }
                                                t_con->state = TELNET_STATE_DATA;
                                                        t_con->line_cursor--;
                                                }
                                                t_con->state = TELNET_STATE_DATA;
@@ -397,7 +461,7 @@ int telnet_input(connection_t *connection)
                                        {
                                                if (t_con->line_cursor < t_con->line_size)
                                                {
                                        {
                                                if (t_con->line_cursor < t_con->line_size)
                                                {
-                                                       write_socket(connection->fd, t_con->line + t_con->line_cursor++, 1);
+                                                       telnet_write(connection, t_con->line + t_con->line_cursor++, 1);
                                                }
                                                t_con->state = TELNET_STATE_DATA;
                                        }
                                                }
                                                t_con->state = TELNET_STATE_DATA;
                                        }
@@ -409,8 +473,8 @@ 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;
                                                        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);
-                                                       write_socket(connection->fd, t_con->line, t_con->line_size);
+                                                       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;
                                                }
                                                t_con->state = TELNET_STATE_DATA;
                                                        t_con->current_history = last_history;
                                                }
                                                t_con->state = TELNET_STATE_DATA;
@@ -423,8 +487,8 @@ 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;
                                                        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);
-                                                       write_socket(connection->fd, t_con->line, t_con->line_size);
+                                                       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;
                                                }
                                                t_con->state = TELNET_STATE_DATA;
                                                        t_con->current_history = next_history;
                                                }
                                                t_con->state = TELNET_STATE_DATA;
@@ -449,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);
                                                        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 */
                                                        /* print remainder of buffer */
-                                                       write_socket(connection->fd, t_con->line + t_con->line_cursor, 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);
                                                        /* overwrite last char with whitespace */
                                                        /* overwrite last char with whitespace */
-                                                       write_socket(connection->fd, " \b", 2);
-                                                       
+                                                       telnet_write(connection, " \b", 2);
+
                                                        /* move back to cursor position*/
                                                        for (i = t_con->line_cursor; i < t_con->line_size; i++)
                                                        {
                                                        /* move back to cursor position*/
                                                        for (i = t_con->line_cursor; i < t_con->line_size; i++)
                                                        {
-                                                               write_socket(connection->fd, "\b", 1);
+                                                               telnet_write(connection, "\b", 1);
                                                        }
                                                }
                                                        }
                                                }
-                                                       
+
                                                t_con->state = TELNET_STATE_DATA;
                                        }
                                        else
                                                t_con->state = TELNET_STATE_DATA;
                                        }
                                        else
@@ -482,20 +546,20 @@ int telnet_input(connection_t *connection)
                                }
                                else
                                {
                                }
                                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;
                                }
                                        t_con->state = TELNET_STATE_DATA;
                                }
-                               
+
                                break;
                        default:
                                break;
                        default:
-                               ERROR("unknown telnet state");
+                               LOG_ERROR("unknown telnet state");
                                exit(-1);
                }
 
                bytes_read--;
                buf_p++;
        }
                                exit(-1);
                }
 
                bytes_read--;
                buf_p++;
        }
-       
+
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 
@@ -503,21 +567,37 @@ int telnet_connection_closed(connection_t *connection)
 {
        telnet_connection_t *t_con = connection->priv;
        int i;
 {
        telnet_connection_t *t_con = connection->priv;
        int i;
-       
+
+       log_remove_callback(telnet_log_callback, connection);
+
        if (t_con->prompt)
        if (t_con->prompt)
+       {
                free(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])
        for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++)
        {
                if (t_con->history[i])
+               {
                        free(t_con->history[i]);
                        free(t_con->history[i]);
+                       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)
        if (connection->priv)
+       {
                free(connection->priv);
                free(connection->priv);
+               connection->priv = NULL;
+       }
        else
        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;
        target_unregister_event_callback(telnet_target_callback_event_handler, connection->cmd_ctx);
 
        return ERROR_OK;
@@ -527,25 +607,28 @@ int telnet_set_prompt(connection_t *connection, char *prompt)
 {
        telnet_connection_t *t_con = connection->priv;
 
 {
        telnet_connection_t *t_con = connection->priv;
 
+       if (t_con->prompt != NULL)
+               free(t_con->prompt);
+
        t_con->prompt = strdup(prompt);
        t_con->prompt = strdup(prompt);
-       
+
        return ERROR_OK;
 }
 
 int telnet_init(char *banner)
 {
        telnet_service_t *telnet_service = malloc(sizeof(telnet_service_t));
        return ERROR_OK;
 }
 
 int telnet_init(char *banner)
 {
        telnet_service_t *telnet_service = malloc(sizeof(telnet_service_t));
-       
+
        if (telnet_port == 0)
        {
        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_port = 4444;
        }
-       
+
        telnet_service->banner = banner;
        telnet_service->banner = banner;
-       
+
        add_service("telnet", CONNECTION_TELNET, telnet_port, 1, telnet_new_connection, telnet_input, telnet_connection_closed, telnet_service);
        add_service("telnet", CONNECTION_TELNET, telnet_port, 1, telnet_new_connection, telnet_input, telnet_connection_closed, telnet_service);
-       
+
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 
@@ -553,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, "exit", handle_exit_command,
                                         COMMAND_EXEC, "exit telnet session");
-       
+
        register_command(command_context, NULL, "telnet_port", handle_telnet_port_command,
                                         COMMAND_CONFIG, "");
        register_command(command_context, NULL, "telnet_port", handle_telnet_port_command,
                                         COMMAND_CONFIG, "");
-       
+
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 
@@ -566,9 +649,7 @@ int handle_telnet_port_command(struct command_context_s *cmd_ctx, char *cmd, cha
        if (argc == 0)
                return ERROR_OK;
 
        if (argc == 0)
                return ERROR_OK;
 
-       /* only if the port wasn't overwritten by cmdline */
-       if (telnet_port == 0)
-               telnet_port = strtoul(args[0], NULL, 0);
+       telnet_port = strtoul(args[0], NULL, 0);
 
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
Open On-Chip Debugger

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)