interesting
/
riscv-openocd
mirror of https://github.com/riscv/riscv-openocd.git
1
0
Fork 0
Code Issues 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., * * Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#ifndef GDB_SERVER_H #ifndef GDB_SERVER_H
#define GDB_SERVER_H #define GDB_SERVER_H
@ -33,7 +34,7 @@ struct image;
struct reg; struct reg;
#include <target/target.h> #include <target/target.h>
#define GDB_BUFFER_SIZE 16384 #define GDB_BUFFER_SIZE 16384
int gdb_target_add_all(struct target *target); int gdb_target_add_all(struct target *target);
int gdb_register_commands(struct command_context *command_context); 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_BUFFER_TOO_SMALL (-800)
#define ERROR_GDB_TIMEOUT (-801) #define ERROR_GDB_TIMEOUT (-801)
#endif /* GDB_SERVER_H */ #endif /* GDB_SERVER_H */

271
src/server/server.c
View File

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

22
src/server/server.h
View File

@ -23,6 +23,7 @@
* Free Software Foundation, Inc., * * Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#ifndef SERVER_H #ifndef SERVER_H
#define SERVER_H #define SERVER_H
@ -32,17 +33,15 @@
#include <netinet/in.h> #include <netinet/in.h>
#endif #endif
enum connection_type enum connection_type {
{
CONNECTION_TCP, CONNECTION_TCP,
CONNECTION_PIPE, CONNECTION_PIPE,
CONNECTION_STDINOUT CONNECTION_STDINOUT
}; };
struct connection struct connection {
{
int fd; 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 sockaddr_in sin;
struct command_context *cmd_ctx; struct command_context *cmd_ctx;
struct service *service; 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 (*input_handler_t)(struct connection *connection);
typedef int (*connection_closed_handler_t)(struct connection *connection); typedef int (*connection_closed_handler_t)(struct connection *connection);
struct service struct service {
{
const char *name; const char *name;
enum connection_type type; enum connection_type type;
const char *port; const char *port;
@ -104,15 +102,15 @@ void openocd_sleep_postlude(void);
* to receive the specified port number. * to receive the specified port number.
*/ */
#define SERVER_PIPE_COMMAND() \ #define SERVER_PIPE_COMMAND() \
COMMAND_HELPER(server_pipe_command, const char **out) COMMAND_HELPER(server_pipe_command, const char **out)
SERVER_PIPE_COMMAND(); SERVER_PIPE_COMMAND();
#define SERVER_PORT_COMMAND() \ #define SERVER_PORT_COMMAND() \
COMMAND_HELPER(server_port_command, unsigned short *out) COMMAND_HELPER(server_port_command, unsigned short *out)
SERVER_PORT_COMMAND(); SERVER_PORT_COMMAND();
#define ERROR_SERVER_REMOTE_CLOSED (-400) #define ERROR_SERVER_REMOTE_CLOSED (-400)
#define ERROR_CONNECTION_REJECTED (-401) #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) void openocd_sleep_prelude(void)
{ {
// no-op /* no-op */
} }
void openocd_sleep_postlude(void) 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" #include "tcl_server.h"
#define TCL_SERVER_VERSION "TCL Server 0.1"
#define TCL_SERVER_VERSION "TCL Server 0.1" #define TCL_MAX_LINE (4096)
#define TCL_MAX_LINE (4096)
struct tcl_connection { struct tcl_connection {
int tc_linedrop; int tc_linedrop;
int tc_lineoffset; int tc_lineoffset;
char tc_line[TCL_MAX_LINE]; 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; static const char *tcl_port;
@ -104,8 +103,7 @@ static int tcl_input(struct connection *connection)
return ERROR_CONNECTION_REJECTED; return ERROR_CONNECTION_REJECTED;
/* push as much data into the line as possible */ /* push as much data into the line as possible */
for (i = 0; i < rlen; i++) for (i = 0; i < rlen; i++) {
{
/* buffer the data */ /* buffer the data */
tclc->tc_line[tclc->tc_lineoffset] = in[i]; tclc->tc_line[tclc->tc_lineoffset] = in[i];
if (tclc->tc_lineoffset < TCL_MAX_LINE) if (tclc->tc_lineoffset < TCL_MAX_LINE)
@ -127,12 +125,12 @@ static int tcl_input(struct connection *connection)
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
#undef ESTR #undef ESTR
} } else {
else {
tclc->tc_line[tclc->tc_lineoffset-1] = '\0'; tclc->tc_line[tclc->tc_lineoffset-1] = '\0';
LOG_DEBUG("Executing script:\n %s", tclc->tc_line); LOG_DEBUG("Executing script:\n %s", tclc->tc_line);
retval = Jim_Eval_Named(interp, tclc->tc_line, "remote:connection",1); retval = Jim_Eval_Named(interp, tclc->tc_line, "remote:connection", 1);
LOG_DEBUG("Result: %d\n %s", retval, Jim_GetString(Jim_GetResult(interp), &reslen)); LOG_DEBUG("Result: %d\n %s", retval,
Jim_GetString(Jim_GetResult(interp), &reslen));
result = Jim_GetString(Jim_GetResult(interp), &reslen); result = Jim_GetString(Jim_GetResult(interp), &reslen);
retval = tcl_output(connection, result, reslen); retval = tcl_output(connection, result, reslen);
if (retval != ERROR_OK) if (retval != ERROR_OK)
@ -160,15 +158,14 @@ static int tcl_closed(struct connection *connection)
int tcl_init(void) int tcl_init(void)
{ {
if (strcmp(tcl_port, "disabled") == 0) if (strcmp(tcl_port, "disabled") == 0) {
{
LOG_INFO("tcl server disabled"); LOG_INFO("tcl server disabled");
return ERROR_OK; return ERROR_OK;
} }
return add_service("tcl", tcl_port, 1, return add_service("tcl", tcl_port, 1,
&tcl_new_connection, &tcl_input, &tcl_new_connection, &tcl_input,
&tcl_closed, NULL); &tcl_closed, NULL);
} }
COMMAND_HANDLER(handle_tcl_port_command) COMMAND_HANDLER(handle_tcl_port_command)

2
src/server/tcl_server.h
View File

@ -25,4 +25,4 @@
int tcl_init(void); int tcl_init(void);
int tcl_register_commands(struct command_context *cmd_ctx); 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., * * Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include "config.h" #include "config.h"
#endif #endif
@ -33,10 +34,10 @@
static const char *telnet_port; static const char *telnet_port;
static char *negotiate = static char *negotiate =
"\xFF\xFB\x03" /* IAC WILL Suppress Go Ahead */ "\xFF\xFB\x03" /* IAC WILL Suppress Go Ahead */
"\xFF\xFB\x01" /* IAC WILL Echo */ "\xFF\xFB\x01" /* IAC WILL Echo */
"\xFF\xFD\x03" /* IAC DO Suppress Go Ahead */ "\xFF\xFD\x03" /* IAC DO Suppress Go Ahead */
"\xFF\xFE\x01"; /* IAC DON'T Echo */ "\xFF\xFE\x01"; /* IAC DON'T Echo */
#define CTRL(c) (c - '@') #define CTRL(c) (c - '@')
@ -45,16 +46,14 @@ static char *negotiate =
* succeed. Shudder! * succeed. Shudder!
*/ */
static int telnet_write(struct connection *connection, const void *data, static int telnet_write(struct connection *connection, const void *data,
int len) int len)
{ {
struct telnet_connection *t_con = connection->priv; struct telnet_connection *t_con = connection->priv;
if (t_con->closed) if (t_con->closed)
return ERROR_SERVER_REMOTE_CLOSED; return ERROR_SERVER_REMOTE_CLOSED;
if (connection_write(connection, data, len) == len) if (connection_write(connection, data, len) == len)
{
return ERROR_OK; return ERROR_OK;
}
t_con->closed = 1; t_con->closed = 1;
return ERROR_SERVER_REMOTE_CLOSED; return ERROR_SERVER_REMOTE_CLOSED;
} }
@ -80,21 +79,17 @@ static int telnet_outputline(struct connection *connection, const char *line)
len = strlen(line); len = strlen(line);
telnet_write(connection, line, len); telnet_write(connection, line, len);
if (line_end) if (line_end) {
{
telnet_write(connection, "\r\n", 2); telnet_write(connection, "\r\n", 2);
line += len + 1; line += len + 1;
} } else
else
{
line += len; line += len;
}
} }
return ERROR_OK; 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; 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, 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 connection *connection = priv;
struct telnet_connection *t_con = connection->priv; struct telnet_connection *t_con = connection->priv;
int i; int i;
/* if there is no prompt, simply output the message */ /* 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); telnet_outputline(connection, string);
return; return;
} }
@ -156,20 +150,18 @@ static int telnet_new_connection(struct connection *connection)
telnet_write(connection, negotiate, strlen(negotiate)); telnet_write(connection, negotiate, strlen(negotiate));
/* print connection banner */ /* print connection banner */
if (telnet_service->banner) if (telnet_service->banner) {
{
telnet_write(connection, telnet_service->banner, strlen(telnet_service->banner)); telnet_write(connection, telnet_service->banner, strlen(telnet_service->banner));
telnet_write(connection, "\r\n", 2); 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); telnet_prompt(connection);
/* initialize history */ /* initialize history */
for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++) for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++)
{
telnet_connection->history[i] = NULL; telnet_connection->history[i] = NULL;
}
telnet_connection->next_history = 0; telnet_connection->next_history = 0;
telnet_connection->current_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, static void telnet_clear_line(struct connection *connection,
struct telnet_connection *t_con) struct telnet_connection *t_con)
{ {
/* move to end of line */ /* move to end of line */
if (t_con->line_cursor < t_con->line_size) if (t_con->line_cursor < t_con->line_size)
{ telnet_write(connection,
telnet_write(connection, t_con->line + t_con->line_cursor, t_con->line_size - t_con->line_cursor); t_con->line + t_con->line_cursor,
} t_con->line_size - t_con->line_cursor);
/* backspace, overwrite with space, backspace */ /* backspace, overwrite with space, backspace */
while (t_con->line_size > 0) while (t_con->line_size > 0) {
{
telnet_write(connection, "\b \b", 3); telnet_write(connection, "\b \b", 3);
t_con->line_size--; t_con->line_size--;
} }
@ -208,71 +199,68 @@ static int telnet_input(struct connection *connection)
if (bytes_read == 0) if (bytes_read == 0)
return ERROR_SERVER_REMOTE_CLOSED; return ERROR_SERVER_REMOTE_CLOSED;
else if (bytes_read == -1) else if (bytes_read == -1) {
{
LOG_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; buf_p = buffer;
while (bytes_read) while (bytes_read) {
{ switch (t_con->state) {
switch (t_con->state)
{
case TELNET_STATE_DATA: case TELNET_STATE_DATA:
if (*buf_p == 0xff) if (*buf_p == 0xff)
{
t_con->state = TELNET_STATE_IAC; t_con->state = TELNET_STATE_IAC;
} else {
else if (isprint(*buf_p)) { /* printable character */
{ /* watch buffer size leaving one spare character for
if (isprint(*buf_p)) /* printable character */ *string null termination */
{ if (t_con->line_size == TELNET_LINE_MAX_SIZE-1) {
/* 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 */ /* output audible bell if buffer is full */
telnet_write(connection, "\x07", 1); /* "\a" does not work, at least on windows */ telnet_write(connection, "\x07", 1); /*
} *"\a"
else if (t_con->line_cursor == t_con->line_size) *does
{ *not
*work,
*at
*least
*on
*windows
**/
} else if (t_con->line_cursor == t_con->line_size) {
telnet_write(connection, buf_p, 1); telnet_write(connection, buf_p, 1);
t_con->line[t_con->line_size++] = *buf_p; t_con->line[t_con->line_size++] = *buf_p;
t_con->line_cursor++; t_con->line_cursor++;
} } else {
else
{
int i; 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[t_con->line_cursor] = *buf_p;
t_con->line_size++; 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++; 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++)
{
telnet_write(connection, "\b", 1); telnet_write(connection, "\b", 1);
}
} }
} } else { /* non-printable */
else /* non-printable */ if (*buf_p == 0x1b) { /* escape */
{
if (*buf_p == 0x1b) /* escape */
{
t_con->state = TELNET_STATE_ESCAPE; t_con->state = TELNET_STATE_ESCAPE;
t_con->last_escape = '\x00'; t_con->last_escape = '\x00';
} } else if ((*buf_p == 0xd) || (*buf_p == 0xa)) { /*
else if ((*buf_p == 0xd) || (*buf_p == 0xa)) /* CR/LF */ *CR/LF
{ **/
int retval; int retval;
/* skip over combinations with CR/LF and NUL characters */ /* skip over combinations with CR/LF and NUL
if ((bytes_read > 1) && ((*(buf_p + 1) == 0xa) || (*(buf_p + 1) == 0xd))) *characters */
{ if ((bytes_read > 1) && ((*(buf_p + 1) == 0xa) ||
(*(buf_p + 1) == 0xd))) {
buf_p++; buf_p++;
bytes_read--; bytes_read--;
} }
if ((bytes_read > 1) && (*(buf_p + 1) == 0)) if ((bytes_read > 1) && (*(buf_p + 1) == 0)) {
{
buf_p++; buf_p++;
bytes_read--; bytes_read--;
} }
@ -280,16 +268,19 @@ static int telnet_input(struct connection *connection)
telnet_write(connection, "\r\n\x00", 3); telnet_write(connection, "\r\n\x00", 3);
if (strcmp(t_con->line, "history") == 0) if (strcmp(t_con->line, "history") == 0) {
{
int i; int i;
for (i = 1; i < TELNET_LINE_HISTORY_SIZE; i++) for (i = 1; i < TELNET_LINE_HISTORY_SIZE; i++) {
{ /* the t_con->next_history
/* the t_con->next_history line contains empty string (unless NULL), thus it is not printed */ *line contains empty string
char *history_line = t_con->history[(t_con->next_history + i) % TELNET_LINE_HISTORY_SIZE]; *(unless NULL), thus it is
if (history_line) *not printed */
{ char *history_line = t_con->history[(t_con->
telnet_write(connection, history_line, strlen(history_line)); 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); telnet_write(connection, "\r\n\x00", 3);
} }
} }
@ -298,35 +289,41 @@ static int telnet_input(struct connection *connection)
continue; continue;
} }
/* save only non-blank not repeating lines in the history */ /* save only non-blank not repeating lines
char *prev_line = t_con->history[(t_con->current_history > 0) ? t_con->current_history - 1 : TELNET_LINE_HISTORY_SIZE-1]; *in the history */
if (*t_con->line && (prev_line == NULL || strcmp(t_con->line, prev_line))) char *prev_line = t_con->history[(t_con->current_history > 0) ?
{ t_con->current_history - 1 : TELNET_LINE_HISTORY_SIZE-1];
/* if the history slot is already taken, free it */ 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]) if (t_con->history[t_con->next_history])
{
free(t_con->history[t_con->next_history]); free(t_con->history[t_con->next_history]);
}
/* add line to history */ /* add line to history */
t_con->history[t_con->next_history] = strdup(t_con->line); t_con->history[t_con->next_history] = strdup(t_con->line);
/* wrap history at TELNET_LINE_HISTORY_SIZE */ /* wrap history at
t_con->next_history = (t_con->next_history + 1) % TELNET_LINE_HISTORY_SIZE; *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 */ /* current history line starts at
t_con->current_history = t_con->next_history; *the new entry */
t_con->current_history =
t_con->next_history;
if (t_con->history[t_con->current_history]) if (t_con->history[t_con->current_history])
{
free(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->history[t_con->current_history] = strdup("");
} }
t_con->line_size = 0; 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); 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) if (retval == ERROR_COMMAND_CLOSE_CONNECTION)
return ERROR_SERVER_REMOTE_CLOSED; 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); retval = telnet_prompt(connection);
if (retval == ERROR_SERVER_REMOTE_CLOSED) if (retval == ERROR_SERVER_REMOTE_CLOSED)
return ERROR_SERVER_REMOTE_CLOSED; return ERROR_SERVER_REMOTE_CLOSED;
} } else if ((*buf_p == 0x7f) || (*buf_p == 0x8)) { /*
else if ((*buf_p == 0x7f) || (*buf_p == 0x8)) /* delete character */ *delete
{ *character
if (t_con->line_cursor > 0) **/
{ if (t_con->line_cursor > 0) {
if (t_con->line_cursor != t_con->line_size) if (t_con->line_cursor != t_con->line_size) {
{
int i; int i;
telnet_write(connection, "\b", 1); telnet_write(connection, "\b", 1);
t_con->line_cursor--; t_con->line_cursor--;
t_con->line_size--; 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); 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++)
{
telnet_write(connection, "\b", 1); telnet_write(connection, "\b", 1);
} } else {
}
else
{
t_con->line_size--; t_con->line_size--;
t_con->line_cursor--; 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); 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); telnet_clear_line(connection, t_con);
} else if (*buf_p == CTRL('B')) { /* cursor left */
else if (*buf_p == CTRL('B')) /* cursor left */ if (t_con->line_cursor > 0) {
{
if (t_con->line_cursor > 0)
{
telnet_write(connection, "\b", 1); telnet_write(connection, "\b", 1);
t_con->line_cursor--; t_con->line_cursor--;
} }
t_con->state = TELNET_STATE_DATA; 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) 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; t_con->state = TELNET_STATE_DATA;
} } else
else
{
LOG_DEBUG("unhandled nonprintable: %2.2x", *buf_p); LOG_DEBUG("unhandled nonprintable: %2.2x", *buf_p);
}
} }
} }
break; break;
case TELNET_STATE_IAC: case TELNET_STATE_IAC:
switch (*buf_p) switch (*buf_p) {
{ case 0xfe:
case 0xfe: t_con->state = TELNET_STATE_DONT;
t_con->state = TELNET_STATE_DONT; break;
break; case 0xfd:
case 0xfd: t_con->state = TELNET_STATE_DO;
t_con->state = TELNET_STATE_DO; break;
break; case 0xfc:
case 0xfc: t_con->state = TELNET_STATE_WONT;
t_con->state = TELNET_STATE_WONT; break;
break; case 0xfb:
case 0xfb: t_con->state = TELNET_STATE_WILL;
t_con->state = TELNET_STATE_WILL; break;
break;
} }
break; break;
case TELNET_STATE_SB: case TELNET_STATE_SB:
@ -425,30 +423,22 @@ static int telnet_input(struct connection *connection)
t_con->state = TELNET_STATE_DATA; t_con->state = TELNET_STATE_DATA;
break; break;
case TELNET_STATE_ESCAPE: case TELNET_STATE_ESCAPE:
if (t_con->last_escape == '[') if (t_con->last_escape == '[') {
{ if (*buf_p == 'D') { /* cursor left */
if (*buf_p == 'D') /* cursor left */ if (t_con->line_cursor > 0) {
{
if (t_con->line_cursor > 0)
{
telnet_write(connection, "\b", 1); telnet_write(connection, "\b", 1);
t_con->line_cursor--; t_con->line_cursor--;
} }
t_con->state = TELNET_STATE_DATA; 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) if (t_con->line_cursor < t_con->line_size)
{ telnet_write(connection,
telnet_write(connection, t_con->line + t_con->line_cursor++, 1); t_con->line + t_con->line_cursor++, 1);
}
t_con->state = TELNET_STATE_DATA; t_con->state = TELNET_STATE_DATA;
} } else if (*buf_p == 'A') { /* cursor up */
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;
int last_history = (t_con->current_history > 0) ? t_con->current_history - 1 : TELNET_LINE_HISTORY_SIZE-1; if (t_con->history[last_history]) {
if (t_con->history[last_history])
{
telnet_clear_line(connection, t_con); telnet_clear_line(connection, t_con);
t_con->line_size = strlen(t_con->history[last_history]); t_con->line_size = strlen(t_con->history[last_history]);
t_con->line_cursor = t_con->line_size; 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->current_history = last_history;
} }
t_con->state = TELNET_STATE_DATA; 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; 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); telnet_clear_line(connection, t_con);
t_con->line_size = strlen(t_con->history[next_history]); t_con->line_size = strlen(t_con->history[next_history]);
t_con->line_cursor = t_con->line_size; 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->current_history = next_history;
} }
t_con->state = TELNET_STATE_DATA; t_con->state = TELNET_STATE_DATA;
} } else if (*buf_p == '3')
else if (*buf_p == '3')
{
t_con->last_escape = *buf_p; t_con->last_escape = *buf_p;
}
else else
{
t_con->state = TELNET_STATE_DATA; t_con->state = TELNET_STATE_DATA;
} } else if (t_con->last_escape == '3') {
}
else if (t_con->last_escape == '3')
{
/* Remove character */ /* Remove character */
if (*buf_p == '~') if (*buf_p == '~') {
{ if (t_con->line_cursor < t_con->line_size) {
if (t_con->line_cursor < t_con->line_size)
{
int i; int i;
t_con->line_size--; t_con->line_size--;
/* remove char from line buffer */ /* 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 */ /* 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 */ /* overwrite last char with whitespace */
telnet_write(connection, " \b", 2); telnet_write(connection, " \b", 2);
/* move back to cursor position*/ /* move back to cursor position*/
for (i = t_con->line_cursor; i < t_con->line_size; i++) for (i = t_con->line_cursor; i < t_con->line_size; i++)
{
telnet_write(connection, "\b", 1); telnet_write(connection, "\b", 1);
}
} }
t_con->state = TELNET_STATE_DATA; t_con->state = TELNET_STATE_DATA;
} } else
else
{
t_con->state = TELNET_STATE_DATA; t_con->state = TELNET_STATE_DATA;
} } else if (t_con->last_escape == '\x00') {
}
else if (t_con->last_escape == '\x00')
{
if (*buf_p == '[') if (*buf_p == '[')
{
t_con->last_escape = *buf_p; t_con->last_escape = *buf_p;
}
else else
{
t_con->state = TELNET_STATE_DATA; t_con->state = TELNET_STATE_DATA;
} } else {
}
else
{
LOG_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;
} }
@ -549,16 +517,13 @@ static int telnet_connection_closed(struct connection *connection)
log_remove_callback(telnet_log_callback, connection); 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; t_con->prompt = NULL;
} }
for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++) for (i = 0; i < TELNET_LINE_HISTORY_SIZE; i++) {
{ if (t_con->history[i]) {
if (t_con->history[i])
{
free(t_con->history[i]); free(t_con->history[i]);
t_con->history[i] = NULL; 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 */ /* if this connection registered a debug-message receiver delete it */
delete_debug_msg_receiver(connection->cmd_ctx, NULL); delete_debug_msg_receiver(connection->cmd_ctx, NULL);
if (connection->priv) if (connection->priv) {
{
free(connection->priv); free(connection->priv);
connection->priv = NULL; connection->priv = NULL;
} } else
else
{
LOG_ERROR("BUG: connection->priv == NULL"); LOG_ERROR("BUG: connection->priv == NULL");
}
return ERROR_OK; return ERROR_OK;
} }
int telnet_init(char *banner) int telnet_init(char *banner)
{ {
if (strcmp(telnet_port, "disabled") == 0) if (strcmp(telnet_port, "disabled") == 0) {
{
LOG_INFO("telnet server disabled"); LOG_INFO("telnet server disabled");
return ERROR_OK; return ERROR_OK;
} }
@ -592,7 +552,13 @@ int telnet_init(char *banner)
telnet_service->banner = 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 */ /* daemon configuration command telnet_port */

12
src/server/telnet_server.h
View File

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