HostNetworkInterfaceImpl.cpp@ 45434

Last change on this file since 45434 was 44039, checked in by vboxsync, 12 years ago
Main: renavation com::Guid class. PR5744
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 20.5 KB

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

Download in other formats: