External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-01-03 11:35:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

vbox: Rewrite vboxNetworkUndefineDestroy

Browse Source 
This patch rewrites two public APIs. They are vboxNetworkUndefine
and vboxNetworkDestroy. They use the same core function
vboxNetworkUndefineDestroy. I merged it in one patch.
This commit is contained in:
Taowei 2014-10-02 11:30:35 +08:00 committed by Michal Privoznik
parent e8d999ada9
commit 1f8b9882f1
4 changed files with 157 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
po/POTFILES.in
View File

@ -220,6 +220,7 @@ src/vbox/vbox_MSCOMGlue.c
src/vbox/vbox_XPCOMCGlue.c
src/vbox/vbox_driver.c
src/vbox/vbox_common.c
src/vbox/vbox_network.c
src/vbox/vbox_snapshot_conf.c
src/vbox/vbox_tmpl.c
src/vmware/vmware_conf.c

109
src/vbox/vbox_network.c
View File

@ -36,6 +36,9 @@
VIR_LOG_INIT("vbox.vbox_network");
#define RC_SUCCEEDED(rc) NS_SUCCEEDED(rc.resultCode)
#define RC_FAILED(rc) NS_FAILED(rc.resultCode)
#define VBOX_UTF16_FREE(arg) \
do { \
if (arg) { \
@ -627,3 +630,109 @@ virNetworkPtr vboxNetworkDefineXML(virConnectPtr conn, const char *xml)
{
return vboxNetworkDefineCreateXML(conn, xml, false);
}
static int
vboxNetworkUndefineDestroy(virNetworkPtr network, bool removeinterface)
{
vboxGlobalData *data = network->conn->privateData;
char *networkNameUtf8 = NULL;
PRUnichar *networkInterfaceNameUtf16 = NULL;
IHostNetworkInterface *networkInterface = NULL;
PRUnichar *networkNameUtf16 = NULL;
IDHCPServer *dhcpServer = NULL;
PRUint32 interfaceType = 0;
IHost *host = NULL;
int ret = -1;
if (!data->vboxObj)
return ret;
gVBoxAPI.UIVirtualBox.GetHost(data->vboxObj, &host);
if (!host)
return ret;
/* Current limitation of the function for VirtualBox 2.2.* is
* that you can't delete the default hostonly adaptor namely:
* vboxnet0 and thus all this functions does is remove the
* dhcp server configuration, but the network can still be used
* by giving the machine static IP and also it will still
* show up in the net-list in virsh
*/
if (virAsprintf(&networkNameUtf8, "HostInterfaceNetworking-%s", network->name) < 0)
goto cleanup;
VBOX_UTF8_TO_UTF16(network->name, &networkInterfaceNameUtf16);
gVBoxAPI.UIHost.FindHostNetworkInterfaceByName(host, networkInterfaceNameUtf16, &networkInterface);
if (!networkInterface)
goto cleanup;
gVBoxAPI.UIHNInterface.GetInterfaceType(networkInterface, &interfaceType);
if (interfaceType != HostNetworkInterfaceType_HostOnly)
goto cleanup;
if (gVBoxAPI.networkRemoveInterface && removeinterface) {
vboxIIDUnion iid;
IProgress *progress = NULL;
nsresult rc;
resultCodeUnion resultCode;
VBOX_IID_INITIALIZE(&iid);
rc = gVBoxAPI.UIHNInterface.GetId(networkInterface, &iid);
if (NS_FAILED(rc))
goto cleanup;
gVBoxAPI.UIHost.RemoveHostOnlyNetworkInterface(host, &iid, &progress);
vboxIIDUnalloc(&iid);
if (!progress)
goto cleanup;
gVBoxAPI.UIProgress.WaitForCompletion(progress, -1);
gVBoxAPI.UIProgress.GetResultCode(progress, &resultCode);
if (RC_FAILED(resultCode)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Error while removing hostonly network interface, rc=%08x"),
resultCode.uResultCode);
goto cleanup;
}
VBOX_RELEASE(progress);
}
VBOX_UTF8_TO_UTF16(networkNameUtf8, &networkNameUtf16);
gVBoxAPI.UIVirtualBox.FindDHCPServerByNetworkName(data->vboxObj,
networkNameUtf16,
&dhcpServer);
if (!dhcpServer)
goto cleanup;
gVBoxAPI.UIDHCPServer.SetEnabled(dhcpServer, PR_FALSE);
gVBoxAPI.UIDHCPServer.Stop(dhcpServer);
if (removeinterface)
gVBoxAPI.UIVirtualBox.RemoveDHCPServer(data->vboxObj, dhcpServer);
ret = 0;
VBOX_RELEASE(dhcpServer);
cleanup:
VBOX_UTF16_FREE(networkNameUtf16);
VBOX_RELEASE(networkInterface);
VBOX_UTF16_FREE(networkInterfaceNameUtf16);
VBOX_RELEASE(host);
VIR_FREE(networkNameUtf8);
return ret;
}
int vboxNetworkUndefine(virNetworkPtr network)
{
return vboxNetworkUndefineDestroy(network, true);
}
int vboxNetworkDestroy(virNetworkPtr network)
{
return vboxNetworkUndefineDestroy(network, false);
}

136
src/vbox/vbox_tmpl.c
View File

@ -2042,97 +2042,6 @@ _registerDomainEvent(virDriverPtr driver)
* The Network Functions here on
*/
static int
vboxNetworkUndefineDestroy(virNetworkPtr network, bool removeinterface)
{
VBOX_OBJECT_HOST_CHECK(network->conn, int, -1);
char *networkNameUtf8 = NULL;
PRUnichar *networkInterfaceNameUtf16 = NULL;
IHostNetworkInterface *networkInterface = NULL;
/* Current limitation of the function for VirtualBox 2.2.* is
* that you can't delete the default hostonly adaptor namely:
* vboxnet0 and thus all this functions does is remove the
* dhcp server configuration, but the network can still be used
* by giving the machine static IP and also it will still
* show up in the net-list in virsh
*/
if (virAsprintf(&networkNameUtf8, "HostInterfaceNetworking-%s", network->name) < 0)
goto cleanup;
VBOX_UTF8_TO_UTF16(network->name, &networkInterfaceNameUtf16);
host->vtbl->FindHostNetworkInterfaceByName(host, networkInterfaceNameUtf16, &networkInterface);
if (networkInterface) {
PRUint32 interfaceType = 0;
networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
if (interfaceType == HostNetworkInterfaceType_HostOnly) {
PRUnichar *networkNameUtf16 = NULL;
IDHCPServer *dhcpServer = NULL;
#if VBOX_API_VERSION != 2002000
if (removeinterface) {
PRUnichar *iidUtf16 = NULL;
IProgress *progress = NULL;
networkInterface->vtbl->GetId(networkInterface, &iidUtf16);
if (iidUtf16) {
# if VBOX_API_VERSION == 3000000
IHostNetworkInterface *netInt = NULL;
host->vtbl->RemoveHostOnlyNetworkInterface(host, iidUtf16, &netInt, &progress);
VBOX_RELEASE(netInt);
# else /* VBOX_API_VERSION > 3000000 */
host->vtbl->RemoveHostOnlyNetworkInterface(host, iidUtf16, &progress);
# endif /* VBOX_API_VERSION > 3000000 */
VBOX_UTF16_FREE(iidUtf16);
}
if (progress) {
progress->vtbl->WaitForCompletion(progress, -1);
VBOX_RELEASE(progress);
}
}
#endif /* VBOX_API_VERSION != 2002000 */
VBOX_UTF8_TO_UTF16(networkNameUtf8, &networkNameUtf16);
data->vboxObj->vtbl->FindDHCPServerByNetworkName(data->vboxObj,
networkNameUtf16,
&dhcpServer);
if (dhcpServer) {
dhcpServer->vtbl->SetEnabled(dhcpServer, PR_FALSE);
dhcpServer->vtbl->Stop(dhcpServer);
if (removeinterface)
data->vboxObj->vtbl->RemoveDHCPServer(data->vboxObj, dhcpServer);
VBOX_RELEASE(dhcpServer);
}
VBOX_UTF16_FREE(networkNameUtf16);
}
VBOX_RELEASE(networkInterface);
}
VBOX_UTF16_FREE(networkInterfaceNameUtf16);
VBOX_RELEASE(host);
ret = 0;
cleanup:
VIR_FREE(networkNameUtf8);
return ret;
}
static int vboxNetworkUndefine(virNetworkPtr network)
{
return vboxNetworkUndefineDestroy(network, true);
}
static int vboxNetworkCreate(virNetworkPtr network)
{
VBOX_OBJECT_HOST_CHECK(network->conn, int, -1);
@ -2201,11 +2110,6 @@ static int vboxNetworkCreate(virNetworkPtr network)
return ret;
}
static int vboxNetworkDestroy(virNetworkPtr network)
{
return vboxNetworkUndefineDestroy(network, false);
}
static char *vboxNetworkGetXMLDesc(virNetworkPtr network,
unsigned int flags)
{
@ -4221,6 +4125,12 @@ _virtualboxCreateDHCPServer(IVirtualBox *vboxObj, PRUnichar *name, IDHCPServer *
return vboxObj->vtbl->CreateDHCPServer(vboxObj, name, server);
}
static nsresult
_virtualboxRemoveDHCPServer(IVirtualBox *vboxObj, IDHCPServer *server)
{
return vboxObj->vtbl->RemoveDHCPServer(vboxObj, server);
}
static nsresult
_machineAddStorageController(IMachine *machine, PRUnichar *name,
PRUint32 connectionType,
@ -5641,6 +5551,25 @@ _hostCreateHostOnlyNetworkInterface(vboxGlobalData *data ATTRIBUTE_UNUSED,
return rc;
}
static nsresult
_hostRemoveHostOnlyNetworkInterface(IHost *host ATTRIBUTE_UNUSED,
vboxIIDUnion *iidu ATTRIBUTE_UNUSED,
IProgress **progress ATTRIBUTE_UNUSED)
{
#if VBOX_API_VERSION == 2002000
vboxUnsupported();
return 0;
#elif VBOX_API_VERSION == 3000000
nsresult rc;
IHostNetworkInterface *netInt = NULL;
rc = host->vtbl->RemoveHostOnlyNetworkInterface(host, IID_MEMBER(value), &netInt, progress);
VBOX_RELEASE(netInt);
return rc;
#else /* VBOX_API_VERSION > 3000000 */
return host->vtbl->RemoveHostOnlyNetworkInterface(host, IID_MEMBER(value), progress);
#endif /* VBOX_API_VERSION > 3000000 */
}
static nsresult
_hnInterfaceGetInterfaceType(IHostNetworkInterface *hni, PRUint32 *interfaceType)
{
@ -5720,6 +5649,12 @@ _dhcpServerStart(IDHCPServer *dhcpServer, PRUnichar *networkName,
trunkName, trunkType);
}
static nsresult
_dhcpServerStop(IDHCPServer *dhcpServer)
{
return dhcpServer->vtbl->Stop(dhcpServer);
}
static bool _machineStateOnline(PRUint32 state)
{
return ((state >= MachineState_FirstOnline) &&
@ -5807,6 +5742,7 @@ static vboxUniformedIVirtualBox _UIVirtualBox = {
.OpenMedium = _virtualboxOpenMedium,
.FindDHCPServerByNetworkName = _virtualboxFindDHCPServerByNetworkName,
.CreateDHCPServer = _virtualboxCreateDHCPServer,
.RemoveDHCPServer = _virtualboxRemoveDHCPServer,
};
static vboxUniformedIMachine _UIMachine = {
@ -6029,6 +5965,7 @@ static vboxUniformedIHost _UIHost = {
.FindHostNetworkInterfaceById = _hostFindHostNetworkInterfaceById,
.FindHostNetworkInterfaceByName = _hostFindHostNetworkInterfaceByName,
.CreateHostOnlyNetworkInterface = _hostCreateHostOnlyNetworkInterface,
.RemoveHostOnlyNetworkInterface = _hostRemoveHostOnlyNetworkInterface,
};
static vboxUniformedIHNInterface _UIHNInterface = {
@ -6045,6 +5982,7 @@ static vboxUniformedIDHCPServer _UIDHCPServer = {
.SetEnabled = _dhcpServerSetEnabled,
.SetConfiguration = _dhcpServerSetConfiguration,
.Start = _dhcpServerStart,
.Stop = _dhcpServerStop,
};
static uniformedMachineStateChecker _machineStateChecker = {
@ -6149,6 +6087,12 @@ void NAME(InstallUniformedAPI)(vboxUniformedAPI *pVBoxAPI)
#else /* VBOX_API_VERSION < 4002000 */
pVBoxAPI->vboxSnapshotRedefine = 0;
#endif /* VBOX_API_VERSION < 4002000 */
#if VBOX_API_VERSION == 2002000
pVBoxAPI->networkRemoveInterface = 0;
#else /* VBOX_API_VERSION > 2002000 */
pVBoxAPI->networkRemoveInterface = 1;
#endif /* VBOX_API_VERSION > 2002000 */
}
/**

7
src/vbox/vbox_uniformed_api.h
View File

@ -199,6 +199,7 @@ typedef struct {
nsresult (*OpenMedium)(IVirtualBox *vboxObj, PRUnichar *location, PRUint32 deviceType, PRUint32 accessMode, 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 */
@ -477,6 +478,8 @@ typedef struct {
nsresult (*CreateHostOnlyNetworkInterface)(vboxGlobalData *data,
IHost *host, char *name,
IHostNetworkInterface **networkInterface);
nsresult (*RemoveHostOnlyNetworkInterface)(IHost *host, vboxIIDUnion *iidu,
IProgress **progress);
} vboxUniformedIHost;
/* Functions for IHostNetworkInterface */
@ -499,6 +502,7 @@ typedef struct {
PRUnichar *ToIPAddress);
nsresult (*Start)(IDHCPServer *dhcpServer, PRUnichar *networkName,
PRUnichar *trunkName, PRUnichar *trunkType);
nsresult (*Stop)(IDHCPServer *dhcpServer);
} vboxUniformedIDHCPServer;
typedef struct {
@ -570,6 +574,7 @@ typedef struct {
bool oldMediumInterface;
bool vboxSnapshotRedefine;
bool supportScreenshot;
bool networkRemoveInterface;
} vboxUniformedAPI;
virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn,
@ -586,6 +591,8 @@ virNetworkPtr vboxNetworkLookupByUUID(virConnectPtr conn, const unsigned char *u
virNetworkPtr vboxNetworkLookupByName(virConnectPtr conn, const char *name);
virNetworkPtr vboxNetworkCreateXML(virConnectPtr conn, const char *xml);
virNetworkPtr vboxNetworkDefineXML(virConnectPtr conn, const char *xml);
int vboxNetworkUndefine(virNetworkPtr network);
int vboxNetworkDestroy(virNetworkPtr network);
/* Version specified functions for installing uniformed API */
void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI);