External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-11-01 02:41:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
a269ac0f62
libvirt/src/vbox/vbox_uniformed_api.h
Daniel P. Berrangé 622c5e4099 vbox: add support for version 6.1 SDK 
Changes in the API:

 - APIs related to the graphics adapter are no longer on the
   IMachine interface, but on a IGraphicsAdapter interface
 - The LaunchVMProcess method takes a list of env variables
   instead of a single variable containing a concatenated
   list. Since we only ever pass a single env variable, we
   can simply stuff it straight into a list.
 - The DHCP server start method no longer needs the network
   name

Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2020-04-20 11:34:59 +01:00

561 lines
28 KiB
C
Raw Blame History

/*
* Copyright (C) 2014, Taowei Luo (uaedante@gmail.com)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "internal.h"
/* This file may be used in three place. That is vbox_tmpl.c,
* vbox_common.c and vbox_driver.c. The vboxUniformedAPI and some
* types used for vboxUniformedAPI is defined here.
*
* The vbox_tmpl.c is the only place where the driver knows the inside
* architecture of those vbox structs(vboxObj, vboxSession,
* pFuncs, and vboxCallback). The file should be included
* after the currect vbox_CAPI_v*.h, then we can use the vbox structs
* in vboxGlobalData. The vbox_tmpl.c should implement functions
* defined in vboxUniformedAPI.
*
* In vbox_driver.c, it is used to define the struct vboxUniformedAPI.
* The vbox_driver.c collects vboxUniformedAPI for all versions.
* Then vboxRegister calls the vboxRegisterUniformedAPI to register.
* Note: In vbox_driver.c, the vbox structs in vboxGlobalData is
* defined by vbox_CAPI_v4_0.h.
*
* The vbox_common.c, it is used to generate common codes for all vbox
* versions. Because the same member variable's offset in a vbox struct
* may change between different vbox versions. The vbox_common.c
* shouldn't directly use struct's member variables defined in
* vbox_CAPI_v*.h. To make things safety, we include the
* vbox_common.h in vbox_common.c. In this case, we treat structs
* defined by vbox as a void*. The common codes don't concern about
* the inside of this structs(actually, we can't, in the common level).
* With the help of vboxUniformed API, we call VirtualBox's API and
* implement the vbox driver in a high level.
*
* In conclusion:
* * In vbox_tmpl.c, this file is included after vbox_CAPI_v*.h
* * In vbox_driver.c, this file is included after vbox_XPCOMCGlue.h
* * In vbox_common.c, this file is included after vbox_common.h
*
*/
/* Extracted define from vbox_tmpl.c */
struct _vboxIID {
/* IID is represented by a UTF-16 encoded UUID in string form. */
PRUnichar *value;
/* owner indicates if we own the value and need to free it. */
bool owner;
};
typedef struct _vboxIID vboxIID;
typedef union {
nsresult uResultCode;
PRInt32 resultCode;
} resultCodeUnion;
struct _vboxDriver {
virObjectLockable parent;
virCapsPtr caps;
virDomainXMLOptionPtr xmlopt;
virObjectEventStatePtr domainEventState;
/* vbox API initialization members */
PCVBOXXPCOM pFuncs;
IVirtualBox *vboxObj;
ISession *vboxSession;
#ifdef VBOX_API_VERSION
IVirtualBoxClient *vboxClient;
#endif
unsigned long version;
/* reference counting of vbox connections */
int volatile connectionCount;
};
typedef struct _vboxDriver vboxDriver;
typedef struct _vboxDriver *vboxDriverPtr;
/* vboxUniformedAPI gives vbox_common.c a uniformed layer to see
* vbox API.
*/
/* Functions for pFuncs */
typedef struct {
int (*Initialize)(vboxDriverPtr driver);
void (*Uninitialize)(vboxDriverPtr driver);
void (*ComUnallocMem)(PCVBOXXPCOM pFuncs, void *pv);
void (*Utf16Free)(PCVBOXXPCOM pFuncs, PRUnichar *pwszString);
void (*Utf8Free)(PCVBOXXPCOM pFuncs, char *pszString);
int (*Utf16ToUtf8)(PCVBOXXPCOM pFuncs, const PRUnichar *pwszString, char **ppszString);
int (*Utf8ToUtf16)(PCVBOXXPCOM pFuncs, const char *pszString, PRUnichar **ppwszString);
} vboxUniformedPFN;
/* Functions for vboxIID */
typedef struct {
void (*vboxIIDInitialize)(vboxIID *iid);
void (*vboxIIDUnalloc)(vboxDriverPtr driver, vboxIID *iid);
void (*vboxIIDToUUID)(vboxDriverPtr driver, vboxIID *iid, unsigned char *uuid);
void (*vboxIIDFromUUID)(vboxDriverPtr driver, vboxIID *iid, const unsigned char *uuid);
bool (*vboxIIDIsEqual)(vboxDriverPtr driver, vboxIID *iid1, vboxIID *iid2);
void (*vboxIIDFromArrayItem)(vboxDriverPtr driver, vboxIID *iid, vboxArray *array, int idx);
void (*vboxIIDToUtf8)(vboxDriverPtr driver, vboxIID *iid, char **utf8);
void (*DEBUGIID)(vboxDriverPtr driver, const char *msg, vboxIID *iid);
} vboxUniformedIID;
/* Functions for vboxArray */
typedef struct {
nsresult (*vboxArrayGet)(vboxArray *array, void *self, void *getter);
nsresult (*vboxArrayGetWithIIDArg)(vboxArray *array, void *self, void *getter, vboxIID *iid);
void (*vboxArrayRelease)(vboxArray *array);
void (*vboxArrayUnalloc)(vboxArray *array);
/* Generate function pointers for vboxArrayGet */
void* (*handleGetMachines)(IVirtualBox *vboxObj);
void* (*handleGetHardDisks)(IVirtualBox *vboxObj);
void* (*handleUSBGetDeviceFilters)(IUSBCommon *USBCommon);
void* (*handleMachineGetStorageControllers)(IMachine *machine);
void* (*handleMachineGetMediumAttachments)(IMachine *machine);
void* (*handleMachineGetSharedFolders)(IMachine *machine);
void* (*handleSnapshotGetChildren)(ISnapshot *snapshot);
void* (*handleMediumGetChildren)(IMedium *medium);
void* (*handleMediumGetSnapshotIds)(IMedium *medium);
void* (*handleMediumGetMachineIds)(IMedium *medium);
void* (*handleHostGetNetworkInterfaces)(IHost *host);
} vboxUniformedArray;
/* Functions for nsISupports */
typedef struct {
nsresult (*Release)(nsISupports *nsi);
nsresult (*AddRef)(nsISupports *nsi);
} vboxUniformednsISupports;
/* Functions for IVirtualBox */
typedef struct {
nsresult (*GetVersion)(IVirtualBox *vboxObj, PRUnichar **versionUtf16);
nsresult (*GetMachine)(IVirtualBox *vboxObj, vboxIID *iid, IMachine **machine);
nsresult (*OpenMachine)(IVirtualBox *vboxObj, PRUnichar *settingsFile, IMachine **machine);
nsresult (*GetSystemProperties)(IVirtualBox *vboxObj, ISystemProperties **systemProperties);
nsresult (*GetHost)(IVirtualBox *vboxObj, IHost **host);
nsresult (*CreateMachine)(vboxDriverPtr driver, virDomainDefPtr def, IMachine **machine, char *uuidstr);
nsresult (*CreateHardDisk)(IVirtualBox *vboxObj, PRUnichar *format, PRUnichar *location, IMedium **medium);
nsresult (*RegisterMachine)(IVirtualBox *vboxObj, IMachine *machine);
nsresult (*FindHardDisk)(IVirtualBox *vboxObj, PRUnichar *location, PRUint32 deviceType,
PRUint32 accessMode, IMedium **medium);
nsresult (*OpenMedium)(IVirtualBox *vboxObj, PRUnichar *location, PRUint32 deviceType, PRUint32 accessMode, IMedium **medium);
nsresult (*GetHardDiskByIID)(IVirtualBox *vboxObj, vboxIID *iid, IMedium **medium);
nsresult (*FindDHCPServerByNetworkName)(IVirtualBox *vboxObj, PRUnichar *name, IDHCPServer **server);
nsresult (*CreateDHCPServer)(IVirtualBox *vboxObj, PRUnichar *name, IDHCPServer **server);
nsresult (*RemoveDHCPServer)(IVirtualBox *vboxObj, IDHCPServer *server);
} vboxUniformedIVirtualBox;
/* Functions for IMachine */
typedef struct {
nsresult (*AddStorageController)(IMachine *machine, PRUnichar *name,
PRUint32 connectionType, IStorageController **controller);
nsresult (*GetStorageControllerByName)(IMachine *machine, PRUnichar *name,
IStorageController **storageController);
nsresult (*AttachDevice)(IMachine *machine, PRUnichar *name,
PRInt32 controllerPort, PRInt32 device,
PRUint32 type, IMedium *medium);
nsresult (*CreateSharedFolder)(IMachine *machine, PRUnichar *name,
PRUnichar *hostPath, PRBool writable,
PRBool automount);
nsresult (*RemoveSharedFolder)(IMachine *machine, PRUnichar *name);
nsresult (*LaunchVMProcess)(vboxDriverPtr driver, IMachine *machine,
vboxIID *iid,
PRUnichar *sessionType, PRUnichar *env,
IProgress **progress);
nsresult (*Unregister)(IMachine *machine, PRUint32 cleanupMode,
PRUint32 *aMediaSize, IMedium ***aMedia);
nsresult (*FindSnapshot)(IMachine *machine, vboxIID *iid, ISnapshot **snapshot);
nsresult (*DetachDevice)(IMachine *machine, PRUnichar *name,
PRInt32 controllerPort, PRInt32 device);
nsresult (*GetAccessible)(IMachine *machine, PRBool *isAccessible);
nsresult (*GetState)(IMachine *machine, PRUint32 *state);
nsresult (*GetName)(IMachine *machine, PRUnichar **name);
nsresult (*GetId)(IMachine *machine, vboxIID *iid);
nsresult (*GetBIOSSettings)(IMachine *machine, IBIOSSettings **bios);
nsresult (*GetAudioAdapter)(IMachine *machine, IAudioAdapter **audioAdapter);
nsresult (*GetNetworkAdapter)(IMachine *machine, PRUint32 slot, INetworkAdapter **adapter);
nsresult (*GetChipsetType)(IMachine *machine, PRUint32 *chipsetType);
nsresult (*GetSerialPort)(IMachine *machine, PRUint32 slot, ISerialPort **port);
nsresult (*GetParallelPort)(IMachine *machine, PRUint32 slot, IParallelPort **port);
nsresult (*GetVRDEServer)(IMachine *machine, IVRDEServer **VRDEServer);
nsresult (*GetUSBCommon)(IMachine *machine, IUSBCommon **USBCommon);
nsresult (*GetCurrentSnapshot)(IMachine *machine, ISnapshot **currentSnapshot);
nsresult (*GetSettingsFilePath)(IMachine *machine, PRUnichar **settingsFilePath);
nsresult (*GetCPUCount)(IMachine *machine, PRUint32 *CPUCount);
nsresult (*SetCPUCount)(IMachine *machine, PRUint32 CPUCount);
nsresult (*GetMemorySize)(IMachine *machine, PRUint32 *memorySize);
nsresult (*SetMemorySize)(IMachine *machine, PRUint32 memorySize);
nsresult (*GetCPUProperty)(IMachine *machine, PRUint32 property, PRBool *value);
nsresult (*SetCPUProperty)(IMachine *machine, PRUint32 property, PRBool value);
nsresult (*GetBootOrder)(IMachine *machine, PRUint32 position, PRUint32 *device);
nsresult (*SetBootOrder)(IMachine *machine, PRUint32 position, PRUint32 device);
nsresult (*GetVRAMSize)(IMachine *machine, PRUint32 *VRAMSize);
nsresult (*SetVRAMSize)(IMachine *machine, PRUint32 VRAMSize);
nsresult (*GetMonitorCount)(IMachine *machine, PRUint32 *monitorCount);
nsresult (*SetMonitorCount)(IMachine *machine, PRUint32 monitorCount);
nsresult (*GetAccelerate3DEnabled)(IMachine *machine, PRBool *accelerate3DEnabled);
nsresult (*SetAccelerate3DEnabled)(IMachine *machine, PRBool accelerate3DEnabled);
nsresult (*GetAccelerate2DVideoEnabled)(IMachine *machine, PRBool *accelerate2DVideoEnabled);
nsresult (*SetAccelerate2DVideoEnabled)(IMachine *machine, PRBool accelerate2DVideoEnabled);
nsresult (*GetExtraData)(IMachine *machine, PRUnichar *key, PRUnichar **value);
nsresult (*SetExtraData)(IMachine *machine, PRUnichar *key, PRUnichar *value);
nsresult (*GetSnapshotCount)(IMachine *machine, PRUint32 *snapshotCount);
nsresult (*SaveSettings)(IMachine *machine);
} vboxUniformedIMachine;
/* Functions for ISession */
typedef struct {
nsresult (*Open)(vboxDriverPtr driver, vboxIID *iid, IMachine *machine);
nsresult (*OpenExisting)(vboxDriverPtr driver, vboxIID *iid, IMachine *machine);
nsresult (*GetConsole)(ISession *session, IConsole **console);
nsresult (*GetMachine)(ISession *session, IMachine **machine);
nsresult (*Close)(ISession *session);
} vboxUniformedISession;
/* Functions for IConsole */
typedef struct {
nsresult (*SaveState)(IConsole *console, IProgress **progress);
nsresult (*Pause)(IConsole *console);
nsresult (*Resume)(IConsole *console);
nsresult (*PowerButton)(IConsole *console);
nsresult (*PowerDown)(IConsole *console);
nsresult (*Reset)(IConsole *console);
nsresult (*TakeSnapshot)(IConsole *console, PRUnichar *name,
PRUnichar *description, IProgress **progress);
nsresult (*DeleteSnapshot)(IConsole *console, vboxIID *iid, IProgress **progress);
nsresult (*GetDisplay)(IConsole *console, IDisplay **display);
nsresult (*GetKeyboard)(IConsole *console, IKeyboard **keyboard);
} vboxUniformedIConsole;
/* Functions for IProgress */
typedef struct {
nsresult (*WaitForCompletion)(IProgress *progress, PRInt32 timeout);
nsresult (*GetResultCode)(IProgress *progress, resultCodeUnion *resultCode);
nsresult (*GetCompleted)(IProgress *progress, PRBool *completed);
} vboxUniformedIProgress;
/* Functions for ISystemProperties */
typedef struct {
nsresult (*GetMaxGuestCPUCount)(ISystemProperties *systemProperties, PRUint32 *maxCPUCount);
nsresult (*GetMaxBootPosition)(ISystemProperties *systemProperties, PRUint32 *maxBootPosition);
nsresult (*GetMaxNetworkAdapters)(ISystemProperties *systemProperties, PRUint32 chipset,
PRUint32 *maxNetworkAdapters);
nsresult (*GetSerialPortCount)(ISystemProperties *systemProperties, PRUint32 *SerialPortCount);
nsresult (*GetParallelPortCount)(ISystemProperties *systemProperties, PRUint32 *ParallelPortCount);
nsresult (*GetMaxPortCountForStorageBus)(ISystemProperties *systemProperties, PRUint32 bus,
PRUint32 *maxPortCount);
nsresult (*GetMaxDevicesPerPortForStorageBus)(ISystemProperties *systemProperties,
PRUint32 bus, PRUint32 *maxDevicesPerPort);
nsresult (*GetMaxGuestRAM)(ISystemProperties *systemProperties, PRUint32 *maxGuestRAM);
} vboxUniformedISystemProperties;
/* Functions for IBIOSSettings */
typedef struct {
nsresult (*GetACPIEnabled)(IBIOSSettings *bios, PRBool *ACPIEnabled);
nsresult (*SetACPIEnabled)(IBIOSSettings *bios, PRBool ACPIEnabled);
nsresult (*GetIOAPICEnabled)(IBIOSSettings *bios, PRBool *IOAPICEnabled);
nsresult (*SetIOAPICEnabled)(IBIOSSettings *bios, PRBool IOAPICEnabled);
} vboxUniformedIBIOSSettings;
/* Functions for IAudioAdapter */
typedef struct {
nsresult (*GetEnabled)(IAudioAdapter *audioAdapter, PRBool *enabled);
nsresult (*SetEnabled)(IAudioAdapter *audioAdapter, PRBool enabled);
nsresult (*GetAudioController)(IAudioAdapter *audioAdapter, PRUint32 *audioController);
nsresult (*SetAudioController)(IAudioAdapter *audioAdapter, PRUint32 audioController);
} vboxUniformedIAudioAdapter;
/* Functions for INetworkAdapter */
typedef struct {
nsresult (*GetAttachmentType)(INetworkAdapter *adapter, PRUint32 *attachmentType);
nsresult (*GetEnabled)(INetworkAdapter *adapter, PRBool *enabled);
nsresult (*SetEnabled)(INetworkAdapter *adapter, PRBool enabled);
nsresult (*GetAdapterType)(INetworkAdapter *adapter, PRUint32 *adapterType);
nsresult (*SetAdapterType)(INetworkAdapter *adapter, PRUint32 adapterType);
nsresult (*GetBridgedInterface)(INetworkAdapter *adapter, PRUnichar **bridgedInterface);
nsresult (*SetBridgedInterface)(INetworkAdapter *adapter, PRUnichar *bridgedInterface);
nsresult (*GetInternalNetwork)(INetworkAdapter *adapter, PRUnichar **internalNetwork);
nsresult (*SetInternalNetwork)(INetworkAdapter *adapter, PRUnichar *internalNetwork);
nsresult (*GetHostOnlyInterface)(INetworkAdapter *adapter, PRUnichar **hostOnlyInterface);
nsresult (*SetHostOnlyInterface)(INetworkAdapter *adapter, PRUnichar *hostOnlyInterface);
nsresult (*GetMACAddress)(INetworkAdapter *adapter, PRUnichar **MACAddress);
nsresult (*SetMACAddress)(INetworkAdapter *adapter, PRUnichar *MACAddress);
nsresult (*AttachToBridgedInterface)(INetworkAdapter *adapter);
nsresult (*AttachToInternalNetwork)(INetworkAdapter *adapter);
nsresult (*AttachToHostOnlyInterface)(INetworkAdapter *adapter);
nsresult (*AttachToNAT)(INetworkAdapter *adapter);
} vboxUniformedINetworkAdapter;
/* Functions for ISerialPort */
typedef struct {
nsresult (*GetEnabled)(ISerialPort *port, PRBool *enabled);
nsresult (*SetEnabled)(ISerialPort *port, PRBool enabled);
nsresult (*GetPath)(ISerialPort *port, PRUnichar **path);
nsresult (*SetPath)(ISerialPort *port, PRUnichar *path);
nsresult (*GetIRQ)(ISerialPort *port, PRUint32 *IRQ);
nsresult (*SetIRQ)(ISerialPort *port, PRUint32 IRQ);
nsresult (*GetIOBase)(ISerialPort *port, PRUint32 *IOBase);
nsresult (*SetIOBase)(ISerialPort *port, PRUint32 IOBase);
nsresult (*GetHostMode)(ISerialPort *port, PRUint32 *hostMode);
nsresult (*SetHostMode)(ISerialPort *port, PRUint32 hostMode);
} vboxUniformedISerialPort;
/* Functions for IParallelPort */
typedef struct {
nsresult (*GetEnabled)(IParallelPort *port, PRBool *enabled);
nsresult (*SetEnabled)(IParallelPort *port, PRBool enabled);
nsresult (*GetPath)(IParallelPort *port, PRUnichar **path);
nsresult (*SetPath)(IParallelPort *port, PRUnichar *path);
nsresult (*GetIRQ)(IParallelPort *port, PRUint32 *IRQ);
nsresult (*SetIRQ)(IParallelPort *port, PRUint32 IRQ);
nsresult (*GetIOBase)(IParallelPort *port, PRUint32 *IOBase);
nsresult (*SetIOBase)(IParallelPort *port, PRUint32 IOBase);
} vboxUniformedIParallelPort;
/* Functions for IVRDEServer */
typedef struct {
nsresult (*GetEnabled)(IVRDEServer *VRDEServer, PRBool *enabled);
nsresult (*SetEnabled)(IVRDEServer *VRDEServer, PRBool enabled);
nsresult (*GetPorts)(vboxDriverPtr driver, IVRDEServer *VRDEServer,
IMachine *machine, virDomainGraphicsDefPtr graphics);
nsresult (*SetPorts)(vboxDriverPtr driver, IVRDEServer *VRDEServer,
virDomainGraphicsDefPtr graphics);
nsresult (*GetReuseSingleConnection)(IVRDEServer *VRDEServer, PRBool *enabled);
nsresult (*SetReuseSingleConnection)(IVRDEServer *VRDEServer, PRBool enabled);
nsresult (*GetAllowMultiConnection)(IVRDEServer *VRDEServer, PRBool *enabled);
nsresult (*SetAllowMultiConnection)(IVRDEServer *VRDEServer, PRBool enabled);
nsresult (*GetNetAddress)(vboxDriverPtr driver, IVRDEServer *VRDEServer,
PRUnichar **netAddress);
nsresult (*SetNetAddress)(vboxDriverPtr driver, IVRDEServer *VRDEServer,
PRUnichar *netAddress);
} vboxUniformedIVRDEServer;
/* Common Functions for IUSBController and IUSBDeviceFilters */
typedef struct {
nsresult (*Enable)(IUSBCommon *USBCommon);
nsresult (*GetEnabled)(IUSBCommon *USBCommon, PRBool *enabled);
nsresult (*CreateDeviceFilter)(IUSBCommon *USBCommon, PRUnichar *name,
IUSBDeviceFilter **filter);
nsresult (*InsertDeviceFilter)(IUSBCommon *USBCommon, PRUint32 position,
IUSBDeviceFilter *filter);
} vboxUniformedIUSBCommon;
typedef struct {
nsresult (*GetProductId)(IUSBDeviceFilter *USBDeviceFilter, PRUnichar **productId);
nsresult (*SetProductId)(IUSBDeviceFilter *USBDeviceFilter, PRUnichar *productId);
nsresult (*GetActive)(IUSBDeviceFilter *USBDeviceFilter, PRBool *active);
nsresult (*SetActive)(IUSBDeviceFilter *USBDeviceFilter, PRBool active);
nsresult (*GetVendorId)(IUSBDeviceFilter *USBDeviceFilter, PRUnichar **vendorId);
nsresult (*SetVendorId)(IUSBDeviceFilter *USBDeviceFilter, PRUnichar *vendorId);
} vboxUniformedIUSBDeviceFilter;
/* Functions for IMedium */
typedef struct {
nsresult (*GetId)(IMedium *medium, vboxIID *iid);
nsresult (*GetLocation)(IMedium *medium, PRUnichar **location);
nsresult (*GetState)(IMedium *medium, PRUint32 *state);
nsresult (*GetName)(IMedium *medium, PRUnichar **name);
nsresult (*GetSize)(IMedium *medium, PRUint64 *uSize);
nsresult (*GetReadOnly)(IMedium *medium, PRBool *readOnly);
nsresult (*GetParent)(IMedium *medium, IMedium **parent);
nsresult (*GetChildren)(IMedium *medium, PRUint32 *childrenSize,
IMedium ***children);
nsresult (*GetFormat)(IMedium *medium, PRUnichar **format);
nsresult (*DeleteStorage)(IMedium *medium, IProgress **progress);
nsresult (*Release)(IMedium *medium);
nsresult (*Close)(IMedium *medium);
nsresult (*SetType)(IMedium *medium, PRUint32 type);
nsresult (*CreateDiffStorage)(IMedium *medium, IMedium *target,
PRUint32 variantSize, PRUint32 *variant,
IProgress **progress);
nsresult (*CreateBaseStorage)(IMedium *medium, PRUint64 logicalSize,
PRUint32 variant, IProgress **progress);
nsresult (*GetLogicalSize)(IMedium *medium, PRUint64 *uLogicalSize);
} vboxUniformedIMedium;
/* Functions for IMediumAttachment */
typedef struct {
nsresult (*GetMedium)(IMediumAttachment *mediumAttachment, IMedium **medium);
nsresult (*GetController)(IMediumAttachment *mediumAttachment, PRUnichar **controller);
nsresult (*GetType)(IMediumAttachment *mediumAttachment, PRUint32 *type);
nsresult (*GetPort)(IMediumAttachment *mediumAttachment, PRInt32 *port);
nsresult (*GetDevice)(IMediumAttachment *mediumAttachment, PRInt32 *device);
} vboxUniformedIMediumAttachment;
/* Functions for IStorageController */
typedef struct {
nsresult (*GetBus)(IStorageController *storageController, PRUint32 *bus);
nsresult (*SetControllerType)(IStorageController *storageController, PRUint32 controllerType);
nsresult (*GetControllerType)(IStorageController *storageController, PRUint32 *controllerType);
} vboxUniformedIStorageController;
/* Functions for ISharedFolder */
typedef struct {
nsresult (*GetHostPath)(ISharedFolder *sharedFolder, PRUnichar **hostPath);
nsresult (*GetName)(ISharedFolder *sharedFolder, PRUnichar **name);
nsresult (*GetWritable)(ISharedFolder *sharedFolder, PRBool *writable);
} vboxUniformedISharedFolder;
/* Functions for ISnapshot */
typedef struct {
nsresult (*GetName)(ISnapshot *snapshot, PRUnichar **name);
nsresult (*GetId)(ISnapshot *snapshot, vboxIID *iid);
nsresult (*GetMachine)(ISnapshot *snapshot, IMachine **machine);
nsresult (*GetDescription)(ISnapshot *snapshot, PRUnichar **description);
nsresult (*GetTimeStamp)(ISnapshot *snapshot, PRInt64 *timeStamp);
nsresult (*GetParent)(ISnapshot *snapshot, ISnapshot **parent);
nsresult (*GetOnline)(ISnapshot *snapshot, PRBool *online);
} vboxUniformedISnapshot;
/* Functions for IDisplay */
typedef struct {
nsresult (*GetScreenResolution)(IDisplay *display,
PRUint32 screenId,
PRUint32 *width,
PRUint32 *height,
PRUint32 *bitsPerPixel,
PRInt32 *xOrigin,
PRInt32 *yOrigin);
nsresult (*TakeScreenShotPNGToArray)(IDisplay *display,
PRUint32 screenId,
PRUint32 width,
PRUint32 height,
PRUint32 *screenDataSize,
PRUint8** screenData);
} vboxUniformedIDisplay;
/* Functions for IHost */
typedef struct {
nsresult (*FindHostNetworkInterfaceById)(IHost *host, vboxIID *iid,
IHostNetworkInterface **networkInterface);
nsresult (*FindHostNetworkInterfaceByName)(IHost *host, PRUnichar *name,
IHostNetworkInterface **networkInterface);
nsresult (*CreateHostOnlyNetworkInterface)(vboxDriverPtr driver,
IHost *host, char *name,
IHostNetworkInterface **networkInterface);
nsresult (*RemoveHostOnlyNetworkInterface)(IHost *host, vboxIID *iid,
IProgress **progress);
} vboxUniformedIHost;
/* Functions for IHostNetworkInterface */
typedef struct {
nsresult (*GetInterfaceType)(IHostNetworkInterface *hni, PRUint32 *interfaceType);
nsresult (*GetStatus)(IHostNetworkInterface *hni, PRUint32 *status);
nsresult (*GetName)(IHostNetworkInterface *hni, PRUnichar **name);
nsresult (*GetId)(IHostNetworkInterface *hni, vboxIID *iid);
nsresult (*GetHardwareAddress)(IHostNetworkInterface *hni, PRUnichar **hardwareAddress);
nsresult (*GetIPAddress)(IHostNetworkInterface *hni, PRUnichar **IPAddress);
nsresult (*GetNetworkMask)(IHostNetworkInterface *hni, PRUnichar **networkMask);
nsresult (*EnableStaticIPConfig)(IHostNetworkInterface *hni, PRUnichar *IPAddress,
PRUnichar *networkMask);
nsresult (*EnableDynamicIPConfig)(IHostNetworkInterface *hni);
nsresult (*DHCPRediscover)(IHostNetworkInterface *hni);
} vboxUniformedIHNInterface;
/* Functions for IDHCPServer */
typedef struct {
nsresult (*GetIPAddress)(IDHCPServer *dhcpServer, PRUnichar **IPAddress);
nsresult (*GetNetworkMask)(IDHCPServer *dhcpServer, PRUnichar **networkMask);
nsresult (*GetLowerIP)(IDHCPServer *dhcpServer, PRUnichar **lowerIP);
nsresult (*GetUpperIP)(IDHCPServer *dhcpServer, PRUnichar **upperIP);
nsresult (*SetEnabled)(IDHCPServer *dhcpServer, PRBool enabled);
nsresult (*SetConfiguration)(IDHCPServer *dhcpServer, PRUnichar *IPAddress,
PRUnichar *networkMask, PRUnichar *FromIPAddress,
PRUnichar *ToIPAddress);
nsresult (*Start)(IDHCPServer *dhcpServer, PRUnichar *networkName,
PRUnichar *trunkName, PRUnichar *trunkType);
nsresult (*Stop)(IDHCPServer *dhcpServer);
} vboxUniformedIDHCPServer;
typedef struct {
nsresult (*PutScancode)(IKeyboard *keyboard, PRInt32 scancode);
nsresult (*PutScancodes)(IKeyboard *keyboard, PRUint32 scancodesSize,
PRInt32 *scanCodes, PRUint32 *codesStored);
} vboxUniformedIKeyboard;
typedef struct {
bool (*Online)(PRUint32 state);
bool (*Inactive)(PRUint32 state);
bool (*NotStart)(PRUint32 state);
bool (*Running)(PRUint32 state);
bool (*Paused)(PRUint32 state);
bool (*PoweredOff)(PRUint32 state);
} uniformedMachineStateChecker;
typedef struct {
/* vbox API version */
uint32_t APIVersion;
uint32_t XPCOMCVersion;
/* vbox APIs */
nsresult (*unregisterMachine)(vboxDriverPtr driver, vboxIID *iid, IMachine **machine);
void (*deleteConfig)(IMachine *machine);
void (*vboxAttachDrivesOld)(virDomainDefPtr def, vboxDriverPtr driver, IMachine *machine);
virDomainState (*vboxConvertState)(PRUint32 state);
int (*snapshotRestore)(virDomainPtr dom, IMachine *machine, ISnapshot *snapshot);
vboxUniformedPFN UPFN;
vboxUniformedIID UIID;
vboxUniformedArray UArray;
vboxUniformednsISupports nsUISupports;
vboxUniformedIVirtualBox UIVirtualBox;
vboxUniformedIMachine UIMachine;
vboxUniformedISession UISession;
vboxUniformedIConsole UIConsole;
vboxUniformedIProgress UIProgress;
vboxUniformedISystemProperties UISystemProperties;
vboxUniformedIBIOSSettings UIBIOSSettings;
vboxUniformedIAudioAdapter UIAudioAdapter;
vboxUniformedINetworkAdapter UINetworkAdapter;
vboxUniformedISerialPort UISerialPort;
vboxUniformedIParallelPort UIParallelPort;
vboxUniformedIVRDEServer UIVRDEServer;
vboxUniformedIUSBCommon UIUSBCommon;
vboxUniformedIUSBDeviceFilter UIUSBDeviceFilter;
vboxUniformedIMedium UIMedium;
vboxUniformedIMediumAttachment UIMediumAttachment;
vboxUniformedIStorageController UIStorageController;
vboxUniformedISharedFolder UISharedFolder;
vboxUniformedISnapshot UISnapshot;
vboxUniformedIDisplay UIDisplay;
vboxUniformedIHost UIHost;
vboxUniformedIHNInterface UIHNInterface;
vboxUniformedIDHCPServer UIDHCPServer;
vboxUniformedIKeyboard UIKeyboard;
uniformedMachineStateChecker machineStateChecker;
/* vbox API features */
bool chipsetType;
bool vboxSnapshotRedefine;
} vboxUniformedAPI;
virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn,
const unsigned char *uuid);
/* Version specified functions for installing uniformed API */
void vbox52InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI);
void vbox60InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI);
void vbox61InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI);
Reference in New Issue View Git Blame Copy Permalink