HostNetworkInterfaceImpl.cpp@ 48015

Last change on this file since 48015 was 46820, checked in by vboxsync, 11 years ago
Main: do not include VirtualBoxImpl.h from code ending in VBoxC (causes unnecessary rebuilds), and make sure that the code still builds with VBOX_WITH_RESOURCE_USAGE_API unset
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 20.6 KB

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

Download in other formats: