Skip to contentSkip to conversation

Remote console access though socket

PATCH In review Daniel Veillard 3 participants 8 messages Mar 8, 2006 – Mar 12, 2006 1 message not in the archive Kbuild

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 Remote console access though socket

Hi,

enclosed is a first version of a patch to allow remote access and control for QEmu instances, I'm not suggesting to apply it as is (though it seems to work in my limited testing) but would rather like to get comments back for choices I'm facing.
First a bit of context, I'm working on libvirt (see
http://libvirt.org/) a library providing access to virtualization. I would like to be able to handle QEmu instance like we do for Xen, the simpler would be to be able to list and connect to the console of running QEmu. In an early mail last month Fabrice expressed interest in exporting the console though TCP, so I hope I'm not too much off-track. Enclosed are:
- qemu-tcpctrl.patch: the patch to the existing code, it add tcpctrl as a configure option (on by default except on Windows), it plugs in main() of vl.c, add one entry point in console.c, and add a new module in the Makefile
- tcpctrl.c: the C file, it currently use an unix socket /tmp/qemu-$pid-socket add a routine to start and stop the access and plug in the I/O handler of QEmu to wait for connections on it. When connections are accepted they are also plugged in the I/O handling, and receive commands. The commands are passed to console.c along with a minimal CharDriverState whose grite goes back to the associated connection.
- client.c: a minimal client to send a command and get the output. use as './client /tmp/qemu-*-socket quit'

There is a number of open questions which would need to be resolved before
applying any such patch:
- First one is the unix socket, we could as easilly start normal port based access but:
+ I would really like to be able to list the current running instance without checking all process on the OS, and mapping in the file system seems the easiest way
+ the permission over the filesystem allows to set up the access policy without any special mechanism
+ in a port based access how do you guess the port numbers used by the QEmu instances
the drawback of the file sockets are:
+ security: one need a directory where any user (since qemu isn't priviledged) can create a new file, and ensure safety over those accesses
+ cleanup: when qemu exits one need to clean up the socket, and currently qemu has no central exit routine for this (and doesn't seems to trap signals leading to exit)
- what about asynchronous events CharDriverState has structures in place for those, in general is that okay to keep some of the CharDriverState as NULL or should it trap every possible entries not just write()
- the plug of the socket in the console framework is a bit crude, it just replace the global variable monitor_hd during the processing of the request (c.f. monitor_process_command()).
- the console -> socket code should try to coalesce multiple writes from the console into a single packet flushed at the end of the routine, and a marker for the end of the output from the command will help parsing at the client level.
- ease of error handling on the client if possible, to generalize a bit go from a human targetted interaction to a machine one.
- command line configurations, for enabling/disabling the remote access and being able to specify the port number if using port, left open I didn't tried to address that

So there is a bit too many open issues but IMHO nothing really hard, I would
just like to get feedback from other interested people.

Daniel

Signature · 3 lines
Daniel Veillard      | Red Hat http://redhat.com/
[email protected]  | libxml GNOME XML XSLT toolkit  http://xmlsoft.org/
http://veillard.com/ | Rpmfind RPM search engine http://rpmfind.net/

Index: qemu/Makefile.target
===================================================================
RCS file: /sources/qemu/qemu/Makefile.target,v
retrieving revision 1.93

Makefile.target +3 -0
diff -u -r1.93 Makefile.target
@@ -275,6 +275,9 @@
 ifdef CONFIG_WIN32
 VL_OBJS+=tap-win32.o
 endif
+ifdef CONFIG_TCPCTRL
+VL_OBJS+=tcpctrl.o
+endif
 
 SOUND_HW = sb16.o es1370.o
 AUDIODRV = audio.o noaudio.o wavaudio.o

Index: qemu/configure
===================================================================
RCS file: /sources/qemu/qemu/configure,v
retrieving revision 1.83

configure +12 -0
diff -u -r1.83 configure
@@ -74,6 +74,7 @@
 mingw32="no"
 EXESUF=""
 gdbstub="yes"
+tcpctrl="yes"
 slirp="yes"
 adlib="no"
 oss="no"
@@ -208,6 +209,10 @@
   ;;
   --disable-gcc-check) check_gcc="no"
   ;;
+  --enable-tcpctrl) tcpctrl="yes"
+  ;;
+  --disable-tcpctrl) tcpctrl="no"
+  ;;
   esac
 done
 
