NetIf-win.cpp@ 57639

Last change on this file since 57639 was 57639, checked in by vboxsync, 9 years ago
Main/Network: report errors from VBoxNetCfg back to VBoxManage (#7973)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 65.9 KB

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

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

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

Download in other formats: