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

[libvirt] [PATCH 5/6] Sanitize whitespace in driver.h



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

The driver.h file has no consistent indentation usage across
all the typedefs. Attempts to vertically align struct field
members have also been inconsistently applied. Sanitize the
whitespace used for typedefs & remove all vertical alignment
from structs

Signed-off-by: Daniel P. Berrange <berrange redhat com>
---
 src/driver.h | 2561 +++++++++++++++++++++++++++++++---------------------------
 1 file changed, 1376 insertions(+), 1185 deletions(-)

diff --git a/src/driver.h b/src/driver.h
index 8c1a9d1..8eb25ea 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -67,879 +67,967 @@ typedef enum {
         (drv)->connectSupportsFeature((conn), (feature)) > 0 : 0)
 
 typedef virDrvOpenStatus
-        (*virDrvConnectOpen)    (virConnectPtr conn,
-                                 virConnectAuthPtr auth,
-                                 unsigned int flags);
+(*virDrvConnectOpen)(virConnectPtr conn,
+                     virConnectAuthPtr auth,
+                     unsigned int flags);
+
 typedef int
-        (*virDrvConnectClose)   (virConnectPtr conn);
+(*virDrvConnectClose)(virConnectPtr conn);
+
 typedef int
-    (*virDrvConnectSupportsFeature) (virConnectPtr conn, int feature);
+(*virDrvConnectSupportsFeature)(virConnectPtr conn,
+                                int feature);
+
 typedef const char *
-        (*virDrvConnectGetType)        (virConnectPtr conn);
+(*virDrvConnectGetType)(virConnectPtr conn);
+
 typedef int
-        (*virDrvConnectGetVersion)     (virConnectPtr conn,
-                                        unsigned long *hvVer);
+(*virDrvConnectGetVersion)(virConnectPtr conn,
+                           unsigned long *hvVer);
+
 typedef int
-        (*virDrvConnectGetLibVersion)  (virConnectPtr conn,
-                                        unsigned long *libVer);
+(*virDrvConnectGetLibVersion)(virConnectPtr conn,
+                              unsigned long *libVer);
+
 typedef char *
-    (*virDrvConnectGetHostname)    (virConnectPtr conn);
+(*virDrvConnectGetHostname)(virConnectPtr conn);
+
 typedef char *
-    (*virDrvConnectGetURI)         (virConnectPtr conn);
+(*virDrvConnectGetURI)(virConnectPtr conn);
+
 typedef char *
-    (*virDrvConnectGetSysinfo)     (virConnectPtr conn,
-                                    unsigned int flags);
+(*virDrvConnectGetSysinfo)(virConnectPtr conn,
+                           unsigned int flags);
+
 typedef int
-        (*virDrvConnectGetMaxVcpus)            (virConnectPtr conn,
-                                                const char *type);
+(*virDrvConnectGetMaxVcpus)(virConnectPtr conn,
+                            const char *type);
+
 typedef int
-        (*virDrvNodeGetInfo)            (virConnectPtr conn,
-                                         virNodeInfoPtr info);
+(*virDrvNodeGetInfo)(virConnectPtr conn,
+                     virNodeInfoPtr info);
+
 typedef char *
-        (*virDrvConnectGetCapabilities)        (virConnectPtr conn);
+(*virDrvConnectGetCapabilities)(virConnectPtr conn);
+
 typedef int
-        (*virDrvConnectListDomains)            (virConnectPtr conn,
-                                                int *ids,
-                                                int maxids);
+(*virDrvConnectListDomains)(virConnectPtr conn,
+                            int *ids,
+                            int maxids);
+
 typedef int
-        (*virDrvConnectNumOfDomains)           (virConnectPtr conn);
+(*virDrvConnectNumOfDomains)(virConnectPtr conn);
+
 typedef virDomainPtr
-        (*virDrvDomainCreateXML)        (virConnectPtr conn,
-                                         const char *xmlDesc,
-                                         unsigned int flags);
+(*virDrvDomainCreateXML)(virConnectPtr conn,
+                         const char *xmlDesc,
+                         unsigned int flags);
+
 typedef virDomainPtr
-        (*virDrvDomainLookupByID)       (virConnectPtr conn,
-                                         int id);
+(*virDrvDomainLookupByID)(virConnectPtr conn,
+                          int id);
+
 typedef virDomainPtr
-        (*virDrvDomainLookupByUUID)     (virConnectPtr conn,
-                                         const unsigned char *uuid);
+(*virDrvDomainLookupByUUID)(virConnectPtr conn,
+                            const unsigned char *uuid);
+
 typedef virDomainPtr
-        (*virDrvDomainLookupByName)     (virConnectPtr conn,
-                                         const char *name);
+(*virDrvDomainLookupByName)(virConnectPtr conn,
+                            const char *name);
+
 typedef int
-        (*virDrvDomainSuspend)          (virDomainPtr domain);
+(*virDrvDomainSuspend)(virDomainPtr domain);
+
 typedef int
-        (*virDrvDomainResume)           (virDomainPtr domain);
+(*virDrvDomainResume)(virDomainPtr domain);
+
 typedef int
-        (*virDrvDomainPMSuspendForDuration) (virDomainPtr,
-                                             unsigned int target,
-                                             unsigned long long duration,
-                                             unsigned int flags);
+ (*virDrvDomainPMSuspendForDuration)(virDomainPtr,
+                                     unsigned int target,
+                                     unsigned long long duration,
+                                     unsigned int flags);
+
 typedef int
-        (*virDrvDomainPMWakeup)         (virDomainPtr domain,
-                                         unsigned int flags);
+(*virDrvDomainPMWakeup)(virDomainPtr domain,
+                        unsigned int flags);
+
 typedef int
-        (*virDrvDomainShutdown)         (virDomainPtr domain);
+(*virDrvDomainShutdown)(virDomainPtr domain);
+
 typedef int
-        (*virDrvDomainReboot)           (virDomainPtr domain,
-                                         unsigned int flags);
+(*virDrvDomainReboot)(virDomainPtr domain,
+                      unsigned int flags);
+
 typedef int
-        (*virDrvDomainReset)            (virDomainPtr domain,
-                                         unsigned int flags);
+(*virDrvDomainReset)(virDomainPtr domain,
+                     unsigned int flags);
+
 typedef int
-        (*virDrvDomainDestroy)          (virDomainPtr domain);
+(*virDrvDomainDestroy)(virDomainPtr domain);
+
 typedef int
-        (*virDrvDomainDestroyFlags)     (virDomainPtr domain,
-                                         unsigned int flags);
+(*virDrvDomainDestroyFlags)(virDomainPtr domain,
+                            unsigned int flags);
+
 typedef char *
-        (*virDrvDomainGetOSType)        (virDomainPtr domain);
+(*virDrvDomainGetOSType)(virDomainPtr domain);
 
 typedef char *
-        (*virDrvDomainGetHostname)      (virDomainPtr domain,
-                                         unsigned int flags);
+(*virDrvDomainGetHostname)(virDomainPtr domain,
+                           unsigned int flags);
 
 typedef unsigned long long
-        (*virDrvDomainGetMaxMemory)     (virDomainPtr domain);
+(*virDrvDomainGetMaxMemory)(virDomainPtr domain);
+
 typedef int
-        (*virDrvDomainSetMaxMemory)     (virDomainPtr domain,
-                                         unsigned long memory);
+(*virDrvDomainSetMaxMemory)(virDomainPtr domain,
+                            unsigned long memory);
+
 typedef int
-        (*virDrvDomainSetMemory)        (virDomainPtr domain,
-                                         unsigned long memory);
+(*virDrvDomainSetMemory)(virDomainPtr domain,
+                         unsigned long memory);
+
 typedef int
-        (*virDrvDomainSetMemoryFlags)   (virDomainPtr domain,
-                                         unsigned long memory,
-                                         unsigned int flags);
+(*virDrvDomainSetMemoryFlags)(virDomainPtr domain,
+                              unsigned long memory,
+                              unsigned int flags);
+
 typedef int
-        (*virDrvDomainSetMemoryParameters)
-                                        (virDomainPtr domain,
-                                         virTypedParameterPtr params,
-                                         int nparams,
-                                         unsigned int flags);
+(*virDrvDomainSetMemoryParameters)(virDomainPtr domain,
+                                   virTypedParameterPtr params,
+                                   int nparams,
+                                   unsigned int flags);
+
 typedef int
-        (*virDrvDomainGetMemoryParameters)
-                                        (virDomainPtr domain,
-                                         virTypedParameterPtr params,
-                                         int *nparams,
-                                         unsigned int flags);
+(*virDrvDomainGetMemoryParameters)(virDomainPtr domain,
+                                   virTypedParameterPtr params,
+                                   int *nparams,
+                                   unsigned int flags);
+
 typedef int
-        (*virDrvDomainSetNumaParameters)
-                                        (virDomainPtr domain,
-                                         virTypedParameterPtr params,
-                                         int nparams,
-                                         unsigned int flags);
+(*virDrvDomainSetNumaParameters)(virDomainPtr domain,
+                                 virTypedParameterPtr params,
+                                 int nparams,
+                                 unsigned int flags);
+
 typedef int
-        (*virDrvDomainGetNumaParameters)
-                                        (virDomainPtr domain,
-                                         virTypedParameterPtr params,
-                                         int *nparams,
-                                         unsigned int flags);
+(*virDrvDomainGetNumaParameters)(virDomainPtr domain,
+                                 virTypedParameterPtr params,
+                                 int *nparams,
+                                 unsigned int flags);
 
 typedef int
-        (*virDrvDomainSetBlkioParameters)
-                                        (virDomainPtr domain,
-                                         virTypedParameterPtr params,
-                                         int nparams,
-                                         unsigned int flags);
+(*virDrvDomainSetBlkioParameters)(virDomainPtr domain,
+                                  virTypedParameterPtr params,
+                                  int nparams,
+                                  unsigned int flags);
+
 typedef int
-        (*virDrvDomainGetBlkioParameters)
-                                        (virDomainPtr domain,
-                                         virTypedParameterPtr params,
-                                         int *nparams,
-                                         unsigned int flags);
+(*virDrvDomainGetBlkioParameters)(virDomainPtr domain,
+                                  virTypedParameterPtr params,
+                                  int *nparams,
+                                  unsigned int flags);
+
 typedef int
-        (*virDrvDomainGetInfo)          (virDomainPtr domain,
-                                         virDomainInfoPtr info);
+(*virDrvDomainGetInfo)(virDomainPtr domain,
+                       virDomainInfoPtr info);
+
 typedef int
-        (*virDrvDomainGetState)         (virDomainPtr domain,
-                                         int *state,
-                                         int *reason,
-                                         unsigned int flags);
+(*virDrvDomainGetState)(virDomainPtr domain,
+                        int *state,
+                        int *reason,
+                        unsigned int flags);
+
 typedef int
-        (*virDrvDomainGetControlInfo)   (virDomainPtr domain,
-                                         virDomainControlInfoPtr info,
-                                         unsigned int flags);
+(*virDrvDomainGetControlInfo)(virDomainPtr domain,
+                              virDomainControlInfoPtr info,
+                              unsigned int flags);
+
 typedef int
-        (*virDrvDomainSave)             (virDomainPtr domain,
-                                         const char *to);
+(*virDrvDomainSave)(virDomainPtr domain,
+                    const char *to);
+
 typedef int
-        (*virDrvDomainSaveFlags)        (virDomainPtr domain,
-                                         const char *to,
-                                         const char *dxml,
-                                         unsigned int flags);
+(*virDrvDomainSaveFlags)(virDomainPtr domain,
+                         const char *to,
+                         const char *dxml,
+                         unsigned int flags);
+
 typedef int
-        (*virDrvDomainRestore)          (virConnectPtr conn,
-                                         const char *from);
+(*virDrvDomainRestore)(virConnectPtr conn,
+                       const char *from);
+
 typedef int
-        (*virDrvDomainRestoreFlags)     (virConnectPtr conn,
-                                         const char *from,
-                                         const char *dxml,
-                                         unsigned int flags);
+(*virDrvDomainRestoreFlags)(virConnectPtr conn,
+                            const char *from,
+                            const char *dxml,
+                            unsigned int flags);
+
 typedef char *
-        (*virDrvDomainSaveImageGetXMLDesc)      (virConnectPtr conn,
-                                                 const char *file,
-                                                 unsigned int flags);
+(*virDrvDomainSaveImageGetXMLDesc)(virConnectPtr conn,
+                                   const char *file,
+                                   unsigned int flags);
+
 typedef int
-        (*virDrvDomainSaveImageDefineXML)       (virConnectPtr conn,
-                                                 const char *file,
-                                                 const char *dxml,
-                                                 unsigned int flags);
+(*virDrvDomainSaveImageDefineXML)(virConnectPtr conn,
+                                  const char *file,
+                                  const char *dxml,
+                                  unsigned int flags);
+
 typedef int
-        (*virDrvDomainCoreDump)         (virDomainPtr domain,
-                                         const char *to,
-                                         unsigned int flags);
+(*virDrvDomainCoreDump)(virDomainPtr domain,
+                        const char *to,
+                        unsigned int flags);
+
 typedef char *
-        (*virDrvDomainScreenshot)       (virDomainPtr domain,
-                                         virStreamPtr stream,
-                                         unsigned int screen,
-                                         unsigned int flags);
+(*virDrvDomainScreenshot)(virDomainPtr domain,
+                          virStreamPtr stream,
+                          unsigned int screen,
+                          unsigned int flags);
+
 typedef char *
-        (*virDrvDomainGetXMLDesc)       (virDomainPtr dom,
-                                         unsigned int flags);
+(*virDrvDomainGetXMLDesc)(virDomainPtr dom,
+                          unsigned int flags);
+
 typedef char *
-        (*virDrvConnectDomainXMLFromNative) (virConnectPtr conn,
-                                             const char *nativeFormat,
-                                             const char *nativeConfig,
-                                             unsigned int flags);
+(*virDrvConnectDomainXMLFromNative)(virConnectPtr conn,
+                                    const char *nativeFormat,
+                                    const char *nativeConfig,
+                                    unsigned int flags);
+
 typedef char *
-        (*virDrvConnectDomainXMLToNative) (virConnectPtr conn,
-                                           const char *nativeFormat,
-                                           const char *domainXml,
-                                           unsigned int flags);
+(*virDrvConnectDomainXMLToNative)(virConnectPtr conn,
+                                  const char *nativeFormat,
+                                  const char *domainXml,
+                                  unsigned int flags);
+
 typedef int
-        (*virDrvConnectListDefinedDomains)     (virConnectPtr conn,
-                                                char **const names,
-                                                int maxnames);
+(*virDrvConnectListDefinedDomains)(virConnectPtr conn,
+                                   char **const names,
+                                   int maxnames);
+
 typedef int
-        (*virDrvConnectListAllDomains)         (virConnectPtr conn,
-                                                virDomainPtr **domains,
-                                                unsigned int flags);
+(*virDrvConnectListAllDomains)(virConnectPtr conn,
+                               virDomainPtr **domains,
+                               unsigned int flags);
+
 typedef int
-        (*virDrvConnectNumOfDefinedDomains)    (virConnectPtr conn);
+(*virDrvConnectNumOfDefinedDomains)(virConnectPtr conn);
+
 typedef int
-        (*virDrvDomainCreate)           (virDomainPtr dom);
+(*virDrvDomainCreate)(virDomainPtr dom);
+
 typedef int
-        (*virDrvDomainCreateWithFlags)  (virDomainPtr dom,
-                                         unsigned int flags);
+(*virDrvDomainCreateWithFlags)(virDomainPtr dom,
+                               unsigned int flags);
+
 typedef virDomainPtr