@@ -224,6 +229,7 @@
     linux="no"
     EXESUF=".exe"
     gdbstub="no"
+    tcpctrl="no"
     oss="no"
     if [ "$cpu" = "i386" ] ; then
         kqemu="yes"
@@ -385,6 +391,7 @@
 echo "  --enable-alsa            enable ALSA audio driver"
 echo "  --enable-fmod            enable FMOD audio driver"
 echo "  --enabled-dsound         enable DirectSound audio driver"
+echo "  --disable-tcpctrl        disable TCP control connections"
 echo "  --fmod-lib               path to FMOD library"
 echo "  --fmod-inc               path to FMOD includes"
 echo ""
@@ -451,6 +458,7 @@
     echo -n " (lib='$fmod_lib' include='$fmod_inc')"
 fi
 echo ""
+echo "TCP control       $tcpctrl"
 echo "kqemu support     $kqemu"
 
 if test $sdl_too_old = "yes"; then
@@ -545,6 +553,10 @@
   echo "CONFIG_GDBSTUB=yes" >> $config_mak
   echo "#define CONFIG_GDBSTUB 1" >> $config_h
 fi
+if test "$tcpctrl" = "yes" ; then
+  echo "CONFIG_TCPCTRL=yes" >> $config_mak
+  echo "#define CONFIG_TCPCTRL 1" >> $config_h
+fi
 if test "$gprof" = "yes" ; then
   echo "TARGET_GPROF=yes" >> $config_mak
   echo "#define HAVE_GPROF 1" >> $config_h

Index: qemu/monitor.c
===================================================================
RCS file: /sources/qemu/qemu/monitor.c,v
retrieving revision 1.46

monitor.c +27 -0
diff -u -r1.46 monitor.c
@@ -296,6 +296,9 @@
 
 static void do_quit(void)
 {
+#ifdef CONFIG_TCPCTRL
+    tcpctrl_stop();
+#endif
     exit(0);
 }
 
@@ -2026,6 +2029,30 @@
     return;
 }
 
+/**
+ * monitor_process_command:
+ * @output: the console used to send the output
+ * @cmdline: the line of the command to process
+ *
+ * Process a command coming from a different requester than the usual console.
+ */
+
+void monitor_process_command(CharDriverState *output, const char *cmdline)
+{
+    CharDriverState *old_output = monitor_hd;
+
+    if ((output == NULL) || (cmdline == NULL))
+        return;
+
+    /*
+     * TODO: maybe it would be cleaner to inherit the current driver
+     *       in the calls than relying on a global variable ?
+     */
+    monitor_hd = output;
+    monitor_handle_command(cmdline);
+    monitor_hd = old_output;
+}
+
 static void cmd_completion(const char *name, const char *list)
 {
     const char *p, *pstart;

Index: qemu/vl.c
===================================================================
RCS file: /sources/qemu/qemu/vl.c,v
retrieving revision 1.165

vl.c +16 -0
diff -u -r1.165 vl.c
@@ -4550,6 +4550,9 @@
 
 int main(int argc, char **argv)
 {
+#ifdef CONFIG_TCPCTRL
+    int use_tcpctrl = 1;
+#endif
 #ifdef CONFIG_GDBSTUB
     int use_gdbstub, gdbstub_port;
 #endif
@@ -5210,6 +5213,14 @@
     gui_timer = qemu_new_timer(rt_clock, gui_update, NULL);
     qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock));
 
+#ifdef CONFIG_TCPCTRL
+    if (use_tcpctrl) {
+        if (tcpctrl_start() < 0) {
+            fprintf(stderr, "Could not open TCP control socket\n");
+	    exit(1);
+	}
+    }
+#endif
 #ifdef CONFIG_GDBSTUB
     if (use_gdbstub) {
         if (gdbserver_start(gdbstub_port) < 0) {
@@ -5232,6 +5243,11 @@
         }
     }
     main_loop();
