path: root/xenscreen.c

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <sys/utsname.h>

#include <xs.h>

#include "list.h"
#include "xenstore.h"
#include "apps.h"

/* ------------------------------------------------------------- */

#define BUFSIZE     64
#define PRE_STATE   "%16s: "

struct dom {
    int                domid;
    char               name[BUFSIZE];
    char               tty[BUFSIZE];
    int                connected;
    int                destroyed;
    struct list_head   next;
};
static LIST_HEAD(doms);
static int domcnt;

static char *screen_rc      = "/etc/xen/xenscreenrc";
static char *screen_unlink  = NULL;
static char *screen_session = "xencon";
static char *screen_title   = "mon";
static int  screen_detached;
static int  screen_logging;
static int  screen_shell;

static char builtin_screen_rc[] =
"multiuser on\n"
"\n"
"# status line\n"
"sorendition =s wb\n"
"hardstatus lastline \"%{=b bw} xen |%{-} %-w%{= yb} %50>%n* %t %{-}%+w%<\"\n"
"\n"
"# logging\n"
"logfile /var/log/xen/console.%t\n"
"logfile flush 1\n"
"logtstamp on\n"
"\n"
"# disable killing windows\n"
"bind k\n"
"bind K\n"
"bind ^K\n"
"\n"
"# misc other useful settings\n"
"shell /bin/bash\n"
"defscrollback 5000\n"
"compacthist on\n"
"defutf8 on\n"
"termcapinfo xterm hs@\n"
"\n"
;

/* ------------------------------------------------------------- */

static struct dom *find_dom(int domid)
{
    struct dom *dom;
    struct list_head *item;

    list_for_each(item, &doms) {
	dom = list_entry(item, struct dom, next);
	if (dom->domid == domid)
	    return dom;
    }
    return NULL;
}

static struct dom *get_dom(int domid)
{
    struct dom *dom;

    dom = find_dom(domid);
    if (!dom) {
	dom = malloc(sizeof(*dom));
	memset(dom,0,sizeof(*dom));
	dom->domid = domid;
	list_add_tail(&dom->next, &doms);
    }
    return dom;
}

/* ------------------------------------------------------------- */

static int termsig;

static void catchsig(int sig)
{
    termsig = sig;
}

/* ------------------------------------------------------------- */

static int screen_command(char *arg0, ...)
{
    va_list args;
    char *argv[64];
    int i = 0;

    argv[i++] = "screen";
    argv[i++] = "-X";
    argv[i++] = "-S";
    argv[i++] = screen_session;

    argv[i++] = arg0;
    va_start(args, arg0);
    while (i < array_size(argv)) {
	argv[i] = va_arg(args, char*);
	if (NULL == argv[i])
	    break;
	i++;
    }
    va_end(args);

    return run_application_va(1, "screen", argv);
}

static int screen_attach(char *window)
{
    return run_application(1, "screen", "screen",
			   "-S", screen_session, "-r", "-x",
			   "-p", window ? window : "=",
			   NULL);
}

static void try_attach_domain(struct dom *dom, int boot)
{
    int rc;
    
    if (dom->connected)
	return;
    if (!strlen(dom->name))
	return;
    if (!strlen(dom->tty))
	return;

    fprintf(stderr, PRE_STATE "%s (%d) @ %s\n",
	    "connecting", dom->name, dom->domid, dom->tty);

    if (0 != access(dom->tty, R_OK)) {
	fprintf(stderr, "        error: no access to tty %s\n", dom->tty);
	return;
    }

    /* known-racy, but better than nothing ... */
    rc = run_application(1, "fuser", "fuser", "-s", dom->tty, NULL);
    if (0 == rc) {
	fprintf(stderr,"        error: tty %s already in use\n", dom->tty);
	return;
    }

    if (screen_logging)
	rc = screen_command("screen", "-L", "-t", dom->name, dom->tty,
			    NULL);
    else
	rc = screen_command("screen", "-t", dom->name, dom->tty,
			    NULL);

#if 0
    /*
     * Hmm, not exactly the most elegant way to do this, has
     * some ugly glitches too.
     *
     * Switches back from the new window to the previous one.
     * Better would be to not switch in the first place,
     * seems screen can't do that though :-(
     */
    if (!boot)
	rc = screen_command("other", NULL);
#endif

    dom->connected = 1;
    domcnt++;
}

static void try_release_domain(struct dom *dom)
{
    if (!dom->destroyed)
	return;
    fprintf(stderr, PRE_STATE "%s (%d)%s\n", "disappeared",
	    dom->name, dom->domid, dom->connected ? " [conn]" : "");
    if (dom->connected)
	domcnt--;
    list_del(&dom->next);
    free(dom);
}