-        (*virDrvDomainDefineXML)        (virConnectPtr conn,
-                                         const char *xml);
+(*virDrvDomainDefineXML)(virConnectPtr conn,
+                         const char *xml);
+
 typedef int
-        (*virDrvDomainUndefine)         (virDomainPtr dom);
+(*virDrvDomainUndefine)(virDomainPtr dom);
+
 typedef int
-        (*virDrvDomainUndefineFlags)    (virDomainPtr dom,
-                                         unsigned int flags);
+(*virDrvDomainUndefineFlags)(virDomainPtr dom,
+                             unsigned int flags);
+
 typedef int
-        (*virDrvDomainSetVcpus)         (virDomainPtr domain,
-                                         unsigned int nvcpus);
+(*virDrvDomainSetVcpus)(virDomainPtr domain,
+                        unsigned int nvcpus);
+
 typedef int
-        (*virDrvDomainSetVcpusFlags)    (virDomainPtr domain,
-                                         unsigned int nvcpus,
-                                         unsigned int flags);
+(*virDrvDomainSetVcpusFlags)(virDomainPtr domain,
+                             unsigned int nvcpus,
+                             unsigned int flags);
+
 typedef int
-        (*virDrvDomainGetVcpusFlags)    (virDomainPtr domain,
-                                         unsigned int flags);
+(*virDrvDomainGetVcpusFlags)(virDomainPtr domain,
+                             unsigned int flags);
+
 typedef int
-        (*virDrvDomainPinVcpu)          (virDomainPtr domain,
-                                         unsigned int vcpu,
-                                         unsigned char *cpumap,
-                                         int maplen);
+(*virDrvDomainPinVcpu)(virDomainPtr domain,
+                       unsigned int vcpu,
+                       unsigned char *cpumap,
+                       int maplen);
+
 typedef int
-        (*virDrvDomainPinVcpuFlags)     (virDomainPtr domain,
-                                         unsigned int vcpu,
-                                         unsigned char *cpumap,
-                                         int maplen,
-                                         unsigned int flags);
+(*virDrvDomainPinVcpuFlags)(virDomainPtr domain,
+                            unsigned int vcpu,
+                            unsigned char *cpumap,
+                            int maplen,
+                            unsigned int flags);
+
 typedef int
-        (*virDrvDomainGetVcpuPinInfo)   (virDomainPtr domain,
-                                         int ncpumaps,
-                                         unsigned char *cpumaps,
-                                         int maplen,
-                                         unsigned int flags);
- typedef int
-        (*virDrvDomainPinEmulator)     (virDomainPtr domain,
-                                        unsigned char *cpumap,
-                                        int maplen,
-                                        unsigned int flags);
+(*virDrvDomainGetVcpuPinInfo)(virDomainPtr domain,
+                              int ncpumaps,
+                              unsigned char *cpumaps,
+                              int maplen,
+                              unsigned int flags);
+
 typedef int
-        (*virDrvDomainGetEmulatorPinInfo)   (virDomainPtr domain,
-                                             unsigned char *cpumaps,
-                                             int maplen,
-                                             unsigned int flags);
+(*virDrvDomainPinEmulator)(virDomainPtr domain,
+                           unsigned char *cpumap,
+                           int maplen,
+                           unsigned int flags);
 
 typedef int
-        (*virDrvDomainGetVcpus)         (virDomainPtr domain,
-                                         virVcpuInfoPtr info,
-                                         int maxinfo,
-                                         unsigned char *cpumaps,
-                                         int maplen);
+(*virDrvDomainGetEmulatorPinInfo)(virDomainPtr domain,
+                                  unsigned char *cpumaps,
+                                  int maplen,
+                                  unsigned int flags);
+
 typedef int
-        (*virDrvDomainGetMaxVcpus)      (virDomainPtr domain);
+(*virDrvDomainGetVcpus)(virDomainPtr domain,
+                        virVcpuInfoPtr info,
+                        int maxinfo,
+                        unsigned char *cpumaps,
+                        int maplen);
 
 typedef int
-        (*virDrvDomainGetSecurityLabel) (virDomainPtr domain,
-                                         virSecurityLabelPtr seclabel);
+(*virDrvDomainGetMaxVcpus)(virDomainPtr domain);
+
+typedef int
+(*virDrvDomainGetSecurityLabel)(virDomainPtr domain,
+                                virSecurityLabelPtr seclabel);
+
 typedef int
-        (*virDrvDomainGetSecurityLabelList) (virDomainPtr domain,
-                                         virSecurityLabelPtr* seclabels);
+(*virDrvDomainGetSecurityLabelList)(virDomainPtr domain,
+                                    virSecurityLabelPtr* seclabels);
+
 typedef int
-        (*virDrvNodeGetSecurityModel)   (virConnectPtr conn,
-                                         virSecurityModelPtr secmodel);
+(*virDrvNodeGetSecurityModel)(virConnectPtr conn,
+                              virSecurityModelPtr secmodel);
+
 typedef int
-        (*virDrvDomainAttachDevice)     (virDomainPtr domain,
-                                         const char *xml);
+(*virDrvDomainAttachDevice)(virDomainPtr domain,
+                            const char *xml);
+
 typedef int
-        (*virDrvDomainAttachDeviceFlags) (virDomainPtr domain,
-                                          const char *xml,
-                                          unsigned int flags);
+(*virDrvDomainAttachDeviceFlags)(virDomainPtr domain,
+                                 const char *xml,
+                                 unsigned int flags);
+
 typedef int
-        (*virDrvDomainDetachDevice)      (virDomainPtr domain,
-                                         const char *xml);
+(*virDrvDomainDetachDevice)(virDomainPtr domain,
+                            const char *xml);
+
 typedef int
-        (*virDrvDomainDetachDeviceFlags) (virDomainPtr domain,
-                                          const char *xml,
-                                          unsigned int flags);
+(*virDrvDomainDetachDeviceFlags)(virDomainPtr domain,
+                                 const char *xml,
+                                 unsigned int flags);
+
 typedef int
-        (*virDrvDomainUpdateDeviceFlags) (virDomainPtr domain,
-                                          const char *xml,
-                                          unsigned int flags);
+(*virDrvDomainUpdateDeviceFlags)(virDomainPtr domain,
+                                 const char *xml,
+                                 unsigned int flags);
+
 typedef int
-        (*virDrvDomainGetAutostart)      (virDomainPtr domain,
-                                          int *autostart);
+(*virDrvDomainGetAutostart)(virDomainPtr domain,
+                            int *autostart);
+
 typedef int
-        (*virDrvDomainSetAutostart) (virDomainPtr domain,
-                                         int autostart);
+(*virDrvDomainSetAutostart)(virDomainPtr domain,
+                            int autostart);
 
 typedef char *
-        (*virDrvDomainGetSchedulerType) (virDomainPtr domain,
-                                         int *nparams);
+(*virDrvDomainGetSchedulerType)(virDomainPtr domain,
+                                int *nparams);
 
 typedef int
-        (*virDrvDomainGetSchedulerParameters)
-                                        (virDomainPtr domain,
-                                         virTypedParameterPtr params,
-                                         int *nparams);
+(*virDrvDomainGetSchedulerParameters)(virDomainPtr domain,
+                                      virTypedParameterPtr params,
+                                      int *nparams);
 
 typedef int
-        (*virDrvDomainGetSchedulerParametersFlags)
-                                        (virDomainPtr domain,
-                                         virTypedParameterPtr params,
-                                         int *nparams,
-                                         unsigned int flags);
+(*virDrvDomainGetSchedulerParametersFlags)(virDomainPtr domain,
+                                           virTypedParameterPtr params,
+                                           int *nparams,
+                                           unsigned int flags);
 
 typedef int
-        (*virDrvDomainSetSchedulerParameters)
-                                        (virDomainPtr domain,
-                                         virTypedParameterPtr params,
-                                         int nparams);
+(*virDrvDomainSetSchedulerParameters)(virDomainPtr domain,
+                                      virTypedParameterPtr params,
+                                      int nparams);
 
 typedef int
-        (*virDrvDomainSetSchedulerParametersFlags)
-                                        (virDomainPtr domain,
-                                         virTypedParameterPtr params,
-                                         int nparams,
-                                         unsigned int flags);
+(*virDrvDomainSetSchedulerParametersFlags)(virDomainPtr domain,
+                                           virTypedParameterPtr params,
+                                           int nparams,
+                                           unsigned int flags);
 
 typedef int
-    (*virDrvDomainBlockStats)
-                    (virDomainPtr domain,
-                     const char *path,
-                     struct _virDomainBlockStats *stats);
+(*virDrvDomainBlockStats)(virDomainPtr domain,
+                          const char *path,
+                          struct _virDomainBlockStats *stats);
+
 typedef int
-    (*virDrvDomainBlockStatsFlags)
-                    (virDomainPtr domain,
-                     const char *path,
-                     virTypedParameterPtr params,
-                     int *nparams,
-                     unsigned int flags);
+(*virDrvDomainBlockStatsFlags)(virDomainPtr domain,
+                               const char *path,
+                               virTypedParameterPtr params,
+                               int *nparams,
+                               unsigned int flags);
+
 typedef int
-    (*virDrvDomainInterfaceStats)
-                    (virDomainPtr domain,
-                     const char *path,
-                     struct _virDomainInterfaceStats *stats);
+(*virDrvDomainInterfaceStats)(virDomainPtr domain,
+                              const char *path,
+                              struct _virDomainInterfaceStats *stats);
+
 typedef int
-    (*virDrvDomainSetInterfaceParameters) (virDomainPtr dom,
-                                          const char *device,
-                                          virTypedParameterPtr params,
-                                          int nparams, unsigned int flags);
+(*virDrvDomainSetInterfaceParameters)(virDomainPtr dom,
+                                      const char *device,
+                                      virTypedParameterPtr params,
+                                      int nparams,
+                                      unsigned int flags);
+
 typedef int
-    (*virDrvDomainGetInterfaceParameters) (virDomainPtr dom,
-                                          const char *device,
-                                          virTypedParameterPtr params,
-                                          int *nparams, unsigned int flags);
+(*virDrvDomainGetInterfaceParameters)(virDomainPtr dom,
+                                      const char *device,
+                                      virTypedParameterPtr params,
+                                      int *nparams,
+                                      unsigned int flags);
 
 typedef int
-    (*virDrvDomainMemoryStats)
-                    (virDomainPtr domain,
-                     struct _virDomainMemoryStat *stats,
-                     unsigned int nr_stats,
-                     unsigned int flags);
+(*virDrvDomainMemoryStats)(virDomainPtr domain,
+                           struct _virDomainMemoryStat *stats,
+                           unsigned int nr_stats,
+                           unsigned int flags);
 
 typedef int
-    (*virDrvDomainBlockPeek)
-                    (virDomainPtr domain,
-                     const char *path,
-                     unsigned long long offset, size_t size,
-                     void *buffer,
-                     unsigned int flags);
+(*virDrvDomainBlockPeek)(virDomainPtr domain,
+                         const char *path,
+                         unsigned long long offset,
+                         size_t size,
+                         void *buffer,
+                         unsigned int flags);
+
 typedef int
-    (*virDrvDomainBlockResize)
-                    (virDomainPtr domain,
-                     const char *path,
-                     unsigned long long size,
-                     unsigned int flags);
+(*virDrvDomainBlockResize)(virDomainPtr domain,
+                           const char *path,
+                           unsigned long long size,
+                           unsigned int flags);
+
 typedef int
-    (*virDrvDomainMemoryPeek)
-                    (virDomainPtr domain,
-                     unsigned long long start, size_t size,
-                     void *buffer,
-                     unsigned int flags);
+(*virDrvDomainMemoryPeek)(virDomainPtr domain,
+                          unsigned long long start,
+                          size_t size,
+                          void *buffer,
+                          unsigned int flags);
+
 typedef int
-    (*virDrvDomainGetBlockInfo)
-                    (virDomainPtr domain,
-                     const char *path,
-                     virDomainBlockInfoPtr info,
-                     unsigned int flags);
+(*virDrvDomainGetBlockInfo)(virDomainPtr domain,
+                            const char *path,
+                            virDomainBlockInfoPtr info,
+                            unsigned int flags);
 
 typedef int
-    (*virDrvDomainMigratePrepare)
-                    (virConnectPtr dconn,
-                     char **cookie,
-                     int *cookielen,
-                     const char *uri_in,
-                     char **uri_out,
-                     unsigned long flags,
-                     const char *dname,
-                     unsigned long resource);
+(*virDrvDomainMigratePrepare)(virConnectPtr dconn,
+                              char **cookie,
+                              int *cookielen,
+                              const char *uri_in,
+                              char **uri_out,
+                              unsigned long flags,
+                              const char *dname,
+                              unsigned long resource);
 
 typedef int
-    (*virDrvDomainMigratePerform)
-                    (virDomainPtr domain,
-                     const char *cookie,
-                     int cookielen,
-                     const char *uri,
-                     unsigned long flags,
-                     const char *dname,
-                     unsigned long resource);
+(*virDrvDomainMigratePerform)(virDomainPtr domain,
+                              const char *cookie,
+                              int cookielen,
+                              const char *uri,
+                              unsigned long flags,
+                              const char *dname,
+                              unsigned long resource);
 
 typedef virDomainPtr
-    (*virDrvDomainMigrateFinish)
-                    (virConnectPtr dconn,
-                     const char *dname,
-                     const char *cookie,
-                     int cookielen,
-                     const char *uri,
-                     unsigned long flags);
-
-typedef struct _virDriver virDriver;
-typedef virDriver *virDriverPtr;
+(*virDrvDomainMigrateFinish)(virConnectPtr dconn,
+                             const char *dname,
+                             const char *cookie,
+                             int cookielen,
+                             const char *uri,
+                             unsigned long flags);
 
 typedef int
-    (*virDrvNodeGetCPUStats)
-                    (virConnectPtr conn,
-                     int cpuNum,
-                     virNodeCPUStatsPtr params,
-                     int *nparams,
-                     unsigned int flags);
+(*virDrvNodeGetCPUStats)(virConnectPtr conn,
+                         int cpuNum,
+                         virNodeCPUStatsPtr params,
+                         int *nparams,
+                         unsigned int flags);
 
 typedef int
-    (*virDrvNodeGetMemoryStats)
-                    (virConnectPtr conn,
-                     int cellNum,
-                     virNodeMemoryStatsPtr params,
-                     int *nparams,
-                     unsigned int flags);
+(*virDrvNodeGetMemoryStats)(virConnectPtr conn,
+                            int cellNum,
+                            virNodeMemoryStatsPtr params,
+                            int *nparams,
+                            unsigned int flags);
 
 typedef int
-    (*virDrvNodeGetCellsFreeMemory)
-                    (virConnectPtr conn,
-                     unsigned long long *freeMems,
-                     int startCell,
-                     int maxCells);
+(*virDrvNodeGetCellsFreeMemory)(virConnectPtr conn,
+                                unsigned long long *freeMems,
+                                int startCell,
+                                int maxCells);
 
 typedef unsigned long long
-    (*virDrvNodeGetFreeMemory)
-                    (virConnectPtr conn);
+(*virDrvNodeGetFreeMemory)(virConnectPtr conn);
 
 typedef int
-    (*virDrvConnectDomainEventRegister)
-                    (virConnectPtr conn,
-                     virConnectDomainEventCallback cb,
-                     void *opaque,
-                     virFreeCallback freecb);
+(*virDrvConnectDomainEventRegister)(virConnectPtr conn,
+                                    virConnectDomainEventCallback cb,
+                                    void *opaque,
+                                    virFreeCallback freecb);
 
 typedef int
-    (*virDrvConnectDomainEventDeregister)
-                    (virConnectPtr conn,
-                     virConnectDomainEventCallback cb);
+(*virDrvConnectDomainEventDeregister)(virConnectPtr conn,
+                                      virConnectDomainEventCallback cb);
 
 typedef int