+#ifdef CONFIG_TCPCTRL
+    if (use_tcpctrl) {
+        tcpctrl_stop();
+    }
+#endif
     quit_timers();
     return 0;
 }

Index: qemu/vl.h
===================================================================
RCS file: /sources/qemu/qemu/vl.h,v
retrieving revision 1.105

vl.h +8 -0
diff -u -r1.105 vl.h
@@ -991,6 +991,14 @@
 void term_print_help(void);
 void monitor_readline(const char *prompt, int is_password,
                       char *buf, int buf_size);
+void monitor_process_command(CharDriverState *output, const char *cmdline);
+
+#ifdef CONFIG_TCPCTRL
+/* tcpctrl.c */
+int tcpctrl_start(void);
+void tcpctrl_stop(void);
+
+#endif /* CONFIG_TCPCTRL */
 
 /* readline.c */
 typedef void ReadLineFunc(void *opaque, const char *str);

/*
* remote TCP control connection
*
* Copyright (c) 2006 Daniel Veillard <[email protected]>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version. *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#include "vl.h"
#ifdef CONFIG_TCPCTRL

#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/tcp.h>

/* #define DEBUG_TCPCTRL */

static int tcpctrl_fd = -1;
static char tcpctrl_socket[150] = "";

typedef struct _tcp_client {
    int fd;
    CharDriverState drv;
} tcp_client;

static int

chrctr_write(struct CharDriverState *s, const uint8_t *buf, int len) {
    tcp_client *info;
    int written, sent = 0;

    if ((s == NULL) || (buf == NULL) || (len < 0) || (s->opaque == NULL))
        return(-1);
    if (tcpctrl_fd == -1)
        return(-1);

    info = s->opaque;
#ifdef DEBUG_TCPCTRL
    fprintf(stderr, "chrctr_write(fd = %d, len = %d)\n", info->fd, len);

#endif

retry_write:

    written = write(info->fd, buf + sent, len - sent);
    if (written < 0) {
        if ((errno == EINTR) || (errno == EAGAIN))
	    goto retry_write;
	close(info->fd);
	qemu_set_fd_handler(info->fd, NULL, NULL, NULL);
	info->fd = -1;
	return(-1);
    }
    if (written + sent < len) {
        sent += written;
	goto retry_write;
    }
    return(written);
}

static void
tcpctrl_disconnect(tcp_client *info)

{
    if ((info == NULL) || (info->fd < 0))
        return;
#ifdef DEBUG_TCPCTRL
    fprintf(stderr, "tcpctrl_disconnect(fd = %d)\n", info->fd);
#endif
    /*
     * this seems the best way to unregister this should work
     * even in the loop over iov in the main loop
     */
    if (info->fd > 0) {
	qemu_set_fd_handler(info->fd, NULL, NULL, NULL);
	close(info->fd);
    }
    qemu_free(info);
}
static int tcpctrl_process(tcp_client *info, const char *command) {
    if (tcpctrl_fd == -1)
        return(-1);
#ifdef DEBUG_TCPCTRL
    fprintf(stderr, "tcpctrl_process(command = '%s')\n", command);
#endif
    monitor_process_command(&info->drv, command);

    /* writing back to tcp connection may have failed */
    if (info->fd < 0)
        tcpctrl_disconnect(info);
}

static void tcpctrl_read(void *opaque)

{
    char buffer[4096 + 1];
    int ret;

    tcp_client *info = opaque;
#ifdef DEBUG_TCPCTRL
    fprintf(stderr, "tcpctrl_read(fd = %d)\n", info->fd);
#endif
    
    if (tcpctrl_fd == -1) {
	tcpctrl_disconnect(info);
        return;
    }

retry_read:

    ret = read(info->fd, &buffer[0], sizeof(buffer) - 1);
    if (ret < 0) {
        if ((errno == EINTR) || (errno == EAGAIN))
	    goto retry_read;
	tcpctrl_disconnect(info);
	return;
    }
    if (ret == 0) {
	tcpctrl_disconnect(info);
	return;
    }
    buffer[ret] = 0;
    tcpctrl_process(info, &buffer[0]);
}