static void builtin_screen_setup(void)
{
    char *rc = strdup("/tmp/xenscreen-XXXXXX");
    int fd;

    fd = mkstemp(rc);
    if (-1 == fd) {
	fprintf(stderr,"mkstmp(%s): %s\n", rc, strerror(errno));
	return;
    }
    write(fd, builtin_screen_rc, sizeof(builtin_screen_rc));
    close(fd);

    fprintf(stderr, "Config file \"%s\" doesn't exist, using builtin config (%s).\n",
	    screen_rc, rc);
    screen_rc     = rc;
    screen_unlink = rc;
    return;
}

/* ------------------------------------------------------------- */

static void usage(FILE *fp)
{
    fprintf(fp,
	    "I'm managing xen consoles using screen.\n"
	    "\n"
	    "usage: xenscreen [options]\n"
	    "options:\n"
	    "   -h            print this text\n"
	    "   -b            print default screen config file\n"
	    "   -z            open a screen window with a shell\n"
	    "\n"
	    "   -L            enable console output logging\n"
	    "   -c screenrc   screen config file              [%s]\n"
	    "   -S session    screen session name             [%s]\n"
	    "   -p window     preselect screen window\n"
	    "\n"
	    "-- \n"
	    "(c) 2006 Gerd Hoffmann <kraxel@suse.de>\n",
	    screen_rc, screen_session);
}

