diff -ur a/server/checkpoint.c b/server/checkpoint.c
--- a/server/checkpoint.c	2014-06-23 15:56:09.000000000 -0400
+++ b/server/checkpoint.c	2017-08-09 13:30:40.708689303 -0400
@@ -79,7 +79,7 @@
 {
 	virt_list_t *list = NULL;
 
-	list = vl_get(vp, my_id);
+	list = vl_get(vp, 1, my_id);
 	if (!list)
 		return -1;
 
diff -ur a/server/libvirt.c b/server/libvirt.c
--- a/server/libvirt.c	2014-06-23 15:56:09.000000000 -0400
+++ b/server/libvirt.c	2017-08-09 13:30:40.709689288 -0400
@@ -1,5 +1,5 @@
 /*
-  Copyright Red Hat, Inc. 2006
+  Copyright Red Hat, Inc. 2006-2017
 
   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
@@ -61,13 +61,15 @@
 
 
 #define NAME "libvirt"
-#define VERSION "0.1"
+#define VERSION "0.3"
 
 #define MAGIC 0x1e19317a
 
 struct libvirt_info {
 	int magic;
-	virConnectPtr vp;
+	config_object_t *config;
+	int vp_count;
+	virConnectPtr *vp;
 };
 
 #define VALIDATE(arg) \
@@ -79,179 +81,128 @@
 } while(0)
 
 
-static inline int
-wait_domain(const char *vm_name, virConnectPtr vp,
-	    int timeout)
-{
-	int tries = 0;
-	int response = 1;
-	int ret;
-	virDomainPtr vdp;
-	virDomainInfo vdi;
-	int uuid_check;
-	
-	uuid_check = is_uuid(vm_name);
-
-	if (uuid_check) {
-		vdp = virDomainLookupByUUIDString(vp, (const char *)vm_name);
-	} else {
-		vdp = virDomainLookupByName(vp, vm_name);
+static void
+libvirt_init_libvirt_conf(struct libvirt_info *info) {
+	config_object_t *config = info->config;
+	int i = 0;
+
+	if (info->vp) {
+		dbg_printf(2, "Lost libvirtd connection. Reinitializing.\n");
+		for (i = 0 ; i < info->vp_count ; i++)
+			virConnectClose(info->vp[i]);
+		free(info->vp);
+		info->vp = NULL;
 	}
-	if (!vdp)
-		return 0;
+	info->vp_count = 0;
 
-	/* Check domain liveliness.  If the domain is still here,
-	   we return failure, and the client must then retry */
-	/* XXX On the xen 3.0.4 API, we will be able to guarantee
-	   synchronous virDomainDestroy, so this check will not
-	   be necessary */
 	do {
-		if (++tries > timeout)
-			break;
+		virConnectPtr vp;
+		virConnectPtr *vpl = NULL;
+		char conf_attr[256];
+		char value[1024];
+		char *uri;
+
+		if (i != 0) {
+			snprintf(conf_attr, sizeof(conf_attr),
+				"backends/libvirt/@uri%d", i);
+		} else
+			snprintf(conf_attr, sizeof(conf_attr), "backends/libvirt/@uri");
+		++i;
 
-		sleep(1);
-		if (uuid_check) {
-			vdp = virDomainLookupByUUIDString(vp,
-					(const char *)vm_name);
-		} else {
-			vdp = virDomainLookupByName(vp, vm_name);
-		}
-		if (!vdp) {
-			dbg_printf(2, "Domain no longer exists\n");
-			response = 0;
+		if (sc_get(config, conf_attr, value, sizeof(value)) != 0)
 			break;
-		}
 
-		memset(&vdi, 0, sizeof(vdi));
-		ret = virDomainGetInfo(vdp, &vdi);
-		virDomainFree(vdp);
-		if (ret < 0)
+		uri = value;
+		vp = virConnectOpen(uri);
+		if (!vp) {
+			dbg_printf(1, "[libvirt:INIT] Failed to connect to URI: %s\n", uri);
 			continue;
+		}
 
-		if (vdi.state == VIR_DOMAIN_SHUTOFF) {
-			dbg_printf(2, "Domain has been shut off\n");
-			response = 0;
-			break;
+		vpl = realloc(info->vp, sizeof(*info->vp) * (info->vp_count + 1));
+		if (!vpl) {
+			dbg_printf(1, "[libvirt:INIT] Out of memory allocating URI: %s\n",
+				uri);
+			virConnectClose(vp);
+			continue;
 		}
-		
-		dbg_printf(4, "Domain still exists (state %d) "
-			   "after %d seconds\n",
-			   vdi.state, tries);
+
+		info->vp = vpl;
+		info->vp[info->vp_count++] = vp;
+
+		if (i > 1)
+			dbg_printf(1, "[libvirt:INIT] Added URI%d %s\n", i - 1, uri);
+		else
+			dbg_printf(1, "[libvirt:INIT] Added URI %s\n", uri);
 	} while (1);
+}
 
-	return response;
+
+static int
+libvirt_bad_connections(struct libvirt_info *info) {
+	int bad = 0;
+	int i;
+
+	for (i = 0 ; i < info->vp_count ; i++) {
+		/*
+		** Send a dummy command to trigger an error if libvirtd
+		** died or restarted
+		*/
+		virConnectNumOfDomains(info->vp[i]);
+		if (!virConnectIsAlive(info->vp[i])) {
+			dbg_printf(1, "libvirt connection %d is dead\n", i);
+			bad++;
+		}
+	}
+
+	if (info->vp_count < 1 || bad)
+		libvirt_init_libvirt_conf(info);
+
+	return bad || info->vp_count < 1;
 }
 
+static void
+libvirt_validate_connections(struct libvirt_info *info) {
+	while (1) {
+		if (libvirt_bad_connections(info))
+			sleep(1);
+		else
+			break;
+	}
+}
 
 static int
 libvirt_null(const char *vm_name, void *priv)
 {
-	dbg_printf(5, "%s %s\n", __FUNCTION__, vm_name);
+	dbg_printf(5, "ENTER %s %s\n", __FUNCTION__, vm_name);
 	printf("NULL operation: returning failure\n");
 	return 1;
 }
 
 
 static int
-libvirt_off(const char *vm_name, const char *src,
-	    uint32_t seqno, void *priv)
+libvirt_off(const char *vm_name, const char *src, uint32_t seqno, void *priv)
 {
 	struct libvirt_info *info = (struct libvirt_info *)priv;
-	virDomainPtr vdp;
-	virDomainInfo vdi;
-	int ret = -1;
 
-	dbg_printf(5, "%s %s\n", __FUNCTION__, vm_name);
+	dbg_printf(5, "ENTER %s %s %u\n", __FUNCTION__, vm_name, seqno);
 	VALIDATE(info);
 
-	if (is_uuid(vm_name)) {
-		vdp = virDomainLookupByUUIDString(info->vp,
-					    (const char *)vm_name);
-	} else {
-		vdp = virDomainLookupByName(info->vp, vm_name);
-	}
-
-	if (!vdp) {
-		dbg_printf(2, "Nothing to do - domain does not exist\n");
-		return 1;
-	}
-
-	if (((virDomainGetInfo(vdp, &vdi) == 0) &&
-	     (vdi.state == VIR_DOMAIN_SHUTOFF))) {
-		dbg_printf(2, "Nothing to do - domain is off\n");
-		virDomainFree(vdp);
-		return 0;
-	}
-
-	syslog(LOG_NOTICE, "Destroying domain %s\n", vm_name);
-	dbg_printf(2, "[OFF] Calling virDomainDestroy\n");
-	ret = virDomainDestroy(vdp);
-	if (ret < 0) {
-		syslog(LOG_NOTICE, "Failed to destroy domain: %d\n", ret);
-		printf("virDomainDestroy() failed: %d\n", ret);
-		return 1;
-	}
-
-	if (ret) {
-		syslog(LOG_NOTICE,
-		       "Domain %s still exists; fencing failed\n",
-		       vm_name);
-		printf("Domain %s still exists; fencing failed\n", vm_name);
-		return 1;
-	}
-
-	return 0;
+	libvirt_validate_connections(info);
+	return vm_off(info->vp, info->vp_count, vm_name);
 }
 
 
 static int
-libvirt_on(const char *vm_name, const char *src,
-	   uint32_t seqno, void *priv)
+libvirt_on(const char *vm_name, const char *src, uint32_t seqno, void *priv)
 {
 	struct libvirt_info *info = (struct libvirt_info *)priv;
-	virDomainPtr vdp;
-	virDomainInfo vdi;
-	int ret = -1;
 
-	dbg_printf(5, "%s %s\n", __FUNCTION__, vm_name);
+	dbg_printf(5, "ENTER %s %s %u\n", __FUNCTION__, vm_name, seqno);
 	VALIDATE(info);
 
-	if (is_uuid(vm_name)) {
-		vdp = virDomainLookupByUUIDString(info->vp,
-					    (const char *)vm_name);
-	} else {
-		vdp = virDomainLookupByName(info->vp, vm_name);
-	}
-
-	if (vdp &&
-	    ((virDomainGetInfo(vdp, &vdi) == 0) &&
-	     (vdi.state != VIR_DOMAIN_SHUTOFF))) {
-		dbg_printf(2, "Nothing to do - domain is running\n");
-
-		if (vdp)
-			virDomainFree(vdp);
-		return 0;
-	}
-
-	syslog(LOG_NOTICE, "Starting domain %s\n", vm_name);
-	dbg_printf(2, "[ON] Calling virDomainCreate\n");
-	ret = virDomainCreate(vdp);
-	if (ret < 0) {
-		syslog(LOG_NOTICE, "Failed to start domain: %d\n", ret);
-		printf("virDomainCreate() failed: %d\n", ret);
-		return 1;
-	}
-
-	if (ret) {
-		syslog(LOG_NOTICE,
-		       "Domain %s did not start\n",
-		       vm_name);
-		printf("Domain %s did not start\n", vm_name);
-		return 1;
-	}
-	syslog(LOG_NOTICE, "Domain %s started\n", vm_name);
-
-	return 0;
+	libvirt_validate_connections(info);
+	return vm_on(info->vp, info->vp_count, vm_name);
 }
 
 
@@ -270,126 +221,25 @@
 libvirt_status(const char *vm_name, void *priv)
 {
 	struct libvirt_info *info = (struct libvirt_info *)priv;
-	virDomainPtr vdp;
-	virDomainInfo vdi;
-	int ret = 0;
 
-	dbg_printf(5, "%s %s\n", __FUNCTION__, vm_name);
+	dbg_printf(5, "ENTER %s %s\n", __FUNCTION__, vm_name);
 	VALIDATE(info);
 
-	if (is_uuid(vm_name)) {
-		vdp = virDomainLookupByUUIDString(info->vp,
-					    (const char *)vm_name);
-	} else {
-		vdp = virDomainLookupByName(info->vp, vm_name);
-	}
-
-	if (!vdp || ((virDomainGetInfo(vdp, &vdi) == 0) &&
-	     (vdi.state == VIR_DOMAIN_SHUTOFF))) {
-		ret = RESP_OFF;
-	}
-
-	if (vdp)
-		virDomainFree(vdp);
-	return ret;
+	libvirt_validate_connections(info);
+	return vm_status(info->vp, info->vp_count, vm_name);
 }
 
 
 static int
-libvirt_reboot(const char *vm_name, const char *src,
-	       uint32_t seqno, void *priv)
+libvirt_reboot(const char *vm_name, const char *src, uint32_t seqno, void *priv)
 {
 	struct libvirt_info *info = (struct libvirt_info *)priv;
-	virDomainPtr vdp, nvdp;
-	virDomainInfo vdi;
-	char *domain_desc;
-	int ret;
 
-	//uuid_unparse(vm_uuid, uu_string);
-	dbg_printf(5, "%s %s\n", __FUNCTION__, vm_name);
+	dbg_printf(5, "ENTER %s %s %u\n", __FUNCTION__, vm_name, seqno);
 	VALIDATE(info);
-	
-	if (is_uuid(vm_name)) {
-		vdp = virDomainLookupByUUIDString(info->vp,
-					    (const char *)vm_name);
-	} else {
-		vdp = virDomainLookupByName(info->vp, vm_name);
-	}
-
-	if (!vdp) {
-		dbg_printf(2, "[libvirt:REBOOT] Nothing to "
-			   "do - domain does not exist\n");
-		return 1;
-	}
-
-	if (((virDomainGetInfo(vdp, &vdi) == 0) &&
-	     (vdi.state == VIR_DOMAIN_SHUTOFF))) {
-			dbg_printf(2, "[libvirt:REBOOT] Nothing to "
-				   "do - domain is off\n");
-		virDomainFree(vdp);
-		return 0;
-	}
-
-
-	syslog(LOG_NOTICE, "Rebooting domain %s\n", vm_name);
-	printf("Rebooting domain %s...\n", vm_name);
-	domain_desc = virDomainGetXMLDesc(vdp, 0);
-
-	if (!domain_desc) {
-		printf("Failed getting domain description from "
-		       "libvirt\n");
-	}
-
-	dbg_printf(2, "[REBOOT] Calling virDomainDestroy(%p)\n", vdp);
-	ret = virDomainDestroy(vdp);
-	if (ret < 0) {
-		printf("virDomainDestroy() failed: %d/%d\n", ret, errno);
-		free(domain_desc);
-		virDomainFree(vdp);
-		return 1;
-	}
-
-	ret = wait_domain(vm_name, info->vp, 15);
-
-	if (ret) {
-		syslog(LOG_NOTICE, "Domain %s still exists; fencing failed\n",
-		       vm_name);
-		printf("Domain %s still exists; fencing failed\n", vm_name);
-		if (domain_desc)
-			free(domain_desc);
-		return 1;
-	}
-		
-	if (!domain_desc)
-		return 0;
 
-	/* 'on' is not a failure */
-	ret = 0;
-
-	dbg_printf(3, "[[ XML Domain Info ]]\n");
-	dbg_printf(3, "%s\n[[ XML END ]]\n", domain_desc);
-	dbg_printf(2, "Calling virDomainCreateLinux()...\n");
-
-	nvdp = virDomainCreateLinux(info->vp, domain_desc, 0);
-	if (nvdp == NULL) {
-		/* More recent versions of libvirt or perhaps the
-		 * KVM back-end do not let you create a domain from
-		 * XML if there is already a defined domain description
-		 * with the same name that it knows about.  You must
-		 * then call virDomainCreate() */
-		dbg_printf(2, "Failed; Trying virDomainCreate()...\n");
-		if (virDomainCreate(vdp) < 0) {
-			syslog(LOG_NOTICE,
-			       "Could not restart %s\n",
-			       vm_name);
-			dbg_printf(1, "Failed to recreate guest"
-				   " %s!\n", vm_name);
-		}
-	}
-
-	free(domain_desc);
-
-	return ret;
+	libvirt_validate_connections(info);
+	return vm_reboot(info->vp, info->vp_count, vm_name);
 }
 
 
@@ -400,22 +250,27 @@
 	virt_list_t *vl;
 	int x;
 
-	dbg_printf(5, "%s\n", __FUNCTION__);
+	dbg_printf(5, "ENTER %s\n", __FUNCTION__);
 	VALIDATE(info);
 
-	vl = vl_get(info->vp, 1);
+	libvirt_validate_connections(info);
+
+	vl = vl_get(info->vp, info->vp_count, 1);
 	if (!vl)
-		return 1;
+		return 0;
 
 	for (x = 0; x < vl->vm_count; x++) {
-		dbg_printf(10, "Sending %s\n", vl->vm_states[x].v_uuid);
 		callback(vl->vm_states[x].v_name,
-			 vl->vm_states[x].v_uuid,
-			 vl->vm_states[x].v_state.s_state, arg);
+				 vl->vm_states[x].v_uuid,
+				 vl->vm_states[x].v_state.s_state, arg);
+
+		dbg_printf(10, "[libvirt:HOSTLIST] Sent %s %s %d\n",
+			vl->vm_states[x].v_name,
+			vl->vm_states[x].v_uuid,
+			vl->vm_states[x].v_state.s_state);
 	}
 
 	vl_free(vl);
