[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [PATCH resend] allow connecting to xenconsole from remote hosts
The attached patch makes xenconsole send and receive console messages over a remote connection, instead of via stdin/stdout - if given the --remote switch. It is useful for proxy'ing real console message or other protocol messages (such as gdb) between dom0 and a remote host. We're currently using it for proxying gdb between gdbstub in a partition that talks gdb over the console page to a remote host running gdb. Changed since last version: - fixed compile warning - type of 'buf' in handle_read_fd() should be char*, not unsigned char*. Signed-off-by: Muli Ben-Yehuda <muli@xxxxxxxxxx> diff -Naurp -X /home/muli/w/dontdiff vanilla/tools/console/client/main.c gdbconsole.hg/tools/console/client/main.c --- vanilla/tools/console/client/main.c 2006-09-07 11:16:07.000000000 +0300 +++ gdbconsole.hg/tools/console/client/main.c 2006-09-25 11:17:32.000000000 +0300 @@ -1,8 +1,9 @@ /*\ - * Copyright (C) International Business Machines Corp., 2005 - * Author(s): Anthony Liguori <aliguori@xxxxxxxxxx> + * Copyright (C) International Business Machines Corp., 2005, 2006 + * Author: Anthony Liguori <aliguori@xxxxxxxxxx> + * Author: Muli Ben-Yehuda <muli@xxxxxxxxxx> * - * Xen Console Daemon + * Xen Console Client * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -35,32 +36,110 @@ #include <err.h> #include <errno.h> #include <pty.h> +#include <netinet/in.h> +#include <netdb.h> +#include <stdarg.h> #include "xs.h" +#define min(x,y) ({ \ + const typeof(x) _x = (x); \ + const typeof(y) _y = (y); \ + (void) (&_x == &_y); \ + _x < _y ? _x : _y; }) + #define ESCAPE_CHARACTER 0x1d +#define DEFAULT_LISTEN_PORT 7890 -static volatile sig_atomic_t received_signal = 0; +struct remote { + long port; + int do_listen; + int gateway; + int server; /* server socket */ +}; + +#define RING_SIZE (1 << 16) +#define RING_IDX_MASK(i) ((i) & (RING_SIZE - 1)) + +struct ring { + size_t prod; + size_t cons; + unsigned char ring[RING_SIZE]; +}; -static void sighandler(int signum) +static void ring_put(struct ring* ring, char* buf, size_t len) { - received_signal = 1; + size_t i; + + for (i = 0; i < len; i++) + ring->ring[RING_IDX_MASK(ring->prod++)] = buf[i]; } -static bool write_sync(int fd, const void *data, size_t size) +static void ring_get(struct ring* ring, char* buf, size_t *pcount) { - size_t offset = 0; - ssize_t len; + size_t idx, len, max, sofar, c; - while (offset < size) { - len = write(fd, data + offset, size - offset); - if (len < 1) { - return false; - } - offset += len; + max = *pcount; + sofar = 0; + + c = ring->cons; + while ((c != ring->prod) && (sofar < max)) { + idx = RING_IDX_MASK(c); + len = ring->prod - c; + if ((idx + len) > RING_SIZE) + len = RING_SIZE - idx; + if ((sofar + len) > max) + len = max - sofar; + memcpy(buf, &ring->ring[idx], len); + buf += len; + sofar += len; + c += len; } - return true; + ring->cons = c; + *pcount = sofar; +} + +static size_t ring_prod_available(struct ring *ring) +{ + size_t distance = ring->prod - ring->cons; + + if (distance >= RING_SIZE) + return 0; + + return (RING_SIZE - distance); +} + +static size_t ring_cons_available(struct ring *ring) +{ + if (ring->cons == ring->prod) + return 0; + + return ring->prod - ring->cons; +} + +static volatile sig_atomic_t received_signal = 0; + +static int debug; + +#define dbg(fmt, args...) do { \ + if (debug) \ + _dbg("[%s] " fmt, __func__, ##args); \ +} while (0) + +static void _dbg(const char *fmt, ...) +{ + va_list args; + + va_start(args, fmt); + vfprintf(stderr, fmt, args); + va_end(args); + fflush(stderr); +} + +static void sighandler(int signum) +{ + received_signal = 1; } static void usage(const char *program) { @@ -68,9 +147,35 @@ static void usage(const char *program) { "Attaches to a virtual domain console\n" "\n" " -h, --help display this help and exit\n" + " -r, --remote wait for connections from local clients\n" + " -g, --gateway allow connections from any host\n" + " -d, --debug enable debug output\n" , program); } +ssize_t write_all(int fd, const void *buf, size_t count) +{ + const unsigned char* b = (const unsigned char*)buf; + ssize_t sum = 0; + ssize_t ret = 0; + + while (count) { + ret = write(fd, b, count); + if (ret == -1) { + if (errno == EINTR || errno == EAGAIN) + continue; + ret = -errno; + break; + } + if (ret == 0) + break; + count -= ret; + b += ret; + sum += ret; + } + return (ret >= 0 ? sum : ret); +} + /* don't worry too much if setting terminal attributes fail */ static void init_term(int fd, struct termios *old) { @@ -91,79 +196,256 @@ static void restore_term(int fd, struct tcsetattr(fd, TCSAFLUSH, old); } -static int console_loop(int fd) +static inline void dump_buf(char* prefix, int fd, const char *data, size_t len) +{ + dbg("%s: %u bytes on %d:\n", prefix, len, fd); + dbg("buf: `%s'\n", data); +} + +static int handle_read_fd(int fd, struct ring* ring) +{ + int ret; + ssize_t len; + char* buf; + size_t avail; + + avail = ring_prod_available(ring); + if (avail == 0) + return 0; + + buf = malloc(avail); + if (!buf) { + ret = -ENOMEM; + goto done; + } + + len = read(fd, buf, avail); + if (len == 1 && buf[0] == ESCAPE_CHARACTER) { + ret = ECONNRESET; + goto free; + } + + if (len == -1) { + if (errno == EINTR || errno == EAGAIN) + ret = EINTR; + else + ret = -errno; + goto free; + } + if (len == 0) { + /* try to reconnect */ + ret = EAGAIN; + goto free; + } + + dump_buf("read", fd, buf, len); + ring_put(ring, buf, len); + ret = 0; +free: + free(buf); +done: + return ret; +} + +static int handle_write_fd(int fd, struct ring* ring) +{ + int ret; + size_t len; + char buf[4096]; + + len = min(ring_cons_available(ring), sizeof(buf)); + + while (len) { + ring_get(ring, buf, &len); + + dump_buf("write", fd, buf, len); + + ret = write_all(fd, buf, len); + if (ret < 0) + return ret; + + len = min(ring_cons_available(ring), sizeof(buf)); + } + return 0; +} + +static int console_loop(int conspty, int infd, int outfd) { int ret; + int max; + + struct ring console = { + .prod = 0, + .cons = 0, + .ring = { '\0' } + }; + + struct ring out = { + .prod = 0, + .cons = 0, + .ring = { '\0' } + }; do { - fd_set fds; + fd_set rfds, wfds; + + FD_ZERO(&rfds); + FD_SET(infd, &rfds); + FD_SET(conspty, &rfds); + + FD_ZERO(&wfds); + FD_SET(conspty, &wfds); + FD_SET(outfd, &wfds); + + max = (conspty | infd | outfd) + 1; - FD_ZERO(&fds); - FD_SET(STDIN_FILENO, &fds); - FD_SET(fd, &fds); + ret = select(max, &rfds, &wfds, NULL, NULL); - ret = select(fd + 1, &fds, NULL, NULL, NULL); if (ret == -1) { if (errno == EINTR || errno == EAGAIN) { continue; } - return -1; + return -errno; } - if (FD_ISSET(STDIN_FILENO, &fds)) { - ssize_t len; - char msg[60]; - - len = read(STDIN_FILENO, msg, sizeof(msg)); - if (len == 1 && msg[0] == ESCAPE_CHARACTER) { + if (FD_ISSET(infd, &rfds)) { + ret = handle_read_fd(infd, &console); + if (ret < 0) + return ret; + if (ret == EINTR) + continue; + if (ret == EAGAIN) + return EAGAIN; + if (ret == ECONNRESET) return 0; - } - - if (len == 0 || len == -1) { - if (len == -1 && - (errno == EINTR || errno == EAGAIN)) { - continue; - } - return -1; - } + } - if (!write_sync(fd, msg, len)) { - perror("write() failed"); - return -1; - } + if (FD_ISSET(conspty, &rfds)) { + ret = handle_read_fd(conspty, &out); + if (ret < 0) + return ret; + if (ret == EINTR) + continue; + if (ret == EAGAIN) + return EAGAIN; + if (ret == ECONNRESET) + return 0; } - if (FD_ISSET(fd, &fds)) { - ssize_t len; - char msg[512]; - - len = read(fd, msg, sizeof(msg)); - if (len == 0 || len == -1) { - if (len == -1 && - (errno == EINTR || errno == EAGAIN)) { - continue; - } - return -1; - } + if (FD_ISSET(outfd, &wfds)) { + ret = handle_write_fd(outfd, &out); + if (ret < 0) + return ret; + } - if (!write_sync(STDOUT_FILENO, msg, len)) { - perror("write() failed"); - return -1; - } + if (FD_ISSET(conspty, &wfds)) { + ret = handle_write_fd(conspty, &console); + if (ret < 0) + return ret; } } while (received_signal == 0); return 0; } -int main(int argc, char **argv) +static int start_server(struct remote *remote) +{ + struct sockaddr_in sa; + struct hostent *he = NULL; + int ret; + int on; + + memset(&sa, 0, sizeof(sa)); + + sa.sin_family = AF_INET; + sa.sin_port = htons(remote->port); + + if (!remote->gateway) { + he = gethostbyname("localhost"); + if (!he) + err(h_errno, "could not get localhost address\n"); + memcpy(&sa.sin_addr, he->h_addr_list[0], he->h_length); + } else + sa.sin_addr.s_addr = htonl(INADDR_ANY); + + remote->server = socket(AF_INET, SOCK_STREAM, 0); + if (remote->server < 0) + err(errno, "socket failed\n"); + + on = 1; + ret = setsockopt(remote->server, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); + if (ret) + err(errno, "setsockopt(SO_REUSEADDR) failed\n"); + + ret = bind(remote->server, (struct sockaddr *)&sa, sizeof(sa)); + if (ret) + err(errno, "bind failed\n"); + + ret = listen(remote->server, 5); + if (ret) + err(errno, "listen failed\n"); + + return ret; +} + +static int remote_loop(int conspty, struct remote *remote) { + int in; + int out; + int socket; + int ret; + + ret = start_server(remote); + if (ret) + return ret; + + do { + socket = accept(remote->server, NULL, 0); + if (socket < 0) + err(errno, "accept failed\n"); + + in = socket; + out = socket; + + ret = console_loop(conspty, in, out); + } while (ret == EAGAIN); + + return ret; +} + +static int main_loop(int conspty, struct remote *remote) +{ + int in; + int out; + int ret; struct termios attr; + + if (remote->do_listen) + return remote_loop(conspty, remote); + + init_term(fileno(stdin), &attr); + + in = fileno(stdin); + out = fileno(stdout); + + ret = console_loop(conspty, in, out); + + restore_term(in, &attr); + + return ret; +} + +int main(int argc, char **argv) +{ int domid; - char *sopt = "h"; + char *sopt = "rp:gdh"; int ch; int opt_ind=0; struct option lopt[] = { + { "remote", 0, NULL, 'r' }, + { "port", 1, NULL, 'p' }, + { "gateway", 0, NULL, 'g' }, + { "debug", 0, NULL, 'd' }, { "help", 0, 0, 'h' }, { 0 }, @@ -174,6 +456,13 @@ int main(int argc, char **argv) struct xs_handle *xs; char *end; time_t now; + struct remote remote = { + .port = DEFAULT_LISTEN_PORT, + .do_listen = 0, + .gateway = 0, + .server = -1, + }; + int ret; while((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) { switch(ch) { @@ -181,6 +470,25 @@ int main(int argc, char **argv) usage(argv[0]); exit(0); break; + case 'r': + remote.do_listen = 1; + break; + case 'p': + remote.port = strtol(optarg, &end, 10); + if (end && *end) { + fprintf(stderr, "Invalid port `%s' specified\n", + optarg); + fprintf(stderr, "Try `%s --help' for more " + "information.\n", argv[0]); + exit(EINVAL); + } + break; + case 'g': + remote.gateway = 1; + break; + case 'd': + debug = 1; + break; } } @@ -199,6 +507,14 @@ int main(int argc, char **argv) exit(EINVAL); } + if (remote.gateway && !remote.do_listen) { + fprintf(stderr, "setting `gateway' requires also setting " + "`remote'\n"); + fprintf(stderr, "Try `%s --help' for more information.\n", + argv[0]); + exit(EINVAL); + } + xs = xs_daemon_open(); if (xs == NULL) { err(errno, "Could not contact XenStore"); @@ -253,9 +569,9 @@ int main(int argc, char **argv) free(str_pty); free(path); - init_term(STDIN_FILENO, &attr); - console_loop(spty); - restore_term(STDIN_FILENO, &attr); + ret = main_loop(spty, &remote); - return 0; - } + xs_daemon_close(xs); + + return abs(ret); +} _______________________________________________ Xen-devel mailing list Xen-devel@xxxxxxxxxxxxxxxxxxx http://lists.xensource.com/xen-devel
|
![]() |
Lists.xenproject.org is hosted with RackSpace, monitoring our |