int main(int argc, char *argv[])
{
    struct sigaction act,old;
    struct utsname uts;
    fd_set set;
    struct xs_handle *xenstore = NULL;
    xs_transaction_t xst;
    char **vec = NULL, *window = NULL;
    int domid, nac, c;
    char path[BUFSIZE], value[BUFSIZE];
    unsigned int count, i, rc;
    struct dom *dom;
    time_t last_ctrl_c = 0;
    char **nav;

    for (;;) {
        if (-1 == (c = getopt(argc, argv, "hdbLzc:S:u:p:")))
            break;
        switch (c) {

	/* screen-like behaviour */
        case 'c':
	    screen_rc = optarg;
            break;
        case 'S':
	    screen_session = optarg;
            break;
	case 'p':
	    window = optarg;
	    break;
	case 'L':
	    screen_logging = 1;
	    break;
	case 'd':
	    screen_detached = 1;
	    break;

	/* other options */
	case 'u':
	    screen_unlink = optarg;
	    break;
	case 'z':
	    screen_shell = 1;
	    break;
	case 'b':
	    printf("%s", builtin_screen_rc);
	    exit(0);

        case 'h':
            usage(stdout);
            exit(0);
        default:
            usage(stderr);
            exit(1);
        }
    }

    if (!have_application("screen")) {
	fprintf(stderr, "screen not found in $PATH (not installed?), exiting.\n");
	exit(1);
    }

    memset(&uts, 0, sizeof(uts));
    if (0 == uname(&uts)) {
	screen_title = malloc(strlen(uts.nodename) +4);
	sprintf(screen_title, "[%s]", uts.nodename);
    }

    if (NULL == getenv("STY") || NULL == strstr(getenv("STY"),screen_session)) {
	/* not running inside screen */
	if (!screen_detached) {
	    /* try to attach */
	    rc = screen_attach(window);
	    if (0 == rc)
		exit(0);
	} else {
	    /* This is a nop: just check if screen is running */
	    rc = screen_command("select", ".", NULL);
	    if (0 == rc) {
		fprintf(stderr,"Screen session \"%s\" already active, exiting.\n",
			screen_session);
		exit(0);
	    }
	}

	/* failing that, start a new screen session ... */
	fprintf(stderr,"Starting new screen session \"%s\".\n", screen_session);
	if (0 != access(screen_rc, R_OK))
	    builtin_screen_setup();
	nav = malloc(sizeof(char*) * (argc + 16));
	nac = 0;
	nav[nac++] = "screen";
	nav[nac++] = "-d";
	nav[nac++] = "-m";
	nav[nac++] = "-S";
	nav[nac++] = screen_session;
	nav[nac++] = "-c";
	nav[nac++] = screen_rc;
	nav[nac++] = "-t";
	nav[nac++] = screen_title;
	for (i = 0; argv[i] != NULL;)
	    nav[nac++] = argv[i++];
	if (screen_unlink) {
	    nav[nac++] = "-u";
	    nav[nac++] = screen_unlink;
	}
	nav[nac++] = NULL;
	rc = run_application_va(1, "screen", nav);
	/* ... and attach if asked for */
	if (0 == rc && !screen_detached) {
	    sleep(1); /* quick & dirty race work around */
	    rc = screen_attach(window);
	}
	exit(rc);
    }

    /* setup signal handler */
    memset(&act,0,sizeof(act));
    sigemptyset(&act.sa_mask);
    act.sa_handler = catchsig;
    sigaction(SIGTERM,&act,&old);
    sigaction(SIGINT,&act,&old);

    fprintf(stderr,
	    "###\n"
	    "### Managing Xen consoles using screen.\n"
	    "### This is the monitor process, at %s.\n"
	    "###\n"
	    "\n",
	    uts.nodename);
    if (screen_shell)
	screen_command("screen", "-t", "[shell]", "/bin/bash", NULL);

    /* connect to xenstore */
    xenstore = xenstore_open(1,1,1,1);
    if (NULL == xenstore) {
	fprintf(stderr, "can't access xenstore, exiting\n");
	exit(1);
    }
    xs_watch(xenstore, "/local/domain", "token");

    /* look for running domains */
    if (!(xst = xs_transaction_start(xenstore))) {
	fprintf(stderr,"Oops, can't start xenstore transaction\n");
	exit(1);
    }
    vec = xs_directory(xenstore, xst, "/local/domain", &count);
    xs_transaction_end(xenstore, xst, 0);

    fprintf(stderr,"looking for existing domains\n");
    for (i = 0; i < count; i++) {
	domid = atoi(vec[i]);
	dom = get_dom(domid);
	snprintf(path, sizeof(path), "/local/domain/%d/name", domid);
	xenstore_read(xenstore, path, dom->name, sizeof(dom->name));
	snprintf(path, sizeof(path), "/local/domain/%d/console/tty", domid);
	xenstore_read(xenstore, path, dom->tty, sizeof(dom->tty));
	try_attach_domain(dom, 1);
    }

    /* main loop */
    fprintf(stderr,"ok, watching out for changes now\n");
    for (;;) {
	if (termsig) {
	    if (!domcnt)
		break;
	    if (time(NULL) - last_ctrl_c < 3)
		break;
	    fprintf(stderr,
		    "\n"
		    "Got ^C - still %d domain(s) active - not quitting.\n"
		    "\n"
		    "You should better use detach instead (^A d).\n"
		    "Or kill all windows (^A \\) if you don't want\n"
		    "keep screen hanging around.\n"
		    "\n"
		    "Hit ^C within 3 secs again to quit nevertheless.\n"
		    "\n",
		    domcnt);
	    last_ctrl_c = time(NULL);
	    termsig = 0;
	}

	FD_ZERO(&set);
	FD_SET(xs_fileno(xenstore), &set);
	switch (select(xs_fileno(xenstore)+1, &set, NULL, NULL, NULL)) {
	case -1:
	    if (EINTR == errno)
		continue; /* termsig check */
	    perror("select");
	    break;
	case 0:
	    fprintf(stderr,"Huh, select() timeout?\n");
	    exit(1);
	    break;
	default:
	    break;
	}
	
	if (vec)
	    free(vec);
	vec = xs_read_watch(xenstore, &count);
	if (NULL == vec) {
	    fprintf(stderr,"xs_read_watch() failed\n");
	    exit(1);
	}
	if (2 != sscanf(vec[XS_WATCH_PATH], "/local/domain/%d/%64s", &domid, path)) {
	    if (1 != sscanf(vec[XS_WATCH_PATH], "/local/domain/%d", &domid))
		continue;
	    strcpy(path, "");
	}
	dom = get_dom(domid);

	if (0 == strcmp(path,"")) {
	    rc = xenstore_read(xenstore, vec[XS_WATCH_PATH], value, sizeof(value));
	    if (0 != rc)
		dom->destroyed = 1;

	} else if (0 == strcmp(path, "console/tty")) {
	    rc = xenstore_read(xenstore, vec[XS_WATCH_PATH], value, sizeof(value));
	    if (0 != rc)
		continue;
	    strcpy(dom->tty, value);

	} else if (0 == strcmp(path, "name")) {
	    rc = xenstore_read(xenstore, vec[XS_WATCH_PATH], value, sizeof(value));
	    if (0 != rc)
		continue;
	    strcpy(dom->name, value);
	    fprintf(stderr, PRE_STATE "%s (%d)\n", "new domain", dom->name, dom->domid);

	} else {
	    continue;

	}

	try_attach_domain(dom, 0);
	try_release_domain(dom);
    }

    if (screen_unlink)
	unlink(screen_unlink);
    return 0;
}