-    (*virDrvDomainMigratePrepare2)
-                    (virConnectPtr dconn,
-                     char **cookie,
-                     int *cookielen,
-                     const char *uri_in,
-                     char **uri_out,
-                     unsigned long flags,
-                     const char *dname,
-                     unsigned long resource,
-                     const char *dom_xml);
+(*virDrvDomainMigratePrepare2)(virConnectPtr dconn,
+                               char **cookie,
+                               int *cookielen,
+                               const char *uri_in,
+                               char **uri_out,
+                               unsigned long flags,
+                               const char *dname,
+                               unsigned long resource,
+                               const char *dom_xml);
 
 typedef virDomainPtr
-    (*virDrvDomainMigrateFinish2)
-                    (virConnectPtr dconn,
-                     const char *dname,
-                     const char *cookie,
-                     int cookielen,
-                     const char *uri,
-                     unsigned long flags,
-                     int retcode);
+(*virDrvDomainMigrateFinish2)(virConnectPtr dconn,
+                              const char *dname,
+                              const char *cookie,
+                              int cookielen,
+                              const char *uri,
+                              unsigned long flags,
+                              int retcode);
 
 typedef int
-    (*virDrvNodeDeviceDettach)
-                    (virNodeDevicePtr dev);
+(*virDrvNodeDeviceDettach)(virNodeDevicePtr dev);
+
 typedef int
-    (*virDrvNodeDeviceReAttach)
-                    (virNodeDevicePtr dev);
+(*virDrvNodeDeviceReAttach)(virNodeDevicePtr dev);
+
 typedef int
-    (*virDrvNodeDeviceReset)
-                    (virNodeDevicePtr dev);
+(*virDrvNodeDeviceReset)(virNodeDevicePtr dev);
 
 typedef int
-    (*virDrvDomainMigratePrepareTunnel)
-                    (virConnectPtr dconn,
-                     virStreamPtr st,
-                     unsigned long flags,
-                     const char *dname,
-                     unsigned long resource,
-                     const char *dom_xml);
+(*virDrvDomainMigratePrepareTunnel)(virConnectPtr dconn,
+                                    virStreamPtr st,
+                                    unsigned long flags,
+                                    const char *dname,
+                                    unsigned long resource,
+                                    const char *dom_xml);
 
 typedef int
-    (*virDrvConnectIsEncrypted)(virConnectPtr conn);
+(*virDrvConnectIsEncrypted)(virConnectPtr conn);
+
 typedef int
-    (*virDrvConnectIsSecure)(virConnectPtr conn);
+(*virDrvConnectIsSecure)(virConnectPtr conn);
+
 typedef int
-    (*virDrvConnectIsAlive)(virConnectPtr conn);
+(*virDrvConnectIsAlive)(virConnectPtr conn);
+
 typedef int
-    (*virDrvDomainIsActive)(virDomainPtr dom);
+(*virDrvDomainIsActive)(virDomainPtr dom);
+
 typedef int
-    (*virDrvDomainIsPersistent)(virDomainPtr dom);
+(*virDrvDomainIsPersistent)(virDomainPtr dom);
+
 typedef int
-    (*virDrvDomainIsUpdated)(virDomainPtr dom);
+(*virDrvDomainIsUpdated)(virDomainPtr dom);
 
 typedef int
-    (*virDrvConnectCompareCPU)(virConnectPtr conn,
-                               const char *cpu,
-                               unsigned int flags);
+(*virDrvConnectCompareCPU)(virConnectPtr conn,
+                           const char *cpu,
+                           unsigned int flags);
+
 typedef char *
-    (*virDrvConnectBaselineCPU)(virConnectPtr conn,
-                                const char **xmlCPUs,
-                                unsigned int ncpus,
-                                unsigned int flags);
+(*virDrvConnectBaselineCPU)(virConnectPtr conn,
+                            const char **xmlCPUs,
+                            unsigned int ncpus,
+                            unsigned int flags);
 
 typedef int
-    (*virDrvDomainGetJobInfo)(virDomainPtr domain,
-                              virDomainJobInfoPtr info);
+(*virDrvDomainGetJobInfo)(virDomainPtr domain,
+                          virDomainJobInfoPtr info);
+
 typedef int
-    (*virDrvDomainGetJobStats)(virDomainPtr domain,
-                               int *type,
-                               virTypedParameterPtr *params,
-                               int *nparams,
-                               unsigned int flags);
+(*virDrvDomainGetJobStats)(virDomainPtr domain,
+                           int *type,
+                           virTypedParameterPtr *params,
+                           int *nparams,
+                           unsigned int flags);
 
 typedef int
-    (*virDrvDomainAbortJob)(virDomainPtr domain);
+(*virDrvDomainAbortJob)(virDomainPtr domain);
 
 typedef int
-    (*virDrvDomainMigrateSetMaxDowntime)(virDomainPtr domain,
-                                         unsigned long long downtime,
-                                         unsigned int flags);
+(*virDrvDomainMigrateSetMaxDowntime)(virDomainPtr domain,
+                                     unsigned long long downtime,
+                                     unsigned int flags);
+
 typedef int
-    (*virDrvDomainMigrateGetCompressionCache)(virDomainPtr domain,
-                                              unsigned long long *cacheSize,
-                                              unsigned int flags);
+(*virDrvDomainMigrateGetCompressionCache)(virDomainPtr domain,
+                                          unsigned long long *cacheSize,
+                                          unsigned int flags);
+
 typedef int
-    (*virDrvDomainMigrateSetCompressionCache)(virDomainPtr domain,
-                                              unsigned long long cacheSize,
-                                              unsigned int flags);
+(*virDrvDomainMigrateSetCompressionCache)(virDomainPtr domain,
+                                          unsigned long long cacheSize,
+                                          unsigned int flags);
 
 typedef int
-    (*virDrvDomainMigrateSetMaxSpeed)(virDomainPtr domain,
-                                      unsigned long bandwidth,
-                                      unsigned int flags);
+(*virDrvDomainMigrateSetMaxSpeed)(virDomainPtr domain,
+                                  unsigned long bandwidth,
+                                  unsigned int flags);
 
 typedef int
-    (*virDrvDomainMigrateGetMaxSpeed)(virDomainPtr domain,
-                                      unsigned long *bandwidth,
-                                      unsigned int flags);
+(*virDrvDomainMigrateGetMaxSpeed)(virDomainPtr domain,
+                                  unsigned long *bandwidth,
+                                  unsigned int flags);
 
 typedef int
-    (*virDrvConnectDomainEventRegisterAny)(virConnectPtr conn,
-                                           virDomainPtr dom,
-                                           int eventID,
-                                           virConnectDomainEventGenericCallback cb,
-                                           void *opaque,
-                                           virFreeCallback freecb);
+(*virDrvConnectDomainEventRegisterAny)(virConnectPtr conn,
+                                       virDomainPtr dom,
+                                       int eventID,
+                                       virConnectDomainEventGenericCallback cb,
+                                       void *opaque,
+                                       virFreeCallback freecb);
 
 typedef int
-    (*virDrvConnectDomainEventDeregisterAny)(virConnectPtr conn,
-                                             int callbackID);
+(*virDrvConnectDomainEventDeregisterAny)(virConnectPtr conn,
+                                         int callbackID);
 
 typedef int
-    (*virDrvDomainManagedSave)(virDomainPtr domain, unsigned int flags);
+(*virDrvDomainManagedSave)(virDomainPtr domain,
+                           unsigned int flags);
 
 typedef int
-    (*virDrvDomainHasManagedSaveImage)(virDomainPtr domain, unsigned int flags);
+(*virDrvDomainHasManagedSaveImage)(virDomainPtr domain,
+                                   unsigned int flags);
 
 typedef int
-    (*virDrvDomainManagedSaveRemove)(virDomainPtr domain, unsigned int flags);
+(*virDrvDomainManagedSaveRemove)(virDomainPtr domain,
+                                 unsigned int flags);
 
 typedef virDomainSnapshotPtr
-    (*virDrvDomainSnapshotCreateXML)(virDomainPtr domain,
-                                     const char *xmlDesc,
-                                     unsigned int flags);
+(*virDrvDomainSnapshotCreateXML)(virDomainPtr domain,
+                                 const char *xmlDesc,
+                                 unsigned int flags);
 
 typedef char *
-    (*virDrvDomainSnapshotGetXMLDesc)(virDomainSnapshotPtr snapshot,
-                                      unsigned int flags);
+(*virDrvDomainSnapshotGetXMLDesc)(virDomainSnapshotPtr snapshot,
+                                  unsigned int flags);
 
 typedef int
-    (*virDrvDomainSnapshotNum)(virDomainPtr domain, unsigned int flags);
+(*virDrvDomainSnapshotNum)(virDomainPtr domain,
+                           unsigned int flags);
 
 typedef int
-    (*virDrvDomainSnapshotListNames)(virDomainPtr domain, char **names,
-                                     int nameslen,
-                                     unsigned int flags);
+(*virDrvDomainSnapshotListNames)(virDomainPtr domain,
+                                 char **names,
+                                 int nameslen,
+                                 unsigned int flags);
 
 typedef int
-    (*virDrvDomainListAllSnapshots)(virDomainPtr domain,
-                                    virDomainSnapshotPtr **snaps,
-                                    unsigned int flags);
+(*virDrvDomainListAllSnapshots)(virDomainPtr domain,
+                                virDomainSnapshotPtr **snaps,
+                                unsigned int flags);
 
 typedef int
-    (*virDrvDomainSnapshotNumChildren)(virDomainSnapshotPtr snapshot,
-                                       unsigned int flags);
+(*virDrvDomainSnapshotNumChildren)(virDomainSnapshotPtr snapshot,
+                                   unsigned int flags);
 
 typedef int
-    (*virDrvDomainSnapshotListChildrenNames)(virDomainSnapshotPtr snapshot,
-                                             char **names,
-                                             int nameslen,
-                                             unsigned int flags);
+(*virDrvDomainSnapshotListChildrenNames)(virDomainSnapshotPtr snapshot,
+                                         char **names,
+                                         int nameslen,
+                                         unsigned int flags);
 
 typedef int
-    (*virDrvDomainSnapshotListAllChildren)(virDomainSnapshotPtr snapshot,
-                                           virDomainSnapshotPtr **snaps,
-                                           unsigned int flags);
+(*virDrvDomainSnapshotListAllChildren)(virDomainSnapshotPtr snapshot,
+                                       virDomainSnapshotPtr **snaps,
+                                       unsigned int flags);
 
 typedef virDomainSnapshotPtr
-    (*virDrvDomainSnapshotLookupByName)(virDomainPtr domain,
-                                        const char *name,
-                                        unsigned int flags);
+(*virDrvDomainSnapshotLookupByName)(virDomainPtr domain,
+                                    const char *name,
+                                    unsigned int flags);
 
 typedef int
-    (*virDrvDomainHasCurrentSnapshot)(virDomainPtr domain, unsigned int flags);
+(*virDrvDomainHasCurrentSnapshot)(virDomainPtr domain,
+                                  unsigned int flags);
 
 typedef virDomainSnapshotPtr
-    (*virDrvDomainSnapshotGetParent)(virDomainSnapshotPtr snapshot,
-                                     unsigned int flags);
+(*virDrvDomainSnapshotGetParent)(virDomainSnapshotPtr snapshot,
+                                 unsigned int flags);
 
 typedef virDomainSnapshotPtr
-    (*virDrvDomainSnapshotCurrent)(virDomainPtr domain,
-                                   unsigned int flags);
+(*virDrvDomainSnapshotCurrent)(virDomainPtr domain,
+                               unsigned int flags);
 
 typedef int
-    (*virDrvDomainSnapshotIsCurrent)(virDomainSnapshotPtr snapshot,
-                                     unsigned int flags);
+(*virDrvDomainSnapshotIsCurrent)(virDomainSnapshotPtr snapshot,
+                                 unsigned int flags);
 
 typedef int
-    (*virDrvDomainSnapshotHasMetadata)(virDomainSnapshotPtr snapshot,
-                                       unsigned int flags);
+(*virDrvDomainSnapshotHasMetadata)(virDomainSnapshotPtr snapshot,
+                                   unsigned int flags);
 
 typedef int
-    (*virDrvDomainRevertToSnapshot)(virDomainSnapshotPtr snapshot,
-                                    unsigned int flags);
+(*virDrvDomainRevertToSnapshot)(virDomainSnapshotPtr snapshot,
+                                unsigned int flags);
 
 typedef int
-    (*virDrvDomainSnapshotDelete)(virDomainSnapshotPtr snapshot,
-                                  unsigned int flags);
+(*virDrvDomainSnapshotDelete)(virDomainSnapshotPtr snapshot,
+                              unsigned int flags);
 
 typedef int
-    (*virDrvDomainQemuMonitorCommand)(virDomainPtr domain, const char *cmd,
-                                      char **result, unsigned int flags);
+(*virDrvDomainQemuMonitorCommand)(virDomainPtr domain,
+                                  const char *cmd,
+                                  char **result,
+                                  unsigned int flags);
+
 typedef char *
-    (*virDrvDomainQemuAgentCommand)(virDomainPtr domain, const char *cmd,
-                                    int timeout, unsigned int flags);
+(*virDrvDomainQemuAgentCommand)(virDomainPtr domain,
+                                const char *cmd,
+                                int timeout,
+                                unsigned int flags);
 
 /* Choice of unsigned int rather than pid_t is intentional.  */
 typedef virDomainPtr
-    (*virDrvDomainQemuAttach)(virConnectPtr conn,
-                              unsigned int pid_value,
-                              unsigned int flags);
+(*virDrvDomainQemuAttach)(virConnectPtr conn,
+                          unsigned int pid_value,
+                          unsigned int flags);
 
 typedef int
-    (*virDrvDomainOpenConsole)(virDomainPtr dom,
-                               const char *dev_name,
-                               virStreamPtr st,
-                               unsigned int flags);
+(*virDrvDomainOpenConsole)(virDomainPtr dom,
+                           const char *dev_name,
+                           virStreamPtr st,
+                           unsigned int flags);
+
 typedef int
-    (*virDrvDomainOpenChannel)(virDomainPtr dom,
-                               const char *name,
-                               virStreamPtr st,
-                               unsigned int flags);
+(*virDrvDomainOpenChannel)(virDomainPtr dom,
+                           const char *name,
+                           virStreamPtr st,
+                           unsigned int flags);
 
 typedef int
-    (*virDrvDomainOpenGraphics)(virDomainPtr dom,
-                                unsigned int idx,
-                                int fd,
-                                unsigned int flags);
+(*virDrvDomainOpenGraphics)(virDomainPtr dom,
+                            unsigned int idx,
+                            int fd,
+                            unsigned int flags);
 
 typedef int
-    (*virDrvDomainInjectNMI)(virDomainPtr dom, unsigned int flags);
+(*virDrvDomainInjectNMI)(virDomainPtr dom,
+                         unsigned int flags);
 
 typedef int
-    (*virDrvDomainSendKey)(virDomainPtr dom, unsigned int codeset,
-                           unsigned int holdtime,
-                           unsigned int *keycodes,
-                           int nkeycodes,
-                           unsigned int flags);
+(*virDrvDomainSendKey)(virDomainPtr dom,
+                       unsigned int codeset,
+                       unsigned int holdtime,
+                       unsigned int *keycodes,
+                       int nkeycodes,
+                       unsigned int flags);
 
 typedef int
-    (*virDrvDomainSendProcessSignal)(virDomainPtr dom,
-                                     long long pid_value,
-                                     unsigned int signum,
-                                     unsigned int flags);
+(*virDrvDomainSendProcessSignal)(virDomainPtr dom,
+                                 long long pid_value,
+                                 unsigned int signum,
+                                 unsigned int flags);
 
 typedef char *