static void
tcpctrl_accept(void *opaque)

{
    struct sockaddr_in sockaddr;
    socklen_t len;
    int val, fd;
    tcp_client *info;
#ifdef DEBUG_TCPCTRL
    fprintf(stderr, "tcpctrl_accept()\n");

#endif

    for(;;) {
        len = sizeof(sockaddr);
        fd = accept(tcpctrl_fd, (struct sockaddr *)&sockaddr, &len);
        if (fd < 0 && errno != EINTR) {
            perror("accept");
            return;
        } else if (fd >= 0) {
            break;
        }
    }

    /* set short latency */
    val = 1;
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
    
    info = qemu_mallocz(sizeof(tcp_client));
    if (!info) {
        close(fd);
        return;
    }
    info->fd = fd;
    info->drv.chr_write = chrctr_write;
    info->drv.opaque = info;

    fcntl(fd, F_SETFL, O_NONBLOCK);

    qemu_set_fd_handler(fd, tcpctrl_read, NULL, info);
#ifdef DEBUG_TCPCTRL
    fprintf(stderr, "tcpctrl_accept(): fd = %d\n", fd);

#endif
}

static int tcpctrl_open()

{
    int fd = -1;
    int pid = getpid();
    mode_t oldmask;
    struct sockaddr_un addr;

    snprintf(tcpctrl_socket, sizeof(tcpctrl_socket) - 1,
             "%s/qemu-%d-socket", "/tmp", pid);
    tcpctrl_socket[sizeof(tcpctrl_socket) - 1] = 0;
    unlink(tcpctrl_socket);

    fd = socket(PF_UNIX, SOCK_STREAM, 0);
    if (fd < 0) {
        fprintf(stderr, "Failed to create unix socket");
	return(-1);
    }
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(&addr.sun_path[0], tcpctrl_socket, (sizeof(addr) - 4) - 1);
    oldmask = umask(0077);
    if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        fprintf(stderr, "Failed to bind to socket %s\n", tcpctrl_socket);
	close(fd);
	umask(oldmask);
	return(-1);
    }
    if (listen(fd, 3) < 0) {
        fprintf(stderr, "Failed to listen to socket %s\n", tcpctrl_socket);
	close(fd);
	umask(oldmask);
	return(-1);
    }
    umask(oldmask);
#ifdef DEBUG_TCPCTRL
    fprintf(stderr, "Listening on TCP control socket %s\n", tcpctrl_socket);

#endif

    return fd;
}

int tcpctrl_start()
{

#ifdef DEBUG_TCPCTRL
    fprintf(stderr, "tcpctrl_start()\n");
#endif
    tcpctrl_fd = tcpctrl_open();
    if (tcpctrl_fd < 0)
        return -1;
    qemu_set_fd_handler(tcpctrl_fd, tcpctrl_accept, NULL, NULL);
    return 0;
}

void tcpctrl_stop()

{
    if (tcpctrl_fd < 0)
        return;
#ifdef DEBUG_TCPCTRL
    fprintf(stderr, "tcpctrl_stop()\n");
#endif
    unlink(tcpctrl_socket);
    qemu_set_fd_handler(tcpctrl_fd, NULL, NULL, NULL);
    close(tcpctrl_fd);
    tcpctrl_fd = -1;
    return;
}

#endif /* CONFIG_TCPCTRL */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>

#define DEBUG_TCPCTRL

static int

qemu_connect(const char *path) {
    int fd;
    struct sockaddr_un addr;

    fd = socket(PF_UNIX, SOCK_STREAM, 0);
    if (fd < 0) {
        fprintf(stderr, "Failed to create unix socket\n");
	return (-1);
    }
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(&addr.sun_path[0], path, (sizeof(addr) - 4) - 1);

    while (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        if (errno != EINTR) {
	    fprintf(stderr, "Failed to connect to unix socket %s\n",
	            path);
	    close(fd);
	    unlink(path);
	    return (-1);
	}
    }
#ifdef DEBUG_TCPCTRL
    fprintf(stderr, "Connected to socket %s : %d\n", path, fd);
#endif
    return(fd);
}

