X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fserver%2Ftcl_server.c;h=1793453a962b5f3f787f00e5fe7274cac20d35e4;hb=f9837d1807dae8042aac2e52af3f007ef3cca4d9;hp=d6828f12aab7da54076666ffb38d43cfad1d6d6f;hpb=1d0cf0df37a4e831ca3121ba8987d5848cad3e42;p=fw%2Fopenocd diff --git a/src/server/tcl_server.c b/src/server/tcl_server.c index d6828f12a..1793453a9 100644 --- a/src/server/tcl_server.c +++ b/src/server/tcl_server.c @@ -1,21 +1,8 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + /*************************************************************************** * Copyright (C) 2010 Øyvind Harboe * * oyvind.harboe@zylin.com * - * * - * This program is free software; you can redistribute it and/or modify * - * it under the terms of the GNU General Public License as published by * - * the Free Software Foundation; either version 2 of the License, or * - * (at your option) any later version. * - * * - * This program is distributed in the hope that it will be useful, * - * but WITHOUT ANY WARRANTY; without even the implied warranty of * - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * - * GNU General Public License for more details. * - * * - * You should have received a copy of the GNU General Public License * - * along with this program; if not, write to the * - * Free Software Foundation, Inc., * - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * ***************************************************************************/ #ifdef HAVE_CONFIG_H @@ -24,17 +11,21 @@ #include "tcl_server.h" #include +#include #define TCL_SERVER_VERSION "TCL Server 0.1" -#define TCL_MAX_LINE (4096) +#define TCL_LINE_INITIAL (4*1024) +#define TCL_LINE_MAX (4*1024*1024) struct tcl_connection { int tc_linedrop; int tc_lineoffset; - char tc_line[TCL_MAX_LINE]; + int tc_line_size; + char *tc_line; int tc_outerror;/* flag an output error */ enum target_state tc_laststate; bool tc_notify; + bool tc_trace; }; static char *tcl_port; @@ -87,6 +78,32 @@ static int tcl_target_callback_reset_handler(struct target *target, return ERROR_OK; } +static int tcl_target_callback_trace_handler(struct target *target, + size_t len, uint8_t *data, void *priv) +{ + struct connection *connection = priv; + struct tcl_connection *tclc; + char *header = "type target_trace data "; + char *trailer = "\r\n\x1a"; + size_t hex_len = len * 2 + 1; + size_t max_len = hex_len + strlen(header) + strlen(trailer); + char *buf, *hex; + + tclc = connection->priv; + + if (tclc->tc_trace) { + hex = malloc(hex_len); + buf = malloc(max_len); + hexify(hex, data, len, hex_len); + snprintf(buf, max_len, "%s%s%s", header, hex, trailer); + tcl_output(connection, buf, strlen(buf)); + free(hex); + free(buf); + } + + return ERROR_OK; +} + /* write data out to a socket. * * this is a blocking write, so the return value must equal the length, if @@ -116,15 +133,21 @@ static int tcl_new_connection(struct connection *connection) { struct tcl_connection *tclc; - tclc = malloc(sizeof(struct tcl_connection)); - if (tclc == NULL) + tclc = calloc(1, sizeof(struct tcl_connection)); + if (!tclc) + return ERROR_CONNECTION_REJECTED; + + tclc->tc_line_size = TCL_LINE_INITIAL; + tclc->tc_line = malloc(tclc->tc_line_size); + if (!tclc->tc_line) { + free(tclc); return ERROR_CONNECTION_REJECTED; + } - memset(tclc, 0, sizeof(struct tcl_connection)); connection->priv = tclc; - struct target *target = get_current_target(connection->cmd_ctx); - if (target != NULL) + struct target *target = get_current_target_or_null(connection->cmd_ctx); + if (target) tclc->tc_laststate = target->state; /* store the connection object on cmd_ctx so we can access it from command handlers */ @@ -132,6 +155,7 @@ static int tcl_new_connection(struct connection *connection) target_register_event_callback(tcl_target_callback_event_handler, connection); target_register_reset_callback(tcl_target_callback_reset_handler, connection); + target_register_trace_callback(tcl_target_callback_trace_handler, connection); return ERROR_OK; } @@ -146,6 +170,8 @@ static int tcl_input(struct connection *connection) int reslen; struct tcl_connection *tclc; unsigned char in[256]; + char *tc_line_new; + int tc_line_size_new; rlen = connection_read(connection, &in, sizeof(in)); if (rlen <= 0) { @@ -155,17 +181,38 @@ static int tcl_input(struct connection *connection) } tclc = connection->priv; - if (tclc == NULL) + if (!tclc) return ERROR_CONNECTION_REJECTED; /* push as much data into the line as possible */ for (i = 0; i < rlen; i++) { /* buffer the data */ tclc->tc_line[tclc->tc_lineoffset] = in[i]; - if (tclc->tc_lineoffset < TCL_MAX_LINE) + if (tclc->tc_lineoffset + 1 < tclc->tc_line_size) { tclc->tc_lineoffset++; - else + } else if (tclc->tc_line_size >= TCL_LINE_MAX) { + /* maximum line size reached, drop line */ tclc->tc_linedrop = 1; + } else { + /* grow line buffer: exponential below 1 MB, linear above */ + if (tclc->tc_line_size <= 1*1024*1024) + tc_line_size_new = tclc->tc_line_size * 2; + else + tc_line_size_new = tclc->tc_line_size + 1*1024*1024; + + if (tc_line_size_new > TCL_LINE_MAX) + tc_line_size_new = TCL_LINE_MAX; + + tc_line_new = realloc(tclc->tc_line, tc_line_size_new); + if (!tc_line_new) { + tclc->tc_linedrop = 1; + } else { + tclc->tc_line = tc_line_new; + tclc->tc_line_size = tc_line_size_new; + tclc->tc_lineoffset++; + } + + } /* ctrl-z is end of command. When testing from telnet, just * press ctrl-z a couple of times first to put telnet into the @@ -183,12 +230,12 @@ static int tcl_input(struct connection *connection) #undef ESTR } else { tclc->tc_line[tclc->tc_lineoffset-1] = '\0'; - retval = command_run_line(connection->cmd_ctx, tclc->tc_line); + command_run_line(connection->cmd_ctx, tclc->tc_line); result = Jim_GetString(Jim_GetResult(interp), &reslen); retval = tcl_output(connection, result, reslen); if (retval != ERROR_OK) return retval; - /* Always output ctrl-d as end of line to allow multiline results */ + /* Always output ctrl-z as end of line to allow multiline results */ tcl_output(connection, "\x1a", 1); } @@ -201,18 +248,32 @@ static int tcl_input(struct connection *connection) static int tcl_closed(struct connection *connection) { + struct tcl_connection *tclc; + tclc = connection->priv; + /* cleanup connection context */ - if (connection->priv) { - free(connection->priv); + if (tclc) { + free(tclc->tc_line); + free(tclc); connection->priv = NULL; } target_unregister_event_callback(tcl_target_callback_event_handler, connection); target_unregister_reset_callback(tcl_target_callback_reset_handler, connection); + target_unregister_trace_callback(tcl_target_callback_trace_handler, connection); return ERROR_OK; } +static const struct service_driver tcl_service_driver = { + .name = "tcl", + .new_connection_during_keep_alive_handler = NULL, + .new_connection_handler = tcl_new_connection, + .input_handler = tcl_input, + .connection_closed_handler = tcl_closed, + .keep_client_alive_handler = NULL, +}; + int tcl_init(void) { if (strcmp(tcl_port, "disabled") == 0) { @@ -220,9 +281,7 @@ int tcl_init(void) return ERROR_OK; } - return add_service("tcl", tcl_port, 1, - &tcl_new_connection, &tcl_input, - &tcl_closed, NULL); + return add_service(&tcl_service_driver, tcl_port, CONNECTION_LIMIT_UNLIMITED, NULL); } COMMAND_HANDLER(handle_tcl_port_command) @@ -235,12 +294,29 @@ COMMAND_HANDLER(handle_tcl_notifications_command) struct connection *connection = NULL; struct tcl_connection *tclc = NULL; - if (CMD_CTX->output_handler_priv != NULL) + if (CMD_CTX->output_handler_priv) + connection = CMD_CTX->output_handler_priv; + + if (connection && !strcmp(connection->service->name, "tcl")) { + tclc = connection->priv; + return CALL_COMMAND_HANDLER(handle_command_parse_bool, &tclc->tc_notify, "Target Notification output "); + } else { + LOG_ERROR("%s: can only be called from the tcl server", CMD_NAME); + return ERROR_COMMAND_SYNTAX_ERROR; + } +} + +COMMAND_HANDLER(handle_tcl_trace_command) +{ + struct connection *connection = NULL; + struct tcl_connection *tclc = NULL; + + if (CMD_CTX->output_handler_priv) connection = CMD_CTX->output_handler_priv; - if (connection != NULL && !strcmp(connection->service->name, "tcl")) { + if (connection && !strcmp(connection->service->name, "tcl")) { tclc = connection->priv; - return CALL_COMMAND_HANDLER(handle_command_parse_bool, &tclc->tc_notify, "Target Notification output is"); + return CALL_COMMAND_HANDLER(handle_command_parse_bool, &tclc->tc_trace, "Target trace output "); } else { LOG_ERROR("%s: can only be called from the tcl server", CMD_NAME); return ERROR_COMMAND_SYNTAX_ERROR; @@ -251,7 +327,7 @@ static const struct command_registration tcl_command_handlers[] = { { .name = "tcl_port", .handler = handle_tcl_port_command, - .mode = COMMAND_ANY, + .mode = COMMAND_CONFIG, .help = "Specify port on which to listen " "for incoming Tcl syntax. " "Read help on 'gdb_port'.", @@ -264,6 +340,13 @@ static const struct command_registration tcl_command_handlers[] = { .help = "Target Notification output", .usage = "[on|off]", }, + { + .name = "tcl_trace", + .handler = handle_tcl_trace_command, + .mode = COMMAND_EXEC, + .help = "Target trace output", + .usage = "[on|off]", + }, COMMAND_REGISTRATION_DONE }; @@ -272,3 +355,8 @@ int tcl_register_commands(struct command_context *cmd_ctx) tcl_port = strdup("6666"); return register_commands(cmd_ctx, NULL, tcl_command_handlers); } + +void tcl_service_free(void) +{ + free(tcl_port); +}