NetIf-win.cpp@ 76900

Last change on this file since 76900 was 76592, checked in by vboxsync, 6 years ago
Main: Don't use Logging.h.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 73.0 KB

Line
1	/* $Id: NetIf-win.cpp 76592 2019-01-01 20:13:07Z vboxsync $ */
2	/** @file
3	* Main - NetIfList, Windows implementation.
4	*/
5
6	/*
7	* Copyright (C) 2008-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19
20	/*********************************************************************************************************************************
21	* Header Files *
22	*********************************************************************************************************************************/
23	#define LOG_GROUP LOG_GROUP_MAIN_HOST
24
25	#define NETIF_WITHOUT_NETCFG
26
27	#include <iprt/errcore.h>
28	#include <list>
29
30	#define _WIN32_DCOM
31	#include <iprt/win/winsock2.h>
32	#include <iprt/win/ws2tcpip.h>
33	#include <iprt/win/windows.h>
34	#include <tchar.h>
35
36	#ifdef VBOX_WITH_NETFLT
37	# include "VBox/VBoxNetCfg-win.h"
38	# include "devguid.h"
39	#endif
40
41	#include <iprt/win/iphlpapi.h>
42	#include <iprt/win/ntddndis.h>
43
44	#include "LoggingNew.h"
45	#include "HostNetworkInterfaceImpl.h"
46	#include "ProgressImpl.h"
47	#include "VirtualBoxImpl.h"
48	#include "netif.h"
49	#include "ThreadTask.h"
50
51	#ifdef VBOX_WITH_NETFLT
52	#include <Wbemidl.h>
53	#include <comdef.h>
54
55	#include "svchlp.h"
56
57	#include <shellapi.h>
58	#define INITGUID
59	#include <guiddef.h>
60	#include <devguid.h>
61	#include <iprt/win/objbase.h>
62	#include <iprt/win/setupapi.h>
63	#include <iprt/win/shlobj.h>
64	#include <cfgmgr32.h>
65
66	#define VBOX_APP_NAME L"VirtualBox"
67
68	static int getDefaultInterfaceIndex()
69	{
70	PMIB_IPFORWARDTABLE pIpTable;
71	DWORD dwSize = sizeof(MIB_IPFORWARDTABLE) * 20;
72	DWORD dwRC = NO_ERROR;
73	int iIndex = -1;
74
75	pIpTable = (MIB_IPFORWARDTABLE *)RTMemAlloc(dwSize);
76	if (GetIpForwardTable(pIpTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER)
77	{
78	RTMemFree(pIpTable);
79	pIpTable = (MIB_IPFORWARDTABLE *)RTMemAlloc(dwSize);
80	if (!pIpTable)
81	return -1;
82	}
83	dwRC = GetIpForwardTable(pIpTable, &dwSize, 0);
84	if (dwRC == NO_ERROR)
85	{
86	for (unsigned int i = 0; i < pIpTable->dwNumEntries; i++)
87	if (pIpTable->table[i].dwForwardDest == 0)
88	{
89	iIndex = pIpTable->table[i].dwForwardIfIndex;
90	break;
91	}
92	}
93	RTMemFree(pIpTable);
94	return iIndex;
95	}
96
97	static int collectNetIfInfo(Bstr &strName, Guid &guid, PNETIFINFO pInfo, int iDefault)
98	{
99	RT_NOREF(strName);
100
101	/*
102	* Most of the hosts probably have less than 10 adapters,
103	* so we'll mostly succeed from the first attempt.
104	*/
105	ULONG uBufLen = sizeof(IP_ADAPTER_ADDRESSES) * 10;
106	PIP_ADAPTER_ADDRESSES pAddresses = (PIP_ADAPTER_ADDRESSES)RTMemAlloc(uBufLen);
107	if (!pAddresses)
108	return VERR_NO_MEMORY;
109	DWORD dwRc = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX, NULL, pAddresses, &uBufLen);
110	if (dwRc == ERROR_BUFFER_OVERFLOW)
111	{
112	/* Impressive! More than 10 adapters! Get more memory and try again. */
113	RTMemFree(pAddresses);
114	pAddresses = (PIP_ADAPTER_ADDRESSES)RTMemAlloc(uBufLen);
115	if (!pAddresses)
116	return VERR_NO_MEMORY;
117	dwRc = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX, NULL, pAddresses, &uBufLen);
118	}
119	if (dwRc == NO_ERROR)
120	{
121	PIP_ADAPTER_ADDRESSES pAdapter;
122	for (pAdapter = pAddresses; pAdapter; pAdapter = pAdapter->Next)
123	{
124	char *pszUuid = RTStrDup(pAdapter->AdapterName);
125	size_t len = strlen(pszUuid) - 1;
126	if (pszUuid[0] == '{' && pszUuid[len] == '}')
127	{
128	pszUuid[len] = 0;
129	if (!RTUuidCompareStr(&pInfo->Uuid, pszUuid + 1))
130	{
131	bool fIPFound, fIPv6Found;
132	PIP_ADAPTER_UNICAST_ADDRESS pAddr;
133	fIPFound = fIPv6Found = false;
134	for (pAddr = pAdapter->FirstUnicastAddress; pAddr; pAddr = pAddr->Next)
135	{
136	switch (pAddr->Address.lpSockaddr->sa_family)
137	{
138	case AF_INET:
139	if (!fIPFound)
140	{
141	fIPFound = true;
142	memcpy(&pInfo->IPAddress,
143	&((struct sockaddr_in *)pAddr->Address.lpSockaddr)->sin_addr.s_addr,
144	sizeof(pInfo->IPAddress));
145	}
146	break;
147	case AF_INET6:
148	if (!fIPv6Found)
149	{
150	fIPv6Found = true;
151	memcpy(&pInfo->IPv6Address,
152	((struct sockaddr_in6 *)pAddr->Address.lpSockaddr)->sin6_addr.s6_addr,
153	sizeof(pInfo->IPv6Address));
154	}
155	break;
156	}
157	}
158	PIP_ADAPTER_PREFIX pPrefix;
159	fIPFound = fIPv6Found = false;
160	for (pPrefix = pAdapter->FirstPrefix; pPrefix; pPrefix = pPrefix->Next)
161	{
162	switch (pPrefix->Address.lpSockaddr->sa_family)
163	{
164	case AF_INET:
165	if (!fIPFound)
166	{
167	if (pPrefix->PrefixLength <= sizeof(pInfo->IPNetMask) * 8)
168	{
169	fIPFound = true;
170	RTNetPrefixToMaskIPv4(pPrefix->PrefixLength, &pInfo->IPNetMask);
171	}
172	else
173	LogFunc(("Unexpected IPv4 prefix length of %d\n",
174	pPrefix->PrefixLength));
175	}
176	break;
177	case AF_INET6:
178	if (!fIPv6Found)
179	{
180	if (pPrefix->PrefixLength <= sizeof(pInfo->IPv6NetMask) * 8)
181	{
182	fIPv6Found = true;
183	RTNetPrefixToMaskIPv6(pPrefix->PrefixLength, &pInfo->IPv6NetMask);
184	}
185	else
186	LogFunc(("Unexpected IPv6 prefix length of %d\n",
187	pPrefix->PrefixLength));
188	}
189	break;
190	}
191	}
192	if (sizeof(pInfo->MACAddress) != pAdapter->PhysicalAddressLength)
193	LogFunc(("Unexpected physical address length: %u\n", pAdapter->PhysicalAddressLength));
194	else
195	memcpy(pInfo->MACAddress.au8, pAdapter->PhysicalAddress, sizeof(pInfo->MACAddress));
196	pInfo->enmMediumType = NETIF_T_ETHERNET;
197	pInfo->enmStatus = pAdapter->OperStatus == IfOperStatusUp ? NETIF_S_UP : NETIF_S_DOWN;
198	pInfo->fIsDefault = (pAdapter->IfIndex == (DWORD)iDefault);
199	RTStrFree(pszUuid);
200	break;
201	}
202	}
203	RTStrFree(pszUuid);
204	}
205
206	ADAPTER_SETTINGS Settings;
207	HRESULT hr = VBoxNetCfgWinGetAdapterSettings((const GUID *)guid.raw(), &Settings);
208	if (hr == S_OK)
209	{
210	if (Settings.ip)
211	{
212	pInfo->IPAddress.u = Settings.ip;
213	pInfo->IPNetMask.u = Settings.mask;
214	}
215	pInfo->fDhcpEnabled = Settings.bDhcp;
216	}
217	else
218	{
219	pInfo->fDhcpEnabled = false;
220	}
221	}
222	RTMemFree(pAddresses);
223
224	return VINF_SUCCESS;
225	}
226
227	/* svc helper func */
228
229	struct StaticIpConfig
230	{
231	ULONG IPAddress;
232	ULONG IPNetMask;
233	};
234
235	struct StaticIpV6Config
236	{
237	BSTR IPV6Address;
238	ULONG IPV6NetMaskLength;
239	};
240
241	class NetworkInterfaceHelperClientData : public ThreadVoidData
242	{
243	public:
244	NetworkInterfaceHelperClientData(){};
245	~NetworkInterfaceHelperClientData(){};
246
247	SVCHlpMsg::Code msgCode;
248	/* for SVCHlpMsg::CreateHostOnlyNetworkInterface */
249	Bstr name;
250	ComObjPtr<HostNetworkInterface> iface;
251	ComObjPtr<VirtualBox> vBox;
252	/* for SVCHlpMsg::RemoveHostOnlyNetworkInterface */
253	Guid guid;
254
255	union
256	{
257	StaticIpConfig StaticIP;
258	StaticIpV6Config StaticIPV6;
259	} u;
260
261	};
262
263	static HRESULT netIfNetworkInterfaceHelperClient(SVCHlpClient *aClient,
264	Progress *aProgress,
265	void aUser, int aVrc)
266	{
267	LogFlowFuncEnter();
268	LogFlowFunc(("aClient={%p}, aProgress={%p}, aUser={%p}\n",
269	aClient, aProgress, aUser));
270
271	AssertReturn( (aClient == NULL && aProgress == NULL && aVrc == NULL)
272	\|\| (aClient != NULL && aProgress != NULL && aVrc != NULL),
273	E_POINTER);
274	AssertReturn(aUser, E_POINTER);
275
276	NetworkInterfaceHelperClientData* d = static_cast<NetworkInterfaceHelperClientData *>(aUser);
277
278	if (aClient == NULL)
279	{
280	/* "cleanup only" mode, just return (it will free aUser) */
281	return S_OK;
282	}
283
284	HRESULT rc = S_OK;
285	int vrc = VINF_SUCCESS;
286
287	switch (d->msgCode)
288	{
289	case SVCHlpMsg::CreateHostOnlyNetworkInterface:
290	{
291	LogFlowFunc(("CreateHostOnlyNetworkInterface:\n"));
292	LogFlowFunc(("Network connection name = '%ls'\n", d->name.raw()));
293
294	/* write message and parameters */
295	vrc = aClient->write(d->msgCode);
296	if (RT_FAILURE(vrc)) break;
297	// vrc = aClient->write(Utf8Str(d->name));
298	// if (RT_FAILURE(vrc)) break;
299
300	/* wait for a reply */
301	bool endLoop = false;
302	while (!endLoop)
303	{
304	SVCHlpMsg::Code reply = SVCHlpMsg::Null;
305
306	vrc = aClient->read(reply);
307	if (RT_FAILURE(vrc)) break;
308
309	switch (reply)
310	{
311	case SVCHlpMsg::CreateHostOnlyNetworkInterface_OK:
312	{
313	/* read the GUID */
314	Guid guid;
315	Utf8Str name;
316	vrc = aClient->read(name);
317	if (RT_FAILURE(vrc)) break;
318	vrc = aClient->read(guid);
319	if (RT_FAILURE(vrc)) break;
320
321	LogFlowFunc(("Network connection GUID = {%RTuuid}\n", guid.raw()));
322
323	/* initialize the object returned to the caller by
324	* CreateHostOnlyNetworkInterface() */
325	rc = d->iface->init(Bstr(name), Bstr(name), guid, HostNetworkInterfaceType_HostOnly);
326	if (SUCCEEDED(rc))
327	{
328	rc = d->iface->i_setVirtualBox(d->vBox);
329	if (SUCCEEDED(rc))
330	{
331	rc = d->iface->updateConfig();
332	}
333	}
334	endLoop = true;
335	break;
336	}
337	case SVCHlpMsg::Error:
338	{
339	/* read the error message */
340	Utf8Str errMsg;
341	vrc = aClient->read(errMsg);
342	if (RT_FAILURE(vrc)) break;
343
344	rc = E_FAIL;
345	d->iface->setError(E_FAIL, errMsg.c_str());
346	endLoop = true;
347	break;
348	}
349	default:
350	{
351	endLoop = true;
352	rc = E_FAIL;/// @todo ComAssertMsgFailedBreak((
353	//"Invalid message code %d (%08lX)\n",
354	//reply, reply),
355	//rc = E_FAIL);
356	}
357	}
358	}
359
360	break;
361	}
362	case SVCHlpMsg::RemoveHostOnlyNetworkInterface:
363	{
364	LogFlowFunc(("RemoveHostOnlyNetworkInterface:\n"));
365	LogFlowFunc(("Network connection GUID = {%RTuuid}\n", d->guid.raw()));
366
367	/* write message and parameters */
368	vrc = aClient->write(d->msgCode);
369	if (RT_FAILURE(vrc)) break;
370	vrc = aClient->write(d->guid);
371	if (RT_FAILURE(vrc)) break;
372
373	/* wait for a reply */
374	bool endLoop = false;
375	while (!endLoop)
376	{
377	SVCHlpMsg::Code reply = SVCHlpMsg::Null;
378
379	vrc = aClient->read(reply);
380	if (RT_FAILURE(vrc)) break;
381
382	switch (reply)
383	{
384	case SVCHlpMsg::OK:
385	{
386	/* no parameters */
387	rc = S_OK;
388	endLoop = true;
389	break;
390	}
391	case SVCHlpMsg::Error:
392	{
393	/* read the error message */
394	Utf8Str errMsg;
395	vrc = aClient->read(errMsg);
396	if (RT_FAILURE(vrc)) break;
397
398	rc = E_FAIL;
399	d->iface->setError(E_FAIL, errMsg.c_str());
400	endLoop = true;
401	break;
402	}
403	default:
404	{
405	endLoop = true;
406	rc = E_FAIL; /// @todo ComAssertMsgFailedBreak((
407	//"Invalid message code %d (%08lX)\n",
408	//reply, reply),
409	//rc = E_FAIL);
410	}
411	}
412	}
413
414	break;
415	}
416	case SVCHlpMsg::EnableDynamicIpConfig: /* see usage in code */
417	{
418	LogFlowFunc(("EnableDynamicIpConfig:\n"));
419	LogFlowFunc(("Network connection name = '%ls'\n", d->name.raw()));
420
421	/* write message and parameters */
422	vrc = aClient->write(d->msgCode);
423	if (RT_FAILURE(vrc)) break;
424	vrc = aClient->write(d->guid);
425	if (RT_FAILURE(vrc)) break;
426
427	/* wait for a reply */
428	bool endLoop = false;
429	while (!endLoop)
430	{
431	SVCHlpMsg::Code reply = SVCHlpMsg::Null;
432
433	vrc = aClient->read(reply);
434	if (RT_FAILURE(vrc)) break;
435
436	switch (reply)
437	{
438	case SVCHlpMsg::OK:
439	{
440	/* no parameters */
441	rc = d->iface->updateConfig();
442	endLoop = true;
443	break;
444	}
445	case SVCHlpMsg::Error:
446	{
447	/* read the error message */
448	Utf8Str errMsg;
449	vrc = aClient->read(errMsg);
450	if (RT_FAILURE(vrc)) break;
451
452	rc = E_FAIL;
453	d->iface->setError(E_FAIL, errMsg.c_str());
454	endLoop = true;
455	break;
456	}
457	default:
458	{
459	endLoop = true;
460	rc = E_FAIL; /// @todo ComAssertMsgFailedBreak((
461	//"Invalid message code %d (%08lX)\n",
462	//reply, reply),
463	//rc = E_FAIL);
464	}
465	}
466	}
467
468	break;
469	}
470	case SVCHlpMsg::EnableStaticIpConfig: /* see usage in code */
471	{
472	LogFlowFunc(("EnableStaticIpConfig:\n"));
473	LogFlowFunc(("Network connection name = '%ls'\n", d->name.raw()));
474
475	/* write message and parameters */
476	vrc = aClient->write(d->msgCode);
477	if (RT_FAILURE(vrc)) break;
478	vrc = aClient->write(d->guid);
479	if (RT_FAILURE(vrc)) break;
480	vrc = aClient->write(d->u.StaticIP.IPAddress);
481	if (RT_FAILURE(vrc)) break;
482	vrc = aClient->write(d->u.StaticIP.IPNetMask);
483	if (RT_FAILURE(vrc)) break;
484
485	/* wait for a reply */
486	bool endLoop = false;
487	while (!endLoop)
488	{
489	SVCHlpMsg::Code reply = SVCHlpMsg::Null;
490
491	vrc = aClient->read(reply);
492	if (RT_FAILURE(vrc)) break;
493
494	switch (reply)
495	{
496	case SVCHlpMsg::OK:
497	{
498	/* no parameters */
499	rc = d->iface->updateConfig();
500	endLoop = true;
501	break;
502	}
503	case SVCHlpMsg::Error:
504	{
505	/* read the error message */
506	Utf8Str errMsg;
507	vrc = aClient->read(errMsg);
508	if (RT_FAILURE(vrc)) break;
509
510	rc = E_FAIL;
511	d->iface->setError(E_FAIL, errMsg.c_str());
512	endLoop = true;
513	break;
514	}
515	default:
516	{
517	endLoop = true;
518	rc = E_FAIL; /// @todo ComAssertMsgFailedBreak((
519	//"Invalid message code %d (%08lX)\n",
520	//reply, reply),
521	//rc = E_FAIL);
522	}
523	}
524	}
525
526	break;
527	}
528	case SVCHlpMsg::EnableStaticIpConfigV6: /* see usage in code */
529	{
530	LogFlowFunc(("EnableStaticIpConfigV6:\n"));
531	LogFlowFunc(("Network connection name = '%ls'\n", d->name.raw()));
532
533	/* write message and parameters */
534	vrc = aClient->write(d->msgCode);
535	if (RT_FAILURE(vrc)) break;
536	vrc = aClient->write(d->guid);
537	if (RT_FAILURE(vrc)) break;
538	vrc = aClient->write(Utf8Str(d->u.StaticIPV6.IPV6Address));
539	if (RT_FAILURE(vrc)) break;
540	vrc = aClient->write(d->u.StaticIPV6.IPV6NetMaskLength);
541	if (RT_FAILURE(vrc)) break;
542
543	/* wait for a reply */
544	bool endLoop = false;
545	while (!endLoop)
546	{
547	SVCHlpMsg::Code reply = SVCHlpMsg::Null;
548
549	vrc = aClient->read(reply);
550	if (RT_FAILURE(vrc)) break;
551
552	switch (reply)
553	{
554	case SVCHlpMsg::OK:
555	{
556	/* no parameters */
557	rc = d->iface->updateConfig();
558	endLoop = true;
559	break;
560	}
561	case SVCHlpMsg::Error:
562	{
563	/* read the error message */
564	Utf8Str errMsg;
565	vrc = aClient->read(errMsg);
566	if (RT_FAILURE(vrc)) break;
567
568	rc = E_FAIL;
569	d->iface->setError(E_FAIL, errMsg.c_str());
570	endLoop = true;
571	break;
572	}
573	default:
574	{
575	endLoop = true;
576	rc = E_FAIL; /// @todo ComAssertMsgFailedBreak((
577	//"Invalid message code %d (%08lX)\n",
578	//reply, reply),
579	//rc = E_FAIL);
580	}
581	}
582	}
583
584	break;
585	}
586	case SVCHlpMsg::DhcpRediscover: /* see usage in code */
587	{
588	LogFlowFunc(("DhcpRediscover:\n"));
589	LogFlowFunc(("Network connection name = '%ls'\n", d->name.raw()));
590
591	/* write message and parameters */
592	vrc = aClient->write(d->msgCode);
593	if (RT_FAILURE(vrc)) break;
594	vrc = aClient->write(d->guid);
595	if (RT_FAILURE(vrc)) break;
596
597	/* wait for a reply */
598	bool endLoop = false;
599	while (!endLoop)
600	{
601	SVCHlpMsg::Code reply = SVCHlpMsg::Null;
602
603	vrc = aClient->read(reply);
604	if (RT_FAILURE(vrc)) break;
605
606	switch (reply)
607	{
608	case SVCHlpMsg::OK:
609	{
610	/* no parameters */
611	rc = d->iface->updateConfig();
612	endLoop = true;
613	break;
614	}
615	case SVCHlpMsg::Error:
616	{
617	/* read the error message */
618	Utf8Str errMsg;
619	vrc = aClient->read(errMsg);
620	if (RT_FAILURE(vrc)) break;
621
622	rc = E_FAIL;
623	d->iface->setError(E_FAIL, errMsg.c_str());
624	endLoop = true;
625	break;
626	}
627	default:
628	{
629	endLoop = true;
630	rc = E_FAIL; /// @todo ComAssertMsgFailedBreak((
631	//"Invalid message code %d (%08lX)\n",
632	//reply, reply),
633	//rc = E_FAIL);
634	}
635	}
636	}
637
638	break;
639	}
640	default:
641	rc = E_FAIL; /// @todo ComAssertMsgFailedBreak((
642	// "Invalid message code %d (%08lX)\n",
643	// d->msgCode, d->msgCode),
644	// rc = E_FAIL);
645	}
646
647	if (aVrc)
648	*aVrc = vrc;
649
650	LogFlowFunc(("rc=0x%08X, vrc=%Rrc\n", rc, vrc));
651	LogFlowFuncLeave();
652	return rc;
653	}
654
655
656	int netIfNetworkInterfaceHelperServer(SVCHlpClient *aClient,
657	SVCHlpMsg::Code aMsgCode)
658	{
659	LogFlowFuncEnter();
660	LogFlowFunc(("aClient={%p}, aMsgCode=%d\n", aClient, aMsgCode));
661
662	AssertReturn(aClient, VERR_INVALID_POINTER);
663
664	int vrc = VINF_SUCCESS;
665	HRESULT hrc;
666
667	switch (aMsgCode)
668	{
669	case SVCHlpMsg::CreateHostOnlyNetworkInterface:
670	{
671	LogFlowFunc(("CreateHostOnlyNetworkInterface:\n"));
672
673	// Utf8Str name;
674	// vrc = aClient->read(name);
675	// if (RT_FAILURE(vrc)) break;
676
677	Guid guid;
678	Utf8Str errMsg;
679	Bstr name;
680	Bstr bstrErr;
681
682	#ifdef VBOXNETCFG_DELAYEDRENAME
683	Bstr devId;
684	hrc = VBoxNetCfgWinCreateHostOnlyNetworkInterface(NULL, false, guid.asOutParam(), devId.asOutParam(),
685	bstrErr.asOutParam());
686	#else /* !VBOXNETCFG_DELAYEDRENAME */
687	hrc = VBoxNetCfgWinCreateHostOnlyNetworkInterface(NULL, false, guid.asOutParam(), name.asOutParam(),
688	bstrErr.asOutParam());
689	#endif /* !VBOXNETCFG_DELAYEDRENAME */
690
691	if (hrc == S_OK)
692	{
693	ULONG ip, mask;
694	hrc = VBoxNetCfgWinGenHostOnlyNetworkNetworkIp(&ip, &mask);
695	if (hrc == S_OK)
696	{
697	/* ip returned by VBoxNetCfgWinGenHostOnlyNetworkNetworkIp is a network ip,
698	* i.e. 192.168.xxx.0, assign 192.168.xxx.1 for the hostonly adapter */
699	ip = ip \| (1 << 24);
700	hrc = VBoxNetCfgWinEnableStaticIpConfig((const GUID*)guid.raw(), ip, mask);
701	if (hrc != S_OK)
702	LogRel(("VBoxNetCfgWinEnableStaticIpConfig failed (0x%x)\n", hrc));
703	}
704	else
705	LogRel(("VBoxNetCfgWinGenHostOnlyNetworkNetworkIp failed (0x%x)\n", hrc));
706	#ifdef VBOXNETCFG_DELAYEDRENAME
707	hrc = VBoxNetCfgWinRenameHostOnlyConnection((const GUID*)guid.raw(), devId.raw(), name.asOutParam());
708	if (hrc != S_OK)
709	LogRel(("VBoxNetCfgWinRenameHostOnlyConnection failed, error = 0x%x", hrc));
710	#endif /* VBOXNETCFG_DELAYEDRENAME */
711	/* write success followed by GUID */
712	vrc = aClient->write(SVCHlpMsg::CreateHostOnlyNetworkInterface_OK);
713	if (RT_FAILURE(vrc)) break;
714	vrc = aClient->write(Utf8Str(name));
715	if (RT_FAILURE(vrc)) break;
716	vrc = aClient->write(guid);
717	if (RT_FAILURE(vrc)) break;
718	}
719	else
720	{
721	vrc = VERR_GENERAL_FAILURE;
722	errMsg = Utf8Str(bstrErr);
723	/* write failure followed by error message */
724	if (errMsg.isEmpty())
725	errMsg = Utf8StrFmt("Unspecified error (%Rrc)", vrc);
726	vrc = aClient->write(SVCHlpMsg::Error);
727	if (RT_FAILURE(vrc)) break;
728	vrc = aClient->write(errMsg);
729	if (RT_FAILURE(vrc)) break;
730	}
731
732	break;
733	}
734	case SVCHlpMsg::RemoveHostOnlyNetworkInterface:
735	{
736	LogFlowFunc(("RemoveHostOnlyNetworkInterface:\n"));
737
738	Guid guid;
739	Bstr bstrErr;
740
741	vrc = aClient->read(guid);
742	if (RT_FAILURE(vrc)) break;
743
744	Utf8Str errMsg;
745	hrc = VBoxNetCfgWinRemoveHostOnlyNetworkInterface((const GUID*)guid.raw(), bstrErr.asOutParam());
746
747	if (hrc == S_OK)
748	{
749	/* write parameter-less success */
750	vrc = aClient->write(SVCHlpMsg::OK);
751	if (RT_FAILURE(vrc)) break;
752	}
753	else
754	{
755	vrc = VERR_GENERAL_FAILURE;
756	errMsg = Utf8Str(bstrErr);
757	/* write failure followed by error message */
758	if (errMsg.isEmpty())
759	errMsg = Utf8StrFmt("Unspecified error (%Rrc)", vrc);
760	vrc = aClient->write(SVCHlpMsg::Error);
761	if (RT_FAILURE(vrc)) break;
762	vrc = aClient->write(errMsg);
763	if (RT_FAILURE(vrc)) break;
764	}
765
766	break;
767	}
768	case SVCHlpMsg::EnableStaticIpConfigV6:
769	{
770	LogFlowFunc(("EnableStaticIpConfigV6:\n"));
771
772	Guid guid;
773	Utf8Str ipV6;
774	ULONG maskLengthV6;
775	vrc = aClient->read(guid);
776	if (RT_FAILURE(vrc)) break;
777	vrc = aClient->read(ipV6);
778	if (RT_FAILURE(vrc)) break;
779	vrc = aClient->read(maskLengthV6);
780	if (RT_FAILURE(vrc)) break;
781
782	Utf8Str errMsg;
783	vrc = VERR_NOT_IMPLEMENTED;
784
785	if (RT_SUCCESS(vrc))
786	{
787	/* write success followed by GUID */
788	vrc = aClient->write(SVCHlpMsg::OK);
789	if (RT_FAILURE(vrc)) break;
790	}
791	else
792	{
793	/* write failure followed by error message */
794	if (errMsg.isEmpty())
795	errMsg = Utf8StrFmt("Unspecified error (%Rrc)", vrc);
796	vrc = aClient->write(SVCHlpMsg::Error);
797	if (RT_FAILURE(vrc)) break;
798	vrc = aClient->write(errMsg);
799	if (RT_FAILURE(vrc)) break;
800	}
801
802	break;
803	}
804	case SVCHlpMsg::EnableStaticIpConfig:
805	{
806	LogFlowFunc(("EnableStaticIpConfig:\n"));
807
808	Guid guid;
809	ULONG ip, mask;
810	vrc = aClient->read(guid);
811	if (RT_FAILURE(vrc)) break;
812	vrc = aClient->read(ip);
813	if (RT_FAILURE(vrc)) break;
814	vrc = aClient->read(mask);
815	if (RT_FAILURE(vrc)) break;
816
817	Utf8Str errMsg;
818	hrc = VBoxNetCfgWinEnableStaticIpConfig((const GUID *)guid.raw(), ip, mask);
819
820	if (hrc == S_OK)
821	{
822	/* write success followed by GUID */
823	vrc = aClient->write(SVCHlpMsg::OK);
824	if (RT_FAILURE(vrc)) break;
825	}
826	else
827	{
828	vrc = VERR_GENERAL_FAILURE;
829	/* write failure followed by error message */
830	if (errMsg.isEmpty())
831	errMsg = Utf8StrFmt("Unspecified error (%Rrc)", vrc);
832	vrc = aClient->write(SVCHlpMsg::Error);
833	if (RT_FAILURE(vrc)) break;
834	vrc = aClient->write(errMsg);
835	if (RT_FAILURE(vrc)) break;
836	}
837
838	break;
839	}
840	case SVCHlpMsg::EnableDynamicIpConfig:
841	{
842	LogFlowFunc(("EnableDynamicIpConfig:\n"));
843
844	Guid guid;
845	vrc = aClient->read(guid);
846	if (RT_FAILURE(vrc)) break;
847
848	Utf8Str errMsg;
849	hrc = VBoxNetCfgWinEnableDynamicIpConfig((const GUID *)guid.raw());
850
851	if (hrc == S_OK)
852	{
853	/* write success followed by GUID */
854	vrc = aClient->write(SVCHlpMsg::OK);
855	if (RT_FAILURE(vrc)) break;
856	}
857	else
858	{
859	vrc = VERR_GENERAL_FAILURE;
860	/* write failure followed by error message */
861	if (errMsg.isEmpty())
862	errMsg = Utf8StrFmt("Unspecified error (%Rrc)", vrc);
863	vrc = aClient->write(SVCHlpMsg::Error);
864	if (RT_FAILURE(vrc)) break;
865	vrc = aClient->write(errMsg);
866	if (RT_FAILURE(vrc)) break;
867	}
868
869	break;
870	}
871	case SVCHlpMsg::DhcpRediscover:
872	{
873	LogFlowFunc(("DhcpRediscover:\n"));
874
875	Guid guid;
876	vrc = aClient->read(guid);
877	if (RT_FAILURE(vrc)) break;
878
879	Utf8Str errMsg;
880	hrc = VBoxNetCfgWinDhcpRediscover((const GUID *)guid.raw());
881
882	if (hrc == S_OK)
883	{
884	/* write success followed by GUID */
885	vrc = aClient->write(SVCHlpMsg::OK);
886	if (RT_FAILURE(vrc)) break;
887	}
888	else
889	{
890	vrc = VERR_GENERAL_FAILURE;
891	/* write failure followed by error message */
892	if (errMsg.isEmpty())
893	errMsg = Utf8StrFmt("Unspecified error (%Rrc)", vrc);
894	vrc = aClient->write(SVCHlpMsg::Error);
895	if (RT_FAILURE(vrc)) break;
896	vrc = aClient->write(errMsg);
897	if (RT_FAILURE(vrc)) break;
898	}
899
900	break;
901	}
902	default:
903	AssertMsgFailedBreakStmt(
904	("Invalid message code %d (%08lX)\n", aMsgCode, aMsgCode),
905	VERR_GENERAL_FAILURE);
906	}
907
908	LogFlowFunc(("vrc=%Rrc\n", vrc));
909	LogFlowFuncLeave();
910	return vrc;
911	}
912
913	/** @todo REMOVE. OBSOLETE NOW. */
914	/**
915	* Returns TRUE if the Windows version is 6.0 or greater (i.e. it's Vista and
916	* later OSes) and it has the UAC (User Account Control) feature enabled.
917	*/
918	static BOOL IsUACEnabled()
919	{
920	LONG rc = 0;
921
922	OSVERSIONINFOEX info;
923	ZeroMemory(&info, sizeof(OSVERSIONINFOEX));
924	info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
925	rc = GetVersionEx((OSVERSIONINFO *) &info);
926	AssertReturn(rc != 0, FALSE);
927
928	LogFlowFunc(("dwMajorVersion=%d, dwMinorVersion=%d\n",
929	info.dwMajorVersion, info.dwMinorVersion));
930
931	/* we are interested only in Vista (and newer versions...). In all
932	* earlier versions UAC is not present. */
933	if (info.dwMajorVersion < 6)
934	return FALSE;
935
936	/* the default EnableLUA value is 1 (Enabled) */
937	DWORD dwEnableLUA = 1;
938
939	HKEY hKey;
940	rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
941	"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System",
942	0, KEY_QUERY_VALUE, &hKey);
943
944	Assert(rc == ERROR_SUCCESS \|\| rc == ERROR_PATH_NOT_FOUND);
945	if (rc == ERROR_SUCCESS)
946	{
947
948	DWORD cbEnableLUA = sizeof(dwEnableLUA);
949	rc = RegQueryValueExA(hKey, "EnableLUA", NULL, NULL,
950	(LPBYTE) &dwEnableLUA, &cbEnableLUA);
951
952	RegCloseKey(hKey);
953
954	Assert(rc == ERROR_SUCCESS \|\| rc == ERROR_FILE_NOT_FOUND);
955	}
956
957	LogFlowFunc(("rc=%d, dwEnableLUA=%d\n", rc, dwEnableLUA));
958
959	return dwEnableLUA == 1;
960	}
961
962	/* end */
963
964	static int vboxNetWinAddComponent(std::list<ComObjPtr<HostNetworkInterface> > * pPist,
965	INetCfgComponent * pncc, HostNetworkInterfaceType enmType,
966	int iDefaultInterface)
967	{
968	LPWSTR lpszName;
969	GUID IfGuid;
970	HRESULT hr;
971	int rc = VERR_GENERAL_FAILURE;
972
973	hr = pncc->GetDisplayName(&lpszName);
974	Assert(hr == S_OK);
975	if (hr == S_OK)
976	{
977	Bstr name(lpszName);
978
979	hr = pncc->GetInstanceGuid(&IfGuid);
980	Assert(hr == S_OK);
981	if (hr == S_OK)
982	{
983	Guid guidIfCopy(IfGuid);
984	NETIFINFO Info;
985	RT_ZERO(Info);
986	Info.Uuid = *guidIfCopy.raw();
987	rc = collectNetIfInfo(name, guidIfCopy, &Info, iDefaultInterface);
988	if (RT_FAILURE(rc))
989	LogRelFunc(("collectNetIfInfo() -> %Rrc\n", rc));
990	LogFunc(("adding %ls\n", lpszName));
991	/* create a new object and add it to the list */
992	ComObjPtr<HostNetworkInterface> iface;
993	iface.createObject();
994	/* remove the curly bracket at the end */
995	rc = iface->init(name, enmType, &Info);
996	if (SUCCEEDED(rc))
997	{
998	if (Info.fIsDefault)
999	pPist->push_front(iface);
1000	else
1001	pPist->push_back(iface);
1002	}
1003	else
1004	{
1005	LogRelFunc(("HostNetworkInterface::init() -> %Rrc\n", rc));
1006	AssertComRC(rc);
1007	}
1008	}
1009	else
1010	LogRelFunc(("failed to get device instance GUID (0x%x)\n", hr));
1011	CoTaskMemFree(lpszName);
1012	}
1013	else
1014	LogRelFunc(("failed to get device display name (0x%x)\n", hr));
1015
1016	return rc;
1017	}
1018
1019	#endif /* VBOX_WITH_NETFLT */
1020
1021
1022	static int netIfListHostAdapters(INetCfg *pNc, std::list<ComObjPtr<HostNetworkInterface> > &list)
1023	{
1024	#ifndef VBOX_WITH_NETFLT
1025	/* VBoxNetAdp is available only when VBOX_WITH_NETFLT is enabled */
1026	return VERR_NOT_IMPLEMENTED;
1027	#else /* # if defined VBOX_WITH_NETFLT */
1028	INetCfgComponent *pMpNcc;
1029	HRESULT hr;
1030	IEnumNetCfgComponent *pEnumComponent;
1031
1032	hr = pNc->EnumComponents(&GUID_DEVCLASS_NET, &pEnumComponent);
1033	if (hr == S_OK)
1034	{
1035	while ((hr = pEnumComponent->Next(1, &pMpNcc, NULL)) == S_OK)
1036	{
1037	LPWSTR pwszName;
1038	ULONG uComponentStatus;
1039	hr = pMpNcc->GetDisplayName(&pwszName);
1040	if (hr == S_OK)
1041	LogFunc(("%ls\n", pwszName));
1042	else
1043	LogRelFunc(("failed to get device display name (0x%x)\n", hr));
1044	hr = pMpNcc->GetDeviceStatus(&uComponentStatus);
1045	if (hr == S_OK)
1046	{
1047	if (uComponentStatus == 0)
1048	{
1049	LPWSTR pId;
1050	hr = pMpNcc->GetId(&pId);
1051	Assert(hr == S_OK);
1052	if (hr == S_OK)
1053	{
1054	LogFunc(("id = %ls\n", pId));
1055	if (!_wcsnicmp(pId, L"sun_VBoxNetAdp", sizeof(L"sun_VBoxNetAdp")/2))
1056	{
1057	vboxNetWinAddComponent(&list, pMpNcc, HostNetworkInterfaceType_HostOnly, -1);
1058	}
1059	CoTaskMemFree(pId);
1060	}
1061	else
1062	LogRelFunc(("failed to get device id (0x%x)\n", hr));
1063	}
1064	}
1065	else
1066	LogRelFunc(("failed to get device status (0x%x)\n", hr));
1067	pMpNcc->Release();
1068	}
1069	Assert(hr == S_OK \|\| hr == S_FALSE);
1070
1071	pEnumComponent->Release();
1072	}
1073	else
1074	LogRelFunc(("EnumComponents error (0x%x)\n", hr));
1075	#endif /* # if defined VBOX_WITH_NETFLT */
1076	return VINF_SUCCESS;
1077	}
1078
1079	int NetIfGetConfig(HostNetworkInterface * pIf, NETIFINFO *pInfo)
1080	{
1081	#ifndef VBOX_WITH_NETFLT
1082	return VERR_NOT_IMPLEMENTED;
1083	#else
1084	Bstr name;
1085	HRESULT hr = pIf->COMGETTER(Name)(name.asOutParam());
1086	if (hr == S_OK)
1087	{
1088	Bstr IfGuid;
1089	hr = pIf->COMGETTER(Id)(IfGuid.asOutParam());
1090	Assert(hr == S_OK);
1091	if (hr == S_OK)
1092	{
1093	memset(pInfo, 0, sizeof(NETIFINFO));
1094	Guid guid(IfGuid);
1095	pInfo->Uuid = *(guid.raw());
1096
1097	return collectNetIfInfo(name, guid, pInfo, getDefaultInterfaceIndex());
1098	}
1099	}
1100	return VERR_GENERAL_FAILURE;
1101	#endif
1102	}
1103
1104	int NetIfGetConfigByName(PNETIFINFO)
1105	{
1106	return VERR_NOT_IMPLEMENTED;
1107	}
1108
1109	/**
1110	* Obtain the current state of the interface.
1111	*
1112	* @returns VBox status code.
1113	*
1114	* @param pcszIfName Interface name.
1115	* @param penmState Where to store the retrieved state.
1116	*/
1117	int NetIfGetState(const char pcszIfName, NETIFSTATUS penmState)
1118	{
1119	RT_NOREF(pcszIfName, penmState);
1120	return VERR_NOT_IMPLEMENTED;
1121	}
1122
1123	/**
1124	* Retrieve the physical link speed in megabits per second. If the interface is
1125	* not up or otherwise unavailable the zero speed is returned.
1126	*
1127	* @returns VBox status code.
1128	*
1129	* @param pcszIfName Interface name.
1130	* @param puMbits Where to store the link speed.
1131	*/
1132	int NetIfGetLinkSpeed(const char pcszIfName, uint32_t puMbits)
1133	{
1134	RT_NOREF(pcszIfName, puMbits);
1135	return VERR_NOT_IMPLEMENTED;
1136	}
1137
1138	int NetIfCreateHostOnlyNetworkInterface(VirtualBox *pVirtualBox,
1139	IHostNetworkInterface **aHostNetworkInterface,
1140	IProgress **aProgress,
1141	const char *pszName)
1142	{
1143	RT_NOREF(pszName);
1144	#ifndef VBOX_WITH_NETFLT
1145	return VERR_NOT_IMPLEMENTED;
1146	#else
1147	/* create a progress object */
1148	ComObjPtr<Progress> progress;
1149	progress.createObject();
1150
1151	ComPtr<IHost> host;
1152	HRESULT rc = pVirtualBox->COMGETTER(Host)(host.asOutParam());
1153	if (SUCCEEDED(rc))
1154	{
1155	rc = progress->init(pVirtualBox, host,
1156	Bstr(_T("Creating host only network interface")).raw(),
1157	FALSE /* aCancelable */);
1158	if (SUCCEEDED(rc))
1159	{
1160	if (FAILED(rc)) return rc;
1161	progress.queryInterfaceTo(aProgress);
1162
1163	/* create a new uninitialized host interface object */
1164	ComObjPtr<HostNetworkInterface> iface;
1165	iface.createObject();
1166	iface.queryInterfaceTo(aHostNetworkInterface);
1167
1168	/* create the networkInterfaceHelperClient() argument */
1169	NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
1170
1171	d->msgCode = SVCHlpMsg::CreateHostOnlyNetworkInterface;
1172	// d->name = aName;
1173	d->iface = iface;
1174	d->vBox = pVirtualBox;
1175
1176	rc = pVirtualBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
1177	netIfNetworkInterfaceHelperClient,
1178	static_cast<void *>(d),
1179	progress);
1180	/* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
1181
1182	}
1183	}
1184
1185	return SUCCEEDED(rc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
1186	#endif
1187	}
1188
1189	int NetIfRemoveHostOnlyNetworkInterface(VirtualBox *pVirtualBox, IN_GUID aId,
1190	IProgress **aProgress)
1191	{
1192	#ifndef VBOX_WITH_NETFLT
1193	return VERR_NOT_IMPLEMENTED;
1194	#else
1195	/* create a progress object */
1196	ComObjPtr<Progress> progress;
1197	progress.createObject();
1198	ComPtr<IHost> host;
1199	HRESULT rc = pVirtualBox->COMGETTER(Host)(host.asOutParam());
1200	if (SUCCEEDED(rc))
1201	{
1202	rc = progress->init(pVirtualBox, host,
1203	Bstr(_T("Removing host network interface")).raw(),
1204	FALSE /* aCancelable */);
1205	if (SUCCEEDED(rc))
1206	{
1207	if (FAILED(rc)) return rc;
1208	progress.queryInterfaceTo(aProgress);
1209
1210	/* create the networkInterfaceHelperClient() argument */
1211	NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
1212
1213	d->msgCode = SVCHlpMsg::RemoveHostOnlyNetworkInterface;
1214	d->guid = aId;
1215
1216	rc = pVirtualBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
1217	netIfNetworkInterfaceHelperClient,
1218	static_cast<void *>(d),
1219	progress);
1220	/* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
1221
1222	}
1223	}
1224
1225	return SUCCEEDED(rc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
1226	#endif
1227	}
1228
1229	int NetIfEnableStaticIpConfig(VirtualBox vBox, HostNetworkInterface pIf, ULONG aOldIp, ULONG ip, ULONG mask)
1230	{
1231	RT_NOREF(aOldIp);
1232	#ifndef VBOX_WITH_NETFLT
1233	return VERR_NOT_IMPLEMENTED;
1234	#else
1235	Bstr guid;
1236	HRESULT rc = pIf->COMGETTER(Id)(guid.asOutParam());
1237	if (SUCCEEDED(rc))
1238	{
1239	// ComPtr<VirtualBox> vBox;
1240	// rc = pIf->getVirtualBox(vBox.asOutParam());
1241	// if (SUCCEEDED(rc))
1242	{
1243	/* create a progress object */
1244	ComObjPtr<Progress> progress;
1245	progress.createObject();
1246	// ComPtr<IHost> host;
1247	// HRESULT rc = vBox->COMGETTER(Host)(host.asOutParam());
1248	// if (SUCCEEDED(rc))
1249	{
1250	rc = progress->init(vBox, (IHostNetworkInterface*)pIf,
1251	Bstr("Enabling Dynamic Ip Configuration").raw(),
1252	FALSE /* aCancelable */);
1253	if (SUCCEEDED(rc))
1254	{
1255	if (FAILED(rc)) return rc;
1256	// progress.queryInterfaceTo(aProgress);
1257
1258	/* create the networkInterfaceHelperClient() argument */
1259	NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
1260
1261	d->msgCode = SVCHlpMsg::EnableStaticIpConfig;
1262	d->guid = Guid(guid);
1263	d->iface = pIf;
1264	d->u.StaticIP.IPAddress = ip;
1265	d->u.StaticIP.IPNetMask = mask;
1266
1267	rc = vBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
1268	netIfNetworkInterfaceHelperClient,
1269	static_cast<void *>(d),
1270	progress);
1271	/* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
1272
1273	if (SUCCEEDED(rc))
1274	{
1275	progress->WaitForCompletion(-1);
1276	}
1277	}
1278	}
1279	}
1280	}
1281
1282	return SUCCEEDED(rc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
1283	#endif
1284	}
1285
1286	int NetIfEnableStaticIpConfigV6(VirtualBox vBox, HostNetworkInterface pIf, IN_BSTR aOldIPV6Address,
1287	IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength)
1288	{
1289	RT_NOREF(aOldIPV6Address);
1290	#ifndef VBOX_WITH_NETFLT
1291	return VERR_NOT_IMPLEMENTED;
1292	#else
1293	Bstr guid;
1294	HRESULT rc = pIf->COMGETTER(Id)(guid.asOutParam());
1295	if (SUCCEEDED(rc))
1296	{
1297	// ComPtr<VirtualBox> vBox;
1298	// rc = pIf->getVirtualBox(vBox.asOutParam());
1299	// if (SUCCEEDED(rc))
1300	{
1301	/* create a progress object */
1302	ComObjPtr<Progress> progress;
1303	progress.createObject();
1304	// ComPtr<IHost> host;
1305	// HRESULT rc = vBox->COMGETTER(Host)(host.asOutParam());
1306	// if (SUCCEEDED(rc))
1307	{
1308	rc = progress->init(vBox, (IHostNetworkInterface*)pIf,
1309	Bstr("Enabling Dynamic Ip Configuration").raw(),
1310	FALSE /* aCancelable */);
1311	if (SUCCEEDED(rc))
1312	{
1313	if (FAILED(rc)) return rc;
1314	// progress.queryInterfaceTo(aProgress);
1315
1316	/* create the networkInterfaceHelperClient() argument */
1317	NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
1318
1319	d->msgCode = SVCHlpMsg::EnableStaticIpConfigV6;
1320	d->guid = guid;
1321	d->iface = pIf;
1322	d->u.StaticIPV6.IPV6Address = aIPV6Address;
1323	d->u.StaticIPV6.IPV6NetMaskLength = aIPV6MaskPrefixLength;
1324
1325	rc = vBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
1326	netIfNetworkInterfaceHelperClient,
1327	static_cast<void *>(d),
1328	progress);
1329	/* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
1330
1331	if (SUCCEEDED(rc))
1332	{
1333	progress->WaitForCompletion(-1);
1334	}
1335	}
1336	}
1337	}
1338	}
1339
1340	return SUCCEEDED(rc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
1341	#endif
1342	}
1343
1344	int NetIfEnableDynamicIpConfig(VirtualBox vBox, HostNetworkInterface pIf)
1345	{
1346	#ifndef VBOX_WITH_NETFLT
1347	return VERR_NOT_IMPLEMENTED;
1348	#else
1349	HRESULT rc;
1350	Bstr guid;
1351	rc = pIf->COMGETTER(Id)(guid.asOutParam());
1352	if (SUCCEEDED(rc))
1353	{
1354	// ComPtr<VirtualBox> vBox;
1355	// rc = pIf->getVirtualBox(vBox.asOutParam());
1356	// if (SUCCEEDED(rc))
1357	{
1358	/* create a progress object */
1359	ComObjPtr<Progress> progress;
1360	progress.createObject();
1361	// ComPtr<IHost> host;
1362	// HRESULT rc = vBox->COMGETTER(Host)(host.asOutParam());
1363	// if (SUCCEEDED(rc))
1364	{
1365	rc = progress->init(vBox, (IHostNetworkInterface*)pIf,
1366	Bstr("Enabling Dynamic Ip Configuration").raw(),
1367	FALSE /* aCancelable */);
1368	if (SUCCEEDED(rc))
1369	{
1370	if (FAILED(rc)) return rc;
1371	// progress.queryInterfaceTo(aProgress);
1372
1373	/* create the networkInterfaceHelperClient() argument */
1374	NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
1375
1376	d->msgCode = SVCHlpMsg::EnableDynamicIpConfig;
1377	d->guid = guid;
1378	d->iface = pIf;
1379
1380	rc = vBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
1381	netIfNetworkInterfaceHelperClient,
1382	static_cast<void *>(d),
1383	progress);
1384	/* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
1385
1386	if (SUCCEEDED(rc))
1387	{
1388	progress->WaitForCompletion(-1);
1389	}
1390	}
1391	}
1392	}
1393	}
1394
1395	return SUCCEEDED(rc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
1396	#endif
1397	}
1398
1399	int NetIfDhcpRediscover(VirtualBox vBox, HostNetworkInterface pIf)
1400	{
1401	#ifndef VBOX_WITH_NETFLT
1402	return VERR_NOT_IMPLEMENTED;
1403	#else
1404	HRESULT rc;
1405	Bstr guid;
1406	rc = pIf->COMGETTER(Id)(guid.asOutParam());
1407	if (SUCCEEDED(rc))
1408	{
1409	// ComPtr<VirtualBox> vBox;
1410	// rc = pIf->getVirtualBox(vBox.asOutParam());
1411	// if (SUCCEEDED(rc))
1412	{
1413	/* create a progress object */
1414	ComObjPtr<Progress> progress;
1415	progress.createObject();
1416	// ComPtr<IHost> host;
1417	// HRESULT rc = vBox->COMGETTER(Host)(host.asOutParam());
1418	// if (SUCCEEDED(rc))
1419	{
1420	rc = progress->init(vBox, (IHostNetworkInterface*)pIf,
1421	Bstr("Enabling Dynamic Ip Configuration").raw(),
1422	FALSE /* aCancelable */);
1423	if (SUCCEEDED(rc))
1424	{
1425	if (FAILED(rc)) return rc;
1426	// progress.queryInterfaceTo(aProgress);
1427
1428	/* create the networkInterfaceHelperClient() argument */
1429	NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
1430
1431	d->msgCode = SVCHlpMsg::DhcpRediscover;
1432	d->guid = guid;
1433	d->iface = pIf;
1434
1435	rc = vBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
1436	netIfNetworkInterfaceHelperClient,
1437	static_cast<void *>(d),
1438	progress);
1439	/* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
1440
1441	if (SUCCEEDED(rc))
1442	{
1443	progress->WaitForCompletion(-1);
1444	}
1445	}
1446	}
1447	}
1448	}
1449
1450	return SUCCEEDED(rc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
1451	#endif
1452	}
1453
1454
1455	#define netIfLog LogFunc
1456
1457	struct BoundAdapter
1458	{
1459	LPWSTR pName;
1460	LPWSTR pHwId;
1461	RTUUID guid;
1462	PIP_ADAPTER_ADDRESSES pAdapter;
1463	BOOL fWireless;
1464	};
1465
1466	static int netIfGetUnboundHostOnlyAdapters(INetCfg *pNetCfg, std::list<BoundAdapter> &adapters)
1467	{
1468	INetCfgComponent *pMiniport;
1469	HRESULT hr;
1470	IEnumNetCfgComponent *pEnumComponent;
1471
1472	if ((hr = pNetCfg->EnumComponents(&GUID_DEVCLASS_NET, &pEnumComponent)) != S_OK)
1473	LogRelFunc(("failed to enumerate network adapter components (0x%x)\n", hr));
1474	else
1475	{
1476	while ((hr = pEnumComponent->Next(1, &pMiniport, NULL)) == S_OK)
1477	{
1478	GUID guid;
1479	ULONG uComponentStatus;
1480	struct BoundAdapter adapter;
1481	memset(&adapter, 0, sizeof(adapter));
1482	if ((hr = pMiniport->GetDisplayName(&adapter.pName)) != S_OK)
1483	LogRelFunc(("failed to get device display name (0x%x)\n", hr));
1484	else if ((hr = pMiniport->GetDeviceStatus(&uComponentStatus)) != S_OK)
1485	netIfLog(("failed to get device status (0x%x)\n", hr));
1486	else if (uComponentStatus != 0)
1487	netIfLog(("wrong device status (0x%x)\n", uComponentStatus));
1488	else if ((hr = pMiniport->GetId(&adapter.pHwId)) != S_OK)
1489	LogRelFunc(("failed to get device id (0x%x)\n", hr));
1490	else if (_wcsnicmp(adapter.pHwId, L"sun_VBoxNetAdp", sizeof(L"sun_VBoxNetAdp")/2))
1491	netIfLog(("not host-only id = %ls, ignored\n", adapter.pHwId));
1492	else if ((hr = pMiniport->GetInstanceGuid(&guid)) != S_OK)
1493	LogRelFunc(("failed to get instance id (0x%x)\n", hr));
1494	else
1495	{
1496	adapter.guid = *(Guid(guid).raw());
1497	netIfLog(("guid=%RTuuid, name=%ls id = %ls\n", &adapter.guid, adapter.pName, adapter.pHwId));
1498	adapters.push_back(adapter);
1499	adapter.pName = adapter.pHwId = NULL; /* do not free, will be done later */
1500	}
1501	if (adapter.pHwId)
1502	CoTaskMemFree(adapter.pHwId);
1503	if (adapter.pName)
1504	CoTaskMemFree(adapter.pName);
1505	pMiniport->Release();
1506	}
1507	Assert(hr == S_OK \|\| hr == S_FALSE);
1508
1509	pEnumComponent->Release();
1510	}
1511	netIfLog(("return\n"));
1512	return VINF_SUCCESS;
1513	}
1514
1515	#define DEVNAME_PREFIX L"\\\\.\\"
1516
1517	static BOOL netIfIsWireless(INetCfgComponent *pAdapter)
1518	{
1519	bool fWireless = false;
1520
1521	/* Construct a device name. */
1522	LPWSTR pwszBindName = NULL;
1523	HRESULT hrc = pAdapter->GetBindName(&pwszBindName);
1524	if (SUCCEEDED(hrc) && pwszBindName)
1525	{
1526	WCHAR wszFileName[MAX_PATH];
1527	int vrc = RTUtf16Copy(wszFileName, MAX_PATH, DEVNAME_PREFIX);
1528	if (RT_SUCCESS(vrc))
1529	vrc = RTUtf16Cat(wszFileName, MAX_PATH, pwszBindName);
1530	if (RT_SUCCESS(vrc))
1531	{
1532	/* open the device */
1533	HANDLE hDevice = CreateFileW(wszFileName,
1534	GENERIC_READ \| GENERIC_WRITE, FILE_SHARE_READ \| FILE_SHARE_WRITE,
1535	NULL,
1536	OPEN_EXISTING,
1537	FILE_ATTRIBUTE_NORMAL,
1538	NULL);
1539	if (hDevice != INVALID_HANDLE_VALUE)
1540	{
1541	/* now issue the OID_GEN_PHYSICAL_MEDIUM query */
1542	DWORD Oid = OID_GEN_PHYSICAL_MEDIUM;
1543	NDIS_PHYSICAL_MEDIUM PhMedium = NdisPhysicalMediumUnspecified;
1544	DWORD cbResultIgn = 0;
1545	if (DeviceIoControl(hDevice,
1546	IOCTL_NDIS_QUERY_GLOBAL_STATS,
1547	&Oid,
1548	sizeof(Oid),
1549	&PhMedium,
1550	sizeof(PhMedium),
1551	&cbResultIgn,
1552	NULL))
1553	{
1554	/* that was simple, now examine PhMedium */
1555	fWireless = PhMedium == NdisPhysicalMediumWirelessWan
1556	\|\| PhMedium == NdisPhysicalMediumWirelessLan
1557	\|\| PhMedium == NdisPhysicalMediumNative802_11
1558	\|\| PhMedium == NdisPhysicalMediumBluetooth;
1559	}
1560	else
1561	{
1562	DWORD rcWin = GetLastError();
1563	LogRel(("netIfIsWireless: DeviceIoControl to '%ls' failed with rcWin=%u (%#x) - ignoring\n",
1564	wszFileName, rcWin, rcWin));
1565	Assert(rcWin == ERROR_INVALID_PARAMETER \|\| rcWin == ERROR_NOT_SUPPORTED \|\| rcWin == ERROR_BAD_COMMAND);
1566	}
1567	CloseHandle(hDevice);
1568	}
1569	else
1570	{
1571	DWORD rcWin = GetLastError();
1572	#if 0 /* bird: Triggers on each VBoxSVC startup so, disabled. Whoever want it, can enable using DEBUG_xxxx. */
1573	AssertLogRelMsgFailed(("netIfIsWireless: CreateFile on '%ls' failed with rcWin=%u (%#x) - ignoring\n",
1574	wszFileName, rcWin, rcWin));
1575	#else
1576	LogRel(("netIfIsWireless: CreateFile on '%ls' failed with rcWin=%u (%#x) - ignoring\n",
1577	wszFileName, rcWin, rcWin));
1578	#endif
1579	}
1580	}
1581	CoTaskMemFree(pwszBindName);
1582	}
1583	else
1584	LogRel(("netIfIsWireless: GetBindName failed hrc=%Rhrc\n", hrc));
1585
1586	return fWireless;
1587	}
1588
1589	static HRESULT netIfGetBoundAdapters(std::list<BoundAdapter> &boundAdapters)
1590	{
1591	INetCfg *pNetCfg = NULL;
1592	INetCfgComponent *pFilter;
1593	LPWSTR lpszApp;
1594	HRESULT hr;
1595
1596	netIfLog(("building the list of interfaces\n"));
1597	/* we are using the INetCfg API for getting the list of miniports */
1598	hr = VBoxNetCfgWinQueryINetCfg(&pNetCfg, FALSE,
1599	VBOX_APP_NAME,
1600	10000,
1601	&lpszApp);
1602	Assert(hr == S_OK);
1603	if (hr != S_OK)
1604	{
1605	LogRelFunc(("failed to query INetCfg (0x%x)\n", hr));
1606	return hr;
1607	}
1608
1609	if ((hr = pNetCfg->FindComponent(L"oracle_VBoxNetLwf", &pFilter)) != S_OK
1610	/* fall back to NDIS5 miniport lookup */
1611	&& (hr = pNetCfg->FindComponent(L"sun_VBoxNetFlt", &pFilter)))
1612	LogRelFunc(("could not find either 'oracle_VBoxNetLwf' or 'sun_VBoxNetFlt' components (0x%x)\n", hr));
1613	else
1614	{
1615	INetCfgComponentBindings *pFilterBindings;
1616	if ((pFilter->QueryInterface(IID_INetCfgComponentBindings, (PVOID*)&pFilterBindings)) != S_OK)
1617	LogRelFunc(("failed to query INetCfgComponentBindings (0x%x)\n", hr));
1618	else
1619	{
1620	IEnumNetCfgBindingPath *pEnumBp;
1621	INetCfgBindingPath *pBp;
1622	if ((pFilterBindings->EnumBindingPaths(EBP_BELOW, &pEnumBp)) != S_OK)
1623	LogRelFunc(("failed to enumerate binding paths (0x%x)\n", hr));
1624	else
1625	{
1626	pEnumBp->Reset();
1627	while ((hr = pEnumBp->Next(1, &pBp, NULL)) == S_OK)
1628	{
1629	IEnumNetCfgBindingInterface *pEnumBi;
1630	INetCfgBindingInterface *pBi;
1631	if (pBp->IsEnabled() != S_OK)
1632	{
1633	/** @todo some id of disabled path could be useful. */
1634	netIfLog(("INetCfgBindingPath is disabled (0x%x)\n", hr));
1635	pBp->Release();
1636	continue;
1637	}
1638	if ((pBp->EnumBindingInterfaces(&pEnumBi)) != S_OK)
1639	LogRelFunc(("failed to enumerate binding interfaces (0x%x)\n", hr));
1640	else
1641	{
1642	hr = pEnumBi->Reset();
1643	while ((hr = pEnumBi->Next(1, &pBi, NULL)) == S_OK)
1644	{
1645	INetCfgComponent *pAdapter;
1646	if ((hr = pBi->GetLowerComponent(&pAdapter)) != S_OK)
1647	LogRelFunc(("failed to get lower component (0x%x)\n", hr));
1648	else
1649	{
1650	LPWSTR pwszName = NULL;
1651	if ((hr = pAdapter->GetDisplayName(&pwszName)) != S_OK)
1652	LogRelFunc(("failed to get display name (0x%x)\n", hr));
1653	else
1654	{
1655	ULONG uStatus;
1656	DWORD dwChars;
1657	if ((hr = pAdapter->GetDeviceStatus(&uStatus)) != S_OK)
1658	netIfLog(("%ls: failed to get device status (0x%x)\n",
1659	pwszName, hr));
1660	else if ((hr = pAdapter->GetCharacteristics(&dwChars)) != S_OK)
1661	netIfLog(("%ls: failed to get device characteristics (0x%x)\n",
1662	pwszName, hr));
1663	else if (uStatus != 0)
1664	netIfLog(("%ls: wrong status 0x%x\n",
1665	pwszName, uStatus));
1666	else if (dwChars & NCF_HIDDEN)
1667	netIfLog(("%ls: wrong characteristics 0x%x\n",
1668	pwszName, dwChars));
1669	else
1670	{
1671	GUID guid;
1672	LPWSTR pwszHwId = NULL;
1673	if ((hr = pAdapter->GetId(&pwszHwId)) != S_OK)
1674	LogRelFunc(("%ls: failed to get hardware id (0x%x)\n",
1675	pwszName, hr));
1676	else if (!_wcsnicmp(pwszHwId, L"sun_VBoxNetAdp", sizeof(L"sun_VBoxNetAdp")/2))
1677	netIfLog(("host-only adapter %ls, ignored\n", pwszName));
1678	else if ((hr = pAdapter->GetInstanceGuid(&guid)) != S_OK)
1679	LogRelFunc(("%ls: failed to get instance GUID (0x%x)\n",
1680	pwszName, hr));
1681	else
1682	{
1683	struct BoundAdapter adapter;
1684	adapter.pName = pwszName;
1685	adapter.pHwId = pwszHwId;
1686	adapter.guid = *(Guid(guid).raw());
1687	adapter.pAdapter = NULL;
1688	adapter.fWireless = netIfIsWireless(pAdapter);
1689	netIfLog(("guid=%RTuuid, name=%ls, hwid=%ls, status=%x, chars=%x\n",
1690	&adapter.guid, pwszName, pwszHwId, uStatus, dwChars));
1691	boundAdapters.push_back(adapter);
1692	pwszName = pwszHwId = NULL; /* do not free, will be done later */
1693	}
1694	if (pwszHwId)
1695	CoTaskMemFree(pwszHwId);
1696	}
1697	if (pwszName)
1698	CoTaskMemFree(pwszName);
1699	}
1700
1701	pAdapter->Release();
1702	}
1703	pBi->Release();
1704	}
1705	pEnumBi->Release();
1706	}
1707	pBp->Release();
1708	}
1709	pEnumBp->Release();
1710	}
1711	pFilterBindings->Release();
1712	}
1713	pFilter->Release();
1714	}
1715	/* Host-only adapters are not necessarily bound, add them separately. */
1716	netIfGetUnboundHostOnlyAdapters(pNetCfg, boundAdapters);
1717	VBoxNetCfgWinReleaseINetCfg(pNetCfg, FALSE);
1718
1719	return S_OK;
1720	}
1721
1722	#if 0
1723	static HRESULT netIfGetBoundAdaptersFallback(std::list<BoundAdapter> &boundAdapters)
1724	{
1725	return CO_E_NOT_SUPPORTED;
1726	}
1727	#endif
1728
1729	/**
1730	* Walk through the list of adpater addresses and extract the required
1731	* information. XP and older don't not have the OnLinkPrefixLength field.
1732	*/
1733	static void netIfFillInfoWithAddressesXp(PNETIFINFO pInfo, PIP_ADAPTER_ADDRESSES pAdapter)
1734	{
1735	PIP_ADAPTER_UNICAST_ADDRESS pAddr;
1736	bool fIPFound = false;
1737	bool fIPv6Found = false;
1738	for (pAddr = pAdapter->FirstUnicastAddress; pAddr; pAddr = pAddr->Next)
1739	{
1740	switch (pAddr->Address.lpSockaddr->sa_family)
1741	{
1742	case AF_INET:
1743	if (!fIPFound)
1744	{
1745	fIPFound = true;
1746	memcpy(&pInfo->IPAddress,
1747	&((struct sockaddr_in *)pAddr->Address.lpSockaddr)->sin_addr.s_addr,
1748	sizeof(pInfo->IPAddress));
1749	}
1750	break;
1751	case AF_INET6:
1752	if (!fIPv6Found)
1753	{
1754	fIPv6Found = true;
1755	memcpy(&pInfo->IPv6Address,
1756	((struct sockaddr_in6 *)pAddr->Address.lpSockaddr)->sin6_addr.s6_addr,
1757	sizeof(pInfo->IPv6Address));
1758	}
1759	break;
1760	}
1761	}
1762	PIP_ADAPTER_PREFIX pPrefix;
1763	ULONG uPrefixLenV4 = 0;
1764	ULONG uPrefixLenV6 = 0;
1765	for (pPrefix = pAdapter->FirstPrefix; pPrefix && !(uPrefixLenV4 && uPrefixLenV6); pPrefix = pPrefix->Next)
1766	{
1767	switch (pPrefix->Address.lpSockaddr->sa_family)
1768	{
1769	case AF_INET:
1770	if (!uPrefixLenV4)
1771	{
1772	ULONG ip = ((PSOCKADDR_IN)(pPrefix->Address.lpSockaddr))->sin_addr.s_addr;
1773	netIfLog(("prefix=%RTnaipv4 len=%u\n", ip, pPrefix->PrefixLength));
1774	if ( pPrefix->PrefixLength < sizeof(pInfo->IPNetMask) * 8
1775	&& pPrefix->PrefixLength > 0
1776	&& (ip & 0xF0) < 224)
1777	{
1778	uPrefixLenV4 = pPrefix->PrefixLength;
1779	RTNetPrefixToMaskIPv4(pPrefix->PrefixLength, &pInfo->IPNetMask);
1780	}
1781	else
1782	netIfLog(("Unexpected IPv4 prefix length of %d\n",
1783	pPrefix->PrefixLength));
1784	}
1785	break;
1786	case AF_INET6:
1787	if (!uPrefixLenV6)
1788	{
1789	PBYTE ipv6 = ((PSOCKADDR_IN6)(pPrefix->Address.lpSockaddr))->sin6_addr.s6_addr;
1790	netIfLog(("prefix=%RTnaipv6 len=%u\n", ipv6, pPrefix->PrefixLength));
1791	if ( pPrefix->PrefixLength < sizeof(pInfo->IPv6NetMask) * 8
1792	&& pPrefix->PrefixLength > 0
1793	&& ipv6[0] != 0xFF)
1794	{
1795	uPrefixLenV6 = pPrefix->PrefixLength;
1796	RTNetPrefixToMaskIPv6(pPrefix->PrefixLength, &pInfo->IPv6NetMask);
1797	}
1798	else
1799	netIfLog(("Unexpected IPv6 prefix length of %d\n", pPrefix->PrefixLength));
1800	}
1801	break;
1802	}
1803	}
1804	netIfLog(("%RTnaipv4/%u\n", pInfo->IPAddress, uPrefixLenV4));
1805	netIfLog(("%RTnaipv6/%u\n", &pInfo->IPv6Address, uPrefixLenV6));
1806	}
1807
1808	/**
1809	* Walk through the list of adpater addresses and extract the required
1810	* information. XP and older don't not have the OnLinkPrefixLength field.
1811	*/
1812	static void netIfFillInfoWithAddressesVista(PNETIFINFO pInfo, PIP_ADAPTER_ADDRESSES pAdapter)
1813	{
1814	PIP_ADAPTER_UNICAST_ADDRESS pAddr;
1815
1816	if (sizeof(pInfo->MACAddress) != pAdapter->PhysicalAddressLength)
1817	netIfLog(("Unexpected physical address length: %u\n", pAdapter->PhysicalAddressLength));
1818	else
1819	memcpy(pInfo->MACAddress.au8, pAdapter->PhysicalAddress, sizeof(pInfo->MACAddress));
1820
1821	bool fIPFound = false;
1822	bool fIPv6Found = false;
1823	for (pAddr = pAdapter->FirstUnicastAddress; pAddr; pAddr = pAddr->Next)
1824	{
1825	PIP_ADAPTER_UNICAST_ADDRESS_LH pAddrLh = (PIP_ADAPTER_UNICAST_ADDRESS_LH)pAddr;
1826	switch (pAddrLh->Address.lpSockaddr->sa_family)
1827	{
1828	case AF_INET:
1829	if (!fIPFound)
1830	{
1831	fIPFound = true;
1832	memcpy(&pInfo->IPAddress,
1833	&((struct sockaddr_in *)pAddrLh->Address.lpSockaddr)->sin_addr.s_addr,
1834	sizeof(pInfo->IPAddress));
1835	if (pAddrLh->OnLinkPrefixLength > 32)
1836	netIfLog(("Invalid IPv4 prefix length of %d\n", pAddrLh->OnLinkPrefixLength));
1837	else
1838	RTNetPrefixToMaskIPv4(pAddrLh->OnLinkPrefixLength, &pInfo->IPNetMask);
1839	}
1840	break;
1841	case AF_INET6:
1842	if (!fIPv6Found)
1843	{
1844	fIPv6Found = true;
1845	memcpy(&pInfo->IPv6Address,
1846	((struct sockaddr_in6 *)pAddrLh->Address.lpSockaddr)->sin6_addr.s6_addr,
1847	sizeof(pInfo->IPv6Address));
1848	if (pAddrLh->OnLinkPrefixLength > 128)
1849	netIfLog(("Invalid IPv6 prefix length of %d\n", pAddrLh->OnLinkPrefixLength));
1850	else
1851	RTNetPrefixToMaskIPv6(pAddrLh->OnLinkPrefixLength, &pInfo->IPv6NetMask);
1852	}
1853	break;
1854	}
1855	}
1856
1857	if (fIPFound)
1858	{
1859	int iPrefixIPv4 = -1;
1860	RTNetMaskToPrefixIPv4(&pInfo->IPNetMask, &iPrefixIPv4);
1861	netIfLog(("%RTnaipv4/%u\n", pInfo->IPAddress, iPrefixIPv4));
1862	}
1863	if (fIPv6Found)
1864	{
1865	int iPrefixIPv6 = -1;
1866	RTNetMaskToPrefixIPv6(&pInfo->IPv6NetMask, &iPrefixIPv6);
1867	netIfLog(("%RTnaipv6/%u\n", &pInfo->IPv6Address, iPrefixIPv6));
1868	}
1869	}
1870
1871	#if (NTDDI_VERSION >= NTDDI_VISTA)
1872	#define NETIF_GAA_FLAGS GAA_FLAG_SKIP_ANYCAST \| GAA_FLAG_SKIP_MULTICAST
1873	#else /* (NTDDI_VERSION < NTDDI_VISTA) */
1874	#define NETIF_GAA_FLAGS GAA_FLAG_INCLUDE_PREFIX \| GAA_FLAG_SKIP_ANYCAST \| GAA_FLAG_SKIP_MULTICAST
1875	#endif /* (NTDDI_VERSION < NTDDI_VISTA) */
1876
1877	int NetIfList(std::list<ComObjPtr<HostNetworkInterface> > &list)
1878	{
1879	HRESULT hr = S_OK;
1880	int iDefault = getDefaultInterfaceIndex();
1881	/* MSDN recommends to pre-allocate a 15KB buffer. */
1882	ULONG uBufLen = 15 * 1024;
1883	PIP_ADAPTER_ADDRESSES pAddresses = (PIP_ADAPTER_ADDRESSES)RTMemAlloc(uBufLen);
1884	if (!pAddresses)
1885	return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
1886	DWORD dwRc = GetAdaptersAddresses(AF_UNSPEC, NETIF_GAA_FLAGS, NULL, pAddresses, &uBufLen);
1887	for (int tries = 0; tries < 3 && dwRc == ERROR_BUFFER_OVERFLOW; ++tries)
1888	{
1889	/* Get more memory and try again. */
1890	RTMemFree(pAddresses);
1891	pAddresses = (PIP_ADAPTER_ADDRESSES)RTMemAlloc(uBufLen);
1892	if (!pAddresses)
1893	return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
1894	dwRc = GetAdaptersAddresses(AF_UNSPEC, NETIF_GAA_FLAGS, NULL, pAddresses, &uBufLen);
1895	}
1896	if (dwRc != NO_ERROR)
1897	{
1898	LogRelFunc(("GetAdaptersAddresses failed (0x%x)\n", dwRc));
1899	hr = HRESULT_FROM_WIN32(dwRc);
1900	}
1901	else
1902	{
1903	std::list<BoundAdapter> boundAdapters;
1904	HRESULT hr = netIfGetBoundAdapters(boundAdapters);
1905	#if 0
1906	if (hr != S_OK)
1907	hr = netIfGetBoundAdaptersFallback(boundAdapters);
1908	#endif
1909	if (hr != S_OK)
1910	LogRelFunc(("netIfGetBoundAdapters failed (0x%x)\n", hr));
1911	else
1912	{
1913	PIP_ADAPTER_ADDRESSES pAdapter;
1914
1915	for (pAdapter = pAddresses; pAdapter; pAdapter = pAdapter->Next)
1916	{
1917	char *pszUuid = RTStrDup(pAdapter->AdapterName);
1918	if (!pszUuid)
1919	{
1920	LogRelFunc(("out of memory\n"));
1921	break;
1922	}
1923	size_t len = strlen(pszUuid) - 1;
1924	if (pszUuid[0] != '{' \|\| pszUuid[len] != '}')
1925	LogRelFunc(("ignoring invalid GUID %s\n", pAdapter->AdapterName));
1926	else
1927	{
1928	std::list<BoundAdapter>::iterator it;
1929	pszUuid[len] = 0;
1930	for (it = boundAdapters.begin(); it != boundAdapters.end(); ++it)
1931	{
1932	if (!RTUuidCompareStr(&(*it).guid, pszUuid + 1))
1933	{
1934	(*it).pAdapter = pAdapter;
1935	break;
1936	}
1937	}
1938	}
1939	RTStrFree(pszUuid);
1940	}
1941	std::list<BoundAdapter>::iterator it;
1942	for (it = boundAdapters.begin(); it != boundAdapters.end(); ++it)
1943	{
1944	NETIFINFO info;
1945	memset(&info, 0, sizeof(info));
1946	info.Uuid = (*it).guid;
1947	info.enmMediumType = NETIF_T_ETHERNET;
1948	info.fWireless = (*it).fWireless;
1949	pAdapter = (*it).pAdapter;
1950	if (pAdapter)
1951	{
1952	info.enmStatus = pAdapter->OperStatus == IfOperStatusUp ? NETIF_S_UP : NETIF_S_DOWN;
1953	info.fIsDefault = (pAdapter->IfIndex == (DWORD)iDefault);
1954	info.fDhcpEnabled = pAdapter->Flags & IP_ADAPTER_DHCP_ENABLED;
1955	OSVERSIONINFOEX OSInfoEx;
1956	RT_ZERO(OSInfoEx);
1957	OSInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1958	if ( GetVersionEx((LPOSVERSIONINFO)&OSInfoEx)
1959	&& OSInfoEx.dwMajorVersion < 6)
1960	netIfFillInfoWithAddressesXp(&info, pAdapter);
1961	else
1962	netIfFillInfoWithAddressesVista(&info, pAdapter);
1963	}
1964	else
1965	info.enmStatus = NETIF_S_DOWN;
1966	/* create a new object and add it to the list */
1967	ComObjPtr<HostNetworkInterface> iface;
1968	iface.createObject();
1969	HostNetworkInterfaceType enmType =
1970	_wcsnicmp((*it).pHwId, L"sun_VBoxNetAdp", sizeof(L"sun_VBoxNetAdp")/2) ?
1971	HostNetworkInterfaceType_Bridged : HostNetworkInterfaceType_HostOnly;
1972	netIfLog(("Adding %ls as %s\n", (*it).pName,
1973	enmType == HostNetworkInterfaceType_Bridged ? "bridged" :
1974	enmType == HostNetworkInterfaceType_HostOnly ? "host-only" : "unknown"));
1975	int rc = iface->init((*it).pName, enmType, &info);
1976	if (FAILED(rc))
1977	LogRelFunc(("HostNetworkInterface::init() -> %Rrc\n", rc));
1978	else
1979	{
1980	if (info.fIsDefault)
1981	list.push_front(iface);
1982	else
1983	list.push_back(iface);
1984	}
1985	if ((*it).pHwId)
1986	CoTaskMemFree((*it).pHwId);
1987	if ((*it).pName)
1988	CoTaskMemFree((*it).pName);
1989	}
1990	}
1991	}
1992	RTMemFree(pAddresses);
1993
1994	return hr;
1995	}

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

source: vbox/trunk/src/VBox/Main/src-server/win/NetIf-win.cpp@ 76900

Download in other formats: