[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[libvirt] [PATCH 3/3] Implmentation of new APIs to checking state/persistence of objects



This implements the virConnectIsSecure, virConnectIsEncrypted,
virDomainIsPersistent, virDomainIsActive, virNetworkIsActive,
virNetworkIsPersistent, virStoragePoolIsActive,
virStoragePoolIsPersistent, virInterfaceIsActive APIs in
(nearly) all drivers. Exceptions are:

 phyp: missing domainIsActive/Persistent
 esx: missing domainIsPersistent
 opennebula: missing domainIsActive/Persistent

* src/remote/remote_protocol.x: Define remote wire ABI for newly
  added APIs.
* daemon/remote_dispatch*.h: Re-generated from remote_protocol.x
* src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/network/bridge_driver.c,
  src/opennebula/one_driver.c, src/openvz/openvz_conf.c,
  src/openvz/openvz_driver.c, src/phyp/phyp_driver.c,
  src/remote/remote_driver.c, src/storage/storage_driver.c,
  src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c,
  src/xen/xen_driver.c, src/xen/xen_driver.h, src/xen/xen_inotify.c,
  src/xen/xen_inotify.h: Implement all the new APIs where possible
---
 daemon/remote.c                     |  202 ++++++++++++++++++++++++++
 daemon/remote_dispatch_args.h       |    7 +
 daemon/remote_dispatch_prototypes.h |   64 +++++++++
 daemon/remote_dispatch_ret.h        |    8 +
 daemon/remote_dispatch_table.h      |   40 ++++++
 src/esx/esx_driver.c                |  106 +++++++++++++-
 src/lxc/lxc_driver.c                |   68 +++++++++-
 src/network/bridge_driver.c         |   50 ++++++-
 src/opennebula/one_driver.c         |   21 +++-
 src/openvz/openvz_conf.c            |    2 +
 src/openvz/openvz_driver.c          |   66 ++++++++-
 src/phyp/phyp_driver.c              |   25 +++-
 src/qemu/qemu_driver.c              |   65 ++++++++-
 src/remote/remote_driver.c          |  266 +++++++++++++++++++++++++++++++++--
 src/remote/remote_protocol.c        |  137 ++++++++++++++++++-
 src/remote/remote_protocol.h        |  112 +++++++++++++++
 src/remote/remote_protocol.x        |   87 +++++++++++-
 src/storage/storage_driver.c        |   46 ++++++
 src/test/test_driver.c              |  184 +++++++++++++++++++++++--
 src/uml/uml_driver.c                |   67 ++++++++-
 src/vbox/vbox_tmpl.c                |  108 ++++++++++++++-
 src/xen/xen_driver.c                |   98 ++++++++++++-
 src/xen/xen_driver.h                |    2 +
 src/xen/xen_inotify.c               |    8 +-
 src/xen/xen_inotify.h               |    1 +
 25 files changed, 1772 insertions(+), 68 deletions(-)

diff --git a/daemon/remote.c b/daemon/remote.c
index 4296fc3..1f239cd 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -5005,6 +5005,208 @@ remoteDispatchSecretLookupByUsage (struct qemud_server *server ATTRIBUTE_UNUSED,
 }
 
 
+static int remoteDispatchDomainIsActive(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                        struct qemud_client *client ATTRIBUTE_UNUSED,
+                                        virConnectPtr conn,
+                                        remote_message_header *hdr ATTRIBUTE_UNUSED,
+                                        remote_error *err,
+                                        remote_domain_is_active_args *args,
+                                        remote_domain_is_active_ret *ret)
+{
+    virDomainPtr domain;
+
+    domain = get_nonnull_domain(conn, args->dom);
+    if (domain == NULL) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    ret->active = virDomainIsActive(domain);
+
+    if (ret->active < 0) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    return 0;
+}
+
+static int remoteDispatchDomainIsPersistent(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                            struct qemud_client *client ATTRIBUTE_UNUSED,
+                                            virConnectPtr conn,
+                                            remote_message_header *hdr ATTRIBUTE_UNUSED,
+                                            remote_error *err,
+                                            remote_domain_is_persistent_args *args,
+                                            remote_domain_is_persistent_ret *ret)
+{
+    virDomainPtr domain;
+
+    domain = get_nonnull_domain(conn, args->dom);
+    if (domain == NULL) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    ret->persistent = virDomainIsPersistent(domain);
+
+    if (ret->persistent < 0) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    return 0;
+}
+
+static int remoteDispatchInterfaceIsActive(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                           struct qemud_client *client ATTRIBUTE_UNUSED,
+                                           virConnectPtr conn,
+                                           remote_message_header *hdr ATTRIBUTE_UNUSED,
+                                           remote_error *err,
+                                           remote_interface_is_active_args *args,
+                                           remote_interface_is_active_ret *ret)
+{
+    virInterfacePtr iface;
+
+    iface = get_nonnull_interface(conn, args->iface);
+    if (iface == NULL) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    ret->active = virInterfaceIsActive(iface);
+
+    if (ret->active < 0) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    return 0;
+}
+
+static int remoteDispatchNetworkIsActive(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                         struct qemud_client *client ATTRIBUTE_UNUSED,
+                                         virConnectPtr conn,
+                                         remote_message_header *hdr ATTRIBUTE_UNUSED,
+                                         remote_error *err,
+                                         remote_network_is_active_args *args,
+                                         remote_network_is_active_ret *ret)
+{
+    virNetworkPtr network;
+
+    network = get_nonnull_network(conn, args->net);
+    if (network == NULL) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    ret->active = virNetworkIsActive(network);
+
+    if (ret->active < 0) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    return 0;
+}
+
+static int remoteDispatchNetworkIsPersistent(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                             struct qemud_client *client ATTRIBUTE_UNUSED,
+                                             virConnectPtr conn,
+                                             remote_message_header *hdr ATTRIBUTE_UNUSED,
+                                             remote_error *err,
+                                             remote_network_is_persistent_args *args,
+                                             remote_network_is_persistent_ret *ret)
+{
+    virNetworkPtr network;
+
+    network = get_nonnull_network(conn, args->net);
+    if (network == NULL) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    ret->persistent = virNetworkIsPersistent(network);
+
+    if (ret->persistent < 0) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    return 0;
+}
+
+static int remoteDispatchStoragePoolIsActive(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                             struct qemud_client *client ATTRIBUTE_UNUSED,
+                                             virConnectPtr conn,
+                                             remote_message_header *hdr ATTRIBUTE_UNUSED,
+                                             remote_error *err,
+                                             remote_storage_pool_is_active_args *args,
+                                             remote_storage_pool_is_active_ret *ret)
+{
+    virStoragePoolPtr pool;
+
+    pool = get_nonnull_storage_pool(conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    ret->active = virStoragePoolIsActive(pool);
+
+    if (ret->active < 0) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    return 0;
+}
+
+static int remoteDispatchStoragePoolIsPersistent(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                                 struct qemud_client *client ATTRIBUTE_UNUSED,
+                                                 virConnectPtr conn,
+                                                 remote_message_header *hdr ATTRIBUTE_UNUSED,
+                                                 remote_error *err,
+                                                 remote_storage_pool_is_persistent_args *args,
+                                                 remote_storage_pool_is_persistent_ret *ret)
+{
+    virStoragePoolPtr pool;
+
+    pool = get_nonnull_storage_pool(conn, args->pool);
+    if (pool == NULL) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    ret->persistent = virStoragePoolIsPersistent(pool);
+
+    if (ret->persistent < 0) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    return 0;
+}
+
+
+static int remoteDispatchIsSecure(struct qemud_server *server ATTRIBUTE_UNUSED,
+                                  struct qemud_client *client ATTRIBUTE_UNUSED,
+                                  virConnectPtr conn,
+                                  remote_message_header *hdr ATTRIBUTE_UNUSED,
+                                  remote_error *err,
+                                  void *args ATTRIBUTE_UNUSED,
+                                  remote_is_secure_ret *ret)
+{
+    ret->secure = virConnectIsSecure(conn);
+
+    if (ret->secure < 0) {
+        remoteDispatchConnError(err, conn);
+        return -1;
+    }
+
+    return 0;
+}
+
+
 /*----- Helpers. -----*/
 
 /* get_nonnull_domain and get_nonnull_network turn an on-wire
diff --git a/daemon/remote_dispatch_args.h b/daemon/remote_dispatch_args.h
index aceead1..87dcdae 100644
--- a/daemon/remote_dispatch_args.h
+++ b/daemon/remote_dispatch_args.h
@@ -126,3 +126,10 @@
     remote_secret_undefine_args val_remote_secret_undefine_args;
     remote_secret_lookup_by_usage_args val_remote_secret_lookup_by_usage_args;
     remote_domain_migrate_prepare_tunnel_args val_remote_domain_migrate_prepare_tunnel_args;
+    remote_domain_is_active_args val_remote_domain_is_active_args;
+    remote_domain_is_persistent_args val_remote_domain_is_persistent_args;
+    remote_network_is_active_args val_remote_network_is_active_args;
+    remote_network_is_persistent_args val_remote_network_is_persistent_args;
+    remote_storage_pool_is_active_args val_remote_storage_pool_is_active_args;
+    remote_storage_pool_is_persistent_args val_remote_storage_pool_is_persistent_args;
+    remote_interface_is_active_args val_remote_interface_is_active_args;
diff --git a/daemon/remote_dispatch_prototypes.h b/daemon/remote_dispatch_prototypes.h
index 9afd2c7..7c2da07 100644
--- a/daemon/remote_dispatch_prototypes.h
+++ b/daemon/remote_dispatch_prototypes.h
@@ -226,6 +226,22 @@ static int remoteDispatchDomainInterfaceStats(
     remote_error *err,
     remote_domain_interface_stats_args *args,
     remote_domain_interface_stats_ret *ret);
+static int remoteDispatchDomainIsActive(
+    struct qemud_server *server,
+    struct qemud_client *client,
+    virConnectPtr conn,
+    remote_message_header *hdr,
+    remote_error *err,
+    remote_domain_is_active_args *args,
+    remote_domain_is_active_ret *ret);
+static int remoteDispatchDomainIsPersistent(
+    struct qemud_server *server,
+    struct qemud_client *client,
+    virConnectPtr conn,
+    remote_message_header *hdr,
+    remote_error *err,
+    remote_domain_is_persistent_args *args,
+    remote_domain_is_persistent_ret *ret);
 static int remoteDispatchDomainLookupById(
     struct qemud_server *server,
     struct qemud_client *client,
@@ -514,6 +530,14 @@ static int remoteDispatchInterfaceGetXmlDesc(
     remote_error *err,
     remote_interface_get_xml_desc_args *args,
     remote_interface_get_xml_desc_ret *ret);
+static int remoteDispatchInterfaceIsActive(
+    struct qemud_server *server,
+    struct qemud_client *client,
+    virConnectPtr conn,
+    remote_message_header *hdr,
+    remote_error *err,
+    remote_interface_is_active_args *args,
+    remote_interface_is_active_ret *ret);
 static int remoteDispatchInterfaceLookupByMacString(
     struct qemud_server *server,
     struct qemud_client *client,
@@ -538,6 +562,14 @@ static int remoteDispatchInterfaceUndefine(
     remote_error *err,
     remote_interface_undefine_args *args,
     void *ret);
+static int remoteDispatchIsSecure(
+    struct qemud_server *server,
+    struct qemud_client *client,
+    virConnectPtr conn,
+    remote_message_header *hdr,
+    remote_error *err,
+    void *args,
+    remote_is_secure_ret *ret);
 static int remoteDispatchListDefinedDomains(
     struct qemud_server *server,
     struct qemud_client *client,
@@ -666,6 +698,22 @@ static int remoteDispatchNetworkGetBridgeName(
     remote_error *err,
     remote_network_get_bridge_name_args *args,
     remote_network_get_bridge_name_ret *ret);
+static int remoteDispatchNetworkIsActive(
+    struct qemud_server *server,
+    struct qemud_client *client,
+    virConnectPtr conn,
+    remote_message_header *hdr,
+    remote_error *err,
+    remote_network_is_active_args *args,
+    remote_network_is_active_ret *ret);
+static int remoteDispatchNetworkIsPersistent(
+    struct qemud_server *server,
+    struct qemud_client *client,
+    virConnectPtr conn,
+    remote_message_header *hdr,
+    remote_error *err,
+    remote_network_is_persistent_args *args,
+    remote_network_is_persistent_ret *ret);
 static int remoteDispatchNetworkLookupByName(
     struct qemud_server *server,
     struct qemud_client *client,
@@ -1034,6 +1082,22 @@ static int remoteDispatchStoragePoolGetInfo(
     remote_error *err,
     remote_storage_pool_get_info_args *args,
     remote_storage_pool_get_info_ret *ret);
+static int remoteDispatchStoragePoolIsActive(
+    struct qemud_server *server,
+    struct qemud_client *client,
+    virConnectPtr conn,
+    remote_message_header *hdr,
+    remote_error *err,
+    remote_storage_pool_is_active_args *args,
+    remote_storage_pool_is_active_ret *ret);
+static int remoteDispatchStoragePoolIsPersistent(
+    struct qemud_server *server,
+    struct qemud_client *client,
+    virConnectPtr conn,
+    remote_message_header *hdr,
+    remote_error *err,
+    remote_storage_pool_is_persistent_args *args,
+    remote_storage_pool_is_persistent_ret *ret);
 static int remoteDispatchStoragePoolListVolumes(
     struct qemud_server *server,
     struct qemud_client *client,
diff --git a/daemon/remote_dispatch_ret.h b/daemon/remote_dispatch_ret.h
index 6ced13a..c37744a 100644
--- a/daemon/remote_dispatch_ret.h
+++ b/daemon/remote_dispatch_ret.h
@@ -106,3 +106,11 @@
     remote_secret_get_xml_desc_ret val_remote_secret_get_xml_desc_ret;
     remote_secret_get_value_ret val_remote_secret_get_value_ret;
     remote_secret_lookup_by_usage_ret val_remote_secret_lookup_by_usage_ret;
+    remote_is_secure_ret val_remote_is_secure_ret;
+    remote_domain_is_active_ret val_remote_domain_is_active_ret;
+    remote_domain_is_persistent_ret val_remote_domain_is_persistent_ret;
+    remote_network_is_active_ret val_remote_network_is_active_ret;
+    remote_network_is_persistent_ret val_remote_network_is_persistent_ret;
+    remote_storage_pool_is_active_ret val_remote_storage_pool_is_active_ret;
+    remote_storage_pool_is_persistent_ret val_remote_storage_pool_is_persistent_ret;
+    remote_interface_is_active_ret val_remote_interface_is_active_ret;
diff --git a/daemon/remote_dispatch_table.h b/daemon/remote_dispatch_table.h
index bb13f4c..cb640b6 100644
--- a/daemon/remote_dispatch_table.h
+++ b/daemon/remote_dispatch_table.h
@@ -747,3 +747,43 @@
     .args_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel_args,
     .ret_filter = (xdrproc_t) xdr_void,
 },
+{   /* IsSecure => 149 */
+    .fn = (dispatch_fn) remoteDispatchIsSecure,
+    .args_filter = (xdrproc_t) xdr_void,
+    .ret_filter = (xdrproc_t) xdr_remote_is_secure_ret,
+},
+{   /* DomainIsActive => 150 */
+    .fn = (dispatch_fn) remoteDispatchDomainIsActive,
+    .args_filter = (xdrproc_t) xdr_remote_domain_is_active_args,
+    .ret_filter = (xdrproc_t) xdr_remote_domain_is_active_ret,
+},
+{   /* DomainIsPersistent => 151 */
+    .fn = (dispatch_fn) remoteDispatchDomainIsPersistent,
+    .args_filter = (xdrproc_t) xdr_remote_domain_is_persistent_args,
+    .ret_filter = (xdrproc_t) xdr_remote_domain_is_persistent_ret,
+},
+{   /* NetworkIsActive => 152 */
+    .fn = (dispatch_fn) remoteDispatchNetworkIsActive,
+    .args_filter = (xdrproc_t) xdr_remote_network_is_active_args,
+    .ret_filter = (xdrproc_t) xdr_remote_network_is_active_ret,
+},
+{   /* NetworkIsPersistent => 153 */
+    .fn = (dispatch_fn) remoteDispatchNetworkIsPersistent,
+    .args_filter = (xdrproc_t) xdr_remote_network_is_persistent_args,
+    .ret_filter = (xdrproc_t) xdr_remote_network_is_persistent_ret,
+},
+{   /* StoragePoolIsActive => 154 */
+    .fn = (dispatch_fn) remoteDispatchStoragePoolIsActive,
+    .args_filter = (xdrproc_t) xdr_remote_storage_pool_is_active_args,
+    .ret_filter = (xdrproc_t) xdr_remote_storage_pool_is_active_ret,
+},
+{   /* StoragePoolIsPersistent => 155 */
+    .fn = (dispatch_fn) remoteDispatchStoragePoolIsPersistent,
+    .args_filter = (xdrproc_t) xdr_remote_storage_pool_is_persistent_args,
+    .ret_filter = (xdrproc_t) xdr_remote_storage_pool_is_persistent_ret,
+},
+{   /* InterfaceIsActive => 156 */
+    .fn = (dispatch_fn) remoteDispatchInterfaceIsActive,
+    .args_filter = (xdrproc_t) xdr_remote_interface_is_active_args,
+    .ret_filter = (xdrproc_t) xdr_remote_interface_is_active_ret,
+},
diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c
index 3a57613..c3d1eac 100644
--- a/src/esx/esx_driver.c
+++ b/src/esx/esx_driver.c
@@ -503,6 +503,30 @@ esxClose(virConnectPtr conn)
 }
 
 