static int

qemu_command(int fd, const char *command) {
    int ret, written, sent = 0, len;
    char answer[200];

    len = strlen(command);

retry_write:

    written = write(fd, &command[sent], len - sent);
    if (written < 0) {
        if ((errno == EINTR) || (errno == EAGAIN))
	    goto retry_write;
	fprintf(stderr, "Failed to write message to socket %d\n", fd);
	return (-1);
    }

    if (written + sent < len) {
        sent += written;
	goto retry_write;
    }

retry_read:

    ret = read(fd, &answer[0], sizeof(answer) - 1);
    if (ret < 0) {
        if ((errno == EINTR) || (errno == EAGAIN))
	    goto retry_read;
	return (-1);
    }
    answer[ret] = 0;
    printf("%s\n", answer);
    return(0);
}
static void usage(const char *progname) {
    printf("Usage %s socket_path [command]\n", progname);
    exit(1);
}
int main(int argc, char **argv) {
    const char *path, *command;
    int fd;
    int ret;

    if ((argc < 2) || (argc > 3))
        usage(argv[0]);
    path = argv[1];
    if (argc == 3)
        command = argv[2];
    else
        command = "help";

    fd = qemu_connect(path);
    if (fd < 0)
        exit(1);

    ret = qemu_command(fd, command);
    return(ret);
}

A message that is not in the archive (sent off-list or not yet received): [email protected]

#2 lore raw
Quoted 4 lines · Daniel Veillard

enclosed is a first version of a patch to allow remote access and control for QEmu instances, I'm not suggesting to apply it as is (though it seems to work in my limited testing) but would rather like to get comments back for choices I'm facing.

This sounds pretty nice. A few general comments:

A few weeks ago I wrote a qemu daemon manager. It's a pretty simple script that manages multiple qemu processes, launching each one in an instance of screen. screen does most of the dirty work of keeping track of running processes, assigning a name to each process, attaching to a process's console, terminating a process, etc. Of course screen has many more features that we don't really need, but it might be worth looking at screen as a model for implementing the functions you describe.

The other problem my script deals with, which screen doesn't solve, is managing resources like ports (for -redir) and network interface MAC addresses (in cases where uniqueness matters), and providing some way for the user to determine which resource has been assigned to a particular qemu process.

If qemu provides access to its console via a socket, this is just another resource that a manager can deal with, perhaps passing the desired port number to qemu via the command line.

--Ed

#3 lore raw
Quoted 8 lines · Ed Swierk
Quoted 4 lines · Daniel Veillard

enclosed is a first version of a patch to allow remote access and control for QEmu instances, I'm not suggesting to apply it as is (though it seems to work in my limited testing) but would rather like to get comments back for choices I'm facing.

This sounds pretty nice. A few general comments:

Quoted 8 lines

A few weeks ago I wrote a qemu daemon manager. It's a pretty simple script that manages multiple qemu processes, launching each one in an instance of screen. screen does most of the dirty work of keeping track of running processes, assigning a name to each process, attaching to a process's console, terminating a process, etc. Of course screen has many more features that we don't really need, but it might be worth looking at screen as a model for implementing the functions you describe.

I don't see how this would solve the problems I asked about:
- discovery of running instances if not using a filesystem based socket
- being able to hook up to qemu instances which are older than the program you're trying to control them from.
I know screen, it's good for handling a few number of console, but it's not really what I'm trying to get at, really.

[...]

Quoted 3 lines

If qemu provides access to its console via a socket, this is just another resource that a manager can deal with, perhaps passing the desired port number to qemu via the command line.

But for that you need to know the given port a priori, i.e. before lauch
which limits a lot the usefulness of the control tool. So far I only see filesystem based discoveey access, I was hoping for something better, maybe there isn't a better way ...

