tcl_server.c

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
 
/***************************************************************************
 *   Copyright (C) 2010 Øyvind Harboe                                      *
 *   oyvind.harboe@zylin.com                                               *
 ***************************************************************************/
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include "tcl_server.h"
#include <target/target.h>
#include <helper/binarybuffer.h>
 
#define TCL_SERVER_VERSION      "TCL Server 0.1"
#define TCL_LINE_INITIAL        (4*1024)
#define TCL_LINE_MAX            (4*1024*1024)
 
struct tcl_connection {
    int tc_linedrop;
    int tc_lineoffset;
    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;
 
/* handlers */
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(struct connection *connection, const void *data, ssize_t len)
{
    ssize_t wlen;
    struct tcl_connection *tclc;
 
    tclc = connection->priv;
    if (tclc->tc_outerror)
        return ERROR_SERVER_REMOTE_CLOSED;
 
    wlen = connection_write(connection, data, len);
 
    if (wlen == len)
        return ERROR_OK;
 
    LOG_ERROR("error during write: %d != %d", (int)wlen, (int)len);
    tclc->tc_outerror = 1;
    return ERROR_SERVER_REMOTE_CLOSED;
}
 
/* connections */
static int tcl_new_connection(struct connection *connection)
{
    struct tcl_connection *tclc;
 
    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;
    }
 
    connection->priv = tclc;
 
    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 */
    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(struct connection *connection)
{
    Jim_Interp *interp = (Jim_Interp *)connection->cmd_ctx->interp;
    int retval;
    int i;
    ssize_t rlen;
    const char *result;
    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) {
        if (rlen < 0)
            LOG_ERROR("error during read: %s", strerror(errno));
        return ERROR_SERVER_REMOTE_CLOSED;
    }
 
    tclc = connection->priv;
    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 + 1 < tclc->tc_line_size) {
            tclc->tc_lineoffset++;
        } 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
         * mode where it will send 0x1a in response to pressing ctrl-z
         */
        if (in[i] != '\x1a')
            continue;
 
        /* process the line */
        if (tclc->tc_linedrop) {
#define ESTR "line too long\n"
            retval = tcl_output(connection, ESTR, sizeof(ESTR));
            if (retval != ERROR_OK)
                return retval;
#undef ESTR
        } else {
            tclc->tc_line[tclc->tc_lineoffset-1] = '\0';
            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-z as end of line to allow multiline results */
            tcl_output(connection, "\x1a", 1);
        }
 
        tclc->tc_lineoffset = 0;
        tclc->tc_linedrop = 0;
    }
 
    return ERROR_OK;
}
 
static int tcl_closed(struct connection *connection)
{
    struct tcl_connection *tclc;
    tclc = connection->priv;
 
    /* cleanup connection context */
    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) {
        LOG_INFO("tcl server disabled");
        return ERROR_OK;
    }
 
    return add_service(&tcl_service_driver, tcl_port, CONNECTION_LIMIT_UNLIMITED, NULL);
}
 
COMMAND_HANDLER(handle_tcl_port_command)
{
    return CALL_COMMAND_HANDLER(server_pipe_command, &tcl_port);
}
 
COMMAND_HANDLER(handle_tcl_notifications_command)
{
    struct connection *connection = NULL;
    struct tcl_connection *tclc = 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 && !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_subcommand_handlers[] = {
    {
        .name = "port",
        .handler = handle_tcl_port_command,
        .mode = COMMAND_CONFIG,
        .help = "Specify port on which to listen "
            "for incoming Tcl syntax.  "
            "Read help on 'gdb port'.",
        .usage = "[port_num]",
    },
    {
        .name = "notifications",
        .handler = handle_tcl_notifications_command,
        .mode = COMMAND_EXEC,
        .help = "Target Notification output",
        .usage = "[on|off]",
    },
    {
        .name = "trace",
        .handler = handle_tcl_trace_command,
        .mode = COMMAND_EXEC,
        .help = "Target trace output",
        .usage = "[on|off]",
    },
    COMMAND_REGISTRATION_DONE
};
 
static const struct command_registration tcl_command_handlers[] = {
    {
        .name = "tcl",
        .mode = COMMAND_ANY,
        .help = "tcl command group",
        .usage = "",
        .chain = tcl_subcommand_handlers,
    },
    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);
}