+static int
+esxIsSecure(virConnectPtr conn)
+{
+    esxPrivate *priv = (esxPrivate *)conn->privateData;
+
+    if (STRCASEEQ(priv->transport, "https")) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+
+static int
+esxIsEncrypted(virConnectPtr conn)
+{
+    esxPrivate *priv = (esxPrivate *)conn->privateData;
+
+    if (STRCASEEQ(priv->transport, "https")) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
 
 static esxVI_Boolean
 esxSupportsVMotion(virConnectPtr conn)
@@ -1227,6 +1251,80 @@ esxDomainLookupByName(virConnectPtr conn, const char *name)
 }
 
 
+static int
+esxDomainIsActive(virDomainPtr dom)
+{
+    esxPrivate *priv = (esxPrivate *)dom->conn->privateData;
+    esxVI_String *propertyNameList = NULL;
+    esxVI_ObjectContent *virtualMachineList = NULL;
+    esxVI_ObjectContent *virtualMachine = NULL;
+    esxVI_VirtualMachinePowerState powerState;
+    int id_candidate = -1;
+    char *name_candidate = NULL;
+    unsigned char uuid_candidate[VIR_UUID_BUFLEN];
+    char uuid_string[VIR_UUID_STRING_BUFLEN];
+    int ret = -1;
+
+    if (esxVI_EnsureSession(dom->conn, priv->host) < 0) {
+        goto cleanup;
+    }
+
+    if (esxVI_String_AppendValueListToList(dom->conn, &propertyNameList,
+                                           "configStatus\0"
+                                           "name\0"
+                                           "runtime.powerState\0"
+                                           "config.uuid\0") < 0 ||
+        esxVI_GetObjectContent(dom->conn, priv->host, priv->host->vmFolder,
+                               "VirtualMachine", propertyNameList,
+                               esxVI_Boolean_True, &virtualMachineList) < 0) {
+        goto cleanup;
+    }
+
+    for (virtualMachine = virtualMachineList; virtualMachine != NULL;
+         virtualMachine = virtualMachine->_next) {
+        VIR_FREE(name_candidate);
+
+        if (esxVI_GetVirtualMachineIdentity(dom->conn, virtualMachine,
+                                            &id_candidate, &name_candidate,
+                                            uuid_candidate) < 0) {
+            goto cleanup;
+        }
+
+        if (memcmp(dom->uuid, uuid_candidate,
+                   VIR_UUID_BUFLEN * sizeof(unsigned char)) != 0) {
+            continue;
+        }
+
+        if (esxVI_GetVirtualMachinePowerState(dom->conn, virtualMachine,
+                                              &powerState) < 0) {
+            goto cleanup;
+        }
+
+        /* Only running/suspended virtual machines have an ID != -1 */
+        if (powerState != esxVI_VirtualMachinePowerState_PoweredOff) {
+            ret = 1;
+        } else {
+            ret = 0;
+        }
+
+        break;
+    }
+
+    if (ret == -1) {
+        virUUIDFormat(dom->uuid, uuid_string);
+
+        ESX_ERROR(dom->conn, VIR_ERR_NO_DOMAIN, "No domain with UUID '%s'",
+                  uuid_string);
+    }
+
+  cleanup:
+    esxVI_String_Free(&propertyNameList);
+    esxVI_ObjectContent_Free(&virtualMachineList);
+    VIR_FREE(name_candidate);
+
+    return ret;
+}
+
 
 static int
 esxDomainSuspend(virDomainPtr domain)
@@ -3275,10 +3373,10 @@ static virDriver esxDriver = {
     NULL,                            /* nodeDeviceReAttach */
     NULL,                            /* nodeDeviceReset */
     NULL,                            /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
-    NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    esxIsEncrypted,                  /* isEncrypted */
+    esxIsSecure,                     /* isSecure */
+    esxDomainIsActive,               /* domainIsActive */
+    NULL,                            /* domainIsPersistent */
 };
 
 
diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c
index 92502fe..313342e 100644
--- a/src/lxc/lxc_driver.c
+++ b/src/lxc/lxc_driver.c
@@ -128,6 +128,21 @@ static int lxcClose(virConnectPtr conn)
     return 0;
 }
 
