imi415
/
openocd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

build: cleanup src/server directory 

Change-Id: I6410df28c5999f5cbee2d3bcaa02469a29ea4c15
Signed-off-by: Spencer Oliver <spen@spen-soft.co.uk>
Reviewed-on: http://openocd.zylin.com/412
Tested-by: jenkins
This commit is contained in:
Spencer Oliver 2012-01-30 12:05:19 +00:00
parent 91e054a9ea
commit b48d1f6637
9 changed files with 702 additions and 975 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

956
src/server/gdb_server.c
View File

File diff suppressed because it is too large Load Diff

5
src/server/gdb_server.h
View File

@ -26,6 +26,7 @@
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef GDB_SERVER_H
#define GDB_SERVER_H
@ -33,7 +34,7 @@ struct image;
struct reg;
#include <target/target.h>
#define GDB_BUFFER_SIZE 16384
#define GDB_BUFFER_SIZE 16384
int gdb_target_add_all(struct target *target);
int gdb_register_commands(struct command_context *command_context);
@ -49,4 +50,4 @@ static inline struct target *get_target_from_connection(struct connection *conne
#define ERROR_GDB_BUFFER_TOO_SMALL (-800)
#define ERROR_GDB_TIMEOUT (-801)
#endif /* GDB_SERVER_H */
#endif /* GDB_SERVER_H */

273
src/server/server.c
View File

@ -23,6 +23,7 @@
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
@ -40,11 +41,10 @@
#include <netinet/tcp.h>
#endif
static struct service *services = NULL;
static struct service *services;
/* shutdown_openocd == 1: exit the main event loop, and quit the debugger */
static int shutdown_openocd = 0;
static int shutdown_openocd;
static int add_connection(struct service *service, struct command_context *cmd_ctx)
{
@ -63,34 +63,32 @@ static int add_connection(struct service *service, struct command_context *cmd_c
c->priv = NULL;
c->next = NULL;
if (service->type == CONNECTION_TCP)
{
if (service->type == CONNECTION_TCP) {
address_size = sizeof(c->sin);
c->fd = accept(service->fd, (struct sockaddr *)&service->sin, &address_size);
c->fd_out = c->fd;
/* This increases performance dramatically for e.g. GDB load which
* does not have a sliding window protocol.
* does not have a sliding window protocol.
*
* Ignore errors from this fn as it probably just means less performance
*/
setsockopt(c->fd, /* socket affected */
IPPROTO_TCP, /* set option at TCP level */
TCP_NODELAY, /* name of option */
(char *)&flag, /* the cast is historical cruft */
sizeof(int)); /* length of option value */
IPPROTO_TCP, /* set option at TCP level */
TCP_NODELAY, /* name of option */
(char *)&flag, /* the cast is historical cruft */
sizeof(int)); /* length of option value */
LOG_INFO("accepting '%s' connection from %s", service->name, service->port);
if ((retval = service->new_connection(c)) != ERROR_OK)
{
retval = service->new_connection(c);
if (retval != ERROR_OK) {
close_socket(c->fd);
LOG_ERROR("attempted '%s' connection rejected", service->name);
free(c);
return retval;
}
} else if (service->type == CONNECTION_STDINOUT)
{
} else if (service->type == CONNECTION_STDINOUT) {
c->fd = service->fd;
c->fd_out = fileno(stdout);
@ -103,30 +101,28 @@ static int add_connection(struct service *service, struct command_context *cmd_c
service->fd = -1;
LOG_INFO("accepting '%s' connection from pipe", service->name);
if ((retval = service->new_connection(c)) != ERROR_OK)
{
retval = service->new_connection(c);
if (retval != ERROR_OK) {
LOG_ERROR("attempted '%s' connection rejected", service->name);
free(c);
return retval;
}
} else if (service->type == CONNECTION_PIPE)
{
} else if (service->type == CONNECTION_PIPE) {
c->fd = service->fd;
/* do not check for new connections again on stdin */
service->fd = -1;
char * out_file = alloc_printf("%so", service->port);
char *out_file = alloc_printf("%so", service->port);
c->fd_out = open(out_file, O_WRONLY);
free(out_file);
if (c->fd_out == -1)
{
if (c->fd_out == -1) {
LOG_ERROR("could not open %s", service->port);
exit(1);
}
LOG_INFO("accepting '%s' connection from pipe %s", service->name, service->port);
if ((retval = service->new_connection(c)) != ERROR_OK)
{
retval = service->new_connection(c);
if (retval != ERROR_OK) {
LOG_ERROR("attempted '%s' connection rejected", service->name);
free(c);
return retval;
@ -134,7 +130,8 @@ static int add_connection(struct service *service, struct command_context *cmd_c
}
/* add to the end of linked list */
for (p = &service->connections; *p; p = &(*p)->next);
for (p = &service->connections; *p; p = &(*p)->next)
;
*p = c;
service->max_connections--;
@ -148,16 +145,12 @@ static int remove_connection(struct service *service, struct connection *connect
struct connection *c;
/* find connection */
while ((c = *p))
{
if (c->fd == connection->fd)
{
while ((c = *p)) {
if (c->fd == connection->fd) {
service->connection_closed(c);
if (service->type == CONNECTION_TCP)
{
close_socket(c->fd);
} else if (service->type == CONNECTION_PIPE)
{
else if (service->type == CONNECTION_PIPE) {
/* The service will listen to the pipe again */
c->service->fd = c->fd;
}
@ -180,7 +173,13 @@ static int remove_connection(struct service *service, struct connection *connect
}
/* FIX! make service return error instead of invoking exit() */
int add_service(char *name, const char *port, int max_connections, new_connection_handler_t new_connection_handler, input_handler_t input_handler, connection_closed_handler_t connection_closed_handler, void *priv)
int add_service(char *name,
const char *port,
int max_connections,
new_connection_handler_t new_connection_handler,
input_handler_t input_handler,
connection_closed_handler_t connection_closed_handler,
void *priv)
{
struct service *c, **p;
int so_reuseaddr_option = 1;
@ -189,7 +188,7 @@ int add_service(char *name, const char *port, int max_connections, new_connectio
c->name = strdup(name);
c->port = strdup(port);
c->max_connections = 1; /* Only TCP/IP ports can support more than one connection */
c->max_connections = 1; /* Only TCP/IP ports can support more than one connection */
c->fd = -1;
c->connections = NULL;
c->new_connection = new_connection_handler;
@ -199,33 +198,31 @@ int add_service(char *name, const char *port, int max_connections, new_connectio
c->next = NULL;
long portnumber;
if (strcmp(c->port, "pipe") == 0)
{
c->type = CONNECTION_STDINOUT;
} else
{
else {
char *end;
portnumber = strtol(c->port, &end, 0);
if (!*end && (parse_long(c->port, &portnumber) == ERROR_OK))
{
if (!*end && (parse_long(c->port, &portnumber) == ERROR_OK)) {
c->portnumber = portnumber;
c->type = CONNECTION_TCP;
} else
{
c->type = CONNECTION_PIPE;
}
}
if (c->type == CONNECTION_TCP)
{
if (c->type == CONNECTION_TCP) {
c->max_connections = max_connections;
if ((c->fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
c->fd = socket(AF_INET, SOCK_STREAM, 0);
if (c->fd == -1) {
LOG_ERROR("error creating socket: %s", strerror(errno));
exit(-1);
}
setsockopt(c->fd, SOL_SOCKET, SO_REUSEADDR, (void*)&so_reuseaddr_option, sizeof(int));
setsockopt(c->fd,
SOL_SOCKET,
SO_REUSEADDR,
(void *)&so_reuseaddr_option,
sizeof(int));
socket_nonblock(c->fd);
@ -234,8 +231,7 @@ int add_service(char *name, const char *port, int max_connections, new_connectio
c->sin.sin_addr.s_addr = INADDR_ANY;
c->sin.sin_port = htons(c->portnumber);
if (bind(c->fd, (struct sockaddr *)&c->sin, sizeof(c->sin)) == -1)
{
if (bind(c->fd, (struct sockaddr *)&c->sin, sizeof(c->sin)) == -1) {
LOG_ERROR("couldn't bind to socket: %s", strerror(errno));
exit(-1);
}
@ -253,14 +249,11 @@ int add_service(char *name, const char *port, int max_connections, new_connectio
setsockopt(c->fd, SOL_SOCKET, SO_RCVBUF,
(char *)&window_size, sizeof(window_size));
if (listen(c->fd, 1) == -1)
{
if (listen(c->fd, 1) == -1) {
LOG_ERROR("couldn't listen on socket: %s", strerror(errno));
exit(-1);
}
}
else if (c->type == CONNECTION_STDINOUT)
{
} else if (c->type == CONNECTION_STDINOUT) {
c->fd = fileno(stdin);
#ifdef _WIN32
@ -274,9 +267,7 @@ int add_service(char *name, const char *port, int max_connections, new_connectio
#else
socket_nonblock(c->fd);
#endif
}
else if (c->type == CONNECTION_PIPE)
{
} else if (c->type == CONNECTION_PIPE) {
#ifdef _WIN32
/* we currenty do not support named pipes under win32
* so exit openocd for now */
@ -285,8 +276,7 @@ int add_service(char *name, const char *port, int max_connections, new_connectio
#else
/* Pipe we're reading from */
c->fd = open(c->port, O_RDONLY | O_NONBLOCK);
if (c->fd == -1)
{
if (c->fd == -1) {
LOG_ERROR("could not open %s", c->port);
exit(1);
}
@ -294,7 +284,8 @@ int add_service(char *name, const char *port, int max_connections, new_connectio
}
/* add to the end of linked list */
for (p = &services; *p; p = &(*p)->next);
for (p = &services; *p; p = &(*p)->next)
;
*p = c;
return ERROR_OK;
@ -305,15 +296,13 @@ static int remove_services(void)
struct service *c = services;
/* loop service */
while (c)
{
while (c) {
struct service *next = c->next;
if (c->name)
free((void *)c->name);
if (c->type == CONNECTION_PIPE)
{
if (c->type == CONNECTION_PIPE) {
if (c->fd != -1)
close(c->fd);
}
@ -353,17 +342,14 @@ int server_loop(struct command_context *command_context)
LOG_ERROR("couldn't set SIGPIPE to SIG_IGN");
#endif
while (!shutdown_openocd)
{
while (!shutdown_openocd) {
/* monitor sockets for activity */
fd_max = 0;
FD_ZERO(&read_fds);
/* add service and connection fds to read_fds */
for (service = services; service; service = service->next)
{
if (service->fd != -1)
{
for (service = services; service; service = service->next) {
if (service->fd != -1) {
/* listen for new connections */
FD_SET(service->fd, &read_fds);
@ -371,12 +357,10 @@ int server_loop(struct command_context *command_context)
fd_max = service->fd;
}
if (service->connections)
{
if (service->connections) {
struct connection *c;
for (c = service->connections; c; c = c->next)
{
for (c = service->connections; c; c = c->next) {
/* check for activity on the connection */
FD_SET(c->fd, &read_fds);
if (c->fd > fd_max)
@ -387,14 +371,12 @@ int server_loop(struct command_context *command_context)
struct timeval tv;
tv.tv_sec = 0;
if (poll_ok)
{
if (poll_ok) {
/* we're just polling this iteration, this is faster on embedded
* hosts */
tv.tv_usec = 0;
retval = socket_select(fd_max + 1, &read_fds, NULL, NULL, &tv);
} else
{
} else {
/* Every 100ms */
tv.tv_usec = 100000;
/* Only while we're sleeping we'll let others run */
@ -404,45 +386,40 @@ int server_loop(struct command_context *command_context)
openocd_sleep_postlude();
}
if (retval == -1)
{
if (retval == -1) {
#ifdef _WIN32
errno = WSAGetLastError();
if (errno == WSAEINTR)
FD_ZERO(&read_fds);
else
{
else {
LOG_ERROR("error during select: %s", strerror(errno));
exit(-1);
}
#else
if (errno == EINTR)
{
FD_ZERO(&read_fds);
}
else
{
else {
LOG_ERROR("error during select: %s", strerror(errno));
exit(-1);
}
#endif
}
if (retval == 0)
{
/* We only execute these callbacks when there was nothing to do or we timed out */
if (retval == 0) {
/* We only execute these callbacks when there was nothing to do or we timed
*out */
target_call_timer_callbacks();
process_jim_events(command_context);
FD_ZERO(&read_fds); /* eCos leaves read_fds unchanged in this case! */
FD_ZERO(&read_fds); /* eCos leaves read_fds unchanged in this case! */
/* We timed out/there was nothing to do, timeout rather than poll next time */
/* We timed out/there was nothing to do, timeout rather than poll next time
**/
poll_ok = false;
} else
{
} else {
/* There was something to do, next time we'll just poll */
poll_ok = true;
}
@ -454,50 +431,45 @@ int server_loop(struct command_context *command_context)
*/
poll_ok = poll_ok || target_got_message();
for (service = services; service; service = service->next)
{
for (service = services; service; service = service->next) {
/* handle new connections on listeners */
if ((service->fd != -1)
&& (FD_ISSET(service->fd, &read_fds)))
{
&& (FD_ISSET(service->fd, &read_fds))) {
if (service->max_connections > 0)
{
add_connection(service, command_context);
}
else
{
if (service->type == CONNECTION_TCP)
{
else {
if (service->type == CONNECTION_TCP) {
struct sockaddr_in sin;
socklen_t address_size = sizeof(sin);
int tmp_fd;
tmp_fd = accept(service->fd, (struct sockaddr *)&service->sin, &address_size);
tmp_fd = accept(service->fd,
(struct sockaddr *)&service->sin,
&address_size);
close_socket(tmp_fd);
}
LOG_INFO("rejected '%s' connection, no more connections allowed", service->name);
LOG_INFO(
"rejected '%s' connection, no more connections allowed",
service->name);
}
}
/* handle activity on connections */
if (service->connections)
{
if (service->connections) {
struct connection *c;
for (c = service->connections; c;)
{
if ((FD_ISSET(c->fd, &read_fds)) || c->input_pending)
{
for (c = service->connections; c; ) {
if ((FD_ISSET(c->fd, &read_fds)) || c->input_pending) {
retval = service->input(c);
if (retval != ERROR_OK)
{
if (retval != ERROR_OK) {
struct connection *next = c->next;
if (service->type == CONNECTION_PIPE)
{
/* if connection uses a pipe then shutdown openocd on error */
if (service->type == CONNECTION_PIPE) {
/* if connection uses a pipe then
*shutdown openocd on error */
shutdown_openocd = 1;
}
remove_connection(service, c);
LOG_INFO("dropped '%s' connection", service->name);
LOG_INFO("dropped '%s' connection",
service->name);
c = next;
continue;
}
@ -509,8 +481,7 @@ int server_loop(struct command_context *command_context)
#ifdef _WIN32
MSG msg;
while (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
if (msg.message == WM_QUIT)
shutdown_openocd = 1;
}
@ -527,7 +498,8 @@ BOOL WINAPI ControlHandler(DWORD dwCtrlType)
return TRUE;
}
void sig_handler(int sig) {
void sig_handler(int sig)
{
shutdown_openocd = 1;
}
#endif
@ -544,8 +516,7 @@ int server_preinit(void)
wVersionRequested = MAKEWORD(2, 2);
if (WSAStartup(wVersionRequested, &wsaData) != 0)
{
if (WSAStartup(wVersionRequested, &wsaData) != 0) {
LOG_ERROR("Failed to Open Winsock");
exit(-1);
}
@ -585,29 +556,22 @@ int server_quit(void)
int connection_write(struct connection *connection, const void *data, int len)
{
if (len == 0)
{
if (len == 0) {
/* successful no-op. Sockets and pipes behave differently here... */
return 0;
}
if (connection->service->type == CONNECTION_TCP)
{
return write_socket(connection->fd_out, data, len);
} else
{
else
return write(connection->fd_out, data, len);
}
}
int connection_read(struct connection *connection, void *data, int len)
{
if (connection->service->type == CONNECTION_TCP)
{
return read_socket(connection->fd, data, len);
} else
{
else
return read(connection->fd, data, len);
}
}
/* tell the server we want to shut down */
@ -647,18 +611,18 @@ int server_register_commands(struct command_context *cmd_ctx)
SERVER_PORT_COMMAND()
{
switch (CMD_ARGC) {
case 0:
command_print(CMD_CTX, "%d", *out);
break;
case 1:
{
uint16_t port;
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], port);
*out = port;
break;
}
default:
return ERROR_COMMAND_SYNTAX_ERROR;
case 0:
command_print(CMD_CTX, "%d", *out);
break;
case 1:
{
uint16_t port;
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], port);
*out = port;
break;
}
default:
return ERROR_COMMAND_SYNTAX_ERROR;
}
return ERROR_OK;
}
@ -666,19 +630,18 @@ SERVER_PORT_COMMAND()
SERVER_PIPE_COMMAND()
{
switch (CMD_ARGC) {
case 0:
command_print(CMD_CTX, "%s", *out);
break;
case 1:
{
const char * t = strdup(CMD_ARGV[0]);
free((void *)*out);
*out = t;
break;
}
default:
return ERROR_COMMAND_SYNTAX_ERROR;
case 0:
command_print(CMD_CTX, "%s", *out);
break;
case 1:
{
const char *t = strdup(CMD_ARGV[0]);
free((void *)*out);
*out = t;
break;
}
default:
return ERROR_COMMAND_SYNTAX_ERROR;
}
return ERROR_OK;
}

22
src/server/server.h
View File

@ -23,6 +23,7 @@
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef SERVER_H
#define SERVER_H
@ -32,17 +33,15 @@
#include <netinet/in.h>
#endif
enum connection_type
{
enum connection_type {
CONNECTION_TCP,
CONNECTION_PIPE,
CONNECTION_STDINOUT
};
struct connection
{
struct connection {
int fd;
int fd_out; /* When using pipes we're writing to a different fd */
int fd_out; /* When using pipes we're writing to a different fd */
struct sockaddr_in sin;
struct command_context *cmd_ctx;
struct service *service;
@ -55,8 +54,7 @@ typedef int (*new_connection_handler_t)(struct connection *connection);
typedef int (*input_handler_t)(struct connection *connection);
typedef int (*connection_closed_handler_t)(struct connection *connection);
struct service
{
struct service {
const char *name;
enum connection_type type;
const char *port;
@ -104,15 +102,15 @@ void openocd_sleep_postlude(void);
* to receive the specified port number.
*/
#define SERVER_PIPE_COMMAND() \
COMMAND_HELPER(server_pipe_command, const char **out)
COMMAND_HELPER(server_pipe_command, const char **out)
SERVER_PIPE_COMMAND();
#define SERVER_PORT_COMMAND() \
COMMAND_HELPER(server_port_command, unsigned short *out)
COMMAND_HELPER(server_port_command, unsigned short *out)
SERVER_PORT_COMMAND();
#define ERROR_SERVER_REMOTE_CLOSED (-400)
#define ERROR_CONNECTION_REJECTED (-401)
#define ERROR_SERVER_REMOTE_CLOSED (-400)
#define ERROR_CONNECTION_REJECTED (-401)
#endif /* SERVER_H */
#endif /* SERVER_H */

4
src/server/server_stubs.c
View File

@ -24,9 +24,9 @@
void openocd_sleep_prelude(void)
{
// no-op
/* no-op */
}
void openocd_sleep_postlude(void)
{
// no-op
/* no-op */
}

25
src/server/tcl_server.c
View File

@ -24,15 +24,14 @@
#include "tcl_server.h"
#define TCL_SERVER_VERSION "TCL Server 0.1"
#define TCL_MAX_LINE (4096)
#define TCL_SERVER_VERSION "TCL Server 0.1"
#define TCL_MAX_LINE (4096)
struct tcl_connection {
int tc_linedrop;
int tc_lineoffset;
char tc_line[TCL_MAX_LINE];
int tc_outerror; /* flag an output error */
int tc_outerror;/* flag an output error */
};
static const char *tcl_port;
@ -104,8 +103,7 @@ static int tcl_input(struct connection *connection)
return ERROR_CONNECTION_REJECTED;
/* push as much data into the line as possible */
for (i = 0; i < rlen; i++)
{
for (i = 0; i < rlen; i++) {
/* buffer the data */
tclc->tc_line[tclc->tc_lineoffset] = in[i];
if (tclc->tc_lineoffset < TCL_MAX_LINE)
@ -127,12 +125,12 @@ static int tcl_input(struct connection *connection)
if (retval != ERROR_OK)
return retval;
#undef ESTR
}
else {
} else {
tclc->tc_line[tclc->tc_lineoffset-1] = '\0';
LOG_DEBUG("Executing script:\n %s", tclc->tc_line);
retval = Jim_Eval_Named(interp, tclc->tc_line, "remote:connection",1);
LOG_DEBUG("Result: %d\n %s", retval, Jim_GetString(Jim_GetResult(interp), &reslen));
retval = Jim_Eval_Named(interp, tclc->tc_line, "remote:connection", 1);
LOG_DEBUG("Result: %d\n %s", retval,
Jim_GetString(Jim_GetResult(interp), &reslen));
result = Jim_GetString(Jim_GetResult(interp), &reslen);
retval = tcl_output(connection, result, reslen);
if (retval != ERROR_OK)
@ -160,15 +158,14 @@ static int tcl_closed(struct connection *connection)
int tcl_init(void)
{
if (strcmp(tcl_port, "disabled") == 0)
{
if (strcmp(tcl_port, "disabled") == 0) {
LOG_INFO("tcl server disabled");
return ERROR_OK;
}
return add_service("tcl", tcl_port, 1,
&tcl_new_connection, &tcl_input,
&tcl_closed, NULL);
&tcl_new_connection, &tcl_input,
&tcl_closed, NULL);
}
COMMAND_HANDLER(handle_tcl_port_command)

2
src/server/tcl_server.h
View File

@ -25,4 +25,4 @@
int tcl_init(void);
int tcl_register_commands(struct command_context *cmd_ctx);
#endif /* _TCL_SERVER_H_ */
#endif /* _TCL_SERVER_H_ */

378
src/server/telnet_server.c
View File

@ -23,6 +23,7 @@
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
@ -33,10 +34,10 @@
static const char *telnet_port;
static char *negotiate =
"\xFF\xFB\x03" /* IAC WILL Suppress Go Ahead */
"\xFF\xFB\x01" /* IAC WILL Echo */
"\xFF\xFD\x03" /* IAC DO Suppress Go Ahead */
"\xFF\xFE\x01"; /* IAC DON'T Echo */
"\xFF\xFB\x03" /* IAC WILL Suppress Go Ahead */
"\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 - '@')
@ -45,16 +46,14 @@ static char *negotiate =
* succeed. Shudder!
*/
static int telnet_write(struct connection *connection, const void *data,
int len)
int len)
{
struct telnet_connection *t_con = connection->priv;
if (t_con->closed)
return ERROR_SERVER_REMOTE_CLOSED;
if (connection_write(connection, data, len) == len)
{
return ERROR_OK;
}
t_con->closed = 1;
return ERROR_SERVER_REMOTE_CLOSED;
}
@ -80,21 +79,17 @@ static int telnet_outputline(struct connection *connection, const char *line)
len = strlen(line);
telnet_write(connection, line, len);
if (line_end)
{
if (line_end) {
telnet_write(connection, "\r\n", 2);
line += len + 1;
}
else
{
} else
line += len;
}
}
return ERROR_OK;
}
static int telnet_output(struct command_context *cmd_ctx, const char* line)
static int telnet_output(struct command_context *cmd_ctx, const char *line)
{
struct connection *connection = cmd_ctx->output_handler_priv;
@ -102,15 +97,14 @@ static int telnet_output(struct command_context *cmd_ctx, const char* line)
}
static void telnet_log_callback(void *priv, const char *file, unsigned line,
const char *function, const char *string)
const char *function, const char *string)
{
struct connection *connection = priv;
struct telnet_connection *t_con = connection->priv;
int i;
/* if there is no prompt, simply output the message */
if (t_con->line_cursor < 0)
{
if (t_con->line_cursor < 0) {
telnet_outputline(connection, string);
return;
}
@ -156,20 +150,18 @@ static int telnet_new_connection(struct connection *connection)
telnet_write(connection, negotiate, strlen(negotiate));
/* print connection banner */
if (telnet_service->banner)
{
if (telnet_service->banner) {
telnet_write(connection, telnet_service->banner, strlen(telnet_service->banner));
telnet_write(connection, "\r\n", 2);
}
telnet_write(connection, "\r", 1); /* the prompt is always placed at the line beginning */
telnet_write(connection, "\r", 1); /* the prompt is always placed at the line beginning
**/
telnet_prompt(connection);
/* initialize history */
for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++)
{
telnet_connection->history[i] = NULL;
}
telnet_connection->next_history = 0;
telnet_connection->current_history = 0;
@ -179,17 +171,16 @@ static int telnet_new_connection(struct connection *connection)
}
static void telnet_clear_line(struct connection *connection,
struct telnet_connection *t_con)
struct telnet_connection *t_con)
{
/* move to end of line */
if (t_con->line_cursor < t_con->line_size)
{
telnet_write(connection, 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)
{
while (t_con->line_size > 0) {
telnet_write(connection, "\b \b", 3);
t_con->line_size--;
}
@ -208,71 +199,68 @@ static int telnet_input(struct connection *connection)
if (bytes_read == 0)
return ERROR_SERVER_REMOTE_CLOSED;
else if (bytes_read == -1)
{
else if (bytes_read == -1) {
LOG_ERROR("error during read: %s", strerror(errno));
return ERROR_SERVER_REMOTE_CLOSED;
}
buf_p = buffer;
while (bytes_read)
{
switch (t_con->state)
{
while (bytes_read) {
switch (t_con->state) {
case TELNET_STATE_DATA:
if (*buf_p == 0xff)
{
t_con->state = TELNET_STATE_IAC;
}
else
{
if (isprint(*buf_p)) /* printable character */
{
/* watch buffer size leaving one spare character for string null termination */
if (t_con->line_size == TELNET_LINE_MAX_SIZE-1)
{
else {
if (isprint(*buf_p)) { /* printable character */
/* 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, "\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++;
}
else
{
} else {
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);
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_size++;
telnet_write(connection, 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++)
{
telnet_write(connection, "\b", 1);
}
}
}
else /* non-printable */
{
if (*buf_p == 0x1b) /* escape */
{
} else { /* non-printable */
if (*buf_p == 0x1b) { /* escape */
t_con->state = TELNET_STATE_ESCAPE;
t_con->last_escape = '\x00';
}
else if ((*buf_p == 0xd) || (*buf_p == 0xa)) /* CR/LF */
{
} else if ((*buf_p == 0xd) || (*buf_p == 0xa)) { /*
*CR/LF
**/
int retval;
/* skip over combinations with CR/LF and NUL characters */
if ((bytes_read > 1) && ((*(buf_p + 1) == 0xa) || (*(buf_p + 1) == 0xd)))
{
/* 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 ((bytes_read > 1) && (*(buf_p + 1) == 0))
{
if ((bytes_read > 1) && (*(buf_p + 1) == 0)) {
buf_p++;
bytes_read--;
}
@ -280,16 +268,19 @@ static int telnet_input(struct connection *connection)
telnet_write(connection, "\r\n\x00", 3);
if (strcmp(t_con->line, "history") == 0)
{
if (strcmp(t_con->line, "history") == 0) {
int i;
for (i = 1; i < TELNET_LINE_HISTORY_SIZE; 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, history_line, strlen(history_line));
for (i = 1; i < TELNET_LINE_HISTORY_SIZE; 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, history_line,
strlen(history_line));
telnet_write(connection, "\r\n\x00", 3);
}
}
@ -298,35 +289,41 @@ static int telnet_input(struct connection *connection)
continue;
}
/* 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 */
/* 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;
/* 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("");
}
t_con->line_size = 0;
t_con->line_cursor = -1; /* to supress prompt in log callback during command execution */
t_con->line_cursor = -1; /* to supress prompt
*in log callback
*during command
*execution */
retval = command_run_line(command_context, t_con->line);
@ -335,83 +332,84 @@ static int telnet_input(struct connection *connection)
if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
return ERROR_SERVER_REMOTE_CLOSED;
telnet_write(connection, "\r", 1); /* the prompt is always placed at the line beginning */
telnet_write(connection, "\r", 1); /*
*the
*prompt
*is
*always
*placed
*at
*the
*line
*beginning
**/
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 */
{
if (t_con->line_cursor > 0)
{
if (t_con->line_cursor != t_con->line_size)
{
} else if ((*buf_p == 0x7f) || (*buf_p == 0x8)) { /*
*delete
*character
**/
if (t_con->line_cursor > 0) {
if (t_con->line_cursor != t_con->line_size) {
int i;
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);
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,
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++)
{
telnet_write(connection, "\b", 1);
}
}
else
{
} else {
t_con->line_size--;
t_con->line_cursor--;
/* back space: move the 'printer' head one char back, overwrite with space, move back again */
/* back space: move the
*'printer' head one char
*back, overwrite with
*space, move back again */
telnet_write(connection, "\b \b", 3);
}
}
}
else if (*buf_p == 0x15) /* clear line */
{
} else if (*buf_p == 0x15) /* clear line */
telnet_clear_line(connection, t_con);
}
else if (*buf_p == CTRL('B')) /* cursor left */
{
if (t_con->line_cursor > 0)
{
else if (*buf_p == CTRL('B')) { /* cursor left */
if (t_con->line_cursor > 0) {
telnet_write(connection, "\b", 1);
t_con->line_cursor--;
}
t_con->state = TELNET_STATE_DATA;
}
else if (*buf_p == CTRL('F')) /* cursor right */
{
} else if (*buf_p == CTRL('F')) { /* cursor right */
if (t_con->line_cursor < t_con->line_size)
{
telnet_write(connection, t_con->line + t_con->line_cursor++, 1);
}
t_con->state = TELNET_STATE_DATA;
}
else
{
} else
LOG_DEBUG("unhandled nonprintable: %2.2x", *buf_p);
}
}
}
break;
case TELNET_STATE_IAC:
switch (*buf_p)
{
case 0xfe:
t_con->state = TELNET_STATE_DONT;
break;
case 0xfd:
t_con->state = TELNET_STATE_DO;
break;
case 0xfc:
t_con->state = TELNET_STATE_WONT;
break;
case 0xfb:
t_con->state = TELNET_STATE_WILL;
break;
switch (*buf_p) {
case 0xfe:
t_con->state = TELNET_STATE_DONT;
break;
case 0xfd:
t_con->state = TELNET_STATE_DO;
break;
case 0xfc:
t_con->state = TELNET_STATE_WONT;
break;
case 0xfb:
t_con->state = TELNET_STATE_WILL;
break;
}
break;
case TELNET_STATE_SB:
@ -425,30 +423,22 @@ static int telnet_input(struct connection *connection)
t_con->state = TELNET_STATE_DATA;
break;
case TELNET_STATE_ESCAPE:
if (t_con->last_escape == '[')
{
if (*buf_p == 'D') /* cursor left */
{
if (t_con->line_cursor > 0)
{
if (t_con->last_escape == '[') {
if (*buf_p == 'D') { /* cursor left */
if (t_con->line_cursor > 0) {
telnet_write(connection, "\b", 1);
t_con->line_cursor--;
}
t_con->state = TELNET_STATE_DATA;
}
else if (*buf_p == 'C') /* cursor right */
{
} else if (*buf_p == 'C') { /* cursor right */
if (t_con->line_cursor < t_con->line_size)
{
telnet_write(connection, 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 if (*buf_p == 'A') /* cursor up */
{
int last_history = (t_con->current_history > 0) ? t_con->current_history - 1 : TELNET_LINE_HISTORY_SIZE-1;
if (t_con->history[last_history])
{
} else if (*buf_p == 'A') { /* cursor up */
int last_history = (t_con->current_history > 0) ?
t_con->current_history - 1 : TELNET_LINE_HISTORY_SIZE-1;
if (t_con->history[last_history]) {
telnet_clear_line(connection, t_con);
t_con->line_size = strlen(t_con->history[last_history]);
t_con->line_cursor = t_con->line_size;
@ -457,12 +447,9 @@ static int telnet_input(struct connection *connection)
t_con->current_history = last_history;
}
t_con->state = TELNET_STATE_DATA;
}
else if (*buf_p == 'B') /* cursor down */
{
} else if (*buf_p == 'B') { /* cursor down */
int next_history = (t_con->current_history + 1) % TELNET_LINE_HISTORY_SIZE;
if (t_con->history[next_history])
{
if (t_con->history[next_history]) {
telnet_clear_line(connection, t_con);
t_con->line_size = strlen(t_con->history[next_history]);
t_con->line_cursor = t_con->line_size;
@ -471,60 +458,41 @@ static int telnet_input(struct connection *connection)
t_con->current_history = next_history;
}
t_con->state = TELNET_STATE_DATA;
}
else if (*buf_p == '3')
{
} else if (*buf_p == '3')
t_con->last_escape = *buf_p;
}
else
{
t_con->state = TELNET_STATE_DATA;
}
}
else if (t_con->last_escape == '3')
{
} else if (t_con->last_escape == '3') {
/* Remove character */
if (*buf_p == '~')
{
if (t_con->line_cursor < t_con->line_size)
{
if (*buf_p == '~') {
if (t_con->line_cursor < t_con->line_size) {
int i;
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);
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);
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
{
} else
t_con->state = TELNET_STATE_DATA;
}
}
else if (t_con->last_escape == '\x00')
{
} else if (t_con->last_escape == '\x00') {
if (*buf_p == '[')
{
t_con->last_escape = *buf_p;
}
else
{
t_con->state = TELNET_STATE_DATA;
}
}
else
{
} else {
LOG_ERROR("BUG: unexpected value in t_con->last_escape");
t_con->state = TELNET_STATE_DATA;
}
@ -549,16 +517,13 @@ static int telnet_connection_closed(struct connection *connection)
log_remove_callback(telnet_log_callback, connection);
if (t_con->prompt)
{
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])
{
for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++) {
if (t_con->history[i]) {
free(t_con->history[i]);
t_con->history[i] = NULL;
}
@ -567,23 +532,18 @@ static int telnet_connection_closed(struct connection *connection)
/* 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);
connection->priv = NULL;
}
else
{
} else
LOG_ERROR("BUG: connection->priv == NULL");
}
return ERROR_OK;
}
int telnet_init(char *banner)
{
if (strcmp(telnet_port, "disabled") == 0)
{
if (strcmp(telnet_port, "disabled") == 0) {
LOG_INFO("telnet server disabled");
return ERROR_OK;
}
@ -592,7 +552,13 @@ int telnet_init(char *banner)
telnet_service->banner = banner;
return add_service("telnet", telnet_port, 1, telnet_new_connection, telnet_input, telnet_connection_closed, telnet_service);
return add_service("telnet",
telnet_port,
1,
telnet_new_connection,
telnet_input,
telnet_connection_closed,
telnet_service);
}
/* daemon configuration command telnet_port */

12
src/server/telnet_server.h
View File

@ -23,6 +23,7 @@
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef TELNET_SERVER_H
#define TELNET_SERVER_H
@ -34,8 +35,7 @@
#define TELNET_LINE_HISTORY_SIZE (128)
#define TELNET_LINE_MAX_SIZE (256)
enum telnet_states
{
enum telnet_states {
TELNET_STATE_DATA,
TELNET_STATE_IAC,
TELNET_STATE_SB,
@ -47,8 +47,7 @@ enum telnet_states
TELNET_STATE_ESCAPE,
};
struct telnet_connection
{
struct telnet_connection {
char *prompt;
enum telnet_states state;
char line[TELNET_LINE_MAX_SIZE];
@ -63,12 +62,11 @@ struct telnet_connection
int closed;
};
struct telnet_service
{
struct telnet_service {
char *banner;
};
int telnet_init(char *banner);
int telnet_register_commands(struct command_context *command_context);
#endif /* TELNET_SERVER_H */
#endif /* TELNET_SERVER_H */