HostNetworkInterfaceImpl.cpp@ 73164

Last change on this file since 73164 was 72973, checked in by vboxsync, 6 years ago
Main: Some early sketches on how to get proper C++ enums with xpidl.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.2 KB

Line
1	/* $Id: HostNetworkInterfaceImpl.cpp 72973 2018-07-08 13:23:58Z vboxsync $ */
2
3	/** @file
4	*
5	* VirtualBox COM class implementation
6	*/
7
8	/*
9	* Copyright (C) 2006-2017 Oracle Corporation
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*/
19	#include "HostNetworkInterfaceImpl.h"
20	#include "AutoCaller.h"
21	#include "Logging.h"
22	#include "netif.h"
23	#ifdef VBOX_WITH_RESOURCE_USAGE_API
24	# include "Performance.h"
25	# include "PerformanceImpl.h"
26	#endif
27
28	#include <iprt/cpp/utils.h>
29
30	#ifdef RT_OS_FREEBSD
31	# include <netinet/in.h> /* INADDR_NONE */
32	#endif /* RT_OS_FREEBSD */
33
34	#include "VirtualBoxImpl.h"
35
36	// constructor / destructor
37	/////////////////////////////////////////////////////////////////////////////
38
39	HostNetworkInterface::HostNetworkInterface()
40	: mVirtualBox(NULL)
41	{
42	}
43
44	HostNetworkInterface::~HostNetworkInterface()
45	{
46	}
47
48	HRESULT HostNetworkInterface::FinalConstruct()
49	{
50	return BaseFinalConstruct();
51	}
52
53	void HostNetworkInterface::FinalRelease()
54	{
55	uninit();
56	BaseFinalRelease();
57	}
58
59	// public initializer/uninitializer for internal purposes only
60	/////////////////////////////////////////////////////////////////////////////
61
62	/**
63	* Initializes the host object.
64	*
65	* @returns COM result indicator
66	* @param aInterfaceName name of the network interface
67	* @param aShortName short name of the network interface
68	* @param aGuid GUID of the host network interface
69	* @param ifType interface type
70	*/
71	HRESULT HostNetworkInterface::init(Bstr aInterfaceName, Bstr aShortName, Guid aGuid, HostNetworkInterfaceType_T ifType)
72	{
73	LogFlowThisFunc(("aInterfaceName={%ls}, aGuid={%s}\n",
74	aInterfaceName.raw(), aGuid.toString().c_str()));
75
76	ComAssertRet(!aInterfaceName.isEmpty(), E_INVALIDARG);
77	ComAssertRet(aGuid.isValid(), E_INVALIDARG);
78
79	/* Enclose the state transition NotReady->InInit->Ready */
80	AutoInitSpan autoInitSpan(this);
81	AssertReturn(autoInitSpan.isOk(), E_FAIL);
82
83	unconst(mInterfaceName) = aInterfaceName;
84	unconst(mNetworkName) = i_composeNetworkName(aShortName);
85	unconst(mShortName) = aShortName;
86	unconst(mGuid) = aGuid;
87	mIfType = ifType;
88
89	/* Confirm a successful initialization */
90	autoInitSpan.setSucceeded();
91
92	return S_OK;
93	}
94
95	#ifdef VBOX_WITH_RESOURCE_USAGE_API
96
97	void HostNetworkInterface::i_registerMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
98	{
99	LogFlowThisFunc(("mShortName={%ls}, mInterfaceName={%ls}, mGuid={%s}, mSpeedMbits=%u\n",
100	mShortName.raw(), mInterfaceName.raw(), mGuid.toString().c_str(), m.speedMbits));
101	pm::CollectorHAL *hal = aCollector->getHAL();
102	/* Create sub metrics */
103	Utf8StrFmt strName("Net/%ls", mShortName.raw());
104	pm::SubMetric *networkLoadRx = new pm::SubMetric(strName + "/Load/Rx",
105	"Percentage of network interface receive bandwidth used.");
106	pm::SubMetric *networkLoadTx = new pm::SubMetric(strName + "/Load/Tx",
107	"Percentage of network interface transmit bandwidth used.");
108	pm::SubMetric *networkLinkSpeed = new pm::SubMetric(strName + "/LinkSpeed",
109	"Physical link speed.");
110
111	/* Create and register base metrics */
112	pm::BaseMetric *networkSpeed = new pm::HostNetworkSpeed(hal, objptr, strName + "/LinkSpeed",
113	Utf8Str(mShortName), Utf8Str(mInterfaceName),
114	m.speedMbits, networkLinkSpeed);
115	aCollector->registerBaseMetric(networkSpeed);
116	pm::BaseMetric *networkLoad = new pm::HostNetworkLoadRaw(hal, objptr, strName + "/Load",
117	Utf8Str(mShortName), Utf8Str(mInterfaceName),
118	m.speedMbits, networkLoadRx, networkLoadTx);
119	aCollector->registerBaseMetric(networkLoad);
120
121	aCollector->registerMetric(new pm::Metric(networkSpeed, networkLinkSpeed, 0));
122	aCollector->registerMetric(new pm::Metric(networkSpeed, networkLinkSpeed,
123	new pm::AggregateAvg()));
124	aCollector->registerMetric(new pm::Metric(networkSpeed, networkLinkSpeed,
125	new pm::AggregateMin()));
126	aCollector->registerMetric(new pm::Metric(networkSpeed, networkLinkSpeed,
127	new pm::AggregateMax()));
128
129	aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx, 0));
130	aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
131	new pm::AggregateAvg()));
132	aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
133	new pm::AggregateMin()));
134	aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadRx,
135	new pm::AggregateMax()));
136
137	aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx, 0));
138	aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
139	new pm::AggregateAvg()));
140	aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
141	new pm::AggregateMin()));
142	aCollector->registerMetric(new pm::Metric(networkLoad, networkLoadTx,
143	new pm::AggregateMax()));
144	}
145
146	void HostNetworkInterface::i_unregisterMetrics(PerformanceCollector *aCollector, ComPtr<IUnknown> objptr)
147	{
148	LogFlowThisFunc(("mShortName={%ls}, mInterfaceName={%ls}, mGuid={%s}\n",
149	mShortName.raw(), mInterfaceName.raw(), mGuid.toString().c_str()));
150	Utf8StrFmt name("Net/%ls", mShortName.raw());
151	aCollector->unregisterMetricsFor(objptr, name + "/*");
152	aCollector->unregisterBaseMetricsFor(objptr, name);
153	}
154
155	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
156
157	#ifdef VBOX_WITH_HOSTNETIF_API
158
159	HRESULT HostNetworkInterface::updateConfig()
160	{
161	NETIFINFO info;
162	int rc = NetIfGetConfig(this, &info);
163	if (RT_SUCCESS(rc))
164	{
165	int iPrefixIPv6;
166
167	m.realIPAddress = m.IPAddress = info.IPAddress.u;
168	m.realNetworkMask = m.networkMask = info.IPNetMask.u;
169	m.dhcpEnabled = info.fDhcpEnabled;
170	if (info.IPv6Address.s.Lo \|\| info.IPv6Address.s.Hi)
171	m.realIPV6Address = m.IPV6Address = Bstr(Utf8StrFmt("%RTnaipv6", &info.IPv6Address));
172	else
173	m.realIPV6Address = m.IPV6Address = Bstr("");
174	RTNetMaskToPrefixIPv6(&info.IPv6NetMask, &iPrefixIPv6);
175	m.realIPV6PrefixLength = m.IPV6NetworkMaskPrefixLength = iPrefixIPv6;
176	m.hardwareAddress = Bstr(Utf8StrFmt("%RTmac", &info.MACAddress));
177	AssertCompile((unsigned)NETIF_T_UNKNOWN == (unsigned)HostNetworkInterfaceMediumType_Unknown);
178	m.mediumType = (HostNetworkInterfaceMediumType_T)info.enmMediumType;
179	AssertCompile((unsigned)NETIF_S_UNKNOWN == (unsigned)HostNetworkInterfaceStatus_Unknown);
180	m.status = (HostNetworkInterfaceStatus_T)info.enmStatus;
181	m.speedMbits = info.uSpeedMbits;
182	m.wireless = info.fWireless;
183	return S_OK;
184	}
185	return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
186	}
187
188	Bstr HostNetworkInterface::i_composeNetworkName(const Utf8Str aShortName)
189	{
190	return Utf8Str("HostInterfaceNetworking-").append(aShortName);
191	}
192	/**
193	* Initializes the host object.
194	*
195	* @returns COM result indicator
196	* @param aInterfaceName name of the network interface
197	* @param aGuid GUID of the host network interface
198	*/
199	HRESULT HostNetworkInterface::init(Bstr aInterfaceName, HostNetworkInterfaceType_T ifType, PNETIFINFO pIf)
200	{
201	// LogFlowThisFunc(("aInterfaceName={%ls}, aGuid={%s}\n",
202	// aInterfaceName.raw(), aGuid.toString().raw()));
203
204	// ComAssertRet(aInterfaceName, E_INVALIDARG);
205	// ComAssertRet(aGuid.isValid(), E_INVALIDARG);
206	ComAssertRet(pIf, E_INVALIDARG);
207
208	/* Enclose the state transition NotReady->InInit->Ready */
209	AutoInitSpan autoInitSpan(this);
210	AssertReturn(autoInitSpan.isOk(), E_FAIL);
211
212	unconst(mInterfaceName) = aInterfaceName;
213	unconst(mGuid) = pIf->Uuid;
214	if (pIf->szShortName[0])
215	{
216	unconst(mNetworkName) = i_composeNetworkName(pIf->szShortName);
217	unconst(mShortName) = pIf->szShortName;
218	}
219	else
220	{
221	unconst(mNetworkName) = i_composeNetworkName(aInterfaceName);
222	unconst(mShortName) = aInterfaceName;
223	}
224	mIfType = ifType;
225
226	int iPrefixIPv6;
227
228	m.realIPAddress = m.IPAddress = pIf->IPAddress.u;
229	m.realNetworkMask = m.networkMask = pIf->IPNetMask.u;
230	if (pIf->IPv6Address.s.Lo \|\| pIf->IPv6Address.s.Hi)
231	m.realIPV6Address = m.IPV6Address = Bstr(Utf8StrFmt("%RTnaipv6", &pIf->IPv6Address));
232	else
233	m.realIPV6Address = m.IPV6Address = Bstr("");
234	RTNetMaskToPrefixIPv6(&pIf->IPv6NetMask, &iPrefixIPv6);
235	m.realIPV6PrefixLength = m.IPV6NetworkMaskPrefixLength = iPrefixIPv6;
236	m.dhcpEnabled = pIf->fDhcpEnabled;
237	m.hardwareAddress = Bstr(Utf8StrFmt("%RTmac", &pIf->MACAddress));
238	AssertCompile((unsigned)NETIF_T_UNKNOWN == (unsigned)HostNetworkInterfaceMediumType_Unknown);
239	m.mediumType = (HostNetworkInterfaceMediumType_T)pIf->enmMediumType;
240	AssertCompile((unsigned)NETIF_S_UNKNOWN == (unsigned)HostNetworkInterfaceStatus_Unknown);
241	m.status = (HostNetworkInterfaceStatus_T)pIf->enmStatus;
242	m.speedMbits = pIf->uSpeedMbits;
243	m.wireless = pIf->fWireless;
244
245	/* Confirm a successful initialization */
246	autoInitSpan.setSucceeded();
247
248	return S_OK;
249	}
250	#endif
251
252	// wrapped IHostNetworkInterface properties
253	/////////////////////////////////////////////////////////////////////////////
254	/**
255	* Returns the name of the host network interface.
256	*
257	* @returns COM status code
258	* @param aInterfaceName - Interface Name
259	*/
260
261	HRESULT HostNetworkInterface::getName(com::Utf8Str &aInterfaceName)
262	{
263	aInterfaceName = mInterfaceName;
264	return S_OK;
265	}
266
267	/**
268	* Returns the short name of the host network interface.
269	*
270	* @returns COM status code
271	* @param aShortName Short Name
272	*/
273
274	HRESULT HostNetworkInterface::getShortName(com::Utf8Str &aShortName)
275	{
276	aShortName = mShortName;
277
278	return S_OK;
279	}
280
281	/**
282	* Returns the GUID of the host network interface.
283	*
284	* @returns COM status code
285	* @param aGuid GUID
286	*/
287	HRESULT HostNetworkInterface::getId(com::Guid &aGuid)
288	{
289	aGuid = mGuid;
290
291	return S_OK;
292	}
293
294	HRESULT HostNetworkInterface::getDHCPEnabled(BOOL *aDHCPEnabled)
295	{
296	*aDHCPEnabled = m.dhcpEnabled;
297
298	return S_OK;
299	}
300
301
302	/**
303	* Returns the IP address of the host network interface.
304	*
305	* @returns COM status code
306	* @param aIPAddress Address name
307	*/
308	HRESULT HostNetworkInterface::getIPAddress(com::Utf8Str &aIPAddress)
309	{
310	in_addr tmp;
311	#if defined(RT_OS_WINDOWS)
312	tmp.S_un.S_addr = m.IPAddress;
313	#else
314	tmp.s_addr = m.IPAddress;
315	#endif
316	char *addr = inet_ntoa(tmp);
317	if (addr)
318	{
319	aIPAddress = addr;
320	return S_OK;
321	}
322
323	return E_FAIL;
324	}
325
326	/**
327	* Returns the netwok mask of the host network interface.
328	*
329	* @returns COM status code
330	* @param aNetworkMask name.
331	*/
332	HRESULT HostNetworkInterface::getNetworkMask(com::Utf8Str &aNetworkMask)
333	{
334
335	in_addr tmp;
336	#if defined(RT_OS_WINDOWS)
337	tmp.S_un.S_addr = m.networkMask;
338	#else
339	tmp.s_addr = m.networkMask;
340	#endif
341	char *addr = inet_ntoa(tmp);
342	if (addr)
343	{
344	aNetworkMask = Utf8Str(addr);
345	return S_OK;
346	}
347
348	return E_FAIL;
349	}
350
351	HRESULT HostNetworkInterface::getIPV6Supported(BOOL *aIPV6Supported)
352	{
353	#if defined(RT_OS_WINDOWS)
354	*aIPV6Supported = FALSE;
355	#else
356	*aIPV6Supported = TRUE;
357	#endif
358
359	return S_OK;
360	}
361
362	/**
363	* Returns the IP V6 address of the host network interface.
364	*
365	* @returns COM status code
366	* @param aIPV6Address
367	*/
368	HRESULT HostNetworkInterface::getIPV6Address(com::Utf8Str &aIPV6Address)
369	{
370	aIPV6Address = m.IPV6Address;
371	return S_OK;
372	}
373
374	/**
375	* Returns the IP V6 network mask prefix length of the host network interface.
376	*
377	* @returns COM status code
378	* @param aIPV6NetworkMaskPrefixLength address of result pointer
379	*/
380	HRESULT HostNetworkInterface::getIPV6NetworkMaskPrefixLength(ULONG *aIPV6NetworkMaskPrefixLength)
381	{
382	*aIPV6NetworkMaskPrefixLength = m.IPV6NetworkMaskPrefixLength;
383
384	return S_OK;
385	}
386
387	/**
388	* Returns the hardware address of the host network interface.
389	*
390	* @returns COM status code
391	* @param aHardwareAddress hardware address
392	*/
393	HRESULT HostNetworkInterface::getHardwareAddress(com::Utf8Str &aHardwareAddress)
394	{
395	aHardwareAddress = m.hardwareAddress;
396	return S_OK;
397	}
398
399	/**
400	* Returns the encapsulation protocol type of the host network interface.
401	*
402	* @returns COM status code
403	* @param aType address of result pointer
404	*/
405	HRESULT HostNetworkInterface::getMediumType(HostNetworkInterfaceMediumType_T *aType)
406	{
407	*aType = m.mediumType;
408
409	return S_OK;
410	}
411
412	/**
413	* Returns the current state of the host network interface.
414	*
415	* @returns COM status code
416	* @param aStatus address of result pointer
417	*/
418	HRESULT HostNetworkInterface::getStatus(HostNetworkInterfaceStatus_T *aStatus)
419	{
420	*aStatus = m.status;
421
422	return S_OK;
423	}
424
425	/**
426	* Returns network interface type
427	*
428	* @returns COM status code
429	* @param aType address of result pointer
430	*/
431	HRESULT HostNetworkInterface::getInterfaceType(HostNetworkInterfaceType_T *aType)
432	{
433	*aType = mIfType;
434
435	return S_OK;
436
437	}
438
439	HRESULT HostNetworkInterface::getNetworkName(com::Utf8Str &aNetworkName)
440	{
441	aNetworkName = mNetworkName;
442
443	return S_OK;
444	}
445
446	HRESULT HostNetworkInterface::getWireless(BOOL *aWireless)
447	{
448	*aWireless = m.wireless;
449
450	return S_OK;
451	}
452
453	HRESULT HostNetworkInterface::enableStaticIPConfig(const com::Utf8Str &aIPAddress,
454	const com::Utf8Str &aNetworkMask)
455	{
456	#ifndef VBOX_WITH_HOSTNETIF_API
457	return E_NOTIMPL;
458	#else
459	if (aIPAddress.isEmpty())
460	{
461	if (m.IPAddress)
462	{
463	int rc = NetIfEnableStaticIpConfig(mVirtualBox, this, m.IPAddress, 0, 0);
464	if (RT_SUCCESS(rc))
465	{
466	m.realIPAddress = 0;
467	if (FAILED(mVirtualBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress",
468	mInterfaceName.raw()).raw(), NULL)))
469	return E_FAIL;
470	if (FAILED(mVirtualBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask",
471	mInterfaceName.raw()).raw(), NULL)))
472	return E_FAIL;
473	return S_OK;
474	}
475	}
476	else
477	return S_OK;
478	}
479
480	ULONG ip, mask;
481	ip = inet_addr(aIPAddress.c_str());
482	if (ip != INADDR_NONE)
483	{
484	if (aNetworkMask.isEmpty())
485	mask = 0xFFFFFF;
486	else
487	mask = inet_addr(aNetworkMask.c_str());
488	if (mask != INADDR_NONE)
489	{
490	if (m.realIPAddress == ip && m.realNetworkMask == mask)
491	return S_OK;
492	int rc = NetIfEnableStaticIpConfig(mVirtualBox, this, m.IPAddress, ip, mask);
493	if (RT_SUCCESS(rc))
494	{
495	m.realIPAddress = ip;
496	m.realNetworkMask = mask;
497	if (FAILED(mVirtualBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress",
498	mInterfaceName.raw()).raw(),
499	Bstr(aIPAddress).raw())))
500	return E_FAIL;
501	if (FAILED(mVirtualBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask",
502	mInterfaceName.raw()).raw(),
503	Bstr(aNetworkMask).raw())))
504	return E_FAIL;
505	return S_OK;
506	}
507	else
508	{
509	LogRel(("Failed to EnableStaticIpConfig with rc=%Rrc\n", rc));
510	return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
511	}
512
513	}
514	}
515	return E_FAIL;
516	#endif
517	}
518
519	HRESULT HostNetworkInterface::enableStaticIPConfigV6(const com::Utf8Str &aIPV6Address,
520	ULONG aIPV6NetworkMaskPrefixLength)
521	{
522	#ifndef VBOX_WITH_HOSTNETIF_API
523	return E_NOTIMPL;
524	#else
525	if (aIPV6NetworkMaskPrefixLength > 128)
526	return mVirtualBox->setErrorBoth(E_INVALIDARG, VERR_INVALID_PARAMETER,
527	"Invalid IPv6 prefix length");
528
529	int rc;
530
531	RTNETADDRIPV6 AddrOld, AddrNew;
532	char *pszZoneIgnored;
533	bool fAddrChanged;
534
535	rc = RTNetStrToIPv6Addr(aIPV6Address.c_str(), &AddrNew, &pszZoneIgnored);
536	if (RT_FAILURE(rc))
537	{
538	return mVirtualBox->setErrorBoth(E_INVALIDARG, rc, "Invalid IPv6 address");
539	}
540
541	rc = RTNetStrToIPv6Addr(com::Utf8Str(m.realIPV6Address).c_str(), &AddrOld, &pszZoneIgnored);
542	if (RT_SUCCESS(rc))
543	{
544	fAddrChanged = (AddrNew.s.Lo != AddrOld.s.Lo \|\| AddrNew.s.Hi != AddrOld.s.Hi);
545	}
546	else
547	{
548	fAddrChanged = true;
549	}
550
551	if ( fAddrChanged
552	\|\| m.realIPV6PrefixLength != aIPV6NetworkMaskPrefixLength)
553	{
554	BSTR bstr;
555	aIPV6Address.cloneTo(&bstr);
556	if (aIPV6NetworkMaskPrefixLength == 0)
557	aIPV6NetworkMaskPrefixLength = 64;
558	rc = NetIfEnableStaticIpConfigV6(mVirtualBox, this, m.IPV6Address.raw(),
559	bstr, aIPV6NetworkMaskPrefixLength);
560	if (RT_FAILURE(rc))
561	{
562	LogRel(("Failed to EnableStaticIpConfigV6 with rc=%Rrc\n", rc));
563	return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
564	}
565	else
566	{
567	m.realIPV6Address = aIPV6Address;
568	m.realIPV6PrefixLength = aIPV6NetworkMaskPrefixLength;
569	if (FAILED(mVirtualBox->SetExtraData(BstrFmt("HostOnly/%ls/IPV6Address",
570	mInterfaceName.raw()).raw(),
571	Bstr(aIPV6Address).raw())))
572	return E_FAIL;
573	if (FAILED(mVirtualBox->SetExtraData(BstrFmt("HostOnly/%ls/IPV6NetMask",
574	mInterfaceName.raw()).raw(),
575	BstrFmt("%u", aIPV6NetworkMaskPrefixLength).raw())))
576	return E_FAIL;
577	}
578
579	}
580	return S_OK;
581	#endif
582	}
583
584	HRESULT HostNetworkInterface::enableDynamicIPConfig()
585	{
586	#ifndef VBOX_WITH_HOSTNETIF_API
587	return E_NOTIMPL;
588	#else
589	int rc = NetIfEnableDynamicIpConfig(mVirtualBox, this);
590	if (RT_FAILURE(rc))
591	{
592	LogRel(("Failed to EnableDynamicIpConfig with rc=%Rrc\n", rc));
593	return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
594	}
595	return S_OK;
596	#endif
597	}
598
599	HRESULT HostNetworkInterface::dHCPRediscover()
600	{
601	#ifndef VBOX_WITH_HOSTNETIF_API
602	return E_NOTIMPL;
603	#else
604	int rc = NetIfDhcpRediscover(mVirtualBox, this);
605	if (RT_FAILURE(rc))
606	{
607	LogRel(("Failed to DhcpRediscover with rc=%Rrc\n", rc));
608	return rc == VERR_NOT_IMPLEMENTED ? E_NOTIMPL : E_FAIL;
609	}
610	return S_OK;
611	#endif
612	}
613
614	HRESULT HostNetworkInterface::i_setVirtualBox(VirtualBox *pVirtualBox)
615	{
616	AutoCaller autoCaller(this);
617	if (FAILED(autoCaller.rc())) return autoCaller.rc();
618
619	AssertReturn(mVirtualBox != pVirtualBox, S_OK);
620
621	unconst(mVirtualBox) = pVirtualBox;
622
623	#if !defined(RT_OS_WINDOWS)
624	/* If IPv4 address hasn't been initialized */
625	if (m.IPAddress == 0 && mIfType == HostNetworkInterfaceType_HostOnly)
626	{
627	Bstr tmpAddr, tmpMask;
628	HRESULT hrc = mVirtualBox->GetExtraData(BstrFmt("HostOnly/%ls/IPAddress",
629	mInterfaceName.raw()).raw(),
630	tmpAddr.asOutParam());
631	if (FAILED(hrc) \|\| tmpAddr.isEmpty())
632	tmpAddr = getDefaultIPv4Address(mInterfaceName);
633
634	hrc = mVirtualBox->GetExtraData(BstrFmt("HostOnly/%ls/IPNetMask",
635	mInterfaceName.raw()).raw(),
636	tmpMask.asOutParam());
637	if (FAILED(hrc) \|\| tmpMask.isEmpty())
638	tmpMask = Bstr(VBOXNET_IPV4MASK_DEFAULT);
639
640	m.IPAddress = inet_addr(Utf8Str(tmpAddr).c_str());
641	m.networkMask = inet_addr(Utf8Str(tmpMask).c_str());
642	}
643
644	if (m.IPV6Address.isEmpty())
645	{
646	Bstr tmpPrefixLen;
647	HRESULT hrc = mVirtualBox->GetExtraData(BstrFmt("HostOnly/%ls/IPV6Address",
648	mInterfaceName.raw()).raw(),
649	m.IPV6Address.asOutParam());
650	if (SUCCEEDED(hrc) && !m.IPV6Address.isEmpty())
651	{
652	hrc = mVirtualBox->GetExtraData(BstrFmt("HostOnly/%ls/IPV6PrefixLen",
653	mInterfaceName.raw()).raw(),
654	tmpPrefixLen.asOutParam());
655	if (SUCCEEDED(hrc) && !tmpPrefixLen.isEmpty())
656	m.IPV6NetworkMaskPrefixLength = Utf8Str(tmpPrefixLen).toUInt32();
657	else
658	m.IPV6NetworkMaskPrefixLength = 64;
659	}
660	}
661	#endif
662
663	return S_OK;
664	}
665
666	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/src-server/HostNetworkInterfaceImpl.cpp@ 73164

Download in other formats: