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

[libvirt] [PATCH 4/6] Extend previous check to validate driver struct field names



From: "Daniel P. Berrange" <berrange redhat com>

Ensure that the driver struct field names match the public
API names. For an API virXXXX we must have a driver struct
field xXXXX. ie strip the leading 'vir' and lowercase any
leading uppercase letters.

Signed-off-by: Daniel P. Berrange <berrange redhat com>
---
 daemon/remote.c                         |   2 +-
 docs/apibuild.py                        |   2 +-
 docs/hvsupport.pl                       |  16 +-
 src/check-drivername.pl                 |  13 +
 src/datatypes.c                         |  14 +-
 src/driver.h                            | 262 +++++++++---------
 src/esx/esx_device_monitor.c            |   4 +-
 src/esx/esx_driver.c                    |  34 +--
 src/esx/esx_interface_driver.c          |  12 +-
 src/esx/esx_network_driver.c            |  12 +-
 src/esx/esx_nwfilter_driver.c           |   4 +-
 src/esx/esx_secret_driver.c             |   4 +-
 src/esx/esx_storage_backend_iscsi.c     |  36 +--
 src/esx/esx_storage_backend_vmfs.c      |  38 +--
 src/esx/esx_storage_driver.c            |  96 +++----
 src/fdstream.c                          |   6 +-
 src/hyperv/hyperv_device_monitor.c      |   4 +-
 src/hyperv/hyperv_driver.c              |  24 +-
 src/hyperv/hyperv_interface_driver.c    |   4 +-
 src/hyperv/hyperv_network_driver.c      |   4 +-
 src/hyperv/hyperv_nwfilter_driver.c     |   4 +-
 src/hyperv/hyperv_secret_driver.c       |   4 +-
 src/hyperv/hyperv_storage_driver.c      |   4 +-
 src/interface/interface_backend_netcf.c |  14 +-
 src/interface/interface_backend_udev.c  |  14 +-
 src/libvirt-qemu.c                      |  14 +-
 src/libvirt.c                           | 469 ++++++++++++++++----------------
 src/libvirt_internal.h                  |   2 +-
 src/libvirt_private.syms                |   2 +-
 src/libxl/libxl_driver.c                |  44 +--
 src/lxc/lxc_driver.c                    |  42 +--
 src/network/bridge_driver.c             |  20 +-
 src/node_device/node_device_hal.c       |  32 +--
 src/node_device/node_device_udev.c      |  32 +--
 src/nwfilter/nwfilter_driver.c          |  22 +-
 src/openvz/openvz_driver.c              |  30 +-
 src/parallels/parallels_driver.c        |  20 +-
 src/parallels/parallels_network.c       |  14 +-
 src/parallels/parallels_storage.c       |  66 ++---
 src/phyp/phyp_driver.c                  |  64 ++---
 src/qemu/qemu_command.c                 |   8 +-
 src/qemu/qemu_driver.c                  |  64 ++---
 src/qemu/qemu_process.c                 |  12 +-
 src/remote/remote_driver.c              | 248 ++++++++---------
 src/secret/secret_driver.c              |  30 +-
 src/storage/storage_backend.c           |  16 +-
 src/storage/storage_driver.c            |  94 +++----
 src/test/test_driver.c                  | 172 ++++++------
 src/uml/uml_driver.c                    |  42 +--
 src/vbox/vbox_driver.c                  |   2 +-
 src/vbox/vbox_tmpl.c                    |  96 +++----
 src/vmware/vmware_driver.c              |  22 +-
 src/xen/xen_driver.c                    |  44 +--
 src/xenapi/xenapi_driver.c              |  26 +-
 tests/qemuxml2argvtest.c                |  22 +-
 55 files changed, 1205 insertions(+), 1197 deletions(-)

diff --git a/daemon/remote.c b/daemon/remote.c
index cc2ecec..e5e3f2c 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -3732,7 +3732,7 @@ static int remoteDispatchConnectSupportsFeature(virNetServerPtr server ATTRIBUTE
         break;
 
     default:
-        if ((supported = virDrvSupportsFeature(priv->conn, args->feature)) < 0)
+        if ((supported = virConnectSupportsFeature(priv->conn, args->feature)) < 0)
             goto cleanup;
         break;
     }