+
+static int lxcIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* Trivially secure, since always inside the daemon */
+    return 1;
+}
+
+
+static int lxcIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* Not encrypted, but remote driver takes care of that */
+    return 0;
+}
+
+
 static char *lxcGetCapabilities(virConnectPtr conn) {
     lxc_driver_t *driver = conn->privateData;
     char *xml;
@@ -218,6 +233,51 @@ cleanup:
     return dom;
 }
 
+
+static int lxcDomainIsActive(virDomainPtr dom)
+{
+    lxc_driver_t *driver = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    lxcDriverLock(driver);
+    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+    lxcDriverUnlock(driver);
+    if (!obj) {
+        lxcError(dom->conn, NULL, VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = virDomainObjIsActive(obj);
+
+cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+
+static int lxcDomainIsPersistent(virDomainPtr dom)
+{
+    lxc_driver_t *driver = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    lxcDriverLock(driver);
+    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+    lxcDriverUnlock(driver);
+    if (!obj) {
+        lxcError(dom->conn, NULL, VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = obj->persistent;
+
+cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+
 static int lxcListDomains(virConnectPtr conn, int *ids, int nids) {
     lxc_driver_t *driver = conn->privateData;
     int got = 0, i;
@@ -2348,10 +2408,10 @@ static virDriver lxcDriver = {
     NULL, /* nodeDeviceReAttach */
     NULL, /* nodeDeviceReset */
     NULL, /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
-    NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    lxcIsEncrypted,
+    lxcIsSecure,
+    lxcDomainIsActive,
+    lxcDomainIsPersistent,
 };
 
 static virStateDriver lxcStateDriver = {
diff --git a/src/network/bridge_driver.c b/src/network/bridge_driver.c
index 311838c..60c1acc 100644
--- a/src/network/bridge_driver.c
+++ b/src/network/bridge_driver.c
@@ -1159,6 +1159,50 @@ static int networkListDefinedNetworks(virConnectPtr conn, char **const names, in
     return -1;
 }
 
+
+static int networkIsActive(virNetworkPtr net)
+{
+    struct network_driver *driver = net->conn->privateData;
+    virNetworkObjPtr obj;
+    int ret = -1;
+
+    networkDriverLock(driver);
+    obj = virNetworkFindByUUID(&driver->networks, net->uuid);
+    networkDriverUnlock(driver);
+    if (!obj) {
+        networkReportError(net->conn, NULL, NULL, VIR_ERR_NO_NETWORK, NULL);
+        goto cleanup;
+    }
+    ret = virNetworkObjIsActive(obj);
+
+cleanup:
+    if (obj)
+        virNetworkObjUnlock(obj);
+    return ret;
+}
+
+static int networkIsPersistent(virNetworkPtr net)
+{
+    struct network_driver *driver = net->conn->privateData;
+    virNetworkObjPtr obj;
+    int ret = -1;
+
+    networkDriverLock(driver);
+    obj = virNetworkFindByUUID(&driver->networks, net->uuid);
+    networkDriverUnlock(driver);
+    if (!obj) {
+        networkReportError(net->conn, NULL, NULL, VIR_ERR_NO_NETWORK, NULL);
+        goto cleanup;
+    }
+    ret = obj->persistent;
+
+cleanup:
+    if (obj)
+        virNetworkObjUnlock(obj);
+    return ret;
+}
+
+
 static virNetworkPtr networkCreate(virConnectPtr conn, const char *xml) {
     struct network_driver *driver = conn->networkPrivateData;
     virNetworkDefPtr def;
@@ -1246,7 +1290,7 @@ static int networkUndefine(virNetworkPtr net) {
 
     network = virNetworkFindByUUID(&driver->networks, net->uuid);
     if (!network) {
-        networkReportError(net->conn, NULL, net, VIR_ERR_INVALID_DOMAIN,
+        networkReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
                            "%s", _("no network with matching uuid"));
         goto cleanup;
     }
@@ -1497,8 +1541,8 @@ static virNetworkDriver networkDriver = {
     networkGetBridgeName, /* networkGetBridgeName */
     networkGetAutostart, /* networkGetAutostart */
     networkSetAutostart, /* networkSetAutostart */
-    NULL, /* networkIsActive */
-    NULL, /* networkIsEncrypted */
+    networkIsActive,
+    networkIsPersistent,
 };
 
 static virStateDriver networkStateDriver = {
diff --git a/src/opennebula/one_driver.c b/src/opennebula/one_driver.c
index 9707bf8..ba61432 100644
--- a/src/opennebula/one_driver.c
+++ b/src/opennebula/one_driver.c
@@ -90,6 +90,21 @@ static int oneClose(virConnectPtr conn)
     return 0;
 }
 
+
+static int oneIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* Not encrypted because it uses HTTP, not HTTPs */
+    return 0;
+}
+
+
+static int oneIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* Not secure because it uses HTTP, not HTTPs */
+    return 0;
+}
+
+
 static virDomainPtr oneDomainLookupByID(virConnectPtr conn,
                                         int id)
 {
@@ -788,10 +803,10 @@ static virDriver oneDriver = {
     NULL, /* nodeDeviceReAttach; */
     NULL, /* nodeDeviceReset; */
     NULL, /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
+    oneIsEncrypted,
+    oneIsSecure,
     NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    NULL, /* domainIsPersistent */
 };
 
 static virStateDriver oneStateDriver = {
diff --git a/src/openvz/openvz_conf.c b/src/openvz/openvz_conf.c
index 403f537..83687a2 100644
--- a/src/openvz/openvz_conf.c
+++ b/src/openvz/openvz_conf.c
@@ -473,6 +473,8 @@ int openvzLoadDomains(struct openvz_driver *driver) {
 
         dom->pid = veid;
         dom->def->id = dom->state == VIR_DOMAIN_SHUTOFF ? -1 : veid;
+        /* XXX OpenVZ doesn't appear to have concept of a transient domain */
+        dom->persistent = 1;
 
         if (virAsprintf(&dom->def->name, "%i", veid) < 0)
             goto no_memory;
diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c
index 4d7f56c..c9fb8a2 100644
--- a/src/openvz/openvz_driver.c
+++ b/src/openvz/openvz_driver.c
@@ -415,6 +415,50 @@ cleanup:
 }
 
 
+static int openvzDomainIsActive(virDomainPtr dom)
+{
+    struct openvz_driver *driver = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    openvzDriverLock(driver);
+    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+    openvzDriverUnlock(driver);
+    if (!obj) {
+        openvzError(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = virDomainObjIsActive(obj);
+
+cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+
+static int openvzDomainIsPersistent(virDomainPtr dom)
+{
+    struct openvz_driver *driver = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    openvzDriverLock(driver);
+    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+    openvzDriverUnlock(driver);
+    if (!obj) {
+        openvzError(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = obj->persistent;
+
+cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+
 static char *openvzDomainDumpXML(virDomainPtr dom, int flags) {
     struct openvz_driver *driver = dom->conn->privateData;
     virDomainObjPtr vm;
@@ -777,6 +821,7 @@ openvzDomainDefineXML(virConnectPtr conn, const char *xml)
     if (!(vm = virDomainAssignDef(conn, &driver->domains, vmdef)))
         goto cleanup;
     vmdef = NULL;
+    vm->persistent = 1;
 
     if (openvzSetInitialConfig(conn, vm->def) < 0) {
         openvzError(conn, VIR_ERR_INTERNAL_ERROR,
@@ -844,6 +889,9 @@ openvzDomainCreateXML(virConnectPtr conn, const char *xml,
     if (!(vm = virDomainAssignDef(conn, &driver->domains, vmdef)))
         goto cleanup;
     vmdef = NULL;
+    /* All OpenVZ domains seem to be persistent - this is a bit of a violation
+     * of this libvirt API which is intended for transient domain creation */
+    vm->persistent = 1;
 
     if (openvzSetInitialConfig(conn, vm->def) < 0) {
         openvzError(conn, VIR_ERR_INTERNAL_ERROR,
@@ -1199,6 +1247,16 @@ static const char *openvzGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
     return "OpenVZ";
 }
 
+static int openvzIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED) {
+    /* Encryption is not relevant / applicable to way we talk to openvz */
+    return 0;
+}
+
+static int openvzIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED) {
+    /* We run CLI tools directly so this is secure */
+    return 1;
+}
+
 static char *openvzGetCapabilities(virConnectPtr conn) {
     struct openvz_driver *driver = conn->privateData;
     char *ret;
@@ -1433,10 +1491,10 @@ static virDriver openvzDriver = {
     NULL, /* nodeDeviceReAttach */
     NULL, /* nodeDeviceReset */
     NULL, /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
-    NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    openvzIsEncrypted,
+    openvzIsSecure,
+    openvzDomainIsActive,
+    openvzDomainIsPersistent,
 };
 
 int openvzRegister(void) {
diff --git a/src/phyp/phyp_driver.c b/src/phyp/phyp_driver.c
index cd0e9a7..52bdcce 100644
--- a/src/phyp/phyp_driver.c
+++ b/src/phyp/phyp_driver.c
@@ -159,6 +159,23 @@ phypClose(virConnectPtr conn)
     return 0;
 }
 
+
+static int
+phypIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* Phyp uses an SSH tunnel, so is always encrypted */
+    return 1;
+}
+
+
+static int
+phypIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* Phyp uses an SSH tunnel, so is always secure */
+    return 1;
+}
+
+
 LIBSSH2_SESSION *
 openSSHSession(virConnectPtr conn, virConnectAuthPtr auth,
                int *internal_socket)
@@ -1378,10 +1395,10 @@ virDriver phypDriver = {
     NULL,                       /* nodeDeviceReAttach */
     NULL,                       /* nodeDeviceReset */
     NULL,                       /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
-    NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    phypIsEncrypted,
+    phypIsSecure,
+    NULL,                       /* domainIsActive */
+    NULL,                       /* domainIsPersistent */
 };
 
 int
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 0264797..c98fa58 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -2395,6 +2395,19 @@ static const char *qemudGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
 }
 
 
+static int qemuIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* Trivially secure, since always inside the daemon */
+    return 1;
+}
+
+static int qemuIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* Not encrypted, but remote driver takes care of that */
+    return 0;
+}
+
+
 static int kvmGetMaxVCPUs(void) {
     int maxvcpus = 1;
 
@@ -2604,6 +2617,50 @@ cleanup:
     return dom;
 }
 
+
+static int qemuDomainIsActive(virDomainPtr dom)
+{
+    struct qemud_driver *driver = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    qemuDriverLock(driver);
+    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+    qemuDriverUnlock(driver);
+    if (!obj) {
+        qemudReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = virDomainObjIsActive(obj);
+
+cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+static int qemuDomainIsPersistent(virDomainPtr dom)
+{
+    struct qemud_driver *driver = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    qemuDriverLock(driver);
+    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+    qemuDriverUnlock(driver);
+    if (!obj) {
+        qemudReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = obj->persistent;
+
+cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+
 static int qemudGetVersion(virConnectPtr conn, unsigned long *version) {
     struct qemud_driver *driver = conn->privateData;
     int ret = -1;
@@ -7166,10 +7223,10 @@ static virDriver qemuDriver = {
     qemudNodeDeviceReAttach, /* nodeDeviceReAttach */
     qemudNodeDeviceReset, /* nodeDeviceReset */
     qemudDomainMigratePrepareTunnel, /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
-    NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    qemuIsEncrypted,
+    qemuIsSecure,
+    qemuDomainIsActive,
+    qemuDomainIsPersistent,
 };
 
 
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 9a265ac..5eeba00 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -157,6 +157,7 @@ struct private_data {
     int watch;                  /* File handle watch */
     pid_t pid;                  /* PID of tunnel process */
     int uses_tls;               /* TLS enabled on socket? */
+    int is_secure;              /* Secure if TLS or SASL or UNIX sockets */
     gnutls_session_t session;   /* GnuTLS session (if uses_tls != 0). */
     char *type;                 /* Cached return from remoteType. */
     int counter;                /* Generates serial numbers for RPC. */
@@ -574,6 +575,7 @@ doRemoteOpen (virConnectPtr conn,
     case trans_tls:
         if (initialise_gnutls (conn) == -1) goto failed;
         priv->uses_tls = 1;
+        priv->is_secure = 1;
 
         /*FALLTHROUGH*/
     case trans_tcp: {
@@ -691,6 +693,7 @@ doRemoteOpen (virConnectPtr conn,
             addr.sun_path[0] = '\0';
 
       autostart_retry:
+        priv->is_secure = 1;
         priv->sock = socket (AF_UNIX, SOCK_STREAM, 0);
         if (priv->sock == -1) {
             virReportSystemError(conn, errno, "%s",
@@ -771,6 +774,8 @@ doRemoteOpen (virConnectPtr conn,
         for (j = 0; j < (nr_args-1); j++)
             if (cmd_argv[j] == NULL)
                 goto out_of_memory;
+
+        priv->is_secure = 1;
     }
 
         /*FALLTHROUGH*/
@@ -797,6 +802,10 @@ doRemoteOpen (virConnectPtr conn,
         close (sv[1]);
         priv->sock = sv[0];
         priv->pid = pid;
+
+        /* Do not set 'is_secure' flag since we can't guarentee
+         * an external program is secure, and this flag must be
+         * pessimistic */
     }
 #else /* WIN32 */
 
@@ -1562,6 +1571,72 @@ done:
     return rv;
 }
 
+static int remoteIsSecure(virConnectPtr conn)
+{
+    int rv = -1;
+    struct private_data *priv = conn->privateData;
+    remote_is_secure_ret ret;
+    remoteDriverLock(priv);
+
+    memset (&ret, 0, sizeof ret);
+    if (call (conn, priv, 0, REMOTE_PROC_IS_SECURE,
+              (xdrproc_t) xdr_void, (char *) NULL,
+              (xdrproc_t) xdr_remote_is_secure_ret, (char *) &ret) == -1)
+        goto done;
+
+    /* We claim to be secure, if the remote driver
+     * transport itself is secure, and the remote
+     * HV connection is secure
+     *
+     * ie, we don't want to claim to be secure if the
+     * remote driver is used to connect to a XenD
+     * driver using unencrypted HTTP:/// access
+     */
+    rv = priv->is_secure && ret.secure ? 1 : 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int remoteIsEncrypted(virConnectPtr conn)
+{
+    int rv = -1;
+    int encrypted = 0;
+    struct private_data *priv = conn->privateData;
+    remote_is_secure_ret ret;
+    remoteDriverLock(priv);
+
+    memset (&ret, 0, sizeof ret);
+    if (call (conn, priv, 0, REMOTE_PROC_IS_SECURE,
+              (xdrproc_t) xdr_void, (char *) NULL,
+              (xdrproc_t) xdr_remote_is_secure_ret, (char *) &ret) == -1)
+        goto done;
+
+    if (priv->uses_tls)
+        encrypted = 1;
+#if HAVE_SASL
+    else if (priv->saslconn)
+        encrypted = 1;
+#endif
+
+
+    /* We claim to be encrypted, if the remote driver
+     * transport itself is encrypted, and the remote
+     * HV connection is secure.
+     *
+     * Yes, we really don't check the remote 'encrypted'
+     * option, since it will almost always be false,
+     * even if secure (eg UNIX sockets).
+     */
+    rv = encrypted && ret.secure ? 1 : 0;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+
 static int
 remoteGetMaxVcpus (virConnectPtr conn, const char *type)
 {
@@ -1773,6 +1848,54 @@ done:
     return rv;
 }
 
+static int
+remoteDomainIsActive(virDomainPtr domain)
+{
+    int rv = -1;
+    remote_domain_is_active_args args;
+    remote_domain_is_active_ret ret;
+    struct private_data *priv = domain->conn->privateData;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain (&args.dom, domain);
+
+    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_ACTIVE,
+              (xdrproc_t) xdr_remote_domain_is_active_args, (char *) &args,
+              (xdrproc_t) xdr_remote_domain_is_active_ret, (char *) &ret) == -1)
+        goto done;
+
+    rv = ret.active;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteDomainIsPersistent(virDomainPtr domain)
+{
+    int rv = -1;
+    remote_domain_is_persistent_args args;
+    remote_domain_is_persistent_ret ret;
+    struct private_data *priv = domain->conn->privateData;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_domain (&args.dom, domain);
+
+    if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_PERSISTENT,
+              (xdrproc_t) xdr_remote_domain_is_persistent_args, (char *) &args,
+              (xdrproc_t) xdr_remote_domain_is_persistent_ret, (char *) &ret) == -1)
+        goto done;
+
+    rv = ret.persistent;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
 static virDomainPtr
 remoteDomainCreateXML (virConnectPtr conn,
                          const char *xmlDesc,
@@ -3572,6 +3695,54 @@ done:
     return net;
 }
 
+static int
+remoteNetworkIsActive(virNetworkPtr network)
+{
+    int rv = -1;
+    remote_network_is_active_args args;
+    remote_network_is_active_ret ret;
+    struct private_data *priv = network->conn->privateData;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_network (&args.net, network);
+
+    if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_IS_ACTIVE,
+              (xdrproc_t) xdr_remote_network_is_active_args, (char *) &args,
+              (xdrproc_t) xdr_remote_network_is_active_ret, (char *) &ret) == -1)
+        goto done;
+
+    rv = ret.active;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteNetworkIsPersistent(virNetworkPtr network)
+{
+    int rv = -1;
+    remote_network_is_persistent_args args;
+    remote_network_is_persistent_ret ret;
+    struct private_data *priv = network->conn->privateData;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_network (&args.net, network);
+
+    if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_IS_PERSISTENT,
+              (xdrproc_t) xdr_remote_network_is_persistent_args, (char *) &args,
+              (xdrproc_t) xdr_remote_network_is_persistent_ret, (char *) &ret) == -1)
+        goto done;
+
+    rv = ret.persistent;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
 static virNetworkPtr
 remoteNetworkCreateXML (virConnectPtr conn, const char *xmlDesc)
 {
@@ -4060,6 +4231,32 @@ done:
     return iface;
 }
 
+
+static int
+remoteInterfaceIsActive(virInterfacePtr iface)
+{
+    int rv = -1;
+    remote_interface_is_active_args args;
+    remote_interface_is_active_ret ret;
+    struct private_data *priv = iface->conn->privateData;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_interface (&args.iface, iface);
+
+    if (call (iface->conn, priv, 0, REMOTE_PROC_INTERFACE_IS_ACTIVE,
+              (xdrproc_t) xdr_remote_interface_is_active_args, (char *) &args,
+              (xdrproc_t) xdr_remote_interface_is_active_ret, (char *) &ret) == -1)
+        goto done;
+
+    rv = ret.active;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+
 static char *
 remoteInterfaceGetXMLDesc (virInterfacePtr iface,
                            unsigned int flags)
@@ -4522,6 +4719,55 @@ done:
 }
 
 
+static int
+remoteStoragePoolIsActive(virStoragePoolPtr pool)
+{
+    int rv = -1;
+    remote_storage_pool_is_active_args args;
+    remote_storage_pool_is_active_ret ret;
+    struct private_data *priv = pool->conn->privateData;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool (&args.pool, pool);
+
+    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_IS_ACTIVE,
+              (xdrproc_t) xdr_remote_storage_pool_is_active_args, (char *) &args,
+              (xdrproc_t) xdr_remote_storage_pool_is_active_ret, (char *) &ret) == -1)
+        goto done;
+
+    rv = ret.active;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+static int
+remoteStoragePoolIsPersistent(virStoragePoolPtr pool)
+{
+    int rv = -1;
+    remote_storage_pool_is_persistent_args args;
+    remote_storage_pool_is_persistent_ret ret;
+    struct private_data *priv = pool->conn->privateData;
+
+    remoteDriverLock(priv);
+
+    make_nonnull_storage_pool (&args.pool, pool);
+
+    if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT,
+              (xdrproc_t) xdr_remote_storage_pool_is_persistent_args, (char *) &args,
+              (xdrproc_t) xdr_remote_storage_pool_is_persistent_ret, (char *) &ret) == -1)
+        goto done;
+
+    rv = ret.persistent;
+
+done:
+    remoteDriverUnlock(priv);
+    return rv;
+}
+
+
 static virStoragePoolPtr
 remoteStoragePoolCreateXML (virConnectPtr conn, const char *xmlDesc, unsigned int flags)
 {
@@ -6205,6 +6451,7 @@ remoteAuthSASL (virConnectPtr conn, struct private_data *priv, int in_open,
                              _("negotiation SSF %d was not strong enough"), ssf);
             goto cleanup;
         }
+        priv->is_secure = 1;
     }
 
     DEBUG0("SASL authentication complete");
@@ -8449,10 +8696,10 @@ static virDriver remote_driver = {
     remoteNodeDeviceReAttach, /* nodeDeviceReAttach */
     remoteNodeDeviceReset, /* nodeDeviceReset */
     remoteDomainMigratePrepareTunnel, /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
-    NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    remoteIsEncrypted, /* isEncrypted */
+    remoteIsSecure, /* isSecure */
+    remoteDomainIsActive, /* domainIsActive */
+    remoteDomainIsPersistent, /* domainIsPersistent */
 };
 
 static virNetworkDriver network_driver = {
@@ -8474,8 +8721,8 @@ static virNetworkDriver network_driver = {
     .networkGetBridgeName = remoteNetworkGetBridgeName,
     .networkGetAutostart = remoteNetworkGetAutostart,
     .networkSetAutostart = remoteNetworkSetAutostart,
-    .networkIsActive = NULL,
-    .networkIsPersistent = NULL,
+    .networkIsActive = remoteNetworkIsActive,
+    .networkIsPersistent = remoteNetworkIsPersistent,
 };
 
 static virInterfaceDriver interface_driver = {
@@ -8493,7 +8740,7 @@ static virInterfaceDriver interface_driver = {
     .interfaceUndefine = remoteInterfaceUndefine,
     .interfaceCreate = remoteInterfaceCreate,
     .interfaceDestroy = remoteInterfaceDestroy,
-    .interfaceIsActive = NULL, /* interfaceIsActive */
+    .interfaceIsActive = remoteInterfaceIsActive,
 };
 
 static virStorageDriver storage_driver = {
@@ -8532,9 +8779,8 @@ static virStorageDriver storage_driver = {
     .volGetInfo = remoteStorageVolGetInfo,
     .volGetXMLDesc = remoteStorageVolDumpXML,
     .volGetPath = remoteStorageVolGetPath,
-
-    .poolIsActive = NULL, /* poolIsActive */
-    .poolIsPersistent = NULL, /* poolIsEncrypted */
+    .poolIsActive = remoteStoragePoolIsActive,
+    .poolIsPersistent = remoteStoragePoolIsPersistent,
 };
 
 static virSecretDriver secret_driver = {
diff --git a/src/remote/remote_protocol.c b/src/remote/remote_protocol.c
index 1449ed4..b6a85a8 100644
--- a/src/remote/remote_protocol.c
+++ b/src/remote/remote_protocol.c
@@ -4,7 +4,7 @@
  * It was generated using rpcgen.
  */
 
-#include "remote_protocol.h"
+#include "./remote/remote_protocol.h"
 #include "internal.h"
 #include <arpa/inet.h>
 
@@ -2713,6 +2713,141 @@ xdr_remote_domain_migrate_prepare_tunnel_args (XDR *xdrs, remote_domain_migrate_
 }
 
 bool_t
+xdr_remote_is_secure_ret (XDR *xdrs, remote_is_secure_ret *objp)
+{
+
+         if (!xdr_int (xdrs, &objp->secure))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_domain_is_active_args (XDR *xdrs, remote_domain_is_active_args *objp)
+{
+
+         if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_domain_is_active_ret (XDR *xdrs, remote_domain_is_active_ret *objp)
+{
+
+         if (!xdr_int (xdrs, &objp->active))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_domain_is_persistent_args (XDR *xdrs, remote_domain_is_persistent_args *objp)
+{
+
+         if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_domain_is_persistent_ret (XDR *xdrs, remote_domain_is_persistent_ret *objp)
+{
+
+         if (!xdr_int (xdrs, &objp->persistent))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_network_is_active_args (XDR *xdrs, remote_network_is_active_args *objp)
+{
+
+         if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_network_is_active_ret (XDR *xdrs, remote_network_is_active_ret *objp)
+{
+
+         if (!xdr_int (xdrs, &objp->active))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_network_is_persistent_args (XDR *xdrs, remote_network_is_persistent_args *objp)
+{
+
+         if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_network_is_persistent_ret (XDR *xdrs, remote_network_is_persistent_ret *objp)
+{
+
+         if (!xdr_int (xdrs, &objp->persistent))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_is_active_args (XDR *xdrs, remote_storage_pool_is_active_args *objp)
+{
+
+         if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_is_active_ret (XDR *xdrs, remote_storage_pool_is_active_ret *objp)
+{
+
+         if (!xdr_int (xdrs, &objp->active))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_is_persistent_args (XDR *xdrs, remote_storage_pool_is_persistent_args *objp)
+{
+
+         if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_is_persistent_ret (XDR *xdrs, remote_storage_pool_is_persistent_ret *objp)
+{
+
+         if (!xdr_int (xdrs, &objp->persistent))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_interface_is_active_args (XDR *xdrs, remote_interface_is_active_args *objp)
+{
+
+         if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_interface_is_active_ret (XDR *xdrs, remote_interface_is_active_ret *objp)
+{
+
+         if (!xdr_int (xdrs, &objp->active))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
 xdr_remote_procedure (XDR *xdrs, remote_procedure *objp)
 {
 
diff --git a/src/remote/remote_protocol.h b/src/remote/remote_protocol.h
index d87e8bc..885695c 100644
--- a/src/remote/remote_protocol.h
+++ b/src/remote/remote_protocol.h
@@ -1537,6 +1537,80 @@ struct remote_domain_migrate_prepare_tunnel_args {
 };
 typedef struct remote_domain_migrate_prepare_tunnel_args remote_domain_migrate_prepare_tunnel_args;
 
+struct remote_is_secure_ret {
+        int secure;
+};
+typedef struct remote_is_secure_ret remote_is_secure_ret;
+
+struct remote_domain_is_active_args {
+        remote_nonnull_domain dom;
+};
+typedef struct remote_domain_is_active_args remote_domain_is_active_args;
+
+struct remote_domain_is_active_ret {
+        int active;
+};
+typedef struct remote_domain_is_active_ret remote_domain_is_active_ret;
+
+struct remote_domain_is_persistent_args {
+        remote_nonnull_domain dom;
+};
+typedef struct remote_domain_is_persistent_args remote_domain_is_persistent_args;
+
+struct remote_domain_is_persistent_ret {
+        int persistent;
+};
+typedef struct remote_domain_is_persistent_ret remote_domain_is_persistent_ret;
+
+struct remote_network_is_active_args {
+        remote_nonnull_network net;
+};
+typedef struct remote_network_is_active_args remote_network_is_active_args;
+
+struct remote_network_is_active_ret {
+        int active;
+};
+typedef struct remote_network_is_active_ret remote_network_is_active_ret;
+
+struct remote_network_is_persistent_args {
+        remote_nonnull_network net;
+};
+typedef struct remote_network_is_persistent_args remote_network_is_persistent_args;
+
+struct remote_network_is_persistent_ret {
+        int persistent;
+};
+typedef struct remote_network_is_persistent_ret remote_network_is_persistent_ret;
+
+struct remote_storage_pool_is_active_args {
+        remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_is_active_args remote_storage_pool_is_active_args;
+
+struct remote_storage_pool_is_active_ret {
+        int active;
+};
+typedef struct remote_storage_pool_is_active_ret remote_storage_pool_is_active_ret;
+
+struct remote_storage_pool_is_persistent_args {
+        remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_is_persistent_args remote_storage_pool_is_persistent_args;
+
+struct remote_storage_pool_is_persistent_ret {
+        int persistent;
+};
+typedef struct remote_storage_pool_is_persistent_ret remote_storage_pool_is_persistent_ret;
+
+struct remote_interface_is_active_args {
+        remote_nonnull_interface iface;
+};
+typedef struct remote_interface_is_active_args remote_interface_is_active_args;
+
+struct remote_interface_is_active_ret {
+        int active;
+};
+typedef struct remote_interface_is_active_ret remote_interface_is_active_ret;
 #define REMOTE_PROGRAM 0x20008086
 #define REMOTE_PROTOCOL_VERSION 1
 
@@ -1689,6 +1763,14 @@ enum remote_procedure {
         REMOTE_PROC_SECRET_UNDEFINE = 146,
         REMOTE_PROC_SECRET_LOOKUP_BY_USAGE = 147,
         REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL = 148,
+        REMOTE_PROC_IS_SECURE = 149,
+        REMOTE_PROC_DOMAIN_IS_ACTIVE = 150,
+        REMOTE_PROC_DOMAIN_IS_PERSISTENT = 151,
+        REMOTE_PROC_NETWORK_IS_ACTIVE = 152,
+        REMOTE_PROC_NETWORK_IS_PERSISTENT = 153,
+        REMOTE_PROC_STORAGE_POOL_IS_ACTIVE = 154,
+        REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT = 155,
+        REMOTE_PROC_INTERFACE_IS_ACTIVE = 156,
 };
 typedef enum remote_procedure remote_procedure;
 
@@ -1970,6 +2052,21 @@ extern  bool_t xdr_remote_secret_undefine_args (XDR *, remote_secret_undefine_ar
 extern  bool_t xdr_remote_secret_lookup_by_usage_args (XDR *, remote_secret_lookup_by_usage_args*);
 extern  bool_t xdr_remote_secret_lookup_by_usage_ret (XDR *, remote_secret_lookup_by_usage_ret*);
 extern  bool_t xdr_remote_domain_migrate_prepare_tunnel_args (XDR *, remote_domain_migrate_prepare_tunnel_args*);
+extern  bool_t xdr_remote_is_secure_ret (XDR *, remote_is_secure_ret*);
+extern  bool_t xdr_remote_domain_is_active_args (XDR *, remote_domain_is_active_args*);
+extern  bool_t xdr_remote_domain_is_active_ret (XDR *, remote_domain_is_active_ret*);
+extern  bool_t xdr_remote_domain_is_persistent_args (XDR *, remote_domain_is_persistent_args*);
+extern  bool_t xdr_remote_domain_is_persistent_ret (XDR *, remote_domain_is_persistent_ret*);
+extern  bool_t xdr_remote_network_is_active_args (XDR *, remote_network_is_active_args*);
+extern  bool_t xdr_remote_network_is_active_ret (XDR *, remote_network_is_active_ret*);
+extern  bool_t xdr_remote_network_is_persistent_args (XDR *, remote_network_is_persistent_args*);
+extern  bool_t xdr_remote_network_is_persistent_ret (XDR *, remote_network_is_persistent_ret*);
+extern  bool_t xdr_remote_storage_pool_is_active_args (XDR *, remote_storage_pool_is_active_args*);
+extern  bool_t xdr_remote_storage_pool_is_active_ret (XDR *, remote_storage_pool_is_active_ret*);
+extern  bool_t xdr_remote_storage_pool_is_persistent_args (XDR *, remote_storage_pool_is_persistent_args*);
+extern  bool_t xdr_remote_storage_pool_is_persistent_ret (XDR *, remote_storage_pool_is_persistent_ret*);
+extern  bool_t xdr_remote_interface_is_active_args (XDR *, remote_interface_is_active_args*);
+extern  bool_t xdr_remote_interface_is_active_ret (XDR *, remote_interface_is_active_ret*);
 extern  bool_t xdr_remote_procedure (XDR *, remote_procedure*);
 extern  bool_t xdr_remote_message_type (XDR *, remote_message_type*);
 extern  bool_t xdr_remote_message_status (XDR *, remote_message_status*);
@@ -2225,6 +2322,21 @@ extern bool_t xdr_remote_secret_undefine_args ();
 extern bool_t xdr_remote_secret_lookup_by_usage_args ();
 extern bool_t xdr_remote_secret_lookup_by_usage_ret ();
 extern bool_t xdr_remote_domain_migrate_prepare_tunnel_args ();
+extern bool_t xdr_remote_is_secure_ret ();
+extern bool_t xdr_remote_domain_is_active_args ();
+extern bool_t xdr_remote_domain_is_active_ret ();
+extern bool_t xdr_remote_domain_is_persistent_args ();
+extern bool_t xdr_remote_domain_is_persistent_ret ();
+extern bool_t xdr_remote_network_is_active_args ();
+extern bool_t xdr_remote_network_is_active_ret ();
+extern bool_t xdr_remote_network_is_persistent_args ();
+extern bool_t xdr_remote_network_is_persistent_ret ();
+extern bool_t xdr_remote_storage_pool_is_active_args ();
+extern bool_t xdr_remote_storage_pool_is_active_ret ();
+extern bool_t xdr_remote_storage_pool_is_persistent_args ();
+extern bool_t xdr_remote_storage_pool_is_persistent_ret ();
+extern bool_t xdr_remote_interface_is_active_args ();
+extern bool_t xdr_remote_interface_is_active_ret ();
 extern bool_t xdr_remote_procedure ();
 extern bool_t xdr_remote_message_type ();
 extern bool_t xdr_remote_message_status ();
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index 2b3c03b..1886282 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -1362,6 +1362,73 @@ struct remote_domain_migrate_prepare_tunnel_args {
     remote_nonnull_string dom_xml;
 };
 
+
+struct remote_is_secure_ret {
+    int secure;
+};
+
+
+struct remote_domain_is_active_args {
+    remote_nonnull_domain dom;
+};
+
+struct remote_domain_is_active_ret {
+    int active;
+};
+
+
+struct remote_domain_is_persistent_args {
+    remote_nonnull_domain dom;
+};
+
+struct remote_domain_is_persistent_ret {
+    int persistent;
+};
+
+
+struct remote_network_is_active_args {
+    remote_nonnull_network net;
+};
+
+struct remote_network_is_active_ret {
+    int active;
+};
+
+struct remote_network_is_persistent_args {
+    remote_nonnull_network net;
+};
+
+struct remote_network_is_persistent_ret {
+    int persistent;
+};
+
+
+struct remote_storage_pool_is_active_args {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_is_active_ret {
+    int active;
+};
+
+struct remote_storage_pool_is_persistent_args {
+    remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_is_persistent_ret {
+    int persistent;
+};
+
+
+struct remote_interface_is_active_args {
+    remote_nonnull_interface iface;
+};
+
+struct remote_interface_is_active_ret {
+    int active;
+};
+
+
 /*----- Protocol. -----*/
 
 /* Define the program number, protocol version and procedure numbers here. */
@@ -1518,12 +1585,11 @@ enum remote_procedure {
     REMOTE_PROC_INTERFACE_DESTROY = 134,
     REMOTE_PROC_DOMAIN_XML_FROM_NATIVE = 135,
     REMOTE_PROC_DOMAIN_XML_TO_NATIVE = 136,
-
     REMOTE_PROC_NUM_OF_DEFINED_INTERFACES = 137,
     REMOTE_PROC_LIST_DEFINED_INTERFACES = 138,
-
     REMOTE_PROC_NUM_OF_SECRETS = 139,
     REMOTE_PROC_LIST_SECRETS = 140,
+
     REMOTE_PROC_SECRET_LOOKUP_BY_UUID = 141,
     REMOTE_PROC_SECRET_DEFINE_XML = 142,
     REMOTE_PROC_SECRET_GET_XML_DESC = 143,
@@ -1531,11 +1597,24 @@ enum remote_procedure {
     REMOTE_PROC_SECRET_GET_VALUE = 145,
     REMOTE_PROC_SECRET_UNDEFINE = 146,
     REMOTE_PROC_SECRET_LOOKUP_BY_USAGE = 147,
+    REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL = 148,
+    REMOTE_PROC_IS_SECURE = 149,
+    REMOTE_PROC_DOMAIN_IS_ACTIVE = 150,
 
-    REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL = 148
-};
+    REMOTE_PROC_DOMAIN_IS_PERSISTENT = 151,
+    REMOTE_PROC_NETWORK_IS_ACTIVE = 152,
+    REMOTE_PROC_NETWORK_IS_PERSISTENT = 153,
+    REMOTE_PROC_STORAGE_POOL_IS_ACTIVE = 154,
+    REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT = 155,
+    REMOTE_PROC_INTERFACE_IS_ACTIVE = 156
 
 
+    /*
+     * Notice how the entries are grouped in sets of 10 ?
+     * Nice isn't it. Please keep it this way when adding more.
+     */
+};
+
 /*
  * RPC wire format
  *
diff --git a/src/storage/storage_driver.c b/src/storage/storage_driver.c
index 4f8949b..00ee472 100644
--- a/src/storage/storage_driver.c
+++ b/src/storage/storage_driver.c
@@ -464,6 +464,49 @@ cleanup:
 }
 
 
+static int storagePoolIsActive(virStoragePoolPtr net)
+{
+    virStorageDriverStatePtr driver = net->conn->privateData;
+    virStoragePoolObjPtr obj;
+    int ret = -1;
+
+    storageDriverLock(driver);
+    obj = virStoragePoolObjFindByUUID(&driver->pools, net->uuid);
+    storageDriverUnlock(driver);
+    if (!obj) {
+        virStorageReportError(net->conn, VIR_ERR_NO_STORAGE_POOL, NULL);
+        goto cleanup;
+    }
+    ret = virStoragePoolObjIsActive(obj);
+
+cleanup:
+    if (obj)
+        virStoragePoolObjUnlock(obj);
+    return ret;
+}
+
+static int storagePoolIsPersistent(virStoragePoolPtr net)
+{
+    virStorageDriverStatePtr driver = net->conn->privateData;
+    virStoragePoolObjPtr obj;
+    int ret = -1;
+
+    storageDriverLock(driver);
+    obj = virStoragePoolObjFindByUUID(&driver->pools, net->uuid);
+    storageDriverUnlock(driver);
+    if (!obj) {
+        virStorageReportError(net->conn, VIR_ERR_NO_STORAGE_POOL, NULL);
+        goto cleanup;
+    }
+    ret = obj->configFile ? 1 : 0;
+
+cleanup:
+    if (obj)
+        virStoragePoolObjUnlock(obj);
+    return ret;
+}
+
+
 static virStoragePoolPtr
 storagePoolCreate(virConnectPtr conn,
                   const char *xml,
@@ -1740,6 +1783,9 @@ static virStorageDriver storageDriver = {
     .volGetInfo = storageVolumeGetInfo,
     .volGetXMLDesc = storageVolumeGetXMLDesc,
     .volGetPath = storageVolumeGetPath,
+
+    .poolIsActive = storagePoolIsActive,
+    .poolIsPersistent = storagePoolIsPersistent,
 };
 
 
diff --git a/src/test/test_driver.c b/src/test/test_driver.c
index 88dc6a5..afa9b02 100644
--- a/src/test/test_driver.c
+++ b/src/test/test_driver.c
@@ -1006,6 +1006,17 @@ static char *testGetHostname (virConnectPtr conn)
     return result;
 }
 
+
+static int testIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    return 1;
+}
+
+static int testIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    return 0;
+}
+
 static int testGetMaxVCPUs(virConnectPtr conn ATTRIBUTE_UNUSED,
                            const char *type ATTRIBUTE_UNUSED)
 {
@@ -1047,6 +1058,48 @@ static int testNumOfDomains(virConnectPtr conn)
     return numActive;
 }
 
+static int testDomainIsActive(virDomainPtr dom)
+{
+    testConnPtr privconn = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    testDriverLock(privconn);
+    obj = virDomainFindByUUID(&privconn->domains, dom->uuid);
+    testDriverUnlock(privconn);
+    if (!obj) {
+        testError(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = virDomainObjIsActive(obj);
+
+cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+static int testDomainIsPersistent(virDomainPtr dom)
+{
+    testConnPtr privconn = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    testDriverLock(privconn);
+    obj = virDomainFindByUUID(&privconn->domains, dom->uuid);
+    testDriverUnlock(privconn);
+    if (!obj) {
+        testError(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = obj->persistent;
+
+cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
 static virDomainPtr
 testDomainCreateXML(virConnectPtr conn, const char *xml,
                       unsigned int flags ATTRIBUTE_UNUSED)
@@ -2441,6 +2494,50 @@ no_memory:
     return -1;
 }
 
+
+static int testNetworkIsActive(virNetworkPtr net)
+{
+    testConnPtr privconn = net->conn->privateData;
+    virNetworkObjPtr obj;
+    int ret = -1;
+
+    testDriverLock(privconn);
+    obj = virNetworkFindByUUID(&privconn->networks, net->uuid);
+    testDriverUnlock(privconn);
+    if (!obj) {
+        testError(net->conn, VIR_ERR_NO_NETWORK, NULL);
+        goto cleanup;
+    }
+    ret = virNetworkObjIsActive(obj);
+
+cleanup:
+    if (obj)
+        virNetworkObjUnlock(obj);
+    return ret;
+}
+
+static int testNetworkIsPersistent(virNetworkPtr net)
+{
+    testConnPtr privconn = net->conn->privateData;
+    virNetworkObjPtr obj;
+    int ret = -1;
+
+    testDriverLock(privconn);
+    obj = virNetworkFindByUUID(&privconn->networks, net->uuid);
+    testDriverUnlock(privconn);
+    if (!obj) {
+        testError(net->conn, VIR_ERR_NO_NETWORK, NULL);
+        goto cleanup;
+    }
+    ret = obj->persistent;
+
+cleanup:
+    if (obj)
+        virNetworkObjUnlock(obj);
+    return ret;
+}
+
+
 static virNetworkPtr testNetworkCreate(virConnectPtr conn, const char *xml) {
     testConnPtr privconn = conn->privateData;
     virNetworkDefPtr def;
@@ -2857,6 +2954,28 @@ cleanup:
     return ret;
 }
 
+static int testInterfaceIsActive(virInterfacePtr iface)
+{
+    testConnPtr privconn = iface->conn->privateData;
+    virInterfaceObjPtr obj;
+    int ret = -1;
+
+    testDriverLock(privconn);
+    obj = virInterfaceFindByName(&privconn->ifaces, iface->name);
+    testDriverUnlock(privconn);
+    if (!obj) {
+        testError(iface->conn, VIR_ERR_NO_INTERFACE, NULL);
+        goto cleanup;
+    }
+    ret = virInterfaceObjIsActive(obj);
+
+cleanup:
+    if (obj)
+        virInterfaceObjUnlock(obj);
+    return ret;
+}
+
+
 static char *testInterfaceGetXMLDesc(virInterfacePtr iface,
                                      unsigned int flags ATTRIBUTE_UNUSED)
 {
@@ -3001,6 +3120,7 @@ cleanup:
  * Storage Driver routines
  */
 
+
 static int testStoragePoolObjSetDefaults(virConnectPtr conn,
                                          virStoragePoolObjPtr pool) {
 
@@ -3032,6 +3152,7 @@ static int testStorageClose(virConnectPtr conn) {
     return 0;
 }
 
+
 static virStoragePoolPtr
 testStoragePoolLookupByUUID(virConnectPtr conn,
                             const unsigned char *uuid) {
@@ -3177,6 +3298,50 @@ no_memory:
 }
 
 
+static int testStoragePoolIsActive(virStoragePoolPtr pool)
+{
+    testConnPtr privconn = pool->conn->privateData;
+    virStoragePoolObjPtr obj;
+    int ret = -1;
+
+    testDriverLock(privconn);
+    obj = virStoragePoolObjFindByUUID(&privconn->pools, pool->uuid);
+    testDriverUnlock(privconn);
+    if (!obj) {
+        testError(pool->conn, VIR_ERR_NO_STORAGE_POOL, NULL);
+        goto cleanup;
+    }
+    ret = virStoragePoolObjIsActive(obj);
+
+cleanup:
+    if (obj)
+        virStoragePoolObjUnlock(obj);
+    return ret;
+}
+
+static int testStoragePoolIsPersistent(virStoragePoolPtr pool)
+{
+    testConnPtr privconn = pool->conn->privateData;
+    virStoragePoolObjPtr obj;
+    int ret = -1;
+
+    testDriverLock(privconn);
+    obj = virStoragePoolObjFindByUUID(&privconn->pools, pool->uuid);
+    testDriverUnlock(privconn);
+    if (!obj) {
+        testError(pool->conn, VIR_ERR_NO_STORAGE_POOL, NULL);
+        goto cleanup;
+    }
+    ret = obj->configFile ? 1 : 0;
+
+cleanup:
+    if (obj)
+        virStoragePoolObjUnlock(obj);
+    return ret;
+}
+
+
+
 static int
 testStoragePoolStart(virStoragePoolPtr pool,
                      unsigned int flags ATTRIBUTE_UNUSED) {
@@ -4558,10 +4723,10 @@ static virDriver testDriver = {
     NULL, /* nodeDeviceReAttach */
     NULL, /* nodeDeviceReset */
     NULL, /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
-    NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    testIsEncrypted, /* isEncrypted */
+    testIsSecure, /* isEncrypted */
+    testDomainIsActive, /* domainIsActive */
+    testDomainIsPersistent, /* domainIsPersistent */
 };
 
 static virNetworkDriver testNetworkDriver = {
@@ -4583,8 +4748,8 @@ static virNetworkDriver testNetworkDriver = {
     testNetworkGetBridgeName, /* networkGetBridgeName */
     testNetworkGetAutostart, /* networkGetAutostart */
     testNetworkSetAutostart, /* networkSetAutostart */
-    NULL, /* networkIsActive */
-    NULL, /* networkIsEncrypted */
+    testNetworkIsActive, /* domainIsActive */
+    testNetworkIsPersistent, /* domainIsPersistent */
 };
 
 static virInterfaceDriver testInterfaceDriver = {
@@ -4602,7 +4767,7 @@ static virInterfaceDriver testInterfaceDriver = {
     testInterfaceUndefine,      /* interfaceUndefine */
     testInterfaceCreate,        /* interfaceCreate */
     testInterfaceDestroy,       /* interfaceDestroy */
-    NULL, /* interfaceIsActive */
+    testInterfaceIsActive, /* domainIsActive */
 };
 
 
@@ -4643,9 +4808,8 @@ static virStorageDriver testStorageDriver = {
     .volGetInfo = testStorageVolumeGetInfo,
     .volGetXMLDesc = testStorageVolumeGetXMLDesc,
     .volGetPath = testStorageVolumeGetPath,
-
-    .poolIsActive = NULL, /* poolIsActive */
-    .poolIsPersistent = NULL, /* poolIsEncrypted */
+    .poolIsActive = testStoragePoolIsActive,
+    .poolIsPersistent = testStoragePoolIsPersistent,
 };
 
 static virDeviceMonitor testDevMonitor = {
diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c
index 9b450d9..0a87341 100644
--- a/src/uml/uml_driver.c
+++ b/src/uml/uml_driver.c
@@ -981,6 +981,20 @@ static const char *umlGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
 }
 
 
+static int umlIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* Trivially secure, since always inside the daemon */
+    return 1;
+}
+
+
+static int umlIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    /* Not encrypted, but remote driver takes care of that */
+    return 0;
+}
+
+
 static char *umlGetCapabilities(virConnectPtr conn) {
     struct uml_driver *driver = (struct uml_driver *)conn->privateData;
     char *xml;
@@ -1104,6 +1118,51 @@ cleanup:
     return dom;
 }
 
+
+static int umlDomainIsActive(virDomainPtr dom)
+{
+    struct uml_driver *driver = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    umlDriverLock(driver);
+    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+    umlDriverUnlock(driver);
+    if (!obj) {
+        umlReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = virDomainObjIsActive(obj);
+
+cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+
+static int umlDomainIsPersistent(virDomainPtr dom)
+{
+    struct uml_driver *driver = dom->conn->privateData;
+    virDomainObjPtr obj;
+    int ret = -1;
+
+    umlDriverLock(driver);
+    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+    umlDriverUnlock(driver);
+    if (!obj) {
+        umlReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
+        goto cleanup;
+    }
+    ret = obj->persistent;
+
+cleanup:
+    if (obj)
+        virDomainObjUnlock(obj);
+    return ret;
+}
+
+
 static int umlGetVersion(virConnectPtr conn, unsigned long *version) {
     struct uml_driver *driver = conn->privateData;
     struct utsname ut;
@@ -1862,10 +1921,10 @@ static virDriver umlDriver = {
     NULL, /* nodeDeviceReAttach */
     NULL, /* nodeDeviceReset */
     NULL, /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
-    NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    umlIsEncrypted,
+    umlIsSecure,
+    umlDomainIsActive,
+    umlDomainIsPersistent,
 };
 
 
diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c
index 5878154..28651a4 100644
--- a/src/vbox/vbox_tmpl.c
+++ b/src/vbox/vbox_tmpl.c
@@ -607,6 +607,19 @@ static char *vboxGetHostname(virConnectPtr conn) {
     return hostname;
 }
 
+
+static int vboxIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED) {
+    /* Driver is using local, non-network based transport */
+    return 1;
+}
+
+
+static int vboxIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED) {
+    /* No encryption is needed, or used on the local transport*/
+    return 0;
+}
+
+
 static int vboxGetMaxVcpus(virConnectPtr conn, const char *type ATTRIBUTE_UNUSED) {
     vboxGlobalData *data = conn->privateData;
     PRUint32 maxCPUCount = 0;
@@ -1030,6 +1043,93 @@ static virDomainPtr vboxDomainLookupByName(virConnectPtr conn, const char *name)
     return dom;
 }
 
+
+static int vboxDomainIsActive(virDomainPtr dom) {
+    nsresult rc;
+    vboxGlobalData *data = dom->conn->privateData;
+    IMachine **machines  = NULL;
+    PRUint32 machineCnt  = 0;
+    vboxIID *iid         = NULL;
+    char      *machineNameUtf8  = NULL;
+    PRUnichar *machineNameUtf16 = NULL;
+    unsigned char iidl[VIR_UUID_BUFLEN];
+    int i, matched = 0;
+    int ret = -1;
+
+    if(data->vboxObj) {
+        rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+        if (NS_FAILED(rc)) {
+            vboxError(dom->conn, VIR_ERR_INTERNAL_ERROR,"%s, rc=%08x",
+                      "Could not get list of machines",(unsigned)rc);
+            return -1;
+        }
+
+        for (i = 0; i < machineCnt; ++i) {
+            IMachine *machine = machines[i];
+            PRBool isAccessible = PR_FALSE;
+
+            if (!machine)
+                continue;
+
+            machine->vtbl->GetAccessible(machine, &isAccessible);
+            if (isAccessible) {
+
+                machine->vtbl->GetId(machine, &iid);
+                if (!iid)
+                    continue;
+                vboxIIDToUUID(iidl, iid);
+                vboxIIDUnalloc(iid);
+
+                if (memcmp(dom->uuid, iidl, VIR_UUID_BUFLEN) == 0) {
+
+                    PRUint32 state;
+
+                    matched = 1;
+
+                    machine->vtbl->GetName(machine, &machineNameUtf16);
+                    data->pFuncs->pfnUtf16ToUtf8(machineNameUtf16, &machineNameUtf8);
+
+                    machine->vtbl->GetState(machine, &state);
+
+                    if ((state == MachineState_Starting)   ||
+                        (state == MachineState_Running)    ||
+                        (state == MachineState_Stuck)      ||
+                        (state == MachineState_Stopping)   ||
+                        (state == MachineState_Saving)     ||
+                        (state == MachineState_Restoring)  ||
+                        (state == MachineState_Discarding) ||
+                        (state == MachineState_Paused) )
+                        ret = 1;
+                    else
+                        ret = 0;
+                }
+
+                if (matched == 1)
+                    break;
+            }
+        }
+
+        /* Do the cleanup and take care you dont leak any memory */
+        if (machineNameUtf8)
+            data->pFuncs->pfnUtf8Free(machineNameUtf8);
+        if (machineNameUtf16)
+            data->pFuncs->pfnComUnallocMem(machineNameUtf16);
+        for (i = 0; i < machineCnt; ++i) {
+            if (machines[i])
+                machines[i]->vtbl->nsisupports.Release((nsISupports *)machines[i]);
+        }
+    }
+
+    return ret;
+}
+
+
+static int vboxDomainIsPersistent(virDomainPtr dom ATTRIBUTE_UNUSED) {
+    /* XXX All domains appear to be persistent. Is this true ? */
+    return 1;
+}
+
+
 static int vboxDomainSuspend(virDomainPtr dom) {
     nsresult rc;
     vboxGlobalData *data = dom->conn->privateData;
@@ -6468,10 +6568,10 @@ virDriver NAME(Driver) = {
     NULL, /* nodeDeviceReAttach */
     NULL, /* nodeDeviceReset */
     NULL, /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
-    NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    vboxIsEncrypted,
+    vboxIsSecure,
+    vboxDomainIsActive,
+    vboxDomainIsPersistent,
 };
 
 virNetworkDriver NAME(NetworkDriver) = {
diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c
index da05253..fcf0506 100644
--- a/src/xen/xen_driver.c
+++ b/src/xen/xen_driver.c
@@ -45,6 +45,7 @@
 #include "memory.h"
 #include "node_device_conf.h"
 #include "pci.h"
+#include "uuid.h"
 
 #define VIR_FROM_THIS VIR_FROM_XEN
 
@@ -497,6 +498,26 @@ xenUnifiedGetHostname (virConnectPtr conn)
 }
 
 static int
+xenUnifiedIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+    return 0;
+}
+
+static int
+xenUnifiedIsSecure(virConnectPtr conn)
+{
+    GET_PRIVATE(conn);
+    int ret = 1;
+
+    /* All drivers are secure, except for XenD over TCP */
+    if (priv->opened[XEN_UNIFIED_XEND_OFFSET] &&
+        priv->addrfamily != AF_UNIX)
+        ret = 0;
+
+    return ret;
+}
+
+static int
 xenUnifiedGetMaxVcpus (virConnectPtr conn, const char *type)
 {
     GET_PRIVATE(conn);
@@ -738,6 +759,75 @@ xenUnifiedDomainLookupByName (virConnectPtr conn,
     return NULL;
 }
 
+
+static int
+xenUnifiedDomainIsActive(virDomainPtr dom)
+{
+    virDomainPtr currdom;
+    int ret = -1;
+
+    /* ID field in dom may be outdated, so re-lookup */
+    currdom = xenUnifiedDomainLookupByUUID(dom->conn, dom->uuid);
+
+    if (currdom) {
+        ret = currdom->id == -1 ? 0 : 1;
+        virDomainFree(currdom);
+    }
+
+    return ret;
+}
+
+static int
+xenUnifiedDomainisPersistent(virDomainPtr dom)
+{
+    GET_PRIVATE(dom->conn);
+    virDomainPtr currdom = NULL;
+    int ret = -1;
+
+    if (priv->opened[XEN_UNIFIED_XM_OFFSET]) {
+        /* Old Xen, pre-inactive domain management.
+         * If the XM driver can see the guest, it is definitely persistent */
+        currdom = xenXMDomainLookupByUUID(dom->conn, dom->uuid);
+        if (currdom)
+            ret = 1;
+        else
+            ret = 0;
+    } else {
+        /* New Xen with inactive domain management */
+        if (priv->opened[XEN_UNIFIED_XEND_OFFSET]) {
+            currdom = xenDaemonLookupByUUID(dom->conn, dom->uuid);
+            if (currdom) {
+                if (currdom->id == -1) {
+                    /* If its inactive, then trivially, it must be persistent */
+                    ret = 1;
+                } else {
+                    char *path;
+                    char uuidstr[VIR_UUID_STRING_BUFLEN];
+
+                    /* If its running there's no official way to tell, so we
+                     * go behind xend's back & look at the config dir */
+
+                    virUUIDFormat(dom->uuid, uuidstr);
+                    if (virAsprintf(&path, "%s/%s", XEND_DOMAINS_DIR, uuidstr) < 0) {
+                        virReportOOMError(NULL);
+                        goto done;
+                    }
+                    if (access(path, R_OK) == 0)
+                        ret = 1;
+                    else if (errno == ENOENT)
+                        ret = 0;
+                }
+            }
+        }
+    }
+
+done:
+    if (currdom)
+        virDomainFree(currdom);
+
+    return ret;
+}
+
 static int
 xenUnifiedDomainSuspend (virDomainPtr dom)
 {
@@ -1726,10 +1816,10 @@ static virDriver xenUnifiedDriver = {
     xenUnifiedNodeDeviceReAttach, /* nodeDeviceReAttach */
     xenUnifiedNodeDeviceReset, /* nodeDeviceReset */
     NULL, /* domainMigratePrepareTunnel */
-    NULL, /* isEncrypted */
-    NULL, /* isSecure */
-    NULL, /* domainIsActive */
-    NULL, /* domainIsEncrypted */
+    xenUnifiedIsEncrypted,
+    xenUnifiedIsSecure,
+    xenUnifiedDomainIsActive,
+    xenUnifiedDomainisPersistent,
 };
 
 /**
diff --git a/src/xen/xen_driver.h b/src/xen/xen_driver.h
index 9cc877b..185eb2b 100644
--- a/src/xen/xen_driver.h
+++ b/src/xen/xen_driver.h
@@ -49,6 +49,8 @@ extern int xenRegister (void);
 #define XEN_CONFIG_FORMAT_XM    "xen-xm"
 #define XEN_CONFIG_FORMAT_SEXPR "xen-sxpr"
 
+#define XEND_DOMAINS_DIR "/var/lib/xend/domains"
+
 /* _xenUnifiedDriver:
  *
  * Entry points into the underlying Xen drivers.  This structure
diff --git a/src/xen/xen_inotify.c b/src/xen/xen_inotify.c
index 9e0407f..d47565d 100644
--- a/src/xen/xen_inotify.c
+++ b/src/xen/xen_inotify.c
@@ -47,8 +47,6 @@
         virReportErrorHelper(NULL, VIR_FROM_XEN_INOTIFY, code, __FILE__,      \
                                __FUNCTION__, __LINE__, fmt)
 
-#define LIBVIRTD_DOMAINS_DIR "/var/lib/xend/domains"
-
 struct xenUnifiedDriver xenInotifyDriver = {
     xenInotifyOpen, /* open */
     xenInotifyClose, /* close */
@@ -125,7 +123,7 @@ xenInotifyXendDomainsDirLookup(virConnectPtr conn, const char *filename,
     * a filename in the manner:
     * /var/lib/xend/domains/<uuid>/
     */
-    uuid_str = filename + strlen(LIBVIRTD_DOMAINS_DIR) + 1;
+    uuid_str = filename + strlen(XEND_DOMAINS_DIR) + 1;
 
     if (virUUIDParse(uuid_str, rawuuid) < 0) {
         virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR,
@@ -198,7 +196,7 @@ static int
 xenInotifyXendDomainsDirRemoveEntry(virConnectPtr conn,
                                     const char *fname) {
     xenUnifiedPrivatePtr priv = conn->privateData;
-    const char *uuidstr = fname + strlen(LIBVIRTD_DOMAINS_DIR) + 1;
+    const char *uuidstr = fname + strlen(XEND_DOMAINS_DIR) + 1;
     unsigned char uuid[VIR_UUID_BUFLEN];
     int i;
 
@@ -393,7 +391,7 @@ xenInotifyOpen(virConnectPtr conn ATTRIBUTE_UNUSED,
         priv->useXenConfigCache = 1;
     } else {
         /* /var/lib/xend/domains/<uuid>/config.sxp */
-        priv->configDir = LIBVIRTD_DOMAINS_DIR;
+        priv->configDir = XEND_DOMAINS_DIR;
         priv->useXenConfigCache = 0;
 
         if (VIR_ALLOC(priv->configInfoList) < 0) {
diff --git a/src/xen/xen_inotify.h b/src/xen/xen_inotify.h
index 70bc63c..48490e7 100644
--- a/src/xen/xen_inotify.h
+++ b/src/xen/xen_inotify.h
@@ -31,4 +31,5 @@ virDrvOpenStatus	xenInotifyOpen	(virConnectPtr conn,
                                          virConnectAuthPtr auth,
                                          int flags);
 int		xenInotifyClose		(virConnectPtr conn);
+
 #endif
-- 
1.6.2.5


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]