-    (*virDrvDomainMigrateBegin3)
-                    (virDomainPtr domain,
-                     const char *xmlin,
-                     char **cookieout,
-                     int *cookieoutlen,
-                     unsigned long flags,
-                     const char *dname,
-                     unsigned long resource);
-
-typedef int
-    (*virDrvDomainMigratePrepare3)
-                    (virConnectPtr dconn,
-                     const char *cookiein,
-                     int cookieinlen,
-                     char **cookieout,
-                     int *cookieoutlen,
-                     const char *uri_in,
-                     char **uri_out,
-                     unsigned long flags,
-                     const char *dname,
-                     unsigned long resource,
-                     const char *dom_xml);
-
-typedef int
-    (*virDrvDomainMigratePrepareTunnel3)
-                    (virConnectPtr dconn,
-                     virStreamPtr st,
-                     const char *cookiein,
-                     int cookieinlen,
-                     char **cookieout,
-                     int *cookieoutlen,
-                     unsigned long flags,
-                     const char *dname,
-                     unsigned long resource,
-                     const char *dom_xml);
-
-
-typedef int
-    (*virDrvDomainMigratePerform3)
-                    (virDomainPtr dom,
-                     const char *xmlin,
-                     const char *cookiein,
-                     int cookieinlen,
-                     char **cookieout,
-                     int *cookieoutlen,
-                     const char *dconnuri,
-                     const char *uri,
-                     unsigned long flags,
-                     const char *dname,
-                     unsigned long resource);
+(*virDrvDomainMigrateBegin3)(virDomainPtr domain,
+                             const char *xmlin,
+                             char **cookieout,
+                             int *cookieoutlen,
+                             unsigned long flags,
+                             const char *dname,
+                             unsigned long resource);
+
+typedef int
+(*virDrvDomainMigratePrepare3)(virConnectPtr dconn,
+                               const char *cookiein,
+                               int cookieinlen,
+                               char **cookieout,
+                               int *cookieoutlen,
+                               const char *uri_in,
+                               char **uri_out,
+                               unsigned long flags,
+                               const char *dname,
+                               unsigned long resource,
+                               const char *dom_xml);
+
+typedef int
+(*virDrvDomainMigratePrepareTunnel3)(virConnectPtr dconn,
+                                     virStreamPtr st,
+                                     const char *cookiein,
+                                     int cookieinlen,
+                                     char **cookieout,
+                                     int *cookieoutlen,
+                                     unsigned long flags,
+                                     const char *dname,
+                                     unsigned long resource,
+                                     const char *dom_xml);
+
+
+typedef int
+(*virDrvDomainMigratePerform3)(virDomainPtr dom,
+                               const char *xmlin,
+                               const char *cookiein,
+                               int cookieinlen,
+                               char **cookieout,
+                               int *cookieoutlen,
+                               const char *dconnuri,
+                               const char *uri,
+                               unsigned long flags,
+                               const char *dname,
+                               unsigned long resource);
 
 typedef virDomainPtr
-    (*virDrvDomainMigrateFinish3)
-                    (virConnectPtr dconn,
-                     const char *dname,
-                     const char *cookiein,
-                     int cookieinlen,
-                     char **cookieout,
-                     int *cookieoutlen,
-                     const char *dconnuri,
-                     const char *uri,
-                     unsigned long flags,
-                     int cancelled);
-
-typedef int
-    (*virDrvDomainMigrateConfirm3)
-                    (virDomainPtr domain,
-                     const char *cookiein,
-                     int cookieinlen,
-                     unsigned long flags,
-                     int cancelled);
-
-typedef int
-    (*virDrvNodeSuspendForDuration)(virConnectPtr conn, unsigned int target,
-                                     unsigned long long duration,
-                                     unsigned int flags);
-
+(*virDrvDomainMigrateFinish3)(virConnectPtr dconn,
+                              const char *dname,
+                              const char *cookiein,
+                              int cookieinlen,
+                              char **cookieout,
+                              int *cookieoutlen,
+                              const char *dconnuri,
+                              const char *uri,
+                              unsigned long flags,
+                              int cancelled);
+
+typedef int
+(*virDrvDomainMigrateConfirm3)(virDomainPtr domain,
+                               const char *cookiein,
+                               int cookieinlen,
+                               unsigned long flags,
+                               int cancelled);
+
+typedef int
+(*virDrvNodeSuspendForDuration)(virConnectPtr conn,
+                                unsigned int target,
+                                unsigned long long duration,
+                                unsigned int flags);
 
 typedef int
-    (*virDrvDomainBlockJobAbort)(virDomainPtr dom, const char *path,
-                                 unsigned int flags);
+(*virDrvDomainBlockJobAbort)(virDomainPtr dom,
+                             const char *path,
+                             unsigned int flags);
 
 typedef int
-    (*virDrvDomainGetBlockJobInfo)(virDomainPtr dom, const char *path,
-                                   virDomainBlockJobInfoPtr info,
-                                   unsigned int flags);
+(*virDrvDomainGetBlockJobInfo)(virDomainPtr dom,
+                               const char *path,
+                               virDomainBlockJobInfoPtr info,
+                               unsigned int flags);
 
 typedef int
-    (*virDrvDomainBlockJobSetSpeed)(virDomainPtr dom,
-                                    const char *path, unsigned long bandwidth,
-                                    unsigned int flags);
+(*virDrvDomainBlockJobSetSpeed)(virDomainPtr dom,
+                                const char *path,
+                                unsigned long bandwidth,
+                                unsigned int flags);
 
 typedef int
-    (*virDrvDomainBlockPull)(virDomainPtr dom, const char *path,
-                             unsigned long bandwidth, unsigned int flags);
+(*virDrvDomainBlockPull)(virDomainPtr dom,
+                         const char *path,
+                         unsigned long bandwidth,
+                         unsigned int flags);
+
 typedef int
-    (*virDrvDomainBlockRebase)(virDomainPtr dom, const char *path,
-                               const char *base, unsigned long bandwidth,
-                               unsigned int flags);
+(*virDrvDomainBlockRebase)(virDomainPtr dom,
+                           const char *path,
+                           const char *base,
+                           unsigned long bandwidth,
+                           unsigned int flags);
+
 typedef int
-    (*virDrvDomainBlockCommit)(virDomainPtr dom, const char *disk,
-                               const char *base, const char *top,
-                               unsigned long bandwidth, unsigned int flags);
+(*virDrvDomainBlockCommit)(virDomainPtr dom,
+                           const char *disk,
+                           const char *base,
+                           const char *top,
+                           unsigned long bandwidth,
+                           unsigned int flags);
 
 typedef int
-    (*virDrvConnectSetKeepAlive)(virConnectPtr conn,
-                                 int interval,
-                                 unsigned int count);
+(*virDrvConnectSetKeepAlive)(virConnectPtr conn,
+                             int interval,
+                             unsigned int count);
 
 typedef int
-    (*virDrvDomainSetBlockIoTune)(virDomainPtr dom,
-                                  const char *disk,
-                                  virTypedParameterPtr params,
-                                  int nparams,
-                                  unsigned int flags);
+(*virDrvDomainSetBlockIoTune)(virDomainPtr dom,
+                              const char *disk,
+                              virTypedParameterPtr params,
+                              int nparams,
+                              unsigned int flags);
+
 typedef int
-    (*virDrvDomainGetBlockIoTune)(virDomainPtr dom,
-                                  const char *disk,
-                                  virTypedParameterPtr params,
-                                  int *nparams,
-                                  unsigned int flags);
+(*virDrvDomainGetBlockIoTune)(virDomainPtr dom,
+                              const char *disk,
+                              virTypedParameterPtr params,
+                              int *nparams,
+                              unsigned int flags);
+
 typedef int
-    (*virDrvDomainShutdownFlags)(virDomainPtr domain,
-                                 unsigned int flags);
+(*virDrvDomainShutdownFlags)(virDomainPtr domain,
+                             unsigned int flags);
 
 typedef int
-    (*virDrvDomainGetCPUStats)(virDomainPtr domain,
-                               virTypedParameterPtr params,
-                               unsigned int nparams,
-                               int start_cpu,
-                               unsigned int ncpus,
-                               unsigned int flags);
+(*virDrvDomainGetCPUStats)(virDomainPtr domain,
+                           virTypedParameterPtr params,
+                           unsigned int nparams,
+                           int start_cpu,
+                           unsigned int ncpus,
+                           unsigned int flags);
 
 typedef int
-    (*virDrvDomainGetDiskErrors)(virDomainPtr dom,
-                                 virDomainDiskErrorPtr errors,
-                                 unsigned int maxerrors,
-                                 unsigned int flags);
+(*virDrvDomainGetDiskErrors)(virDomainPtr dom,
+                             virDomainDiskErrorPtr errors,
+                             unsigned int maxerrors,
+                             unsigned int flags);
 
 typedef int
-    (*virDrvDomainSetMetadata)(virDomainPtr dom,
-                               int type,
-                               const char *metadata,
-                               const char *key,
-                               const char *uri,
-                               unsigned int flags);
+(*virDrvDomainSetMetadata)(virDomainPtr dom,
+                           int type,
+                           const char *metadata,
+                           const char *key,
+                           const char *uri,
+                           unsigned int flags);
 
 typedef char *
-    (*virDrvDomainGetMetadata)(virDomainPtr dom,
-                               int type,
-                               const char *uri,
-                               unsigned int flags);
+(*virDrvDomainGetMetadata)(virDomainPtr dom,
+                           int type,
+                           const char *uri,
+                           unsigned int flags);
 
 typedef int
-    (*virDrvNodeGetMemoryParameters)(virConnectPtr conn,
-                                     virTypedParameterPtr params,
-                                     int *nparams,
-                                     unsigned int flags);
+(*virDrvNodeGetMemoryParameters)(virConnectPtr conn,
+                                 virTypedParameterPtr params,
+                                 int *nparams,
+                                 unsigned int flags);
 
 typedef int
-    (*virDrvNodeSetMemoryParameters)(virConnectPtr conn,
-                                     virTypedParameterPtr params,
-                                     int nparams,
-                                     unsigned int flags);
+(*virDrvNodeSetMemoryParameters)(virConnectPtr conn,
+                                 virTypedParameterPtr params,
+                                 int nparams,
+                                 unsigned int flags);
 
 typedef int
-    (*virDrvNodeGetCPUMap)(virConnectPtr conn,
-                           unsigned char **cpumap,
-                           unsigned int *online,
-                           unsigned int flags);
+(*virDrvNodeGetCPUMap)(virConnectPtr conn,
+                       unsigned char **cpumap,
+                       unsigned int *online,
+                       unsigned int flags);
+
 typedef int
-    (*virDrvDomainFSTrim)(virDomainPtr dom,
-                          const char *mountPoint,
-                          unsigned long long minimum,
-                          unsigned int flags);
+(*virDrvDomainFSTrim)(virDomainPtr dom,
+                      const char *mountPoint,
+                      unsigned long long minimum,
+                      unsigned int flags);
 
 typedef int
