WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-devel

[Xen-devel] [PATCH resend] allow connecting to xenconsole from remote ho

To: Keir Fraser <Keir.Fraser@xxxxxxxxxxxx>
Subject: [Xen-devel] [PATCH resend] allow connecting to xenconsole from remote hosts
From: Muli Ben-Yehuda <muli@xxxxxxxxxx>
Date: Tue, 26 Sep 2006 18:26:35 +0300
Cc: Jimi Xenidis <jimix@xxxxxxxxxxxxxx>, xen-devel <xen-devel@xxxxxxxxxxxxxxxxxxx>, Anthony Liguori <anthony@xxxxxxxxxxxxx>, Orran Y Krieger <okrieg@xxxxxxxxxx>
Delivery-date: Tue, 26 Sep 2006 08:27:06 -0700
Envelope-to: www-data@xxxxxxxxxxxxxxxxxx
List-help: <mailto:xen-devel-request@lists.xensource.com?subject=help>
List-id: Xen developer discussion <xen-devel.lists.xensource.com>
List-post: <mailto:xen-devel@lists.xensource.com>
List-subscribe: <http://lists.xensource.com/cgi-bin/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=subscribe>
List-unsubscribe: <http://lists.xensource.com/cgi-bin/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=unsubscribe>
Sender: xen-devel-bounces@xxxxxxxxxxxxxxxxxxx
User-agent: Mutt/1.5.11
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