-
 	return 0;
 }
 
@@ -423,46 +278,33 @@
 static int
 libvirt_init(backend_context_t *c, config_object_t *config)
 {
-	virConnectPtr vp;
 	char value[256];
 	struct libvirt_info *info = NULL;
-	char *uri = NULL;
 
-	info = malloc(sizeof(*info));
+	dbg_printf(5, "ENTER [%s:%d %s]\n", __FILE__, __LINE__, __FUNCTION__);
+
+	info = calloc(1, sizeof(*info));
 	if (!info)
 		return -1;
+	info->magic = MAGIC;
+	info->config = config;
 
-	dbg_printf(5, "[%s:%d %s]\n", __FILE__, __LINE__, __FUNCTION__);
-	memset(info, 0, sizeof(*info));
+	libvirt_init_libvirt_conf(info);
 
 #ifdef _MODULE
-	if (sc_get(config, "fence_virtd/@debug", value, sizeof(value))==0)
+	if (sc_get(config, "fence_virtd/@debug", value, sizeof(value)) == 0)
 		dset(atoi(value));
 #endif
 
-	if (sc_get(config, "backends/libvirt/@uri",
-		   value, sizeof(value)) == 0) {
-		uri = strdup(value);
-		if (!uri) {
-			free(info);
-			return -1;
-		}
-		dbg_printf(1, "Using %s\n", uri);
-	}
-
-	/* We don't need to store the URI; we only use it once */
-	vp = virConnectOpen(uri);
-	if (!vp) {
-		free(uri);
+	if (info->vp_count < 1) {
+		dbg_printf(1, "[libvirt:INIT] Could not connect to any hypervisors\n");
+		if (info->vp)
+			free(info->vp);
 		free(info);
 		return -1;
 	}
-	free(uri);
-
-	info->magic = MAGIC;
-	info->vp = vp;
 
-	*c = (void *)info;
+	*c = (void *) info;
 	return 0;
 }
 
@@ -471,16 +313,19 @@
 libvirt_shutdown(backend_context_t c)
 {
 	struct libvirt_info *info = (struct libvirt_info *)c;
+	int i;
+	int ret = 0;
 
 	VALIDATE(info);
 
-	if (virConnectClose(info->vp) < 0) {
-		free(info);
-		return -errno;
+	for (i = 0 ; i < info->vp_count ; i++) {
+		if (virConnectClose(info->vp[i]) < 0)
+			ret = -errno;
 	}
 
+	free(info->vp);
 	free(info);
-	return 0;
+	return ret;
 }
 
 
diff -ur a/server/virt.c b/server/virt.c
--- a/server/virt.c	2014-06-23 15:56:09.000000000 -0400
+++ b/server/virt.c	2017-08-09 13:35:07.247875913 -0400
@@ -1,5 +1,5 @@
 /*
-  Copyright Red Hat, Inc. 2006
+  Copyright Red Hat, Inc. 2006-2017
 
   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
@@ -16,7 +16,9 @@
   Free Software Foundation, Inc.,  675 Mass Ave, Cambridge, 
   MA 02139, USA.
 */
+
 #include <stdio.h>
+#include <unistd.h>
 #include <sys/types.h>
 #include <stdlib.h>
 #include <libvirt/libvirt.h>
@@ -24,8 +26,11 @@
 #include <malloc.h>
 #include <stdint.h>
 #include <errno.h>
-#include "virt.h"
+#include <syslog.h>
 
+#include "debug.h"
+#include "uuid-test.h"
+#include "virt.h"
 
 static int
 _compare_virt(const void *_left, const void *_right)
@@ -37,96 +42,98 @@
 }
 
 
-virt_list_t *vl_get(virConnectPtr vp, int my_id)
-{
-	virt_list_t *vl = NULL;
-	int d_count, x, saved_errno;
-	virDomainPtr *dom_list;
-
-	errno = EINVAL;
-	if (!vp)
-		return NULL;
-
-	d_count = virConnectListAllDomains(vp, &dom_list, 0);
-	if (d_count <= 0)
-		goto out_fail;
+static void
+_free_dom_list(virDomainPtr *dom_list, int len) {
+	int x;
 
-	vl = malloc(sizeof(uint32_t) + sizeof(virt_state_t) * d_count);
-	if (!vl)
-		goto out_fail;
+	if (!dom_list || len <= 0)
+		return;
+	for (x = 0 ; x < len; x++)
+		virDomainFree(dom_list[x]);
 
-	vl->vm_count = d_count;
+	free(dom_list);
+}
 
-	/* Ok, we have the domain IDs - let's get their names and states */
-	for (x = 0; x < d_count; x++) {
-		char *d_name;
-		virDomainInfo d_info;
-		char d_uuid[MAX_DOMAINNAME_LENGTH];
-		virDomainPtr dom = dom_list[x];
 
-		if (!(d_name = (char *)virDomainGetName(dom)))
-			goto out_fail;
+virt_list_t *vl_get(virConnectPtr *vp, int vp_count, int my_id)
+{
+	virt_list_t *vl = NULL;
+	int d_count = 0;
+	int i;
 
-		if (virDomainGetUUIDString(dom, d_uuid) != 0)
-			goto out_fail;
+	errno = EINVAL;
+	if (!vp || vp_count < 1)
+		return NULL;
 
-		if (virDomainGetInfo(dom, &d_info) < 0)
-			goto out_fail;
+	for (i = 0 ; i < vp_count ; i++) {
+		int x;
+		virDomainPtr *dom_list;
+		virt_list_t *new_vl;
+
+		int ret = virConnectListAllDomains(vp[i], &dom_list, 0);
+		if (ret == 0)
+			continue;
+
+		if (ret < 0) {
+			int saved_errno = errno;
+			dbg_printf(2, "Error: virConnectListAllDomains: %d %d\n",
+				ret, saved_errno);
+			if (vl)
+				free(vl);
+			errno = saved_errno;
+			return NULL;
+		}
+
+		d_count += ret;
+		new_vl = realloc(vl, sizeof(uint32_t) + sizeof(virt_state_t) * d_count);
+		if (!new_vl) {
+			_free_dom_list(dom_list, ret);
+			free(vl);
+			return NULL;
+		}
+		vl = new_vl;
+		vl->vm_count = d_count;
+
+		/* Ok, we have the domain IDs - let's get their names and states */
+		for (x = 0; x < ret; x++) {
+			char *d_name;
+			virDomainInfo d_info;
+			char d_uuid[MAX_DOMAINNAME_LENGTH];
+			virDomainPtr dom = dom_list[x];
+
+			if (!(d_name = (char *)virDomainGetName(dom))) {
+				_free_dom_list(dom_list, ret);
+				free(vl);
+				return NULL;
+			}
+
+			if (virDomainGetUUIDString(dom, d_uuid) != 0) {
+				_free_dom_list(dom_list, ret);
+				free(vl);
+				return NULL;
+			}
+
+			if (virDomainGetInfo(dom, &d_info) < 0) {
+				_free_dom_list(dom_list, ret);
+				free(vl);
+				return NULL;
+			}
+
+			/* Store the name & state */
+			strncpy(vl->vm_states[x].v_name, d_name, MAX_DOMAINNAME_LENGTH);
+			strncpy(vl->vm_states[x].v_uuid, d_uuid, MAX_DOMAINNAME_LENGTH);
+			vl->vm_states[x].v_state.s_state = d_info.state;
+			vl->vm_states[x].v_state.s_owner = my_id;
+		}
 
-		/* Store the name & state */
-		strncpy(vl->vm_states[x].v_name, d_name, MAX_DOMAINNAME_LENGTH);
-		strncpy(vl->vm_states[x].v_uuid, d_uuid, MAX_DOMAINNAME_LENGTH);
-		vl->vm_states[x].v_state.s_state = d_info.state;
-		vl->vm_states[x].v_state.s_owner = my_id;
+		_free_dom_list(dom_list, ret);
 	}
 
-	for (x = 0 ; x < d_count; x++)
-		virDomainFree(dom_list[x]);
-	free(dom_list);
-
 	/* We have all the locally running domains & states now */
 	/* Sort */
 	qsort(&vl->vm_states[0], vl->vm_count, sizeof(vl->vm_states[0]),
 	      _compare_virt);
 	return vl;	
-
-out_fail:
-	saved_errno = errno;
-	for (x = 0 ; x < d_count; x++)
-		virDomainFree(dom_list[x]);
-	free(dom_list);
-
-	if (vl)
-		free(vl);
-	errno = saved_errno;
-	return NULL;
-}
-
-
-/* Returns 0 if equal, nonzero if not */
-int
-vl_cmp(virt_list_t *left, virt_list_t *right)
-{
-	int x;
-
-	/* Quick checks */
-	if (!left->vm_count && !right->vm_count)
-		return 1;
-	if (left->vm_count != right->vm_count)
-		return 0;
-
-	for (x = 0; x < left->vm_count; x++) {
-		if (strcmp(left->vm_states[x].v_name,
-			   right->vm_states[x].v_name))
-			return 1;
-		/*
-		if (left->vm_states[x].v_state.s_state !=
-		    right->vm_states[x].v_state.s_state)
-			return 1;
-		 */
-	}
-
-	return 0;
 }
 
 
@@ -192,3 +199,333 @@
 {
 	free(old);
 }
+
+
+static inline int
+wait_domain(const char *vm_name, virConnectPtr vp, int timeout)
+{
+	int tries = 0;
+	int response = 1;
+	int ret;
+	virDomainPtr vdp;
+	virDomainInfo vdi;
+	int uuid_check;
+
+	uuid_check = is_uuid(vm_name);
+
+	if (uuid_check) {
+		vdp = virDomainLookupByUUIDString(vp, (const char *)vm_name);
+	} else {
+		vdp = virDomainLookupByName(vp, vm_name);
+	}
+	if (!vdp)
+		return 0;
+
+	/* Check domain liveliness.  If the domain is still here,
+	   we return failure, and the client must then retry */
+	/* XXX On the xen 3.0.4 API, we will be able to guarantee
+	   synchronous virDomainDestroy, so this check will not
+	   be necessary */
+	do {
+		if (++tries > timeout)
+			break;
+
+		sleep(1);
+		if (uuid_check) {
+			vdp = virDomainLookupByUUIDString(vp, (const char *)vm_name);
+		} else {
+			vdp = virDomainLookupByName(vp, vm_name);
+		}
+		if (!vdp) {
+			dbg_printf(2, "Domain no longer exists\n");
+			response = 0;
+			break;
+		}
+
+		memset(&vdi, 0, sizeof(vdi));
+		ret = virDomainGetInfo(vdp, &vdi);
+		virDomainFree(vdp);
+		if (ret < 0)
+			continue;
+
+		if (vdi.state == VIR_DOMAIN_SHUTOFF) {
+			dbg_printf(2, "Domain has been shut off\n");
+			response = 0;
+			break;
+		}
+
+		dbg_printf(4, "Domain still exists (state %d) after %d seconds\n",
+			vdi.state, tries);
+	} while (1);
+
+	return response;
+}
+
+
+int
+vm_off(virConnectPtr *vp, int vp_count, const char *vm_name)
+{
+	virDomainPtr vdp = NULL;
+	virDomainInfo vdi;
+	virDomainPtr (*virt_lookup_fn)(virConnectPtr, const char *);
+	int ret = -1;
+	int i;
+
+	if (is_uuid(vm_name))
+		virt_lookup_fn = virDomainLookupByUUIDString;
+	else
+		virt_lookup_fn = virDomainLookupByName;
+
+	for (i = 0 ; i < vp_count ; i++) {
+		vdp = virt_lookup_fn(vp[i], vm_name);
+		if (vdp)
+			break;
+	}
+
+	if (!vdp) {
+		dbg_printf(2, "[virt:OFF] Domain %s does not exist\n", vm_name);
+		return 1;
+	}
+
+	if (virDomainGetInfo(vdp, &vdi) == 0 && vdi.state == VIR_DOMAIN_SHUTOFF)
+	{
+		dbg_printf(2, "[virt:OFF] Nothing to do - "
+			"domain %s is already off\n",
+			vm_name);
+		virDomainFree(vdp);
+		return 0;
+	}
+
+	syslog(LOG_NOTICE, "Destroying domain %s\n", vm_name);
+	dbg_printf(2, "[virt:OFF] Calling virDomainDestroy for %s\n", vm_name);
+
+	ret = virDomainDestroy(vdp);
+	virDomainFree(vdp);
+
+	if (ret < 0) {
+		syslog(LOG_NOTICE,
+			"Failed to destroy domain %s: %d\n", vm_name, ret);
+		dbg_printf(2, "[virt:OFF] Failed to destroy domain: %s %d\n",
+			vm_name, ret);
+		return 1;
+	}
+
+	if (ret) {
+		syslog(LOG_NOTICE, "Domain %s still exists; fencing failed\n",
+			vm_name);
+		dbg_printf(2,
+			"[virt:OFF] Domain %s still exists; fencing failed\n",
+			vm_name);
+		return 1;
+	}
+
+	dbg_printf(2, "[virt:OFF] Success for %s\n", vm_name);
+	return 0;
+}
+
+
+int
+vm_on(virConnectPtr *vp, int vp_count, const char *vm_name)
+{
+	virDomainPtr vdp = NULL;
+	virDomainInfo vdi;
+	virDomainPtr (*virt_lookup_fn)(virConnectPtr, const char *);
+	int ret = -1;
+	int i;
+
+	if (is_uuid(vm_name))
+		virt_lookup_fn = virDomainLookupByUUIDString;
+	else
+		virt_lookup_fn = virDomainLookupByName;
+
+	for (i = 0 ; i < vp_count ; i++) {
+		vdp = virt_lookup_fn(vp[i], vm_name);
+		if (vdp)
+			break;
+	}
+
+	if (!vdp) {
+		dbg_printf(2, "[virt:ON] Domain %s does not exist\n", vm_name);
+		return 1;
+	}
+
+	if (virDomainGetInfo(vdp, &vdi) == 0 && vdi.state != VIR_DOMAIN_SHUTOFF) {
+		dbg_printf(2, "Nothing to do - domain %s is already running\n",
+			vm_name);
+		virDomainFree(vdp);
+		return 0;
+	}
+
+	syslog(LOG_NOTICE, "Starting domain %s\n", vm_name);
+	dbg_printf(2, "[virt:ON] Calling virDomainCreate for %s\n", vm_name);
+
+	ret = virDomainCreate(vdp);
+	virDomainFree(vdp);
+
+	if (ret < 0) {
+		syslog(LOG_NOTICE, "Failed to start domain %s: %d\n", vm_name, ret);
+		dbg_printf(2, "[virt:ON] virDomainCreate() failed for %s: %d\n",
+			vm_name, ret);
+		return 1;
+	}
+
+	if (ret) {
+		syslog(LOG_NOTICE, "Domain %s did not start\n", vm_name);
+		dbg_printf(2, "[virt:ON] Domain %s did not start\n", vm_name);
+		return 1;
+	}
+
+	syslog(LOG_NOTICE, "Domain %s started\n", vm_name);
+	dbg_printf(2, "[virt:ON] Success for %s\n", vm_name);
+	return 0;
+}
+
+
+int
+vm_status(virConnectPtr *vp, int vp_count, const char *vm_name)
+{
+	virDomainPtr vdp = NULL;
+	virDomainInfo vdi;
+	int ret = 0;
+	int i;
+	virDomainPtr (*virt_lookup_fn)(virConnectPtr, const char *);
+
+	if (is_uuid(vm_name))
+		virt_lookup_fn = virDomainLookupByUUIDString;
+	else
+		virt_lookup_fn = virDomainLookupByName;
+
+	for (i = 0 ; i < vp_count ; i++) {
+		vdp = virt_lookup_fn(vp[i], vm_name);
+		if (vdp)
+			break;
+	}
+
+	if (!vdp) {
+		dbg_printf(2, "[virt:STATUS] Unknown VM %s - return OFF\n", vm_name);
+		return RESP_OFF;
+	}
+
+	if (virDomainGetInfo(vdp, &vdi) == 0 && vdi.state == VIR_DOMAIN_SHUTOFF) {
+		dbg_printf(2, "[virt:STATUS] VM %s is OFF\n", vm_name);
+		ret = RESP_OFF;
+	}
+
+	if (vdp)
+		virDomainFree(vdp);
+	return ret;
+}
+
+
+int
+vm_reboot(virConnectPtr *vp, int vp_count, const char *vm_name)
+{
+	virDomainPtr vdp = NULL, nvdp;
+	virDomainInfo vdi;
+	char *domain_desc;
+	virConnectPtr vcp = NULL;
+	virDomainPtr (*virt_lookup_fn)(virConnectPtr, const char *);
+	int ret;
+	int i;
+
+	if (is_uuid(vm_name))
+		virt_lookup_fn = virDomainLookupByUUIDString;
+	else
+		virt_lookup_fn = virDomainLookupByName;
+
+	for (i = 0 ; i < vp_count ; i++) {
+		vdp = virt_lookup_fn(vp[i], vm_name);
+		if (vdp) {
+			vcp = vp[i];
+			break;
+		}
+	}
+
+	if (!vdp || !vcp) {
+		dbg_printf(2,
+			"[virt:REBOOT] Nothing to do - domain %s does not exist\n",
+			vm_name);
+		return 1;
+	}
+
+	if (virDomainGetInfo(vdp, &vdi) == 0 && vdi.state == VIR_DOMAIN_SHUTOFF) {
+		dbg_printf(2, "[virt:REBOOT] Nothing to do - domain %s is off\n",
+			vm_name);
+		virDomainFree(vdp);
+		return 0;
+	}
+
+	syslog(LOG_NOTICE, "Rebooting domain %s\n", vm_name);
+	dbg_printf(5, "[virt:REBOOT] Rebooting domain %s...\n", vm_name);
+
+	domain_desc = virDomainGetXMLDesc(vdp, 0);
+
+	if (!domain_desc) {
+		dbg_printf(5, "[virt:REBOOT] Failed getting domain description "
+			"from libvirt for %s...\n", vm_name);
+	}
+
+	dbg_printf(2, "[virt:REBOOT] Calling virDomainDestroy(%p) for %s\n",
+		vdp, vm_name);
+
+	ret = virDomainDestroy(vdp);
+	if (ret < 0) {
+		dbg_printf(2,
+			"[virt:REBOOT] virDomainDestroy() failed for %s: %d/%d\n",
+			vm_name, ret, errno);
+
+		if (domain_desc)
+			free(domain_desc);
+		virDomainFree(vdp);
+		return 1;
+	}
+
+	ret = wait_domain(vm_name, vcp, 15);
+
+	if (ret) {
+		syslog(LOG_NOTICE, "Domain %s still exists; fencing failed\n", vm_name);
+		dbg_printf(2,
+			"[virt:REBOOT] Domain %s still exists; fencing failed\n",
+			vm_name);
+
+		if (domain_desc)
+			free(domain_desc);
+		virDomainFree(vdp);
+		return 1;
+	}
+
+	if (!domain_desc)
+		return 0;
+
+	/* 'on' is not a failure */
+	ret = 0;
+
+	dbg_printf(3, "[[ XML Domain Info ]]\n");
+	dbg_printf(3, "%s\n[[ XML END ]]\n", domain_desc);
+
+	dbg_printf(2, "[virt:REBOOT] Calling virDomainCreateLinux() for %s\n",
+		vm_name);
+
+	nvdp = virDomainCreateLinux(vcp, domain_desc, 0);
+	if (nvdp == NULL) {
+		/* More recent versions of libvirt or perhaps the
+		 * KVM back-end do not let you create a domain from
+		 * XML if there is already a defined domain description
+		 * with the same name that it knows about.  You must
+		 * then call virDomainCreate() */
+		dbg_printf(2,
+			"[virt:REBOOT] virDomainCreateLinux() failed for %s; "
+			"Trying virDomainCreate()\n",
+			vm_name);
+
+		if (virDomainCreate(vdp) < 0) {
+			syslog(LOG_NOTICE, "Could not restart %s\n", vm_name);
+			dbg_printf(1, "[virt:REBOOT] Failed to recreate guest %s!\n",
+				vm_name);
+		}
+	}
+
+	free(domain_desc);
+	virDomainFree(vdp);
+	return ret;
+}
diff -ur a/server/virt.h b/server/virt.h
--- a/server/virt.h	2014-06-23 15:56:09.000000000 -0400
+++ b/server/virt.h	2017-08-09 13:30:40.709689288 -0400
@@ -1,5 +1,5 @@
 /*
-  Copyright Red Hat, Inc. 2006
+  Copyright Red Hat, Inc. 2006-2017
 
   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
@@ -16,11 +16,13 @@
   Free Software Foundation, Inc.,  675 Mass Ave, Cambridge, 
   MA 02139, USA.
 */
+
 #ifndef _VIRT_H
 #define _VIRT_H
-#include <libvirt/libvirt.h>
+
 #include <stdint.h>
 #include <netinet/in.h>
+#include <libvirt/libvirt.h>
 
 #include "xvm.h"
 
@@ -59,15 +61,16 @@
 	virt_state_t	vm_states[0];
 } virt_list_t;
 
-virt_list_t *vl_get(virConnectPtr vp, int my_id);
-
-int vl_cmp(virt_list_t *left, virt_list_t *right);
-
+virt_list_t *vl_get(virConnectPtr *vp, int vp_count, int my_id);
 void vl_print(virt_list_t *vl);
 void vl_free(virt_list_t *old);
-virt_state_t * vl_find_uuid(virt_list_t *vl, const char *name);
-virt_state_t * vl_find_name(virt_list_t *vl, const char *name);
+virt_state_t *vl_find_uuid(virt_list_t *vl, const char *name);
+virt_state_t *vl_find_name(virt_list_t *vl, const char *name);
 
+int vm_off(virConnectPtr *vp, int vp_count, const char *vm_name);
+int vm_on(virConnectPtr *vp, int vp_count, const char *vm_name);
+int vm_status(virConnectPtr *vp, int vp_count, const char *vm_name);
+int vm_reboot(virConnectPtr *vp, int vp_count, const char *vm_name);
 
 typedef void ckpt_handle;
 int ckpt_read(void *hp, const char *secid, void *buf, size_t maxlen);