Sanitize whitespace in driver.h

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: NDaniel P. Berrange <berrange@redhat.com>

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;
 };