-    (*virDrvDomainLxcOpenNamespace)(virDomainPtr dom,
-                                    int **fdlist,
-                                    unsigned int flags);
+(*virDrvDomainLxcOpenNamespace)(virDomainPtr dom,
+                                int **fdlist,
+                                unsigned int flags);
+
+typedef struct _virDriver virDriver;
+typedef virDriver *virDriverPtr;
 
 /**
  * _virDriver:
@@ -954,249 +1042,266 @@ typedef int
  *  - close
  */
 struct _virDriver {
-    int                                 no;    /* the number virDrvNo */
-    const char                          *name; /* the name of the driver */
-    virDrvConnectOpen                         connectOpen;
-    virDrvConnectClose                        connectClose;
-    virDrvConnectSupportsFeature            connectSupportsFeature;
-    virDrvConnectGetType                       connectGetType;
-    virDrvConnectGetVersion                    connectGetVersion;
-    virDrvConnectGetLibVersion                 connectGetLibVersion;
-    virDrvConnectGetHostname                   connectGetHostname;
-    virDrvConnectGetSysinfo                    connectGetSysinfo;
-    virDrvConnectGetMaxVcpus                   connectGetMaxVcpus;
-    virDrvNodeGetInfo                   nodeGetInfo;
-    virDrvConnectGetCapabilities               connectGetCapabilities;
-    virDrvConnectListDomains                   connectListDomains;
-    virDrvConnectNumOfDomains                  connectNumOfDomains;
-    virDrvConnectListAllDomains                connectListAllDomains;
-    virDrvDomainCreateXML               domainCreateXML;
-    virDrvDomainLookupByID              domainLookupByID;
-    virDrvDomainLookupByUUID            domainLookupByUUID;
-    virDrvDomainLookupByName            domainLookupByName;
-    virDrvDomainSuspend                 domainSuspend;
-    virDrvDomainResume                  domainResume;
-    virDrvDomainPMSuspendForDuration    domainPMSuspendForDuration;
-    virDrvDomainPMWakeup                domainPMWakeup;
-    virDrvDomainShutdown                domainShutdown;
-    virDrvDomainShutdownFlags           domainShutdownFlags;
-    virDrvDomainReboot                  domainReboot;
-    virDrvDomainReset                   domainReset;
-    virDrvDomainDestroy                 domainDestroy;
-    virDrvDomainDestroyFlags            domainDestroyFlags;
-    virDrvDomainGetOSType               domainGetOSType;
-    virDrvDomainGetHostname             domainGetHostname;
-    virDrvDomainGetMaxMemory            domainGetMaxMemory;
-    virDrvDomainSetMaxMemory            domainSetMaxMemory;
-    virDrvDomainSetMemory               domainSetMemory;
-    virDrvDomainSetMemoryFlags          domainSetMemoryFlags;
-    virDrvDomainSetMemoryParameters     domainSetMemoryParameters;
-    virDrvDomainGetMemoryParameters     domainGetMemoryParameters;
-    virDrvDomainSetNumaParameters       domainSetNumaParameters;
-    virDrvDomainGetNumaParameters       domainGetNumaParameters;
-    virDrvDomainSetBlkioParameters      domainSetBlkioParameters;
-    virDrvDomainGetBlkioParameters      domainGetBlkioParameters;
-    virDrvDomainGetInfo                 domainGetInfo;
-    virDrvDomainGetState                domainGetState;
-    virDrvDomainGetControlInfo          domainGetControlInfo;
-    virDrvDomainSave                    domainSave;
-    virDrvDomainSaveFlags               domainSaveFlags;
-    virDrvDomainRestore                 domainRestore;
-    virDrvDomainRestoreFlags            domainRestoreFlags;
-    virDrvDomainSaveImageGetXMLDesc     domainSaveImageGetXMLDesc;
-    virDrvDomainSaveImageDefineXML      domainSaveImageDefineXML;
-    virDrvDomainCoreDump                domainCoreDump;
-    virDrvDomainScreenshot              domainScreenshot;
-    virDrvDomainSetVcpus                domainSetVcpus;
-    virDrvDomainSetVcpusFlags           domainSetVcpusFlags;
-    virDrvDomainGetVcpusFlags           domainGetVcpusFlags;
-    virDrvDomainPinVcpu                 domainPinVcpu;
-    virDrvDomainPinVcpuFlags            domainPinVcpuFlags;
-    virDrvDomainGetVcpuPinInfo          domainGetVcpuPinInfo;
-    virDrvDomainPinEmulator             domainPinEmulator;
-    virDrvDomainGetEmulatorPinInfo      domainGetEmulatorPinInfo;
-    virDrvDomainGetVcpus                domainGetVcpus;
-    virDrvDomainGetMaxVcpus             domainGetMaxVcpus;
-    virDrvDomainGetSecurityLabel        domainGetSecurityLabel;
-    virDrvDomainGetSecurityLabelList     domainGetSecurityLabelList;
-    virDrvNodeGetSecurityModel          nodeGetSecurityModel;
-    virDrvDomainGetXMLDesc              domainGetXMLDesc;
-    virDrvConnectDomainXMLFromNative    connectDomainXMLFromNative;
-    virDrvConnectDomainXMLToNative      connectDomainXMLToNative;
-    virDrvConnectListDefinedDomains            connectListDefinedDomains;
-    virDrvConnectNumOfDefinedDomains           connectNumOfDefinedDomains;
-    virDrvDomainCreate                  domainCreate;
-    virDrvDomainCreateWithFlags         domainCreateWithFlags;
-    virDrvDomainDefineXML               domainDefineXML;
-    virDrvDomainUndefine                domainUndefine;
-    virDrvDomainUndefineFlags           domainUndefineFlags;
-    virDrvDomainAttachDevice            domainAttachDevice;
-    virDrvDomainAttachDeviceFlags       domainAttachDeviceFlags;
-    virDrvDomainDetachDevice            domainDetachDevice;
-    virDrvDomainDetachDeviceFlags       domainDetachDeviceFlags;
-    virDrvDomainUpdateDeviceFlags       domainUpdateDeviceFlags;
-    virDrvDomainGetAutostart            domainGetAutostart;
-    virDrvDomainSetAutostart            domainSetAutostart;
-    virDrvDomainGetSchedulerType        domainGetSchedulerType;
-    virDrvDomainGetSchedulerParameters      domainGetSchedulerParameters;
+    int no; /* the number virDrvNo */
+    const char *name; /* the name of the driver */
+    virDrvConnectOpen connectOpen;
+    virDrvConnectClose connectClose;
+    virDrvConnectSupportsFeature connectSupportsFeature;
+    virDrvConnectGetType connectGetType;
+    virDrvConnectGetVersion connectGetVersion;
+    virDrvConnectGetLibVersion connectGetLibVersion;
+    virDrvConnectGetHostname connectGetHostname;
+    virDrvConnectGetSysinfo connectGetSysinfo;
+    virDrvConnectGetMaxVcpus connectGetMaxVcpus;
+    virDrvNodeGetInfo nodeGetInfo;
+    virDrvConnectGetCapabilities connectGetCapabilities;
+    virDrvConnectListDomains connectListDomains;
+    virDrvConnectNumOfDomains connectNumOfDomains;
+    virDrvConnectListAllDomains connectListAllDomains;
+    virDrvDomainCreateXML domainCreateXML;
+    virDrvDomainLookupByID domainLookupByID;
+    virDrvDomainLookupByUUID domainLookupByUUID;
+    virDrvDomainLookupByName domainLookupByName;
+    virDrvDomainSuspend domainSuspend;
+    virDrvDomainResume domainResume;
+    virDrvDomainPMSuspendForDuration domainPMSuspendForDuration;
+    virDrvDomainPMWakeup domainPMWakeup;
+    virDrvDomainShutdown domainShutdown;
+    virDrvDomainShutdownFlags domainShutdownFlags;
+    virDrvDomainReboot domainReboot;
+    virDrvDomainReset domainReset;
+    virDrvDomainDestroy domainDestroy;
+    virDrvDomainDestroyFlags domainDestroyFlags;
+    virDrvDomainGetOSType domainGetOSType;
+    virDrvDomainGetHostname domainGetHostname;
+    virDrvDomainGetMaxMemory domainGetMaxMemory;
+    virDrvDomainSetMaxMemory domainSetMaxMemory;
+    virDrvDomainSetMemory domainSetMemory;
+    virDrvDomainSetMemoryFlags domainSetMemoryFlags;
+    virDrvDomainSetMemoryParameters domainSetMemoryParameters;
+    virDrvDomainGetMemoryParameters domainGetMemoryParameters;
+    virDrvDomainSetNumaParameters domainSetNumaParameters;
+    virDrvDomainGetNumaParameters domainGetNumaParameters;
+    virDrvDomainSetBlkioParameters domainSetBlkioParameters;
+    virDrvDomainGetBlkioParameters domainGetBlkioParameters;
+    virDrvDomainGetInfo domainGetInfo;
+    virDrvDomainGetState domainGetState;
+    virDrvDomainGetControlInfo domainGetControlInfo;
+    virDrvDomainSave domainSave;
+    virDrvDomainSaveFlags domainSaveFlags;
+    virDrvDomainRestore domainRestore;
+    virDrvDomainRestoreFlags domainRestoreFlags;
+    virDrvDomainSaveImageGetXMLDesc domainSaveImageGetXMLDesc;
+    virDrvDomainSaveImageDefineXML domainSaveImageDefineXML;
+    virDrvDomainCoreDump domainCoreDump;
+    virDrvDomainScreenshot domainScreenshot;
+    virDrvDomainSetVcpus domainSetVcpus;
+    virDrvDomainSetVcpusFlags domainSetVcpusFlags;
+    virDrvDomainGetVcpusFlags domainGetVcpusFlags;
+    virDrvDomainPinVcpu domainPinVcpu;
+    virDrvDomainPinVcpuFlags domainPinVcpuFlags;
+    virDrvDomainGetVcpuPinInfo domainGetVcpuPinInfo;
+    virDrvDomainPinEmulator domainPinEmulator;
+    virDrvDomainGetEmulatorPinInfo domainGetEmulatorPinInfo;
+    virDrvDomainGetVcpus domainGetVcpus;
+    virDrvDomainGetMaxVcpus domainGetMaxVcpus;
+    virDrvDomainGetSecurityLabel domainGetSecurityLabel;
+    virDrvDomainGetSecurityLabelList domainGetSecurityLabelList;
+    virDrvNodeGetSecurityModel nodeGetSecurityModel;
+    virDrvDomainGetXMLDesc domainGetXMLDesc;
+    virDrvConnectDomainXMLFromNative connectDomainXMLFromNative;
+    virDrvConnectDomainXMLToNative connectDomainXMLToNative;
+    virDrvConnectListDefinedDomains connectListDefinedDomains;
+    virDrvConnectNumOfDefinedDomains connectNumOfDefinedDomains;
+    virDrvDomainCreate domainCreate;
+    virDrvDomainCreateWithFlags domainCreateWithFlags;
+    virDrvDomainDefineXML domainDefineXML;
+    virDrvDomainUndefine domainUndefine;
+    virDrvDomainUndefineFlags domainUndefineFlags;
+    virDrvDomainAttachDevice domainAttachDevice;
+    virDrvDomainAttachDeviceFlags domainAttachDeviceFlags;
+    virDrvDomainDetachDevice domainDetachDevice;
+    virDrvDomainDetachDeviceFlags domainDetachDeviceFlags;
+    virDrvDomainUpdateDeviceFlags domainUpdateDeviceFlags;
+    virDrvDomainGetAutostart domainGetAutostart;
+    virDrvDomainSetAutostart domainSetAutostart;
+    virDrvDomainGetSchedulerType domainGetSchedulerType;
+    virDrvDomainGetSchedulerParameters domainGetSchedulerParameters;
     virDrvDomainGetSchedulerParametersFlags domainGetSchedulerParametersFlags;
-    virDrvDomainSetSchedulerParameters      domainSetSchedulerParameters;
+    virDrvDomainSetSchedulerParameters domainSetSchedulerParameters;
     virDrvDomainSetSchedulerParametersFlags domainSetSchedulerParametersFlags;
-    virDrvDomainMigratePrepare          domainMigratePrepare;
-    virDrvDomainMigratePerform          domainMigratePerform;
-    virDrvDomainMigrateFinish           domainMigrateFinish;
-    virDrvDomainBlockResize             domainBlockResize;
-    virDrvDomainBlockStats              domainBlockStats;
-    virDrvDomainBlockStatsFlags         domainBlockStatsFlags;
-    virDrvDomainInterfaceStats          domainInterfaceStats;
-    virDrvDomainSetInterfaceParameters  domainSetInterfaceParameters;
-    virDrvDomainGetInterfaceParameters  domainGetInterfaceParameters;
-    virDrvDomainMemoryStats             domainMemoryStats;
-    virDrvDomainBlockPeek               domainBlockPeek;
-    virDrvDomainMemoryPeek              domainMemoryPeek;
-    virDrvDomainGetBlockInfo            domainGetBlockInfo;
-    virDrvNodeGetCPUStats               nodeGetCPUStats;
-    virDrvNodeGetMemoryStats            nodeGetMemoryStats;
-    virDrvNodeGetCellsFreeMemory        nodeGetCellsFreeMemory;
-    virDrvNodeGetFreeMemory             nodeGetFreeMemory;
-    virDrvConnectDomainEventRegister           connectDomainEventRegister;
-    virDrvConnectDomainEventDeregister         connectDomainEventDeregister;
-    virDrvDomainMigratePrepare2         domainMigratePrepare2;
-    virDrvDomainMigrateFinish2          domainMigrateFinish2;
-    virDrvNodeDeviceDettach             nodeDeviceDettach;
-    virDrvNodeDeviceReAttach            nodeDeviceReAttach;
-    virDrvNodeDeviceReset               nodeDeviceReset;
-    virDrvDomainMigratePrepareTunnel    domainMigratePrepareTunnel;
-    virDrvConnectIsEncrypted            connectIsEncrypted;
-    virDrvConnectIsSecure               connectIsSecure;
-    virDrvDomainIsActive                domainIsActive;
-    virDrvDomainIsPersistent            domainIsPersistent;
-    virDrvDomainIsUpdated               domainIsUpdated;
-    virDrvConnectCompareCPU                    connectCompareCPU;
-    virDrvConnectBaselineCPU                   connectBaselineCPU;
-    virDrvDomainGetJobInfo              domainGetJobInfo;
-    virDrvDomainGetJobStats             domainGetJobStats;
-    virDrvDomainAbortJob                domainAbortJob;
-    virDrvDomainMigrateSetMaxDowntime   domainMigrateSetMaxDowntime;
+    virDrvDomainMigratePrepare domainMigratePrepare;
+    virDrvDomainMigratePerform domainMigratePerform;
+    virDrvDomainMigrateFinish domainMigrateFinish;
+    virDrvDomainBlockResize domainBlockResize;
+    virDrvDomainBlockStats domainBlockStats;
+    virDrvDomainBlockStatsFlags domainBlockStatsFlags;
+    virDrvDomainInterfaceStats domainInterfaceStats;
+    virDrvDomainSetInterfaceParameters domainSetInterfaceParameters;
+    virDrvDomainGetInterfaceParameters domainGetInterfaceParameters;
+    virDrvDomainMemoryStats domainMemoryStats;
+    virDrvDomainBlockPeek domainBlockPeek;
+    virDrvDomainMemoryPeek domainMemoryPeek;
+    virDrvDomainGetBlockInfo domainGetBlockInfo;
+    virDrvNodeGetCPUStats nodeGetCPUStats;
+    virDrvNodeGetMemoryStats nodeGetMemoryStats;
+    virDrvNodeGetCellsFreeMemory nodeGetCellsFreeMemory;
+    virDrvNodeGetFreeMemory nodeGetFreeMemory;
+    virDrvConnectDomainEventRegister connectDomainEventRegister;
+    virDrvConnectDomainEventDeregister connectDomainEventDeregister;
+    virDrvDomainMigratePrepare2 domainMigratePrepare2;
+    virDrvDomainMigrateFinish2 domainMigrateFinish2;
+    virDrvNodeDeviceDettach nodeDeviceDettach;
+    virDrvNodeDeviceReAttach nodeDeviceReAttach;
+    virDrvNodeDeviceReset nodeDeviceReset;
+    virDrvDomainMigratePrepareTunnel domainMigratePrepareTunnel;
+    virDrvConnectIsEncrypted connectIsEncrypted;
+    virDrvConnectIsSecure connectIsSecure;
+    virDrvDomainIsActive domainIsActive;
+    virDrvDomainIsPersistent domainIsPersistent;
+    virDrvDomainIsUpdated domainIsUpdated;
+    virDrvConnectCompareCPU connectCompareCPU;
+    virDrvConnectBaselineCPU connectBaselineCPU;
+    virDrvDomainGetJobInfo domainGetJobInfo;
+    virDrvDomainGetJobStats domainGetJobStats;
+    virDrvDomainAbortJob domainAbortJob;
+    virDrvDomainMigrateSetMaxDowntime domainMigrateSetMaxDowntime;
     virDrvDomainMigrateGetCompressionCache domainMigrateGetCompressionCache;
     virDrvDomainMigrateSetCompressionCache domainMigrateSetCompressionCache;
-    virDrvDomainMigrateGetMaxSpeed      domainMigrateGetMaxSpeed;
-    virDrvDomainMigrateSetMaxSpeed      domainMigrateSetMaxSpeed;
-    virDrvConnectDomainEventRegisterAny        connectDomainEventRegisterAny;
-    virDrvConnectDomainEventDeregisterAny      connectDomainEventDeregisterAny;
-    virDrvDomainManagedSave             domainManagedSave;
-    virDrvDomainHasManagedSaveImage     domainHasManagedSaveImage;
-    virDrvDomainManagedSaveRemove       domainManagedSaveRemove;
-    virDrvDomainSnapshotCreateXML       domainSnapshotCreateXML;
-    virDrvDomainSnapshotGetXMLDesc      domainSnapshotGetXMLDesc;
-    virDrvDomainSnapshotNum             domainSnapshotNum;
-    virDrvDomainSnapshotListNames       domainSnapshotListNames;
-    virDrvDomainListAllSnapshots        domainListAllSnapshots;
-    virDrvDomainSnapshotNumChildren     domainSnapshotNumChildren;
+    virDrvDomainMigrateGetMaxSpeed domainMigrateGetMaxSpeed;
+    virDrvDomainMigrateSetMaxSpeed domainMigrateSetMaxSpeed;
+    virDrvConnectDomainEventRegisterAny connectDomainEventRegisterAny;
+    virDrvConnectDomainEventDeregisterAny connectDomainEventDeregisterAny;
+    virDrvDomainManagedSave domainManagedSave;
+    virDrvDomainHasManagedSaveImage domainHasManagedSaveImage;
+    virDrvDomainManagedSaveRemove domainManagedSaveRemove;
+    virDrvDomainSnapshotCreateXML domainSnapshotCreateXML;
+    virDrvDomainSnapshotGetXMLDesc domainSnapshotGetXMLDesc;
+    virDrvDomainSnapshotNum domainSnapshotNum;
+    virDrvDomainSnapshotListNames domainSnapshotListNames;
+    virDrvDomainListAllSnapshots domainListAllSnapshots;
+    virDrvDomainSnapshotNumChildren domainSnapshotNumChildren;
     virDrvDomainSnapshotListChildrenNames domainSnapshotListChildrenNames;
     virDrvDomainSnapshotListAllChildren domainSnapshotListAllChildren;
-    virDrvDomainSnapshotLookupByName    domainSnapshotLookupByName;
-    virDrvDomainHasCurrentSnapshot      domainHasCurrentSnapshot;
-    virDrvDomainSnapshotGetParent       domainSnapshotGetParent;
-    virDrvDomainSnapshotCurrent         domainSnapshotCurrent;
-    virDrvDomainSnapshotIsCurrent       domainSnapshotIsCurrent;
-    virDrvDomainSnapshotHasMetadata     domainSnapshotHasMetadata;
-    virDrvDomainRevertToSnapshot        domainRevertToSnapshot;
-    virDrvDomainSnapshotDelete          domainSnapshotDelete;
-    virDrvDomainQemuMonitorCommand      domainQemuMonitorCommand;
-    virDrvDomainQemuAttach              domainQemuAttach;
-    virDrvDomainQemuAgentCommand        domainQemuAgentCommand;
-    virDrvDomainOpenConsole             domainOpenConsole;
-    virDrvDomainOpenChannel             domainOpenChannel;
-    virDrvDomainOpenGraphics            domainOpenGraphics;
-    virDrvDomainInjectNMI               domainInjectNMI;
-    virDrvDomainMigrateBegin3           domainMigrateBegin3;
-    virDrvDomainMigratePrepare3         domainMigratePrepare3;
-    virDrvDomainMigratePrepareTunnel3   domainMigratePrepareTunnel3;
-    virDrvDomainMigratePerform3         domainMigratePerform3;
-    virDrvDomainMigrateFinish3          domainMigrateFinish3;
-    virDrvDomainMigrateConfirm3         domainMigrateConfirm3;
-    virDrvDomainSendKey                 domainSendKey;
-    virDrvDomainBlockJobAbort           domainBlockJobAbort;
-    virDrvDomainGetBlockJobInfo         domainGetBlockJobInfo;
-    virDrvDomainBlockJobSetSpeed        domainBlockJobSetSpeed;
-    virDrvDomainBlockPull               domainBlockPull;
-    virDrvDomainBlockRebase             domainBlockRebase;
-    virDrvDomainBlockCommit             domainBlockCommit;
-    virDrvConnectSetKeepAlive                  connectSetKeepAlive;
-    virDrvConnectIsAlive                connectIsAlive;
-    virDrvNodeSuspendForDuration        nodeSuspendForDuration;
-    virDrvDomainSetBlockIoTune          domainSetBlockIoTune;
-    virDrvDomainGetBlockIoTune          domainGetBlockIoTune;
-    virDrvDomainGetCPUStats             domainGetCPUStats;
-    virDrvDomainGetDiskErrors           domainGetDiskErrors;
-    virDrvDomainSetMetadata             domainSetMetadata;
-    virDrvDomainGetMetadata             domainGetMetadata;
-    virDrvNodeGetMemoryParameters       nodeGetMemoryParameters;
-    virDrvNodeSetMemoryParameters       nodeSetMemoryParameters;
-    virDrvNodeGetCPUMap                 nodeGetCPUMap;
-    virDrvDomainFSTrim                  domainFSTrim;
-    virDrvDomainSendProcessSignal       domainSendProcessSignal;
-    virDrvDomainLxcOpenNamespace        domainLxcOpenNamespace;
+    virDrvDomainSnapshotLookupByName domainSnapshotLookupByName;
+    virDrvDomainHasCurrentSnapshot domainHasCurrentSnapshot;
+    virDrvDomainSnapshotGetParent domainSnapshotGetParent;
+    virDrvDomainSnapshotCurrent domainSnapshotCurrent;
+    virDrvDomainSnapshotIsCurrent domainSnapshotIsCurrent;
+    virDrvDomainSnapshotHasMetadata domainSnapshotHasMetadata;
+    virDrvDomainRevertToSnapshot domainRevertToSnapshot;
+    virDrvDomainSnapshotDelete domainSnapshotDelete;
+    virDrvDomainQemuMonitorCommand domainQemuMonitorCommand;
+    virDrvDomainQemuAttach domainQemuAttach;
+    virDrvDomainQemuAgentCommand domainQemuAgentCommand;
+    virDrvDomainOpenConsole domainOpenConsole;
+    virDrvDomainOpenChannel domainOpenChannel;
+    virDrvDomainOpenGraphics domainOpenGraphics;
+    virDrvDomainInjectNMI domainInjectNMI;
+    virDrvDomainMigrateBegin3 domainMigrateBegin3;
+    virDrvDomainMigratePrepare3 domainMigratePrepare3;
+    virDrvDomainMigratePrepareTunnel3 domainMigratePrepareTunnel3;
+    virDrvDomainMigratePerform3 domainMigratePerform3;
+    virDrvDomainMigrateFinish3 domainMigrateFinish3;
+    virDrvDomainMigrateConfirm3 domainMigrateConfirm3;
+    virDrvDomainSendKey domainSendKey;
+    virDrvDomainBlockJobAbort domainBlockJobAbort;
+    virDrvDomainGetBlockJobInfo domainGetBlockJobInfo;
+    virDrvDomainBlockJobSetSpeed domainBlockJobSetSpeed;
+    virDrvDomainBlockPull domainBlockPull;
+    virDrvDomainBlockRebase domainBlockRebase;
+    virDrvDomainBlockCommit domainBlockCommit;
+    virDrvConnectSetKeepAlive connectSetKeepAlive;
+    virDrvConnectIsAlive connectIsAlive;
+    virDrvNodeSuspendForDuration nodeSuspendForDuration;
+    virDrvDomainSetBlockIoTune domainSetBlockIoTune;
+    virDrvDomainGetBlockIoTune domainGetBlockIoTune;
+    virDrvDomainGetCPUStats domainGetCPUStats;
+    virDrvDomainGetDiskErrors domainGetDiskErrors;
+    virDrvDomainSetMetadata domainSetMetadata;
+    virDrvDomainGetMetadata domainGetMetadata;
+    virDrvNodeGetMemoryParameters nodeGetMemoryParameters;
+    virDrvNodeSetMemoryParameters nodeSetMemoryParameters;
+    virDrvNodeGetCPUMap nodeGetCPUMap;
+    virDrvDomainFSTrim domainFSTrim;
+    virDrvDomainSendProcessSignal domainSendProcessSignal;
+    virDrvDomainLxcOpenNamespace domainLxcOpenNamespace;
 };
 
 typedef int
