X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fserver%2Ftcl_server.c;h=1ec45ffbb1856f13b980090f1b768858c454afd3;hp=a6601ffd7ede246deff80c4852f3d4aed9e3f1c7;hb=5202d82a954627c6706529a82447aad4c63aefcc;hpb=ed9c257551729cf2dc54fcbc3ad520fdfa9ad0c1 diff --git a/src/server/tcl_server.c b/src/server/tcl_server.c index a6601ffd7e..1ec45ffbb1 100644 --- a/src/server/tcl_server.c +++ b/src/server/tcl_server.c @@ -1,5 +1,6 @@ /*************************************************************************** - * Copyright (C) 2008 * + * 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 * @@ -12,64 +13,124 @@ * 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., * - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * along with this program. If not, see . * ***************************************************************************/ #ifdef HAVE_CONFIG_H #include "config.h" #endif -#include #include "tcl_server.h" +#include +#include -#include "log.h" -#include "command.h" +#define TCL_SERVER_VERSION "TCL Server 0.1" +#define TCL_LINE_INITIAL (4*1024) +#define TCL_LINE_MAX (4*1024*1024) -#include -#include -#include -#include -#include - -#define TCL_SERVER_VERSION "TCL Server 0.1" -#define TCL_MAX_LINE (4096) - -typedef struct tcl_connection_s { +struct tcl_connection { int tc_linedrop; int tc_lineoffset; - char tc_line[TCL_MAX_LINE]; - int tc_outerror; /* flag an output error */ -} tcl_connection_t; - -extern Jim_Interp *interp; -static unsigned short tcl_port = 0; + 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; +}; -/* commands */ -static int handle_tcl_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static char *tcl_port; /* handlers */ -static int tcl_new_connection(connection_t *connection); -static int tcl_input(connection_t *connection); -static int tcl_output(connection_t *connection, const void *buf, ssize_t len); -static int tcl_closed(connection_t *connection); +static int tcl_new_connection(struct connection *connection); +static int tcl_input(struct connection *connection); +static int tcl_output(struct connection *connection, const void *buf, ssize_t len); +static int tcl_closed(struct connection *connection); + +static int tcl_target_callback_event_handler(struct target *target, + enum target_event event, void *priv) +{ + struct connection *connection = priv; + struct tcl_connection *tclc; + char buf[256]; + + tclc = connection->priv; + + if (tclc->tc_notify) { + snprintf(buf, sizeof(buf), "type target_event event %s\r\n\x1a", target_event_name(event)); + tcl_output(connection, buf, strlen(buf)); + } + + if (tclc->tc_laststate != target->state) { + tclc->tc_laststate = target->state; + if (tclc->tc_notify) { + snprintf(buf, sizeof(buf), "type target_state state %s\r\n\x1a", target_state_name(target)); + tcl_output(connection, buf, strlen(buf)); + } + } + + return ERROR_OK; +} + +static int tcl_target_callback_reset_handler(struct target *target, + enum target_reset_mode reset_mode, void *priv) +{ + struct connection *connection = priv; + struct tcl_connection *tclc; + char buf[256]; + + tclc = connection->priv; + + if (tclc->tc_notify) { + snprintf(buf, sizeof(buf), "type target_reset mode %s\r\n\x1a", target_reset_mode_name(reset_mode)); + tcl_output(connection, buf, strlen(buf)); + } + + 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 * that is not the case then flag the connection with an output error. */ -int tcl_output(connection_t *connection, const void *data, ssize_t len) +int tcl_output(struct connection *connection, const void *data, ssize_t len) { ssize_t wlen; - tcl_connection_t *tclc; + struct tcl_connection *tclc; tclc = connection->priv; if (tclc->tc_outerror) return ERROR_SERVER_REMOTE_CLOSED; - wlen = write_socket(connection->fd, data, len); + wlen = connection_write(connection, data, len); + if (wlen == len) return ERROR_OK; @@ -79,30 +140,51 @@ int tcl_output(connection_t *connection, const void *data, ssize_t len) } /* connections */ -static int tcl_new_connection(connection_t *connection) +static int tcl_new_connection(struct connection *connection) { - tcl_connection_t *tclc; + struct tcl_connection *tclc; - tclc = malloc(sizeof(tcl_connection_t)); + tclc = calloc(1, sizeof(struct tcl_connection)); if (tclc == NULL) return ERROR_CONNECTION_REJECTED; - memset(tclc, 0, sizeof(tcl_connection_t)); + tclc->tc_line_size = TCL_LINE_INITIAL; + tclc->tc_line = malloc(tclc->tc_line_size); + if (tclc->tc_line == NULL) { + free(tclc); + return ERROR_CONNECTION_REJECTED; + } + connection->priv = tclc; + + struct target *target = get_current_target_or_null(connection->cmd_ctx); + if (target != NULL) + tclc->tc_laststate = target->state; + + /* store the connection object on cmd_ctx so we can access it from command handlers */ + connection->cmd_ctx->output_handler_priv = 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; } -static int tcl_input(connection_t *connection) +static int tcl_input(struct connection *connection) { + Jim_Interp *interp = (Jim_Interp *)connection->cmd_ctx->interp; int retval; int i; ssize_t rlen; const char *result; int reslen; - tcl_connection_t *tclc; - char in[256]; + struct tcl_connection *tclc; + unsigned char in[256]; + char *tc_line_new; + int tc_line_size_new; - rlen = read_socket(connection->fd, &in, sizeof(in)); + rlen = connection_read(connection, &in, sizeof(in)); if (rlen <= 0) { if (rlen < 0) LOG_ERROR("error during read: %s", strerror(errno)); @@ -114,23 +196,40 @@ static int tcl_input(connection_t *connection) return ERROR_CONNECTION_REJECTED; /* push as much data into the line as possible */ - for (i = 0; i < rlen; i++) - { - if (!isprint(in[i]) && !isspace(in[i])) - { - /* drop this line */ - tclc->tc_linedrop = 1; - continue; - } - + 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 < 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 == NULL) { + tclc->tc_linedrop = 1; + } else { + tclc->tc_line = tc_line_new; + tclc->tc_line_size = tc_line_size_new; + tclc->tc_lineoffset++; + } + + } - if (in[i] != '\n') + /* ctrl-z is end of command. When testing from telnet, just + * press ctrl-z a couple of times first to put telnet into the + * mode where it will send 0x1a in response to pressing ctrl-z + */ + if (in[i] != '\x1a') continue; /* process the line */ @@ -140,18 +239,17 @@ static int tcl_input(connection_t *connection) if (retval != ERROR_OK) return retval; #undef ESTR - } - else { + } else { tclc->tc_line[tclc->tc_lineoffset-1] = '\0'; - retval = Jim_Eval_Named(interp, tclc->tc_line, "remote:connection",1); + 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; - if (memchr(result, '\n', reslen) == NULL) - tcl_output(connection, "\n", 1); + /* Always output ctrl-z as end of line to allow multiline results */ + tcl_output(connection, "\x1a", 1); } - + tclc->tc_lineoffset = 0; tclc->tc_linedrop = 0; } @@ -159,40 +257,110 @@ static int tcl_input(connection_t *connection) return ERROR_OK; } -static int tcl_closed(connection_t *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; } int tcl_init(void) { - int retval; - - if (tcl_port == 0) - { - LOG_WARNING("no tcl port specified, using default port 6666"); - tcl_port = 6666; + if (strcmp(tcl_port, "disabled") == 0) { + LOG_INFO("tcl server disabled"); + return ERROR_OK; } - retval = add_service("tcl", CONNECTION_TCL, tcl_port, 1, tcl_new_connection, tcl_input, tcl_closed, NULL); - return retval; + return add_service("tcl", tcl_port, CONNECTION_LIMIT_UNLIMITED, + &tcl_new_connection, &tcl_input, + &tcl_closed, NULL); } -int tcl_register_commands(command_context_t *cmd_ctx) +COMMAND_HANDLER(handle_tcl_port_command) { - register_command(cmd_ctx, NULL, "tcl_port", handle_tcl_port_command, COMMAND_CONFIG, "port on which to listen for incoming TCL syntax"); - return ERROR_OK; + return CALL_COMMAND_HANDLER(server_pipe_command, &tcl_port); } -static int handle_tcl_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_tcl_notifications_command) { - if (argc == 1) { - tcl_port = strtoul(args[0], NULL, 0); + struct connection *connection = NULL; + struct tcl_connection *tclc = NULL; + + if (CMD_CTX->output_handler_priv != NULL) + connection = CMD_CTX->output_handler_priv; + + if (connection != NULL && !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; } - return ERROR_OK; +} + +COMMAND_HANDLER(handle_tcl_trace_command) +{ + struct connection *connection = NULL; + struct tcl_connection *tclc = NULL; + + if (CMD_CTX->output_handler_priv != NULL) + connection = CMD_CTX->output_handler_priv; + + if (connection != NULL && !strcmp(connection->service->name, "tcl")) { + tclc = connection->priv; + 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; + } +} + +static const struct command_registration tcl_command_handlers[] = { + { + .name = "tcl_port", + .handler = handle_tcl_port_command, + .mode = COMMAND_ANY, + .help = "Specify port on which to listen " + "for incoming Tcl syntax. " + "Read help on 'gdb_port'.", + .usage = "[port_num]", + }, + { + .name = "tcl_notifications", + .handler = handle_tcl_notifications_command, + .mode = COMMAND_EXEC, + .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 +}; + +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); }