Daniel

Signature · 3 lines
Daniel Veillard      | Red Hat http://redhat.com/
[email protected]  | libxml GNOME XML XSLT toolkit  http://xmlsoft.org/
http://veillard.com/ | Rpmfind RPM search engine http://rpmfind.net/
#4 lore raw
In reply to Daniel Veillard

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Quoted 6 lines · Daniel Veillard

Hi,

enclosed is a first version of a patch to allow remote access and control for QEmu instances, I'm not suggesting to apply it as is (though it seems to work in my limited testing) but would rather like to get comments back for choices I'm facing.

[...]

Quoted 7 lines

There is a number of open questions which would need to be resolved before
applying any such patch:
- First one is the unix socket, we could as easilly start normal port based access but:
+ I would really like to be able to list the current running instance without checking all process on the OS, and mapping in the file system seems the easiest way

Just an idea: how about using "Multicast DNS" (see multicastdns.org)? IIUC it provides a generic way to find services on a net; and it's supported at least by MacOSX and with eg. Avahi (see avahi.org) also on Linux. Not sure about Windows, though...

Regards,
Oliver Gerlich
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.2 (GNU/Linux)

iD8DBQFEEvnHTFOM6DcNJ6cRAhe4AJ9LAQwIb25gCuIHKiRoIMLwJzkt4wCgoEXh kjk2Gejn8X+p1tyCeryHqYA=
=z3wY
-----END PGP SIGNATURE-----

#5 lore raw
Quoted 19 lines · Oliver Gerlich

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Quoted 6 lines · Daniel Veillard

Hi,

enclosed is a first version of a patch to allow remote access and control for QEmu instances, I'm not suggesting to apply it as is (though it seems to work in my limited testing) but would rather like to get comments back for choices I'm facing.

[...]

Quoted 7 lines

There is a number of open questions which would need to be resolved before
applying any such patch:
- First one is the unix socket, we could as easilly start normal port based access but:
+ I would really like to be able to list the current running instance without checking all process on the OS, and mapping in the file system seems the easiest way

Quoted 4 lines

Just an idea: how about using "Multicast DNS" (see multicastdns.org)? IIUC it provides a generic way to find services on a net; and it's supported at least by MacOSX and with eg. Avahi (see avahi.org) also on Linux. Not sure about Windows, though...

It's rather LAN oriented, I need first to find the ports of the
QEmu instances (plural, if you limit to one per box, then you can block the default port number and there would be no problem) on a local machine. I don't think that "Multicast DNS"/RendezVous works with random port numbers, all it does over normal TCP is scan for local hosts without using DNS resolution. Again I don't think it's really the problem I'm trying to solve, maybe I just didn't expressed myself clearly :-)

Daniel

Signature · 3 lines
Daniel Veillard      | Red Hat http://redhat.com/
[email protected]  | libxml GNOME XML XSLT toolkit  http://xmlsoft.org/
http://veillard.com/ | Rpmfind RPM search engine http://rpmfind.net/
#6 lore raw

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Quoted 24 lines · Daniel Veillard
Quoted 22 lines · Oliver Gerlich

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Quoted 6 lines · Daniel Veillard

Hi,

enclosed is a first version of a patch to allow remote access and control for QEmu instances, I'm not suggesting to apply it as is (though it seems to work in my limited testing) but would rather like to get comments back for choices I'm facing.

[...]

Quoted 7 lines

There is a number of open questions which would need to be resolved before applying any such patch:
- First one is the unix socket, we could as easilly start normal port based access but:
+ I would really like to be able to list the current running instance without checking all process on the OS, and mapping in the file system seems the easiest way

Quoted 7 lines
Quoted 4 lines

Just an idea: how about using "Multicast DNS" (see multicastdns.org)? IIUC it provides a generic way to find services on a net; and it's supported at least by MacOSX and with eg. Avahi (see avahi.org) also on Linux. Not sure about Windows, though...

It's rather LAN oriented,

Yes, that's a bit ugly.

Quoted 10 lines