-        (*virDrvConnectNumOfNetworks)          (virConnectPtr conn);
+(*virDrvConnectNumOfNetworks)(virConnectPtr conn);
+
 typedef int
-        (*virDrvConnectListNetworks)           (virConnectPtr conn,
-                                                char **const names,
-                                                int maxnames);
+(*virDrvConnectListNetworks)(virConnectPtr conn,
+                             char **const names,
+                             int maxnames);
+
 typedef int
-        (*virDrvConnectNumOfDefinedNetworks)   (virConnectPtr conn);
+(*virDrvConnectNumOfDefinedNetworks)(virConnectPtr conn);
+
 typedef int
-        (*virDrvConnectListDefinedNetworks)    (virConnectPtr conn,
-                                                char **const names,
-                                                int maxnames);
+(*virDrvConnectListDefinedNetworks)(virConnectPtr conn,
+                                    char **const names,
+                                    int maxnames);
+
 typedef int
-        (*virDrvConnectListAllNetworks)        (virConnectPtr conn,
-                                                virNetworkPtr **nets,
-                                                unsigned int flags);
+(*virDrvConnectListAllNetworks)(virConnectPtr conn,
+                                virNetworkPtr **nets,
+                                unsigned int flags);
+
 typedef virNetworkPtr
-        (*virDrvNetworkLookupByUUID)    (virConnectPtr conn,
-                                         const unsigned char *uuid);
+(*virDrvNetworkLookupByUUID)(virConnectPtr conn,
+                             const unsigned char *uuid);
+
 typedef virNetworkPtr
-        (*virDrvNetworkLookupByName)    (virConnectPtr conn,
-                                         const char *name);
+(*virDrvNetworkLookupByName)(virConnectPtr conn,
+                             const char *name);
+
 typedef virNetworkPtr
-        (*virDrvNetworkCreateXML)       (virConnectPtr conn,
-                                         const char *xmlDesc);
+(*virDrvNetworkCreateXML)(virConnectPtr conn,
+                          const char *xmlDesc);
+
 typedef virNetworkPtr
-        (*virDrvNetworkDefineXML)       (virConnectPtr conn,
-                                         const char *xml);
+(*virDrvNetworkDefineXML)(virConnectPtr conn,
+                          const char *xml);
+
 typedef int
-        (*virDrvNetworkUndefine)        (virNetworkPtr network);
+(*virDrvNetworkUndefine)(virNetworkPtr network);
+
 typedef int
-        (*virDrvNetworkUpdate)          (virNetworkPtr network,
-                                         unsigned int command, /* virNetworkUpdateCommand */
-                                         unsigned int section, /* virNetworkUpdateSection */
-                                         int parentIndex,
-                                         const char *xml,
-                                         unsigned int flags);
+(*virDrvNetworkUpdate)(virNetworkPtr network,
+                       unsigned int command, /* virNetworkUpdateCommand */
+                       unsigned int section, /* virNetworkUpdateSection */
+                       int parentIndex,
+                       const char *xml,
+                       unsigned int flags);
+
 typedef int
-        (*virDrvNetworkCreate)          (virNetworkPtr network);
+(*virDrvNetworkCreate)(virNetworkPtr network);
+
 typedef int
-        (*virDrvNetworkDestroy)         (virNetworkPtr network);
+(*virDrvNetworkDestroy)(virNetworkPtr network);
+
 typedef char *
-        (*virDrvNetworkGetXMLDesc)      (virNetworkPtr network,
-                                         unsigned int flags);
+(*virDrvNetworkGetXMLDesc)(virNetworkPtr network,
+                           unsigned int flags);
+
 typedef char *
-        (*virDrvNetworkGetBridgeName)   (virNetworkPtr network);
+(*virDrvNetworkGetBridgeName)(virNetworkPtr network);
+
 typedef int
-        (*virDrvNetworkGetAutostart)    (virNetworkPtr network,
-                                         int *autostart);
+(*virDrvNetworkGetAutostart)(virNetworkPtr network,
+                             int *autostart);
+
 typedef int
-        (*virDrvNetworkSetAutostart)    (virNetworkPtr network,
-                                         int autostart);
+(*virDrvNetworkSetAutostart)(virNetworkPtr network,
+                             int autostart);
 
 typedef int
-        (*virDrvNetworkIsActive)        (virNetworkPtr net);
+(*virDrvNetworkIsActive)(virNetworkPtr net);
+
 typedef int
-        (*virDrvNetworkIsPersistent)    (virNetworkPtr net);
+(*virDrvNetworkIsPersistent)(virNetworkPtr net);
 
 
 
@@ -1214,83 +1319,94 @@ typedef virNetworkDriver *virNetworkDriverPtr;
  *  - close
  */
 struct _virNetworkDriver {
-        const char * name;  /* the name of the driver */
-        virDrvConnectOpen                 connectOpen;
-        virDrvConnectClose                connectClose;
-        virDrvConnectNumOfNetworks         connectNumOfNetworks;
-        virDrvConnectListNetworks          connectListNetworks;
-        virDrvConnectNumOfDefinedNetworks  connectNumOfDefinedNetworks;
-        virDrvConnectListDefinedNetworks   connectListDefinedNetworks;
-        virDrvConnectListAllNetworks       connectListAllNetworks;
-        virDrvNetworkLookupByUUID   networkLookupByUUID;
-        virDrvNetworkLookupByName   networkLookupByName;
-        virDrvNetworkCreateXML      networkCreateXML;
-        virDrvNetworkDefineXML      networkDefineXML;
-        virDrvNetworkUndefine       networkUndefine;
-        virDrvNetworkUpdate         networkUpdate;
-        virDrvNetworkCreate         networkCreate;
-        virDrvNetworkDestroy        networkDestroy;
-        virDrvNetworkGetXMLDesc     networkGetXMLDesc;
-        virDrvNetworkGetBridgeName  networkGetBridgeName;
-        virDrvNetworkGetAutostart   networkGetAutostart;
-        virDrvNetworkSetAutostart   networkSetAutostart;
-        virDrvNetworkIsActive       networkIsActive;
-        virDrvNetworkIsPersistent   networkIsPersistent;
+    const char * name; /* the name of the driver */
+    virDrvConnectOpen connectOpen;
+    virDrvConnectClose connectClose;
+    virDrvConnectNumOfNetworks connectNumOfNetworks;
+    virDrvConnectListNetworks connectListNetworks;
+    virDrvConnectNumOfDefinedNetworks connectNumOfDefinedNetworks;
+    virDrvConnectListDefinedNetworks connectListDefinedNetworks;
+    virDrvConnectListAllNetworks connectListAllNetworks;
+    virDrvNetworkLookupByUUID networkLookupByUUID;
+    virDrvNetworkLookupByName networkLookupByName;
+    virDrvNetworkCreateXML networkCreateXML;
+    virDrvNetworkDefineXML networkDefineXML;
+    virDrvNetworkUndefine networkUndefine;
+    virDrvNetworkUpdate networkUpdate;
+    virDrvNetworkCreate networkCreate;
+    virDrvNetworkDestroy networkDestroy;
+    virDrvNetworkGetXMLDesc networkGetXMLDesc;
+    virDrvNetworkGetBridgeName networkGetBridgeName;
+    virDrvNetworkGetAutostart networkGetAutostart;
+    virDrvNetworkSetAutostart networkSetAutostart;
+    virDrvNetworkIsActive networkIsActive;
+    virDrvNetworkIsPersistent networkIsPersistent;
 };
 
-/*-------*/
+
 typedef int
-        (*virDrvConnectNumOfInterfaces)        (virConnectPtr conn);
+(*virDrvConnectNumOfInterfaces)(virConnectPtr conn);
+
 typedef int
-        (*virDrvConnectListInterfaces)         (virConnectPtr conn,
-                                                char **const names,
-                                                int maxnames);
+(*virDrvConnectListInterfaces)(virConnectPtr conn,
+                               char **const names,
+                               int maxnames);
+
 typedef int
-        (*virDrvConnectNumOfDefinedInterfaces) (virConnectPtr conn);
+(*virDrvConnectNumOfDefinedInterfaces)(virConnectPtr conn);
+
 typedef int
-        (*virDrvConnectListDefinedInterfaces)  (virConnectPtr conn,
-                                                char **const names,
-                                                int maxnames);
+(*virDrvConnectListDefinedInterfaces)(virConnectPtr conn,
+                                      char **const names,
+                                      int maxnames);
+
 typedef int
-        (*virDrvConnectListAllInterfaces)      (virConnectPtr conn,
-                                                virInterfacePtr **ifaces,
-                                                unsigned int flags);
+(*virDrvConnectListAllInterfaces)(virConnectPtr conn,
+                                  virInterfacePtr **ifaces,
+                                  unsigned int flags);
+
 typedef virInterfacePtr
-        (*virDrvInterfaceLookupByName)  (virConnectPtr conn,
-                                         const char *name);
+(*virDrvInterfaceLookupByName)(virConnectPtr conn,
+                               const char *name);
+
 typedef virInterfacePtr
-        (*virDrvInterfaceLookupByMACString)   (virConnectPtr conn,
-                                               const char *mac);
+(*virDrvInterfaceLookupByMACString)(virConnectPtr conn,
+                                    const char *mac);
 
 typedef char *
-        (*virDrvInterfaceGetXMLDesc)    (virInterfacePtr iface,
-                                         unsigned int flags);
+(*virDrvInterfaceGetXMLDesc)(virInterfacePtr iface,
+                             unsigned int flags);
 
 typedef virInterfacePtr
-        (*virDrvInterfaceDefineXML)     (virConnectPtr conn,
-                                         const char *xmlDesc,
-                                         unsigned int flags);
+(*virDrvInterfaceDefineXML)(virConnectPtr conn,
+                            const char *xmlDesc,
+                            unsigned int flags);
+
 typedef int
-        (*virDrvInterfaceUndefine)      (virInterfacePtr iface);
+(*virDrvInterfaceUndefine)(virInterfacePtr iface);
+
 typedef int
-        (*virDrvInterfaceCreate)        (virInterfacePtr iface,
-                                         unsigned int flags);
+(*virDrvInterfaceCreate)(virInterfacePtr iface,
+                         unsigned int flags);
+
 typedef int
-        (*virDrvInterfaceDestroy)       (virInterfacePtr iface,
-                                         unsigned int flags);
+(*virDrvInterfaceDestroy)(virInterfacePtr iface,
+                          unsigned int flags);
 
 typedef int
