diff --git a/agents/virt/server/serial.c b/agents/virt/server/serial.c
index b5cbf5a4..bde82180 100644
--- a/agents/virt/server/serial.c
+++ b/agents/virt/server/serial.c
@@ -1,459 +1,459 @@
 /*
   Copyright Red Hat, Inc. 2010
 
   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 the
   Free Software Foundation; either version 2, or (at your option) any
   later version.
 
   This program 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
   General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; see the file COPYING.  If not, write to the
   Free Software Foundation, Inc.,  675 Mass Ave, Cambridge, 
   MA 02139, USA.
 */
 /*
  * Author: Lon Hohberger <lhh at redhat.com>
  */
 
 #include "config.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <signal.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/un.h>
 #include <sys/socket.h>
 #include <sys/select.h>
 #include <sys/ioctl.h>
 #include <arpa/inet.h>
 #include <net/if.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #include <sys/time.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <pthread.h>
 #include <nss.h>
 #include <libgen.h>
 
 /* Local includes */
 #include "debug.h"
 #include "fdops.h"
 #include "serial.h"
 #include "list.h"
 #include "simpleconfig.h"
 #include "static_map.h"
 #include "server_plugin.h"
 #include "history.h"
 #include "xvm.h"
 
 #define NAME "serial"
 #define SERIAL_VERSION "0.5"
 
 #define SERIAL_PLUG_MAGIC 0x1227a000
 
 #define VALIDATE(info) \
 do {\
 	if (!info || info->magic != SERIAL_PLUG_MAGIC)\
 		return -EINVAL;\
 } while(0)
 
 
 typedef struct _serial_info {
 	uint64_t magic;
 	const fence_callbacks_t *cb;
 	void *priv;
 	char *uri;
 	char *path;
 	history_info_t *history;
 	map_object_t *maps;
 	int mode;
 	int wake_fd;
 } serial_info;
 
 
 struct serial_hostlist_arg {
 	map_object_t *map;
 	const char *src;
 	int fd;
 };
 
 
 /*
  * See if we fenced this node recently (successfully)
  * If so, ignore the request for a few seconds.
  *
  * We purge our history when the entries time out.
  */
 static int
 check_history(void *a, void *b) {
 	serial_req_t *old = a, *current = b;
 
 	if (old->request == current->request &&
 	    old->seqno == current->seqno &&
 	    !strcasecmp((const char *)old->domain,
 			(const char *)current->domain)) {
 		return 1;
 	}
 	return 0;
 }
 
 
 static int 
 serial_hostlist(const char *vm_name, const char *vm_uuid,
 	 	int state, void *priv)
 {
 	struct serial_hostlist_arg *arg = (struct serial_hostlist_arg *)priv;
 	host_state_t hinfo;
 	struct timeval tv;
 	int ret;
 
 	if (map_check2(arg->map, arg->src, vm_uuid, vm_name) == 0) {
 		/* if we don't have access to fence this VM,
 		 * we should not see it in a hostlist either */
 		return 0;
 	}
 
 	strncpy((char *)hinfo.domain, vm_name, sizeof(hinfo.domain) - 1);
 	strncpy((char *)hinfo.uuid, vm_uuid, sizeof(hinfo.uuid) - 1);
 	hinfo.state = state;
 
 	tv.tv_sec = 1;
 	tv.tv_usec = 0;
 
 	ret = _write_retry(arg->fd, &hinfo, sizeof(hinfo), &tv);
 	if (ret == sizeof(hinfo))
 		return 0;
 	return 1;
 }
 
 
 static int
 serial_hostlist_begin(int fd)
 {
 	struct timeval tv;
 	serial_resp_t resp;
 
 	resp.magic = SERIAL_MAGIC;
 	resp.response = RESP_HOSTLIST;
 
 	tv.tv_sec = 1;
 	tv.tv_usec = 0;
 	return _write_retry(fd, &resp, sizeof(resp), &tv);
 }
 
 
 static int 
 serial_hostlist_end(int fd)
 {
 	host_state_t hinfo;
 	struct timeval tv;
 	int ret;
 
 	//printf("Sending terminator packet\n");
 
 	memset(&hinfo, 0, sizeof(hinfo));
 
 	tv.tv_sec = 1;
 	tv.tv_usec = 0;
 	ret = _write_retry(fd, &hinfo, sizeof(hinfo), &tv);
 	if (ret == sizeof(hinfo))
 		return 0;
 	return 1;
 }
 
 
 static int
 do_fence_request(int fd, const char *src, serial_req_t *req, serial_info *info)
 {
 	char response = RESP_FAIL;
 	struct serial_hostlist_arg arg;
 	serial_resp_t resp;
 
 	arg.fd = fd;
 
 	switch(req->request) {
 	case FENCE_NULL:
 		response = info->cb->null((char *)req->domain, info->priv);
 		break;
 	case FENCE_ON:
 		if (map_check(info->maps, src,
 				     (const char *)req->domain) == 0) {
 			response = RESP_PERM;
 			break;
 		}
 		response = info->cb->on((char *)req->domain, src,
 				       	req->seqno, info->priv);
 		break;
 	case FENCE_OFF:
 		if (map_check(info->maps, src,
 				     (const char *)req->domain) == 0) {
 			response = RESP_PERM;
 			break;
 		}
 		response = info->cb->off((char *)req->domain, src,
 					 req->seqno, info->priv);
 		break;
 	case FENCE_REBOOT:
 		if (map_check(info->maps, src,
 				     (const char *)req->domain) == 0) {
 			response = RESP_PERM;
 			break;
 		}
 		response = info->cb->reboot((char *)req->domain, src,
 					    req->seqno, info->priv);
 		break;
 	case FENCE_STATUS:
 		if (map_check(info->maps, src,
 				     (const char *)req->domain) == 0) {
 			response = RESP_PERM;
 			break;
 		}
 		response = info->cb->status((char *)req->domain, info->priv);
 		break;
 	case FENCE_DEVSTATUS:
 		response = info->cb->devstatus(info->priv);
 		break;
 	case FENCE_HOSTLIST:
 		arg.map = info->maps;
 		arg.src = src;
 		arg.fd = fd;
 
 		serial_hostlist_begin(arg.fd);
 		response = info->cb->hostlist(serial_hostlist, &arg,
 					      info->priv);
 		serial_hostlist_end(arg.fd);
 		break;
 	}
 
 	resp.magic = SERIAL_MAGIC;
 	resp.response = response;
 	swab_serial_resp_t(&resp);
 
 	dbg_printf(3, "Sending response to caller...\n");
 	if (_write_retry(fd, &resp, sizeof(resp), NULL) < 0)
 		perror("write");
 
 	/* XVM shotguns multicast packets, so we want to avoid 
 	 * acting on the same request multiple times if the first
 	 * attempt was successful.
 	 */
 	history_record(info->history, req);
 
 	return 1;
 }
 
 
 static int
 serial_dispatch(listener_context_t c, struct timeval *timeout)
 {
 	char src_domain[MAX_DOMAINNAME_LENGTH];
 	serial_info *info;
 	serial_req_t data;
 	fd_set rfds;
 	struct timeval tv;
 	int max;
 	int n, x, ret;
 
 	info = (serial_info *)c;
 	VALIDATE(info);
 
 	FD_ZERO(&rfds);
 	domain_sock_fdset(&rfds, &max);
 	FD_SET(info->wake_fd, &rfds);
 	if (info->wake_fd > max)
 		max = info->wake_fd;
 
 	n = select(max+1, &rfds, NULL, NULL, timeout);
 	if (n < 0) {
 		if (errno == EINTR || errno == EAGAIN)
 			n = 0;
 		else
 			dbg_printf(2, "select: %s\n", strerror(errno));
 		return n;
 	}
 
 	/*
 	 * See if the goal was just to be woken up in order to refill our
 	 * file descriptor set.  For example, if multiple domains were 
 	 * created simultaneously, we would have to refill our fd_set
 	 */
 	if (FD_ISSET(info->wake_fd, &rfds)) {
 		tv.tv_sec = 0;
 		tv.tv_usec = 10000;
 		_read_retry(info->wake_fd, &c, 1, &tv);
 		return 0;
 	}
 
 	/* 
 	 * If no requests, we're done 
 	 */
 	if (n == 0)
 		return 0;
 
 	/* find & read request */
 	for (x = 0; x <= max; x++) {
 		if (FD_ISSET(x, &rfds)) {
 			tv.tv_sec = 1;
 			tv.tv_usec = 0;
 
 			ret = _read_retry(x, &data, sizeof(data), &tv);
 
 			if (ret != sizeof(data)) {
 				if (--n > 0)
 					continue;
 				else
 					return 0;
 			} else {
 				swab_serial_req_t(&data);
 				break;
 			}
 		}
 	}
 
 	src_domain[0] = 0;
 	domain_sock_name(x, src_domain, sizeof(src_domain));
 
 	dbg_printf(2, "Sock %d Request %d seqno %d src %s target %s\n", x,
 	       data.request, data.seqno, src_domain, data.domain);
 
 	if (history_check(info->history, &data) == 1) {
 		dbg_printf(3, "We just did this request; dropping packet\n");
 		return 0;
 	}
 
 	do_fence_request(x, src_domain[0] == 0 ? NULL : src_domain,
 			 &data, info);
 		
 	return 0;
 }
 
 
 static int
 serial_config(config_object_t *config, serial_info *args)
 {
 	char value[1024];
 	int errors = 0;
 
 	if (sc_get(config, "fence_virtd/@debug", value, sizeof(value))==0)
 		dset(atoi(value));
 
 	if (sc_get(config, "listeners/serial/@uri",
 		   value, sizeof(value)-1) == 0) {
 		dbg_printf(1, "Got %s for uri\n", value);
 		args->uri = strdup(value);
 	} 
 
 	if (sc_get(config, "listeners/serial/@path",
 		   value, sizeof(value)-1) == 0) {
-		dbg_printf(1, "Got %s for uri\n", value);
+		dbg_printf(1, "Got %s for path\n", value);
 		args->path = strdup(value);
 	} 
 
 	if (sc_get(config, "listeners/serial/@mode",
 		   value, sizeof(value)-1) == 0) {
 		if (!strcasecmp(value, "vmchannel")) {
 			args->mode = 1;
 		} else if (!strcasecmp(value, "serial")) {
 			args->mode = 0;
 		} else {
 			args->mode = atoi(value);
 			if (args->mode < 0)
 				args->mode = 0;
 		}
 
 		dbg_printf(1, "Got %s for mode\n",
 			   args->mode?"VMChannel":"serial");
 
 	} 
 
 	return errors;
 }
 
 
 static int
 serial_init(listener_context_t *c, const fence_callbacks_t *cb,
 	   config_object_t *config, map_object_t *map, void *priv)
 {
 	serial_info *info;
 	int ret;
 
 	info = malloc(sizeof(*info));
 	if (!info)
 		return -1;
 	memset(info, 0, sizeof(*info));
 
 	info->priv = priv;
 	info->cb = cb;
 
 	ret = serial_config(config, info);
 	if (ret < 0) {
 		perror("serial_config");
 		return -1;
 	} else if (ret > 0) {
 		printf("%d errors found during configuration\n",ret);
 		return -1;
 	}
 
 	info->maps = map;
 
 	info->magic = SERIAL_PLUG_MAGIC;
 	info->history = history_init(check_history, 10, sizeof(fence_req_t));
 	*c = (listener_context_t)info;
 	start_event_listener(info->uri, info->path, info->mode, &info->wake_fd);
 	sleep(1);
 
 	return 0;
 }
 
 
 static int
 serial_shutdown(listener_context_t c)
 {
 	serial_info *info = (serial_info *)c;
 	
 	dbg_printf(3, "Shutting down serial\n");
 
 	VALIDATE(info);
 	info->magic = 0;
 	stop_event_listener();
 	domain_sock_cleanup();
 	history_wipe(info->history);
 	free(info->history);
 	free(info->uri);
 	free(info->path);
 	free(info);
 
 	return 0;
 }
 
 
 static listener_plugin_t serial_plugin = {
 	.name = NAME,
 	.version = SERIAL_VERSION,
 	.init = serial_init,
 	.dispatch = serial_dispatch,
 	.cleanup = serial_shutdown,
 };
 
 double
 LISTENER_VER_SYM(void)
 {
 	return PLUGIN_VERSION_LISTENER;
 }
 
 const listener_plugin_t *
 LISTENER_INFO_SYM(void)
 {
 	return &serial_plugin;
 }