I need first to find the ports of the
QEmu instances (plural, if you limit to one per box, then you can block the default port number and there would be no problem) on a local machine. I don't think that "Multicast DNS"/RendezVous works with random port numbers, all it does over normal TCP is scan for local hosts without using DNS resolution. Again I don't think it's really the problem I'm trying to solve, maybe I just didn't expressed myself clearly :-)

Daniel

After experimenting with the avahi apps a bit, I think mDNS can indeed advertise several services on the same host with different ports! I ran "avahi-publish -s -H localhost myserver1 _http._tcp 80" in one terminal, then "avahi-publish -s -H localhost myserver2 _http._tcp 12345" in another terminal. This advertised two HTTP servers which were running on my local host, on ports 80 and 12345, under the names myserver1 and myserver2.
avahi-discover then displayed these two services, with their names and the correct port numbers. And in konqueror, browsing to "zeroconf:/" also showed the two "WWW servers" correctly.

So, this could provide the functionality you were looking for... But it still has the drawback that zeroconf seems to be quite a big framework, and it requires multicast DNS in the kernel and such stuff...

Regards,
Oliver
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.2 (GNU/Linux)

iD8DBQFEE02jTFOM6DcNJ6cRAtgLAJ9e8YlWFi6Is9+w2yDcOTIJFr9h8QCgvz18 hXvZb+16P1W5QDhnkac1ywc=
=d+pp
-----END PGP SIGNATURE-----

#7 lore raw
Quoted 20 lines · Oliver Gerlich
Quoted 7 lines · Daniel Veillard

I need first to find the ports of the
QEmu instances (plural, if you limit to one per box, then you can block the default port number and there would be no problem) on a local machine. I don't think that "Multicast DNS"/RendezVous works with random port numbers, all it does over normal TCP is scan for local hosts without using DNS resolution. Again I don't think it's really the problem I'm trying to solve, maybe I just didn't expressed myself clearly :-)

After experimenting with the avahi apps a bit, I think mDNS can indeed advertise several services on the same host with different ports! I ran "avahi-publish -s -H localhost myserver1 _http._tcp 80" in one terminal, then "avahi-publish -s -H localhost myserver2 _http._tcp 12345" in another terminal. This advertised two HTTP servers which were running on my local host, on ports 80 and 12345, under the names myserver1 and myserver2.
avahi-discover then displayed these two services, with their names and the correct port numbers. And in konqueror, browsing to "zeroconf:/" also showed the two "WWW servers" correctly.

Quoted 3 lines

So, this could provide the functionality you were looking for... But it still has the drawback that zeroconf seems to be quite a big framework, and it requires multicast DNS in the kernel and such stuff...

Ah, okay, well basically once you run you own DNS like service locally
this kind of things becomes possible. But yes this is quite a big framework, adding this as a dependency sounds a bit extreme, and I assume it won't work if you don't have an avahi or zeroconf server running. One of the main advantage of QEmu is that its requirement at the system level are very low, I'm not sure we can put gracefully such requirement there :-)

But thanks for updating me on this, that's good to know !

Daniel

Signature · 3 lines
Daniel Veillard      | Red Hat http://redhat.com/
[email protected]  | libxml GNOME XML XSLT toolkit  http://xmlsoft.org/
http://veillard.com/ | Rpmfind RPM search engine http://rpmfind.net/
#8 lore raw
In reply to Daniel Veillard
Quoted 4 lines · Daniel Veillard

Hi,

enclosed is a first version of a patch to allow remote access and control for QEmu instances,

I have put an updated version of the patch and client code example at
ftp://veillard.com/libvirt/qemu-patch
it fixed the client-server interaction by adding an end of command marker in the stream sent back. This seems to work well, but I still don't know if the use of a /tmp/qemu-$$-socket entry point is really acceptable.

Daniel

Signature · 3 lines
Daniel Veillard      | Red Hat http://redhat.com/
[email protected]  | libxml GNOME XML XSLT toolkit  http://xmlsoft.org/
http://veillard.com/ | Rpmfind RPM search engine http://rpmfind.net/