-        (*virDrvInterfaceIsActive)     (virInterfacePtr iface);
+(*virDrvInterfaceIsActive)(virInterfacePtr iface);
 
 typedef int
-        (*virDrvInterfaceChangeBegin)   (virConnectPtr conn,
-                                         unsigned int flags);
+(*virDrvInterfaceChangeBegin)(virConnectPtr conn,
+                              unsigned int flags);
+
 typedef int
-        (*virDrvInterfaceChangeCommit)  (virConnectPtr conn,
-                                         unsigned int flags);
+(*virDrvInterfaceChangeCommit)(virConnectPtr conn,
+                               unsigned int flags);
+
 typedef int
-        (*virDrvInterfaceChangeRollback)(virConnectPtr conn,
-                                         unsigned int flags);
+(*virDrvInterfaceChangeRollback)(virConnectPtr conn,
+                                 unsigned int flags);
 
 typedef struct _virInterfaceDriver virInterfaceDriver;
 typedef virInterfaceDriver *virInterfaceDriverPtr;
@@ -1306,166 +1422,198 @@ typedef virInterfaceDriver *virInterfaceDriverPtr;
  *  - close
  */
 struct _virInterfaceDriver {
-    const char                      *name; /* the name of the driver */
-    virDrvConnectOpen                      connectOpen;
-    virDrvConnectClose                     connectClose;
-    virDrvConnectNumOfInterfaces            connectNumOfInterfaces;
-    virDrvConnectListInterfaces             connectListInterfaces;
-    virDrvConnectNumOfDefinedInterfaces     connectNumOfDefinedInterfaces;
-    virDrvConnectListDefinedInterfaces      connectListDefinedInterfaces;
-    virDrvConnectListAllInterfaces          connectListAllInterfaces;
-    virDrvInterfaceLookupByName      interfaceLookupByName;
+    const char *name; /* the name of the driver */
+    virDrvConnectOpen connectOpen;
+    virDrvConnectClose connectClose;
+    virDrvConnectNumOfInterfaces connectNumOfInterfaces;
+    virDrvConnectListInterfaces connectListInterfaces;
+    virDrvConnectNumOfDefinedInterfaces connectNumOfDefinedInterfaces;
+    virDrvConnectListDefinedInterfaces connectListDefinedInterfaces;
+    virDrvConnectListAllInterfaces connectListAllInterfaces;
+    virDrvInterfaceLookupByName interfaceLookupByName;
     virDrvInterfaceLookupByMACString interfaceLookupByMACString;
-    virDrvInterfaceGetXMLDesc        interfaceGetXMLDesc;
-    virDrvInterfaceDefineXML         interfaceDefineXML;
-    virDrvInterfaceUndefine          interfaceUndefine;
-    virDrvInterfaceCreate            interfaceCreate;
-    virDrvInterfaceDestroy           interfaceDestroy;
-    virDrvInterfaceIsActive          interfaceIsActive;
-    virDrvInterfaceChangeBegin       interfaceChangeBegin;
-    virDrvInterfaceChangeCommit      interfaceChangeCommit;
-    virDrvInterfaceChangeRollback    interfaceChangeRollback;
+    virDrvInterfaceGetXMLDesc interfaceGetXMLDesc;
+    virDrvInterfaceDefineXML interfaceDefineXML;
+    virDrvInterfaceUndefine interfaceUndefine;
+    virDrvInterfaceCreate interfaceCreate;
+    virDrvInterfaceDestroy interfaceDestroy;
+    virDrvInterfaceIsActive interfaceIsActive;
+    virDrvInterfaceChangeBegin interfaceChangeBegin;
+    virDrvInterfaceChangeCommit interfaceChangeCommit;
+    virDrvInterfaceChangeRollback interfaceChangeRollback;
 };
 
 
 typedef int
-    (*virDrvConnectNumOfStoragePools)        (virConnectPtr conn);
+(*virDrvConnectNumOfStoragePools)(virConnectPtr conn);
+
 typedef int
-    (*virDrvConnectListStoragePools)         (virConnectPtr conn,
-                                              char **const names,
-                                              int maxnames);
+(*virDrvConnectListStoragePools)(virConnectPtr conn,
+                                 char **const names,
+                                 int maxnames);
+
 typedef int
-    (*virDrvConnectNumOfDefinedStoragePools) (virConnectPtr conn);
+(*virDrvConnectNumOfDefinedStoragePools)(virConnectPtr conn);
+
 typedef int
-    (*virDrvConnectListDefinedStoragePools)  (virConnectPtr conn,
-                                              char **const names,
-                                              int maxnames);
+(*virDrvConnectListDefinedStoragePools)(virConnectPtr conn,
+                                        char **const names,
+                                        int maxnames);
+
 typedef int
-    (*virDrvConnectListAllStoragePools)      (virConnectPtr conn,
-                                              virStoragePoolPtr **pools,
-                                              unsigned int flags);
+(*virDrvConnectListAllStoragePools)(virConnectPtr conn,
+                                    virStoragePoolPtr **pools,
+                                    unsigned int flags);
+
 typedef char *
-    (*virDrvConnectFindStoragePoolSources)   (virConnectPtr conn,
-                                              const char *type,
-                                              const char *srcSpec,
-                                              unsigned int flags);
+(*virDrvConnectFindStoragePoolSources)(virConnectPtr conn,
+                                       const char *type,
+                                       const char *srcSpec,
+                                       unsigned int flags);
+
 typedef virStoragePoolPtr
-    (*virDrvStoragePoolLookupByName)         (virConnectPtr conn,
-                                              const char *name);
+(*virDrvStoragePoolLookupByName)(virConnectPtr conn,
+                                 const char *name);
+
 typedef virStoragePoolPtr
-    (*virDrvStoragePoolLookupByUUID)         (virConnectPtr conn,
-                                              const unsigned char *uuid);
+(*virDrvStoragePoolLookupByUUID)(virConnectPtr conn,
+                                 const unsigned char *uuid);
+
 typedef virStoragePoolPtr
-    (*virDrvStoragePoolLookupByVolume)       (virStorageVolPtr vol);
+(*virDrvStoragePoolLookupByVolume)(virStorageVolPtr vol);
+
 typedef virStoragePoolPtr
-    (*virDrvStoragePoolCreateXML)            (virConnectPtr conn,
-                                              const char *xmlDesc,
-                                              unsigned int flags);
+(*virDrvStoragePoolCreateXML)(virConnectPtr conn,
+                              const char *xmlDesc,
+                              unsigned int flags);
+
 typedef virStoragePoolPtr
-    (*virDrvStoragePoolDefineXML)            (virConnectPtr conn,
-                                              const char *xmlDesc,
-                                              unsigned int flags);
+(*virDrvStoragePoolDefineXML)(virConnectPtr conn,
+                              const char *xmlDesc,
+                              unsigned int flags);
+
 typedef int
-    (*virDrvStoragePoolUndefine)             (virStoragePoolPtr pool);
+(*virDrvStoragePoolUndefine)(virStoragePoolPtr pool);
+
 typedef int
-    (*virDrvStoragePoolBuild)                (virStoragePoolPtr pool,
-                                              unsigned int flags);
+(*virDrvStoragePoolBuild)(virStoragePoolPtr pool,
+                          unsigned int flags);
+
 typedef int
-    (*virDrvStoragePoolCreate)               (virStoragePoolPtr pool,
-                                              unsigned int flags);
+(*virDrvStoragePoolCreate)(virStoragePoolPtr pool,
+                           unsigned int flags);
+
 typedef int
-    (*virDrvStoragePoolDestroy)              (virStoragePoolPtr pool);
+(*virDrvStoragePoolDestroy)(virStoragePoolPtr pool);
+
 typedef int
-    (*virDrvStoragePoolDelete)               (virStoragePoolPtr pool,
-                                              unsigned int flags);
+(*virDrvStoragePoolDelete)(virStoragePoolPtr pool,
+                           unsigned int flags);
+
 typedef int
-    (*virDrvStoragePoolRefresh)              (virStoragePoolPtr pool,
-                                              unsigned int flags);
+(*virDrvStoragePoolRefresh)(virStoragePoolPtr pool,
+                            unsigned int flags);
+
 typedef int
-    (*virDrvStoragePoolGetInfo)              (virStoragePoolPtr vol,
-                                              virStoragePoolInfoPtr info);
+(*virDrvStoragePoolGetInfo)(virStoragePoolPtr vol,
+                            virStoragePoolInfoPtr info);
+
 typedef char *
-    (*virDrvStoragePoolGetXMLDesc)           (virStoragePoolPtr pool,
-                                              unsigned int flags);
+(*virDrvStoragePoolGetXMLDesc)(virStoragePoolPtr pool,
+                               unsigned int flags);
+
 typedef int
-    (*virDrvStoragePoolGetAutostart)         (virStoragePoolPtr pool,
-                                              int *autostart);
+(*virDrvStoragePoolGetAutostart)(virStoragePoolPtr pool,
+                                 int *autostart);
+
 typedef int
-    (*virDrvStoragePoolSetAutostart)         (virStoragePoolPtr pool,
-                                              int autostart);
+(*virDrvStoragePoolSetAutostart)(virStoragePoolPtr pool,
+                                 int autostart);
+
 typedef int
-    (*virDrvStoragePoolNumOfVolumes)         (virStoragePoolPtr pool);
+(*virDrvStoragePoolNumOfVolumes)(virStoragePoolPtr pool);
+
 typedef int
-    (*virDrvStoragePoolListVolumes)          (virStoragePoolPtr pool,
-                                              char **const names,
-                                              int maxnames);
+(*virDrvStoragePoolListVolumes)(virStoragePoolPtr pool,
+                                char **const names,
+                                int maxnames);
+
 typedef int
-    (*virDrvStoragePoolListAllVolumes)       (virStoragePoolPtr pool,
-                                              virStorageVolPtr **vols,
-                                              unsigned int flags);
+(*virDrvStoragePoolListAllVolumes)(virStoragePoolPtr pool,
+                                   virStorageVolPtr **vols,
+                                   unsigned int flags);
 
 typedef virStorageVolPtr
-    (*virDrvStorageVolLookupByName)          (virStoragePoolPtr pool,
-                                              const char *name);
-typedef virStorageVolPtr
-    (*virDrvStorageVolLookupByKey)           (virConnectPtr pool,
-                                              const char *key);
+(*virDrvStorageVolLookupByName)(virStoragePoolPtr pool,
+                                const char *name);
+
 typedef virStorageVolPtr
-    (*virDrvStorageVolLookupByPath)          (virConnectPtr pool,
-                                              const char *path);
+(*virDrvStorageVolLookupByKey)(virConnectPtr pool,
+                               const char *key);
 
+typedef virStorageVolPtr
+(*virDrvStorageVolLookupByPath)(virConnectPtr pool,
+                                const char *path);
 
 typedef virStorageVolPtr
-    (*virDrvStorageVolCreateXML)             (virStoragePoolPtr pool,
-                                              const char *xmldesc,
-                                              unsigned int flags);
+(*virDrvStorageVolCreateXML)(virStoragePoolPtr pool,
+                             const char *xmldesc,
+                             unsigned int flags);
+
 typedef int
-    (*virDrvStorageVolDelete)               (virStorageVolPtr vol,
-                                             unsigned int flags);
+(*virDrvStorageVolDelete)(virStorageVolPtr vol,
+                          unsigned int flags);
 
 typedef int
-    (*virDrvStorageVolWipe)                  (virStorageVolPtr vol,
-                                              unsigned int flags);
+(*virDrvStorageVolWipe)(virStorageVolPtr vol,
+                        unsigned int flags);
+
 typedef int
-    (*virDrvStorageVolWipePattern)           (virStorageVolPtr vol,
-                                              unsigned int algorithm,
-                                              unsigned int flags);
+(*virDrvStorageVolWipePattern)(virStorageVolPtr vol,
+                               unsigned int algorithm,
+                               unsigned int flags);
 
 typedef int
-    (*virDrvStorageVolGetInfo)               (virStorageVolPtr vol,
-                                              virStorageVolInfoPtr info);
+(*virDrvStorageVolGetInfo)(virStorageVolPtr vol,
+                           virStorageVolInfoPtr info);
+
 typedef char *
-    (*virDrvStorageVolGetXMLDesc)            (virStorageVolPtr pool,
-                                              unsigned int flags);
+(*virDrvStorageVolGetXMLDesc)(virStorageVolPtr pool,
+                              unsigned int flags);
+
 typedef char *
-    (*virDrvStorageVolGetPath)               (virStorageVolPtr vol);
+(*virDrvStorageVolGetPath)(virStorageVolPtr vol);
 
 typedef virStorageVolPtr