diff --git a/docs/apibuild.py b/docs/apibuild.py
index df12ba6..d17b593 100755
--- a/docs/apibuild.py
+++ b/docs/apibuild.py
@@ -50,6 +50,7 @@ ignored_words = {
 }
 
 ignored_functions = {
+  "virConnectSupportsFeature": "private function for remote access",
   "virDomainMigrateFinish": "private function for migration",
   "virDomainMigrateFinish2": "private function for migration",
   "virDomainMigratePerform": "private function for migration",
@@ -62,7 +63,6 @@ ignored_functions = {
   "virDomainMigratePrepare3": "private function for migration",
   "virDomainMigrateConfirm3": "private function for migration",
   "virDomainMigratePrepareTunnel3": "private function for tunnelled migration",
-  "virDrvSupportsFeature": "private function for remote access",
   "DllMain": "specific function for Win32",
   "virTypedParameterArrayValidate": "internal function in virtypedparam.c",
   "virTypedParameterAssign": "internal function in virtypedparam.c",
diff --git a/docs/hvsupport.pl b/docs/hvsupport.pl
index d752d87..baebfc4 100755
--- a/docs/hvsupport.pl
+++ b/docs/hvsupport.pl
@@ -190,17 +190,13 @@ while (defined($line = <FILE>)) {
             $groups{$ingrp} = { apis => {}, drivers => {} };
         }
     } elsif ($ingrp) {
-        if ($line =~ /^\s*vir(?:Drv|DevMon)(\w+)\s+(\w+);\s*$/) {
+        if ($line =~ /^\s*vir(?:Drv)(\w+)\s+(\w+);\s*$/) {
             my $field = $2;
             my $name = $1;
 
             my $api;
             if (exists $apis{"vir$name"}) {
                 $api = "vir$name";
-            } elsif (exists $apis{"virConnect$name"}) {
-                $api = "virConnect$name";
-            } elsif (exists $apis{"virNode$name"}) {
-                $api = "virNode$name";
             } else {
                 die "driver $name does not have a public API";
             }
@@ -290,24 +286,24 @@ $groups{virDriver}->{apis}->{"domainMigrate"} = "virDomainMigrate";
 my $openAuthVers = (0 * 1000 * 1000) + (4 * 1000) + 0;
 
 foreach my $drv (keys %{$groups{"virDriver"}->{drivers}}) {
-    my $openVersStr = $groups{"virDriver"}->{drivers}->{$drv}->{"open"};
+    my $openVersStr = $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpen"};
     my $openVers;
     if ($openVersStr =~ /(\d+)\.(\d+)\.(\d+)/) {
         $openVers = ($1 * 1000 * 1000) + ($2 * 1000) + $3;
     }
 
     # virConnectOpenReadOnly always matches virConnectOpen version
-    $groups{"virDriver"}->{drivers}->{$drv}->{"openReadOnly"} =
-        $groups{"virDriver"}->{drivers}->{$drv}->{"open"};
+    $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenReadOnly"} =
+        $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpen"};
 
     # virConnectOpenAuth is always 0.4.0 if the driver existed
     # before this time, otherwise it matches the version of
     # the driver's virConnectOpen entry
     if ($openVersStr eq "Y" ||
         $openVers >= $openAuthVers) {
-        $groups{"virDriver"}->{drivers}->{$drv}->{"openAuth"} = $openVersStr;
+        $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenAuth"} = $openVersStr;
     } else {
-        $groups{"virDriver"}->{drivers}->{$drv}->{"openAuth"} = "0.4.0";
+        $groups{"virDriver"}->{drivers}->{$drv}->{"connectOpenAuth"} = "0.4.0";
     }
 }
 
diff --git a/src/check-drivername.pl b/src/check-drivername.pl
index f92316d..459c661 100644
--- a/src/check-drivername.pl
+++ b/src/check-drivername.pl
@@ -45,6 +45,19 @@ while (<DRVFILE>) {
         my $name = $1;
         print "Bogus name $1\n";
         $status = 1;
+    } elsif (/^\s*(virDrv\w+)\s+(\w+);\s*/) {
+        my $drv = $1;
+        my $field = $2;
+
+        my $tmp = $drv;
+        $tmp =~ s/virDrv//;
+        $tmp =~ s/^NWFilter/nwfilter/;
+        $tmp =~ s/^(\w)/lc $1/e;
+
+        unless ($tmp eq $field) {
+            print "Driver struct field $field should be named $tmp\n";
+            $status = 1;
+        }
     }
 }
 
diff --git a/src/datatypes.c b/src/datatypes.c
index b21daac..f8b6f49 100644
--- a/src/datatypes.c
+++ b/src/datatypes.c
@@ -144,19 +144,19 @@ virConnectDispose(void *obj)
     virConnectPtr conn = obj;
 
     if (conn->networkDriver)
-        conn->networkDriver->close(conn);
+        conn->networkDriver->connectClose(conn);
     if (conn->interfaceDriver)
-        conn->interfaceDriver->close(conn);
+        conn->interfaceDriver->connectClose(conn);
     if (conn->storageDriver)
-        conn->storageDriver->close(conn);
+        conn->storageDriver->connectClose(conn);
     if (conn->deviceMonitor)
-        conn->deviceMonitor->close(conn);
+        conn->deviceMonitor->connectClose(conn);
     if (conn->secretDriver)
-        conn->secretDriver->close(conn);
+        conn->secretDriver->connectClose(conn);
     if (conn->nwfilterDriver)
-        conn->nwfilterDriver->close(conn);
+        conn->nwfilterDriver->connectClose(conn);
     if (conn->driver)
-        conn->driver->close(conn);
+        conn->driver->connectClose(conn);
 
     virMutexLock(&conn->lock);
 
diff --git a/src/driver.h b/src/driver.h
index 2ca244c..8c1a9d1 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -63,8 +63,8 @@ typedef enum {
  *   0     Feature is not supported.
  */
 # define VIR_DRV_SUPPORTS_FEATURE(drv,conn,feature)                         \
-    ((drv)->supports_feature ?                                              \
-        (drv)->supports_feature((conn), (feature)) > 0 : 0)
+    ((drv)->connectSupportsFeature ?                                              \
+        (drv)->connectSupportsFeature((conn), (feature)) > 0 : 0)
 
 typedef virDrvOpenStatus
         (*virDrvConnectOpen)    (virConnectPtr conn,
@@ -956,20 +956,20 @@ typedef int
 struct _virDriver {
     int                                 no;    /* the number virDrvNo */
     const char                          *name; /* the name of the driver */
-    virDrvConnectOpen                          open;
-    virDrvConnectClose                         close;
-    virDrvConnectSupportsFeature            supports_feature;
-    virDrvConnectGetType                       type;
-    virDrvConnectGetVersion                    version;
-    virDrvConnectGetLibVersion                 libvirtVersion;
-    virDrvConnectGetHostname                   getHostname;
-    virDrvConnectGetSysinfo                    getSysinfo;
-    virDrvConnectGetMaxVcpus                   getMaxVcpus;
+    virDrvConnectOpen                         connectOpen;
+    virDrvConnectClose                        connectClose;
+    virDrvConnectSupportsFeature            connectSupportsFeature;
+    virDrvConnectGetType                       connectGetType;
+    virDrvConnectGetVersion                    connectGetVersion;
+    virDrvConnectGetLibVersion                 connectGetLibVersion;
+    virDrvConnectGetHostname                   connectGetHostname;
+    virDrvConnectGetSysinfo                    connectGetSysinfo;
+    virDrvConnectGetMaxVcpus                   connectGetMaxVcpus;
     virDrvNodeGetInfo                   nodeGetInfo;
-    virDrvConnectGetCapabilities               getCapabilities;
-    virDrvConnectListDomains                   listDomains;
-    virDrvConnectNumOfDomains                  numOfDomains;
-    virDrvConnectListAllDomains                listAllDomains;
+    virDrvConnectGetCapabilities               connectGetCapabilities;
+    virDrvConnectListDomains                   connectListDomains;
+    virDrvConnectNumOfDomains                  connectNumOfDomains;
+    virDrvConnectListAllDomains                connectListAllDomains;
     virDrvDomainCreateXML               domainCreateXML;
     virDrvDomainLookupByID              domainLookupByID;
     virDrvDomainLookupByUUID            domainLookupByUUID;
@@ -1021,10 +1021,10 @@ struct _virDriver {
     virDrvDomainGetSecurityLabelList     domainGetSecurityLabelList;
     virDrvNodeGetSecurityModel          nodeGetSecurityModel;
     virDrvDomainGetXMLDesc              domainGetXMLDesc;
-    virDrvConnectDomainXMLFromNative    domainXMLFromNative;
-    virDrvConnectDomainXMLToNative      domainXMLToNative;
-    virDrvConnectListDefinedDomains            listDefinedDomains;
-    virDrvConnectNumOfDefinedDomains           numOfDefinedDomains;
+    virDrvConnectDomainXMLFromNative    connectDomainXMLFromNative;
+    virDrvConnectDomainXMLToNative      connectDomainXMLToNative;
+    virDrvConnectListDefinedDomains            connectListDefinedDomains;
+    virDrvConnectNumOfDefinedDomains           connectNumOfDefinedDomains;
     virDrvDomainCreate                  domainCreate;
     virDrvDomainCreateWithFlags         domainCreateWithFlags;
     virDrvDomainDefineXML               domainDefineXML;
@@ -1059,21 +1059,21 @@ struct _virDriver {
     virDrvNodeGetMemoryStats            nodeGetMemoryStats;
     virDrvNodeGetCellsFreeMemory        nodeGetCellsFreeMemory;
     virDrvNodeGetFreeMemory             nodeGetFreeMemory;
-    virDrvConnectDomainEventRegister           domainEventRegister;
-    virDrvConnectDomainEventDeregister         domainEventDeregister;
+    virDrvConnectDomainEventRegister           connectDomainEventRegister;
+    virDrvConnectDomainEventDeregister         connectDomainEventDeregister;
     virDrvDomainMigratePrepare2         domainMigratePrepare2;
     virDrvDomainMigrateFinish2          domainMigrateFinish2;
     virDrvNodeDeviceDettach             nodeDeviceDettach;
     virDrvNodeDeviceReAttach            nodeDeviceReAttach;
     virDrvNodeDeviceReset               nodeDeviceReset;
     virDrvDomainMigratePrepareTunnel    domainMigratePrepareTunnel;
-    virDrvConnectIsEncrypted            isEncrypted;
-    virDrvConnectIsSecure               isSecure;
+    virDrvConnectIsEncrypted            connectIsEncrypted;
+    virDrvConnectIsSecure               connectIsSecure;
     virDrvDomainIsActive                domainIsActive;
     virDrvDomainIsPersistent            domainIsPersistent;
     virDrvDomainIsUpdated               domainIsUpdated;
-    virDrvConnectCompareCPU                    cpuCompare;
-    virDrvConnectBaselineCPU                   cpuBaseline;
+    virDrvConnectCompareCPU                    connectCompareCPU;
+    virDrvConnectBaselineCPU                   connectBaselineCPU;
     virDrvDomainGetJobInfo              domainGetJobInfo;
     virDrvDomainGetJobStats             domainGetJobStats;
     virDrvDomainAbortJob                domainAbortJob;
@@ -1082,8 +1082,8 @@ struct _virDriver {
     virDrvDomainMigrateSetCompressionCache domainMigrateSetCompressionCache;
     virDrvDomainMigrateGetMaxSpeed      domainMigrateGetMaxSpeed;
     virDrvDomainMigrateSetMaxSpeed      domainMigrateSetMaxSpeed;
-    virDrvConnectDomainEventRegisterAny        domainEventRegisterAny;
-    virDrvConnectDomainEventDeregisterAny      domainEventDeregisterAny;
+    virDrvConnectDomainEventRegisterAny        connectDomainEventRegisterAny;
+    virDrvConnectDomainEventDeregisterAny      connectDomainEventDeregisterAny;
     virDrvDomainManagedSave             domainManagedSave;
     virDrvDomainHasManagedSaveImage     domainHasManagedSaveImage;
     virDrvDomainManagedSaveRemove       domainManagedSaveRemove;
@@ -1103,9 +1103,9 @@ struct _virDriver {
     virDrvDomainSnapshotHasMetadata     domainSnapshotHasMetadata;
     virDrvDomainRevertToSnapshot        domainRevertToSnapshot;
     virDrvDomainSnapshotDelete          domainSnapshotDelete;
-    virDrvDomainQemuMonitorCommand      qemuDomainMonitorCommand;
-    virDrvDomainQemuAttach              qemuDomainAttach;
-    virDrvDomainQemuAgentCommand        qemuDomainArbitraryAgentCommand;
+    virDrvDomainQemuMonitorCommand      domainQemuMonitorCommand;
+    virDrvDomainQemuAttach              domainQemuAttach;
+    virDrvDomainQemuAgentCommand        domainQemuAgentCommand;
     virDrvDomainOpenConsole             domainOpenConsole;
     virDrvDomainOpenChannel             domainOpenChannel;
     virDrvDomainOpenGraphics            domainOpenGraphics;
@@ -1123,8 +1123,8 @@ struct _virDriver {
     virDrvDomainBlockPull               domainBlockPull;
     virDrvDomainBlockRebase             domainBlockRebase;
     virDrvDomainBlockCommit             domainBlockCommit;
-    virDrvConnectSetKeepAlive                  setKeepAlive;
-    virDrvConnectIsAlive                isAlive;
+    virDrvConnectSetKeepAlive                  connectSetKeepAlive;
+    virDrvConnectIsAlive                connectIsAlive;
     virDrvNodeSuspendForDuration        nodeSuspendForDuration;
     virDrvDomainSetBlockIoTune          domainSetBlockIoTune;
     virDrvDomainGetBlockIoTune          domainGetBlockIoTune;
@@ -1215,13 +1215,13 @@ typedef virNetworkDriver *virNetworkDriverPtr;
  */
 struct _virNetworkDriver {
         const char * name;  /* the name of the driver */
-        virDrvConnectOpen                  open;
-        virDrvConnectClose                 close;
-        virDrvConnectNumOfNetworks         numOfNetworks;
-        virDrvConnectListNetworks          listNetworks;
-        virDrvConnectNumOfDefinedNetworks  numOfDefinedNetworks;
-        virDrvConnectListDefinedNetworks   listDefinedNetworks;
-        virDrvConnectListAllNetworks       listAllNetworks;
+        virDrvConnectOpen                 connectOpen;
+        virDrvConnectClose                connectClose;
+        virDrvConnectNumOfNetworks         connectNumOfNetworks;
+        virDrvConnectListNetworks          connectListNetworks;
+        virDrvConnectNumOfDefinedNetworks  connectNumOfDefinedNetworks;
+        virDrvConnectListDefinedNetworks   connectListDefinedNetworks;
+        virDrvConnectListAllNetworks       connectListAllNetworks;
         virDrvNetworkLookupByUUID   networkLookupByUUID;
         virDrvNetworkLookupByName   networkLookupByName;
         virDrvNetworkCreateXML      networkCreateXML;
@@ -1307,13 +1307,13 @@ typedef virInterfaceDriver *virInterfaceDriverPtr;
  */
 struct _virInterfaceDriver {
     const char                      *name; /* the name of the driver */
-    virDrvConnectOpen                       open;
-    virDrvConnectClose                      close;
-    virDrvConnectNumOfInterfaces            numOfInterfaces;
-    virDrvConnectListInterfaces             listInterfaces;
-    virDrvConnectNumOfDefinedInterfaces     numOfDefinedInterfaces;
-    virDrvConnectListDefinedInterfaces      listDefinedInterfaces;
-    virDrvConnectListAllInterfaces          listAllInterfaces;
+    virDrvConnectOpen                      connectOpen;
+    virDrvConnectClose                     connectClose;
+    virDrvConnectNumOfInterfaces            connectNumOfInterfaces;
+    virDrvConnectListInterfaces             connectListInterfaces;
+    virDrvConnectNumOfDefinedInterfaces     connectNumOfDefinedInterfaces;
+    virDrvConnectListDefinedInterfaces      connectListDefinedInterfaces;
+    virDrvConnectListAllInterfaces          connectListAllInterfaces;
     virDrvInterfaceLookupByName      interfaceLookupByName;
     virDrvInterfaceLookupByMACString interfaceLookupByMACString;
     virDrvInterfaceGetXMLDesc        interfaceGetXMLDesc;
@@ -1484,50 +1484,50 @@ typedef virStorageDriver *virStorageDriverPtr;
  */
 struct _virStorageDriver {
     const char * name;    /* the name of the driver */
-    virDrvConnectOpen                              open;
-    virDrvConnectClose                             close;
-
-    virDrvConnectNumOfStoragePools          numOfPools;
-    virDrvConnectListStoragePools           listPools;
-    virDrvConnectNumOfDefinedStoragePools   numOfDefinedPools;
-    virDrvConnectListDefinedStoragePools    listDefinedPools;
-    virDrvConnectListAllStoragePools        listAllPools;
-    virDrvConnectFindStoragePoolSources     findPoolSources;
-    virDrvStoragePoolLookupByName           poolLookupByName;
-    virDrvStoragePoolLookupByUUID           poolLookupByUUID;
-    virDrvStoragePoolLookupByVolume         poolLookupByVolume;
-    virDrvStoragePoolCreateXML              poolCreateXML;
-    virDrvStoragePoolDefineXML              poolDefineXML;
-    virDrvStoragePoolBuild                  poolBuild;
-    virDrvStoragePoolUndefine               poolUndefine;
-    virDrvStoragePoolCreate                 poolCreate;
-    virDrvStoragePoolDestroy                poolDestroy;
-    virDrvStoragePoolDelete                 poolDelete;
-    virDrvStoragePoolRefresh                poolRefresh;
-    virDrvStoragePoolGetInfo                poolGetInfo;
-    virDrvStoragePoolGetXMLDesc             poolGetXMLDesc;
-    virDrvStoragePoolGetAutostart           poolGetAutostart;
-    virDrvStoragePoolSetAutostart           poolSetAutostart;
-    virDrvStoragePoolNumOfVolumes           poolNumOfVolumes;
-    virDrvStoragePoolListVolumes            poolListVolumes;
-    virDrvStoragePoolListAllVolumes         poolListAllVolumes;
-
-    virDrvStorageVolLookupByName            volLookupByName;
-    virDrvStorageVolLookupByKey             volLookupByKey;
-    virDrvStorageVolLookupByPath            volLookupByPath;
-    virDrvStorageVolCreateXML               volCreateXML;
-    virDrvStorageVolCreateXMLFrom           volCreateXMLFrom;
-    virDrvStorageVolDownload                volDownload;
-    virDrvStorageVolUpload                  volUpload;
-    virDrvStorageVolDelete                  volDelete;
-    virDrvStorageVolWipe                    volWipe;
-    virDrvStorageVolWipePattern             volWipePattern;
-    virDrvStorageVolGetInfo                 volGetInfo;
-    virDrvStorageVolGetXMLDesc              volGetXMLDesc;
-    virDrvStorageVolGetPath                 volGetPath;
-    virDrvStorageVolResize                  volResize;
-    virDrvStoragePoolIsActive               poolIsActive;
-    virDrvStoragePoolIsPersistent           poolIsPersistent;
+    virDrvConnectOpen                             connectOpen;
+    virDrvConnectClose                            connectClose;
+
+    virDrvConnectNumOfStoragePools          connectNumOfStoragePools;
+    virDrvConnectListStoragePools           connectListStoragePools;
+    virDrvConnectNumOfDefinedStoragePools   connectNumOfDefinedStoragePools;
+    virDrvConnectListDefinedStoragePools    connectListDefinedStoragePools;
+    virDrvConnectListAllStoragePools        connectListAllStoragePools;
+    virDrvConnectFindStoragePoolSources     connectFindStoragePoolSources;
+    virDrvStoragePoolLookupByName           storagePoolLookupByName;
+    virDrvStoragePoolLookupByUUID           storagePoolLookupByUUID;
+    virDrvStoragePoolLookupByVolume         storagePoolLookupByVolume;
+    virDrvStoragePoolCreateXML              storagePoolCreateXML;
+    virDrvStoragePoolDefineXML              storagePoolDefineXML;
+    virDrvStoragePoolBuild                  storagePoolBuild;
+    virDrvStoragePoolUndefine               storagePoolUndefine;
+    virDrvStoragePoolCreate                 storagePoolCreate;
+    virDrvStoragePoolDestroy                storagePoolDestroy;
+    virDrvStoragePoolDelete                 storagePoolDelete;
+    virDrvStoragePoolRefresh                storagePoolRefresh;
+    virDrvStoragePoolGetInfo                storagePoolGetInfo;
+    virDrvStoragePoolGetXMLDesc             storagePoolGetXMLDesc;
+    virDrvStoragePoolGetAutostart           storagePoolGetAutostart;
+    virDrvStoragePoolSetAutostart           storagePoolSetAutostart;
+    virDrvStoragePoolNumOfVolumes           storagePoolNumOfVolumes;
+    virDrvStoragePoolListVolumes            storagePoolListVolumes;
+    virDrvStoragePoolListAllVolumes         storagePoolListAllVolumes;
+
+    virDrvStorageVolLookupByName            storageVolLookupByName;
+    virDrvStorageVolLookupByKey             storageVolLookupByKey;
+    virDrvStorageVolLookupByPath            storageVolLookupByPath;
+    virDrvStorageVolCreateXML               storageVolCreateXML;
+    virDrvStorageVolCreateXMLFrom           storageVolCreateXMLFrom;
+    virDrvStorageVolDownload                storageVolDownload;
+    virDrvStorageVolUpload                  storageVolUpload;
+    virDrvStorageVolDelete                  storageVolDelete;
+    virDrvStorageVolWipe                    storageVolWipe;
+    virDrvStorageVolWipePattern             storageVolWipePattern;
+    virDrvStorageVolGetInfo                 storageVolGetInfo;
+    virDrvStorageVolGetXMLDesc              storageVolGetXMLDesc;
+    virDrvStorageVolGetPath                 storageVolGetPath;
+    virDrvStorageVolResize                  storageVolResize;
+    virDrvStoragePoolIsActive               storagePoolIsActive;
+    virDrvStoragePoolIsPersistent           storagePoolIsPersistent;
 };
 
 # ifdef WITH_LIBVIRTD
@@ -1544,10 +1544,10 @@ typedef virStateDriver *virStateDriverPtr;
 
 struct _virStateDriver {
     const char *name;
-    virDrvStateInitialize  initialize;
-    virDrvStateCleanup     cleanup;
-    virDrvStateReload      reload;
-    virDrvStateStop        stop;
+    virDrvStateInitialize  stateInitialize;
+    virDrvStateCleanup     stateCleanup;
+    virDrvStateReload      stateReload;
+    virDrvStateStop        stateStop;
 };
 # endif
 
@@ -1601,19 +1601,19 @@ typedef int (*virDrvNodeDeviceDestroy)(virNodeDevicePtr dev);
  */
 struct _virDeviceMonitor {
     const char * name;    /* the name of the driver */
-    virDrvConnectOpen                 open;
-    virDrvConnectClose                close;
-    virDrvNodeNumOfDevices       numOfDevices;
-    virDrvNodeListDevices        listDevices;
-    virDrvConnectListAllNodeDevices listAllNodeDevices;
-    virDrvNodeDeviceLookupByName deviceLookupByName;
-    virDrvNodeDeviceLookupSCSIHostByWWN  deviceLookupSCSIHostByWWN;
-    virDrvNodeDeviceGetXMLDesc   deviceGetXMLDesc;
-    virDrvNodeDeviceGetParent    deviceGetParent;
-    virDrvNodeDeviceNumOfCaps    deviceNumOfCaps;
-    virDrvNodeDeviceListCaps     deviceListCaps;
-    virDrvNodeDeviceCreateXML   deviceCreateXML;
-    virDrvNodeDeviceDestroy     deviceDestroy;
+    virDrvConnectOpen                 connectOpen;
+    virDrvConnectClose                connectClose;
+    virDrvNodeNumOfDevices       nodeNumOfDevices;
+    virDrvNodeListDevices        nodeListDevices;
+    virDrvConnectListAllNodeDevices connectListAllNodeDevices;
+    virDrvNodeDeviceLookupByName nodeDeviceLookupByName;
+    virDrvNodeDeviceLookupSCSIHostByWWN  nodeDeviceLookupSCSIHostByWWN;
+    virDrvNodeDeviceGetXMLDesc   nodeDeviceGetXMLDesc;
+    virDrvNodeDeviceGetParent    nodeDeviceGetParent;
+    virDrvNodeDeviceNumOfCaps    nodeDeviceNumOfCaps;
+    virDrvNodeDeviceListCaps     nodeDeviceListCaps;
+    virDrvNodeDeviceCreateXML   nodeDeviceCreateXML;
+    virDrvNodeDeviceDestroy     nodeDeviceDestroy;
 };
 
 enum {
@@ -1674,19 +1674,19 @@ typedef virSecretDriver *virSecretDriverPtr;
  */
 struct _virSecretDriver {
     const char *name;
-    virDrvConnectOpen                  open;
-    virDrvConnectClose                 close;
-
-    virDrvConnectNumOfSecrets          numOfSecrets;
-    virDrvConnectListSecrets           listSecrets;
-    virDrvConnectListAllSecrets        listAllSecrets;
-    virDrvSecretLookupByUUID    lookupByUUID;
-    virDrvSecretLookupByUsage   lookupByUsage;
-    virDrvSecretDefineXML       defineXML;
-    virDrvSecretGetXMLDesc      getXMLDesc;
-    virDrvSecretSetValue        setValue;
-    virDrvSecretGetValue        getValue;
-    virDrvSecretUndefine        undefine;
+    virDrvConnectOpen                 connectOpen;
+    virDrvConnectClose                connectClose;
+
+    virDrvConnectNumOfSecrets          connectNumOfSecrets;
+    virDrvConnectListSecrets           connectListSecrets;
+    virDrvConnectListAllSecrets        connectListAllSecrets;
+    virDrvSecretLookupByUUID    secretLookupByUUID;
+    virDrvSecretLookupByUsage   secretLookupByUsage;
+    virDrvSecretDefineXML       secretDefineXML;
+    virDrvSecretGetXMLDesc      secretGetXMLDesc;
+    virDrvSecretSetValue        secretSetValue;
+    virDrvSecretGetValue        secretGetValue;
+    virDrvSecretUndefine        secretUndefine;
 };
 
 
@@ -1716,9 +1716,9 @@ typedef int (*virDrvStreamAbort)(virStreamPtr st);
 struct _virStreamDriver {
     virDrvStreamSend                streamSend;
     virDrvStreamRecv                streamRecv;
-    virDrvStreamEventAddCallback    streamAddCallback;
-    virDrvStreamEventUpdateCallback streamUpdateCallback;
-    virDrvStreamEventRemoveCallback streamRemoveCallback;
+    virDrvStreamEventAddCallback    streamEventAddCallback;
+    virDrvStreamEventUpdateCallback streamEventUpdateCallback;
+    virDrvStreamEventRemoveCallback streamEventRemoveCallback;
     virDrvStreamFinish              streamFinish;
     virDrvStreamAbort               streamAbort;
 };
@@ -1766,17 +1766,17 @@ typedef virNWFilterDriver *virNWFilterDriverPtr;
  */
 struct _virNWFilterDriver {
     const char * name;    /* the name of the driver */
-    virDrvConnectOpen                  open;
-    virDrvConnectClose                 close;
+    virDrvConnectOpen                 connectOpen;
+    virDrvConnectClose                connectClose;
 
-    virDrvConnectNumOfNWFilters numOfNWFilters;
-    virDrvConnectListNWFilters  listNWFilters;
-    virDrvConnectListAllNWFilters  listAllNWFilters;
+    virDrvConnectNumOfNWFilters connectNumOfNWFilters;
+    virDrvConnectListNWFilters  connectListNWFilters;
+    virDrvConnectListAllNWFilters  connectListAllNWFilters;
     virDrvNWFilterLookupByName  nwfilterLookupByName;
     virDrvNWFilterLookupByUUID  nwfilterLookupByUUID;
-    virDrvNWFilterDefineXML     defineXML;
-    virDrvNWFilterUndefine      undefine;
-    virDrvNWFilterGetXMLDesc    getXMLDesc;
+    virDrvNWFilterDefineXML     nwfilterDefineXML;
+    virDrvNWFilterUndefine      nwfilterUndefine;
+    virDrvNWFilterGetXMLDesc    nwfilterGetXMLDesc;
 };
 
 
diff --git a/src/esx/esx_device_monitor.c b/src/esx/esx_device_monitor.c
index f6c85ba..826b171 100644
--- a/src/esx/esx_device_monitor.c
+++ b/src/esx/esx_device_monitor.c
@@ -69,8 +69,8 @@ esxDeviceClose(virConnectPtr conn)
 
 static virDeviceMonitor esxDeviceMonitor = {
     .name = "ESX",
-    .open = esxDeviceOpen, /* 0.7.6 */
-    .close = esxDeviceClose, /* 0.7.6 */
+    .connectOpen = esxDeviceOpen, /* 0.7.6 */
+    .connectClose = esxDeviceClose, /* 0.7.6 */
 };
 
 
diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c
index 4828209..40b9f7f 100644
--- a/src/esx/esx_driver.c
+++ b/src/esx/esx_driver.c
@@ -5236,17 +5236,17 @@ no_memory:
 static virDriver esxDriver = {
     .no = VIR_DRV_ESX,
     .name = "ESX",
-    .open = esxOpen, /* 0.7.0 */
-    .close = esxClose, /* 0.7.0 */
-    .supports_feature = esxSupportsFeature, /* 0.7.0 */
-    .type = esxGetType, /* 0.7.0 */
-    .version = esxGetVersion, /* 0.7.0 */
-    .getHostname = esxGetHostname, /* 0.7.0 */
+    .connectOpen = esxOpen, /* 0.7.0 */
+    .connectClose = esxClose, /* 0.7.0 */
+    .connectSupportsFeature = esxSupportsFeature, /* 0.7.0 */
+    .connectGetType = esxGetType, /* 0.7.0 */
+    .connectGetVersion = esxGetVersion, /* 0.7.0 */
+    .connectGetHostname = esxGetHostname, /* 0.7.0 */
     .nodeGetInfo = esxNodeGetInfo, /* 0.7.0 */
-    .getCapabilities = esxGetCapabilities, /* 0.7.1 */
-    .listDomains = esxListDomains, /* 0.7.0 */
-    .numOfDomains = esxNumberOfDomains, /* 0.7.0 */
-    .listAllDomains = esxListAllDomains, /* 0.10.2 */
+    .connectGetCapabilities = esxGetCapabilities, /* 0.7.1 */
+    .connectListDomains = esxListDomains, /* 0.7.0 */
+    .connectNumOfDomains = esxNumberOfDomains, /* 0.7.0 */
+    .connectListAllDomains = esxListAllDomains, /* 0.10.2 */
     .domainLookupByID = esxDomainLookupByID, /* 0.7.0 */
     .domainLookupByUUID = esxDomainLookupByUUID, /* 0.7.0 */
     .domainLookupByName = esxDomainLookupByName, /* 0.7.0 */
@@ -5270,10 +5270,10 @@ static virDriver esxDriver = {
     .domainGetVcpusFlags = esxDomainGetVcpusFlags, /* 0.8.5 */
     .domainGetMaxVcpus = esxDomainGetMaxVcpus, /* 0.7.0 */
     .domainGetXMLDesc = esxDomainGetXMLDesc, /* 0.7.0 */
-    .domainXMLFromNative = esxDomainXMLFromNative, /* 0.7.0 */
-    .domainXMLToNative = esxDomainXMLToNative, /* 0.7.2 */
-    .listDefinedDomains = esxListDefinedDomains, /* 0.7.0 */
-    .numOfDefinedDomains = esxNumberOfDefinedDomains, /* 0.7.0 */
+    .connectDomainXMLFromNative = esxDomainXMLFromNative, /* 0.7.0 */
+    .connectDomainXMLToNative = esxDomainXMLToNative, /* 0.7.2 */
+    .connectListDefinedDomains = esxListDefinedDomains, /* 0.7.0 */
+    .connectNumOfDefinedDomains = esxNumberOfDefinedDomains, /* 0.7.0 */
     .domainCreate = esxDomainCreate, /* 0.7.0 */
     .domainCreateWithFlags = esxDomainCreateWithFlags, /* 0.8.2 */
     .domainDefineXML = esxDomainDefineXML, /* 0.7.2 */
@@ -5290,8 +5290,8 @@ static virDriver esxDriver = {
     .domainMigratePerform = esxDomainMigratePerform, /* 0.7.0 */
     .domainMigrateFinish = esxDomainMigrateFinish, /* 0.7.0 */
     .nodeGetFreeMemory = esxNodeGetFreeMemory, /* 0.7.2 */
-    .isEncrypted = esxIsEncrypted, /* 0.7.3 */
-    .isSecure = esxIsSecure, /* 0.7.3 */
+    .connectIsEncrypted = esxIsEncrypted, /* 0.7.3 */
+    .connectIsSecure = esxIsSecure, /* 0.7.3 */
     .domainIsActive = esxDomainIsActive, /* 0.7.3 */
     .domainIsPersistent = esxDomainIsPersistent, /* 0.7.3 */
     .domainIsUpdated = esxDomainIsUpdated, /* 0.8.6 */
@@ -5309,7 +5309,7 @@ static virDriver esxDriver = {
     .domainSnapshotIsCurrent = esxDomainSnapshotIsCurrent, /* 0.9.13 */
     .domainSnapshotHasMetadata = esxDomainSnapshotHasMetadata, /* 0.9.13 */
     .domainSnapshotDelete = esxDomainSnapshotDelete, /* 0.8.0 */
-    .isAlive = esxIsAlive, /* 0.9.8 */
+    .connectIsAlive = esxIsAlive, /* 0.9.8 */
 };
 
 
diff --git a/src/esx/esx_interface_driver.c b/src/esx/esx_interface_driver.c
index 53c179b..ec19051 100644
--- a/src/esx/esx_interface_driver.c
+++ b/src/esx/esx_interface_driver.c
@@ -298,12 +298,12 @@ esxInterfaceIsActive(virInterfacePtr iface ATTRIBUTE_UNUSED)
 
 static virInterfaceDriver esxInterfaceDriver = {
     .name = "ESX",
-    .open = esxInterfaceOpen, /* 0.7.6 */
-    .close = esxInterfaceClose, /* 0.7.6 */
-    .numOfInterfaces = esxNumberOfInterfaces, /* 0.10.0 */
-    .listInterfaces = esxListInterfaces, /* 0.10.0 */
-    .numOfDefinedInterfaces = esxNumberOfDefinedInterfaces, /* 0.10.0 */
-    .listDefinedInterfaces = esxListDefinedInterfaces, /* 0.10.0 */
+    .connectOpen = esxInterfaceOpen, /* 0.7.6 */
+    .connectClose = esxInterfaceClose, /* 0.7.6 */
+    .connectNumOfInterfaces = esxNumberOfInterfaces, /* 0.10.0 */
+    .connectListInterfaces = esxListInterfaces, /* 0.10.0 */
+    .connectNumOfDefinedInterfaces = esxNumberOfDefinedInterfaces, /* 0.10.0 */
+    .connectListDefinedInterfaces = esxListDefinedInterfaces, /* 0.10.0 */
     .interfaceLookupByName = esxInterfaceLookupByName, /* 0.10.0 */
     .interfaceLookupByMACString = esxInterfaceLookupByMACString, /* 0.10.0 */
     .interfaceGetXMLDesc = esxInterfaceGetXMLDesc, /* 0.10.0 */
diff --git a/src/esx/esx_network_driver.c b/src/esx/esx_network_driver.c
index 48763d4..c657c82 100644
--- a/src/esx/esx_network_driver.c
+++ b/src/esx/esx_network_driver.c
@@ -933,12 +933,12 @@ esxNetworkIsPersistent(virNetworkPtr network ATTRIBUTE_UNUSED)
 
 static virNetworkDriver esxNetworkDriver = {
     .name = "ESX",
-    .open = esxNetworkOpen, /* 0.7.6 */
-    .close = esxNetworkClose, /* 0.7.6 */
-    .numOfNetworks = esxNumberOfNetworks, /* 0.10.0 */
-    .listNetworks = esxListNetworks, /* 0.10.0 */
-    .numOfDefinedNetworks = esxNumberOfDefinedNetworks, /* 0.10.0 */
-    .listDefinedNetworks = esxListDefinedNetworks, /* 0.10.0 */
+    .connectOpen = esxNetworkOpen, /* 0.7.6 */
+    .connectClose = esxNetworkClose, /* 0.7.6 */
+    .connectNumOfNetworks = esxNumberOfNetworks, /* 0.10.0 */
+    .connectListNetworks = esxListNetworks, /* 0.10.0 */
+    .connectNumOfDefinedNetworks = esxNumberOfDefinedNetworks, /* 0.10.0 */
+    .connectListDefinedNetworks = esxListDefinedNetworks, /* 0.10.0 */
     .networkLookupByUUID = esxNetworkLookupByUUID, /* 0.10.0 */
     .networkLookupByName = esxNetworkLookupByName, /* 0.10.0 */
     .networkDefineXML = esxNetworkDefineXML, /* 0.10.0 */
diff --git a/src/esx/esx_nwfilter_driver.c b/src/esx/esx_nwfilter_driver.c
index c59929c..1181c33 100644
--- a/src/esx/esx_nwfilter_driver.c
+++ b/src/esx/esx_nwfilter_driver.c
@@ -69,8 +69,8 @@ esxNWFilterClose(virConnectPtr conn)
 
 static virNWFilterDriver esxNWFilterDriver = {
     .name = "ESX",
-    .open = esxNWFilterOpen, /* 0.8.1 */
-    .close = esxNWFilterClose, /* 0.8.1 */
+    .connectOpen = esxNWFilterOpen, /* 0.8.1 */
+    .connectClose = esxNWFilterClose, /* 0.8.1 */
 };
 
 
diff --git a/src/esx/esx_secret_driver.c b/src/esx/esx_secret_driver.c
index 92cbb14..a840895 100644
--- a/src/esx/esx_secret_driver.c
+++ b/src/esx/esx_secret_driver.c
@@ -67,8 +67,8 @@ esxSecretClose(virConnectPtr conn)
 
 static virSecretDriver esxSecretDriver = {
     .name = "ESX",
-    .open = esxSecretOpen, /* 0.7.6 */
-    .close = esxSecretClose, /* 0.7.6 */
+    .connectOpen = esxSecretOpen, /* 0.7.6 */
+    .connectClose = esxSecretClose, /* 0.7.6 */
 };
 
 
diff --git a/src/esx/esx_storage_backend_iscsi.c b/src/esx/esx_storage_backend_iscsi.c
index e09fa55..a3336a2 100644
--- a/src/esx/esx_storage_backend_iscsi.c
+++ b/src/esx/esx_storage_backend_iscsi.c
@@ -753,22 +753,22 @@ esxStorageBackendISCSIVolumeGetPath(virStorageVolPtr volume)
 
 
 virStorageDriver esxStorageBackendISCSI = {
-    .numOfPools = esxStorageBackendISCSINumberOfPools, /* 1.0.1 */
-    .listPools = esxStorageBackendISCSIListPools, /* 1.0.1 */
-    .poolLookupByName = esxStorageBackendISCSIPoolLookupByName, /* 1.0.1 */
-    .poolLookupByUUID = esxStorageBackendISCSIPoolLookupByUUID, /* 1.0.1 */
-    .poolRefresh = esxStorageBackendISCSIPoolRefresh, /* 1.0.1 */
-    .poolGetInfo = esxStorageBackendISCSIPoolGetInfo, /* 1.0.1 */
-    .poolGetXMLDesc = esxStorageBackendISCSIPoolGetXMLDesc, /* 1.0.1 */
-    .poolNumOfVolumes = esxStorageBackendISCSIPoolNumberOfVolumes, /* 1.0.1 */
-    .poolListVolumes = esxStorageBackendISCSIPoolListVolumes, /* 1.0.1 */
-    .volLookupByName = esxStorageBackendISCSIVolumeLookupByName, /* 1.0.1 */
-    .volLookupByPath = esxStorageBackendISCSIVolumeLookupByPath, /* 1.0.1 */
-    .volLookupByKey = esxStorageBackendISCSIVolumeLookupByKey, /* 1.0.1 */
-    .volCreateXML = esxStorageBackendISCSIVolumeCreateXML, /* 1.0.1 */
-    .volCreateXMLFrom = esxStorageBackendISCSIVolumeCreateXMLFrom, /* 1.0.1 */
-    .volGetXMLDesc = esxStorageBackendISCSIVolumeGetXMLDesc, /* 1.0.1 */
-    .volDelete = esxStorageBackendISCSIVolumeDelete, /* 1.0.1 */
-    .volWipe = esxStorageBackendISCSIVolumeWipe, /* 1.0.1 */
-    .volGetPath = esxStorageBackendISCSIVolumeGetPath, /* 1.0.1 */
+    .connectNumOfStoragePools = esxStorageBackendISCSINumberOfPools, /* 1.0.1 */
+    .connectListStoragePools = esxStorageBackendISCSIListPools, /* 1.0.1 */
+    .storagePoolLookupByName = esxStorageBackendISCSIPoolLookupByName, /* 1.0.1 */
+    .storagePoolLookupByUUID = esxStorageBackendISCSIPoolLookupByUUID, /* 1.0.1 */
+    .storagePoolRefresh = esxStorageBackendISCSIPoolRefresh, /* 1.0.1 */
+    .storagePoolGetInfo = esxStorageBackendISCSIPoolGetInfo, /* 1.0.1 */
+    .storagePoolGetXMLDesc = esxStorageBackendISCSIPoolGetXMLDesc, /* 1.0.1 */
+    .storagePoolNumOfVolumes = esxStorageBackendISCSIPoolNumberOfVolumes, /* 1.0.1 */
+    .storagePoolListVolumes = esxStorageBackendISCSIPoolListVolumes, /* 1.0.1 */
+    .storageVolLookupByName = esxStorageBackendISCSIVolumeLookupByName, /* 1.0.1 */
+    .storageVolLookupByPath = esxStorageBackendISCSIVolumeLookupByPath, /* 1.0.1 */
+    .storageVolLookupByKey = esxStorageBackendISCSIVolumeLookupByKey, /* 1.0.1 */
+    .storageVolCreateXML = esxStorageBackendISCSIVolumeCreateXML, /* 1.0.1 */
+    .storageVolCreateXMLFrom = esxStorageBackendISCSIVolumeCreateXMLFrom, /* 1.0.1 */
+    .storageVolGetXMLDesc = esxStorageBackendISCSIVolumeGetXMLDesc, /* 1.0.1 */
+    .storageVolDelete = esxStorageBackendISCSIVolumeDelete, /* 1.0.1 */
+    .storageVolWipe = esxStorageBackendISCSIVolumeWipe, /* 1.0.1 */
+    .storageVolGetPath = esxStorageBackendISCSIVolumeGetPath, /* 1.0.1 */
 };
diff --git a/src/esx/esx_storage_backend_vmfs.c b/src/esx/esx_storage_backend_vmfs.c
index f965b4f..329022e 100644
--- a/src/esx/esx_storage_backend_vmfs.c
+++ b/src/esx/esx_storage_backend_vmfs.c
@@ -1515,23 +1515,23 @@ esxStorageBackendVMFSVolumeGetPath(virStorageVolPtr volume)
 
 
 virStorageDriver esxStorageBackendVMFS = {
-    .numOfPools = esxStorageBackendVMFSNumberOfPools, /* 0.8.2 */
-    .listPools = esxStorageBackendVMFSListPools, /* 0.8.2 */
-    .poolLookupByName = esxStorageBackendVMFSPoolLookupByName, /* 0.8.2 */
-    .poolLookupByUUID = esxStorageBackendVMFSPoolLookupByUUID, /* 0.8.2 */
-    .poolRefresh = esxStorageBackendVMFSPoolRefresh, /* 0.8.2 */
-    .poolGetInfo = esxStorageBackendVMFSPoolGetInfo, /* 0.8.2 */
-    .poolGetXMLDesc = esxStorageBackendVMFSPoolGetXMLDesc, /* 0.8.2 */
-    .poolNumOfVolumes = esxStorageBackendVMFSPoolNumberOfVolumes, /* 0.8.4 */
-    .poolListVolumes = esxStorageBackendVMFSPoolListVolumes, /* 0.8.4 */
-    .volLookupByName = esxStorageBackendVMFSVolumeLookupByName, /* 0.8.4 */
-    .volLookupByPath = esxStorageBackendVMFSVolumeLookupByPath, /* 0.8.4 */
-    .volLookupByKey = esxStorageBackendVMFSVolumeLookupByKey, /* 0.8.4 */
-    .volCreateXML = esxStorageBackendVMFSVolumeCreateXML, /* 0.8.4 */
-    .volCreateXMLFrom = esxStorageBackendVMFSVolumeCreateXMLFrom, /* 0.8.7 */
-    .volDelete = esxStorageBackendVMFSVolumeDelete, /* 0.8.7 */
-    .volWipe = esxStorageBackendVMFSVolumeWipe, /* 0.8.7 */
-    .volGetInfo = esxStorageBackendVMFSVolumeGetInfo, /* 0.8.4 */
-    .volGetXMLDesc = esxStorageBackendVMFSVolumeGetXMLDesc, /* 0.8.4 */
-    .volGetPath = esxStorageBackendVMFSVolumeGetPath, /* 0.8.4 */
+    .connectNumOfStoragePools = esxStorageBackendVMFSNumberOfPools, /* 0.8.2 */
+    .connectListStoragePools = esxStorageBackendVMFSListPools, /* 0.8.2 */
+    .storagePoolLookupByName = esxStorageBackendVMFSPoolLookupByName, /* 0.8.2 */
+    .storagePoolLookupByUUID = esxStorageBackendVMFSPoolLookupByUUID, /* 0.8.2 */
+    .storagePoolRefresh = esxStorageBackendVMFSPoolRefresh, /* 0.8.2 */
+    .storagePoolGetInfo = esxStorageBackendVMFSPoolGetInfo, /* 0.8.2 */
+    .storagePoolGetXMLDesc = esxStorageBackendVMFSPoolGetXMLDesc, /* 0.8.2 */
+    .storagePoolNumOfVolumes = esxStorageBackendVMFSPoolNumberOfVolumes, /* 0.8.4 */
+    .storagePoolListVolumes = esxStorageBackendVMFSPoolListVolumes, /* 0.8.4 */
+    .storageVolLookupByName = esxStorageBackendVMFSVolumeLookupByName, /* 0.8.4 */
+    .storageVolLookupByPath = esxStorageBackendVMFSVolumeLookupByPath, /* 0.8.4 */
+    .storageVolLookupByKey = esxStorageBackendVMFSVolumeLookupByKey, /* 0.8.4 */
+    .storageVolCreateXML = esxStorageBackendVMFSVolumeCreateXML, /* 0.8.4 */
+    .storageVolCreateXMLFrom = esxStorageBackendVMFSVolumeCreateXMLFrom, /* 0.8.7 */
+    .storageVolDelete = esxStorageBackendVMFSVolumeDelete, /* 0.8.7 */
+    .storageVolWipe = esxStorageBackendVMFSVolumeWipe, /* 0.8.7 */
+    .storageVolGetInfo = esxStorageBackendVMFSVolumeGetInfo, /* 0.8.4 */
+    .storageVolGetXMLDesc = esxStorageBackendVMFSVolumeGetXMLDesc, /* 0.8.4 */
+    .storageVolGetPath = esxStorageBackendVMFSVolumeGetPath, /* 0.8.4 */
 };
diff --git a/src/esx/esx_storage_driver.c b/src/esx/esx_storage_driver.c
index 5fb4e1f..9ab7a9c 100644
--- a/src/esx/esx_storage_driver.c
+++ b/src/esx/esx_storage_driver.c
@@ -95,7 +95,7 @@ esxNumberOfStoragePools(virConnectPtr conn)
     }
 
     for (i = 0; i < LAST_BACKEND; ++i) {
-        tmp = backends[i]->numOfPools(conn);
+        tmp = backends[i]->connectNumOfStoragePools(conn);
 
         if (tmp < 0) {
             return -1;
@@ -127,7 +127,7 @@ esxListStoragePools(virConnectPtr conn, char **const names, int maxnames)
     }
 
     for (i = 0; i < LAST_BACKEND; ++i) {
-        tmp = backends[i]->listPools(conn, &names[count], maxnames - count);
+        tmp = backends[i]->connectListStoragePools(conn, &names[count], maxnames - count);
 
         if (tmp < 0) {
             goto cleanup;
@@ -186,7 +186,7 @@ esxStoragePoolLookupByName(virConnectPtr conn, const char *name)
     }
 
     for (i = 0; i < LAST_BACKEND; ++i) {
-        pool = backends[i]->poolLookupByName(conn, name);
+        pool = backends[i]->storagePoolLookupByName(conn, name);
 
         if (pool != NULL) {
             return pool;
@@ -215,7 +215,7 @@ esxStoragePoolLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
 
     /* invoke backend drive method to search all known pools */
     for (i = 0; i < LAST_BACKEND; ++i) {
-        pool = backends[i]->poolLookupByUUID(conn, uuid);
+        pool = backends[i]->storagePoolLookupByUUID(conn, uuid);
 
         if (pool != NULL) {
             return pool;
@@ -252,7 +252,7 @@ esxStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags)
         return -1;
     }
 
-    return backend->poolRefresh(pool, flags);
+    return backend->storagePoolRefresh(pool, flags);
 }
 
 
@@ -271,7 +271,7 @@ esxStoragePoolGetInfo(virStoragePoolPtr pool, virStoragePoolInfoPtr info)
         return -1;
     }
 
-    return backend->poolGetInfo(pool, info);
+    return backend->storagePoolGetInfo(pool, info);
 }
 
 
@@ -288,7 +288,7 @@ esxStoragePoolGetXMLDesc(virStoragePoolPtr pool, unsigned int flags)
         return NULL;
     }
 
-    return backend->poolGetXMLDesc(pool, flags);
+    return backend->storagePoolGetXMLDesc(pool, flags);
 }
 
 
@@ -335,7 +335,7 @@ esxStoragePoolNumberOfStorageVolumes(virStoragePoolPtr pool)
         return -1;
     }
 
-    return backend->poolNumOfVolumes(pool);
+    return backend->storagePoolNumOfVolumes(pool);
 }
 
 
@@ -353,7 +353,7 @@ esxStoragePoolListStorageVolumes(virStoragePoolPtr pool, char **const names,
         return -1;
     }
 
-    return backend->poolListVolumes(pool, names, maxnames);
+    return backend->storagePoolListVolumes(pool, names, maxnames);
 }
 
 
@@ -370,7 +370,7 @@ esxStorageVolumeLookupByName(virStoragePoolPtr pool, const char *name)
         return NULL;
     }
 
-    return backend->volLookupByName(pool, name);
+    return backend->storageVolLookupByName(pool, name);
 }
 
 
@@ -393,9 +393,9 @@ esxStorageVolumeLookupByPath(virConnectPtr conn, const char *path)
      * iSCSI LUNs device path follows normal linux path convention
      */
     if (STRPREFIX(path, "[")) {
-        return backends[VMFS]->volLookupByPath(conn, path);
+        return backends[VMFS]->storageVolLookupByPath(conn, path);
     } else if (STRPREFIX(path, "/")) {
-        return backends[ISCSI]->volLookupByPath(conn, path);
+        return backends[ISCSI]->storageVolLookupByPath(conn, path);
     } else {
         virReportError(VIR_ERR_INVALID_ARG,
                        _("Unexpected volume path format: %s"), path);
@@ -418,7 +418,7 @@ esxStorageVolumeLookupByKey(virConnectPtr conn, const char *key)
     }
 
     for (i = 0; i < LAST_BACKEND; ++i) {
-        volume = backends[i]->volLookupByKey(conn, key);
+        volume = backends[i]->storageVolLookupByKey(conn, key);
 
         if (volume != NULL) {
             return volume;
@@ -447,7 +447,7 @@ esxStorageVolumeCreateXML(virStoragePoolPtr pool, const char *xmldesc,
         return NULL;
     }
 
-    return backend->volCreateXML(pool, xmldesc, flags);
+    return backend->storageVolCreateXML(pool, xmldesc, flags);
 }
 
 
@@ -465,7 +465,7 @@ esxStorageVolumeCreateXMLFrom(virStoragePoolPtr pool, const char *xmldesc,
         return NULL;
     }
 
-    return backend->volCreateXMLFrom(pool, xmldesc, sourceVolume, flags);
+    return backend->storageVolCreateXMLFrom(pool, xmldesc, sourceVolume, flags);
 }
 
 
@@ -482,7 +482,7 @@ esxStorageVolumeDelete(virStorageVolPtr volume, unsigned int flags)
         return -1;
     }
 
-    return backend->volDelete(volume, flags);
+    return backend->storageVolDelete(volume, flags);
 }
 
 
@@ -499,7 +499,7 @@ esxStorageVolumeWipe(virStorageVolPtr volume, unsigned int flags)
         return -1;
     }
 
-    return backend->volWipe(volume, flags);
+    return backend->storageVolWipe(volume, flags);
 }
 
 
@@ -516,7 +516,7 @@ esxStorageVolumeGetInfo(virStorageVolPtr volume, virStorageVolInfoPtr info)
         return -1;
     }
 
-    return backend->volGetInfo(volume, info);
+    return backend->storageVolGetInfo(volume, info);
 }
 
 
@@ -533,7 +533,7 @@ esxStorageVolumeGetXMLDesc(virStorageVolPtr volume, unsigned int flags)
         return NULL;
     }
 
-    return backend->volGetXMLDesc(volume, flags);
+    return backend->storageVolGetXMLDesc(volume, flags);
 }
 
 
@@ -550,7 +550,7 @@ esxStorageVolumeGetPath(virStorageVolPtr volume)
         return NULL;
     }
 
-    return backend->volGetPath(volume);
+    return backend->storageVolGetPath(volume);
 }
 
 
@@ -575,34 +575,34 @@ esxStoragePoolIsPersistent(virStoragePoolPtr pool ATTRIBUTE_UNUSED)
 
 static virStorageDriver esxStorageDriver = {
     .name = "ESX",
-    .open = esxStorageOpen, /* 0.7.6 */
-    .close = esxStorageClose, /* 0.7.6 */
-    .numOfPools = esxNumberOfStoragePools, /* 0.8.2 */
-    .listPools = esxListStoragePools, /* 0.8.2 */
-    .numOfDefinedPools = esxNumberOfDefinedStoragePools, /* 0.8.2 */
-    .listDefinedPools = esxListDefinedStoragePools, /* 0.8.2 */
-    .poolLookupByName = esxStoragePoolLookupByName, /* 0.8.2 */
-    .poolLookupByUUID = esxStoragePoolLookupByUUID, /* 0.8.2 */
-    .poolLookupByVolume = esxStoragePoolLookupByVolume, /* 0.8.4 */
-    .poolRefresh = esxStoragePoolRefresh, /* 0.8.2 */
-    .poolGetInfo = esxStoragePoolGetInfo, /* 0.8.2 */
-    .poolGetXMLDesc = esxStoragePoolGetXMLDesc, /* 0.8.2 */
-    .poolGetAutostart = esxStoragePoolGetAutostart, /* 0.8.2 */
-    .poolSetAutostart = esxStoragePoolSetAutostart, /* 0.8.2 */
-    .poolNumOfVolumes = esxStoragePoolNumberOfStorageVolumes, /* 0.8.4 */
-    .poolListVolumes = esxStoragePoolListStorageVolumes, /* 0.8.4 */
-    .volLookupByName = esxStorageVolumeLookupByName, /* 0.8.4 */
-    .volLookupByPath = esxStorageVolumeLookupByPath, /* 0.8.4 */
-    .volLookupByKey = esxStorageVolumeLookupByKey, /* 0.8.4 */
-    .volCreateXML = esxStorageVolumeCreateXML, /* 0.8.4 */
-    .volCreateXMLFrom = esxStorageVolumeCreateXMLFrom, /* 0.8.7 */
-    .volDelete = esxStorageVolumeDelete, /* 0.8.7 */
-    .volWipe = esxStorageVolumeWipe, /* 0.8.7 */
-    .volGetInfo = esxStorageVolumeGetInfo, /* 0.8.4 */
-    .volGetXMLDesc = esxStorageVolumeGetXMLDesc, /* 0.8.4 */
-    .volGetPath = esxStorageVolumeGetPath, /* 0.8.4 */
-    .poolIsActive = esxStoragePoolIsActive, /* 0.8.2 */
-    .poolIsPersistent = esxStoragePoolIsPersistent, /* 0.8.2 */
+    .connectOpen = esxStorageOpen, /* 0.7.6 */
+    .connectClose = esxStorageClose, /* 0.7.6 */
+    .connectNumOfStoragePools = esxNumberOfStoragePools, /* 0.8.2 */
+    .connectListStoragePools = esxListStoragePools, /* 0.8.2 */
+    .connectNumOfDefinedStoragePools = esxNumberOfDefinedStoragePools, /* 0.8.2 */
+    .connectListDefinedStoragePools = esxListDefinedStoragePools, /* 0.8.2 */
+    .storagePoolLookupByName = esxStoragePoolLookupByName, /* 0.8.2 */
+    .storagePoolLookupByUUID = esxStoragePoolLookupByUUID, /* 0.8.2 */
+    .storagePoolLookupByVolume = esxStoragePoolLookupByVolume, /* 0.8.4 */
+    .storagePoolRefresh = esxStoragePoolRefresh, /* 0.8.2 */
+    .storagePoolGetInfo = esxStoragePoolGetInfo, /* 0.8.2 */
+    .storagePoolGetXMLDesc = esxStoragePoolGetXMLDesc, /* 0.8.2 */
+    .storagePoolGetAutostart = esxStoragePoolGetAutostart, /* 0.8.2 */
+    .storagePoolSetAutostart = esxStoragePoolSetAutostart, /* 0.8.2 */
+    .storagePoolNumOfVolumes = esxStoragePoolNumberOfStorageVolumes, /* 0.8.4 */
+    .storagePoolListVolumes = esxStoragePoolListStorageVolumes, /* 0.8.4 */
+    .storageVolLookupByName = esxStorageVolumeLookupByName, /* 0.8.4 */
+    .storageVolLookupByPath = esxStorageVolumeLookupByPath, /* 0.8.4 */
+    .storageVolLookupByKey = esxStorageVolumeLookupByKey, /* 0.8.4 */
+    .storageVolCreateXML = esxStorageVolumeCreateXML, /* 0.8.4 */
+    .storageVolCreateXMLFrom = esxStorageVolumeCreateXMLFrom, /* 0.8.7 */
+    .storageVolDelete = esxStorageVolumeDelete, /* 0.8.7 */
+    .storageVolWipe = esxStorageVolumeWipe, /* 0.8.7 */
+    .storageVolGetInfo = esxStorageVolumeGetInfo, /* 0.8.4 */
+    .storageVolGetXMLDesc = esxStorageVolumeGetXMLDesc, /* 0.8.4 */
+    .storageVolGetPath = esxStorageVolumeGetPath, /* 0.8.4 */
+    .storagePoolIsActive = esxStoragePoolIsActive, /* 0.8.2 */
+    .storagePoolIsPersistent = esxStoragePoolIsPersistent, /* 0.8.2 */
 };
 
 
diff --git a/src/fdstream.c b/src/fdstream.c
index 9a6f042..53dde97 100644
--- a/src/fdstream.c
+++ b/src/fdstream.c
@@ -455,9 +455,9 @@ static virStreamDriver virFDStreamDrv = {
     .streamRecv = virFDStreamRead,
     .streamFinish = virFDStreamClose,
     .streamAbort = virFDStreamAbort,
-    .streamAddCallback = virFDStreamAddCallback,
-    .streamUpdateCallback = virFDStreamUpdateCallback,
-    .streamRemoveCallback = virFDStreamRemoveCallback
+    .streamEventAddCallback = virFDStreamAddCallback,
+    .streamEventUpdateCallback = virFDStreamUpdateCallback,
+    .streamEventRemoveCallback = virFDStreamRemoveCallback
 };
 
 static int virFDStreamOpenInternal(virStreamPtr st,
diff --git a/src/hyperv/hyperv_device_monitor.c b/src/hyperv/hyperv_device_monitor.c
index 9432081..cf3ba25 100644
--- a/src/hyperv/hyperv_device_monitor.c
+++ b/src/hyperv/hyperv_device_monitor.c
@@ -66,8 +66,8 @@ hypervDeviceClose(virConnectPtr conn)
 
 static virDeviceMonitor hypervDeviceMonitor = {
     "Hyper-V",
-    .open = hypervDeviceOpen, /* 0.9.5 */
-    .close = hypervDeviceClose, /* 0.9.5 */
+    .connectOpen = hypervDeviceOpen, /* 0.9.5 */
+    .connectClose = hypervDeviceClose, /* 0.9.5 */
 };
 
 
diff --git a/src/hyperv/hyperv_driver.c b/src/hyperv/hyperv_driver.c
index 4644bff..828e3fe 100644
--- a/src/hyperv/hyperv_driver.c
+++ b/src/hyperv/hyperv_driver.c
@@ -1398,14 +1398,14 @@ no_memory:
 static virDriver hypervDriver = {
     .no = VIR_DRV_HYPERV,
     .name = "Hyper-V",
-    .open = hypervOpen, /* 0.9.5 */
-    .close = hypervClose, /* 0.9.5 */
-    .type = hypervGetType, /* 0.9.5 */
-    .getHostname = hypervGetHostname, /* 0.9.5 */
+    .connectOpen = hypervOpen, /* 0.9.5 */
+    .connectClose = hypervClose, /* 0.9.5 */
+    .connectGetType = hypervGetType, /* 0.9.5 */
+    .connectGetHostname = hypervGetHostname, /* 0.9.5 */
     .nodeGetInfo = hypervNodeGetInfo, /* 0.9.5 */
-    .listDomains = hypervListDomains, /* 0.9.5 */
-    .numOfDomains = hypervNumberOfDomains, /* 0.9.5 */
-    .listAllDomains = hypervListAllDomains, /* 0.10.2 */
+    .connectListDomains = hypervListDomains, /* 0.9.5 */
+    .connectNumOfDomains = hypervNumberOfDomains, /* 0.9.5 */
+    .connectListAllDomains = hypervListAllDomains, /* 0.10.2 */
     .domainLookupByID = hypervDomainLookupByID, /* 0.9.5 */
     .domainLookupByUUID = hypervDomainLookupByUUID, /* 0.9.5 */
     .domainLookupByName = hypervDomainLookupByName, /* 0.9.5 */
@@ -1417,19 +1417,19 @@ static virDriver hypervDriver = {
     .domainGetInfo = hypervDomainGetInfo, /* 0.9.5 */
     .domainGetState = hypervDomainGetState, /* 0.9.5 */
     .domainGetXMLDesc = hypervDomainGetXMLDesc, /* 0.9.5 */
-    .listDefinedDomains = hypervListDefinedDomains, /* 0.9.5 */
-    .numOfDefinedDomains = hypervNumberOfDefinedDomains, /* 0.9.5 */
+    .connectListDefinedDomains = hypervListDefinedDomains, /* 0.9.5 */
+    .connectNumOfDefinedDomains = hypervNumberOfDefinedDomains, /* 0.9.5 */
     .domainCreate = hypervDomainCreate, /* 0.9.5 */
     .domainCreateWithFlags = hypervDomainCreateWithFlags, /* 0.9.5 */
-    .isEncrypted = hypervIsEncrypted, /* 0.9.5 */
-    .isSecure = hypervIsSecure, /* 0.9.5 */
+    .connectIsEncrypted = hypervIsEncrypted, /* 0.9.5 */
+    .connectIsSecure = hypervIsSecure, /* 0.9.5 */
     .domainIsActive = hypervDomainIsActive, /* 0.9.5 */
     .domainIsPersistent = hypervDomainIsPersistent, /* 0.9.5 */
     .domainIsUpdated = hypervDomainIsUpdated, /* 0.9.5 */
     .domainManagedSave = hypervDomainManagedSave, /* 0.9.5 */
     .domainHasManagedSaveImage = hypervDomainHasManagedSaveImage, /* 0.9.5 */
     .domainManagedSaveRemove = hypervDomainManagedSaveRemove, /* 0.9.5 */
-    .isAlive = hypervIsAlive, /* 0.9.8 */
+    .connectIsAlive = hypervIsAlive, /* 0.9.8 */
 };
 
 
diff --git a/src/hyperv/hyperv_interface_driver.c b/src/hyperv/hyperv_interface_driver.c
index b42dbce..db909f3 100644
--- a/src/hyperv/hyperv_interface_driver.c
+++ b/src/hyperv/hyperv_interface_driver.c
@@ -66,8 +66,8 @@ hypervInterfaceClose(virConnectPtr conn)
 
 static virInterfaceDriver hypervInterfaceDriver = {
     .name = "Hyper-V",
-    .open = hypervInterfaceOpen, /* 0.9.5 */
-    .close = hypervInterfaceClose, /* 0.9.5 */
+    .connectOpen = hypervInterfaceOpen, /* 0.9.5 */
+    .connectClose = hypervInterfaceClose, /* 0.9.5 */
 };
 
 
diff --git a/src/hyperv/hyperv_network_driver.c b/src/hyperv/hyperv_network_driver.c
index c75c943..5ede105 100644
--- a/src/hyperv/hyperv_network_driver.c
+++ b/src/hyperv/hyperv_network_driver.c
@@ -66,8 +66,8 @@ hypervNetworkClose(virConnectPtr conn)
 
 static virNetworkDriver hypervNetworkDriver = {
     .name = "Hyper-V",
-    .open = hypervNetworkOpen, /* 0.9.5 */
-    .close = hypervNetworkClose, /* 0.9.5 */
+    .connectOpen = hypervNetworkOpen, /* 0.9.5 */
+    .connectClose = hypervNetworkClose, /* 0.9.5 */
 };
 
 
diff --git a/src/hyperv/hyperv_nwfilter_driver.c b/src/hyperv/hyperv_nwfilter_driver.c
index faa9074..07d8275 100644
--- a/src/hyperv/hyperv_nwfilter_driver.c
+++ b/src/hyperv/hyperv_nwfilter_driver.c
@@ -66,8 +66,8 @@ hypervNWFilterClose(virConnectPtr conn)
 
 static virNWFilterDriver hypervNWFilterDriver = {
     .name = "Hyper-V",
-    .open = hypervNWFilterOpen, /* 0.9.5 */
-    .close = hypervNWFilterClose, /* 0.9.5 */
+    .connectOpen = hypervNWFilterOpen, /* 0.9.5 */
+    .connectClose = hypervNWFilterClose, /* 0.9.5 */
 };
 
 
diff --git a/src/hyperv/hyperv_secret_driver.c b/src/hyperv/hyperv_secret_driver.c
index 602ae99..6554667 100644
--- a/src/hyperv/hyperv_secret_driver.c
+++ b/src/hyperv/hyperv_secret_driver.c
@@ -66,8 +66,8 @@ hypervSecretClose(virConnectPtr conn)
 
 static virSecretDriver hypervSecretDriver = {
     .name = "Hyper-V",
-    .open = hypervSecretOpen, /* 0.9.5 */
-    .close = hypervSecretClose, /* 0.9.5 */
+    .connectOpen = hypervSecretOpen, /* 0.9.5 */
+    .connectClose = hypervSecretClose, /* 0.9.5 */
 };
 
 
diff --git a/src/hyperv/hyperv_storage_driver.c b/src/hyperv/hyperv_storage_driver.c
index a169b14..a908a0c 100644
--- a/src/hyperv/hyperv_storage_driver.c
+++ b/src/hyperv/hyperv_storage_driver.c
@@ -66,8 +66,8 @@ hypervStorageClose(virConnectPtr conn)
 
 static virStorageDriver hypervStorageDriver = {
     .name = "Hyper-V",
-    .open = hypervStorageOpen, /* 0.9.5*/
-    .close = hypervStorageClose, /* 0.9.5 */
+    .connectOpen = hypervStorageOpen, /* 0.9.5*/
+    .connectClose = hypervStorageClose, /* 0.9.5 */
 };
 
 
diff --git a/src/interface/interface_backend_netcf.c b/src/interface/interface_backend_netcf.c
index 8671717..8394b06 100644
--- a/src/interface/interface_backend_netcf.c
+++ b/src/interface/interface_backend_netcf.c
@@ -784,13 +784,13 @@ static int interfaceChangeRollback(virConnectPtr conn, unsigned int flags)
 
 static virInterfaceDriver interfaceDriver = {
     "netcf",
-    .open = interfaceOpenInterface, /* 0.7.0 */
-    .close = interfaceCloseInterface, /* 0.7.0 */
-    .numOfInterfaces = interfaceNumOfInterfaces, /* 0.7.0 */
-    .listInterfaces = interfaceListInterfaces, /* 0.7.0 */
-    .numOfDefinedInterfaces = interfaceNumOfDefinedInterfaces, /* 0.7.0 */
-    .listDefinedInterfaces = interfaceListDefinedInterfaces, /* 0.7.0 */
-    .listAllInterfaces = interfaceListAllInterfaces, /* 0.10.2 */
+    .connectOpen = interfaceOpenInterface, /* 0.7.0 */
+    .connectClose = interfaceCloseInterface, /* 0.7.0 */
+    .connectNumOfInterfaces = interfaceNumOfInterfaces, /* 0.7.0 */
+    .connectListInterfaces = interfaceListInterfaces, /* 0.7.0 */
+    .connectNumOfDefinedInterfaces = interfaceNumOfDefinedInterfaces, /* 0.7.0 */
+    .connectListDefinedInterfaces = interfaceListDefinedInterfaces, /* 0.7.0 */
+    .connectListAllInterfaces = interfaceListAllInterfaces, /* 0.10.2 */
     .interfaceLookupByName = interfaceLookupByName, /* 0.7.0 */
     .interfaceLookupByMACString = interfaceLookupByMACString, /* 0.7.0 */
     .interfaceGetXMLDesc = interfaceGetXMLDesc, /* 0.7.0 */
diff --git a/src/interface/interface_backend_udev.c b/src/interface/interface_backend_udev.c
index 1132d9a..1c317f0 100644
--- a/src/interface/interface_backend_udev.c
+++ b/src/interface/interface_backend_udev.c
@@ -1149,13 +1149,13 @@ cleanup:
 
 static virInterfaceDriver udevIfaceDriver = {
     "udev",
-    .open = udevIfaceOpenInterface, /* 1.0.0 */
-    .close = udevIfaceCloseInterface, /* 1.0.0 */
-    .numOfInterfaces = udevIfaceNumOfInterfaces, /* 1.0.0 */
-    .listInterfaces = udevIfaceListInterfaces, /* 1.0.0 */
-    .numOfDefinedInterfaces = udevIfaceNumOfDefinedInterfaces, /* 1.0.0 */
-    .listDefinedInterfaces = udevIfaceListDefinedInterfaces, /* 1.0.0 */
-    .listAllInterfaces = udevIfaceListAllInterfaces, /* 1.0.0 */
+    .connectOpen = udevIfaceOpenInterface, /* 1.0.0 */
+    .connectClose = udevIfaceCloseInterface, /* 1.0.0 */
+    .connectNumOfInterfaces = udevIfaceNumOfInterfaces, /* 1.0.0 */
+    .connectListInterfaces = udevIfaceListInterfaces, /* 1.0.0 */
+    .connectNumOfDefinedInterfaces = udevIfaceNumOfDefinedInterfaces, /* 1.0.0 */
+    .connectListDefinedInterfaces = udevIfaceListDefinedInterfaces, /* 1.0.0 */
+    .connectListAllInterfaces = udevIfaceListAllInterfaces, /* 1.0.0 */
     .interfaceLookupByName = udevIfaceLookupByName, /* 1.0.0 */
     .interfaceLookupByMACString = udevIfaceLookupByMACString, /* 1.0.0 */
     .interfaceIsActive = udevIfaceIsActive, /* 1.0.0 */
diff --git a/src/libvirt-qemu.c b/src/libvirt-qemu.c
index fb19584..747488d 100644
--- a/src/libvirt-qemu.c
+++ b/src/libvirt-qemu.c
@@ -95,9 +95,9 @@ virDomainQemuMonitorCommand(virDomainPtr domain, const char *cmd,
         goto error;
     }
 
-    if (conn->driver->qemuDomainMonitorCommand) {
+    if (conn->driver->domainQemuMonitorCommand) {
         int ret;
-        ret = conn->driver->qemuDomainMonitorCommand(domain, cmd, result,
+        ret = conn->driver->domainQemuMonitorCommand(domain, cmd, result,
                                                      flags);
         if (ret < 0)
             goto error;
@@ -170,9 +170,9 @@ virDomainQemuAttach(virConnectPtr conn,
         goto error;
     }
 
-    if (conn->driver->qemuDomainAttach) {
+    if (conn->driver->domainQemuAttach) {
         virDomainPtr ret;
-        ret = conn->driver->qemuDomainAttach(conn, pid_value, flags);
+        ret = conn->driver->domainQemuAttach(conn, pid_value, flags);
         if (!ret)
             goto error;
         return ret;
@@ -227,9 +227,9 @@ virDomainQemuAgentCommand(virDomainPtr domain,
 
     conn = domain->conn;
 
-    if (conn->driver->qemuDomainArbitraryAgentCommand) {
-        return conn->driver->qemuDomainArbitraryAgentCommand(domain, cmd,
-                                                             timeout, flags);
+    if (conn->driver->domainQemuAgentCommand) {
+        return conn->driver->domainQemuAgentCommand(domain, cmd,
+                                                    timeout, flags);
     }
 
     virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
diff --git a/src/libvirt.c b/src/libvirt.c
index 870519e..7818e7f 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -827,12 +827,12 @@ int virStateInitialize(bool privileged,
         return -1;
 
     for (i = 0 ; i < virStateDriverTabCount ; i++) {
-        if (virStateDriverTab[i]->initialize) {
+        if (virStateDriverTab[i]->stateInitialize) {
             VIR_DEBUG("Running global init for %s state driver",
                       virStateDriverTab[i]->name);
-            if (virStateDriverTab[i]->initialize(privileged,
-                                                 callback,
-                                                 opaque) < 0) {
+            if (virStateDriverTab[i]->stateInitialize(privileged,
+                                                      callback,
+                                                      opaque) < 0) {
                 VIR_ERROR(_("Initialization of %s state driver failed"),
                           virStateDriverTab[i]->name);
                 return -1;
@@ -853,8 +853,8 @@ int virStateCleanup(void) {
     int i, ret = 0;
 
     for (i = 0 ; i < virStateDriverTabCount ; i++) {
-        if (virStateDriverTab[i]->cleanup &&
-            virStateDriverTab[i]->cleanup() < 0)
+        if (virStateDriverTab[i]->stateCleanup &&
+            virStateDriverTab[i]->stateCleanup() < 0)
             ret = -1;
     }
     return ret;
@@ -871,8 +871,8 @@ int virStateReload(void) {
     int i, ret = 0;
 
     for (i = 0 ; i < virStateDriverTabCount ; i++) {
-        if (virStateDriverTab[i]->reload &&
-            virStateDriverTab[i]->reload() < 0)
+        if (virStateDriverTab[i]->stateReload &&
+            virStateDriverTab[i]->stateReload() < 0)
             ret = -1;
     }
     return ret;
@@ -889,8 +889,8 @@ int virStateStop(void) {
     int i, ret = 0;
 
     for (i = 0 ; i < virStateDriverTabCount ; i++) {
-        if (virStateDriverTab[i]->stop &&
-            virStateDriverTab[i]->stop())
+        if (virStateDriverTab[i]->stateStop &&
+            virStateDriverTab[i]->stateStop())
             ret = 1;
     }
     return ret;
@@ -1209,7 +1209,7 @@ do_open(const char *name,
         }
 
         VIR_DEBUG("trying driver %d (%s) ...", i, virDriverTab[i]->name);
-        res = virDriverTab[i]->open(ret, auth, flags);
+        res = virDriverTab[i]->connectOpen(ret, auth, flags);
         VIR_DEBUG("driver %d %s returned %s",
                   i, virDriverTab[i]->name,
                   res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
@@ -1233,7 +1233,7 @@ do_open(const char *name,
     }
 
     for (i = 0; i < virNetworkDriverTabCount; i++) {
-        res = virNetworkDriverTab[i]->open(ret, auth, flags);
+        res = virNetworkDriverTab[i]->connectOpen(ret, auth, flags);
         VIR_DEBUG("network driver %d %s returned %s",
                   i, virNetworkDriverTab[i]->name,
                   res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
@@ -1249,7 +1249,7 @@ do_open(const char *name,
     }
 
     for (i = 0; i < virInterfaceDriverTabCount; i++) {
-        res = virInterfaceDriverTab[i]->open(ret, auth, flags);
+        res = virInterfaceDriverTab[i]->connectOpen(ret, auth, flags);
         VIR_DEBUG("interface driver %d %s returned %s",
                   i, virInterfaceDriverTab[i]->name,
                   res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
@@ -1266,7 +1266,7 @@ do_open(const char *name,
 
     /* Secondary driver for storage. Optional */
     for (i = 0; i < virStorageDriverTabCount; i++) {
-        res = virStorageDriverTab[i]->open(ret, auth, flags);
+        res = virStorageDriverTab[i]->connectOpen(ret, auth, flags);
         VIR_DEBUG("storage driver %d %s returned %s",
                   i, virStorageDriverTab[i]->name,
                   res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
@@ -1283,7 +1283,7 @@ do_open(const char *name,
 
     /* Node driver (optional) */
     for (i = 0; i < virDeviceMonitorTabCount; i++) {
-        res = virDeviceMonitorTab[i]->open(ret, auth, flags);
+        res = virDeviceMonitorTab[i]->connectOpen(ret, auth, flags);
         VIR_DEBUG("node driver %d %s returned %s",
                   i, virDeviceMonitorTab[i]->name,
                   res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
@@ -1300,7 +1300,7 @@ do_open(const char *name,
 
     /* Secret manipulation driver. Optional */
     for (i = 0; i < virSecretDriverTabCount; i++) {
-        res = virSecretDriverTab[i]->open(ret, auth, flags);
+        res = virSecretDriverTab[i]->connectOpen(ret, auth, flags);
         VIR_DEBUG("secret driver %d %s returned %s",
                   i, virSecretDriverTab[i]->name,
                   res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
@@ -1317,7 +1317,7 @@ do_open(const char *name,
 
     /* Network filter driver. Optional */
     for (i = 0; i < virNWFilterDriverTabCount; i++) {
-        res = virNWFilterDriverTab[i]->open(ret, auth, flags);
+        res = virNWFilterDriverTab[i]->connectOpen(ret, auth, flags);
         VIR_DEBUG("nwfilter driver %d %s returned %s",
                   i, virNWFilterDriverTab[i]->name,
                   res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
@@ -1544,7 +1544,7 @@ virConnectRef(virConnectPtr conn)
  * implementation of driver features in the remote case.
  */
 int
-virDrvSupportsFeature(virConnectPtr conn, int feature)
+virConnectSupportsFeature(virConnectPtr conn, int feature)
 {
     int ret;
     VIR_DEBUG("conn=%p, feature=%d", conn, feature);
@@ -1557,10 +1557,10 @@ virDrvSupportsFeature(virConnectPtr conn, int feature)
         return -1;
     }
 
-    if (!conn->driver->supports_feature)
+    if (!conn->driver->connectSupportsFeature)
         ret = 0;
     else
-        ret = conn->driver->supports_feature(conn, feature);
+        ret = conn->driver->connectSupportsFeature(conn, feature);
 
     if (ret < 0)
         virDispatchError(conn);
@@ -1593,8 +1593,8 @@ virConnectGetType(virConnectPtr conn)
         return NULL;
     }
 
-    if (conn->driver->type) {
-        ret = conn->driver->type(conn);
+    if (conn->driver->connectGetType) {
+        ret = conn->driver->connectGetType(conn);
         if (ret) return ret;
     }
     return conn->driver->name;
@@ -1628,8 +1628,8 @@ virConnectGetVersion(virConnectPtr conn, unsigned long *hvVer)
 
     virCheckNonNullArgGoto(hvVer, error);
 
-    if (conn->driver->version) {
-        int ret = conn->driver->version(conn, hvVer);
+    if (conn->driver->connectGetVersion) {
+        int ret = conn->driver->connectGetVersion(conn, hvVer);
         if (ret < 0)
             goto error;
         return ret;
@@ -1669,8 +1669,8 @@ virConnectGetLibVersion(virConnectPtr conn, unsigned long *libVer)
 
     virCheckNonNullArgGoto(libVer, error);
 
-    if (conn->driver->libvirtVersion) {
-        ret = conn->driver->libvirtVersion(conn, libVer);
+    if (conn->driver->connectGetLibVersion) {
+        ret = conn->driver->connectGetLibVersion(conn, libVer);
         if (ret < 0)
             goto error;
         return ret;
@@ -1709,8 +1709,8 @@ virConnectGetHostname(virConnectPtr conn)
         return NULL;
     }
 
-    if (conn->driver->getHostname) {
-        char *ret = conn->driver->getHostname(conn);
+    if (conn->driver->connectGetHostname) {
+        char *ret = conn->driver->connectGetHostname(conn);
         if (!ret)
             goto error;
         return ret;
@@ -1788,8 +1788,8 @@ virConnectGetSysinfo(virConnectPtr conn, unsigned int flags)
         return NULL;
     }
 
-    if (conn->driver->getSysinfo) {
-        char *ret = conn->driver->getSysinfo(conn, flags);
+    if (conn->driver->connectGetSysinfo) {
+        char *ret = conn->driver->connectGetSysinfo(conn, flags);
         if (!ret)
             goto error;
         return ret;
@@ -1827,8 +1827,8 @@ virConnectGetMaxVcpus(virConnectPtr conn,
         return -1;
     }
 
-    if (conn->driver->getMaxVcpus) {
-        int ret = conn->driver->getMaxVcpus(conn, type);
+    if (conn->driver->connectGetMaxVcpus) {
+        int ret = conn->driver->connectGetMaxVcpus(conn, type);
         if (ret < 0)
             goto error;
         return ret;
@@ -1873,8 +1873,8 @@ virConnectListDomains(virConnectPtr conn, int *ids, int maxids)
     virCheckNonNullArgGoto(ids, error);
     virCheckNonNegativeArgGoto(maxids, error);
 
-    if (conn->driver->listDomains) {
-        int ret = conn->driver->listDomains(conn, ids, maxids);
+    if (conn->driver->connectListDomains) {
+        int ret = conn->driver->connectListDomains(conn, ids, maxids);
         if (ret < 0)
             goto error;
         return ret;
@@ -1907,8 +1907,8 @@ virConnectNumOfDomains(virConnectPtr conn)
         return -1;
     }
 
-    if (conn->driver->numOfDomains) {
-        int ret = conn->driver->numOfDomains(conn);
+    if (conn->driver->connectNumOfDomains) {
+        int ret = conn->driver->connectNumOfDomains(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -4447,12 +4447,12 @@ char *virConnectDomainXMLFromNative(virConnectPtr conn,
     virCheckNonNullArgGoto(nativeFormat, error);
     virCheckNonNullArgGoto(nativeConfig, error);
 
-    if (conn->driver->domainXMLFromNative) {
+    if (conn->driver->connectDomainXMLFromNative) {
         char *ret;
-        ret = conn->driver->domainXMLFromNative(conn,
-                                                nativeFormat,
-                                                nativeConfig,
-                                                flags);
+        ret = conn->driver->connectDomainXMLFromNative(conn,
+                                                       nativeFormat,
+                                                       nativeConfig,
+                                                       flags);
         if (!ret)
             goto error;
         return ret;
@@ -4502,12 +4502,12 @@ char *virConnectDomainXMLToNative(virConnectPtr conn,
     virCheckNonNullArgGoto(nativeFormat, error);
     virCheckNonNullArgGoto(domainXml, error);
 
-    if (conn->driver->domainXMLToNative) {
+    if (conn->driver->connectDomainXMLToNative) {
         char *ret;
-        ret = conn->driver->domainXMLToNative(conn,
-                                              nativeFormat,
-                                              domainXml,
-                                              flags);
+        ret = conn->driver->connectDomainXMLToNative(conn,
+                                                     nativeFormat,
+                                                     domainXml,
+                                                     flags);
         if (!ret)
             goto error;
         return ret;
@@ -6590,9 +6590,9 @@ virConnectGetCapabilities(virConnectPtr conn)
         return NULL;
     }
 
-    if (conn->driver->getCapabilities) {
+    if (conn->driver->connectGetCapabilities) {
         char *ret;
-        ret = conn->driver->getCapabilities(conn);
+        ret = conn->driver->connectGetCapabilities(conn);
         if (!ret)
             goto error;
         VIR_DEBUG("conn=%p ret=%s", conn, ret);
@@ -8257,9 +8257,9 @@ virConnectNumOfDefinedDomains(virConnectPtr conn)
         return -1;
     }
 
-    if (conn->driver->numOfDefinedDomains) {
+    if (conn->driver->connectNumOfDefinedDomains) {
         int ret;
-        ret = conn->driver->numOfDefinedDomains(conn);
+        ret = conn->driver->connectNumOfDefinedDomains(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -8306,9 +8306,9 @@ virConnectListDefinedDomains(virConnectPtr conn, char **const names,
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (conn->driver->listDefinedDomains) {
+    if (conn->driver->connectListDefinedDomains) {
         int ret;
-        ret = conn->driver->listDefinedDomains(conn, names, maxnames);
+        ret = conn->driver->connectListDefinedDomains(conn, names, maxnames);
         if (ret < 0)
             goto error;
         return ret;
@@ -8411,9 +8411,9 @@ virConnectListAllDomains(virConnectPtr conn,
         return -1;
     }
 
-    if (conn->driver->listAllDomains) {
+    if (conn->driver->connectListAllDomains) {
         int ret;
-        ret = conn->driver->listAllDomains(conn, domains, flags);
+        ret = conn->driver->connectListAllDomains(conn, domains, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -10222,9 +10222,9 @@ virConnectListAllNetworks(virConnectPtr conn,
     }
 
     if (conn->networkDriver &&
-        conn->networkDriver->listAllNetworks) {
+        conn->networkDriver->connectListAllNetworks) {
         int ret;
-        ret = conn->networkDriver->listAllNetworks(conn, nets, flags);
+        ret = conn->networkDriver->connectListAllNetworks(conn, nets, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -10259,9 +10259,9 @@ virConnectNumOfNetworks(virConnectPtr conn)
         return -1;
     }
 
-    if (conn->networkDriver && conn->networkDriver->numOfNetworks) {
+    if (conn->networkDriver && conn->networkDriver->connectNumOfNetworks) {
         int ret;
-        ret = conn->networkDriver->numOfNetworks(conn);
+        ret = conn->networkDriver->connectNumOfNetworks(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -10306,9 +10306,9 @@ virConnectListNetworks(virConnectPtr conn, char **const names, int maxnames)
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (conn->networkDriver && conn->networkDriver->listNetworks) {
+    if (conn->networkDriver && conn->networkDriver->connectListNetworks) {
         int ret;
-        ret = conn->networkDriver->listNetworks(conn, names, maxnames);
+        ret = conn->networkDriver->connectListNetworks(conn, names, maxnames);
         if (ret < 0)
             goto error;
         return ret;
@@ -10342,9 +10342,9 @@ virConnectNumOfDefinedNetworks(virConnectPtr conn)
         return -1;
     }
 
-    if (conn->networkDriver && conn->networkDriver->numOfDefinedNetworks) {
+    if (conn->networkDriver && conn->networkDriver->connectNumOfDefinedNetworks) {
         int ret;
-        ret = conn->networkDriver->numOfDefinedNetworks(conn);
+        ret = conn->networkDriver->connectNumOfDefinedNetworks(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -10390,10 +10390,9 @@ virConnectListDefinedNetworks(virConnectPtr conn, char **const names,
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (conn->networkDriver && conn->networkDriver->listDefinedNetworks) {
+    if (conn->networkDriver && conn->networkDriver->connectListDefinedNetworks) {
         int ret;
-        ret = conn->networkDriver->listDefinedNetworks(conn,
-                                                       names, maxnames);
+        ret = conn->networkDriver->connectListDefinedNetworks(conn, names, maxnames);
         if (ret < 0)
             goto error;
         return ret;
@@ -11204,9 +11203,9 @@ virConnectListAllInterfaces(virConnectPtr conn,
     }
 
     if (conn->interfaceDriver &&
-        conn->interfaceDriver->listAllInterfaces) {
+        conn->interfaceDriver->connectListAllInterfaces) {
         int ret;
-        ret = conn->interfaceDriver->listAllInterfaces(conn, ifaces, flags);
+        ret = conn->interfaceDriver->connectListAllInterfaces(conn, ifaces, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -11240,9 +11239,9 @@ virConnectNumOfInterfaces(virConnectPtr conn)
         return -1;
     }
 
-    if (conn->interfaceDriver && conn->interfaceDriver->numOfInterfaces) {
+    if (conn->interfaceDriver && conn->interfaceDriver->connectNumOfInterfaces) {
         int ret;
-        ret = conn->interfaceDriver->numOfInterfaces(conn);
+        ret = conn->interfaceDriver->connectNumOfInterfaces(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -11288,9 +11287,9 @@ virConnectListInterfaces(virConnectPtr conn, char **const names, int maxnames)
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (conn->interfaceDriver && conn->interfaceDriver->listInterfaces) {
+    if (conn->interfaceDriver && conn->interfaceDriver->connectListInterfaces) {
         int ret;
-        ret = conn->interfaceDriver->listInterfaces(conn, names, maxnames);
+        ret = conn->interfaceDriver->connectListInterfaces(conn, names, maxnames);
         if (ret < 0)
             goto error;
         return ret;
@@ -11324,9 +11323,9 @@ virConnectNumOfDefinedInterfaces(virConnectPtr conn)
         return -1;
     }
 
-    if (conn->interfaceDriver && conn->interfaceDriver->numOfDefinedInterfaces) {
+    if (conn->interfaceDriver && conn->interfaceDriver->connectNumOfDefinedInterfaces) {
         int ret;
-        ret = conn->interfaceDriver->numOfDefinedInterfaces(conn);
+        ret = conn->interfaceDriver->connectNumOfDefinedInterfaces(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -11374,9 +11373,9 @@ virConnectListDefinedInterfaces(virConnectPtr conn,
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (conn->interfaceDriver && conn->interfaceDriver->listDefinedInterfaces) {
+    if (conn->interfaceDriver && conn->interfaceDriver->connectListDefinedInterfaces) {
         int ret;
-        ret = conn->interfaceDriver->listDefinedInterfaces(conn, names, maxnames);
+        ret = conn->interfaceDriver->connectListDefinedInterfaces(conn, names, maxnames);
         if (ret < 0)
             goto error;
         return ret;
@@ -12071,9 +12070,9 @@ virConnectListAllStoragePools(virConnectPtr conn,
     }
 
     if (conn->storageDriver &&
-        conn->storageDriver->listAllPools) {
+        conn->storageDriver->connectListAllStoragePools) {
         int ret;
-        ret = conn->storageDriver->listAllPools(conn, pools, flags);
+        ret = conn->storageDriver->connectListAllStoragePools(conn, pools, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -12107,9 +12106,9 @@ virConnectNumOfStoragePools(virConnectPtr conn)
         return -1;
     }
 
-    if (conn->storageDriver && conn->storageDriver->numOfPools) {
+    if (conn->storageDriver && conn->storageDriver->connectNumOfStoragePools) {
         int ret;
-        ret = conn->storageDriver->numOfPools(conn);
+        ret = conn->storageDriver->connectNumOfStoragePools(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -12158,9 +12157,9 @@ virConnectListStoragePools(virConnectPtr conn,
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (conn->storageDriver && conn->storageDriver->listPools) {
+    if (conn->storageDriver && conn->storageDriver->connectListStoragePools) {
         int ret;
-        ret = conn->storageDriver->listPools(conn, names, maxnames);
+        ret = conn->storageDriver->connectListStoragePools(conn, names, maxnames);
         if (ret < 0)
             goto error;
         return ret;
@@ -12195,9 +12194,9 @@ virConnectNumOfDefinedStoragePools(virConnectPtr conn)
         return -1;
     }
 
-    if (conn->storageDriver && conn->storageDriver->numOfDefinedPools) {
+    if (conn->storageDriver && conn->storageDriver->connectNumOfDefinedStoragePools) {
         int ret;
-        ret = conn->storageDriver->numOfDefinedPools(conn);
+        ret = conn->storageDriver->connectNumOfDefinedStoragePools(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -12247,9 +12246,9 @@ virConnectListDefinedStoragePools(virConnectPtr conn,
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (conn->storageDriver && conn->storageDriver->listDefinedPools) {
+    if (conn->storageDriver && conn->storageDriver->connectListDefinedStoragePools) {
         int ret;
-        ret = conn->storageDriver->listDefinedPools(conn, names, maxnames);
+        ret = conn->storageDriver->connectListDefinedStoragePools(conn, names, maxnames);
         if (ret < 0)
             goto error;
         return ret;
@@ -12307,9 +12306,9 @@ virConnectFindStoragePoolSources(virConnectPtr conn,
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->findPoolSources) {
+    if (conn->storageDriver && conn->storageDriver->connectFindStoragePoolSources) {
         char *ret;
-        ret = conn->storageDriver->findPoolSources(conn, type, srcSpec, flags);
+        ret = conn->storageDriver->connectFindStoragePoolSources(conn, type, srcSpec, flags);
         if (!ret)
             goto error;
         return ret;
@@ -12347,9 +12346,9 @@ virStoragePoolLookupByName(virConnectPtr conn,
     }
     virCheckNonNullArgGoto(name, error);
 
-    if (conn->storageDriver && conn->storageDriver->poolLookupByName) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolLookupByName) {
         virStoragePoolPtr ret;
-        ret = conn->storageDriver->poolLookupByName(conn, name);
+        ret = conn->storageDriver->storagePoolLookupByName(conn, name);
         if (!ret)
             goto error;
         return ret;
@@ -12387,9 +12386,9 @@ virStoragePoolLookupByUUID(virConnectPtr conn,
     }
     virCheckNonNullArgGoto(uuid, error);
 
-    if (conn->storageDriver && conn->storageDriver->poolLookupByUUID) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolLookupByUUID) {
         virStoragePoolPtr ret;
-        ret = conn->storageDriver->poolLookupByUUID(conn, uuid);
+        ret = conn->storageDriver->storagePoolLookupByUUID(conn, uuid);
         if (!ret)
             goto error;
         return ret;
@@ -12464,9 +12463,9 @@ virStoragePoolLookupByVolume(virStorageVolPtr vol)
         return NULL;
     }
 
-    if (vol->conn->storageDriver && vol->conn->storageDriver->poolLookupByVolume) {
+    if (vol->conn->storageDriver && vol->conn->storageDriver->storagePoolLookupByVolume) {
         virStoragePoolPtr ret;
-        ret = vol->conn->storageDriver->poolLookupByVolume(vol);
+        ret = vol->conn->storageDriver->storagePoolLookupByVolume(vol);
         if (!ret)
             goto error;
         return ret;
@@ -12512,9 +12511,9 @@ virStoragePoolCreateXML(virConnectPtr conn,
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->poolCreateXML) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolCreateXML) {
         virStoragePoolPtr ret;
-        ret = conn->storageDriver->poolCreateXML(conn, xmlDesc, flags);
+        ret = conn->storageDriver->storagePoolCreateXML(conn, xmlDesc, flags);
         if (!ret)
             goto error;
         return ret;
@@ -12558,9 +12557,9 @@ virStoragePoolDefineXML(virConnectPtr conn,
     }
     virCheckNonNullArgGoto(xml, error);
 
-    if (conn->storageDriver && conn->storageDriver->poolDefineXML) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolDefineXML) {
         virStoragePoolPtr ret;
-        ret = conn->storageDriver->poolDefineXML(conn, xml, flags);
+        ret = conn->storageDriver->storagePoolDefineXML(conn, xml, flags);
         if (!ret)
             goto error;
         return ret;
@@ -12605,9 +12604,9 @@ virStoragePoolBuild(virStoragePoolPtr pool,
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->poolBuild) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolBuild) {
         int ret;
-        ret = conn->storageDriver->poolBuild(pool, flags);
+        ret = conn->storageDriver->storagePoolBuild(pool, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -12648,9 +12647,9 @@ virStoragePoolUndefine(virStoragePoolPtr pool)
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->poolUndefine) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolUndefine) {
         int ret;
-        ret = conn->storageDriver->poolUndefine(pool);
+        ret = conn->storageDriver->storagePoolUndefine(pool);
         if (ret < 0)
             goto error;
         return ret;
@@ -12693,9 +12692,9 @@ virStoragePoolCreate(virStoragePoolPtr pool,
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->poolCreate) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolCreate) {
         int ret;
-        ret = conn->storageDriver->poolCreate(pool, flags);
+        ret = conn->storageDriver->storagePoolCreate(pool, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -12741,9 +12740,9 @@ virStoragePoolDestroy(virStoragePoolPtr pool)
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->poolDestroy) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolDestroy) {
         int ret;
-        ret = conn->storageDriver->poolDestroy(pool);
+        ret = conn->storageDriver->storagePoolDestroy(pool);
         if (ret < 0)
             goto error;
         return ret;
@@ -12788,9 +12787,9 @@ virStoragePoolDelete(virStoragePoolPtr pool,
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->poolDelete) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolDelete) {
         int ret;
-        ret = conn->storageDriver->poolDelete(pool, flags);
+        ret = conn->storageDriver->storagePoolDelete(pool, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -12893,9 +12892,9 @@ virStoragePoolRefresh(virStoragePoolPtr pool,
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->poolRefresh) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolRefresh) {
         int ret;
-        ret = conn->storageDriver->poolRefresh(pool, flags);
+        ret = conn->storageDriver->storagePoolRefresh(pool, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -13033,9 +13032,9 @@ virStoragePoolGetInfo(virStoragePoolPtr pool,
 
     conn = pool->conn;
 
-    if (conn->storageDriver->poolGetInfo) {
+    if (conn->storageDriver->storagePoolGetInfo) {
         int ret;
-        ret = conn->storageDriver->poolGetInfo(pool, info);
+        ret = conn->storageDriver->storagePoolGetInfo(pool, info);
         if (ret < 0)
             goto error;
         return ret;
@@ -13077,9 +13076,9 @@ virStoragePoolGetXMLDesc(virStoragePoolPtr pool,
 
     conn = pool->conn;
 
-    if (conn->storageDriver && conn->storageDriver->poolGetXMLDesc) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolGetXMLDesc) {
         char *ret;
-        ret = conn->storageDriver->poolGetXMLDesc(pool, flags);
+        ret = conn->storageDriver->storagePoolGetXMLDesc(pool, flags);
         if (!ret)
             goto error;
         return ret;
@@ -13121,9 +13120,9 @@ virStoragePoolGetAutostart(virStoragePoolPtr pool,
 
     conn = pool->conn;
 
-    if (conn->storageDriver && conn->storageDriver->poolGetAutostart) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolGetAutostart) {
         int ret;
-        ret = conn->storageDriver->poolGetAutostart(pool, autostart);
+        ret = conn->storageDriver->storagePoolGetAutostart(pool, autostart);
         if (ret < 0)
             goto error;
         return ret;
@@ -13168,9 +13167,9 @@ virStoragePoolSetAutostart(virStoragePoolPtr pool,
 
     conn = pool->conn;
 
-    if (conn->storageDriver && conn->storageDriver->poolSetAutostart) {
+    if (conn->storageDriver && conn->storageDriver->storagePoolSetAutostart) {
         int ret;
-        ret = conn->storageDriver->poolSetAutostart(pool, autostart);
+        ret = conn->storageDriver->storagePoolSetAutostart(pool, autostart);
         if (ret < 0)
             goto error;
         return ret;
@@ -13217,9 +13216,9 @@ virStoragePoolListAllVolumes(virStoragePoolPtr pool,
     }
 
     if (pool->conn->storageDriver &&
-        pool->conn->storageDriver->poolListAllVolumes) {
+        pool->conn->storageDriver->storagePoolListAllVolumes) {
         int ret;
-        ret = pool->conn->storageDriver->poolListAllVolumes(pool, vols, flags);
+        ret = pool->conn->storageDriver->storagePoolListAllVolumes(pool, vols, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -13253,9 +13252,9 @@ virStoragePoolNumOfVolumes(virStoragePoolPtr pool)
         return -1;
     }
 
-    if (pool->conn->storageDriver && pool->conn->storageDriver->poolNumOfVolumes) {
+    if (pool->conn->storageDriver && pool->conn->storageDriver->storagePoolNumOfVolumes) {
         int ret;
-        ret = pool->conn->storageDriver->poolNumOfVolumes(pool);
+        ret = pool->conn->storageDriver->storagePoolNumOfVolumes(pool);
         if (ret < 0)
             goto error;
         return ret;
@@ -13300,9 +13299,9 @@ virStoragePoolListVolumes(virStoragePoolPtr pool,
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (pool->conn->storageDriver && pool->conn->storageDriver->poolListVolumes) {
+    if (pool->conn->storageDriver && pool->conn->storageDriver->storagePoolListVolumes) {
         int ret;
-        ret = pool->conn->storageDriver->poolListVolumes(pool, names, maxnames);
+        ret = pool->conn->storageDriver->storagePoolListVolumes(pool, names, maxnames);
         if (ret < 0)
             goto error;
         return ret;
@@ -13372,9 +13371,9 @@ virStorageVolLookupByName(virStoragePoolPtr pool,
 
     virCheckNonNullArgGoto(name, error);
 
-    if (pool->conn->storageDriver && pool->conn->storageDriver->volLookupByName) {
+    if (pool->conn->storageDriver && pool->conn->storageDriver->storageVolLookupByName) {
         virStorageVolPtr ret;
-        ret = pool->conn->storageDriver->volLookupByName(pool, name);
+        ret = pool->conn->storageDriver->storageVolLookupByName(pool, name);
         if (!ret)
             goto error;
         return ret;
@@ -13415,9 +13414,9 @@ virStorageVolLookupByKey(virConnectPtr conn,
 
     virCheckNonNullArgGoto(key, error);
 
-    if (conn->storageDriver && conn->storageDriver->volLookupByKey) {
+    if (conn->storageDriver && conn->storageDriver->storageVolLookupByKey) {
         virStorageVolPtr ret;
-        ret = conn->storageDriver->volLookupByKey(conn, key);
+        ret = conn->storageDriver->storageVolLookupByKey(conn, key);
         if (!ret)
             goto error;
         return ret;
@@ -13455,9 +13454,9 @@ virStorageVolLookupByPath(virConnectPtr conn,
     }
     virCheckNonNullArgGoto(path, error);
 
-    if (conn->storageDriver && conn->storageDriver->volLookupByPath) {
+    if (conn->storageDriver && conn->storageDriver->storageVolLookupByPath) {
         virStorageVolPtr ret;
-        ret = conn->storageDriver->volLookupByPath(conn, path);
+        ret = conn->storageDriver->storageVolLookupByPath(conn, path);
         if (!ret)
             goto error;
         return ret;
@@ -13561,9 +13560,9 @@ virStorageVolCreateXML(virStoragePoolPtr pool,
         goto error;
     }
 
-    if (pool->conn->storageDriver && pool->conn->storageDriver->volCreateXML) {
+    if (pool->conn->storageDriver && pool->conn->storageDriver->storageVolCreateXML) {
         virStorageVolPtr ret;
-        ret = pool->conn->storageDriver->volCreateXML(pool, xmlDesc, flags);
+        ret = pool->conn->storageDriver->storageVolCreateXML(pool, xmlDesc, flags);
         if (!ret)
             goto error;
         return ret;
@@ -13627,9 +13626,9 @@ virStorageVolCreateXMLFrom(virStoragePoolPtr pool,
     }
 
     if (pool->conn->storageDriver &&
-        pool->conn->storageDriver->volCreateXMLFrom) {
+        pool->conn->storageDriver->storageVolCreateXMLFrom) {
         virStorageVolPtr ret;
-        ret = pool->conn->storageDriver->volCreateXMLFrom(pool, xmlDesc,
+        ret = pool->conn->storageDriver->storageVolCreateXMLFrom(pool, xmlDesc,
                                                           clonevol, flags);
         if (!ret)
             goto error;
@@ -13693,9 +13692,9 @@ virStorageVolDownload(virStorageVolPtr vol,
     }
 
     if (vol->conn->storageDriver &&
-        vol->conn->storageDriver->volDownload) {
+        vol->conn->storageDriver->storageVolDownload) {
         int ret;
-        ret = vol->conn->storageDriver->volDownload(vol,
+        ret = vol->conn->storageDriver->storageVolDownload(vol,
                                                     stream,
                                                     offset,
                                                     length,
@@ -13764,9 +13763,9 @@ virStorageVolUpload(virStorageVolPtr vol,
     }
 
     if (vol->conn->storageDriver &&
-        vol->conn->storageDriver->volUpload) {
+        vol->conn->storageDriver->storageVolUpload) {
         int ret;
-        ret = vol->conn->storageDriver->volUpload(vol,
+        ret = vol->conn->storageDriver->storageVolUpload(vol,
                                                   stream,
                                                   offset,
                                                   length,
@@ -13814,9 +13813,9 @@ virStorageVolDelete(virStorageVolPtr vol,
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->volDelete) {
+    if (conn->storageDriver && conn->storageDriver->storageVolDelete) {
         int ret;
-        ret = conn->storageDriver->volDelete(vol, flags);
+        ret = conn->storageDriver->storageVolDelete(vol, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -13860,9 +13859,9 @@ virStorageVolWipe(virStorageVolPtr vol,
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->volWipe) {
+    if (conn->storageDriver && conn->storageDriver->storageVolWipe) {
         int ret;
-        ret = conn->storageDriver->volWipe(vol, flags);
+        ret = conn->storageDriver->storageVolWipe(vol, flags);
         if (ret < 0) {
             goto error;
         }
@@ -13910,9 +13909,9 @@ virStorageVolWipePattern(virStorageVolPtr vol,
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->volWipePattern) {
+    if (conn->storageDriver && conn->storageDriver->storageVolWipePattern) {
         int ret;
-        ret = conn->storageDriver->volWipePattern(vol, algorithm, flags);
+        ret = conn->storageDriver->storageVolWipePattern(vol, algorithm, flags);
         if (ret < 0) {
             goto error;
         }
@@ -14012,9 +14011,9 @@ virStorageVolGetInfo(virStorageVolPtr vol,
 
     conn = vol->conn;
 
-    if (conn->storageDriver->volGetInfo){
+    if (conn->storageDriver->storageVolGetInfo){
         int ret;
-        ret = conn->storageDriver->volGetInfo(vol, info);
+        ret = conn->storageDriver->storageVolGetInfo(vol, info);
         if (ret < 0)
             goto error;
         return ret;
@@ -14055,9 +14054,9 @@ virStorageVolGetXMLDesc(virStorageVolPtr vol,
 
     conn = vol->conn;
 
-    if (conn->storageDriver && conn->storageDriver->volGetXMLDesc) {
+    if (conn->storageDriver && conn->storageDriver->storageVolGetXMLDesc) {
         char *ret;
-        ret = conn->storageDriver->volGetXMLDesc(vol, flags);
+        ret = conn->storageDriver->storageVolGetXMLDesc(vol, flags);
         if (!ret)
             goto error;
         return ret;
@@ -14100,9 +14099,9 @@ virStorageVolGetPath(virStorageVolPtr vol)
 
     conn = vol->conn;
 
-    if (conn->storageDriver && conn->storageDriver->volGetPath) {
+    if (conn->storageDriver && conn->storageDriver->storageVolGetPath) {
         char *ret;
-        ret = conn->storageDriver->volGetPath(vol);
+        ret = conn->storageDriver->storageVolGetPath(vol);
         if (!ret)
             goto error;
         return ret;
@@ -14180,9 +14179,9 @@ virStorageVolResize(virStorageVolPtr vol,
         goto error;
     }
 
-    if (conn->storageDriver && conn->storageDriver->volResize) {
+    if (conn->storageDriver && conn->storageDriver->storageVolResize) {
         int ret;
-        ret = conn->storageDriver->volResize(vol, capacity, flags);
+        ret = conn->storageDriver->storageVolResize(vol, capacity, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -14221,9 +14220,9 @@ virNodeNumOfDevices(virConnectPtr conn, const char *cap, unsigned int flags)
         return -1;
     }
 
-    if (conn->deviceMonitor && conn->deviceMonitor->numOfDevices) {
+    if (conn->deviceMonitor && conn->deviceMonitor->nodeNumOfDevices) {
         int ret;
-        ret = conn->deviceMonitor->numOfDevices(conn, cap, flags);
+        ret = conn->deviceMonitor->nodeNumOfDevices(conn, cap, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -14293,9 +14292,9 @@ virConnectListAllNodeDevices(virConnectPtr conn,
     }
 
     if (conn->deviceMonitor &&
-        conn->deviceMonitor->listAllNodeDevices) {
+        conn->deviceMonitor->connectListAllNodeDevices) {
         int ret;
-        ret = conn->deviceMonitor->listAllNodeDevices(conn, devices, flags);
+        ret = conn->deviceMonitor->connectListAllNodeDevices(conn, devices, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -14344,9 +14343,9 @@ virNodeListDevices(virConnectPtr conn,
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (conn->deviceMonitor && conn->deviceMonitor->listDevices) {
+    if (conn->deviceMonitor && conn->deviceMonitor->nodeListDevices) {
         int ret;
-        ret = conn->deviceMonitor->listDevices(conn, cap, names, maxnames, flags);
+        ret = conn->deviceMonitor->nodeListDevices(conn, cap, names, maxnames, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -14383,9 +14382,9 @@ virNodeDevicePtr virNodeDeviceLookupByName(virConnectPtr conn, const char *name)
 
     virCheckNonNullArgGoto(name, error);
 
-    if (conn->deviceMonitor && conn->deviceMonitor->deviceLookupByName) {
+    if (conn->deviceMonitor && conn->deviceMonitor->nodeDeviceLookupByName) {
         virNodeDevicePtr ret;
-        ret = conn->deviceMonitor->deviceLookupByName(conn, name);
+        ret = conn->deviceMonitor->nodeDeviceLookupByName(conn, name);
         if (!ret)
             goto error;
         return ret;
@@ -14429,9 +14428,9 @@ virNodeDeviceLookupSCSIHostByWWN(virConnectPtr conn,
     virCheckNonNullArgGoto(wwpn, error);
 
     if (conn->deviceMonitor &&
-        conn->deviceMonitor->deviceLookupSCSIHostByWWN) {
+        conn->deviceMonitor->nodeDeviceLookupSCSIHostByWWN) {
         virNodeDevicePtr ret;
-        ret = conn->deviceMonitor->deviceLookupSCSIHostByWWN(conn, wwnn,
+        ret = conn->deviceMonitor->nodeDeviceLookupSCSIHostByWWN(conn, wwnn,
                                                              wwpn, flags);
         if (!ret)
             goto error;
@@ -14467,9 +14466,9 @@ char *virNodeDeviceGetXMLDesc(virNodeDevicePtr dev, unsigned int flags)
         return NULL;
     }
 
-    if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->deviceGetXMLDesc) {
+    if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceGetXMLDesc) {
         char *ret;
-        ret = dev->conn->deviceMonitor->deviceGetXMLDesc(dev, flags);
+        ret = dev->conn->deviceMonitor->nodeDeviceGetXMLDesc(dev, flags);
         if (!ret)
             goto error;
         return ret;
@@ -14526,8 +14525,8 @@ const char *virNodeDeviceGetParent(virNodeDevicePtr dev)
     }
 
     if (!dev->parent) {
-        if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->deviceGetParent) {
-            dev->parent = dev->conn->deviceMonitor->deviceGetParent(dev);
+        if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceGetParent) {
+            dev->parent = dev->conn->deviceMonitor->nodeDeviceGetParent(dev);
         } else {
             virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__);
             virDispatchError(dev->conn);
@@ -14557,9 +14556,9 @@ int virNodeDeviceNumOfCaps(virNodeDevicePtr dev)
         return -1;
     }
 
-    if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->deviceNumOfCaps) {
+    if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceNumOfCaps) {
         int ret;
-        ret = dev->conn->deviceMonitor->deviceNumOfCaps(dev);
+        ret = dev->conn->deviceMonitor->nodeDeviceNumOfCaps(dev);
         if (ret < 0)
             goto error;
         return ret;
@@ -14600,9 +14599,9 @@ int virNodeDeviceListCaps(virNodeDevicePtr dev,
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->deviceListCaps) {
+    if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceListCaps) {
         int ret;
-        ret = dev->conn->deviceMonitor->deviceListCaps(dev, names, maxnames);
+        ret = dev->conn->deviceMonitor->nodeDeviceListCaps(dev, names, maxnames);
         if (ret < 0)
             goto error;
         return ret;
@@ -14856,8 +14855,8 @@ virNodeDeviceCreateXML(virConnectPtr conn,
     virCheckNonNullArgGoto(xmlDesc, error);
 
     if (conn->deviceMonitor &&
-        conn->deviceMonitor->deviceCreateXML) {
-        virNodeDevicePtr dev = conn->deviceMonitor->deviceCreateXML(conn, xmlDesc, flags);
+        conn->deviceMonitor->nodeDeviceCreateXML) {
+        virNodeDevicePtr dev = conn->deviceMonitor->nodeDeviceCreateXML(conn, xmlDesc, flags);
         if (dev == NULL)
             goto error;
         return dev;
@@ -14899,8 +14898,8 @@ virNodeDeviceDestroy(virNodeDevicePtr dev)
     }
 
     if (dev->conn->deviceMonitor &&
-        dev->conn->deviceMonitor->deviceDestroy) {
-        int retval = dev->conn->deviceMonitor->deviceDestroy(dev);
+        dev->conn->deviceMonitor->nodeDeviceDestroy) {
+        int retval = dev->conn->deviceMonitor->nodeDeviceDestroy(dev);
         if (retval < 0) {
             goto error;
         }
@@ -14959,9 +14958,9 @@ virConnectDomainEventRegister(virConnectPtr conn,
     }
     virCheckNonNullArgGoto(cb, error);
 
-    if ((conn->driver) && (conn->driver->domainEventRegister)) {
+    if ((conn->driver) && (conn->driver->connectDomainEventRegister)) {
         int ret;
-        ret = conn->driver->domainEventRegister(conn, cb, opaque, freecb);
+        ret = conn->driver->connectDomainEventRegister(conn, cb, opaque, freecb);
         if (ret < 0)
             goto error;
         return ret;
@@ -15002,9 +15001,9 @@ virConnectDomainEventDeregister(virConnectPtr conn,
     }
     virCheckNonNullArgGoto(cb, error);
 
-    if ((conn->driver) && (conn->driver->domainEventDeregister)) {
+    if ((conn->driver) && (conn->driver->connectDomainEventDeregister)) {
         int ret;
-        ret = conn->driver->domainEventDeregister(conn, cb);
+        ret = conn->driver->connectDomainEventDeregister(conn, cb);
         if (ret < 0)
             goto error;
         return ret;
@@ -15065,10 +15064,10 @@ virConnectNumOfSecrets(virConnectPtr conn)
     }
 
     if (conn->secretDriver != NULL &&
-        conn->secretDriver->numOfSecrets != NULL) {
+        conn->secretDriver->connectNumOfSecrets != NULL) {
         int ret;
 
-        ret = conn->secretDriver->numOfSecrets(conn);
+        ret = conn->secretDriver->connectNumOfSecrets(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -15133,9 +15132,9 @@ virConnectListAllSecrets(virConnectPtr conn,
     }
 
     if (conn->secretDriver &&
-        conn->secretDriver->listAllSecrets) {
+        conn->secretDriver->connectListAllSecrets) {
         int ret;
-        ret = conn->secretDriver->listAllSecrets(conn, secrets, flags);
+        ret = conn->secretDriver->connectListAllSecrets(conn, secrets, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -15173,10 +15172,10 @@ virConnectListSecrets(virConnectPtr conn, char **uuids, int maxuuids)
     virCheckNonNullArgGoto(uuids, error);
     virCheckNonNegativeArgGoto(maxuuids, error);
 
-    if (conn->secretDriver != NULL && conn->secretDriver->listSecrets != NULL) {
+    if (conn->secretDriver != NULL && conn->secretDriver->connectListSecrets != NULL) {
         int ret;
 
-        ret = conn->secretDriver->listSecrets(conn, uuids, maxuuids);
+        ret = conn->secretDriver->connectListSecrets(conn, uuids, maxuuids);
         if (ret < 0)
             goto error;
         return ret;
@@ -15215,9 +15214,9 @@ virSecretLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
     virCheckNonNullArgGoto(uuid, error);
 
     if (conn->secretDriver &&
-        conn->secretDriver->lookupByUUID) {
+        conn->secretDriver->secretLookupByUUID) {
         virSecretPtr ret;
-        ret = conn->secretDriver->lookupByUUID(conn, uuid);
+        ret = conn->secretDriver->secretLookupByUUID(conn, uuid);
         if (!ret)
             goto error;
         return ret;
@@ -15301,9 +15300,9 @@ virSecretLookupByUsage(virConnectPtr conn,
     virCheckNonNullArgGoto(usageID, error);
 
     if (conn->secretDriver &&
-        conn->secretDriver->lookupByUsage) {
+        conn->secretDriver->secretLookupByUsage) {
         virSecretPtr ret;
-        ret = conn->secretDriver->lookupByUsage(conn, usageType, usageID);
+        ret = conn->secretDriver->secretLookupByUsage(conn, usageType, usageID);
         if (!ret)
             goto error;
         return ret;
@@ -15350,10 +15349,10 @@ virSecretDefineXML(virConnectPtr conn, const char *xml, unsigned int flags)
     }
     virCheckNonNullArgGoto(xml, error);
 
-    if (conn->secretDriver != NULL && conn->secretDriver->defineXML != NULL) {
+    if (conn->secretDriver != NULL && conn->secretDriver->secretDefineXML != NULL) {
         virSecretPtr ret;
 
-        ret = conn->secretDriver->defineXML(conn, xml, flags);
+        ret = conn->secretDriver->secretDefineXML(conn, xml, flags);
         if (ret == NULL)
             goto error;
         return ret;
@@ -15521,10 +15520,10 @@ virSecretGetXMLDesc(virSecretPtr secret, unsigned int flags)
     }
 
     conn = secret->conn;
-    if (conn->secretDriver != NULL && conn->secretDriver->getXMLDesc != NULL) {
+    if (conn->secretDriver != NULL && conn->secretDriver->secretGetXMLDesc != NULL) {
         char *ret;
 
-        ret = conn->secretDriver->getXMLDesc(secret, flags);
+        ret = conn->secretDriver->secretGetXMLDesc(secret, flags);
         if (ret == NULL)
             goto error;
         return ret;
@@ -15571,10 +15570,10 @@ virSecretSetValue(virSecretPtr secret, const unsigned char *value,
     }
     virCheckNonNullArgGoto(value, error);
 
-    if (conn->secretDriver != NULL && conn->secretDriver->setValue != NULL) {
+    if (conn->secretDriver != NULL && conn->secretDriver->secretSetValue != NULL) {
         int ret;
 
-        ret = conn->secretDriver->setValue(secret, value, value_size, flags);
+        ret = conn->secretDriver->secretSetValue(secret, value, value_size, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -15619,10 +15618,10 @@ virSecretGetValue(virSecretPtr secret, size_t *value_size, unsigned int flags)
     }
     virCheckNonNullArgGoto(value_size, error);
 
-    if (conn->secretDriver != NULL && conn->secretDriver->getValue != NULL) {
+    if (conn->secretDriver != NULL && conn->secretDriver->secretGetValue != NULL) {
         unsigned char *ret;
 
-        ret = conn->secretDriver->getValue(secret, value_size, flags, 0);
+        ret = conn->secretDriver->secretGetValue(secret, value_size, flags, 0);
         if (ret == NULL)
             goto error;
         return ret;
@@ -15664,10 +15663,10 @@ virSecretUndefine(virSecretPtr secret)
         goto error;
     }
 
-    if (conn->secretDriver != NULL && conn->secretDriver->undefine != NULL) {
+    if (conn->secretDriver != NULL && conn->secretDriver->secretUndefine != NULL) {
         int ret;
 
-        ret = conn->secretDriver->undefine(secret);
+        ret = conn->secretDriver->secretUndefine(secret);
         if (ret < 0)
             goto error;
         return ret;
@@ -16231,9 +16230,9 @@ int virStreamEventAddCallback(virStreamPtr stream,
     }
 
     if (stream->driver &&
-        stream->driver->streamAddCallback) {
+        stream->driver->streamEventAddCallback) {
         int ret;
-        ret = (stream->driver->streamAddCallback)(stream, events, cb, opaque, ff);
+        ret = (stream->driver->streamEventAddCallback)(stream, events, cb, opaque, ff);
         if (ret < 0)
             goto error;
         return ret;
@@ -16273,9 +16272,9 @@ int virStreamEventUpdateCallback(virStreamPtr stream,
     }
 
     if (stream->driver &&
-        stream->driver->streamUpdateCallback) {
+        stream->driver->streamEventUpdateCallback) {
         int ret;
-        ret = (stream->driver->streamUpdateCallback)(stream, events);
+        ret = (stream->driver->streamEventUpdateCallback)(stream, events);
         if (ret < 0)
             goto error;
         return ret;
@@ -16309,9 +16308,9 @@ int virStreamEventRemoveCallback(virStreamPtr stream)
     }
 
     if (stream->driver &&
-        stream->driver->streamRemoveCallback) {
+        stream->driver->streamEventRemoveCallback) {
         int ret;
-        ret = (stream->driver->streamRemoveCallback)(stream);
+        ret = (stream->driver->streamEventRemoveCallback)(stream);
         if (ret < 0)
             goto error;
         return ret;
@@ -16633,9 +16632,9 @@ int virStoragePoolIsActive(virStoragePoolPtr pool)
         virDispatchError(NULL);
         return -1;
     }
-    if (pool->conn->storageDriver->poolIsActive) {
+    if (pool->conn->storageDriver->storagePoolIsActive) {
         int ret;
-        ret = pool->conn->storageDriver->poolIsActive(pool);
+        ret = pool->conn->storageDriver->storagePoolIsActive(pool);
         if (ret < 0)
             goto error;
         return ret;
@@ -16668,9 +16667,9 @@ int virStoragePoolIsPersistent(virStoragePoolPtr pool)
         virDispatchError(NULL);
         return -1;
     }
-    if (pool->conn->storageDriver->poolIsPersistent) {
+    if (pool->conn->storageDriver->storagePoolIsPersistent) {
         int ret;
-        ret = pool->conn->storageDriver->poolIsPersistent(pool);
+        ret = pool->conn->storageDriver->storagePoolIsPersistent(pool);
         if (ret < 0)
             goto error;
         return ret;
@@ -16705,9 +16704,9 @@ virConnectNumOfNWFilters(virConnectPtr conn)
         return -1;
     }
 
-    if (conn->nwfilterDriver && conn->nwfilterDriver->numOfNWFilters) {
+    if (conn->nwfilterDriver && conn->nwfilterDriver->connectNumOfNWFilters) {
         int ret;
-        ret = conn->nwfilterDriver->numOfNWFilters(conn);
+        ret = conn->nwfilterDriver->connectNumOfNWFilters(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -16756,9 +16755,9 @@ virConnectListAllNWFilters(virConnectPtr conn,
     }
 
     if (conn->nwfilterDriver &&
-        conn->nwfilterDriver->listAllNWFilters) {
+        conn->nwfilterDriver->connectListAllNWFilters) {
         int ret;
-        ret = conn->nwfilterDriver->listAllNWFilters(conn, filters, flags);
+        ret = conn->nwfilterDriver->connectListAllNWFilters(conn, filters, flags);
         if (ret < 0)
             goto error;
         return ret;
@@ -16797,9 +16796,9 @@ virConnectListNWFilters(virConnectPtr conn, char **const names, int maxnames)
     virCheckNonNullArgGoto(names, error);
     virCheckNonNegativeArgGoto(maxnames, error);
 
-    if (conn->nwfilterDriver && conn->nwfilterDriver->listNWFilters) {
+    if (conn->nwfilterDriver && conn->nwfilterDriver->connectListNWFilters) {
         int ret;
-        ret = conn->nwfilterDriver->listNWFilters(conn, names, maxnames);
+        ret = conn->nwfilterDriver->connectListNWFilters(conn, names, maxnames);
         if (ret < 0)
             goto error;
         return ret;
@@ -17078,9 +17077,9 @@ virNWFilterDefineXML(virConnectPtr conn, const char *xmlDesc)
         goto error;
     }
 
-    if (conn->nwfilterDriver && conn->nwfilterDriver->defineXML) {
+    if (conn->nwfilterDriver && conn->nwfilterDriver->nwfilterDefineXML) {
         virNWFilterPtr ret;
-        ret = conn->nwfilterDriver->defineXML(conn, xmlDesc);
+        ret = conn->nwfilterDriver->nwfilterDefineXML(conn, xmlDesc);
         if (!ret)
             goto error;
         return ret;
@@ -17124,9 +17123,9 @@ virNWFilterUndefine(virNWFilterPtr nwfilter)
         goto error;
     }
 
-    if (conn->nwfilterDriver && conn->nwfilterDriver->undefine) {
+    if (conn->nwfilterDriver && conn->nwfilterDriver->nwfilterUndefine) {
         int ret;
-        ret = conn->nwfilterDriver->undefine(nwfilter);
+        ret = conn->nwfilterDriver->nwfilterUndefine(nwfilter);
         if (ret < 0)
             goto error;
         return ret;
@@ -17167,9 +17166,9 @@ virNWFilterGetXMLDesc(virNWFilterPtr nwfilter, unsigned int flags)
 
     conn = nwfilter->conn;
 
-    if (conn->nwfilterDriver && conn->nwfilterDriver->getXMLDesc) {
+    if (conn->nwfilterDriver && conn->nwfilterDriver->nwfilterGetXMLDesc) {
         char *ret;
-        ret = conn->nwfilterDriver->getXMLDesc(nwfilter, flags);
+        ret = conn->nwfilterDriver->nwfilterGetXMLDesc(nwfilter, flags);
         if (!ret)
             goto error;
         return ret;
@@ -17267,9 +17266,9 @@ int virConnectIsEncrypted(virConnectPtr conn)
         virDispatchError(NULL);
         return -1;
     }
-    if (conn->driver->isEncrypted) {
+    if (conn->driver->connectIsEncrypted) {
         int ret;
-        ret = conn->driver->isEncrypted(conn);
+        ret = conn->driver->connectIsEncrypted(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -17304,9 +17303,9 @@ int virConnectIsSecure(virConnectPtr conn)
         virDispatchError(NULL);
         return -1;
     }
-    if (conn->driver->isSecure) {
+    if (conn->driver->connectIsSecure) {
         int ret;
-        ret = conn->driver->isSecure(conn);
+        ret = conn->driver->connectIsSecure(conn);
         if (ret < 0)
             goto error;
         return ret;
@@ -17345,10 +17344,10 @@ virConnectCompareCPU(virConnectPtr conn,
     }
     virCheckNonNullArgGoto(xmlDesc, error);
 
-    if (conn->driver->cpuCompare) {
+    if (conn->driver->connectCompareCPU) {
         int ret;
 
-        ret = conn->driver->cpuCompare(conn, xmlDesc, flags);
+        ret = conn->driver->connectCompareCPU(conn, xmlDesc, flags);
         if (ret == VIR_CPU_COMPARE_ERROR)
             goto error;
         return ret;
@@ -17399,10 +17398,10 @@ virConnectBaselineCPU(virConnectPtr conn,
     }
     virCheckNonNullArgGoto(xmlCPUs, error);
 
-    if (conn->driver->cpuBaseline) {
+    if (conn->driver->connectBaselineCPU) {
         char *cpu;
 
-        cpu = conn->driver->cpuBaseline(conn, xmlCPUs, ncpus, flags);
+        cpu = conn->driver->connectBaselineCPU(conn, xmlCPUs, ncpus, flags);
         if (!cpu)
             goto error;
         return cpu;
@@ -17872,9 +17871,9 @@ virConnectDomainEventRegisterAny(virConnectPtr conn,
         goto error;
     }
 
-    if ((conn->driver) && (conn->driver->domainEventRegisterAny)) {
+    if ((conn->driver) && (conn->driver->connectDomainEventRegisterAny)) {
         int ret;
-        ret = conn->driver->domainEventRegisterAny(conn, dom, eventID, cb, opaque, freecb);
+        ret = conn->driver->connectDomainEventRegisterAny(conn, dom, eventID, cb, opaque, freecb);
         if (ret < 0)
             goto error;
         return ret;
@@ -17911,9 +17910,9 @@ virConnectDomainEventDeregisterAny(virConnectPtr conn,
     }
     virCheckNonNegativeArgGoto(callbackID, error);
 
-    if ((conn->driver) && (conn->driver->domainEventDeregisterAny)) {
+    if ((conn->driver) && (conn->driver->connectDomainEventDeregisterAny)) {
         int ret;
-        ret = conn->driver->domainEventDeregisterAny(conn, callbackID);
+        ret = conn->driver->connectDomainEventDeregisterAny(conn, callbackID);
         if (ret < 0)
             goto error;
         return ret;
@@ -20108,8 +20107,8 @@ int virConnectSetKeepAlive(virConnectPtr conn,
         return -1;
     }
 
-    if (conn->driver->setKeepAlive) {
-        ret = conn->driver->setKeepAlive(conn, interval, count);
+    if (conn->driver->connectSetKeepAlive) {
+        ret = conn->driver->connectSetKeepAlive(conn, interval, count);
         if (ret < 0)
             goto error;
         return ret;
@@ -20144,9 +20143,9 @@ int virConnectIsAlive(virConnectPtr conn)
         virDispatchError(NULL);
         return -1;
     }
-    if (conn->driver->isAlive) {
+    if (conn->driver->connectIsAlive) {
         int ret;
-        ret = conn->driver->isAlive(conn);
+        ret = conn->driver->connectIsAlive(conn);
         if (ret < 0)
             goto error;
         return ret;
diff --git a/src/libvirt_internal.h b/src/libvirt_internal.h
index 595d2db..7b49be2 100644
--- a/src/libvirt_internal.h
+++ b/src/libvirt_internal.h
@@ -113,7 +113,7 @@ enum {
 };
 
 
-int virDrvSupportsFeature (virConnectPtr conn, int feature);
+int virConnectSupportsFeature (virConnectPtr conn, int feature);
 
 int virDomainMigratePrepare (virConnectPtr dconn,
                              char **cookie,
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 82fb7ac..c4ae681 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -700,6 +700,7 @@ virFDStreamOpenFile;
 
 
 # libvirt_internal.h
+virConnectSupportsFeature;
 virDomainMigrateBegin3;
 virDomainMigrateConfirm3;
 virDomainMigrateFinish;
@@ -712,7 +713,6 @@ virDomainMigratePrepare2;
 virDomainMigratePrepare3;
 virDomainMigratePrepareTunnel;
 virDomainMigratePrepareTunnel3;
-virDrvSupportsFeature;
 virRegisterDeviceMonitor;
 virRegisterDriver;
 virRegisterInterfaceDriver;
diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c
index 30541ce..feb7161 100644
--- a/src/libxl/libxl_driver.c
+++ b/src/libxl/libxl_driver.c
@@ -4195,17 +4195,17 @@ libxlListAllDomains(virConnectPtr conn,
 static virDriver libxlDriver = {
     .no = VIR_DRV_LIBXL,
     .name = "xenlight",
-    .open = libxlOpen, /* 0.9.0 */
-    .close = libxlClose, /* 0.9.0 */
-    .type = libxlGetType, /* 0.9.0 */
-    .version = libxlGetVersion, /* 0.9.0 */
-    .getHostname = virGetHostname, /* 0.9.0 */
-    .getMaxVcpus = libxlGetMaxVcpus, /* 0.9.0 */
+    .connectOpen = libxlOpen, /* 0.9.0 */
+    .connectClose = libxlClose, /* 0.9.0 */
+    .connectGetType = libxlGetType, /* 0.9.0 */
+    .connectGetVersion = libxlGetVersion, /* 0.9.0 */
+    .connectGetHostname = virGetHostname, /* 0.9.0 */
+    .connectGetMaxVcpus = libxlGetMaxVcpus, /* 0.9.0 */
     .nodeGetInfo = libxlNodeGetInfo, /* 0.9.0 */
-    .getCapabilities = libxlGetCapabilities, /* 0.9.0 */
-    .listDomains = libxlListDomains, /* 0.9.0 */
-    .numOfDomains = libxlNumDomains, /* 0.9.0 */
-    .listAllDomains = libxlListAllDomains, /* 0.9.13 */
+    .connectGetCapabilities = libxlGetCapabilities, /* 0.9.0 */
+    .connectListDomains = libxlListDomains, /* 0.9.0 */
+    .connectNumOfDomains = libxlNumDomains, /* 0.9.0 */
+    .connectListAllDomains = libxlListAllDomains, /* 0.9.13 */
     .domainCreateXML = libxlDomainCreateXML, /* 0.9.0 */
     .domainLookupByID = libxlDomainLookupByID, /* 0.9.0 */
     .domainLookupByUUID = libxlDomainLookupByUUID, /* 0.9.0 */
@@ -4235,10 +4235,10 @@ static virDriver libxlDriver = {
     .domainPinVcpu = libxlDomainPinVcpu, /* 0.9.0 */
     .domainGetVcpus = libxlDomainGetVcpus, /* 0.9.0 */
     .domainGetXMLDesc = libxlDomainGetXMLDesc, /* 0.9.0 */
-    .domainXMLFromNative = libxlDomainXMLFromNative, /* 0.9.0 */
-    .domainXMLToNative = libxlDomainXMLToNative, /* 0.9.0 */
-    .listDefinedDomains = libxlListDefinedDomains, /* 0.9.0 */
-    .numOfDefinedDomains = libxlNumDefinedDomains, /* 0.9.0 */
+    .connectDomainXMLFromNative = libxlDomainXMLFromNative, /* 0.9.0 */
+    .connectDomainXMLToNative = libxlDomainXMLToNative, /* 0.9.0 */
+    .connectListDefinedDomains = libxlListDefinedDomains, /* 0.9.0 */
+    .connectNumOfDefinedDomains = libxlNumDefinedDomains, /* 0.9.0 */
     .domainCreate = libxlDomainCreate, /* 0.9.0 */
     .domainCreateWithFlags = libxlDomainCreateWithFlags, /* 0.9.0 */
     .domainDefineXML = libxlDomainDefineXML, /* 0.9.0 */
@@ -4257,24 +4257,24 @@ static virDriver libxlDriver = {
     .domainSetSchedulerParameters = libxlDomainSetSchedulerParameters, /* 0.9.0 */
     .domainSetSchedulerParametersFlags = libxlDomainSetSchedulerParametersFlags, /* 0.9.2 */
     .nodeGetFreeMemory = libxlNodeGetFreeMemory, /* 0.9.0 */
-    .domainEventRegister = libxlDomainEventRegister, /* 0.9.0 */
-    .domainEventDeregister = libxlDomainEventDeregister, /* 0.9.0 */
+    .connectDomainEventRegister = libxlDomainEventRegister, /* 0.9.0 */
+    .connectDomainEventDeregister = libxlDomainEventDeregister, /* 0.9.0 */
     .domainManagedSave = libxlDomainManagedSave, /* 0.9.2 */
     .domainHasManagedSaveImage = libxlDomainHasManagedSaveImage, /* 0.9.2 */
     .domainManagedSaveRemove = libxlDomainManagedSaveRemove, /* 0.9.2 */
     .domainIsActive = libxlDomainIsActive, /* 0.9.0 */
     .domainIsPersistent = libxlDomainIsPersistent, /* 0.9.0 */
     .domainIsUpdated = libxlDomainIsUpdated, /* 0.9.0 */
-    .domainEventRegisterAny = libxlDomainEventRegisterAny, /* 0.9.0 */
-    .domainEventDeregisterAny = libxlDomainEventDeregisterAny, /* 0.9.0 */
-    .isAlive = libxlIsAlive, /* 0.9.8 */
+    .connectDomainEventRegisterAny = libxlDomainEventRegisterAny, /* 0.9.0 */
+    .connectDomainEventDeregisterAny = libxlDomainEventDeregisterAny, /* 0.9.0 */
+    .connectIsAlive = libxlIsAlive, /* 0.9.8 */
 };
 
 static virStateDriver libxlStateDriver = {
     .name = "LIBXL",
-    .initialize = libxlStartup,
-    .cleanup = libxlShutdown,
-    .reload = libxlReload,
+    .stateInitialize = libxlStartup,
+    .stateCleanup = libxlShutdown,
+    .stateReload = libxlReload,
 };
 
 
diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c
index ba0fa0a..2a42b16 100644
--- a/src/lxc/lxc_driver.c
+++ b/src/lxc/lxc_driver.c
@@ -4399,16 +4399,16 @@ lxcGetSysinfo(virConnectPtr conn, unsigned int flags)
 static virDriver lxcDriver = {
     .no = VIR_DRV_LXC,
     .name = LXC_DRIVER_NAME,
-    .open = lxcOpen, /* 0.4.2 */
-    .close = lxcClose, /* 0.4.2 */
-    .version = lxcVersion, /* 0.4.6 */
-    .getHostname = virGetHostname, /* 0.6.3 */
-    .getSysinfo = lxcGetSysinfo, /* 1.0.5 */
+    .connectOpen = lxcOpen, /* 0.4.2 */
+    .connectClose = lxcClose, /* 0.4.2 */
+    .connectGetVersion = lxcVersion, /* 0.4.6 */
+    .connectGetHostname = virGetHostname, /* 0.6.3 */
+    .connectGetSysinfo = lxcGetSysinfo, /* 1.0.5 */
     .nodeGetInfo = nodeGetInfo, /* 0.6.5 */
-    .getCapabilities = lxcGetCapabilities, /* 0.6.5 */
-    .listDomains = lxcListDomains, /* 0.4.2 */
-    .numOfDomains = lxcNumDomains, /* 0.4.2 */
-    .listAllDomains = lxcListAllDomains, /* 0.9.13 */
+    .connectGetCapabilities = lxcGetCapabilities, /* 0.6.5 */
+    .connectListDomains = lxcListDomains, /* 0.4.2 */
+    .connectNumOfDomains = lxcNumDomains, /* 0.4.2 */
+    .connectListAllDomains = lxcListAllDomains, /* 0.9.13 */
     .domainCreateXML = lxcDomainCreateAndStart, /* 0.4.4 */
     .domainLookupByID = lxcDomainLookupByID, /* 0.4.2 */
     .domainLookupByUUID = lxcDomainLookupByUUID, /* 0.4.2 */
@@ -4430,8 +4430,8 @@ static virDriver lxcDriver = {
     .domainGetSecurityLabel = lxcDomainGetSecurityLabel, /* 0.9.10 */
     .nodeGetSecurityModel = lxcNodeGetSecurityModel, /* 0.9.10 */
     .domainGetXMLDesc = lxcDomainGetXMLDesc, /* 0.4.2 */
-    .listDefinedDomains = lxcListDefinedDomains, /* 0.4.2 */
-    .numOfDefinedDomains = lxcNumDefinedDomains, /* 0.4.2 */
+    .connectListDefinedDomains = lxcListDefinedDomains, /* 0.4.2 */
+    .connectNumOfDefinedDomains = lxcNumDefinedDomains, /* 0.4.2 */
     .domainCreate = lxcDomainStart, /* 0.4.4 */
     .domainCreateWithFlags = lxcDomainStartWithFlags, /* 0.8.2 */
     .domainDefineXML = lxcDomainDefine, /* 0.4.2 */
@@ -4455,17 +4455,17 @@ static virDriver lxcDriver = {
     .nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.6.5 */
     .nodeGetFreeMemory = nodeGetFreeMemory, /* 0.6.5 */
     .nodeGetCPUMap = nodeGetCPUMap, /* 1.0.0 */
-    .domainEventRegister = lxcDomainEventRegister, /* 0.7.0 */
-    .domainEventDeregister = lxcDomainEventDeregister, /* 0.7.0 */
-    .isEncrypted = lxcIsEncrypted, /* 0.7.3 */
-    .isSecure = lxcIsSecure, /* 0.7.3 */
+    .connectDomainEventRegister = lxcDomainEventRegister, /* 0.7.0 */
+    .connectDomainEventDeregister = lxcDomainEventDeregister, /* 0.7.0 */
+    .connectIsEncrypted = lxcIsEncrypted, /* 0.7.3 */
+    .connectIsSecure = lxcIsSecure, /* 0.7.3 */
     .domainIsActive = lxcDomainIsActive, /* 0.7.3 */
     .domainIsPersistent = lxcDomainIsPersistent, /* 0.7.3 */
     .domainIsUpdated = lxcDomainIsUpdated, /* 0.8.6 */
-    .domainEventRegisterAny = lxcDomainEventRegisterAny, /* 0.8.0 */
-    .domainEventDeregisterAny = lxcDomainEventDeregisterAny, /* 0.8.0 */
+    .connectDomainEventRegisterAny = lxcDomainEventRegisterAny, /* 0.8.0 */
+    .connectDomainEventDeregisterAny = lxcDomainEventDeregisterAny, /* 0.8.0 */
     .domainOpenConsole = lxcDomainOpenConsole, /* 0.8.6 */
-    .isAlive = lxcIsAlive, /* 0.9.8 */
+    .connectIsAlive = lxcIsAlive, /* 0.9.8 */
     .nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
     .nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
     .nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
@@ -4478,9 +4478,9 @@ static virDriver lxcDriver = {
 
 static virStateDriver lxcStateDriver = {
     .name = LXC_DRIVER_NAME,
-    .initialize = lxcStartup,
-    .cleanup = lxcShutdown,
-    .reload = lxcReload,
+    .stateInitialize = lxcStartup,
+    .stateCleanup = lxcShutdown,
+    .stateReload = lxcReload,
 };
 
 int lxcRegister(void)
diff --git a/src/network/bridge_driver.c b/src/network/bridge_driver.c
index 27dd230..ab37d85 100644
--- a/src/network/bridge_driver.c
+++ b/src/network/bridge_driver.c
@@ -3592,13 +3592,13 @@ cleanup:
 
 static virNetworkDriver networkDriver = {
     "Network",
-    .open = networkOpenNetwork, /* 0.2.0 */
-    .close = networkCloseNetwork, /* 0.2.0 */
-    .numOfNetworks = networkNumNetworks, /* 0.2.0 */
-    .listNetworks = networkListNetworks, /* 0.2.0 */
-    .numOfDefinedNetworks = networkNumDefinedNetworks, /* 0.2.0 */
-    .listDefinedNetworks = networkListDefinedNetworks, /* 0.2.0 */
-    .listAllNetworks = networkListAllNetworks, /* 0.10.2 */
+    .connectOpen = networkOpenNetwork, /* 0.2.0 */
+    .connectClose = networkCloseNetwork, /* 0.2.0 */
+    .connectNumOfNetworks = networkNumNetworks, /* 0.2.0 */
+    .connectListNetworks = networkListNetworks, /* 0.2.0 */
+    .connectNumOfDefinedNetworks = networkNumDefinedNetworks, /* 0.2.0 */
+    .connectListDefinedNetworks = networkListDefinedNetworks, /* 0.2.0 */
+    .connectListAllNetworks = networkListAllNetworks, /* 0.10.2 */
     .networkLookupByUUID = networkLookupByUUID, /* 0.2.0 */
     .networkLookupByName = networkLookupByName, /* 0.2.0 */
     .networkCreateXML = networkCreate, /* 0.2.0 */
@@ -3617,9 +3617,9 @@ static virNetworkDriver networkDriver = {
 
 static virStateDriver networkStateDriver = {
     .name = "Network",
-    .initialize  = networkStartup,
-    .cleanup = networkShutdown,
-    .reload = networkReload,
+    .stateInitialize  = networkStartup,
+    .stateCleanup = networkShutdown,
+    .stateReload = networkReload,
 };
 
 int networkRegister(void) {
diff --git a/src/node_device/node_device_hal.c b/src/node_device/node_device_hal.c
index 4955c43..16c59d9 100644
--- a/src/node_device/node_device_hal.c
+++ b/src/node_device/node_device_hal.c
@@ -763,27 +763,27 @@ static int halNodeDrvClose(virConnectPtr conn ATTRIBUTE_UNUSED)
 
 static virDeviceMonitor halDeviceMonitor = {
     .name = "halDeviceMonitor",
-    .open = halNodeDrvOpen, /* 0.5.0 */
-    .close = halNodeDrvClose, /* 0.5.0 */
-    .numOfDevices = nodeNumOfDevices, /* 0.5.0 */
-    .listDevices = nodeListDevices, /* 0.5.0 */
-    .listAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
-    .deviceLookupByName = nodeDeviceLookupByName, /* 0.5.0 */
-    .deviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
-    .deviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.5.0 */
-    .deviceGetParent = nodeDeviceGetParent, /* 0.5.0 */
-    .deviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.5.0 */
-    .deviceListCaps = nodeDeviceListCaps, /* 0.5.0 */
-    .deviceCreateXML = nodeDeviceCreateXML, /* 0.6.5 */
-    .deviceDestroy = nodeDeviceDestroy, /* 0.6.5 */
+    .connectOpen = halNodeDrvOpen, /* 0.5.0 */
+    .connectClose = halNodeDrvClose, /* 0.5.0 */
+    .nodeNumOfDevices = nodeNumOfDevices, /* 0.5.0 */
+    .nodeListDevices = nodeListDevices, /* 0.5.0 */
+    .connectListAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
+    .nodeDeviceLookupByName = nodeDeviceLookupByName, /* 0.5.0 */
+    .nodeDeviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
+    .nodeDeviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.5.0 */
+    .nodeDeviceGetParent = nodeDeviceGetParent, /* 0.5.0 */
+    .nodeDeviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.5.0 */
+    .nodeDeviceListCaps = nodeDeviceListCaps, /* 0.5.0 */
+    .nodeDeviceCreateXML = nodeDeviceCreateXML, /* 0.6.5 */
+    .nodeDeviceDestroy = nodeDeviceDestroy, /* 0.6.5 */
 };
 
 
 static virStateDriver halStateDriver = {
     .name = "HAL",
-    .initialize = halDeviceMonitorStartup, /* 0.5.0 */
-    .cleanup = halDeviceMonitorShutdown, /* 0.5.0 */
-    .reload = halDeviceMonitorReload, /* 0.5.0 */
+    .stateInitialize = halDeviceMonitorStartup, /* 0.5.0 */
+    .stateCleanup = halDeviceMonitorShutdown, /* 0.5.0 */
+    .stateReload = halDeviceMonitorReload, /* 0.5.0 */
 };
 
 int halNodeRegister(void)
diff --git a/src/node_device/node_device_udev.c b/src/node_device/node_device_udev.c
index 362a47f..353cac5 100644
--- a/src/node_device/node_device_udev.c
+++ b/src/node_device/node_device_udev.c
@@ -1793,26 +1793,26 @@ static int udevNodeDrvClose(virConnectPtr conn)
 
 static virDeviceMonitor udevDeviceMonitor = {
     .name = "udevDeviceMonitor",
-    .open = udevNodeDrvOpen, /* 0.7.3 */
-    .close = udevNodeDrvClose, /* 0.7.3 */
-    .numOfDevices = nodeNumOfDevices, /* 0.7.3 */
-    .listDevices = nodeListDevices, /* 0.7.3 */
-    .listAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
-    .deviceLookupByName = nodeDeviceLookupByName, /* 0.7.3 */
-    .deviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
-    .deviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.7.3 */
-    .deviceGetParent = nodeDeviceGetParent, /* 0.7.3 */
-    .deviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.7.3 */
-    .deviceListCaps = nodeDeviceListCaps, /* 0.7.3 */
-    .deviceCreateXML = nodeDeviceCreateXML, /* 0.7.3 */
-    .deviceDestroy = nodeDeviceDestroy, /* 0.7.3 */
+    .connectOpen = udevNodeDrvOpen, /* 0.7.3 */
+    .connectClose = udevNodeDrvClose, /* 0.7.3 */
+    .nodeNumOfDevices = nodeNumOfDevices, /* 0.7.3 */
+    .nodeListDevices = nodeListDevices, /* 0.7.3 */
+    .connectListAllNodeDevices = nodeListAllNodeDevices, /* 0.10.2 */
+    .nodeDeviceLookupByName = nodeDeviceLookupByName, /* 0.7.3 */
+    .nodeDeviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
+    .nodeDeviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.7.3 */
+    .nodeDeviceGetParent = nodeDeviceGetParent, /* 0.7.3 */
+    .nodeDeviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.7.3 */
+    .nodeDeviceListCaps = nodeDeviceListCaps, /* 0.7.3 */
+    .nodeDeviceCreateXML = nodeDeviceCreateXML, /* 0.7.3 */
+    .nodeDeviceDestroy = nodeDeviceDestroy, /* 0.7.3 */
 };
 
 static virStateDriver udevStateDriver = {
     .name = "udev",
-    .initialize = udevDeviceMonitorStartup, /* 0.7.3 */
-    .cleanup = udevDeviceMonitorShutdown, /* 0.7.3 */
-    .reload = udevDeviceMonitorReload, /* 0.7.3 */
+    .stateInitialize = udevDeviceMonitorStartup, /* 0.7.3 */
+    .stateCleanup = udevDeviceMonitorShutdown, /* 0.7.3 */
+    .stateReload = udevDeviceMonitorReload, /* 0.7.3 */
 };
 
 int udevNodeRegister(void)
diff --git a/src/nwfilter/nwfilter_driver.c b/src/nwfilter/nwfilter_driver.c
index 19ebb03..b2ffd73 100644
--- a/src/nwfilter/nwfilter_driver.c
+++ b/src/nwfilter/nwfilter_driver.c
@@ -659,24 +659,24 @@ nwfilterTeardownFilter(virDomainNetDefPtr net) {
 
 static virNWFilterDriver nwfilterDriver = {
     .name = "nwfilter",
-    .open = nwfilterOpen, /* 0.8.0 */
-    .close = nwfilterClose, /* 0.8.0 */
-    .numOfNWFilters = nwfilterNumNWFilters, /* 0.8.0 */
-    .listNWFilters = nwfilterListNWFilters, /* 0.8.0 */
-    .listAllNWFilters = nwfilterListAllNWFilters, /* 0.10.2 */
+    .connectOpen = nwfilterOpen, /* 0.8.0 */
+    .connectClose = nwfilterClose, /* 0.8.0 */
+    .connectNumOfNWFilters = nwfilterNumNWFilters, /* 0.8.0 */
+    .connectListNWFilters = nwfilterListNWFilters, /* 0.8.0 */
+    .connectListAllNWFilters = nwfilterListAllNWFilters, /* 0.10.2 */
     .nwfilterLookupByName = nwfilterLookupByName, /* 0.8.0 */
     .nwfilterLookupByUUID = nwfilterLookupByUUID, /* 0.8.0 */
-    .defineXML = nwfilterDefine, /* 0.8.0 */
-    .undefine = nwfilterUndefine, /* 0.8.0 */
-    .getXMLDesc = nwfilterGetXMLDesc, /* 0.8.0 */
+    .nwfilterDefineXML = nwfilterDefine, /* 0.8.0 */
+    .nwfilterUndefine = nwfilterUndefine, /* 0.8.0 */
+    .nwfilterGetXMLDesc = nwfilterGetXMLDesc, /* 0.8.0 */
 };
 
 
 static virStateDriver stateDriver = {
     .name = "NWFilter",
-    .initialize = nwfilterDriverStartup,
-    .cleanup = nwfilterDriverShutdown,
-    .reload = nwfilterDriverReload,
+    .stateInitialize = nwfilterDriverStartup,
+    .stateCleanup = nwfilterDriverShutdown,
+    .stateReload = nwfilterDriverReload,
 };
 
 
diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c
index 5d22c63..0e3d91d 100644
--- a/src/openvz/openvz_driver.c
+++ b/src/openvz/openvz_driver.c
@@ -2166,22 +2166,22 @@ openvzListAllDomains(virConnectPtr conn,
 static virDriver openvzDriver = {
     .no = VIR_DRV_OPENVZ,
     .name = "OPENVZ",
-    .open = openvzOpen, /* 0.3.1 */
-    .close = openvzClose, /* 0.3.1 */
-    .type = openvzGetType, /* 0.3.1 */
-    .version = openvzGetVersion, /* 0.5.0 */
-    .getHostname = virGetHostname, /* 0.9.12 */
-    .getMaxVcpus = openvzGetMaxVCPUs, /* 0.4.6 */
+    .connectOpen = openvzOpen, /* 0.3.1 */
+    .connectClose = openvzClose, /* 0.3.1 */
+    .connectGetType = openvzGetType, /* 0.3.1 */
+    .connectGetVersion = openvzGetVersion, /* 0.5.0 */
+    .connectGetHostname = virGetHostname, /* 0.9.12 */
+    .connectGetMaxVcpus = openvzGetMaxVCPUs, /* 0.4.6 */
     .nodeGetInfo = nodeGetInfo, /* 0.3.2 */
     .nodeGetCPUStats = nodeGetCPUStats, /* 0.9.12 */
     .nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.12 */
     .nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.9.12 */
     .nodeGetFreeMemory = nodeGetFreeMemory, /* 0.9.12 */
     .nodeGetCPUMap = nodeGetCPUMap, /* 1.0.0 */
-    .getCapabilities = openvzGetCapabilities, /* 0.4.6 */
-    .listDomains = openvzListDomains, /* 0.3.1 */
-    .numOfDomains = openvzNumDomains, /* 0.3.1 */
-    .listAllDomains = openvzListAllDomains, /* 0.9.13 */
+    .connectGetCapabilities = openvzGetCapabilities, /* 0.4.6 */
+    .connectListDomains = openvzListDomains, /* 0.3.1 */
+    .connectNumOfDomains = openvzNumDomains, /* 0.3.1 */
+    .connectListAllDomains = openvzListAllDomains, /* 0.9.13 */
     .domainCreateXML = openvzDomainCreateXML, /* 0.3.3 */
     .domainLookupByID = openvzDomainLookupByID, /* 0.3.1 */
     .domainLookupByUUID = openvzDomainLookupByUUID, /* 0.3.1 */
@@ -2203,8 +2203,8 @@ static virDriver openvzDriver = {
     .domainGetVcpusFlags = openvzDomainGetVcpusFlags, /* 0.8.5 */
     .domainGetMaxVcpus = openvzDomainGetMaxVcpus, /* 0.4.6 */
     .domainGetXMLDesc = openvzDomainGetXMLDesc, /* 0.4.6 */
-    .listDefinedDomains = openvzListDefinedDomains, /* 0.3.1 */
-    .numOfDefinedDomains = openvzNumDefinedDomains, /* 0.3.1 */
+    .connectListDefinedDomains = openvzListDefinedDomains, /* 0.3.1 */
+    .connectNumOfDefinedDomains = openvzNumDefinedDomains, /* 0.3.1 */
     .domainCreate = openvzDomainCreate, /* 0.3.1 */
     .domainCreateWithFlags = openvzDomainCreateWithFlags, /* 0.8.2 */
     .domainDefineXML = openvzDomainDefineXML, /* 0.3.3 */
@@ -2213,12 +2213,12 @@ static virDriver openvzDriver = {
     .domainGetAutostart = openvzDomainGetAutostart, /* 0.4.6 */
     .domainSetAutostart = openvzDomainSetAutostart, /* 0.4.6 */
     .domainInterfaceStats = openvzDomainInterfaceStats, /* 0.9.12 */
-    .isEncrypted = openvzIsEncrypted, /* 0.7.3 */
-    .isSecure = openvzIsSecure, /* 0.7.3 */
+    .connectIsEncrypted = openvzIsEncrypted, /* 0.7.3 */
+    .connectIsSecure = openvzIsSecure, /* 0.7.3 */
     .domainIsActive = openvzDomainIsActive, /* 0.7.3 */
     .domainIsPersistent = openvzDomainIsPersistent, /* 0.7.3 */
     .domainIsUpdated = openvzDomainIsUpdated, /* 0.8.6 */
-    .isAlive = openvzIsAlive, /* 0.9.8 */
+    .connectIsAlive = openvzIsAlive, /* 0.9.8 */
     .domainUpdateDeviceFlags = openvzDomainUpdateDeviceFlags, /* 0.9.13 */
     .domainGetHostname = openvzDomainGetHostname, /* 0.10.0 */
 };
diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c
index 0c0bfcb..851881e 100644
--- a/src/parallels/parallels_driver.c
+++ b/src/parallels/parallels_driver.c
@@ -2390,17 +2390,17 @@ parallelsDomainDefineXML(virConnectPtr conn, const char *xml)
 static virDriver parallelsDriver = {
     .no = VIR_DRV_PARALLELS,
     .name = "Parallels",
-    .open = parallelsOpen,            /* 0.10.0 */
-    .close = parallelsClose,          /* 0.10.0 */
-    .version = parallelsGetVersion,   /* 0.10.0 */
-    .getHostname = virGetHostname,      /* 0.10.0 */
+    .connectOpen = parallelsOpen,            /* 0.10.0 */
+    .connectClose = parallelsClose,          /* 0.10.0 */
+    .connectGetVersion = parallelsGetVersion,   /* 0.10.0 */
+    .connectGetHostname = virGetHostname,      /* 0.10.0 */
     .nodeGetInfo = nodeGetInfo,      /* 0.10.0 */
-    .getCapabilities = parallelsGetCapabilities,      /* 0.10.0 */
-    .listDomains = parallelsListDomains,      /* 0.10.0 */
-    .numOfDomains = parallelsNumOfDomains,    /* 0.10.0 */
-    .listDefinedDomains = parallelsListDefinedDomains,        /* 0.10.0 */
-    .numOfDefinedDomains = parallelsNumOfDefinedDomains,      /* 0.10.0 */
-    .listAllDomains = parallelsListAllDomains, /* 0.10.0 */
+    .connectGetCapabilities = parallelsGetCapabilities,      /* 0.10.0 */
+    .connectListDomains = parallelsListDomains,      /* 0.10.0 */
+    .connectNumOfDomains = parallelsNumOfDomains,    /* 0.10.0 */
+    .connectListDefinedDomains = parallelsListDefinedDomains,        /* 0.10.0 */
+    .connectNumOfDefinedDomains = parallelsNumOfDefinedDomains,      /* 0.10.0 */
+    .connectListAllDomains = parallelsListAllDomains, /* 0.10.0 */
     .domainLookupByID = parallelsLookupDomainByID,    /* 0.10.0 */
     .domainLookupByUUID = parallelsLookupDomainByUUID,        /* 0.10.0 */
     .domainLookupByName = parallelsLookupDomainByName,        /* 0.10.0 */
diff --git a/src/parallels/parallels_network.c b/src/parallels/parallels_network.c
index c5ece79..21de3bf 100644
--- a/src/parallels/parallels_network.c
+++ b/src/parallels/parallels_network.c
@@ -614,13 +614,13 @@ cleanup:
 }
 static virNetworkDriver parallelsNetworkDriver = {
     "Parallels",
-    .open = parallelsOpenNetwork, /* 1.0.1 */
-    .close = parallelsCloseNetwork, /* 1.0.1 */
-    .numOfNetworks = parallelsNumNetworks, /* 1.0.1 */
-    .listNetworks = parallelsListNetworks, /* 1.0.1 */
-    .numOfDefinedNetworks = parallelsNumDefinedNetworks, /* 1.0.1 */
-    .listDefinedNetworks = parallelsListDefinedNetworks, /* 1.0.1 */
-    .listAllNetworks = parallelsListAllNetworks, /* 1.0.1 */
+    .connectOpen = parallelsOpenNetwork, /* 1.0.1 */
+    .connectClose = parallelsCloseNetwork, /* 1.0.1 */
+    .connectNumOfNetworks = parallelsNumNetworks, /* 1.0.1 */
+    .connectListNetworks = parallelsListNetworks, /* 1.0.1 */
+    .connectNumOfDefinedNetworks = parallelsNumDefinedNetworks, /* 1.0.1 */
+    .connectListDefinedNetworks = parallelsListDefinedNetworks, /* 1.0.1 */
+    .connectListAllNetworks = parallelsListAllNetworks, /* 1.0.1 */
     .networkLookupByUUID = parallelsNetworkLookupByUUID, /* 1.0.1 */
     .networkLookupByName = parallelsNetworkLookupByName, /* 1.0.1 */
     .networkGetXMLDesc = parallelsNetworkGetXMLDesc, /* 1.0.1 */
diff --git a/src/parallels/parallels_storage.c b/src/parallels/parallels_storage.c
index ac65a1d..efa7d12 100644
--- a/src/parallels/parallels_storage.c
+++ b/src/parallels/parallels_storage.c
@@ -1671,39 +1671,39 @@ cleanup:
 
 static virStorageDriver parallelsStorageDriver = {
     .name = "Parallels",
-    .open = parallelsStorageOpen,     /* 0.10.0 */
-    .close = parallelsStorageClose,   /* 0.10.0 */
-
-    .numOfPools = parallelsStorageNumPools,   /* 0.10.0 */
-    .listPools = parallelsStorageListPools,   /* 0.10.0 */
-    .numOfDefinedPools = parallelsStorageNumDefinedPools,     /* 0.10.0 */
-    .listDefinedPools = parallelsStorageListDefinedPools,     /* 0.10.0 */
-    .poolLookupByName = parallelsStoragePoolLookupByName,     /* 0.10.0 */
-    .poolLookupByUUID = parallelsStoragePoolLookupByUUID,     /* 0.10.0 */
-    .poolLookupByVolume = parallelsStoragePoolLookupByVolume, /* 0.10.0 */
-    .poolDefineXML = parallelsStoragePoolDefine,      /* 0.10.0 */
-    .poolUndefine = parallelsStoragePoolUndefine,     /* 0.10.0 */
-    .poolCreate = parallelsStoragePoolStart,  /* 0.10.0 */
-    .poolDestroy = parallelsStoragePoolDestroy,       /* 0.10.0 */
-    .poolRefresh = parallelsStoragePoolRefresh,       /* 0.10.0 */
-    .poolGetInfo = parallelsStoragePoolGetInfo,       /* 0.10.0 */
-    .poolGetXMLDesc = parallelsStoragePoolGetXMLDesc, /* 0.10.0 */
-    .poolGetAutostart = parallelsStoragePoolGetAutostart,     /* 0.10.0 */
-    .poolSetAutostart = parallelsStoragePoolSetAutostart,     /* 0.10.0 */
-    .poolNumOfVolumes = parallelsStoragePoolNumVolumes,       /* 0.10.0 */
-    .poolListVolumes = parallelsStoragePoolListVolumes,       /* 0.10.0 */
-
-    .volLookupByName = parallelsStorageVolumeLookupByName,    /* 0.10.0 */
-    .volLookupByKey = parallelsStorageVolumeLookupByKey,      /* 0.10.0 */
-    .volLookupByPath = parallelsStorageVolumeLookupByPath,    /* 0.10.0 */
-    .volCreateXML = parallelsStorageVolumeCreateXML,  /* 0.10.0 */
-    .volCreateXMLFrom = parallelsStorageVolumeCreateXMLFrom,  /* 0.10.0 */
-    .volDelete = parallelsStorageVolumeDelete,        /* 0.10.0 */
-    .volGetInfo = parallelsStorageVolumeGetInfo,      /* 0.10.0 */
-    .volGetXMLDesc = parallelsStorageVolumeGetXMLDesc,        /* 0.10.0 */
-    .volGetPath = parallelsStorageVolumeGetPath,      /* 0.10.0 */
-    .poolIsActive = parallelsStoragePoolIsActive,     /* 0.10.0 */
-    .poolIsPersistent = parallelsStoragePoolIsPersistent,     /* 0.10.0 */
+    .connectOpen = parallelsStorageOpen,     /* 0.10.0 */
+    .connectClose = parallelsStorageClose,   /* 0.10.0 */
+
+    .connectNumOfStoragePools = parallelsStorageNumPools,   /* 0.10.0 */
+    .connectListStoragePools = parallelsStorageListPools,   /* 0.10.0 */
+    .connectNumOfDefinedStoragePools = parallelsStorageNumDefinedPools,     /* 0.10.0 */
+    .connectListDefinedStoragePools = parallelsStorageListDefinedPools,     /* 0.10.0 */
+    .storagePoolLookupByName = parallelsStoragePoolLookupByName,     /* 0.10.0 */
+    .storagePoolLookupByUUID = parallelsStoragePoolLookupByUUID,     /* 0.10.0 */
+    .storagePoolLookupByVolume = parallelsStoragePoolLookupByVolume, /* 0.10.0 */
+    .storagePoolDefineXML = parallelsStoragePoolDefine,      /* 0.10.0 */
+    .storagePoolUndefine = parallelsStoragePoolUndefine,     /* 0.10.0 */
+    .storagePoolCreate = parallelsStoragePoolStart,  /* 0.10.0 */
+    .storagePoolDestroy = parallelsStoragePoolDestroy,       /* 0.10.0 */
+    .storagePoolRefresh = parallelsStoragePoolRefresh,       /* 0.10.0 */
+    .storagePoolGetInfo = parallelsStoragePoolGetInfo,       /* 0.10.0 */
+    .storagePoolGetXMLDesc = parallelsStoragePoolGetXMLDesc, /* 0.10.0 */
+    .storagePoolGetAutostart = parallelsStoragePoolGetAutostart,     /* 0.10.0 */
+    .storagePoolSetAutostart = parallelsStoragePoolSetAutostart,     /* 0.10.0 */
+    .storagePoolNumOfVolumes = parallelsStoragePoolNumVolumes,       /* 0.10.0 */
+    .storagePoolListVolumes = parallelsStoragePoolListVolumes,       /* 0.10.0 */
+
+    .storageVolLookupByName = parallelsStorageVolumeLookupByName,    /* 0.10.0 */
+    .storageVolLookupByKey = parallelsStorageVolumeLookupByKey,      /* 0.10.0 */
+    .storageVolLookupByPath = parallelsStorageVolumeLookupByPath,    /* 0.10.0 */
+    .storageVolCreateXML = parallelsStorageVolumeCreateXML,  /* 0.10.0 */
+    .storageVolCreateXMLFrom = parallelsStorageVolumeCreateXMLFrom,  /* 0.10.0 */
+    .storageVolDelete = parallelsStorageVolumeDelete,        /* 0.10.0 */
+    .storageVolGetInfo = parallelsStorageVolumeGetInfo,      /* 0.10.0 */
+    .storageVolGetXMLDesc = parallelsStorageVolumeGetXMLDesc,        /* 0.10.0 */
+    .storageVolGetPath = parallelsStorageVolumeGetPath,      /* 0.10.0 */
+    .storagePoolIsActive = parallelsStoragePoolIsActive,     /* 0.10.0 */
+    .storagePoolIsPersistent = parallelsStoragePoolIsPersistent,     /* 0.10.0 */
 };
 
 int
diff --git a/src/phyp/phyp_driver.c b/src/phyp/phyp_driver.c
index d6d9b0c..e188785 100644
--- a/src/phyp/phyp_driver.c
+++ b/src/phyp/phyp_driver.c
@@ -3764,11 +3764,11 @@ phypVIOSDriverClose(virConnectPtr conn ATTRIBUTE_UNUSED)
 static virDriver phypDriver = {
     .no = VIR_DRV_PHYP,
     .name = "PHYP",
-    .open = phypOpen, /* 0.7.0 */
-    .close = phypClose, /* 0.7.0 */
-    .getCapabilities = phypConnectGetCapabilities, /* 0.7.3 */
-    .listDomains = phypListDomains, /* 0.7.0 */
-    .numOfDomains = phypNumDomains, /* 0.7.0 */
+    .connectOpen = phypOpen, /* 0.7.0 */
+    .connectClose = phypClose, /* 0.7.0 */
+    .connectGetCapabilities = phypConnectGetCapabilities, /* 0.7.3 */
+    .connectListDomains = phypListDomains, /* 0.7.0 */
+    .connectNumOfDomains = phypNumDomains, /* 0.7.0 */
     .domainCreateXML = phypDomainCreateAndStart, /* 0.7.3 */
     .domainLookupByID = phypDomainLookupByID, /* 0.7.0 */
     .domainLookupByName = phypDomainLookupByName, /* 0.7.0 */
@@ -3784,43 +3784,43 @@ static virDriver phypDriver = {
     .domainGetVcpusFlags = phypDomainGetVcpusFlags, /* 0.8.5 */
     .domainGetMaxVcpus = phypGetLparCPUMAX, /* 0.7.3 */
     .domainGetXMLDesc = phypDomainGetXMLDesc, /* 0.7.0 */
-    .listDefinedDomains = phypListDefinedDomains, /* 0.7.0 */
-    .numOfDefinedDomains = phypNumDefinedDomains, /* 0.7.0 */
+    .connectListDefinedDomains = phypListDefinedDomains, /* 0.7.0 */
+    .connectNumOfDefinedDomains = phypNumDefinedDomains, /* 0.7.0 */
     .domainAttachDevice = phypAttachDevice, /* 0.8.2 */
-    .isEncrypted = phypIsEncrypted, /* 0.7.3 */
-    .isSecure = phypIsSecure, /* 0.7.3 */
+    .connectIsEncrypted = phypIsEncrypted, /* 0.7.3 */
+    .connectIsSecure = phypIsSecure, /* 0.7.3 */
     .domainIsUpdated = phypIsUpdated, /* 0.8.6 */
-    .isAlive = phypIsAlive, /* 0.9.8 */
+    .connectIsAlive = phypIsAlive, /* 0.9.8 */
 };
 
 static virStorageDriver phypStorageDriver = {
     .name = "PHYP",
-    .open = phypVIOSDriverOpen, /* 0.8.2 */
-    .close = phypVIOSDriverClose, /* 0.8.2 */
-
-    .numOfPools = phypNumOfStoragePools, /* 0.8.2 */
-    .listPools = phypListStoragePools, /* 0.8.2 */
-    .poolLookupByName = phypStoragePoolLookupByName, /* 0.8.2 */
-    .poolLookupByUUID = phypGetStoragePoolLookUpByUUID, /* 0.8.2 */
-    .poolCreateXML = phypStoragePoolCreateXML, /* 0.8.2 */
-    .poolDestroy = phypDestroyStoragePool, /* 0.8.2 */
-    .poolGetXMLDesc = phypGetStoragePoolXMLDesc, /* 0.8.2 */
-    .poolNumOfVolumes = phypStoragePoolNumOfVolumes, /* 0.8.2 */
-    .poolListVolumes = phypStoragePoolListVolumes, /* 0.8.2 */
-
-    .volLookupByName = phypVolumeLookupByName, /* 0.8.2 */
-    .volLookupByPath = phypVolumeLookupByPath, /* 0.8.2 */
-    .volCreateXML = phypStorageVolCreateXML, /* 0.8.2 */
-    .volGetXMLDesc = phypVolumeGetXMLDesc, /* 0.8.2 */
-    .volGetPath = phypVolumeGetPath, /* 0.8.2 */
+    .connectOpen = phypVIOSDriverOpen, /* 0.8.2 */
+    .connectClose = phypVIOSDriverClose, /* 0.8.2 */
+
+    .connectNumOfStoragePools = phypNumOfStoragePools, /* 0.8.2 */
+    .connectListStoragePools = phypListStoragePools, /* 0.8.2 */
+    .storagePoolLookupByName = phypStoragePoolLookupByName, /* 0.8.2 */
+    .storagePoolLookupByUUID = phypGetStoragePoolLookUpByUUID, /* 0.8.2 */
+    .storagePoolCreateXML = phypStoragePoolCreateXML, /* 0.8.2 */
+    .storagePoolDestroy = phypDestroyStoragePool, /* 0.8.2 */
+    .storagePoolGetXMLDesc = phypGetStoragePoolXMLDesc, /* 0.8.2 */
+    .storagePoolNumOfVolumes = phypStoragePoolNumOfVolumes, /* 0.8.2 */
+    .storagePoolListVolumes = phypStoragePoolListVolumes, /* 0.8.2 */
+
+    .storageVolLookupByName = phypVolumeLookupByName, /* 0.8.2 */
+    .storageVolLookupByPath = phypVolumeLookupByPath, /* 0.8.2 */
+    .storageVolCreateXML = phypStorageVolCreateXML, /* 0.8.2 */
+    .storageVolGetXMLDesc = phypVolumeGetXMLDesc, /* 0.8.2 */
+    .storageVolGetPath = phypVolumeGetPath, /* 0.8.2 */
 };
 
 static virInterfaceDriver phypInterfaceDriver = {
     .name = "PHYP",
-    .open = phypVIOSDriverOpen, /* 0.9.1 */
-    .close = phypVIOSDriverClose, /* 0.9.1 */
-    .numOfInterfaces = phypNumOfInterfaces, /* 0.9.1 */
-    .listInterfaces = phypListInterfaces, /* 0.9.1 */
+    .connectOpen = phypVIOSDriverOpen, /* 0.9.1 */
+    .connectClose = phypVIOSDriverClose, /* 0.9.1 */
+    .connectNumOfInterfaces = phypNumOfInterfaces, /* 0.9.1 */
+    .connectListInterfaces = phypListInterfaces, /* 0.9.1 */
     .interfaceLookupByName = phypInterfaceLookupByName, /* 0.9.1 */
     .interfaceDefineXML = phypInterfaceDefineXML, /* 0.9.1 */
     .interfaceDestroy = phypInterfaceDestroy, /* 0.9.1 */
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index 05c12b2..8670c5c 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -2076,8 +2076,8 @@ qemuBuildRBDString(virConnectPtr conn,
         if (sec) {
             char *base64 = NULL;
 
-            secret = (char *)conn->secretDriver->getValue(sec, &secret_size, 0,
-                                                          VIR_SECRET_GET_VALUE_INTERNAL_CALL);
+            secret = (char *)conn->secretDriver->secretGetValue(sec, &secret_size, 0,
+                                                                VIR_SECRET_GET_VALUE_INTERNAL_CALL);
             if (secret == NULL) {
                 virReportError(VIR_ERR_INTERNAL_ERROR,
                                _("could not get the value of the secret for username %s"),
@@ -2522,8 +2522,8 @@ qemuBuildDriveURIString(virConnectPtr conn,
         }
 
         if (sec) {
-            secret = (char *)conn->secretDriver->getValue(sec, &secret_size, 0,
-                                                          VIR_SECRET_GET_VALUE_INTERNAL_CALL);
+            secret = (char *)conn->secretDriver->secretGetValue(sec, &secret_size, 0,
+                                                                VIR_SECRET_GET_VALUE_INTERNAL_CALL);
             if (secret == NULL) {
                 virReportError(VIR_ERR_INTERNAL_ERROR,
                                _("could not get the value of the secret for username %s"),
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index d23c26a..0dc5e80 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -14626,19 +14626,19 @@ cleanup:
 static virDriver qemuDriver = {
     .no = VIR_DRV_QEMU,
     .name = QEMU_DRIVER_NAME,
-    .open = qemuOpen, /* 0.2.0 */
-    .close = qemuClose, /* 0.2.0 */
-    .supports_feature = qemuSupportsFeature, /* 0.5.0 */
-    .type = qemuGetType, /* 0.2.0 */
-    .version = qemuGetVersion, /* 0.2.0 */
-    .getHostname = virGetHostname, /* 0.3.3 */
-    .getSysinfo = qemuGetSysinfo, /* 0.8.8 */
-    .getMaxVcpus = qemuGetMaxVCPUs, /* 0.2.1 */
+    .connectOpen = qemuOpen, /* 0.2.0 */
+    .connectClose = qemuClose, /* 0.2.0 */
+    .connectSupportsFeature = qemuSupportsFeature, /* 0.5.0 */
+    .connectGetType = qemuGetType, /* 0.2.0 */
+    .connectGetVersion = qemuGetVersion, /* 0.2.0 */
+    .connectGetHostname = virGetHostname, /* 0.3.3 */
+    .connectGetSysinfo = qemuGetSysinfo, /* 0.8.8 */
+    .connectGetMaxVcpus = qemuGetMaxVCPUs, /* 0.2.1 */
     .nodeGetInfo = nodeGetInfo, /* 0.2.0 */
-    .getCapabilities = qemuGetCapabilities, /* 0.2.1 */
-    .listDomains = qemuListDomains, /* 0.2.0 */
-    .numOfDomains = qemuNumDomains, /* 0.2.0 */
-    .listAllDomains = qemuListAllDomains, /* 0.9.13 */
+    .connectGetCapabilities = qemuGetCapabilities, /* 0.2.1 */
+    .connectListDomains = qemuListDomains, /* 0.2.0 */
+    .connectNumOfDomains = qemuNumDomains, /* 0.2.0 */
+    .connectListAllDomains = qemuListAllDomains, /* 0.9.13 */
     .domainCreateXML = qemuDomainCreate, /* 0.2.0 */
     .domainLookupByID = qemuDomainLookupByID, /* 0.2.0 */
     .domainLookupByUUID = qemuDomainLookupByUUID, /* 0.2.0 */
@@ -14685,10 +14685,10 @@ static virDriver qemuDriver = {
     .domainGetSecurityLabelList = qemuDomainGetSecurityLabelList, /* 0.10.0 */
     .nodeGetSecurityModel = qemuNodeGetSecurityModel, /* 0.6.1 */
     .domainGetXMLDesc = qemuDomainGetXMLDesc, /* 0.2.0 */
-    .domainXMLFromNative = qemuDomainXMLFromNative, /* 0.6.4 */
-    .domainXMLToNative = qemuDomainXMLToNative, /* 0.6.4 */
-    .listDefinedDomains = qemuListDefinedDomains, /* 0.2.0 */
-    .numOfDefinedDomains = qemuNumDefinedDomains, /* 0.2.0 */
+    .connectDomainXMLFromNative = qemuDomainXMLFromNative, /* 0.6.4 */
+    .connectDomainXMLToNative = qemuDomainXMLToNative, /* 0.6.4 */
+    .connectListDefinedDomains = qemuListDefinedDomains, /* 0.2.0 */
+    .connectNumOfDefinedDomains = qemuNumDefinedDomains, /* 0.2.0 */
     .domainCreate = qemuDomainStart, /* 0.2.0 */
     .domainCreateWithFlags = qemuDomainStartWithFlags, /* 0.8.2 */
     .domainDefineXML = qemuDomainDefine, /* 0.2.0 */
@@ -14719,21 +14719,21 @@ static virDriver qemuDriver = {
     .nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.3 */
     .nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.4.4 */
     .nodeGetFreeMemory = nodeGetFreeMemory, /* 0.4.4 */
-    .domainEventRegister = qemuDomainEventRegister, /* 0.5.0 */
-    .domainEventDeregister = qemuDomainEventDeregister, /* 0.5.0 */
+    .connectDomainEventRegister = qemuDomainEventRegister, /* 0.5.0 */
+    .connectDomainEventDeregister = qemuDomainEventDeregister, /* 0.5.0 */
     .domainMigratePrepare2 = qemuDomainMigratePrepare2, /* 0.5.0 */
     .domainMigrateFinish2 = qemuDomainMigrateFinish2, /* 0.5.0 */
     .nodeDeviceDettach = qemuNodeDeviceDettach, /* 0.6.1 */
     .nodeDeviceReAttach = qemuNodeDeviceReAttach, /* 0.6.1 */
     .nodeDeviceReset = qemuNodeDeviceReset, /* 0.6.1 */
     .domainMigratePrepareTunnel = qemuDomainMigratePrepareTunnel, /* 0.7.2 */
-    .isEncrypted = qemuIsEncrypted, /* 0.7.3 */
-    .isSecure = qemuIsSecure, /* 0.7.3 */
+    .connectIsEncrypted = qemuIsEncrypted, /* 0.7.3 */
+    .connectIsSecure = qemuIsSecure, /* 0.7.3 */
     .domainIsActive = qemuDomainIsActive, /* 0.7.3 */
     .domainIsPersistent = qemuDomainIsPersistent, /* 0.7.3 */
     .domainIsUpdated = qemuDomainIsUpdated, /* 0.8.6 */
-    .cpuCompare = qemuCPUCompare, /* 0.7.5 */
-    .cpuBaseline = qemuCPUBaseline, /* 0.7.7 */
+    .connectCompareCPU = qemuCPUCompare, /* 0.7.5 */
+    .connectBaselineCPU = qemuCPUBaseline, /* 0.7.7 */
     .domainGetJobInfo = qemuDomainGetJobInfo, /* 0.7.7 */
     .domainGetJobStats = qemuDomainGetJobStats, /* 1.0.3 */
     .domainAbortJob = qemuDomainAbortJob, /* 0.7.7 */
@@ -14742,8 +14742,8 @@ static virDriver qemuDriver = {
     .domainMigrateSetCompressionCache = qemuDomainMigrateSetCompressionCache, /* 1.0.3 */
     .domainMigrateSetMaxSpeed = qemuDomainMigrateSetMaxSpeed, /* 0.9.0 */
     .domainMigrateGetMaxSpeed = qemuDomainMigrateGetMaxSpeed, /* 0.9.5 */
-    .domainEventRegisterAny = qemuDomainEventRegisterAny, /* 0.8.0 */
-    .domainEventDeregisterAny = qemuDomainEventDeregisterAny, /* 0.8.0 */
+    .connectDomainEventRegisterAny = qemuDomainEventRegisterAny, /* 0.8.0 */
+    .connectDomainEventDeregisterAny = qemuDomainEventDeregisterAny, /* 0.8.0 */
     .domainManagedSave = qemuDomainManagedSave, /* 0.8.0 */
     .domainHasManagedSaveImage = qemuDomainHasManagedSaveImage, /* 0.8.0 */
     .domainManagedSaveRemove = qemuDomainManagedSaveRemove, /* 0.8.0 */
@@ -14763,9 +14763,9 @@ static virDriver qemuDriver = {
     .domainSnapshotHasMetadata = qemuDomainSnapshotHasMetadata, /* 0.9.13 */
     .domainRevertToSnapshot = qemuDomainRevertToSnapshot, /* 0.8.0 */
     .domainSnapshotDelete = qemuDomainSnapshotDelete, /* 0.8.0 */
-    .qemuDomainMonitorCommand = qemuDomainMonitorCommand, /* 0.8.3 */
-    .qemuDomainAttach = qemuDomainAttach, /* 0.9.4 */
-    .qemuDomainArbitraryAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
+    .domainQemuMonitorCommand = qemuDomainMonitorCommand, /* 0.8.3 */
+    .domainQemuAttach = qemuDomainAttach, /* 0.9.4 */
+    .domainQemuAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
     .domainOpenConsole = qemuDomainOpenConsole, /* 0.8.6 */
     .domainOpenGraphics = qemuDomainOpenGraphics, /* 0.9.7 */
     .domainInjectNMI = qemuDomainInjectNMI, /* 0.9.2 */
@@ -14782,7 +14782,7 @@ static virDriver qemuDriver = {
     .domainBlockPull = qemuDomainBlockPull, /* 0.9.4 */
     .domainBlockRebase = qemuDomainBlockRebase, /* 0.9.10 */
     .domainBlockCommit = qemuDomainBlockCommit, /* 1.0.0 */
-    .isAlive = qemuIsAlive, /* 0.9.8 */
+    .connectIsAlive = qemuIsAlive, /* 0.9.8 */
     .nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
     .domainSetBlockIoTune = qemuDomainSetBlockIoTune, /* 0.9.8 */
     .domainGetBlockIoTune = qemuDomainGetBlockIoTune, /* 0.9.8 */
@@ -14806,10 +14806,10 @@ static virDriver qemuDriver = {
 
 static virStateDriver qemuStateDriver = {
     .name = "QEMU",
-    .initialize = qemuStartup,
-    .cleanup = qemuShutdown,
-    .reload = qemuReload,
-    .stop = qemuStop,
+    .stateInitialize = qemuStartup,
+    .stateCleanup = qemuShutdown,
+    .stateReload = qemuReload,
+    .stateStop = qemuStop,
 };
 
 int qemuRegister(void) {
diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index 4988d9b..5fea5e8 100644
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -429,8 +429,8 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
     }
 
     if (conn->secretDriver == NULL ||
-        conn->secretDriver->lookupByUUID == NULL ||
-        conn->secretDriver->getValue == NULL) {
+        conn->secretDriver->secretLookupByUUID == NULL ||
+        conn->secretDriver->secretGetValue == NULL) {
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                        _("secret storage not supported"));
         goto cleanup;
@@ -445,12 +445,12 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
         goto cleanup;
     }
 
-    secret = conn->secretDriver->lookupByUUID(conn,
-                                              enc->secrets[0]->uuid);
+    secret = conn->secretDriver->secretLookupByUUID(conn,
+                                                    enc->secrets[0]->uuid);
     if (secret == NULL)
         goto cleanup;
-    data = conn->secretDriver->getValue(secret, &size, 0,
-                                        VIR_SECRET_GET_VALUE_INTERNAL_CALL);
+    data = conn->secretDriver->secretGetValue(secret, &size, 0,
+                                              VIR_SECRET_GET_VALUE_INTERNAL_CALL);
     virObjectUnref(secret);
     if (data == NULL)
         goto cleanup;
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 6790f78..4aec150 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -4949,9 +4949,9 @@ static virStreamDriver remoteStreamDrv = {
     .streamSend = remoteStreamSend,
     .streamFinish = remoteStreamFinish,
     .streamAbort = remoteStreamAbort,
-    .streamAddCallback = remoteStreamEventAddCallback,
-    .streamUpdateCallback = remoteStreamEventUpdateCallback,
-    .streamRemoveCallback = remoteStreamEventRemoveCallback,
+    .streamEventAddCallback = remoteStreamEventAddCallback,
+    .streamEventUpdateCallback = remoteStreamEventUpdateCallback,
+    .streamEventRemoveCallback = remoteStreamEventRemoveCallback,
 };
 
 
@@ -6120,20 +6120,20 @@ unsigned long remoteVersion(void)
 static virDriver remote_driver = {
     .no = VIR_DRV_REMOTE,
     .name = "remote",
-    .open = remoteOpen, /* 0.3.0 */
-    .close = remoteClose, /* 0.3.0 */
-    .supports_feature = remoteConnectSupportsFeature, /* 0.3.0 */
-    .type = remoteConnectGetType, /* 0.3.0 */
-    .version = remoteConnectGetVersion, /* 0.3.0 */
-    .libvirtVersion = remoteConnectGetLibVersion, /* 0.7.3 */
-    .getHostname = remoteConnectGetHostname, /* 0.3.0 */
-    .getSysinfo = remoteConnectGetSysinfo, /* 0.8.8 */
-    .getMaxVcpus = remoteConnectGetMaxVcpus, /* 0.3.0 */
+    .connectOpen = remoteOpen, /* 0.3.0 */
+    .connectClose = remoteClose, /* 0.3.0 */
+    .connectSupportsFeature = remoteConnectSupportsFeature, /* 0.3.0 */
+    .connectGetType = remoteConnectGetType, /* 0.3.0 */
+    .connectGetVersion = remoteConnectGetVersion, /* 0.3.0 */
+    .connectGetLibVersion = remoteConnectGetLibVersion, /* 0.7.3 */
+    .connectGetHostname = remoteConnectGetHostname, /* 0.3.0 */
+    .connectGetSysinfo = remoteConnectGetSysinfo, /* 0.8.8 */
+    .connectGetMaxVcpus = remoteConnectGetMaxVcpus, /* 0.3.0 */
     .nodeGetInfo = remoteNodeGetInfo, /* 0.3.0 */
-    .getCapabilities = remoteConnectGetCapabilities, /* 0.3.0 */
-    .listDomains = remoteConnectListDomains, /* 0.3.0 */
-    .numOfDomains = remoteConnectNumOfDomains, /* 0.3.0 */
-    .listAllDomains = remoteConnectListAllDomains, /* 0.9.13 */
+    .connectGetCapabilities = remoteConnectGetCapabilities, /* 0.3.0 */
+    .connectListDomains = remoteConnectListDomains, /* 0.3.0 */
+    .connectNumOfDomains = remoteConnectNumOfDomains, /* 0.3.0 */
+    .connectListAllDomains = remoteConnectListAllDomains, /* 0.9.13 */
     .domainCreateXML = remoteDomainCreateXML, /* 0.3.0 */
     .domainLookupByID = remoteDomainLookupByID, /* 0.3.0 */
     .domainLookupByUUID = remoteDomainLookupByUUID, /* 0.3.0 */
@@ -6182,10 +6182,10 @@ static virDriver remote_driver = {
     .domainGetSecurityLabelList = remoteDomainGetSecurityLabelList, /* 0.10.0 */
     .nodeGetSecurityModel = remoteNodeGetSecurityModel, /* 0.6.1 */
     .domainGetXMLDesc = remoteDomainGetXMLDesc, /* 0.3.0 */
-    .domainXMLFromNative = remoteConnectDomainXMLFromNative, /* 0.6.4 */
-    .domainXMLToNative = remoteConnectDomainXMLToNative, /* 0.6.4 */
-    .listDefinedDomains = remoteConnectListDefinedDomains, /* 0.3.0 */
-    .numOfDefinedDomains = remoteConnectNumOfDefinedDomains, /* 0.3.0 */
+    .connectDomainXMLFromNative = remoteConnectDomainXMLFromNative, /* 0.6.4 */
+    .connectDomainXMLToNative = remoteConnectDomainXMLToNative, /* 0.6.4 */
+    .connectListDefinedDomains = remoteConnectListDefinedDomains, /* 0.3.0 */
+    .connectNumOfDefinedDomains = remoteConnectNumOfDefinedDomains, /* 0.3.0 */
     .domainCreate = remoteDomainCreate, /* 0.3.0 */
     .domainCreateWithFlags = remoteDomainCreateWithFlags, /* 0.8.2 */
     .domainDefineXML = remoteDomainDefineXML, /* 0.3.0 */
@@ -6220,21 +6220,21 @@ static virDriver remote_driver = {
     .nodeGetMemoryStats = remoteNodeGetMemoryStats, /* 0.9.3 */
     .nodeGetCellsFreeMemory = remoteNodeGetCellsFreeMemory, /* 0.3.3 */
     .nodeGetFreeMemory = remoteNodeGetFreeMemory, /* 0.3.3 */
-    .domainEventRegister = remoteConnectDomainEventRegister, /* 0.5.0 */
-    .domainEventDeregister = remoteConnectDomainEventDeregister, /* 0.5.0 */
+    .connectDomainEventRegister = remoteConnectDomainEventRegister, /* 0.5.0 */
+    .connectDomainEventDeregister = remoteConnectDomainEventDeregister, /* 0.5.0 */
     .domainMigratePrepare2 = remoteDomainMigratePrepare2, /* 0.5.0 */
     .domainMigrateFinish2 = remoteDomainMigrateFinish2, /* 0.5.0 */
     .nodeDeviceDettach = remoteNodeDeviceDettach, /* 0.6.1 */
     .nodeDeviceReAttach = remoteNodeDeviceReAttach, /* 0.6.1 */
     .nodeDeviceReset = remoteNodeDeviceReset, /* 0.6.1 */
     .domainMigratePrepareTunnel = remoteDomainMigratePrepareTunnel, /* 0.7.2 */
-    .isEncrypted = remoteConnectIsEncrypted, /* 0.7.3 */
-    .isSecure = remoteConnectIsSecure, /* 0.7.3 */
+    .connectIsEncrypted = remoteConnectIsEncrypted, /* 0.7.3 */
+    .connectIsSecure = remoteConnectIsSecure, /* 0.7.3 */
     .domainIsActive = remoteDomainIsActive, /* 0.7.3 */
     .domainIsPersistent = remoteDomainIsPersistent, /* 0.7.3 */
     .domainIsUpdated = remoteDomainIsUpdated, /* 0.8.6 */
-    .cpuCompare = remoteConnectCompareCPU, /* 0.7.5 */
-    .cpuBaseline = remoteConnectBaselineCPU, /* 0.7.7 */
+    .connectCompareCPU = remoteConnectCompareCPU, /* 0.7.5 */
+    .connectBaselineCPU = remoteConnectBaselineCPU, /* 0.7.7 */
     .domainGetJobInfo = remoteDomainGetJobInfo, /* 0.7.7 */
     .domainGetJobStats = remoteDomainGetJobStats, /* 1.0.3 */
     .domainAbortJob = remoteDomainAbortJob, /* 0.7.7 */
@@ -6243,8 +6243,8 @@ static virDriver remote_driver = {
     .domainMigrateSetCompressionCache = remoteDomainMigrateSetCompressionCache, /* 1.0.3 */
     .domainMigrateSetMaxSpeed = remoteDomainMigrateSetMaxSpeed, /* 0.9.0 */
     .domainMigrateGetMaxSpeed = remoteDomainMigrateGetMaxSpeed, /* 0.9.5 */
-    .domainEventRegisterAny = remoteConnectDomainEventRegisterAny, /* 0.8.0 */
-    .domainEventDeregisterAny = remoteConnectDomainEventDeregisterAny, /* 0.8.0 */
+    .connectDomainEventRegisterAny = remoteConnectDomainEventRegisterAny, /* 0.8.0 */
+    .connectDomainEventDeregisterAny = remoteConnectDomainEventDeregisterAny, /* 0.8.0 */
     .domainManagedSave = remoteDomainManagedSave, /* 0.8.0 */
     .domainHasManagedSaveImage = remoteDomainHasManagedSaveImage, /* 0.8.0 */
     .domainManagedSaveRemove = remoteDomainManagedSaveRemove, /* 0.8.0 */
@@ -6264,9 +6264,9 @@ static virDriver remote_driver = {
     .domainSnapshotIsCurrent = remoteDomainSnapshotIsCurrent, /* 0.9.13 */
     .domainSnapshotHasMetadata = remoteDomainSnapshotHasMetadata, /* 0.9.13 */
     .domainSnapshotDelete = remoteDomainSnapshotDelete, /* 0.8.0 */
-    .qemuDomainMonitorCommand = remoteQemuDomainMonitorCommand, /* 0.8.3 */
-    .qemuDomainAttach = qemuDomainAttach, /* 0.9.4 */
-    .qemuDomainArbitraryAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
+    .domainQemuMonitorCommand = remoteQemuDomainMonitorCommand, /* 0.8.3 */
+    .domainQemuAttach = qemuDomainAttach, /* 0.9.4 */
+    .domainQemuAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */
     .domainOpenConsole = remoteDomainOpenConsole, /* 0.8.6 */
     .domainOpenChannel = remoteDomainOpenChannel, /* 1.0.2 */
     .domainOpenGraphics = remoteDomainOpenGraphics, /* 0.9.7 */
@@ -6285,8 +6285,8 @@ static virDriver remote_driver = {
     .domainBlockPull = remoteDomainBlockPull, /* 0.9.4 */
     .domainBlockRebase = remoteDomainBlockRebase, /* 0.9.10 */
     .domainBlockCommit = remoteDomainBlockCommit, /* 0.10.2 */
-    .setKeepAlive = remoteSetKeepAlive, /* 0.9.8 */
-    .isAlive = remoteIsAlive, /* 0.9.8 */
+    .connectSetKeepAlive = remoteSetKeepAlive, /* 0.9.8 */
+    .connectIsAlive = remoteIsAlive, /* 0.9.8 */
     .nodeSuspendForDuration = remoteNodeSuspendForDuration, /* 0.9.8 */
     .domainSetBlockIoTune = remoteDomainSetBlockIoTune, /* 0.9.8 */
     .domainGetBlockIoTune = remoteDomainGetBlockIoTune, /* 0.9.8 */
@@ -6306,13 +6306,13 @@ static virDriver remote_driver = {
 
 static virNetworkDriver network_driver = {
     .name = "remote",
-    .open = remoteNetworkOpen, /* 0.3.0 */
-    .close = remoteNetworkClose, /* 0.3.0 */
-    .numOfNetworks = remoteConnectNumOfNetworks, /* 0.3.0 */
-    .listNetworks = remoteConnectListNetworks, /* 0.3.0 */
-    .numOfDefinedNetworks = remoteConnectNumOfDefinedNetworks, /* 0.3.0 */
-    .listDefinedNetworks = remoteConnectListDefinedNetworks, /* 0.3.0 */
-    .listAllNetworks = remoteConnectListAllNetworks, /* 0.10.2 */
+    .connectOpen = remoteNetworkOpen, /* 0.3.0 */
+    .connectClose = remoteNetworkClose, /* 0.3.0 */
+    .connectNumOfNetworks = remoteConnectNumOfNetworks, /* 0.3.0 */
+    .connectListNetworks = remoteConnectListNetworks, /* 0.3.0 */
+    .connectNumOfDefinedNetworks = remoteConnectNumOfDefinedNetworks, /* 0.3.0 */
+    .connectListDefinedNetworks = remoteConnectListDefinedNetworks, /* 0.3.0 */
+    .connectListAllNetworks = remoteConnectListAllNetworks, /* 0.10.2 */
     .networkLookupByUUID = remoteNetworkLookupByUUID, /* 0.3.0 */
     .networkLookupByName = remoteNetworkLookupByName, /* 0.3.0 */
     .networkCreateXML = remoteNetworkCreateXML, /* 0.3.0 */
@@ -6331,13 +6331,13 @@ static virNetworkDriver network_driver = {
 
 static virInterfaceDriver interface_driver = {
     .name = "remote",
-    .open = remoteInterfaceOpen, /* 0.7.2 */
-    .close = remoteInterfaceClose, /* 0.7.2 */
-    .numOfInterfaces = remoteConnectNumOfInterfaces, /* 0.7.2 */
-    .listInterfaces = remoteConnectListInterfaces, /* 0.7.2 */
-    .numOfDefinedInterfaces = remoteConnectNumOfDefinedInterfaces, /* 0.7.2 */
-    .listDefinedInterfaces = remoteConnectListDefinedInterfaces, /* 0.7.2 */
-    .listAllInterfaces = remoteConnectListAllInterfaces, /* 0.10.2 */
+    .connectOpen = remoteInterfaceOpen, /* 0.7.2 */
+    .connectClose = remoteInterfaceClose, /* 0.7.2 */
+    .connectNumOfInterfaces = remoteConnectNumOfInterfaces, /* 0.7.2 */
+    .connectListInterfaces = remoteConnectListInterfaces, /* 0.7.2 */
+    .connectNumOfDefinedInterfaces = remoteConnectNumOfDefinedInterfaces, /* 0.7.2 */
+    .connectListDefinedInterfaces = remoteConnectListDefinedInterfaces, /* 0.7.2 */
+    .connectListAllInterfaces = remoteConnectListAllInterfaces, /* 0.10.2 */
     .interfaceLookupByName = remoteInterfaceLookupByName, /* 0.7.2 */
     .interfaceLookupByMACString = remoteInterfaceLookupByMACString, /* 0.7.2 */
     .interfaceGetXMLDesc = remoteInterfaceGetXMLDesc, /* 0.7.2 */
@@ -6353,103 +6353,103 @@ static virInterfaceDriver interface_driver = {
 
 static virStorageDriver storage_driver = {
     .name = "remote",
-    .open = remoteStorageOpen, /* 0.4.1 */
-    .close = remoteStorageClose, /* 0.4.1 */
-    .numOfPools = remoteConnectNumOfStoragePools, /* 0.4.1 */
-    .listPools = remoteConnectListStoragePools, /* 0.4.1 */
-    .numOfDefinedPools = remoteConnectNumOfDefinedStoragePools, /* 0.4.1 */
-    .listDefinedPools = remoteConnectListDefinedStoragePools, /* 0.4.1 */
-    .listAllPools = remoteConnectListAllStoragePools, /* 0.10.2 */
-    .findPoolSources = remoteConnectFindStoragePoolSources, /* 0.4.5 */
-    .poolLookupByName = remoteStoragePoolLookupByName, /* 0.4.1 */
-    .poolLookupByUUID = remoteStoragePoolLookupByUUID, /* 0.4.1 */
-    .poolLookupByVolume = remoteStoragePoolLookupByVolume, /* 0.4.1 */
-    .poolCreateXML = remoteStoragePoolCreateXML, /* 0.4.1 */
-    .poolDefineXML = remoteStoragePoolDefineXML, /* 0.4.1 */
-    .poolBuild = remoteStoragePoolBuild, /* 0.4.1 */
-    .poolUndefine = remoteStoragePoolUndefine, /* 0.4.1 */
-    .poolCreate = remoteStoragePoolCreate, /* 0.4.1 */
-    .poolDestroy = remoteStoragePoolDestroy, /* 0.4.1 */
-    .poolDelete = remoteStoragePoolDelete, /* 0.4.1 */
-    .poolRefresh = remoteStoragePoolRefresh, /* 0.4.1 */
-    .poolGetInfo = remoteStoragePoolGetInfo, /* 0.4.1 */
-    .poolGetXMLDesc = remoteStoragePoolGetXMLDesc, /* 0.4.1 */
-    .poolGetAutostart = remoteStoragePoolGetAutostart, /* 0.4.1 */
-    .poolSetAutostart = remoteStoragePoolSetAutostart, /* 0.4.1 */
-    .poolNumOfVolumes = remoteStoragePoolNumOfVolumes, /* 0.4.1 */
-    .poolListVolumes = remoteStoragePoolListVolumes, /* 0.4.1 */
-    .poolListAllVolumes = remoteStoragePoolListAllVolumes, /* 0.10.0 */
-
-    .volLookupByName = remoteStorageVolLookupByName, /* 0.4.1 */
-    .volLookupByKey = remoteStorageVolLookupByKey, /* 0.4.1 */
-    .volLookupByPath = remoteStorageVolLookupByPath, /* 0.4.1 */
-    .volCreateXML = remoteStorageVolCreateXML, /* 0.4.1 */
-    .volCreateXMLFrom = remoteStorageVolCreateXMLFrom, /* 0.6.4 */
-    .volDownload = remoteStorageVolDownload, /* 0.9.0 */
-    .volUpload = remoteStorageVolUpload, /* 0.9.0 */
-    .volDelete = remoteStorageVolDelete, /* 0.4.1 */
-    .volWipe = remoteStorageVolWipe, /* 0.8.0 */
-    .volWipePattern = remoteStorageVolWipePattern, /* 0.9.10 */
-    .volGetInfo = remoteStorageVolGetInfo, /* 0.4.1 */
-    .volGetXMLDesc = remoteStorageVolGetXMLDesc, /* 0.4.1 */
-    .volGetPath = remoteStorageVolGetPath, /* 0.4.1 */
-    .volResize = remoteStorageVolResize, /* 0.9.10 */
-    .poolIsActive = remoteStoragePoolIsActive, /* 0.7.3 */
-    .poolIsPersistent = remoteStoragePoolIsPersistent, /* 0.7.3 */
+    .connectOpen = remoteStorageOpen, /* 0.4.1 */
+    .connectClose = remoteStorageClose, /* 0.4.1 */
+    .connectNumOfStoragePools = remoteConnectNumOfStoragePools, /* 0.4.1 */
+    .connectListStoragePools = remoteConnectListStoragePools, /* 0.4.1 */
+    .connectNumOfDefinedStoragePools = remoteConnectNumOfDefinedStoragePools, /* 0.4.1 */
+    .connectListDefinedStoragePools = remoteConnectListDefinedStoragePools, /* 0.4.1 */
+    .connectListAllStoragePools = remoteConnectListAllStoragePools, /* 0.10.2 */
+    .connectFindStoragePoolSources = remoteConnectFindStoragePoolSources, /* 0.4.5 */
+    .storagePoolLookupByName = remoteStoragePoolLookupByName, /* 0.4.1 */
+    .storagePoolLookupByUUID = remoteStoragePoolLookupByUUID, /* 0.4.1 */
+    .storagePoolLookupByVolume = remoteStoragePoolLookupByVolume, /* 0.4.1 */
+    .storagePoolCreateXML = remoteStoragePoolCreateXML, /* 0.4.1 */
+    .storagePoolDefineXML = remoteStoragePoolDefineXML, /* 0.4.1 */
+    .storagePoolBuild = remoteStoragePoolBuild, /* 0.4.1 */
+    .storagePoolUndefine = remoteStoragePoolUndefine, /* 0.4.1 */
+    .storagePoolCreate = remoteStoragePoolCreate, /* 0.4.1 */
+    .storagePoolDestroy = remoteStoragePoolDestroy, /* 0.4.1 */
+    .storagePoolDelete = remoteStoragePoolDelete, /* 0.4.1 */
+    .storagePoolRefresh = remoteStoragePoolRefresh, /* 0.4.1 */
+    .storagePoolGetInfo = remoteStoragePoolGetInfo, /* 0.4.1 */
+    .storagePoolGetXMLDesc = remoteStoragePoolGetXMLDesc, /* 0.4.1 */
+    .storagePoolGetAutostart = remoteStoragePoolGetAutostart, /* 0.4.1 */
+    .storagePoolSetAutostart = remoteStoragePoolSetAutostart, /* 0.4.1 */
+    .storagePoolNumOfVolumes = remoteStoragePoolNumOfVolumes, /* 0.4.1 */
+    .storagePoolListVolumes = remoteStoragePoolListVolumes, /* 0.4.1 */
+    .storagePoolListAllVolumes = remoteStoragePoolListAllVolumes, /* 0.10.0 */
+
+    .storageVolLookupByName = remoteStorageVolLookupByName, /* 0.4.1 */
+    .storageVolLookupByKey = remoteStorageVolLookupByKey, /* 0.4.1 */
+    .storageVolLookupByPath = remoteStorageVolLookupByPath, /* 0.4.1 */
+    .storageVolCreateXML = remoteStorageVolCreateXML, /* 0.4.1 */
+    .storageVolCreateXMLFrom = remoteStorageVolCreateXMLFrom, /* 0.6.4 */
+    .storageVolDownload = remoteStorageVolDownload, /* 0.9.0 */
+    .storageVolUpload = remoteStorageVolUpload, /* 0.9.0 */
+    .storageVolDelete = remoteStorageVolDelete, /* 0.4.1 */
+    .storageVolWipe = remoteStorageVolWipe, /* 0.8.0 */
+    .storageVolWipePattern = remoteStorageVolWipePattern, /* 0.9.10 */
+    .storageVolGetInfo = remoteStorageVolGetInfo, /* 0.4.1 */
+    .storageVolGetXMLDesc = remoteStorageVolGetXMLDesc, /* 0.4.1 */
+    .storageVolGetPath = remoteStorageVolGetPath, /* 0.4.1 */
+    .storageVolResize = remoteStorageVolResize, /* 0.9.10 */
+    .storagePoolIsActive = remoteStoragePoolIsActive, /* 0.7.3 */
+    .storagePoolIsPersistent = remoteStoragePoolIsPersistent, /* 0.7.3 */
 };
 
 static virSecretDriver secret_driver = {
     .name = "remote",
-    .open = remoteSecretOpen, /* 0.7.1 */
-    .close = remoteSecretClose, /* 0.7.1 */
-    .numOfSecrets = remoteConnectNumOfSecrets, /* 0.7.1 */
-    .listSecrets = remoteConnectListSecrets, /* 0.7.1 */
-    .listAllSecrets = remoteConnectListAllSecrets, /* 0.10.2 */
-    .lookupByUUID = remoteSecretLookupByUUID, /* 0.7.1 */
-    .lookupByUsage = remoteSecretLookupByUsage, /* 0.7.1 */
-    .defineXML = remoteSecretDefineXML, /* 0.7.1 */
-    .getXMLDesc = remoteSecretGetXMLDesc, /* 0.7.1 */
-    .setValue = remoteSecretSetValue, /* 0.7.1 */
-    .getValue = remoteSecretGetValue, /* 0.7.1 */
-    .undefine = remoteSecretUndefine /* 0.7.1 */
+    .connectOpen = remoteSecretOpen, /* 0.7.1 */
+    .connectClose = remoteSecretClose, /* 0.7.1 */
+    .connectNumOfSecrets = remoteConnectNumOfSecrets, /* 0.7.1 */
+    .connectListSecrets = remoteConnectListSecrets, /* 0.7.1 */
+    .connectListAllSecrets = remoteConnectListAllSecrets, /* 0.10.2 */
+    .secretLookupByUUID = remoteSecretLookupByUUID, /* 0.7.1 */
+    .secretLookupByUsage = remoteSecretLookupByUsage, /* 0.7.1 */
+    .secretDefineXML = remoteSecretDefineXML, /* 0.7.1 */
+    .secretGetXMLDesc = remoteSecretGetXMLDesc, /* 0.7.1 */
+    .secretSetValue = remoteSecretSetValue, /* 0.7.1 */
+    .secretGetValue = remoteSecretGetValue, /* 0.7.1 */
+    .secretUndefine = remoteSecretUndefine /* 0.7.1 */
 };
 
 static virDeviceMonitor dev_monitor = {
     .name = "remote",
-    .open = remoteDevMonOpen, /* 0.5.0 */
-    .close = remoteDevMonClose, /* 0.5.0 */
-    .numOfDevices = remoteNodeNumOfDevices, /* 0.5.0 */
-    .listDevices = remoteNodeListDevices, /* 0.5.0 */
-    .listAllNodeDevices  = remoteConnectListAllNodeDevices, /* 0.10.2 */
-    .deviceLookupByName = remoteNodeDeviceLookupByName, /* 0.5.0 */
-    .deviceLookupSCSIHostByWWN = remoteNodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
-    .deviceGetXMLDesc = remoteNodeDeviceGetXMLDesc, /* 0.5.0 */
-    .deviceGetParent = remoteNodeDeviceGetParent, /* 0.5.0 */
-    .deviceNumOfCaps = remoteNodeDeviceNumOfCaps, /* 0.5.0 */
-    .deviceListCaps = remoteNodeDeviceListCaps, /* 0.5.0 */
-    .deviceCreateXML = remoteNodeDeviceCreateXML, /* 0.6.3 */
-    .deviceDestroy = remoteNodeDeviceDestroy /* 0.6.3 */
+    .connectOpen = remoteDevMonOpen, /* 0.5.0 */
+    .connectClose = remoteDevMonClose, /* 0.5.0 */
+    .nodeNumOfDevices = remoteNodeNumOfDevices, /* 0.5.0 */
+    .nodeListDevices = remoteNodeListDevices, /* 0.5.0 */
+    .connectListAllNodeDevices  = remoteConnectListAllNodeDevices, /* 0.10.2 */
+    .nodeDeviceLookupByName = remoteNodeDeviceLookupByName, /* 0.5.0 */
+    .nodeDeviceLookupSCSIHostByWWN = remoteNodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
+    .nodeDeviceGetXMLDesc = remoteNodeDeviceGetXMLDesc, /* 0.5.0 */
+    .nodeDeviceGetParent = remoteNodeDeviceGetParent, /* 0.5.0 */
+    .nodeDeviceNumOfCaps = remoteNodeDeviceNumOfCaps, /* 0.5.0 */
+    .nodeDeviceListCaps = remoteNodeDeviceListCaps, /* 0.5.0 */
+    .nodeDeviceCreateXML = remoteNodeDeviceCreateXML, /* 0.6.3 */
+    .nodeDeviceDestroy = remoteNodeDeviceDestroy /* 0.6.3 */
 };
 
 static virNWFilterDriver nwfilter_driver = {
     .name = "remote",
-    .open = remoteNWFilterOpen, /* 0.8.0 */
-    .close = remoteNWFilterClose, /* 0.8.0 */
+    .connectOpen = remoteNWFilterOpen, /* 0.8.0 */
+    .connectClose = remoteNWFilterClose, /* 0.8.0 */
     .nwfilterLookupByUUID = remoteNWFilterLookupByUUID, /* 0.8.0 */
     .nwfilterLookupByName = remoteNWFilterLookupByName, /* 0.8.0 */
-    .getXMLDesc           = remoteNWFilterGetXMLDesc, /* 0.8.0 */
-    .defineXML            = remoteNWFilterDefineXML, /* 0.8.0 */
-    .undefine             = remoteNWFilterUndefine, /* 0.8.0 */
-    .numOfNWFilters       = remoteConnectNumOfNWFilters, /* 0.8.0 */
-    .listNWFilters        = remoteConnectListNWFilters, /* 0.8.0 */
-    .listAllNWFilters     = remoteConnectListAllNWFilters, /* 0.10.2 */
+    .nwfilterGetXMLDesc           = remoteNWFilterGetXMLDesc, /* 0.8.0 */
+    .nwfilterDefineXML            = remoteNWFilterDefineXML, /* 0.8.0 */
+    .nwfilterUndefine             = remoteNWFilterUndefine, /* 0.8.0 */
+    .connectNumOfNWFilters       = remoteConnectNumOfNWFilters, /* 0.8.0 */
+    .connectListNWFilters        = remoteConnectListNWFilters, /* 0.8.0 */
+    .connectListAllNWFilters     = remoteConnectListAllNWFilters, /* 0.10.2 */
 };
 
 
 #ifdef WITH_LIBVIRTD
 static virStateDriver state_driver = {
     .name = "Remote",
-    .initialize = remoteStartup,
+    .stateInitialize = remoteStartup,
 };
 #endif
 
diff --git a/src/secret/secret_driver.c b/src/secret/secret_driver.c
index c577817..9e7d382 100644
--- a/src/secret/secret_driver.c
+++ b/src/secret/secret_driver.c
@@ -1157,25 +1157,25 @@ secretDriverReload(void)
 
 static virSecretDriver secretDriver = {
     .name = "secret",
-    .open = secretOpen, /* 0.7.1 */
-    .close = secretClose, /* 0.7.1 */
-    .numOfSecrets = secretNumOfSecrets, /* 0.7.1 */
-    .listSecrets = secretListSecrets, /* 0.7.1 */
-    .listAllSecrets = secretListAllSecrets, /* 0.10.2 */
-    .lookupByUUID = secretLookupByUUID, /* 0.7.1 */
-    .lookupByUsage = secretLookupByUsage, /* 0.7.1 */
-    .defineXML = secretDefineXML, /* 0.7.1 */
-    .getXMLDesc = secretGetXMLDesc, /* 0.7.1 */
-    .setValue = secretSetValue, /* 0.7.1 */
-    .getValue = secretGetValue, /* 0.7.1 */
-    .undefine = secretUndefine, /* 0.7.1 */
+    .connectOpen = secretOpen, /* 0.7.1 */
+    .connectClose = secretClose, /* 0.7.1 */
+    .connectNumOfSecrets = secretNumOfSecrets, /* 0.7.1 */
+    .connectListSecrets = secretListSecrets, /* 0.7.1 */
+    .connectListAllSecrets = secretListAllSecrets, /* 0.10.2 */
+    .secretLookupByUUID = secretLookupByUUID, /* 0.7.1 */
+    .secretLookupByUsage = secretLookupByUsage, /* 0.7.1 */
+    .secretDefineXML = secretDefineXML, /* 0.7.1 */
+    .secretGetXMLDesc = secretGetXMLDesc, /* 0.7.1 */
+    .secretSetValue = secretSetValue, /* 0.7.1 */
+    .secretGetValue = secretGetValue, /* 0.7.1 */
+    .secretUndefine = secretUndefine, /* 0.7.1 */
 };
 
 static virStateDriver stateDriver = {
     .name = "Secret",
-    .initialize = secretDriverStartup,
-    .cleanup = secretDriverCleanup,
-    .reload = secretDriverReload,
+    .stateInitialize = secretDriverStartup,
+    .stateCleanup = secretDriverCleanup,
+    .stateReload = secretDriverReload,
 };
 
 int
diff --git a/src/storage/storage_backend.c b/src/storage/storage_backend.c
index aa3f147..d4aabb6 100644
--- a/src/storage/storage_backend.c
+++ b/src/storage/storage_backend.c
@@ -432,7 +432,7 @@ virStorageGenerateSecretUUID(virConnectPtr conn,
                            _("unable to generate uuid"));
             return -1;
         }
-        tmp = conn->secretDriver->lookupByUUID(conn, uuid);
+        tmp = conn->secretDriver->secretLookupByUUID(conn, uuid);
         if (tmp == NULL)
             return 0;
 
@@ -459,9 +459,9 @@ virStorageGenerateQcowEncryption(virConnectPtr conn,
     int ret = -1;
 
     if (conn->secretDriver == NULL ||
-        conn->secretDriver->lookupByUUID == NULL ||
-        conn->secretDriver->defineXML == NULL ||
-        conn->secretDriver->setValue == NULL) {
+        conn->secretDriver->secretLookupByUUID == NULL ||
+        conn->secretDriver->secretDefineXML == NULL ||
+        conn->secretDriver->secretSetValue == NULL) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                        _("secret storage not supported"));
         goto cleanup;
@@ -497,7 +497,7 @@ virStorageGenerateQcowEncryption(virConnectPtr conn,
     if (xml == NULL)
         goto cleanup;
 
-    secret = conn->secretDriver->defineXML(conn, xml, 0);
+    secret = conn->secretDriver->secretDefineXML(conn, xml, 0);
     if (secret == NULL) {
         VIR_FREE(xml);
         goto cleanup;
@@ -507,7 +507,7 @@ virStorageGenerateQcowEncryption(virConnectPtr conn,
     if (virStorageGenerateQcowPassphrase(value) < 0)
         goto cleanup;
 
-    if (conn->secretDriver->setValue(secret, value, sizeof(value), 0) < 0)
+    if (conn->secretDriver->secretSetValue(secret, value, sizeof(value), 0) < 0)
         goto cleanup;
 
     enc_secret->type = VIR_STORAGE_ENCRYPTION_SECRET_TYPE_PASSPHRASE;
@@ -522,8 +522,8 @@ virStorageGenerateQcowEncryption(virConnectPtr conn,
 cleanup:
     if (secret != NULL) {
         if (ret != 0 &&
-            conn->secretDriver->undefine != NULL)
-            conn->secretDriver->undefine(secret);
+            conn->secretDriver->secretUndefine != NULL)
+            conn->secretDriver->secretUndefine(secret);
         virSecretFree(secret);
     }
     virBufferFreeAndReset(&buf);
diff --git a/src/storage/storage_driver.c b/src/storage/storage_driver.c
index bf9db47..9613b3b 100644
--- a/src/storage/storage_driver.c
+++ b/src/storage/storage_driver.c
@@ -2369,58 +2369,58 @@ storageListAllPools(virConnectPtr conn,
 
 static virStorageDriver storageDriver = {
     .name = "storage",
-    .open = storageOpen, /* 0.4.0 */
-    .close = storageClose, /* 0.4.0 */
-    .numOfPools = storageNumPools, /* 0.4.0 */
-    .listPools = storageListPools, /* 0.4.0 */
-    .numOfDefinedPools = storageNumDefinedPools, /* 0.4.0 */
-    .listDefinedPools = storageListDefinedPools, /* 0.4.0 */
-    .listAllPools = storageListAllPools, /* 0.10.2 */
-    .findPoolSources = storageFindPoolSources, /* 0.4.0 */
-    .poolLookupByName = storagePoolLookupByName, /* 0.4.0 */
-    .poolLookupByUUID = storagePoolLookupByUUID, /* 0.4.0 */
-    .poolLookupByVolume = storagePoolLookupByVolume, /* 0.4.0 */
-    .poolCreateXML = storagePoolCreate, /* 0.4.0 */
-    .poolDefineXML = storagePoolDefine, /* 0.4.0 */
-    .poolBuild = storagePoolBuild, /* 0.4.0 */
-    .poolUndefine = storagePoolUndefine, /* 0.4.0 */
-    .poolCreate = storagePoolStart, /* 0.4.0 */
-    .poolDestroy = storagePoolDestroy, /* 0.4.0 */
-    .poolDelete = storagePoolDelete, /* 0.4.0 */
-    .poolRefresh = storagePoolRefresh, /* 0.4.0 */
-    .poolGetInfo = storagePoolGetInfo, /* 0.4.0 */
-    .poolGetXMLDesc = storagePoolGetXMLDesc, /* 0.4.0 */
-    .poolGetAutostart = storagePoolGetAutostart, /* 0.4.0 */
-    .poolSetAutostart = storagePoolSetAutostart, /* 0.4.0 */
-    .poolNumOfVolumes = storagePoolNumVolumes, /* 0.4.0 */
-    .poolListVolumes = storagePoolListVolumes, /* 0.4.0 */
-    .poolListAllVolumes = storagePoolListAllVolumes, /* 0.10.2 */
-
-    .volLookupByName = storageVolumeLookupByName, /* 0.4.0 */
-    .volLookupByKey = storageVolumeLookupByKey, /* 0.4.0 */
-    .volLookupByPath = storageVolumeLookupByPath, /* 0.4.0 */
-    .volCreateXML = storageVolumeCreateXML, /* 0.4.0 */
-    .volCreateXMLFrom = storageVolumeCreateXMLFrom, /* 0.6.4 */
-    .volDownload = storageVolumeDownload, /* 0.9.0 */
-    .volUpload = storageVolumeUpload, /* 0.9.0 */
-    .volDelete = storageVolumeDelete, /* 0.4.0 */
-    .volWipe = storageVolumeWipe, /* 0.8.0 */
-    .volWipePattern = storageVolumeWipePattern, /* 0.9.10 */
-    .volGetInfo = storageVolumeGetInfo, /* 0.4.0 */
-    .volGetXMLDesc = storageVolumeGetXMLDesc, /* 0.4.0 */
-    .volGetPath = storageVolumeGetPath, /* 0.4.0 */
-    .volResize = storageVolumeResize, /* 0.9.10 */
-
-    .poolIsActive = storagePoolIsActive, /* 0.7.3 */
-    .poolIsPersistent = storagePoolIsPersistent, /* 0.7.3 */
+    .connectOpen = storageOpen, /* 0.4.0 */
+    .connectClose = storageClose, /* 0.4.0 */
+    .connectNumOfStoragePools = storageNumPools, /* 0.4.0 */
+    .connectListStoragePools = storageListPools, /* 0.4.0 */
+    .connectNumOfDefinedStoragePools = storageNumDefinedPools, /* 0.4.0 */
+    .connectListDefinedStoragePools = storageListDefinedPools, /* 0.4.0 */
+    .connectListAllStoragePools = storageListAllPools, /* 0.10.2 */
+    .connectFindStoragePoolSources = storageFindPoolSources, /* 0.4.0 */
+    .storagePoolLookupByName = storagePoolLookupByName, /* 0.4.0 */
+    .storagePoolLookupByUUID = storagePoolLookupByUUID, /* 0.4.0 */
+    .storagePoolLookupByVolume = storagePoolLookupByVolume, /* 0.4.0 */
+    .storagePoolCreateXML = storagePoolCreate, /* 0.4.0 */
+    .storagePoolDefineXML = storagePoolDefine, /* 0.4.0 */
+    .storagePoolBuild = storagePoolBuild, /* 0.4.0 */
+    .storagePoolUndefine = storagePoolUndefine, /* 0.4.0 */
+    .storagePoolCreate = storagePoolStart, /* 0.4.0 */
+    .storagePoolDestroy = storagePoolDestroy, /* 0.4.0 */
+    .storagePoolDelete = storagePoolDelete, /* 0.4.0 */
+    .storagePoolRefresh = storagePoolRefresh, /* 0.4.0 */
+    .storagePoolGetInfo = storagePoolGetInfo, /* 0.4.0 */
+    .storagePoolGetXMLDesc = storagePoolGetXMLDesc, /* 0.4.0 */
+    .storagePoolGetAutostart = storagePoolGetAutostart, /* 0.4.0 */
+    .storagePoolSetAutostart = storagePoolSetAutostart, /* 0.4.0 */
+    .storagePoolNumOfVolumes = storagePoolNumVolumes, /* 0.4.0 */
+    .storagePoolListVolumes = storagePoolListVolumes, /* 0.4.0 */
+    .storagePoolListAllVolumes = storagePoolListAllVolumes, /* 0.10.2 */
+
+    .storageVolLookupByName = storageVolumeLookupByName, /* 0.4.0 */
+    .storageVolLookupByKey = storageVolumeLookupByKey, /* 0.4.0 */
+    .storageVolLookupByPath = storageVolumeLookupByPath, /* 0.4.0 */
+    .storageVolCreateXML = storageVolumeCreateXML, /* 0.4.0 */
+    .storageVolCreateXMLFrom = storageVolumeCreateXMLFrom, /* 0.6.4 */
+    .storageVolDownload = storageVolumeDownload, /* 0.9.0 */
+    .storageVolUpload = storageVolumeUpload, /* 0.9.0 */
+    .storageVolDelete = storageVolumeDelete, /* 0.4.0 */
+    .storageVolWipe = storageVolumeWipe, /* 0.8.0 */
+    .storageVolWipePattern = storageVolumeWipePattern, /* 0.9.10 */
+    .storageVolGetInfo = storageVolumeGetInfo, /* 0.4.0 */
+    .storageVolGetXMLDesc = storageVolumeGetXMLDesc, /* 0.4.0 */
+    .storageVolGetPath = storageVolumeGetPath, /* 0.4.0 */
+    .storageVolResize = storageVolumeResize, /* 0.9.10 */
+
+    .storagePoolIsActive = storagePoolIsActive, /* 0.7.3 */
+    .storagePoolIsPersistent = storagePoolIsPersistent, /* 0.7.3 */
 };
 
 
 static virStateDriver stateDriver = {
     .name = "Storage",
-    .initialize = storageDriverStartup,
-    .cleanup = storageDriverShutdown,
-    .reload = storageDriverReload,
+    .stateInitialize = storageDriverStartup,
+    .stateCleanup = storageDriverShutdown,
+    .stateReload = storageDriverReload,
 };
 
 int storageRegister(void) {
diff --git a/src/test/test_driver.c b/src/test/test_driver.c
index 76fbfda..5272f06 100644
--- a/src/test/test_driver.c
+++ b/src/test/test_driver.c
@@ -5793,16 +5793,16 @@ testDomainScreenshot(virDomainPtr dom ATTRIBUTE_UNUSED,
 static virDriver testDriver = {
     .no = VIR_DRV_TEST,
     .name = "Test",
-    .open = testOpen, /* 0.1.1 */
-    .close = testClose, /* 0.1.1 */
-    .version = testGetVersion, /* 0.1.1 */
-    .getHostname = virGetHostname, /* 0.6.3 */
-    .getMaxVcpus = testGetMaxVCPUs, /* 0.3.2 */
+    .connectOpen = testOpen, /* 0.1.1 */
+    .connectClose = testClose, /* 0.1.1 */
+    .connectGetVersion = testGetVersion, /* 0.1.1 */
+    .connectGetHostname = virGetHostname, /* 0.6.3 */
+    .connectGetMaxVcpus = testGetMaxVCPUs, /* 0.3.2 */
     .nodeGetInfo = testNodeGetInfo, /* 0.1.1 */
-    .getCapabilities = testGetCapabilities, /* 0.2.1 */
-    .listDomains = testListDomains, /* 0.1.1 */
-    .numOfDomains = testNumOfDomains, /* 0.1.1 */
-    .listAllDomains = testListAllDomains, /* 0.9.13 */
+    .connectGetCapabilities = testGetCapabilities, /* 0.2.1 */
+    .connectListDomains = testListDomains, /* 0.1.1 */
+    .connectNumOfDomains = testNumOfDomains, /* 0.1.1 */
+    .connectListAllDomains = testListAllDomains, /* 0.9.13 */
     .domainCreateXML = testDomainCreateXML, /* 0.1.4 */
     .domainLookupByID = testLookupDomainByID, /* 0.1.1 */
     .domainLookupByUUID = testLookupDomainByUUID, /* 0.1.1 */
@@ -5831,8 +5831,8 @@ static virDriver testDriver = {
     .domainGetVcpus = testDomainGetVcpus, /* 0.7.3 */
     .domainGetMaxVcpus = testDomainGetMaxVcpus, /* 0.7.3 */
     .domainGetXMLDesc = testDomainGetXMLDesc, /* 0.1.4 */
-    .listDefinedDomains = testListDefinedDomains, /* 0.1.11 */
-    .numOfDefinedDomains = testNumOfDefinedDomains, /* 0.1.11 */
+    .connectListDefinedDomains = testListDefinedDomains, /* 0.1.11 */
+    .connectNumOfDefinedDomains = testNumOfDefinedDomains, /* 0.1.11 */
     .domainCreate = testDomainCreate, /* 0.1.11 */
     .domainCreateWithFlags = testDomainCreateWithFlags, /* 0.8.2 */
     .domainDefineXML = testDomainDefineXML, /* 0.1.11 */
@@ -5848,29 +5848,29 @@ static virDriver testDriver = {
     .domainBlockStats = testDomainBlockStats, /* 0.7.0 */
     .domainInterfaceStats = testDomainInterfaceStats, /* 0.7.0 */
     .nodeGetCellsFreeMemory = testNodeGetCellsFreeMemory, /* 0.4.2 */
-    .domainEventRegister = testDomainEventRegister, /* 0.6.0 */
-    .domainEventDeregister = testDomainEventDeregister, /* 0.6.0 */
-    .isEncrypted = testIsEncrypted, /* 0.7.3 */
-    .isSecure = testIsSecure, /* 0.7.3 */
+    .connectDomainEventRegister = testDomainEventRegister, /* 0.6.0 */
+    .connectDomainEventDeregister = testDomainEventDeregister, /* 0.6.0 */
+    .connectIsEncrypted = testIsEncrypted, /* 0.7.3 */
+    .connectIsSecure = testIsSecure, /* 0.7.3 */
     .domainIsActive = testDomainIsActive, /* 0.7.3 */
     .domainIsPersistent = testDomainIsPersistent, /* 0.7.3 */
     .domainIsUpdated = testDomainIsUpdated, /* 0.8.6 */
-    .domainEventRegisterAny = testDomainEventRegisterAny, /* 0.8.0 */
-    .domainEventDeregisterAny = testDomainEventDeregisterAny, /* 0.8.0 */
-    .isAlive = testIsAlive, /* 0.9.8 */
+    .connectDomainEventRegisterAny = testDomainEventRegisterAny, /* 0.8.0 */
+    .connectDomainEventDeregisterAny = testDomainEventDeregisterAny, /* 0.8.0 */
+    .connectIsAlive = testIsAlive, /* 0.9.8 */
     .nodeGetCPUMap = testNodeGetCPUMap, /* 1.0.0 */
     .domainScreenshot = testDomainScreenshot, /* 1.0.5 */
 };
 
 static virNetworkDriver testNetworkDriver = {
     "Test",
-    .open = testOpenNetwork, /* 0.3.2 */
-    .close = testCloseNetwork, /* 0.3.2 */
-    .numOfNetworks = testNumNetworks, /* 0.3.2 */
-    .listNetworks = testListNetworks, /* 0.3.2 */
-    .numOfDefinedNetworks = testNumDefinedNetworks, /* 0.3.2 */
-    .listDefinedNetworks = testListDefinedNetworks, /* 0.3.2 */
-    .listAllNetworks = testNetworkListAllNetworks, /* 0.10.2 */
+    .connectOpen = testOpenNetwork, /* 0.3.2 */
+    .connectClose = testCloseNetwork, /* 0.3.2 */
+    .connectNumOfNetworks = testNumNetworks, /* 0.3.2 */
+    .connectListNetworks = testListNetworks, /* 0.3.2 */
+    .connectNumOfDefinedNetworks = testNumDefinedNetworks, /* 0.3.2 */
+    .connectListDefinedNetworks = testListDefinedNetworks, /* 0.3.2 */
+    .connectListAllNetworks = testNetworkListAllNetworks, /* 0.10.2 */
     .networkLookupByUUID = testLookupNetworkByUUID, /* 0.3.2 */
     .networkLookupByName = testLookupNetworkByName, /* 0.3.2 */
     .networkCreateXML = testNetworkCreate, /* 0.3.2 */
@@ -5889,12 +5889,12 @@ static virNetworkDriver testNetworkDriver = {
 
 static virInterfaceDriver testInterfaceDriver = {
     "Test",                     /* name */
-    .open = testOpenInterface, /* 0.7.0 */
-    .close = testCloseInterface, /* 0.7.0 */
-    .numOfInterfaces = testNumOfInterfaces, /* 0.7.0 */
-    .listInterfaces = testListInterfaces, /* 0.7.0 */
-    .numOfDefinedInterfaces = testNumOfDefinedInterfaces, /* 0.7.0 */
-    .listDefinedInterfaces = testListDefinedInterfaces, /* 0.7.0 */
+    .connectOpen = testOpenInterface, /* 0.7.0 */
+    .connectClose = testCloseInterface, /* 0.7.0 */
+    .connectNumOfInterfaces = testNumOfInterfaces, /* 0.7.0 */
+    .connectListInterfaces = testListInterfaces, /* 0.7.0 */
+    .connectNumOfDefinedInterfaces = testNumOfDefinedInterfaces, /* 0.7.0 */
+    .connectListDefinedInterfaces = testListDefinedInterfaces, /* 0.7.0 */
     .interfaceLookupByName = testLookupInterfaceByName, /* 0.7.0 */
     .interfaceLookupByMACString = testLookupInterfaceByMACString, /* 0.7.0 */
     .interfaceGetXMLDesc = testInterfaceGetXMLDesc, /* 0.7.0 */
@@ -5911,74 +5911,74 @@ static virInterfaceDriver testInterfaceDriver = {
 
 static virStorageDriver testStorageDriver = {
     .name = "Test",
-    .open = testStorageOpen, /* 0.4.1 */
-    .close = testStorageClose, /* 0.4.1 */
-
-    .numOfPools = testStorageNumPools, /* 0.5.0 */
-    .listPools = testStorageListPools, /* 0.5.0 */
-    .numOfDefinedPools = testStorageNumDefinedPools, /* 0.5.0 */
-    .listDefinedPools = testStorageListDefinedPools, /* 0.5.0 */
-    .listAllPools = testStorageListAllPools, /* 0.10.2 */
-    .findPoolSources = testStorageFindPoolSources, /* 0.5.0 */
-    .poolLookupByName = testStoragePoolLookupByName, /* 0.5.0 */
-    .poolLookupByUUID = testStoragePoolLookupByUUID, /* 0.5.0 */
-    .poolLookupByVolume = testStoragePoolLookupByVolume, /* 0.5.0 */
-    .poolCreateXML = testStoragePoolCreate, /* 0.5.0 */
-    .poolDefineXML = testStoragePoolDefine, /* 0.5.0 */
-    .poolBuild = testStoragePoolBuild, /* 0.5.0 */
-    .poolUndefine = testStoragePoolUndefine, /* 0.5.0 */
-    .poolCreate = testStoragePoolStart, /* 0.5.0 */
-    .poolDestroy = testStoragePoolDestroy, /* 0.5.0 */
-    .poolDelete = testStoragePoolDelete, /* 0.5.0 */
-    .poolRefresh = testStoragePoolRefresh, /* 0.5.0 */
-    .poolGetInfo = testStoragePoolGetInfo, /* 0.5.0 */
-    .poolGetXMLDesc = testStoragePoolGetXMLDesc, /* 0.5.0 */
-    .poolGetAutostart = testStoragePoolGetAutostart, /* 0.5.0 */
-    .poolSetAutostart = testStoragePoolSetAutostart, /* 0.5.0 */
-    .poolNumOfVolumes = testStoragePoolNumVolumes, /* 0.5.0 */
-    .poolListVolumes = testStoragePoolListVolumes, /* 0.5.0 */
-    .poolListAllVolumes = testStoragePoolListAllVolumes, /* 0.10.2 */
-
-    .volLookupByName = testStorageVolumeLookupByName, /* 0.5.0 */
-    .volLookupByKey = testStorageVolumeLookupByKey, /* 0.5.0 */
-    .volLookupByPath = testStorageVolumeLookupByPath, /* 0.5.0 */
-    .volCreateXML = testStorageVolumeCreateXML, /* 0.5.0 */
-    .volCreateXMLFrom = testStorageVolumeCreateXMLFrom, /* 0.6.4 */
-    .volDelete = testStorageVolumeDelete, /* 0.5.0 */
-    .volGetInfo = testStorageVolumeGetInfo, /* 0.5.0 */
-    .volGetXMLDesc = testStorageVolumeGetXMLDesc, /* 0.5.0 */
-    .volGetPath = testStorageVolumeGetPath, /* 0.5.0 */
-    .poolIsActive = testStoragePoolIsActive, /* 0.7.3 */
-    .poolIsPersistent = testStoragePoolIsPersistent, /* 0.7.3 */
+    .connectOpen = testStorageOpen, /* 0.4.1 */
+    .connectClose = testStorageClose, /* 0.4.1 */
+
+    .connectNumOfStoragePools = testStorageNumPools, /* 0.5.0 */
+    .connectListStoragePools = testStorageListPools, /* 0.5.0 */
+    .connectNumOfDefinedStoragePools = testStorageNumDefinedPools, /* 0.5.0 */
+    .connectListDefinedStoragePools = testStorageListDefinedPools, /* 0.5.0 */
+    .connectListAllStoragePools = testStorageListAllPools, /* 0.10.2 */
+    .connectFindStoragePoolSources = testStorageFindPoolSources, /* 0.5.0 */
+    .storagePoolLookupByName = testStoragePoolLookupByName, /* 0.5.0 */
+    .storagePoolLookupByUUID = testStoragePoolLookupByUUID, /* 0.5.0 */
+    .storagePoolLookupByVolume = testStoragePoolLookupByVolume, /* 0.5.0 */
+    .storagePoolCreateXML = testStoragePoolCreate, /* 0.5.0 */
+    .storagePoolDefineXML = testStoragePoolDefine, /* 0.5.0 */
+    .storagePoolBuild = testStoragePoolBuild, /* 0.5.0 */
+    .storagePoolUndefine = testStoragePoolUndefine, /* 0.5.0 */
+    .storagePoolCreate = testStoragePoolStart, /* 0.5.0 */
+    .storagePoolDestroy = testStoragePoolDestroy, /* 0.5.0 */
+    .storagePoolDelete = testStoragePoolDelete, /* 0.5.0 */
+    .storagePoolRefresh = testStoragePoolRefresh, /* 0.5.0 */
+    .storagePoolGetInfo = testStoragePoolGetInfo, /* 0.5.0 */
+    .storagePoolGetXMLDesc = testStoragePoolGetXMLDesc, /* 0.5.0 */
+    .storagePoolGetAutostart = testStoragePoolGetAutostart, /* 0.5.0 */
+    .storagePoolSetAutostart = testStoragePoolSetAutostart, /* 0.5.0 */
+    .storagePoolNumOfVolumes = testStoragePoolNumVolumes, /* 0.5.0 */
+    .storagePoolListVolumes = testStoragePoolListVolumes, /* 0.5.0 */
+    .storagePoolListAllVolumes = testStoragePoolListAllVolumes, /* 0.10.2 */
+
+    .storageVolLookupByName = testStorageVolumeLookupByName, /* 0.5.0 */
+    .storageVolLookupByKey = testStorageVolumeLookupByKey, /* 0.5.0 */
+    .storageVolLookupByPath = testStorageVolumeLookupByPath, /* 0.5.0 */
+    .storageVolCreateXML = testStorageVolumeCreateXML, /* 0.5.0 */
+    .storageVolCreateXMLFrom = testStorageVolumeCreateXMLFrom, /* 0.6.4 */
+    .storageVolDelete = testStorageVolumeDelete, /* 0.5.0 */
+    .storageVolGetInfo = testStorageVolumeGetInfo, /* 0.5.0 */
+    .storageVolGetXMLDesc = testStorageVolumeGetXMLDesc, /* 0.5.0 */
+    .storageVolGetPath = testStorageVolumeGetPath, /* 0.5.0 */
+    .storagePoolIsActive = testStoragePoolIsActive, /* 0.7.3 */
+    .storagePoolIsPersistent = testStoragePoolIsPersistent, /* 0.7.3 */
 };
 
 static virDeviceMonitor testDevMonitor = {
     .name = "Test",
-    .open = testDevMonOpen, /* 0.6.0 */
-    .close = testDevMonClose, /* 0.6.0 */
-
-    .numOfDevices = testNodeNumOfDevices, /* 0.7.2 */
-    .listDevices = testNodeListDevices, /* 0.7.2 */
-    .deviceLookupByName = testNodeDeviceLookupByName, /* 0.7.2 */
-    .deviceGetXMLDesc = testNodeDeviceGetXMLDesc, /* 0.7.2 */
-    .deviceGetParent = testNodeDeviceGetParent, /* 0.7.2 */
-    .deviceNumOfCaps = testNodeDeviceNumOfCaps, /* 0.7.2 */
-    .deviceListCaps = testNodeDeviceListCaps, /* 0.7.2 */
-    .deviceCreateXML = testNodeDeviceCreateXML, /* 0.7.3 */
-    .deviceDestroy = testNodeDeviceDestroy, /* 0.7.3 */
+    .connectOpen = testDevMonOpen, /* 0.6.0 */
+    .connectClose = testDevMonClose, /* 0.6.0 */
+
+    .nodeNumOfDevices = testNodeNumOfDevices, /* 0.7.2 */
+    .nodeListDevices = testNodeListDevices, /* 0.7.2 */
+    .nodeDeviceLookupByName = testNodeDeviceLookupByName, /* 0.7.2 */
+    .nodeDeviceGetXMLDesc = testNodeDeviceGetXMLDesc, /* 0.7.2 */
+    .nodeDeviceGetParent = testNodeDeviceGetParent, /* 0.7.2 */
+    .nodeDeviceNumOfCaps = testNodeDeviceNumOfCaps, /* 0.7.2 */
+    .nodeDeviceListCaps = testNodeDeviceListCaps, /* 0.7.2 */
+    .nodeDeviceCreateXML = testNodeDeviceCreateXML, /* 0.7.3 */
+    .nodeDeviceDestroy = testNodeDeviceDestroy, /* 0.7.3 */
 };
 
 static virSecretDriver testSecretDriver = {
     .name = "Test",
-    .open = testSecretOpen, /* 0.7.1 */
-    .close = testSecretClose, /* 0.7.1 */
+    .connectOpen = testSecretOpen, /* 0.7.1 */
+    .connectClose = testSecretClose, /* 0.7.1 */
 };
 
 
 static virNWFilterDriver testNWFilterDriver = {
     .name = "Test",
-    .open = testNWFilterOpen, /* 0.8.0 */
-    .close = testNWFilterClose, /* 0.8.0 */
+    .connectOpen = testNWFilterOpen, /* 0.8.0 */
+    .connectClose = testNWFilterClose, /* 0.8.0 */
 };
 
 /**
diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c
index 498d1d9..e30f067 100644
--- a/src/uml/uml_driver.c
+++ b/src/uml/uml_driver.c
@@ -2593,16 +2593,16 @@ static int umlListAllDomains(virConnectPtr conn,
 static virDriver umlDriver = {
     .no = VIR_DRV_UML,
     .name = "UML",
-    .open = umlOpen, /* 0.5.0 */
-    .close = umlClose, /* 0.5.0 */
-    .type = umlGetType, /* 0.5.0 */
-    .version = umlGetVersion, /* 0.5.0 */
-    .getHostname = virGetHostname, /* 0.5.0 */
+    .connectOpen = umlOpen, /* 0.5.0 */
+    .connectClose = umlClose, /* 0.5.0 */
+    .connectGetType = umlGetType, /* 0.5.0 */
+    .connectGetVersion = umlGetVersion, /* 0.5.0 */
+    .connectGetHostname = virGetHostname, /* 0.5.0 */
     .nodeGetInfo = nodeGetInfo, /* 0.5.0 */
-    .getCapabilities = umlGetCapabilities, /* 0.5.0 */
-    .listDomains = umlListDomains, /* 0.5.0 */
-    .numOfDomains = umlNumDomains, /* 0.5.0 */
-    .listAllDomains = umlListAllDomains, /* 0.9.13 */
+    .connectGetCapabilities = umlGetCapabilities, /* 0.5.0 */
+    .connectListDomains = umlListDomains, /* 0.5.0 */
+    .connectNumOfDomains = umlNumDomains, /* 0.5.0 */
+    .connectListAllDomains = umlListAllDomains, /* 0.9.13 */
     .domainCreateXML = umlDomainCreate, /* 0.5.0 */
     .domainLookupByID = umlDomainLookupByID, /* 0.5.0 */
     .domainLookupByUUID = umlDomainLookupByUUID, /* 0.5.0 */
@@ -2618,8 +2618,8 @@ static virDriver umlDriver = {
     .domainGetInfo = umlDomainGetInfo, /* 0.5.0 */
     .domainGetState = umlDomainGetState, /* 0.9.2 */
     .domainGetXMLDesc = umlDomainGetXMLDesc, /* 0.5.0 */
-    .listDefinedDomains = umlListDefinedDomains, /* 0.5.0 */
-    .numOfDefinedDomains = umlNumDefinedDomains, /* 0.5.0 */
+    .connectListDefinedDomains = umlListDefinedDomains, /* 0.5.0 */
+    .connectNumOfDefinedDomains = umlNumDefinedDomains, /* 0.5.0 */
     .domainCreate = umlDomainStart, /* 0.5.0 */
     .domainCreateWithFlags = umlDomainStartWithFlags, /* 0.8.2 */
     .domainDefineXML = umlDomainDefine, /* 0.5.0 */
@@ -2637,17 +2637,17 @@ static virDriver umlDriver = {
     .nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.5.0 */
     .nodeGetFreeMemory = nodeGetFreeMemory, /* 0.5.0 */
     .nodeGetCPUMap = nodeGetCPUMap, /* 1.0.0 */
-    .domainEventRegister = umlDomainEventRegister, /* 0.9.4 */
-    .domainEventDeregister = umlDomainEventDeregister, /* 0.9.4 */
-    .isEncrypted = umlIsEncrypted, /* 0.7.3 */
-    .isSecure = umlIsSecure, /* 0.7.3 */
+    .connectDomainEventRegister = umlDomainEventRegister, /* 0.9.4 */
+    .connectDomainEventDeregister = umlDomainEventDeregister, /* 0.9.4 */
+    .connectIsEncrypted = umlIsEncrypted, /* 0.7.3 */
+    .connectIsSecure = umlIsSecure, /* 0.7.3 */
     .domainIsActive = umlDomainIsActive, /* 0.7.3 */
     .domainIsPersistent = umlDomainIsPersistent, /* 0.7.3 */
     .domainIsUpdated = umlDomainIsUpdated, /* 0.8.6 */
-    .domainEventRegisterAny = umlDomainEventRegisterAny, /* 0.9.4 */
-    .domainEventDeregisterAny = umlDomainEventDeregisterAny, /* 0.9.4 */
+    .connectDomainEventRegisterAny = umlDomainEventRegisterAny, /* 0.9.4 */
+    .connectDomainEventDeregisterAny = umlDomainEventDeregisterAny, /* 0.9.4 */
     .domainOpenConsole = umlDomainOpenConsole, /* 0.8.6 */
-    .isAlive = umlIsAlive, /* 0.9.8 */
+    .connectIsAlive = umlIsAlive, /* 0.9.8 */
     .nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
     .nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
     .nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
@@ -2655,9 +2655,9 @@ static virDriver umlDriver = {
 
 static virStateDriver umlStateDriver = {
     .name = "UML",
-    .initialize = umlStartup,
-    .cleanup = umlShutdown,
-    .reload = umlReload,
+    .stateInitialize = umlStartup,
+    .stateCleanup = umlShutdown,
+    .stateReload = umlReload,
 };
 
 int umlRegister(void) {
diff --git a/src/vbox/vbox_driver.c b/src/vbox/vbox_driver.c
index 736c895..c2e17e4 100644
--- a/src/vbox/vbox_driver.c
+++ b/src/vbox/vbox_driver.c
@@ -184,5 +184,5 @@ static virDrvOpenStatus vboxOpenDummy(virConnectPtr conn,
 static virDriver vboxDriverDummy = {
     VIR_DRV_VBOX,
     "VBOX",
-    .open = vboxOpenDummy,
+    .connectOpen = vboxOpenDummy,
 };
diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c
index 0c82675..e9c4d5b 100644
--- a/src/vbox/vbox_tmpl.c
+++ b/src/vbox/vbox_tmpl.c
@@ -9405,16 +9405,16 @@ no_memory:
 virDriver NAME(Driver) = {
     .no = VIR_DRV_VBOX,
     .name = "VBOX",
-    .open = vboxOpen, /* 0.6.3 */
-    .close = vboxClose, /* 0.6.3 */
-    .version = vboxGetVersion, /* 0.6.3 */
-    .getHostname = virGetHostname, /* 0.6.3 */
-    .getMaxVcpus = vboxGetMaxVcpus, /* 0.6.3 */
+    .connectOpen = vboxOpen, /* 0.6.3 */
+    .connectClose = vboxClose, /* 0.6.3 */
+    .connectGetVersion = vboxGetVersion, /* 0.6.3 */
+    .connectGetHostname = virGetHostname, /* 0.6.3 */
+    .connectGetMaxVcpus = vboxGetMaxVcpus, /* 0.6.3 */
     .nodeGetInfo = nodeGetInfo, /* 0.6.3 */
-    .getCapabilities = vboxGetCapabilities, /* 0.6.3 */
-    .listDomains = vboxListDomains, /* 0.6.3 */
-    .numOfDomains = vboxNumOfDomains, /* 0.6.3 */
-    .listAllDomains = vboxListAllDomains, /* 0.9.13 */
+    .connectGetCapabilities = vboxGetCapabilities, /* 0.6.3 */
+    .connectListDomains = vboxListDomains, /* 0.6.3 */
+    .connectNumOfDomains = vboxNumOfDomains, /* 0.6.3 */
+    .connectListAllDomains = vboxListAllDomains, /* 0.9.13 */
     .domainCreateXML = vboxDomainCreateXML, /* 0.6.3 */
     .domainLookupByID = vboxDomainLookupByID, /* 0.6.3 */
     .domainLookupByUUID = vboxDomainLookupByUUID, /* 0.6.3 */
@@ -9436,8 +9436,8 @@ virDriver NAME(Driver) = {
     .domainGetVcpusFlags = vboxDomainGetVcpusFlags, /* 0.8.5 */
     .domainGetMaxVcpus = vboxDomainGetMaxVcpus, /* 0.7.1 */
     .domainGetXMLDesc = vboxDomainGetXMLDesc, /* 0.6.3 */
-    .listDefinedDomains = vboxListDefinedDomains, /* 0.6.3 */
-    .numOfDefinedDomains = vboxNumOfDefinedDomains, /* 0.6.3 */
+    .connectListDefinedDomains = vboxListDefinedDomains, /* 0.6.3 */
+    .connectNumOfDefinedDomains = vboxNumOfDefinedDomains, /* 0.6.3 */
     .domainCreate = vboxDomainCreate, /* 0.6.3 */
     .domainCreateWithFlags = vboxDomainCreateWithFlags, /* 0.8.2 */
     .domainDefineXML = vboxDomainDefineXML, /* 0.6.3 */
@@ -9454,17 +9454,17 @@ virDriver NAME(Driver) = {
     .domainScreenshot = vboxDomainScreenshot, /* 0.9.2 */
 #endif
 #if VBOX_API_VERSION > 2002 && VBOX_API_VERSION < 4000
-    .domainEventRegister = vboxDomainEventRegister, /* 0.7.0 */
-    .domainEventDeregister = vboxDomainEventDeregister, /* 0.7.0 */
+    .connectDomainEventRegister = vboxDomainEventRegister, /* 0.7.0 */
+    .connectDomainEventDeregister = vboxDomainEventDeregister, /* 0.7.0 */
 #endif
-    .isEncrypted = vboxIsEncrypted, /* 0.7.3 */
-    .isSecure = vboxIsSecure, /* 0.7.3 */
+    .connectIsEncrypted = vboxIsEncrypted, /* 0.7.3 */
+    .connectIsSecure = vboxIsSecure, /* 0.7.3 */
     .domainIsActive = vboxDomainIsActive, /* 0.7.3 */
     .domainIsPersistent = vboxDomainIsPersistent, /* 0.7.3 */
     .domainIsUpdated = vboxDomainIsUpdated, /* 0.8.6 */
 #if VBOX_API_VERSION > 2002 && VBOX_API_VERSION < 4000
-    .domainEventRegisterAny = vboxDomainEventRegisterAny, /* 0.8.0 */
-    .domainEventDeregisterAny = vboxDomainEventDeregisterAny, /* 0.8.0 */
+    .connectDomainEventRegisterAny = vboxDomainEventRegisterAny, /* 0.8.0 */
+    .connectDomainEventDeregisterAny = vboxDomainEventDeregisterAny, /* 0.8.0 */
 #endif
     .domainSnapshotCreateXML = vboxDomainSnapshotCreateXML, /* 0.8.0 */
     .domainSnapshotGetXMLDesc = vboxDomainSnapshotGetXMLDesc, /* 0.8.0 */
@@ -9478,43 +9478,43 @@ virDriver NAME(Driver) = {
     .domainSnapshotHasMetadata = vboxDomainSnapshotHasMetadata, /* 0.9.13 */
     .domainRevertToSnapshot = vboxDomainRevertToSnapshot, /* 0.8.0 */
     .domainSnapshotDelete = vboxDomainSnapshotDelete, /* 0.8.0 */
-    .isAlive = vboxIsAlive, /* 0.9.8 */
+    .connectIsAlive = vboxIsAlive, /* 0.9.8 */
 };
 
 virNetworkDriver NAME(NetworkDriver) = {
     "VBOX",
-    .open                   = vboxNetworkOpen, /* 0.6.4 */
-    .close                  = vboxNetworkClose, /* 0.6.4 */
-    .numOfNetworks          = vboxNumOfNetworks, /* 0.6.4 */
-    .listNetworks           = vboxListNetworks, /* 0.6.4 */
-    .numOfDefinedNetworks   = vboxNumOfDefinedNetworks, /* 0.6.4 */
-    .listDefinedNetworks    = vboxListDefinedNetworks, /* 0.6.4 */
-    .networkLookupByUUID    = vboxNetworkLookupByUUID, /* 0.6.4 */
-    .networkLookupByName    = vboxNetworkLookupByName, /* 0.6.4 */
-    .networkCreateXML       = vboxNetworkCreateXML, /* 0.6.4 */
-    .networkDefineXML       = vboxNetworkDefineXML, /* 0.6.4 */
-    .networkUndefine        = vboxNetworkUndefine, /* 0.6.4 */
-    .networkCreate          = vboxNetworkCreate, /* 0.6.4 */
-    .networkDestroy         = vboxNetworkDestroy, /* 0.6.4 */
-    .networkGetXMLDesc      = vboxNetworkGetXMLDesc, /* 0.6.4 */
+    .connectOpen = vboxNetworkOpen, /* 0.6.4 */
+    .connectClose = vboxNetworkClose, /* 0.6.4 */
+    .connectNumOfNetworks = vboxNumOfNetworks, /* 0.6.4 */
+    .connectListNetworks = vboxListNetworks, /* 0.6.4 */
+    .connectNumOfDefinedNetworks = vboxNumOfDefinedNetworks, /* 0.6.4 */
+    .connectListDefinedNetworks = vboxListDefinedNetworks, /* 0.6.4 */
+    .networkLookupByUUID = vboxNetworkLookupByUUID, /* 0.6.4 */
+    .networkLookupByName = vboxNetworkLookupByName, /* 0.6.4 */
+    .networkCreateXML = vboxNetworkCreateXML, /* 0.6.4 */
+    .networkDefineXML = vboxNetworkDefineXML, /* 0.6.4 */
+    .networkUndefine = vboxNetworkUndefine, /* 0.6.4 */
+    .networkCreate = vboxNetworkCreate, /* 0.6.4 */
+    .networkDestroy = vboxNetworkDestroy, /* 0.6.4 */
+    .networkGetXMLDesc = vboxNetworkGetXMLDesc, /* 0.6.4 */
 };
 
 virStorageDriver NAME(StorageDriver) = {
     .name               = "VBOX",
-    .open               = vboxStorageOpen, /* 0.7.1 */
-    .close              = vboxStorageClose, /* 0.7.1 */
-    .numOfPools         = vboxStorageNumOfPools, /* 0.7.1 */
-    .listPools          = vboxStorageListPools, /* 0.7.1 */
-    .poolLookupByName   = vboxStoragePoolLookupByName, /* 0.7.1 */
-    .poolNumOfVolumes   = vboxStoragePoolNumOfVolumes, /* 0.7.1 */
-    .poolListVolumes    = vboxStoragePoolListVolumes, /* 0.7.1 */
-
-    .volLookupByName    = vboxStorageVolLookupByName, /* 0.7.1 */
-    .volLookupByKey     = vboxStorageVolLookupByKey, /* 0.7.1 */
-    .volLookupByPath    = vboxStorageVolLookupByPath, /* 0.7.1 */
-    .volCreateXML       = vboxStorageVolCreateXML, /* 0.7.1 */
-    .volDelete          = vboxStorageVolDelete, /* 0.7.1 */
-    .volGetInfo         = vboxStorageVolGetInfo, /* 0.7.1 */
-    .volGetXMLDesc      = vboxStorageVolGetXMLDesc, /* 0.7.1 */
-    .volGetPath         = vboxStorageVolGetPath /* 0.7.1 */
+    .connectOpen = vboxStorageOpen, /* 0.7.1 */
+    .connectClose = vboxStorageClose, /* 0.7.1 */
+    .connectNumOfStoragePools = vboxStorageNumOfPools, /* 0.7.1 */
+    .connectListStoragePools = vboxStorageListPools, /* 0.7.1 */
+    .storagePoolLookupByName = vboxStoragePoolLookupByName, /* 0.7.1 */
+    .storagePoolNumOfVolumes = vboxStoragePoolNumOfVolumes, /* 0.7.1 */
+    .storagePoolListVolumes = vboxStoragePoolListVolumes, /* 0.7.1 */
+
+    .storageVolLookupByName = vboxStorageVolLookupByName, /* 0.7.1 */
+    .storageVolLookupByKey = vboxStorageVolLookupByKey, /* 0.7.1 */
+    .storageVolLookupByPath = vboxStorageVolLookupByPath, /* 0.7.1 */
+    .storageVolCreateXML = vboxStorageVolCreateXML, /* 0.7.1 */
+    .storageVolDelete = vboxStorageVolDelete, /* 0.7.1 */
+    .storageVolGetInfo = vboxStorageVolGetInfo, /* 0.7.1 */
+    .storageVolGetXMLDesc = vboxStorageVolGetXMLDesc, /* 0.7.1 */
+    .storageVolGetPath = vboxStorageVolGetPath /* 0.7.1 */
 };
diff --git a/src/vmware/vmware_driver.c b/src/vmware/vmware_driver.c
index c7e493f..e42c8e5 100644
--- a/src/vmware/vmware_driver.c
+++ b/src/vmware/vmware_driver.c
@@ -1120,13 +1120,13 @@ vmwareListAllDomains(virConnectPtr conn,
 static virDriver vmwareDriver = {
     .no = VIR_DRV_VMWARE,
     .name = "VMWARE",
-    .open = vmwareOpen, /* 0.8.7 */
-    .close = vmwareClose, /* 0.8.7 */
-    .type = vmwareGetType, /* 0.8.7 */
-    .version = vmwareGetVersion, /* 0.8.7 */
-    .listDomains = vmwareListDomains, /* 0.8.7 */
-    .numOfDomains = vmwareNumDomains, /* 0.8.7 */
-    .listAllDomains = vmwareListAllDomains, /* 0.9.13 */
+    .connectOpen = vmwareOpen, /* 0.8.7 */
+    .connectClose = vmwareClose, /* 0.8.7 */
+    .connectGetType = vmwareGetType, /* 0.8.7 */
+    .connectGetVersion = vmwareGetVersion, /* 0.8.7 */
+    .connectListDomains = vmwareListDomains, /* 0.8.7 */
+    .connectNumOfDomains = vmwareNumDomains, /* 0.8.7 */
+    .connectListAllDomains = vmwareListAllDomains, /* 0.9.13 */
     .domainCreateXML = vmwareDomainCreateXML, /* 0.8.7 */
     .domainLookupByID = vmwareDomainLookupByID, /* 0.8.7 */
     .domainLookupByUUID = vmwareDomainLookupByUUID, /* 0.8.7 */
@@ -1142,9 +1142,9 @@ static virDriver vmwareDriver = {
     .domainGetInfo = vmwareDomainGetInfo, /* 0.8.7 */
     .domainGetState = vmwareDomainGetState, /* 0.9.2 */
     .domainGetXMLDesc = vmwareDomainGetXMLDesc, /* 0.8.7 */
-    .domainXMLFromNative = vmwareDomainXMLFromNative, /* 0.9.11 */
-    .listDefinedDomains = vmwareListDefinedDomains, /* 0.8.7 */
-    .numOfDefinedDomains = vmwareNumDefinedDomains, /* 0.8.7 */
+    .connectDomainXMLFromNative = vmwareDomainXMLFromNative, /* 0.9.11 */
+    .connectListDefinedDomains = vmwareListDefinedDomains, /* 0.8.7 */
+    .connectNumOfDefinedDomains = vmwareNumDefinedDomains, /* 0.8.7 */
     .domainCreate = vmwareDomainCreate, /* 0.8.7 */
     .domainCreateWithFlags = vmwareDomainCreateWithFlags, /* 0.8.7 */
     .domainDefineXML = vmwareDomainDefineXML, /* 0.8.7 */
@@ -1152,7 +1152,7 @@ static virDriver vmwareDriver = {
     .domainUndefineFlags = vmwareDomainUndefineFlags, /* 0.9.4 */
     .domainIsActive = vmwareDomainIsActive, /* 0.8.7 */
     .domainIsPersistent = vmwareDomainIsPersistent, /* 0.8.7 */
-    .isAlive = vmwareIsAlive, /* 0.9.8 */
+    .connectIsAlive = vmwareIsAlive, /* 0.9.8 */
 };
 
 int
diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c
index 5a15b58..04f4206 100644
--- a/src/xen/xen_driver.c
+++ b/src/xen/xen_driver.c
@@ -213,7 +213,7 @@ xenInitialize(bool privileged ATTRIBUTE_UNUSED,
 
 static virStateDriver state_driver = {
     .name = "Xen",
-    .initialize = xenInitialize,
+    .stateInitialize = xenInitialize,
 };
 
 #endif
@@ -2330,17 +2330,17 @@ cleanup:
 static virDriver xenUnifiedDriver = {
     .no = VIR_DRV_XEN_UNIFIED,
     .name = "Xen",
-    .open = xenUnifiedOpen, /* 0.0.3 */
-    .close = xenUnifiedClose, /* 0.0.3 */
-    .supports_feature = xenUnifiedSupportsFeature, /* 0.3.2 */
-    .type = xenUnifiedType, /* 0.0.3 */
-    .version = xenUnifiedGetVersion, /* 0.0.3 */
-    .getHostname = virGetHostname, /* 0.7.3 */
-    .getMaxVcpus = xenUnifiedGetMaxVcpus, /* 0.2.1 */
+    .connectOpen = xenUnifiedOpen, /* 0.0.3 */
+    .connectClose = xenUnifiedClose, /* 0.0.3 */
+    .connectSupportsFeature = xenUnifiedSupportsFeature, /* 0.3.2 */
+    .connectGetType = xenUnifiedType, /* 0.0.3 */
+    .connectGetVersion = xenUnifiedGetVersion, /* 0.0.3 */
+    .connectGetHostname = virGetHostname, /* 0.7.3 */
+    .connectGetMaxVcpus = xenUnifiedGetMaxVcpus, /* 0.2.1 */
     .nodeGetInfo = xenUnifiedNodeGetInfo, /* 0.1.0 */
-    .getCapabilities = xenUnifiedGetCapabilities, /* 0.2.1 */
-    .listDomains = xenUnifiedListDomains, /* 0.0.3 */
-    .numOfDomains = xenUnifiedNumOfDomains, /* 0.0.3 */
+    .connectGetCapabilities = xenUnifiedGetCapabilities, /* 0.2.1 */
+    .connectListDomains = xenUnifiedListDomains, /* 0.0.3 */
+    .connectNumOfDomains = xenUnifiedNumOfDomains, /* 0.0.3 */
     .domainCreateXML = xenUnifiedDomainCreateXML, /* 0.0.3 */
     .domainLookupByID = xenUnifiedDomainLookupByID, /* 0.0.3 */
     .domainLookupByUUID = xenUnifiedDomainLookupByUUID, /* 0.0.5 */
@@ -2373,10 +2373,10 @@ static virDriver xenUnifiedDriver = {
     .domainGetVcpus = xenUnifiedDomainGetVcpus, /* 0.1.4 */
     .domainGetMaxVcpus = xenUnifiedDomainGetMaxVcpus, /* 0.2.1 */
     .domainGetXMLDesc = xenUnifiedDomainGetXMLDesc, /* 0.0.3 */
-    .domainXMLFromNative = xenUnifiedDomainXMLFromNative, /* 0.6.4 */
-    .domainXMLToNative = xenUnifiedDomainXMLToNative, /* 0.6.4 */
-    .listDefinedDomains = xenUnifiedListDefinedDomains, /* 0.1.1 */
-    .numOfDefinedDomains = xenUnifiedNumOfDefinedDomains, /* 0.1.5 */
+    .connectDomainXMLFromNative = xenUnifiedDomainXMLFromNative, /* 0.6.4 */
+    .connectDomainXMLToNative = xenUnifiedDomainXMLToNative, /* 0.6.4 */
+    .connectListDefinedDomains = xenUnifiedListDefinedDomains, /* 0.1.1 */
+    .connectNumOfDefinedDomains = xenUnifiedNumOfDefinedDomains, /* 0.1.5 */
     .domainCreate = xenUnifiedDomainCreate, /* 0.1.1 */
     .domainCreateWithFlags = xenUnifiedDomainCreateWithFlags, /* 0.8.2 */
     .domainDefineXML = xenUnifiedDomainDefineXML, /* 0.1.1 */
@@ -2402,20 +2402,20 @@ static virDriver xenUnifiedDriver = {
     .domainBlockPeek = xenUnifiedDomainBlockPeek, /* 0.4.4 */
     .nodeGetCellsFreeMemory = xenUnifiedNodeGetCellsFreeMemory, /* 0.3.3 */
     .nodeGetFreeMemory = xenUnifiedNodeGetFreeMemory, /* 0.3.3 */
-    .domainEventRegister = xenUnifiedDomainEventRegister, /* 0.5.0 */
-    .domainEventDeregister = xenUnifiedDomainEventDeregister, /* 0.5.0 */
+    .connectDomainEventRegister = xenUnifiedDomainEventRegister, /* 0.5.0 */
+    .connectDomainEventDeregister = xenUnifiedDomainEventDeregister, /* 0.5.0 */
     .nodeDeviceDettach = xenUnifiedNodeDeviceDettach, /* 0.6.1 */
     .nodeDeviceReAttach = xenUnifiedNodeDeviceReAttach, /* 0.6.1 */
     .nodeDeviceReset = xenUnifiedNodeDeviceReset, /* 0.6.1 */
-    .isEncrypted = xenUnifiedIsEncrypted, /* 0.7.3 */
-    .isSecure = xenUnifiedIsSecure, /* 0.7.3 */
+    .connectIsEncrypted = xenUnifiedIsEncrypted, /* 0.7.3 */
+    .connectIsSecure = xenUnifiedIsSecure, /* 0.7.3 */
     .domainIsActive = xenUnifiedDomainIsActive, /* 0.7.3 */
     .domainIsPersistent = xenUnifiedDomainIsPersistent, /* 0.7.3 */
     .domainIsUpdated = xenUnifiedDomainIsUpdated, /* 0.8.6 */
-    .domainEventRegisterAny = xenUnifiedDomainEventRegisterAny, /* 0.8.0 */
-    .domainEventDeregisterAny = xenUnifiedDomainEventDeregisterAny, /* 0.8.0 */
+    .connectDomainEventRegisterAny = xenUnifiedDomainEventRegisterAny, /* 0.8.0 */
+    .connectDomainEventDeregisterAny = xenUnifiedDomainEventDeregisterAny, /* 0.8.0 */
     .domainOpenConsole = xenUnifiedDomainOpenConsole, /* 0.8.6 */
-    .isAlive = xenUnifiedIsAlive, /* 0.9.8 */
+    .connectIsAlive = xenUnifiedIsAlive, /* 0.9.8 */
     .nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
     .nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
     .nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
diff --git a/src/xenapi/xenapi_driver.c b/src/xenapi/xenapi_driver.c
index 123c4f2..fb81184 100644
--- a/src/xenapi/xenapi_driver.c
+++ b/src/xenapi/xenapi_driver.c
@@ -1934,17 +1934,17 @@ xenapiIsAlive(virConnectPtr conn)
 static virDriver xenapiDriver = {
     .no = VIR_DRV_XENAPI,
     .name = "XenAPI",
-    .open = xenapiOpen, /* 0.8.0 */
-    .close = xenapiClose, /* 0.8.0 */
-    .supports_feature = xenapiSupportsFeature, /* 0.8.0 */
-    .type = xenapiType, /* 0.8.0 */
-    .version = xenapiGetVersion, /* 0.8.0 */
-    .getHostname = xenapiGetHostname, /* 0.8.0 */
-    .getMaxVcpus = xenapiGetMaxVcpus, /* 0.8.0 */
+    .connectOpen = xenapiOpen, /* 0.8.0 */
+    .connectClose = xenapiClose, /* 0.8.0 */
+    .connectSupportsFeature = xenapiSupportsFeature, /* 0.8.0 */
+    .connectGetType = xenapiType, /* 0.8.0 */
+    .connectGetVersion = xenapiGetVersion, /* 0.8.0 */
+    .connectGetHostname = xenapiGetHostname, /* 0.8.0 */
+    .connectGetMaxVcpus = xenapiGetMaxVcpus, /* 0.8.0 */
     .nodeGetInfo = xenapiNodeGetInfo, /* 0.8.0 */
-    .getCapabilities = xenapiGetCapabilities, /* 0.8.0 */
-    .listDomains = xenapiListDomains, /* 0.8.0 */
-    .numOfDomains = xenapiNumOfDomains, /* 0.8.0 */
+    .connectGetCapabilities = xenapiGetCapabilities, /* 0.8.0 */
+    .connectListDomains = xenapiListDomains, /* 0.8.0 */
+    .connectNumOfDomains = xenapiNumOfDomains, /* 0.8.0 */
     .domainCreateXML = xenapiDomainCreateXML, /* 0.8.0 */
     .domainLookupByID = xenapiDomainLookupByID, /* 0.8.0 */
     .domainLookupByUUID = xenapiDomainLookupByUUID, /* 0.8.0 */
@@ -1968,8 +1968,8 @@ static virDriver xenapiDriver = {
     .domainGetVcpus = xenapiDomainGetVcpus, /* 0.8.0 */
     .domainGetMaxVcpus = xenapiDomainGetMaxVcpus, /* 0.8.0 */
     .domainGetXMLDesc = xenapiDomainGetXMLDesc, /* 0.8.0 */
-    .listDefinedDomains = xenapiListDefinedDomains, /* 0.8.0 */
-    .numOfDefinedDomains = xenapiNumOfDefinedDomains, /* 0.8.0 */
+    .connectListDefinedDomains = xenapiListDefinedDomains, /* 0.8.0 */
+    .connectNumOfDefinedDomains = xenapiNumOfDefinedDomains, /* 0.8.0 */
     .domainCreate = xenapiDomainCreate, /* 0.8.0 */
     .domainCreateWithFlags = xenapiDomainCreateWithFlags, /* 0.8.2 */
     .domainDefineXML = xenapiDomainDefineXML, /* 0.8.0 */
@@ -1981,7 +1981,7 @@ static virDriver xenapiDriver = {
     .nodeGetCellsFreeMemory = xenapiNodeGetCellsFreeMemory, /* 0.8.0 */
     .nodeGetFreeMemory = xenapiNodeGetFreeMemory, /* 0.8.0 */
     .domainIsUpdated = xenapiDomainIsUpdated, /* 0.8.6 */
-    .isAlive = xenapiIsAlive, /* 0.9.8 */
+    .connectIsAlive = xenapiIsAlive, /* 0.9.8 */
 };
 
 /**
diff --git a/tests/qemuxml2argvtest.c b/tests/qemuxml2argvtest.c
index ae73509..25722f3 100644
--- a/tests/qemuxml2argvtest.c
+++ b/tests/qemuxml2argvtest.c
@@ -60,17 +60,17 @@ fakeSecretClose(virConnectPtr conn ATTRIBUTE_UNUSED)
 
 static virSecretDriver fakeSecretDriver = {
     .name = "fake_secret",
-    .open = NULL,
-    .close = fakeSecretClose,
-    .numOfSecrets = NULL,
-    .listSecrets = NULL,
-    .lookupByUUID = NULL,
-    .lookupByUsage = fakeSecretLookupByUsage,
-    .defineXML = NULL,
-    .getXMLDesc = NULL,
-    .setValue = NULL,
-    .getValue = fakeSecretGetValue,
-    .undefine = NULL,
+    .connectOpen = NULL,
+    .connectClose = fakeSecretClose,
+    .connectNumOfSecrets = NULL,
+    .connectListSecrets = NULL,
+    .secretLookupByUUID = NULL,
+    .secretLookupByUsage = fakeSecretLookupByUsage,
+    .secretDefineXML = NULL,
+    .secretGetXMLDesc = NULL,
+    .secretSetValue = NULL,
+    .secretGetValue = fakeSecretGetValue,
+    .secretUndefine = NULL,
 };
 
 typedef enum {
-- 
1.8.1.4


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