-    (*virDrvStorageVolCreateXMLFrom)         (virStoragePoolPtr pool,
-                                              const char *xmldesc,
-                                              virStorageVolPtr clonevol,
-                                              unsigned int flags);
-typedef int
-    (*virDrvStorageVolDownload) (virStorageVolPtr vol,
-                                 virStreamPtr stream,
-                                 unsigned long long offset,
-                                 unsigned long long length,
+(*virDrvStorageVolCreateXMLFrom)(virStoragePoolPtr pool,
+                                 const char *xmldesc,
+                                 virStorageVolPtr clonevol,
                                  unsigned int flags);
+
 typedef int
-    (*virDrvStorageVolUpload) (virStorageVolPtr vol,
-                               virStreamPtr stream,
-                               unsigned long long offset,
-                               unsigned long long length,
-                               unsigned int flags);
+(*virDrvStorageVolDownload)(virStorageVolPtr vol,
+                            virStreamPtr stream,
+                            unsigned long long offset,
+                            unsigned long long length,
+                            unsigned int flags);
+
 typedef int
-        (*virDrvStorageVolResize) (virStorageVolPtr vol,
-                                   unsigned long long capacity,
-                                   unsigned int flags);
+(*virDrvStorageVolUpload)(virStorageVolPtr vol,
+                          virStreamPtr stream,
+                          unsigned long long offset,
+                          unsigned long long length,
+                          unsigned int flags);
 
 typedef int
-        (*virDrvStoragePoolIsActive)(virStoragePoolPtr pool);
+(*virDrvStorageVolResize)(virStorageVolPtr vol,
+                          unsigned long long capacity,
+                          unsigned int flags);
+
 typedef int
-        (*virDrvStoragePoolIsPersistent)(virStoragePoolPtr pool);
+(*virDrvStoragePoolIsActive)(virStoragePoolPtr pool);
+
+typedef int
+(*virDrvStoragePoolIsPersistent)(virStoragePoolPtr pool);
 
 
 
@@ -1483,114 +1631,134 @@ typedef virStorageDriver *virStorageDriverPtr;
  *  - close
  */
 struct _virStorageDriver {
-    const char * name;    /* the name of the driver */
-    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;
+    const char * name; /* the name of the driver */
+    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
 
-typedef int (*virDrvStateInitialize) (bool privileged,
-                                      virStateInhibitCallback callback,
-                                      void *opaque);
-typedef int (*virDrvStateCleanup) (void);
-typedef int (*virDrvStateReload) (void);
-typedef int (*virDrvStateStop) (void);
+typedef int
+(*virDrvStateInitialize)(bool privileged,
+                         virStateInhibitCallback callback,
+                         void *opaque);
+
+typedef int
+(*virDrvStateCleanup)(void);
+
+typedef int
+(*virDrvStateReload)(void);
+
+typedef int
+(*virDrvStateStop)(void);
 
 typedef struct _virStateDriver virStateDriver;
 typedef virStateDriver *virStateDriverPtr;
 
 struct _virStateDriver {
     const char *name;
-    virDrvStateInitialize  stateInitialize;
-    virDrvStateCleanup     stateCleanup;
-    virDrvStateReload      stateReload;
-    virDrvStateStop        stateStop;
+    virDrvStateInitialize stateInitialize;
+    virDrvStateCleanup stateCleanup;
+    virDrvStateReload stateReload;
+    virDrvStateStop stateStop;
 };
 # endif
 
 
-typedef struct _virDeviceMonitor virDeviceMonitor;
-typedef virDeviceMonitor *virDeviceMonitorPtr;
+typedef int
+(*virDrvNodeNumOfDevices)(virConnectPtr conn,
+                          const char *cap,
+                          unsigned int flags);
 
-typedef int (*virDrvNodeNumOfDevices)(virConnectPtr conn,
-                                      const char *cap,
-                                      unsigned int flags);
+typedef int
+(*virDrvNodeListDevices)(virConnectPtr conn,
+                         const char *cap,
+                         char **const names,
+                         int maxnames,
+                         unsigned int flags);
 
-typedef int (*virDrvNodeListDevices)(virConnectPtr conn,
-                                     const char *cap,
-                                     char **const names,
-                                     int maxnames,
-                                     unsigned int flags);
-typedef int (*virDrvConnectListAllNodeDevices)(virConnectPtr conn,
-                                               virNodeDevicePtr **devices,
-                                               unsigned int flags);
+typedef int
+(*virDrvConnectListAllNodeDevices)(virConnectPtr conn,
+                                   virNodeDevicePtr **devices,
+                                   unsigned int flags);
+
+typedef virNodeDevicePtr
+(*virDrvNodeDeviceLookupByName)(virConnectPtr conn,
+                                const char *name);
+
+typedef virNodeDevicePtr
+(*virDrvNodeDeviceLookupSCSIHostByWWN)(virConnectPtr conn,
+                                       const char *wwnn,
+                                       const char *wwpn,
+                                       unsigned int flags);
+
+typedef char *
+(*virDrvNodeDeviceGetXMLDesc)(virNodeDevicePtr dev,
+                              unsigned int flags);
 
-typedef virNodeDevicePtr (*virDrvNodeDeviceLookupByName)(virConnectPtr conn,
-                                                         const char *name);
+typedef char *
+(*virDrvNodeDeviceGetParent)(virNodeDevicePtr dev);
 
-typedef virNodeDevicePtr (*virDrvNodeDeviceLookupSCSIHostByWWN)(virConnectPtr conn,
-                                                                const char *wwnn,
-                                                                const char *wwpn,
-                                                                unsigned int flags);
+typedef int
+(*virDrvNodeDeviceNumOfCaps)(virNodeDevicePtr dev);
 
-typedef char * (*virDrvNodeDeviceGetXMLDesc)(virNodeDevicePtr dev,
-                                             unsigned int flags);
+typedef int
+(*virDrvNodeDeviceListCaps)(virNodeDevicePtr dev,
+                            char **const names,
+                            int maxnames);
 
-typedef char * (*virDrvNodeDeviceGetParent)(virNodeDevicePtr dev);
+typedef virNodeDevicePtr
+(*virDrvNodeDeviceCreateXML)(virConnectPtr conn,
+                             const char *xmlDesc,
+                             unsigned int flags);
 
-typedef int (*virDrvNodeDeviceNumOfCaps)(virNodeDevicePtr dev);
+typedef int
+(*virDrvNodeDeviceDestroy)(virNodeDevicePtr dev);
 
-typedef int (*virDrvNodeDeviceListCaps)(virNodeDevicePtr dev,
-                                       char **const names,
-                                       int maxnames);
 
-typedef virNodeDevicePtr (*virDrvNodeDeviceCreateXML)(virConnectPtr conn,
-                                                      const char *xmlDesc,
-                                                      unsigned int flags);
-typedef int (*virDrvNodeDeviceDestroy)(virNodeDevicePtr dev);
+
+typedef struct _virDeviceMonitor virDeviceMonitor;
+typedef virDeviceMonitor *virDeviceMonitorPtr;
 
 /**
  * _virDeviceMonitor:
@@ -1600,20 +1768,20 @@ typedef int (*virDrvNodeDeviceDestroy)(virNodeDevicePtr dev);
  *
  */
 struct _virDeviceMonitor {
-    const char * name;    /* the name of the driver */
-    virDrvConnectOpen                 connectOpen;
-    virDrvConnectClose                connectClose;
-    virDrvNodeNumOfDevices       nodeNumOfDevices;
-    virDrvNodeListDevices        nodeListDevices;
+    const char * name; /* the name of the driver */
+    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;
+    virDrvNodeDeviceLookupSCSIHostByWWN nodeDeviceLookupSCSIHostByWWN;
+    virDrvNodeDeviceGetXMLDesc nodeDeviceGetXMLDesc;
+    virDrvNodeDeviceGetParent nodeDeviceGetParent;
+    virDrvNodeDeviceNumOfCaps nodeDeviceNumOfCaps;
+    virDrvNodeDeviceListCaps nodeDeviceListCaps;
+    virDrvNodeDeviceCreateXML nodeDeviceCreateXML;
+    virDrvNodeDeviceDestroy nodeDeviceDestroy;
 };
 
 enum {
@@ -1623,41 +1791,50 @@ enum {
 };
 
 typedef virSecretPtr
-    (*virDrvSecretLookupByUUID)        (virConnectPtr conn,
-                                        const unsigned char *uuid);
+(*virDrvSecretLookupByUUID)(virConnectPtr conn,
+                            const unsigned char *uuid);
+
 typedef virSecretPtr
-    (*virDrvSecretLookupByUsage)       (virConnectPtr conn,
-                                        int usageType,
-                                        const char *usageID);
+(*virDrvSecretLookupByUsage)(virConnectPtr conn,
+                             int usageType,
+                             const char *usageID);
+
 typedef virSecretPtr
-    (*virDrvSecretDefineXML)           (virConnectPtr conn,
-                                        const char *xml,
-                                        unsigned int flags);
+(*virDrvSecretDefineXML)(virConnectPtr conn,
+                         const char *xml,
+                         unsigned int flags);
+
 typedef char *
-    (*virDrvSecretGetXMLDesc)          (virSecretPtr secret,
-                                        unsigned int flags);
+(*virDrvSecretGetXMLDesc)(virSecretPtr secret,
+                          unsigned int flags);
+
 typedef int
-    (*virDrvSecretSetValue)            (virSecretPtr secret,
-                                        const unsigned char *value,
-                                        size_t value_size,
-                                        unsigned int flags);
+(*virDrvSecretSetValue)(virSecretPtr secret,
+                        const unsigned char *value,
+                        size_t value_size,
+                        unsigned int flags);
+
 typedef unsigned char *
-    (*virDrvSecretGetValue)            (virSecretPtr secret,
-                                        size_t *value_size,
-                                        unsigned int flags,
-                                        unsigned int internalFlags);
+(*virDrvSecretGetValue)(virSecretPtr secret,
+                        size_t *value_size,
+                        unsigned int flags,
+                        unsigned int internalFlags);
+
 typedef int
-    (*virDrvSecretUndefine)            (virSecretPtr secret);
+(*virDrvSecretUndefine)(virSecretPtr secret);
+
 typedef int
-    (*virDrvConnectNumOfSecrets)              (virConnectPtr conn);
+(*virDrvConnectNumOfSecrets)(virConnectPtr conn);
+
 typedef int
-    (*virDrvConnectListSecrets)               (virConnectPtr conn,
-                                               char **uuids,
-                                               int maxuuids);
+(*virDrvConnectListSecrets)(virConnectPtr conn,
+                            char **uuids,
+                            int maxuuids);
+
 typedef int
-    (*virDrvConnectListAllSecrets)            (virConnectPtr conn,
-                                               virSecretPtr **secrets,
-                                               unsigned int flags);
+(*virDrvConnectListAllSecrets)(virConnectPtr conn,
+                               virSecretPtr **secrets,
+                               unsigned int flags);
 
 typedef struct _virSecretDriver virSecretDriver;
 typedef virSecretDriver *virSecretDriverPtr;
@@ -1674,81 +1851,96 @@ typedef virSecretDriver *virSecretDriverPtr;
  */
 struct _virSecretDriver {
     const char *name;
-    virDrvConnectOpen                 connectOpen;
-    virDrvConnectClose                connectClose;
-
-    virDrvConnectNumOfSecrets          connectNumOfSecrets;
-    virDrvConnectListSecrets           connectListSecrets;
-    virDrvConnectListAllSecrets        connectListAllSecrets;
-    virDrvSecretLookupByUUID    secretLookupByUUID;
-    virDrvSecretLookupByUsage   secretLookupByUsage;
-    virDrvSecretDefineXML       secretDefineXML;
-    virDrvSecretGetXMLDesc      secretGetXMLDesc;
-    virDrvSecretSetValue        secretSetValue;
-    virDrvSecretGetValue        secretGetValue;
-    virDrvSecretUndefine        secretUndefine;
+    virDrvConnectOpen connectOpen;
+    virDrvConnectClose connectClose;
+    virDrvConnectNumOfSecrets connectNumOfSecrets;
+    virDrvConnectListSecrets connectListSecrets;
+    virDrvConnectListAllSecrets connectListAllSecrets;
+    virDrvSecretLookupByUUID secretLookupByUUID;
+    virDrvSecretLookupByUsage secretLookupByUsage;
+    virDrvSecretDefineXML secretDefineXML;
+    virDrvSecretGetXMLDesc secretGetXMLDesc;
+    virDrvSecretSetValue secretSetValue;
+    virDrvSecretGetValue secretGetValue;
+    virDrvSecretUndefine secretUndefine;
 };
 
 
-typedef struct _virStreamDriver virStreamDriver;
-typedef virStreamDriver *virStreamDriverPtr;
+typedef int
+(*virDrvStreamSend)(virStreamPtr st,
+                    const char *data,
+                    size_t nbytes);
 
-typedef int (*virDrvStreamSend)(virStreamPtr st,
-                                const char *data,
-                                size_t nbytes);
-typedef int (*virDrvStreamRecv)(virStreamPtr st,
-                                char *data,
-                                size_t nbytes);
+typedef int
+(*virDrvStreamRecv)(virStreamPtr st,
+                    char *data,
+                    size_t nbytes);
+
+typedef int
+(*virDrvStreamEventAddCallback)(virStreamPtr stream,
+                                int events,
+                                virStreamEventCallback cb,
+                                void *opaque,
+                                virFreeCallback ff);
+
+typedef int
+(*virDrvStreamEventUpdateCallback)(virStreamPtr stream,
+                                   int events);
+
+typedef int
+(*virDrvStreamEventRemoveCallback)(virStreamPtr stream);
 
-typedef int (*virDrvStreamEventAddCallback)(virStreamPtr stream,
-                                            int events,
-                                            virStreamEventCallback cb,
-                                            void *opaque,
-                                            virFreeCallback ff);
+typedef int
+(*virDrvStreamFinish)(virStreamPtr st);
 
-typedef int (*virDrvStreamEventUpdateCallback)(virStreamPtr stream,
-                                               int events);
-typedef int (*virDrvStreamEventRemoveCallback)(virStreamPtr stream);
-typedef int (*virDrvStreamFinish)(virStreamPtr st);
-typedef int (*virDrvStreamAbort)(virStreamPtr st);
+typedef int
+(*virDrvStreamAbort)(virStreamPtr st);
 
+typedef struct _virStreamDriver virStreamDriver;
+typedef virStreamDriver *virStreamDriverPtr;
 
 struct _virStreamDriver {
-    virDrvStreamSend                streamSend;
-    virDrvStreamRecv                streamRecv;
-    virDrvStreamEventAddCallback    streamEventAddCallback;
+    virDrvStreamSend streamSend;
+    virDrvStreamRecv streamRecv;
+    virDrvStreamEventAddCallback streamEventAddCallback;
     virDrvStreamEventUpdateCallback streamEventUpdateCallback;
     virDrvStreamEventRemoveCallback streamEventRemoveCallback;
-    virDrvStreamFinish              streamFinish;
-    virDrvStreamAbort               streamAbort;
+    virDrvStreamFinish streamFinish;
+    virDrvStreamAbort streamAbort;
 };
 
 
 typedef int
-    (*virDrvConnectNumOfNWFilters)        (virConnectPtr conn);
+(*virDrvConnectNumOfNWFilters)(virConnectPtr conn);
+
 typedef int
-    (*virDrvConnectListNWFilters)         (virConnectPtr conn,
-                                           char **const names,
-                                           int maxnames);
+(*virDrvConnectListNWFilters)(virConnectPtr conn,
+                              char **const names,
+                              int maxnames);
+
 typedef int
-    (*virDrvConnectListAllNWFilters)      (virConnectPtr conn,
-                                           virNWFilterPtr **filters,
-                                           unsigned int flags);
+(*virDrvConnectListAllNWFilters)(virConnectPtr conn,
+                                 virNWFilterPtr **filters,
+                                 unsigned int flags);
+
 typedef virNWFilterPtr
-    (*virDrvNWFilterLookupByName)         (virConnectPtr conn,
-                                           const char *name);
+(*virDrvNWFilterLookupByName)(virConnectPtr conn,
+                              const char *name);
+
 typedef virNWFilterPtr
-    (*virDrvNWFilterLookupByUUID)         (virConnectPtr conn,
-                                           const unsigned char *uuid);
+(*virDrvNWFilterLookupByUUID)(virConnectPtr conn,
+                              const unsigned char *uuid);
+
 typedef virNWFilterPtr
-    (*virDrvNWFilterDefineXML)            (virConnectPtr conn,
-                                           const char *xmlDesc);
+(*virDrvNWFilterDefineXML)(virConnectPtr conn,
+                           const char *xmlDesc);
+
 typedef int
-    (*virDrvNWFilterUndefine)             (virNWFilterPtr nwfilter);
+(*virDrvNWFilterUndefine)(virNWFilterPtr nwfilter);
 
 typedef char *
-    (*virDrvNWFilterGetXMLDesc)           (virNWFilterPtr nwfilter,
-                                           unsigned int flags);
+(*virDrvNWFilterGetXMLDesc)(virNWFilterPtr nwfilter,
+                            unsigned int flags);
 
 
 typedef struct _virNWFilterDriver virNWFilterDriver;
@@ -1765,18 +1957,17 @@ typedef virNWFilterDriver *virNWFilterDriverPtr;
  *  - close
  */
 struct _virNWFilterDriver {
-    const char * name;    /* the name of the driver */
-    virDrvConnectOpen                 connectOpen;
-    virDrvConnectClose                connectClose;
-
+    const char * name; /* the name of the driver */
+    virDrvConnectOpen connectOpen;
+    virDrvConnectClose connectClose;
     virDrvConnectNumOfNWFilters connectNumOfNWFilters;
-    virDrvConnectListNWFilters  connectListNWFilters;
-    virDrvConnectListAllNWFilters  connectListAllNWFilters;
-    virDrvNWFilterLookupByName  nwfilterLookupByName;
-    virDrvNWFilterLookupByUUID  nwfilterLookupByUUID;
-    virDrvNWFilterDefineXML     nwfilterDefineXML;
-    virDrvNWFilterUndefine      nwfilterUndefine;
-    virDrvNWFilterGetXMLDesc    nwfilterGetXMLDesc;
+    virDrvConnectListNWFilters connectListNWFilters;
+    virDrvConnectListAllNWFilters connectListAllNWFilters;
+    virDrvNWFilterLookupByName nwfilterLookupByName;
+    virDrvNWFilterLookupByUUID nwfilterLookupByUUID;
+    virDrvNWFilterDefineXML nwfilterDefineXML;
+    virDrvNWFilterUndefine nwfilterUndefine;
+    virDrvNWFilterGetXMLDesc nwfilterGetXMLDesc;
 };
 
 
-- 
1.8.1.4


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