VBoxNetLwf-win.cpp@ 59971

Last change on this file since 59971 was 59971, checked in by vboxsync, 9 years ago
NetLwf/Win(bugref:8283): re-enabled dynamic re-allocation of frame pool, jumbo frames are allowed
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 111.6 KB

Line
1	/* $Id: VBoxNetLwf-win.cpp 59971 2016-03-09 16:15:06Z vboxsync $ */
2	/** @file
3	* VBoxNetLwf-win.cpp - NDIS6 Bridged Networking Driver, Windows-specific code.
4	*/
5	/*
6	* Copyright (C) 2014-2015 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*/
16	#define LOG_GROUP LOG_GROUP_NET_FLT_DRV
17
18	//#define VBOXNETLWF_TEST_NO_FRAMES_OVER_2K
19	//#define VBOXNETLWF_TEST_NO_REALLOCATE
20
21	//#define VBOXNETLWF_SYNC_SEND
22	/* Payload + Ethernet header + VLAN tag = Max Ethernet frame size */
23	#define VBOXNETLWF_MAX_FRAME_SIZE(mtu) (mtu + sizeof(RTNETETHERHDR) + 4)
24
25	#include <VBox/version.h>
26	#include <VBox/err.h>
27	#include <iprt/initterm.h>
28	#include <iprt/net.h>
29	#include <iprt/list.h>
30	#include <VBox/intnetinline.h>
31
32	/// @todo Not sure why, but can it help with build errors?
33	RT_C_DECLS_BEGIN
34	/* ntddk.h has a missing #pragma pack(), work around it
35	* see #ifdef VBOX_WITH_WORKAROUND_MISSING_PACK below for detail */
36	#define VBOX_WITH_WORKAROUND_MISSING_PACK
37	#if (_MSC_VER >= 1400) && !defined(VBOX_WITH_PATCHED_DDK)
38	# define _InterlockedExchange _InterlockedExchange_StupidDDKVsCompilerCrap
39	# define _InterlockedExchangeAdd _InterlockedExchangeAdd_StupidDDKVsCompilerCrap
40	# define _InterlockedCompareExchange _InterlockedCompareExchange_StupidDDKVsCompilerCrap
41	# define _InterlockedAddLargeStatistic _InterlockedAddLargeStatistic_StupidDDKVsCompilerCrap
42	# define _interlockedbittestandset _interlockedbittestandset_StupidDDKVsCompilerCrap
43	# define _interlockedbittestandreset _interlockedbittestandreset_StupidDDKVsCompilerCrap
44	# define _interlockedbittestandset64 _interlockedbittestandset64_StupidDDKVsCompilerCrap
45	# define _interlockedbittestandreset64 _interlockedbittestandreset64_StupidDDKVsCompilerCrap
46	# pragma warning(disable : 4163)
47	# ifdef VBOX_WITH_WORKAROUND_MISSING_PACK
48	# pragma warning(disable : 4103)
49	# endif
50	# include <ntddk.h>
51	# pragma warning(default : 4163)
52	# ifdef VBOX_WITH_WORKAROUND_MISSING_PACK
53	# pragma pack()
54	# pragma warning(default : 4103)
55	# endif
56	# undef _InterlockedExchange
57	# undef _InterlockedExchangeAdd
58	# undef _InterlockedCompareExchange
59	# undef _InterlockedAddLargeStatistic
60	# undef _interlockedbittestandset
61	# undef _interlockedbittestandreset
62	# undef _interlockedbittestandset64
63	# undef _interlockedbittestandreset64
64	# include <ndis.h>
65	# include <netioapi.h>
66	#else
67	# include <ntddk.h>
68	# include <netioapi.h>
69	/* can include ndis.h right away */
70	# include <ndis.h>
71	#endif
72	#include <mstcpip.h>
73	RT_C_DECLS_END
74
75	#define LogError(x) DbgPrint x
76
77	#if 0
78	#undef Log
79	#define Log(x) DbgPrint x
80	#undef LogFlow
81	#define LogFlow(x) DbgPrint x
82	#endif
83
84	/** We have an entirely different structure than the one defined in VBoxNetFltCmn-win.h */
85	typedef struct VBOXNETFLTWIN
86	{
87	/** filter module context handle */
88	NDIS_HANDLE hModuleCtx;
89	/** IP address change notifier handle */
90	HANDLE hNotifier; /* Must be here as hModuleCtx may already be NULL when vboxNetFltOsDeleteInstance is called */
91	} VBOXNETFLTWIN, *PVBOXNETFLTWIN;
92	#define VBOXNETFLT_NO_PACKET_QUEUE
93	#define VBOXNETFLT_OS_SPECFIC 1
94	#include "VBoxNetFltInternal.h"
95
96	#include "VBoxNetLwf-win.h"
97	#include "VBox/VBoxNetCmn-win.h"
98
99	/* Forward declarations */
100	FILTER_ATTACH vboxNetLwfWinAttach;
101	FILTER_DETACH vboxNetLwfWinDetach;
102	FILTER_RESTART vboxNetLwfWinRestart;
103	FILTER_PAUSE vboxNetLwfWinPause;
104	FILTER_OID_REQUEST vboxNetLwfWinOidRequest;
105	FILTER_OID_REQUEST_COMPLETE vboxNetLwfWinOidRequestComplete;
106	//FILTER_CANCEL_OID_REQUEST vboxNetLwfWinCancelOidRequest;
107	FILTER_STATUS vboxNetLwfWinStatus;
108	//FILTER_NET_PNP_EVENT vboxNetLwfWinPnPEvent;
109	FILTER_SEND_NET_BUFFER_LISTS vboxNetLwfWinSendNetBufferLists;
110	FILTER_SEND_NET_BUFFER_LISTS_COMPLETE vboxNetLwfWinSendNetBufferListsComplete;
111	FILTER_RECEIVE_NET_BUFFER_LISTS vboxNetLwfWinReceiveNetBufferLists;
112	FILTER_RETURN_NET_BUFFER_LISTS vboxNetLwfWinReturnNetBufferLists;
113	KSTART_ROUTINE vboxNetLwfWinInitIdcWorker;
114
115	typedef enum {
116	LwfState_Detached = 0,
117	LwfState_Attaching,
118	LwfState_Paused,
119	LwfState_Restarting,
120	LwfState_Running,
121	LwfState_Pausing,
122	LwfState_32BitHack = 0x7fffffff
123	} VBOXNETLWFSTATE;
124
125	/*
126	* Valid state transitions are:
127	* 1) Disconnected -> Connecting : start the worker thread, attempting to init IDC;
128	* 2) Connecting -> Disconnected : failed to start IDC init worker thread;
129	* 3) Connecting -> Connected : IDC init successful, terminate the worker;
130	* 4) Connecting -> Stopping : IDC init incomplete, but the driver is being unloaded, terminate the worker;
131	* 5) Connected -> Stopping : IDC init was successful, no worker, the driver is being unloaded;
132	*
133	* Driver terminates in Stopping state.
134	*/
135	typedef enum {
136	LwfIdcState_Disconnected = 0, /* Initial state */
137	LwfIdcState_Connecting, /* Attemping to init IDC, worker thread running */
138	LwfIdcState_Connected, /* Successfully connected to IDC, worker thread terminated */
139	LwfIdcState_Stopping /* Terminating the worker thread and disconnecting IDC */
140	} VBOXNETLWFIDCSTATE;
141
142	struct _VBOXNETLWF_MODULE;
143
144	typedef struct VBOXNETLWFGLOBALS
145	{
146	/** synch event used for device creation synchronization */
147	//KEVENT SynchEvent;
148	/** Device reference count */
149	//int cDeviceRefs;
150	/** ndis device */
151	NDIS_HANDLE hDevice;
152	/** device object */
153	PDEVICE_OBJECT pDevObj;
154	/** our filter driver handle */
155	NDIS_HANDLE hFilterDriver;
156	/** lock protecting the module list */
157	NDIS_SPIN_LOCK Lock;
158	/** the head of module list */
159	RTLISTANCHOR listModules;
160	/** IDC initialization state */
161	volatile uint32_t enmIdcState;
162	/** IDC init thread handle */
163	HANDLE hInitIdcThread;
164	} VBOXNETLWFGLOBALS, *PVBOXNETLWFGLOBALS;
165
166	/**
167	* The (common) global data.
168	*/
169	static VBOXNETFLTGLOBALS g_VBoxNetFltGlobals;
170	/* win-specific global data */
171	VBOXNETLWFGLOBALS g_VBoxNetLwfGlobals;
172
173	typedef struct _VBOXNETLWF_MODULE {
174	RTLISTNODE node;
175
176	NDIS_HANDLE hFilter;
177	NDIS_HANDLE hPool;
178	PVBOXNETLWFGLOBALS pGlobals;
179	/** Associated instance of NetFlt, one-to-one relationship */
180	PVBOXNETFLTINS pNetFlt; /// @todo Consider automic access!
181	/** Module state as described in http://msdn.microsoft.com/en-us/library/windows/hardware/ff550017(v=vs.85).aspx */
182	volatile uint32_t enmState; /* No lock needed yet, atomic should suffice. */
183	/** Mutex to prevent pausing while transmitting on behalf of NetFlt */
184	NDIS_MUTEX InTransmit;
185	#ifdef VBOXNETLWF_SYNC_SEND
186	/** Event signalled when sending to the wire is complete */
187	KEVENT EventWire;
188	/** Event signalled when NDIS returns our receive notification */
189	KEVENT EventHost;
190	#else /* !VBOXNETLWF_SYNC_SEND */
191	/** Event signalled when all pending sends (both to wire and host) have completed */
192	NDIS_EVENT EventSendComplete;
193	/** Counter for pending sends (both to wire and host) */
194	int32_t cPendingBuffers;
195	/** Work Item to deliver offloading indications at passive IRQL */
196	NDIS_HANDLE hWorkItem;
197	#endif /* !VBOXNETLWF_SYNC_SEND */
198	/** MAC address of underlying adapter */
199	RTMAC MacAddr;
200	/** Saved MTU size */
201	ULONG uMtuSize;
202	/** Saved offload configuration */
203	NDIS_OFFLOAD SavedOffloadConfig;
204	/** the cloned request we have passed down */
205	PNDIS_OID_REQUEST pPendingRequest;
206	/** true if the underlying miniport supplied offloading config */
207	bool fOffloadConfigValid;
208	/** true if the trunk expects data from us */
209	bool fActive;
210	/** true if the host wants the adapter to be in promisc mode */
211	bool fHostPromisc;
212	/** Name of underlying adapter */
213	char szMiniportName[1];
214	} VBOXNETLWF_MODULE;
215	typedef VBOXNETLWF_MODULE *PVBOXNETLWF_MODULE;
216
217	/*
218	* A structure to wrap OID requests in.
219	*/
220	typedef struct _VBOXNETLWF_OIDREQ {
221	NDIS_OID_REQUEST Request;
222	NDIS_STATUS Status;
223	NDIS_EVENT Event;
224	} VBOXNETLWF_OIDREQ;
225	typedef VBOXNETLWF_OIDREQ *PVBOXNETLWF_OIDREQ;
226
227	/* Forward declarations */
228	static VOID vboxNetLwfWinUnloadDriver(IN PDRIVER_OBJECT pDriver);
229	static int vboxNetLwfWinInitBase();
230	static int vboxNetLwfWinFini();
231
232	/**
233	* Logs an error to the system event log.
234	*
235	* @param ErrCode Error to report to event log.
236	* @param ReturnedStatus Error that was reported by the driver to the caller.
237	* @param uErrId Unique error id representing the location in the driver.
238	* @param cbDumpData Number of bytes at pDumpData.
239	* @param pDumpData Pointer to data that will be added to the message (see 'details' tab).
240	*/
241	static void vboxNetLwfLogErrorEvent(NTSTATUS uErrCode, NTSTATUS uReturnedStatus, ULONG uErrId)
242	{
243	/* Figure out how many modules are attached and if they are going to fit into the dump data. */
244	unsigned cMaxModules = (ERROR_LOG_MAXIMUM_SIZE - FIELD_OFFSET(IO_ERROR_LOG_PACKET, DumpData)) / sizeof(RTMAC);
245	unsigned cModules = 0;
246	PVBOXNETLWF_MODULE pModuleCtx = NULL;
247	NdisAcquireSpinLock(&g_VBoxNetLwfGlobals.Lock);
248	RTListForEach(&g_VBoxNetLwfGlobals.listModules, pModuleCtx, VBOXNETLWF_MODULE, node)
249	++cModules;
250	NdisReleaseSpinLock(&g_VBoxNetLwfGlobals.Lock);
251	/* Prevent overflow */
252	if (cModules > cMaxModules)
253	cModules = cMaxModules;
254
255	/* DumpDataSize must be a multiple of sizeof(ULONG). */
256	unsigned cbDumpData = (cModules * sizeof(RTMAC) + 3) & ~3;
257	/* Prevent underflow */
258	unsigned cbTotal = RT_MAX(FIELD_OFFSET(IO_ERROR_LOG_PACKET, DumpData) + cbDumpData,
259	sizeof(IO_ERROR_LOG_PACKET));
260
261	PIO_ERROR_LOG_PACKET pErrEntry;
262	pErrEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(g_VBoxNetLwfGlobals.pDevObj,
263	(UCHAR)cbTotal);
264	if (pErrEntry)
265	{
266	PRTMAC pDump = (PRTMAC)pErrEntry->DumpData;
267	/*
268	* Initialize the whole structure with zeros in case we are suddenly short
269	* of data because the list is empty or has become smaller.
270	*/
271	memset(pErrEntry, 0, cbTotal);
272
273	NdisAcquireSpinLock(&g_VBoxNetLwfGlobals.Lock);
274	RTListForEach(&g_VBoxNetLwfGlobals.listModules, pModuleCtx, VBOXNETLWF_MODULE, node)
275	{
276	/* The list could have been modified while we were allocating the entry, rely on cModules instead! */
277	if (cModules-- == 0)
278	break;
279	*pDump++ = pModuleCtx->MacAddr;
280	}
281	NdisReleaseSpinLock(&g_VBoxNetLwfGlobals.Lock);
282
283	pErrEntry->DumpDataSize = cbDumpData;
284	pErrEntry->ErrorCode = uErrCode;
285	pErrEntry->UniqueErrorValue = uErrId;
286	pErrEntry->FinalStatus = uReturnedStatus;
287	IoWriteErrorLogEntry(pErrEntry);
288	}
289	else
290	{
291	DbgPrint("Failed to allocate error log entry (cb=%u)\n", cbTotal);
292	}
293	}
294
295	#ifdef DEBUG
296	static const char *vboxNetLwfWinStatusToText(NDIS_STATUS code)
297	{
298	switch (code)
299	{
300	case NDIS_STATUS_MEDIA_CONNECT: return "NDIS_STATUS_MEDIA_CONNECT";
301	case NDIS_STATUS_MEDIA_DISCONNECT: return "NDIS_STATUS_MEDIA_DISCONNECT";
302	case NDIS_STATUS_RESET_START: return "NDIS_STATUS_RESET_START";
303	case NDIS_STATUS_RESET_END: return "NDIS_STATUS_RESET_END";
304	case NDIS_STATUS_MEDIA_BUSY: return "NDIS_STATUS_MEDIA_BUSY";
305	case NDIS_STATUS_MEDIA_SPECIFIC_INDICATION: return "NDIS_STATUS_MEDIA_SPECIFIC_INDICATION";
306	case NDIS_STATUS_LINK_SPEED_CHANGE: return "NDIS_STATUS_LINK_SPEED_CHANGE";
307	case NDIS_STATUS_LINK_STATE: return "NDIS_STATUS_LINK_STATE";
308	case NDIS_STATUS_PORT_STATE: return "NDIS_STATUS_PORT_STATE";
309	case NDIS_STATUS_OPER_STATUS: return "NDIS_STATUS_OPER_STATUS";
310	case NDIS_STATUS_NETWORK_CHANGE: return "NDIS_STATUS_NETWORK_CHANGE";
311	case NDIS_STATUS_PACKET_FILTER: return "NDIS_STATUS_PACKET_FILTER";
312	case NDIS_STATUS_TASK_OFFLOAD_CURRENT_CONFIG: return "NDIS_STATUS_TASK_OFFLOAD_CURRENT_CONFIG";
313	case NDIS_STATUS_TASK_OFFLOAD_HARDWARE_CAPABILITIES: return "NDIS_STATUS_TASK_OFFLOAD_HARDWARE_CAPABILITIES";
314	case NDIS_STATUS_OFFLOAD_ENCASPULATION_CHANGE: return "NDIS_STATUS_OFFLOAD_ENCASPULATION_CHANGE";
315	case NDIS_STATUS_TCP_CONNECTION_OFFLOAD_HARDWARE_CAPABILITIES: return "NDIS_STATUS_TCP_CONNECTION_OFFLOAD_HARDWARE_CAPABILITIES";
316	}
317	return "unknown";
318	}
319
320	static void vboxNetLwfWinDumpFilterTypes(ULONG uFlags)
321	{
322	if (uFlags & NDIS_PACKET_TYPE_DIRECTED) Log5((" NDIS_PACKET_TYPE_DIRECTED\n"));
323	if (uFlags & NDIS_PACKET_TYPE_MULTICAST) Log5((" NDIS_PACKET_TYPE_MULTICAST\n"));
324	if (uFlags & NDIS_PACKET_TYPE_ALL_MULTICAST) Log5((" NDIS_PACKET_TYPE_ALL_MULTICAST\n"));
325	if (uFlags & NDIS_PACKET_TYPE_BROADCAST) Log5((" NDIS_PACKET_TYPE_BROADCAST\n"));
326	if (uFlags & NDIS_PACKET_TYPE_PROMISCUOUS) Log5((" NDIS_PACKET_TYPE_PROMISCUOUS\n"));
327	if (uFlags & NDIS_PACKET_TYPE_ALL_FUNCTIONAL) Log5((" NDIS_PACKET_TYPE_ALL_FUNCTIONAL\n"));
328	if (uFlags & NDIS_PACKET_TYPE_ALL_LOCAL) Log5((" NDIS_PACKET_TYPE_ALL_LOCAL\n"));
329	if (uFlags & NDIS_PACKET_TYPE_FUNCTIONAL) Log5((" NDIS_PACKET_TYPE_FUNCTIONAL\n"));
330	if (uFlags & NDIS_PACKET_TYPE_GROUP) Log5((" NDIS_PACKET_TYPE_GROUP\n"));
331	if (uFlags & NDIS_PACKET_TYPE_MAC_FRAME) Log5((" NDIS_PACKET_TYPE_MAC_FRAME\n"));
332	if (uFlags & NDIS_PACKET_TYPE_SMT) Log5((" NDIS_PACKET_TYPE_SMT\n"));
333	if (uFlags & NDIS_PACKET_TYPE_SOURCE_ROUTING) Log5((" NDIS_PACKET_TYPE_SOURCE_ROUTING\n"));
334	if (uFlags == 0) Log5((" NONE\n"));
335	}
336
337	DECLINLINE(void) vboxNetLwfWinDumpEncapsulation(const char *pcszText, ULONG uEncapsulation)
338	{
339	if (uEncapsulation == NDIS_ENCAPSULATION_NOT_SUPPORTED)
340	Log5(("%s not supported\n", pcszText));
341	else
342	{
343	Log5(("%s", pcszText));
344	if (uEncapsulation & NDIS_ENCAPSULATION_NULL)
345	Log5((" null"));
346	if (uEncapsulation & NDIS_ENCAPSULATION_IEEE_802_3)
347	Log5((" 802.3"));
348	if (uEncapsulation & NDIS_ENCAPSULATION_IEEE_802_3_P_AND_Q)
349	Log5((" 802.3pq"));
350	if (uEncapsulation & NDIS_ENCAPSULATION_IEEE_802_3_P_AND_Q_IN_OOB)
351	Log5((" 802.3pq(oob)"));
352	if (uEncapsulation & NDIS_ENCAPSULATION_IEEE_LLC_SNAP_ROUTED)
353	Log5((" LLC"));
354	Log5(("\n"));
355	}
356	}
357
358	DECLINLINE(const char *) vboxNetLwfWinSetOnOffText(ULONG uOnOff)
359	{
360	switch (uOnOff)
361	{
362	case NDIS_OFFLOAD_SET_NO_CHANGE: return "no change";
363	case NDIS_OFFLOAD_SET_ON: return "on";
364	case NDIS_OFFLOAD_SET_OFF: return "off";
365	}
366	return "unknown";
367	}
368
369	DECLINLINE(const char *) vboxNetLwfWinOnOffText(ULONG uOnOff)
370	{
371	switch (uOnOff)
372	{
373	case NDIS_OFFLOAD_NOT_SUPPORTED: return "off";
374	case NDIS_OFFLOAD_SUPPORTED: return "on";
375	}
376	return "unknown";
377	}
378
379	DECLINLINE(const char *) vboxNetLwfWinSupportedText(ULONG uSupported)
380	{
381	switch (uSupported)
382	{
383	case NDIS_OFFLOAD_NOT_SUPPORTED: return "not supported";
384	case NDIS_OFFLOAD_SUPPORTED: return "supported";
385	}
386	return "unknown";
387	}
388
389	static void vboxNetLwfWinDumpSetOffloadSettings(PNDIS_OFFLOAD pOffloadConfig)
390	{
391	vboxNetLwfWinDumpEncapsulation(" Checksum.IPv4Transmit.Encapsulation =", pOffloadConfig->Checksum.IPv4Transmit.Encapsulation);
392	Log5((" Checksum.IPv4Transmit.IpOptionsSupported = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv4Transmit.IpOptionsSupported)));
393	Log5((" Checksum.IPv4Transmit.TcpOptionsSupported = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv4Transmit.TcpOptionsSupported)));
394	Log5((" Checksum.IPv4Transmit.TcpChecksum = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv4Transmit.TcpChecksum)));
395	Log5((" Checksum.IPv4Transmit.UdpChecksum = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv4Transmit.UdpChecksum)));
396	Log5((" Checksum.IPv4Transmit.IpChecksum = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv4Transmit.IpChecksum)));
397	vboxNetLwfWinDumpEncapsulation(" Checksum.IPv4Receive.Encapsulation =", pOffloadConfig->Checksum.IPv4Receive.Encapsulation);
398	Log5((" Checksum.IPv4Receive.IpOptionsSupported = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv4Receive.IpOptionsSupported)));
399	Log5((" Checksum.IPv4Receive.TcpOptionsSupported = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv4Receive.TcpOptionsSupported)));
400	Log5((" Checksum.IPv4Receive.TcpChecksum = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv4Receive.TcpChecksum)));
401	Log5((" Checksum.IPv4Receive.UdpChecksum = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv4Receive.UdpChecksum)));
402	Log5((" Checksum.IPv4Receive.IpChecksum = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv4Receive.IpChecksum)));
403	vboxNetLwfWinDumpEncapsulation(" Checksum.IPv6Transmit.Encapsulation =", pOffloadConfig->Checksum.IPv6Transmit.Encapsulation);
404	Log5((" Checksum.IPv6Transmit.IpExtensionHeadersSupported = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv6Transmit.IpExtensionHeadersSupported)));
405	Log5((" Checksum.IPv6Transmit.TcpOptionsSupported = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv6Transmit.TcpOptionsSupported)));
406	Log5((" Checksum.IPv6Transmit.TcpChecksum = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv6Transmit.TcpChecksum)));
407	Log5((" Checksum.IPv6Transmit.UdpChecksum = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv6Transmit.UdpChecksum)));
408	vboxNetLwfWinDumpEncapsulation(" Checksum.IPv6Receive.Encapsulation =", pOffloadConfig->Checksum.IPv6Receive.Encapsulation);
409	Log5((" Checksum.IPv6Receive.IpExtensionHeadersSupported = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv6Receive.IpExtensionHeadersSupported)));
410	Log5((" Checksum.IPv6Receive.TcpOptionsSupported = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv6Receive.TcpOptionsSupported)));
411	Log5((" Checksum.IPv6Receive.TcpChecksum = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv6Receive.TcpChecksum)));
412	Log5((" Checksum.IPv6Receive.UdpChecksum = %s\n", vboxNetLwfWinSetOnOffText(pOffloadConfig->Checksum.IPv6Receive.UdpChecksum)));
413	vboxNetLwfWinDumpEncapsulation(" LsoV1.IPv4.Encapsulation =", pOffloadConfig->LsoV1.IPv4.Encapsulation);
414	Log5((" LsoV1.IPv4.TcpOptions = %s\n", vboxNetLwfWinSupportedText(pOffloadConfig->LsoV1.IPv4.TcpOptions)));
415	Log5((" LsoV1.IPv4.IpOptions = %s\n", vboxNetLwfWinSupportedText(pOffloadConfig->LsoV1.IPv4.IpOptions)));
416	vboxNetLwfWinDumpEncapsulation(" LsoV2.IPv4.Encapsulation =", pOffloadConfig->LsoV2.IPv4.Encapsulation);
417	vboxNetLwfWinDumpEncapsulation(" LsoV2.IPv6.Encapsulation =", pOffloadConfig->LsoV2.IPv6.Encapsulation);
418	Log5((" LsoV2.IPv6.IpExtensionHeadersSupported = %s\n", vboxNetLwfWinSupportedText(pOffloadConfig->LsoV2.IPv6.IpExtensionHeadersSupported)));
419	Log5((" LsoV2.IPv6.TcpOptionsSupported = %s\n", vboxNetLwfWinSupportedText(pOffloadConfig->LsoV2.IPv6.TcpOptionsSupported)));
420	}
421
422	static void vboxNetLwfWinDumpOffloadSettings(PNDIS_OFFLOAD pOffloadConfig)
423	{
424	vboxNetLwfWinDumpEncapsulation(" Checksum.IPv4Transmit.Encapsulation =", pOffloadConfig->Checksum.IPv4Transmit.Encapsulation);
425	Log5((" Checksum.IPv4Transmit.IpOptionsSupported = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv4Transmit.IpOptionsSupported)));
426	Log5((" Checksum.IPv4Transmit.TcpOptionsSupported = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv4Transmit.TcpOptionsSupported)));
427	Log5((" Checksum.IPv4Transmit.TcpChecksum = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv4Transmit.TcpChecksum)));
428	Log5((" Checksum.IPv4Transmit.UdpChecksum = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv4Transmit.UdpChecksum)));
429	Log5((" Checksum.IPv4Transmit.IpChecksum = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv4Transmit.IpChecksum)));
430	vboxNetLwfWinDumpEncapsulation(" Checksum.IPv4Receive.Encapsulation =", pOffloadConfig->Checksum.IPv4Receive.Encapsulation);
431	Log5((" Checksum.IPv4Receive.IpOptionsSupported = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv4Receive.IpOptionsSupported)));
432	Log5((" Checksum.IPv4Receive.TcpOptionsSupported = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv4Receive.TcpOptionsSupported)));
433	Log5((" Checksum.IPv4Receive.TcpChecksum = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv4Receive.TcpChecksum)));
434	Log5((" Checksum.IPv4Receive.UdpChecksum = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv4Receive.UdpChecksum)));
435	Log5((" Checksum.IPv4Receive.IpChecksum = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv4Receive.IpChecksum)));
436	vboxNetLwfWinDumpEncapsulation(" Checksum.IPv6Transmit.Encapsulation =", pOffloadConfig->Checksum.IPv6Transmit.Encapsulation);
437	Log5((" Checksum.IPv6Transmit.IpExtensionHeadersSupported = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv6Transmit.IpExtensionHeadersSupported)));
438	Log5((" Checksum.IPv6Transmit.TcpOptionsSupported = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv6Transmit.TcpOptionsSupported)));
439	Log5((" Checksum.IPv6Transmit.TcpChecksum = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv6Transmit.TcpChecksum)));
440	Log5((" Checksum.IPv6Transmit.UdpChecksum = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv6Transmit.UdpChecksum)));
441	vboxNetLwfWinDumpEncapsulation(" Checksum.IPv6Receive.Encapsulation =", pOffloadConfig->Checksum.IPv6Receive.Encapsulation);
442	Log5((" Checksum.IPv6Receive.IpExtensionHeadersSupported = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv6Receive.IpExtensionHeadersSupported)));
443	Log5((" Checksum.IPv6Receive.TcpOptionsSupported = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv6Receive.TcpOptionsSupported)));
444	Log5((" Checksum.IPv6Receive.TcpChecksum = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv6Receive.TcpChecksum)));
445	Log5((" Checksum.IPv6Receive.UdpChecksum = %s\n", vboxNetLwfWinOnOffText(pOffloadConfig->Checksum.IPv6Receive.UdpChecksum)));
446	vboxNetLwfWinDumpEncapsulation(" LsoV1.IPv4.Encapsulation =", pOffloadConfig->LsoV1.IPv4.Encapsulation);
447	Log5((" LsoV1.IPv4.TcpOptions = %s\n", vboxNetLwfWinSupportedText(pOffloadConfig->LsoV1.IPv4.TcpOptions)));
448	Log5((" LsoV1.IPv4.IpOptions = %s\n", vboxNetLwfWinSupportedText(pOffloadConfig->LsoV1.IPv4.IpOptions)));
449	vboxNetLwfWinDumpEncapsulation(" LsoV2.IPv4.Encapsulation =", pOffloadConfig->LsoV2.IPv4.Encapsulation);
450	vboxNetLwfWinDumpEncapsulation(" LsoV2.IPv6.Encapsulation =", pOffloadConfig->LsoV2.IPv6.Encapsulation);
451	Log5((" LsoV2.IPv6.IpExtensionHeadersSupported = %s\n", vboxNetLwfWinSupportedText(pOffloadConfig->LsoV2.IPv6.IpExtensionHeadersSupported)));
452	Log5((" LsoV2.IPv6.TcpOptionsSupported = %s\n", vboxNetLwfWinSupportedText(pOffloadConfig->LsoV2.IPv6.TcpOptionsSupported)));
453	}
454
455	static const char *vboxNetLwfWinStateToText(uint32_t enmState)
456	{
457	switch (enmState)
458	{
459	case LwfState_Detached: return "Detached";
460	case LwfState_Attaching: return "Attaching";
461	case LwfState_Paused: return "Paused";
462	case LwfState_Restarting: return "Restarting";
463	case LwfState_Running: return "Running";
464	case LwfState_Pausing: return "Pausing";
465	}
466	return "invalid";
467	}
468
469	#else /* !DEBUG */
470	#define vboxNetLwfWinDumpFilterTypes(uFlags)
471	#define vboxNetLwfWinDumpOffloadSettings(p)
472	#define vboxNetLwfWinDumpSetOffloadSettings(p)
473	#endif /* DEBUG */
474
475	DECLINLINE(bool) vboxNetLwfWinChangeState(PVBOXNETLWF_MODULE pModuleCtx, uint32_t enmNew, uint32_t enmOld = LwfState_32BitHack)
476	{
477	AssertReturn(pModuleCtx, false);
478
479	bool fSuccess = true;
480	if (enmOld != LwfState_32BitHack)
481	{
482	fSuccess = ASMAtomicCmpXchgU32(&pModuleCtx->enmState, enmNew, enmOld);
483	if (fSuccess)
484	Log(("vboxNetLwfWinChangeState: state change %s -> %s\n",
485	vboxNetLwfWinStateToText(enmOld),
486	vboxNetLwfWinStateToText(enmNew)));
487	else
488	Log(("ERROR! vboxNetLwfWinChangeState: failed state change %s (actual=%s) -> %s\n",
489	vboxNetLwfWinStateToText(enmOld),
490	vboxNetLwfWinStateToText(ASMAtomicReadU32(&pModuleCtx->enmState)),
491	vboxNetLwfWinStateToText(enmNew)));
492	Assert(fSuccess);
493	}
494	else
495	{
496	uint32_t enmPrevState = ASMAtomicXchgU32(&pModuleCtx->enmState, enmNew);
497	Log(("vboxNetLwfWinChangeState: state change %s -> %s\n",
498	vboxNetLwfWinStateToText(enmPrevState),
499	vboxNetLwfWinStateToText(enmNew)));
500	}
501	return fSuccess;
502	}
503
504	DECLINLINE(void) vboxNetLwfWinInitOidRequest(PVBOXNETLWF_OIDREQ pRequest)
505	{
506	NdisZeroMemory(pRequest, sizeof(VBOXNETLWF_OIDREQ));
507
508	NdisInitializeEvent(&pRequest->Event);
509
510	pRequest->Request.Header.Type = NDIS_OBJECT_TYPE_OID_REQUEST;
511	pRequest->Request.Header.Revision = NDIS_OID_REQUEST_REVISION_1;
512	pRequest->Request.Header.Size = NDIS_SIZEOF_OID_REQUEST_REVISION_1;
513
514	pRequest->Request.RequestId = (PVOID)VBOXNETLWF_REQ_ID;
515	}
516
517	static NDIS_STATUS vboxNetLwfWinSyncOidRequest(PVBOXNETLWF_MODULE pModuleCtx, PVBOXNETLWF_OIDREQ pRequest)
518	{
519	NDIS_STATUS Status = NdisFOidRequest(pModuleCtx->hFilter, &pRequest->Request);
520	if (Status == NDIS_STATUS_PENDING)
521	{
522	NdisWaitEvent(&pRequest->Event, 0);
523	Status = pRequest->Status;
524	}
525	return Status;
526	}
527
528	DECLINLINE(void) vboxNetLwfWinCopyOidRequestResults(PNDIS_OID_REQUEST pFrom, PNDIS_OID_REQUEST pTo)
529	{
530	switch (pFrom->RequestType)
531	{
532	case NdisRequestSetInformation:
533	pTo->DATA.SET_INFORMATION.BytesRead = pFrom->DATA.SET_INFORMATION.BytesRead;
534	pTo->DATA.SET_INFORMATION.BytesNeeded = pFrom->DATA.SET_INFORMATION.BytesNeeded;
535	break;
536	case NdisRequestMethod:
537	pTo->DATA.METHOD_INFORMATION.OutputBufferLength = pFrom->DATA.METHOD_INFORMATION.OutputBufferLength;
538	pTo->DATA.METHOD_INFORMATION.BytesWritten = pFrom->DATA.METHOD_INFORMATION.BytesWritten;
539	pTo->DATA.METHOD_INFORMATION.BytesRead = pFrom->DATA.METHOD_INFORMATION.BytesRead;
540	pTo->DATA.METHOD_INFORMATION.BytesNeeded = pFrom->DATA.METHOD_INFORMATION.BytesNeeded;
541	break;
542	case NdisRequestQueryInformation:
543	case NdisRequestQueryStatistics:
544	default:
545	pTo->DATA.QUERY_INFORMATION.BytesWritten = pFrom->DATA.QUERY_INFORMATION.BytesWritten;
546	pTo->DATA.QUERY_INFORMATION.BytesNeeded = pFrom->DATA.QUERY_INFORMATION.BytesNeeded;
547	}
548	}
549
550	void inline vboxNetLwfWinOverridePacketFiltersUp(PVBOXNETLWF_MODULE pModuleCtx, ULONG *pFilters)
551	{
552	if (ASMAtomicReadBool(&pModuleCtx->fActive) && !ASMAtomicReadBool(&pModuleCtx->fHostPromisc))
553	*pFilters &= ~NDIS_PACKET_TYPE_PROMISCUOUS;
554	}
555
556	NDIS_STATUS vboxNetLwfWinOidRequest(IN NDIS_HANDLE hModuleCtx,
557	IN PNDIS_OID_REQUEST pOidRequest)
558	{
559	LogFlow(("==>vboxNetLwfWinOidRequest: module=%p\n", hModuleCtx));
560	vboxNetCmnWinDumpOidRequest(__FUNCTION__, pOidRequest);
561	PVBOXNETLWF_MODULE pModuleCtx = (PVBOXNETLWF_MODULE)hModuleCtx;
562	PNDIS_OID_REQUEST pClone = NULL;
563	NDIS_STATUS Status = NdisAllocateCloneOidRequest(pModuleCtx->hFilter,
564	pOidRequest,
565	VBOXNETLWF_MEM_TAG,
566	&pClone);
567	if (Status == NDIS_STATUS_SUCCESS)
568	{
569	/* Save the pointer to the original */
570	((PNDIS_OID_REQUEST)(pClone->SourceReserved)) = pOidRequest;
571
572	pClone->RequestId = pOidRequest->RequestId;
573	/* We are not supposed to get another request until we are through with the one we "postponed" */
574	PNDIS_OID_REQUEST pPrev = ASMAtomicXchgPtrT(&pModuleCtx->pPendingRequest, pClone, PNDIS_OID_REQUEST);
575	Assert(pPrev == NULL);
576	pModuleCtx->pPendingRequest = pClone;
577	if (pOidRequest->RequestType == NdisRequestSetInformation
578	&& pOidRequest->DATA.SET_INFORMATION.Oid == OID_GEN_CURRENT_PACKET_FILTER)
579	{
580	ASMAtomicWriteBool(&pModuleCtx->fHostPromisc, !!((ULONG)pOidRequest->DATA.SET_INFORMATION.InformationBuffer & NDIS_PACKET_TYPE_PROMISCUOUS));
581	Log(("vboxNetLwfWinOidRequest: host wanted to set packet filter value to:\n"));
582	vboxNetLwfWinDumpFilterTypes((ULONG)pOidRequest->DATA.SET_INFORMATION.InformationBuffer);
583	/* Keep adapter in promisc mode as long as we are active. */
584	if (ASMAtomicReadBool(&pModuleCtx->fActive))
585	(ULONG)pClone->DATA.SET_INFORMATION.InformationBuffer \|= NDIS_PACKET_TYPE_PROMISCUOUS;
586	Log5(("vboxNetLwfWinOidRequest: pass the following packet filters to miniport:\n"));
587	vboxNetLwfWinDumpFilterTypes((ULONG)pOidRequest->DATA.SET_INFORMATION.InformationBuffer);
588	}
589	if (pOidRequest->RequestType == NdisRequestSetInformation
590	&& pOidRequest->DATA.SET_INFORMATION.Oid == OID_TCP_OFFLOAD_CURRENT_CONFIG)
591	{
592	Log5(("vboxNetLwfWinOidRequest: offloading set to:\n"));
593	vboxNetLwfWinDumpSetOffloadSettings((PNDIS_OFFLOAD)pOidRequest->DATA.SET_INFORMATION.InformationBuffer);
594	}
595
596	/* Forward the clone to underlying filters/miniport */
597	Status = NdisFOidRequest(pModuleCtx->hFilter, pClone);
598	if (Status != NDIS_STATUS_PENDING)
599	{
600	/* Synchronous completion */
601	pPrev = ASMAtomicXchgPtrT(&pModuleCtx->pPendingRequest, NULL, PNDIS_OID_REQUEST);
602	Assert(pPrev == pClone);
603	Log5(("vboxNetLwfWinOidRequest: got the following packet filters from miniport:\n"));
604	vboxNetLwfWinDumpFilterTypes((ULONG)pOidRequest->DATA.QUERY_INFORMATION.InformationBuffer);
605	/*
606	* The host does not expect the adapter to be in promisc mode,
607	* unless it enabled the mode. Let's not disillusion it.
608	*/
609	if ( pOidRequest->RequestType == NdisRequestQueryInformation
610	&& pOidRequest->DATA.QUERY_INFORMATION.Oid == OID_GEN_CURRENT_PACKET_FILTER)
611	vboxNetLwfWinOverridePacketFiltersUp(pModuleCtx, (ULONG*)pOidRequest->DATA.QUERY_INFORMATION.InformationBuffer);
612	Log5(("vboxNetLwfWinOidRequest: reporting to the host the following packet filters:\n"));
613	vboxNetLwfWinDumpFilterTypes((ULONG)pOidRequest->DATA.QUERY_INFORMATION.InformationBuffer);
614	vboxNetLwfWinCopyOidRequestResults(pClone, pOidRequest);
615	NdisFreeCloneOidRequest(pModuleCtx->hFilter, pClone);
616	}
617	/* In case of async completion we do the rest in vboxNetLwfWinOidRequestComplete() */
618	}
619	else
620	{
621	LogError(("vboxNetLwfWinOidRequest: NdisAllocateCloneOidRequest failed with 0x%x\n", Status));
622	}
623	LogFlow(("<==vboxNetLwfWinOidRequest: Status=0x%x\n", Status));
624	return Status;
625	}
626
627	VOID vboxNetLwfWinOidRequestComplete(IN NDIS_HANDLE hModuleCtx,
628	IN PNDIS_OID_REQUEST pRequest,
629	IN NDIS_STATUS Status)
630	{
631	LogFlow(("==>vboxNetLwfWinOidRequestComplete: module=%p req=%p status=0x%x\n", hModuleCtx, pRequest, Status));
632	PVBOXNETLWF_MODULE pModuleCtx = (PVBOXNETLWF_MODULE)hModuleCtx;
633	PNDIS_OID_REQUEST pOriginal = ((PNDIS_OID_REQUEST)(pRequest->SourceReserved));
634	if (pOriginal)
635	{
636	/* NDIS is supposed to serialize requests */
637	PNDIS_OID_REQUEST pPrev = ASMAtomicXchgPtrT(&pModuleCtx->pPendingRequest, NULL, PNDIS_OID_REQUEST);
638	Assert(pPrev == pRequest);
639
640	Log5(("vboxNetLwfWinOidRequestComplete: completed rq type=%d oid=%x\n", pRequest->RequestType, pRequest->DATA.QUERY_INFORMATION.Oid));
641	vboxNetLwfWinCopyOidRequestResults(pRequest, pOriginal);
642	if ( pRequest->RequestType == NdisRequestQueryInformation
643	&& pRequest->DATA.QUERY_INFORMATION.Oid == OID_GEN_CURRENT_PACKET_FILTER)
644	{
645	Log5(("vboxNetLwfWinOidRequestComplete: underlying miniport reports its packet filters:\n"));
646	vboxNetLwfWinDumpFilterTypes((ULONG)pRequest->DATA.QUERY_INFORMATION.InformationBuffer);
647	vboxNetLwfWinOverridePacketFiltersUp(pModuleCtx, (ULONG*)pRequest->DATA.QUERY_INFORMATION.InformationBuffer);
648	Log5(("vboxNetLwfWinOidRequestComplete: reporting the following packet filters to upper protocol:\n"));
649	vboxNetLwfWinDumpFilterTypes((ULONG)pRequest->DATA.QUERY_INFORMATION.InformationBuffer);
650	}
651	NdisFreeCloneOidRequest(pModuleCtx->hFilter, pRequest);
652	NdisFOidRequestComplete(pModuleCtx->hFilter, pOriginal, Status);
653	}
654	else
655	{
656	/* This is not a clone, we originated it */
657	Log(("vboxNetLwfWinOidRequestComplete: locally originated request (%p) completed, status=0x%x\n", pRequest, Status));
658	PVBOXNETLWF_OIDREQ pRqWrapper = RT_FROM_MEMBER(pRequest, VBOXNETLWF_OIDREQ, Request);
659	pRqWrapper->Status = Status;
660	NdisSetEvent(&pRqWrapper->Event);
661	}
662	LogFlow(("<==vboxNetLwfWinOidRequestComplete\n"));
663	}
664
665
666	static bool vboxNetLwfWinIsPromiscuous(PVBOXNETLWF_MODULE pModuleCtx)
667	{
668	return ASMAtomicReadBool(&pModuleCtx->fHostPromisc);
669	}
670
671	#if 0
672	static NDIS_STATUS vboxNetLwfWinGetPacketFilter(PVBOXNETLWF_MODULE pModuleCtx)
673	{
674	LogFlow(("==>vboxNetLwfWinGetPacketFilter: module=%p\n", pModuleCtx));
675	VBOXNETLWF_OIDREQ Rq;
676	vboxNetLwfWinInitOidRequest(&Rq);
677	Rq.Request.RequestType = NdisRequestQueryInformation;
678	Rq.Request.DATA.QUERY_INFORMATION.Oid = OID_GEN_CURRENT_PACKET_FILTER;
679	Rq.Request.DATA.QUERY_INFORMATION.InformationBuffer = &pModuleCtx->uPacketFilter;
680	Rq.Request.DATA.QUERY_INFORMATION.InformationBufferLength = sizeof(pModuleCtx->uPacketFilter);
681	NDIS_STATUS Status = vboxNetLwfWinSyncOidRequest(pModuleCtx, &Rq);
682	if (Status != NDIS_STATUS_SUCCESS)
683	{
684	LogError(("vboxNetLwfWinGetPacketFilter: vboxNetLwfWinSyncOidRequest(query, OID_GEN_CURRENT_PACKET_FILTER) failed with 0x%x\n", Status));
685	return FALSE;
686	}
687	if (Rq.Request.DATA.QUERY_INFORMATION.BytesWritten != sizeof(pModuleCtx->uPacketFilter))
688	{
689	LogError(("vboxNetLwfWinGetPacketFilter: vboxNetLwfWinSyncOidRequest(query, OID_GEN_CURRENT_PACKET_FILTER) failed to write neccessary amount (%d bytes), actually written %d bytes\n", sizeof(pModuleCtx->uPacketFilter), Rq.Request.DATA.QUERY_INFORMATION.BytesWritten));
690	}
691
692	Log5(("vboxNetLwfWinGetPacketFilter: OID_GEN_CURRENT_PACKET_FILTER query returned the following filters:\n"));
693	vboxNetLwfWinDumpFilterTypes(pModuleCtx->uPacketFilter);
694
695	LogFlow(("<==vboxNetLwfWinGetPacketFilter: status=0x%x\n", Status));
696	return Status;
697	}
698	#endif
699
700	static NDIS_STATUS vboxNetLwfWinSetPacketFilter(PVBOXNETLWF_MODULE pModuleCtx, bool fPromisc)
701	{
702	LogFlow(("==>vboxNetLwfWinSetPacketFilter: module=%p %s\n", pModuleCtx, fPromisc ? "promiscuous" : "normal"));
703	ULONG uFilter = 0;
704	VBOXNETLWF_OIDREQ Rq;
705	vboxNetLwfWinInitOidRequest(&Rq);
706	Rq.Request.RequestType = NdisRequestQueryInformation;
707	Rq.Request.DATA.QUERY_INFORMATION.Oid = OID_GEN_CURRENT_PACKET_FILTER;
708	Rq.Request.DATA.QUERY_INFORMATION.InformationBuffer = &uFilter;
709	Rq.Request.DATA.QUERY_INFORMATION.InformationBufferLength = sizeof(uFilter);
710	NDIS_STATUS Status = vboxNetLwfWinSyncOidRequest(pModuleCtx, &Rq);
711	if (Status != NDIS_STATUS_SUCCESS)
712	{
713	LogError(("vboxNetLwfWinSetPacketFilter: vboxNetLwfWinSyncOidRequest(query, OID_GEN_CURRENT_PACKET_FILTER) failed with 0x%x\n", Status));
714	return Status;
715	}
716	if (Rq.Request.DATA.QUERY_INFORMATION.BytesWritten != sizeof(uFilter))
717	{
718	LogError(("vboxNetLwfWinSetPacketFilter: vboxNetLwfWinSyncOidRequest(query, OID_GEN_CURRENT_PACKET_FILTER) failed to write neccessary amount (%d bytes), actually written %d bytes\n", sizeof(uFilter), Rq.Request.DATA.QUERY_INFORMATION.BytesWritten));
719	return NDIS_STATUS_FAILURE;
720	}
721
722	Log5(("vboxNetLwfWinSetPacketFilter: OID_GEN_CURRENT_PACKET_FILTER query returned the following filters:\n"));
723	vboxNetLwfWinDumpFilterTypes(uFilter);
724
725	if (fPromisc)
726	{
727	/* If we about to go promiscuous, save the state before we change it. */
728	ASMAtomicWriteBool(&pModuleCtx->fHostPromisc, !!(uFilter & NDIS_PACKET_TYPE_PROMISCUOUS));
729	uFilter \|= NDIS_PACKET_TYPE_PROMISCUOUS;
730	}
731	else
732	{
733	/* Reset promisc only if it was not enabled before we had changed it. */
734	if (!ASMAtomicReadBool(&pModuleCtx->fHostPromisc))
735	uFilter &= ~NDIS_PACKET_TYPE_PROMISCUOUS;
736	}
737
738	Log5(("vboxNetLwfWinSetPacketFilter: OID_GEN_CURRENT_PACKET_FILTER about to set the following filters:\n"));
739	vboxNetLwfWinDumpFilterTypes(uFilter);
740
741	NdisResetEvent(&Rq.Event); /* need to reset as it has been set by query op */
742	Rq.Request.RequestType = NdisRequestSetInformation;
743	Rq.Request.DATA.SET_INFORMATION.Oid = OID_GEN_CURRENT_PACKET_FILTER;
744	Rq.Request.DATA.SET_INFORMATION.InformationBuffer = &uFilter;
745	Rq.Request.DATA.SET_INFORMATION.InformationBufferLength = sizeof(uFilter);
746	Status = vboxNetLwfWinSyncOidRequest(pModuleCtx, &Rq);
747	if (Status != NDIS_STATUS_SUCCESS)
748	{
749	LogError(("vboxNetLwfWinSetPacketFilter: vboxNetLwfWinSyncOidRequest(set, OID_GEN_CURRENT_PACKET_FILTER, vvv below vvv) failed with 0x%x\n", Status));
750	vboxNetLwfWinDumpFilterTypes(uFilter);
751	}
752	LogFlow(("<==vboxNetLwfWinSetPacketFilter: status=0x%x\n", Status));
753	return Status;
754	}
755
756
757	static NTSTATUS vboxNetLwfWinDevDispatch(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
758	{
759	PIO_STACK_LOCATION pIrpSl = IoGetCurrentIrpStackLocation(pIrp);;
760	NTSTATUS Status = STATUS_SUCCESS;
761
762	switch (pIrpSl->MajorFunction)
763	{
764	case IRP_MJ_DEVICE_CONTROL:
765	Status = STATUS_NOT_SUPPORTED;
766	break;
767	case IRP_MJ_CREATE:
768	case IRP_MJ_CLEANUP:
769	case IRP_MJ_CLOSE:
770	break;
771	default:
772	Assert(0);
773	break;
774	}
775
776	pIrp->IoStatus.Status = Status;
777	IoCompleteRequest(pIrp, IO_NO_INCREMENT);
778
779	return Status;
780	}
781
782	/** @todo So far we had no use for device, should we even bother to create it? */
783	static NDIS_STATUS vboxNetLwfWinDevCreate(PVBOXNETLWFGLOBALS pGlobals)
784	{
785	NDIS_STRING DevName, LinkName;
786	PDRIVER_DISPATCH aMajorFunctions[IRP_MJ_MAXIMUM_FUNCTION+1];
787	NdisInitUnicodeString(&DevName, VBOXNETLWF_NAME_DEVICE);
788	NdisInitUnicodeString(&LinkName, VBOXNETLWF_NAME_LINK);
789
790	Assert(!pGlobals->hDevice);
791	Assert(!pGlobals->pDevObj);
792	NdisZeroMemory(aMajorFunctions, sizeof (aMajorFunctions));
793	aMajorFunctions[IRP_MJ_CREATE] = vboxNetLwfWinDevDispatch;
794	aMajorFunctions[IRP_MJ_CLEANUP] = vboxNetLwfWinDevDispatch;
795	aMajorFunctions[IRP_MJ_CLOSE] = vboxNetLwfWinDevDispatch;
796	aMajorFunctions[IRP_MJ_DEVICE_CONTROL] = vboxNetLwfWinDevDispatch;
797
798	NDIS_DEVICE_OBJECT_ATTRIBUTES DeviceAttributes;
799	NdisZeroMemory(&DeviceAttributes, sizeof(DeviceAttributes));
800	DeviceAttributes.Header.Type = NDIS_OBJECT_TYPE_DEVICE_OBJECT_ATTRIBUTES;
801	DeviceAttributes.Header.Revision = NDIS_DEVICE_OBJECT_ATTRIBUTES_REVISION_1;
802	DeviceAttributes.Header.Size = sizeof(DeviceAttributes);
803	DeviceAttributes.DeviceName = &DevName;
804	DeviceAttributes.SymbolicName = &LinkName;
805	DeviceAttributes.MajorFunctions = aMajorFunctions;
806	//DeviceAttributes.ExtensionSize = sizeof(FILTER_DEVICE_EXTENSION);
807
808	NDIS_STATUS Status = NdisRegisterDeviceEx(pGlobals->hFilterDriver,
809	&DeviceAttributes,
810	&pGlobals->pDevObj,
811	&pGlobals->hDevice);
812	Log(("vboxNetLwfWinDevCreate: NdisRegisterDeviceEx returned 0x%x\n", Status));
813	Assert(Status == NDIS_STATUS_SUCCESS);
814	#if 0
815	if (Status == NDIS_STATUS_SUCCESS)
816	{
817	PFILTER_DEVICE_EXTENSION pExtension;
818	pExtension = NdisGetDeviceReservedExtension(pGlobals->pDevObj);
819	pExtension->Signature = VBOXNETLWF_MEM_TAG;
820	pExtension->Handle = pGlobals->hFilterDriver;
821	}
822	#endif
823	return Status;
824	}
825
826	static void vboxNetLwfWinDevDestroy(PVBOXNETLWFGLOBALS pGlobals)
827	{
828	Assert(pGlobals->hDevice);
829	Assert(pGlobals->pDevObj);
830	NdisDeregisterDeviceEx(pGlobals->hDevice);
831	pGlobals->hDevice = NULL;
832	pGlobals->pDevObj = NULL;
833	}
834
835	static void vboxNetLwfWinUpdateSavedOffloadConfig(PVBOXNETLWF_MODULE pModuleCtx, PNDIS_OFFLOAD pOffload)
836	{
837	pModuleCtx->SavedOffloadConfig = *pOffload;
838	pModuleCtx->fOffloadConfigValid = true;
839	}
840
841	static NDIS_STATUS vboxNetLwfWinAttach(IN NDIS_HANDLE hFilter, IN NDIS_HANDLE hDriverCtx,
842	IN PNDIS_FILTER_ATTACH_PARAMETERS pParameters)
843	{
844	LogFlow(("==>vboxNetLwfWinAttach: filter=%p\n", hFilter));
845
846	PVBOXNETLWFGLOBALS pGlobals = (PVBOXNETLWFGLOBALS)hDriverCtx;
847	if (!pGlobals)
848	{
849	vboxNetLwfLogErrorEvent(IO_ERR_INTERNAL_ERROR, NDIS_STATUS_FAILURE, 1);
850	return NDIS_STATUS_FAILURE;
851	}
852
853	ANSI_STRING strMiniportName;
854	/* We use the miniport name to associate this filter module with the netflt instance */
855	NTSTATUS rc = RtlUnicodeStringToAnsiString(&strMiniportName,
856	pParameters->BaseMiniportName,
857	TRUE);
858	if (rc != STATUS_SUCCESS)
859	{
860	LogError(("vboxNetLwfWinAttach: RtlUnicodeStringToAnsiString(%ls) failed with 0x%x\n",
861	pParameters->BaseMiniportName, rc));
862	vboxNetLwfLogErrorEvent(IO_ERR_INTERNAL_ERROR, NDIS_STATUS_FAILURE, 2);
863	return NDIS_STATUS_FAILURE;
864	}
865	DbgPrint("vboxNetLwfWinAttach: friendly name=%wZ\n", pParameters->BaseMiniportInstanceName);
866	DbgPrint("vboxNetLwfWinAttach: name=%Z\n", &strMiniportName);
867
868	UINT cbModuleWithNameExtra = sizeof(VBOXNETLWF_MODULE) + strMiniportName.Length;
869	PVBOXNETLWF_MODULE pModuleCtx = (PVBOXNETLWF_MODULE)NdisAllocateMemoryWithTagPriority(hFilter,
870	cbModuleWithNameExtra,
871	VBOXNETLWF_MEM_TAG,
872	LowPoolPriority);
873	if (!pModuleCtx)
874	{
875	LogError(("vboxNetLwfWinAttach: Failed to allocate module context for %ls\n", pParameters->BaseMiniportName));
876	RtlFreeAnsiString(&strMiniportName);
877	vboxNetLwfLogErrorEvent(IO_ERR_INSUFFICIENT_RESOURCES, NDIS_STATUS_RESOURCES, 3);
878	return NDIS_STATUS_RESOURCES;
879	}
880	Log4(("vboxNetLwfWinAttach: allocated module context 0x%p\n", pModuleCtx));
881
882	NdisZeroMemory(pModuleCtx, cbModuleWithNameExtra);
883	NdisMoveMemory(pModuleCtx->szMiniportName, strMiniportName.Buffer, strMiniportName.Length);
884	RtlFreeAnsiString(&strMiniportName);
885
886	pModuleCtx->hWorkItem = NdisAllocateIoWorkItem(g_VBoxNetLwfGlobals.hFilterDriver);
887	if (!pModuleCtx->hWorkItem)
888	{
889	LogError(("vboxNetLwfWinAttach: Failed to allocate work item for %ls\n",
890	pParameters->BaseMiniportName));
891	NdisFreeMemory(pModuleCtx, 0, 0);
892	vboxNetLwfLogErrorEvent(IO_ERR_INSUFFICIENT_RESOURCES, NDIS_STATUS_RESOURCES, 4);
893	return NDIS_STATUS_RESOURCES;
894	}
895
896	Assert(pParameters->MacAddressLength == sizeof(RTMAC));
897	NdisMoveMemory(&pModuleCtx->MacAddr, pParameters->CurrentMacAddress, RT_MIN(sizeof(RTMAC), pParameters->MacAddressLength));
898	if (pParameters->DefaultOffloadConfiguration)
899	vboxNetLwfWinUpdateSavedOffloadConfig(pModuleCtx, pParameters->DefaultOffloadConfiguration);
900
901	pModuleCtx->pGlobals = pGlobals;
902	pModuleCtx->hFilter = hFilter;
903	vboxNetLwfWinChangeState(pModuleCtx, LwfState_Attaching);
904	/* Initialize transmission mutex and events */
905	NDIS_INIT_MUTEX(&pModuleCtx->InTransmit);
906	#ifdef VBOXNETLWF_SYNC_SEND
907	KeInitializeEvent(&pModuleCtx->EventWire, SynchronizationEvent, FALSE);
908	KeInitializeEvent(&pModuleCtx->EventHost, SynchronizationEvent, FALSE);
909	#else /* !VBOXNETLWF_SYNC_SEND */
910	NdisInitializeEvent(&pModuleCtx->EventSendComplete);
911	pModuleCtx->cPendingBuffers = 0;
912	#endif /* !VBOXNETLWF_SYNC_SEND */
913
914	#ifdef VBOXNETLWF_TEST_NO_REALLOCATE
915	/* Allocate buffer pools */
916	NET_BUFFER_LIST_POOL_PARAMETERS PoolParams;
917	NdisZeroMemory(&PoolParams, sizeof(PoolParams));
918	PoolParams.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
919	PoolParams.Header.Revision = NET_BUFFER_LIST_POOL_PARAMETERS_REVISION_1;
920	PoolParams.Header.Size = sizeof(PoolParams);
921	PoolParams.ProtocolId = NDIS_PROTOCOL_ID_DEFAULT;
922	PoolParams.fAllocateNetBuffer = TRUE;
923	PoolParams.ContextSize = 0; /** @todo Do we need to consider underlying drivers? I think not. */
924	PoolParams.PoolTag = VBOXNETLWF_MEM_TAG;
925	#ifndef VBOXNETLWF_SYNC_SEND
926	PoolParams.DataSize = 9088;
927	#endif /* !VBOXNETLWF_SYNC_SEND */
928
929	pModuleCtx->hPool = NdisAllocateNetBufferListPool(hFilter, &PoolParams);
930	if (!pModuleCtx->hPool)
931	{
932	LogError(("vboxNetLwfWinAttach: NdisAllocateNetBufferListPool failed\n"));
933	NdisFreeIoWorkItem(pModuleCtx->hWorkItem);
934	NdisFreeMemory(pModuleCtx, 0, 0);
935	return NDIS_STATUS_RESOURCES;
936	}
937	Log4(("vboxNetLwfWinAttach: allocated NBL+NB pool 0x%p\n", pModuleCtx->hPool));
938	#endif /* VBOXNETLWF_TEST_NO_REALLOCATE */
939
940	NDIS_FILTER_ATTRIBUTES Attributes;
941	NdisZeroMemory(&Attributes, sizeof(Attributes));
942	Attributes.Header.Revision = NDIS_FILTER_ATTRIBUTES_REVISION_1;
943	Attributes.Header.Size = sizeof(Attributes);
944	Attributes.Header.Type = NDIS_OBJECT_TYPE_FILTER_ATTRIBUTES;
945	Attributes.Flags = 0;
946	NDIS_STATUS Status = NdisFSetAttributes(hFilter, pModuleCtx, &Attributes);
947	if (Status != NDIS_STATUS_SUCCESS)
948	{
949	LogError(("vboxNetLwfWinAttach: NdisFSetAttributes failed with 0x%x\n", Status));
950	NdisFreeNetBufferListPool(pModuleCtx->hPool);
951	Log4(("vboxNetLwfWinAttach: freed NBL+NB pool 0x%p\n", pModuleCtx->hPool));
952	NdisFreeIoWorkItem(pModuleCtx->hWorkItem);
953	NdisFreeMemory(pModuleCtx, 0, 0);
954	vboxNetLwfLogErrorEvent(IO_ERR_INTERNAL_ERROR, NDIS_STATUS_RESOURCES, 5);
955	return NDIS_STATUS_RESOURCES;
956	}
957	/* Insert into module chain */
958	NdisAcquireSpinLock(&pGlobals->Lock);
959	RTListPrepend(&pGlobals->listModules, &pModuleCtx->node);
960	NdisReleaseSpinLock(&pGlobals->Lock);
961
962	vboxNetLwfWinChangeState(pModuleCtx, LwfState_Paused);
963
964	/// @todo Somehow the packet filter is 0 at this point: Status = vboxNetLwfWinGetPacketFilter(pModuleCtx);
965	/// @todo We actually update it later in status handler, perhaps we should not do anything here.
966
967	LogFlow(("<==vboxNetLwfWinAttach: Status = 0x%x\n", Status));
968	return Status;
969	}
970
971	static VOID vboxNetLwfWinDetach(IN NDIS_HANDLE hModuleCtx)
972	{
973	LogFlow(("==>vboxNetLwfWinDetach: module=%p\n", hModuleCtx));
974	PVBOXNETLWF_MODULE pModuleCtx = (PVBOXNETLWF_MODULE)hModuleCtx;
975	vboxNetLwfWinChangeState(pModuleCtx, LwfState_Detached, LwfState_Paused);
976
977	/* Remove from module chain */
978	NdisAcquireSpinLock(&pModuleCtx->pGlobals->Lock);
979	RTListNodeRemove(&pModuleCtx->node);
980	NdisReleaseSpinLock(&pModuleCtx->pGlobals->Lock);
981
982	PVBOXNETFLTINS pNetFltIns = pModuleCtx->pNetFlt; /// @todo Atomic?
983	if (pNetFltIns && vboxNetFltTryRetainBusyNotDisconnected(pNetFltIns))
984	{
985	/*
986	* Set hModuleCtx to null now in order to prevent filter restart,
987	* OID requests and other stuff associated with NetFlt deactivation.
988	*/
989	pNetFltIns->u.s.WinIf.hModuleCtx = NULL;
990	/* Notify NetFlt that we are going down */
991	pNetFltIns->pSwitchPort->pfnDisconnect(pNetFltIns->pSwitchPort, &pNetFltIns->MyPort, vboxNetFltPortReleaseBusy);
992	/* We do not 'release' netflt instance since it has been done by pfnDisconnect */
993	}
994	pModuleCtx->pNetFlt = NULL;
995
996	/*
997	* We have to make sure that all NET_BUFFER_LIST structures have been freed by now, but
998	* it does not require us to do anything here since it has already been taken care of
999	* by vboxNetLwfWinPause().
1000	*/
1001	if (pModuleCtx->hPool)
1002	{
1003	NdisFreeNetBufferListPool(pModuleCtx->hPool);
1004	Log4(("vboxNetLwfWinDetach: freed NBL+NB pool 0x%p\n", pModuleCtx->hPool));
1005	}
1006	NdisFreeIoWorkItem(pModuleCtx->hWorkItem);
1007	NdisFreeMemory(hModuleCtx, 0, 0);
1008	Log4(("vboxNetLwfWinDetach: freed module context 0x%p\n", pModuleCtx));
1009	LogFlow(("<==vboxNetLwfWinDetach\n"));
1010	}
1011
1012
1013	static NDIS_STATUS vboxNetLwfWinPause(IN NDIS_HANDLE hModuleCtx, IN PNDIS_FILTER_PAUSE_PARAMETERS pParameters)
1014	{
1015	LogFlow(("==>vboxNetLwfWinPause: module=%p\n", hModuleCtx));
1016	PVBOXNETLWF_MODULE pModuleCtx = (PVBOXNETLWF_MODULE)hModuleCtx;
1017	vboxNetLwfWinChangeState(pModuleCtx, LwfState_Pausing, LwfState_Running);
1018	/* Wait for pending send/indication operations to complete. */
1019	NDIS_WAIT_FOR_MUTEX(&pModuleCtx->InTransmit);
1020	#ifndef VBOXNETLWF_SYNC_SEND
1021	NdisWaitEvent(&pModuleCtx->EventSendComplete, 1000 /* ms */);
1022	#endif /* !VBOXNETLWF_SYNC_SEND */
1023	vboxNetLwfWinChangeState(pModuleCtx, LwfState_Paused, LwfState_Pausing);
1024	NDIS_RELEASE_MUTEX(&pModuleCtx->InTransmit);
1025	LogFlow(("<==vboxNetLwfWinPause\n"));
1026	return NDIS_STATUS_SUCCESS; /* Failure is not an option */
1027	}
1028
1029
1030	static void vboxNetLwfWinIndicateOffload(PVBOXNETLWF_MODULE pModuleCtx, PNDIS_OFFLOAD pOffload)
1031	{
1032	Log5(("vboxNetLwfWinIndicateOffload: offload config changed to:\n"));
1033	vboxNetLwfWinDumpOffloadSettings(pOffload);
1034	NDIS_STATUS_INDICATION OffloadingIndication;
1035	NdisZeroMemory(&OffloadingIndication, sizeof(OffloadingIndication));
1036	OffloadingIndication.Header.Type = NDIS_OBJECT_TYPE_STATUS_INDICATION;
1037	OffloadingIndication.Header.Revision = NDIS_STATUS_INDICATION_REVISION_1;
1038	OffloadingIndication.Header.Size = NDIS_SIZEOF_STATUS_INDICATION_REVISION_1;
1039	OffloadingIndication.SourceHandle = pModuleCtx->hFilter;
1040	OffloadingIndication.StatusCode = NDIS_STATUS_TASK_OFFLOAD_CURRENT_CONFIG;
1041	OffloadingIndication.StatusBuffer = pOffload;
1042	OffloadingIndication.StatusBufferSize = sizeof(NDIS_OFFLOAD);
1043	NdisFIndicateStatus(pModuleCtx->hFilter, &OffloadingIndication);
1044	}
1045
1046
1047	static NDIS_STATUS vboxNetLwfWinRestart(IN NDIS_HANDLE hModuleCtx, IN PNDIS_FILTER_RESTART_PARAMETERS pParameters)
1048	{
1049	LogFlow(("==>vboxNetLwfWinRestart: module=%p\n", hModuleCtx));
1050	PVBOXNETLWF_MODULE pModuleCtx = (PVBOXNETLWF_MODULE)hModuleCtx;
1051	vboxNetLwfWinChangeState(pModuleCtx, LwfState_Restarting, LwfState_Paused);
1052
1053	NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
1054	#ifndef VBOXNETLWF_TEST_NO_REALLOCATE
1055	ULONG uNewMtuSize = 1500; /* If we fail to find out MTU, we can always assume 1500. */
1056	PNDIS_RESTART_ATTRIBUTES pAttributes = pParameters->RestartAttributes;
1057	while (pAttributes && pAttributes->Oid != OID_GEN_MINIPORT_RESTART_ATTRIBUTES)
1058	pAttributes = pAttributes->Next;
1059	if (pAttributes)
1060	{
1061	PNDIS_RESTART_GENERAL_ATTRIBUTES pGenAttrs = (PNDIS_RESTART_GENERAL_ATTRIBUTES)pAttributes->Data;
1062	uNewMtuSize = pGenAttrs->MtuSize;
1063	}
1064
1065	/* Let's see if MTU has changed. Re-allocate the pool if it has. */
1066	if (pModuleCtx->uMtuSize != uNewMtuSize)
1067	{
1068	pModuleCtx->uMtuSize = uNewMtuSize;
1069	if (pModuleCtx->hPool)
1070	{
1071	/*
1072	* Don't need to wait for pending sends to complete since we are already
1073	* in paused state. Just free the old pool.
1074	*/
1075	NdisFreeNetBufferListPool(pModuleCtx->hPool);
1076	pModuleCtx->hPool = NULL;
1077	}
1078	}
1079	if (!pModuleCtx->hPool)
1080	{
1081	/* Allocate a new pool. */
1082	NET_BUFFER_LIST_POOL_PARAMETERS PoolParams;
1083	NdisZeroMemory(&PoolParams, sizeof(PoolParams));
1084	PoolParams.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
1085	PoolParams.Header.Revision = NET_BUFFER_LIST_POOL_PARAMETERS_REVISION_1;
1086	PoolParams.Header.Size = sizeof(PoolParams);
1087	PoolParams.ProtocolId = NDIS_PROTOCOL_ID_DEFAULT;
1088	PoolParams.fAllocateNetBuffer = TRUE;
1089	PoolParams.ContextSize = 0; /** @todo Do we need to consider underlying drivers? I think not. */
1090	PoolParams.PoolTag = VBOXNETLWF_MEM_TAG;
1091	#ifndef VBOXNETLWF_SYNC_SEND
1092	PoolParams.DataSize = VBOXNETLWF_MAX_FRAME_SIZE(pModuleCtx->uMtuSize);
1093	#endif /* !VBOXNETLWF_SYNC_SEND */
1094
1095	pModuleCtx->hPool = NdisAllocateNetBufferListPool(pModuleCtx->hFilter, &PoolParams);
1096	if (!pModuleCtx->hPool)
1097	{
1098	LogError(("vboxNetLwfWinRestart: NdisAllocateNetBufferListPool failed\n"));
1099	Status = NDIS_STATUS_RESOURCES;
1100	}
1101	else
1102	{
1103	Log4(("vboxNetLwfWinRestart: allocated NBL+NB pool 0x%p with MTU=%u\n",
1104	pModuleCtx->hPool, pModuleCtx->uMtuSize));
1105	}
1106	}
1107
1108	vboxNetLwfWinChangeState(pModuleCtx, Status == NDIS_STATUS_SUCCESS ? LwfState_Running : LwfState_Paused, LwfState_Restarting);
1109	#else /* !VBOXNETLWF_TEST_NO_REALLOCATE */
1110	vboxNetLwfWinChangeState(pModuleCtx, LwfState_Running, LwfState_Restarting);
1111	#endif /* !VBOXNETLWF_TEST_NO_REALLOCATE */
1112	LogFlow(("<==vboxNetLwfWinRestart: Status = 0x%x\n", Status));
1113	return Status;
1114	}
1115
1116
1117	static void vboxNetLwfWinDumpPackets(const char *pszMsg, PNET_BUFFER_LIST pBufLists)
1118	{
1119	for (PNET_BUFFER_LIST pList = pBufLists; pList; pList = NET_BUFFER_LIST_NEXT_NBL(pList))
1120	{
1121	for (PNET_BUFFER pBuf = NET_BUFFER_LIST_FIRST_NB(pList); pBuf; pBuf = NET_BUFFER_NEXT_NB(pBuf))
1122	{
1123	Log(("%s packet: cb=%d\n", pszMsg, NET_BUFFER_DATA_LENGTH(pBuf)));
1124	}
1125	}
1126	}
1127
1128	DECLINLINE(const char *) vboxNetLwfWinEthTypeStr(uint16_t uType)
1129	{
1130	switch (uType)
1131	{
1132	case RTNET_ETHERTYPE_IPV4: return "IP";
1133	case RTNET_ETHERTYPE_IPV6: return "IPv6";
1134	case RTNET_ETHERTYPE_ARP: return "ARP";
1135	}
1136	return "unknown";
1137	}
1138
1139	#define VBOXNETLWF_PKTDMPSIZE 0x50
1140
1141	/**
1142	* Dump a packet to debug log.
1143	*
1144	* @param cpPacket The packet.
1145	* @param cb The size of the packet.
1146	* @param cszText A string denoting direction of packet transfer.
1147	*/
1148	DECLINLINE(void) vboxNetLwfWinDumpPacket(PCINTNETSG pSG, const char *cszText)
1149	{
1150	uint8_t bPacket[VBOXNETLWF_PKTDMPSIZE];
1151
1152	uint32_t cb = pSG->cbTotal < VBOXNETLWF_PKTDMPSIZE ? pSG->cbTotal : VBOXNETLWF_PKTDMPSIZE;
1153	IntNetSgReadEx(pSG, 0, cb, bPacket);
1154
1155	AssertReturnVoid(cb >= 14);
1156
1157	uint8_t *pHdr = bPacket;
1158	uint8_t *pEnd = bPacket + cb;
1159	AssertReturnVoid(pEnd - pHdr >= 14);
1160	uint16_t uEthType = RT_N2H_U16((uint16_t)(pHdr+12));
1161	Log2(("NetLWF: %s (%d bytes), %RTmac => %RTmac, EthType=%s(0x%x)\n",
1162	cszText, pSG->cbTotal, pHdr+6, pHdr, vboxNetLwfWinEthTypeStr(uEthType), uEthType));
1163	pHdr += sizeof(RTNETETHERHDR);
1164	if (uEthType == RTNET_ETHERTYPE_VLAN)
1165	{
1166	AssertReturnVoid(pEnd - pHdr >= 4);
1167	uEthType = RT_N2H_U16((uint16_t)(pHdr+2));
1168	Log2((" + VLAN: id=%d EthType=%s(0x%x)\n", RT_N2H_U16((uint16_t)(pHdr)) & 0xFFF,
1169	vboxNetLwfWinEthTypeStr(uEthType), uEthType));
1170	pHdr += 2 * sizeof(uint16_t);
1171	}
1172	uint8_t uProto = 0xFF;
1173	switch (uEthType)
1174	{
1175	case RTNET_ETHERTYPE_IPV6:
1176	AssertReturnVoid(pEnd - pHdr >= 40);
1177	uProto = pHdr[6];
1178	Log2((" + IPv6: %RTnaipv6 => %RTnaipv6\n", pHdr+8, pHdr+24));
1179	pHdr += 40;
1180	break;
1181	case RTNET_ETHERTYPE_IPV4:
1182	AssertReturnVoid(pEnd - pHdr >= 20);
1183	uProto = pHdr[9];
1184	Log2((" + IP: %RTnaipv4 => %RTnaipv4\n", (uint32_t)(pHdr+12), (uint32_t)(pHdr+16)));
1185	pHdr += (pHdr[0] & 0xF) * 4;
1186	break;
1187	case RTNET_ETHERTYPE_ARP:
1188	AssertReturnVoid(pEnd - pHdr >= 28);
1189	AssertReturnVoid(RT_N2H_U16((uint16_t)(pHdr+2)) == RTNET_ETHERTYPE_IPV4);
1190	switch (RT_N2H_U16((uint16_t)(pHdr+6)))
1191	{
1192	case 1: /* ARP request */
1193	Log2((" + ARP-REQ: who-has %RTnaipv4 tell %RTnaipv4\n",
1194	(uint32_t)(pHdr+24), (uint32_t)(pHdr+14)));
1195	break;
1196	case 2: /* ARP reply */
1197	Log2((" + ARP-RPL: %RTnaipv4 is-at %RTmac\n",
1198	(uint32_t)(pHdr+14), pHdr+8));
1199	break;
1200	default:
1201	Log2((" + ARP: unknown op %d\n", RT_N2H_U16((uint16_t)(pHdr+6))));
1202	break;
1203	}
1204	break;
1205	/* There is no default case as uProto is initialized with 0xFF */
1206	}
1207	while (uProto != 0xFF)
1208	{
1209	switch (uProto)
1210	{
1211	case 0: /* IPv6 Hop-by-Hop option*/
1212	case 60: /* IPv6 Destination option*/
1213	case 43: /* IPv6 Routing option */
1214	case 44: /* IPv6 Fragment option */
1215	Log2((" + IPv6 option (%d): <not implemented>\n", uProto));
1216	uProto = pHdr[0];
1217	pHdr += pHdr[1] * 8 + 8; /* Skip to the next extension/protocol */
1218	break;
1219	case 51: /* IPv6 IPsec AH */
1220	Log2((" + IPv6 IPsec AH: <not implemented>\n"));
1221	uProto = pHdr[0];
1222	pHdr += (pHdr[1] + 2) * 4; /* Skip to the next extension/protocol */
1223	break;
1224	case 50: /* IPv6 IPsec ESP */
1225	/* Cannot decode IPsec, fall through */
1226	Log2((" + IPv6 IPsec ESP: <not implemented>\n"));
1227	uProto = 0xFF;
1228	break;
1229	case 59: /* No Next Header */
1230	Log2((" + IPv6 No Next Header\n"));
1231	uProto = 0xFF;
1232	break;
1233	case 58: /* IPv6-ICMP */
1234	switch (pHdr[0])
1235	{
1236	case 1: Log2((" + IPv6-ICMP: destination unreachable, code %d\n", pHdr[1])); break;
1237	case 128: Log2((" + IPv6-ICMP: echo request\n")); break;
1238	case 129: Log2((" + IPv6-ICMP: echo reply\n")); break;
1239	default: Log2((" + IPv6-ICMP: unknown type %d, code %d\n", pHdr[0], pHdr[1])); break;
1240	}
1241	uProto = 0xFF;
1242	break;
1243	case 1: /* ICMP */
1244	switch (pHdr[0])
1245	{
1246	case 0: Log2((" + ICMP: echo reply\n")); break;
1247	case 8: Log2((" + ICMP: echo request\n")); break;
1248	case 3: Log2((" + ICMP: destination unreachable, code %d\n", pHdr[1])); break;
1249	default: Log2((" + ICMP: unknown type %d, code %d\n", pHdr[0], pHdr[1])); break;
1250	}
1251	uProto = 0xFF;
1252	break;
1253	case 6: /* TCP */
1254	Log2((" + TCP: src=%d dst=%d seq=%x ack=%x\n",
1255	RT_N2H_U16((uint16_t)(pHdr)), RT_N2H_U16((uint16_t)(pHdr+2)),
1256	RT_N2H_U32((uint32_t)(pHdr+4)), RT_N2H_U32((uint32_t)(pHdr+8))));
1257	uProto = 0xFF;
1258	break;
1259	case 17: /* UDP */
1260	Log2((" + UDP: src=%d dst=%d\n",
1261	RT_N2H_U16((uint16_t)(pHdr)), RT_N2H_U16((uint16_t)(pHdr+2))));
1262	uProto = 0xFF;
1263	break;
1264	default:
1265	Log2((" + Unknown: proto=0x%x\n", uProto));
1266	uProto = 0xFF;
1267	break;
1268	}
1269	}
1270	Log3(("%.*Rhxd\n", cb, bPacket));
1271	}
1272
1273	static void vboxNetLwfWinDestroySG(PINTNETSG pSG)
1274	{
1275	NdisFreeMemory(pSG, 0, 0);
1276	Log4(("vboxNetLwfWinDestroySG: freed SG 0x%p\n", pSG));
1277	}
1278
1279	DECLINLINE(ULONG) vboxNetLwfWinCalcSegments(PNET_BUFFER pNetBuf)
1280	{
1281	ULONG cSegs = 0;
1282	for (PMDL pMdl = NET_BUFFER_CURRENT_MDL(pNetBuf); pMdl; pMdl = NDIS_MDL_LINKAGE(pMdl))
1283	cSegs++;
1284	return cSegs;
1285	}
1286
1287	DECLINLINE(void) vboxNetLwfWinFreeMdlChain(PMDL pMdl)
1288	{
1289	#ifdef VBOXNETLWF_SYNC_SEND
1290	PMDL pMdlNext;
1291	while (pMdl)
1292	{
1293	pMdlNext = pMdl->Next;
1294	NdisFreeMdl(pMdl);
1295	Log4(("vboxNetLwfWinFreeMdlChain: freed MDL 0x%p\n", pMdl));
1296	pMdl = pMdlNext;
1297	}
1298	#endif /* VBOXNETLWF_SYNC_SEND */
1299	}
1300
1301	/** @todo
1302	* 1) Copy data from SG to MDL (if we decide to complete asynchronously).
1303	* 2) Provide context/backfill space. Nobody does it, should we?
1304	* 3) We always get a single segment from intnet. Simplify?
1305	*/
1306	static PNET_BUFFER_LIST vboxNetLwfWinSGtoNB(PVBOXNETLWF_MODULE pModule, PINTNETSG pSG)
1307	{
1308	AssertReturn(pSG->cSegsUsed >= 1, NULL);
1309	LogFlow(("==>vboxNetLwfWinSGtoNB: segments=%d hPool=%p cb=%u max=%u\n", pSG->cSegsUsed,
1310	pModule->hPool, pSG->cbTotal, VBOXNETLWF_MAX_FRAME_SIZE(pModule->uMtuSize)));
1311	AssertReturn(pModule->hPool, NULL);
1312
1313	#ifdef VBOXNETLWF_SYNC_SEND
1314	PINTNETSEG pSeg = pSG->aSegs;
1315	PMDL pMdl = NdisAllocateMdl(pModule->hFilter, pSeg->pv, pSeg->cb);
1316	if (!pMdl)
1317	{
1318	LogError(("vboxNetLwfWinSGtoNB: failed to allocate an MDL\n"));
1319	LogFlow(("<==vboxNetLwfWinSGtoNB: return NULL\n"));
1320	return NULL;
1321	}
1322	Log4(("vboxNetLwfWinSGtoNB: allocated Mdl 0x%p\n", pMdl));
1323	PMDL pMdlCurr = pMdl;
1324	for (int i = 1; i < pSG->cSegsUsed; i++)
1325	{
1326	pSeg = &pSG->aSegs[i];
1327	pMdlCurr->Next = NdisAllocateMdl(pModule->hFilter, pSeg->pv, pSeg->cb);
1328	if (!pMdlCurr->Next)
1329	{
1330	LogError(("vboxNetLwfWinSGtoNB: failed to allocate an MDL\n"));
1331	/* Tear down all MDL we chained so far */
1332	vboxNetLwfWinFreeMdlChain(pMdl);
1333	return NULL;
1334	}
1335	pMdlCurr = pMdlCurr->Next;
1336	Log4(("vboxNetLwfWinSGtoNB: allocated Mdl 0x%p\n", pMdlCurr));
1337	}
1338	PNET_BUFFER_LIST pBufList = NdisAllocateNetBufferAndNetBufferList(pModule->hPool,
1339	0 /* ContextSize */,
1340	0 /* ContextBackFill */,
1341	pMdl,
1342	0 /* DataOffset */,
1343	pSG->cbTotal);
1344	if (pBufList)
1345	{
1346	Log4(("vboxNetLwfWinSGtoNB: allocated NBL+NB 0x%p\n", pBufList));
1347	pBufList->SourceHandle = pModule->hFilter;
1348	/** @todo Do we need to initialize anything else? */
1349	}
1350	else
1351	{
1352	LogError(("vboxNetLwfWinSGtoNB: failed to allocate an NBL+NB\n"));
1353	vboxNetLwfWinFreeMdlChain(pMdl);
1354	}
1355	#else /* !VBOXNETLWF_SYNC_SEND */
1356	#ifdef VBOXNETLWF_TEST_NO_FRAMES_OVER_2K
1357	AssertReturn(pSG->cbTotal < 2048, NULL);
1358	#else /* !VBOXNETLWF_TEST_NO_FRAMES_OVER_2K */
1359	AssertReturn(pSG->cbTotal <= VBOXNETLWF_MAX_FRAME_SIZE(pModule->uMtuSize), NULL);
1360	#endif /* !VBOXNETLWF_TEST_NO_FRAMES_OVER_2K */
1361	PNET_BUFFER_LIST pBufList = NdisAllocateNetBufferList(pModule->hPool,
1362	0 /** @todo ContextSize */,
1363	0 /** @todo ContextBackFill */);
1364	NET_BUFFER_LIST_NEXT_NBL(pBufList) = NULL; /** @todo Is it even needed? */
1365	NET_BUFFER *pBuffer = NET_BUFFER_LIST_FIRST_NB(pBufList);
1366	NDIS_STATUS Status = NdisRetreatNetBufferDataStart(pBuffer, pSG->cbTotal, 0 /** @todo DataBackfill */, NULL);
1367	if (Status == NDIS_STATUS_SUCCESS)
1368	{
1369	uint8_t pDst = (uint8_t)NdisGetDataBuffer(pBuffer, pSG->cbTotal, NULL, 1, 0);
1370	if (pDst)
1371	{
1372	for (int i = 0; i < pSG->cSegsUsed; i++)
1373	{
1374	NdisMoveMemory(pDst, pSG->aSegs[i].pv, pSG->aSegs[i].cb);
1375	pDst += pSG->aSegs[i].cb;
1376	}
1377	Log4(("vboxNetLwfWinSGtoNB: allocated NBL+NB+MDL+Data 0x%p\n", pBufList));
1378	pBufList->SourceHandle = pModule->hFilter;
1379	/** @todo Do we need to initialize anything else? */
1380	}
1381	else
1382	{
1383	LogError(("vboxNetLwfWinSGtoNB: failed to obtain the buffer pointer (size=%u)\n", pSG->cbTotal));
1384	NdisAdvanceNetBufferDataStart(pBuffer, pSG->cbTotal, false, NULL); /** @todo why bother? */
1385	NdisFreeNetBufferList(pBufList);
1386	pBufList = NULL;
1387	}
1388	}
1389	else
1390	{
1391	LogError(("vboxNetLwfWinSGtoNB: NdisRetreatNetBufferDataStart failed with 0x%x (size=%u)\n", Status, pSG->cbTotal));
1392	NdisFreeNetBufferList(pBufList);
1393	pBufList = NULL;
1394	}
1395	#endif /* !VBOXNETLWF_SYNC_SEND */
1396	LogFlow(("<==vboxNetLwfWinSGtoNB: return %p\n", pBufList));
1397	return pBufList;
1398	}
1399
1400	static PINTNETSG vboxNetLwfWinNBtoSG(PVBOXNETLWF_MODULE pModule, PNET_BUFFER pNetBuf)
1401	{
1402	ULONG cbPacket = NET_BUFFER_DATA_LENGTH(pNetBuf);
1403	UINT cSegs = vboxNetLwfWinCalcSegments(pNetBuf);
1404	/* Allocate and initialize SG */
1405	PINTNETSG pSG = (PINTNETSG)NdisAllocateMemoryWithTagPriority(pModule->hFilter,
1406	RT_OFFSETOF(INTNETSG, aSegs[cSegs]),
1407	VBOXNETLWF_MEM_TAG,
1408	NormalPoolPriority);
1409	AssertReturn(pSG, pSG);
1410	Log4(("vboxNetLwfWinNBtoSG: allocated SG 0x%p\n", pSG));
1411	IntNetSgInitTempSegs(pSG, cbPacket /cbTotal/, cSegs, cSegs /cSegsUsed/);
1412
1413	int rc = NDIS_STATUS_SUCCESS;
1414	ULONG uOffset = NET_BUFFER_CURRENT_MDL_OFFSET(pNetBuf);
1415	cSegs = 0;
1416	for (PMDL pMdl = NET_BUFFER_CURRENT_MDL(pNetBuf);
1417	pMdl != NULL && cbPacket > 0;
1418	pMdl = NDIS_MDL_LINKAGE(pMdl))
1419	{
1420	PUCHAR pSrc = (PUCHAR)MmGetSystemAddressForMdlSafe(pMdl, LowPagePriority);
1421	if (!pSrc)
1422	{
1423	rc = NDIS_STATUS_RESOURCES;
1424	break;
1425	}
1426	ULONG cbSrc = MmGetMdlByteCount(pMdl);
1427	if (uOffset)
1428	{
1429	Assert(uOffset < cbSrc);
1430	pSrc += uOffset;
1431	cbSrc -= uOffset;
1432	uOffset = 0;
1433	}
1434
1435	if (cbSrc > cbPacket)
1436	cbSrc = cbPacket;
1437
1438	pSG->aSegs[cSegs].pv = pSrc;
1439	pSG->aSegs[cSegs].cb = cbSrc;
1440	pSG->aSegs[cSegs].Phys = NIL_RTHCPHYS;
1441	cSegs++;
1442	cbPacket -= cbSrc;
1443	}
1444
1445	Assert(cSegs <= pSG->cSegsAlloc);
1446
1447	if (RT_FAILURE(rc))
1448	{
1449	vboxNetLwfWinDestroySG(pSG);
1450	pSG = NULL;
1451	}
1452	else
1453	{
1454	Assert(cbPacket == 0);
1455	Assert(pSG->cSegsUsed == cSegs);
1456	}
1457	return pSG;
1458	}
1459
1460	static void vboxNetLwfWinDisableOffloading(PNDIS_OFFLOAD pOffloadConfig)
1461	{
1462	pOffloadConfig->Checksum.IPv4Transmit.Encapsulation = NDIS_ENCAPSULATION_NOT_SUPPORTED;
1463	pOffloadConfig->Checksum.IPv4Transmit.IpOptionsSupported = NDIS_OFFLOAD_NOT_SUPPORTED;
1464	pOffloadConfig->Checksum.IPv4Transmit.TcpOptionsSupported = NDIS_OFFLOAD_NOT_SUPPORTED;
1465	pOffloadConfig->Checksum.IPv4Transmit.TcpChecksum = NDIS_OFFLOAD_NOT_SUPPORTED;
1466	pOffloadConfig->Checksum.IPv4Transmit.UdpChecksum = NDIS_OFFLOAD_NOT_SUPPORTED;
1467	pOffloadConfig->Checksum.IPv4Transmit.IpChecksum = NDIS_OFFLOAD_NOT_SUPPORTED;
1468	pOffloadConfig->Checksum.IPv6Transmit.Encapsulation = NDIS_ENCAPSULATION_NOT_SUPPORTED;
1469	pOffloadConfig->Checksum.IPv6Transmit.IpExtensionHeadersSupported = NDIS_OFFLOAD_NOT_SUPPORTED;
1470	pOffloadConfig->Checksum.IPv6Transmit.TcpOptionsSupported = NDIS_OFFLOAD_NOT_SUPPORTED;
1471	pOffloadConfig->Checksum.IPv6Transmit.TcpChecksum = NDIS_OFFLOAD_NOT_SUPPORTED;
1472	pOffloadConfig->Checksum.IPv6Transmit.UdpChecksum = NDIS_OFFLOAD_NOT_SUPPORTED;
1473	pOffloadConfig->LsoV1.IPv4.Encapsulation = NDIS_ENCAPSULATION_NOT_SUPPORTED;
1474	pOffloadConfig->LsoV1.IPv4.TcpOptions = NDIS_OFFLOAD_NOT_SUPPORTED;
1475	pOffloadConfig->LsoV1.IPv4.IpOptions = NDIS_OFFLOAD_NOT_SUPPORTED;
1476	pOffloadConfig->LsoV2.IPv4.Encapsulation = NDIS_ENCAPSULATION_NOT_SUPPORTED;
1477	pOffloadConfig->LsoV2.IPv6.Encapsulation = NDIS_ENCAPSULATION_NOT_SUPPORTED;
1478	pOffloadConfig->LsoV2.IPv6.IpExtensionHeadersSupported = NDIS_OFFLOAD_NOT_SUPPORTED;
1479	pOffloadConfig->LsoV2.IPv6.TcpOptionsSupported = NDIS_OFFLOAD_NOT_SUPPORTED;
1480	}
1481
1482	VOID vboxNetLwfWinStatus(IN NDIS_HANDLE hModuleCtx, IN PNDIS_STATUS_INDICATION pIndication)
1483	{
1484	LogFlow(("==>vboxNetLwfWinStatus: module=%p\n", hModuleCtx));
1485	PVBOXNETLWF_MODULE pModuleCtx = (PVBOXNETLWF_MODULE)hModuleCtx;
1486	Log(("vboxNetLwfWinStatus: Got status indication: %s\n", vboxNetLwfWinStatusToText(pIndication->StatusCode)));
1487	switch (pIndication->StatusCode)
1488	{
1489	case NDIS_STATUS_PACKET_FILTER:
1490	vboxNetLwfWinDumpFilterTypes((ULONG)pIndication->StatusBuffer);
1491	vboxNetLwfWinOverridePacketFiltersUp(pModuleCtx, (ULONG*)pIndication->StatusBuffer);
1492	Log(("vboxNetLwfWinStatus: Reporting status: %s\n", vboxNetLwfWinStatusToText(pIndication->StatusCode)));
1493	vboxNetLwfWinDumpFilterTypes((ULONG)pIndication->StatusBuffer);
1494	break;
1495	case NDIS_STATUS_TASK_OFFLOAD_CURRENT_CONFIG:
1496	Log5(("vboxNetLwfWinStatus: offloading currently set to:\n"));
1497	vboxNetLwfWinDumpOffloadSettings((PNDIS_OFFLOAD)pIndication->StatusBuffer);
1498	vboxNetLwfWinUpdateSavedOffloadConfig(pModuleCtx, (PNDIS_OFFLOAD)pIndication->StatusBuffer);
1499	if (ASMAtomicReadBool(&pModuleCtx->fActive))
1500	vboxNetLwfWinDisableOffloading((PNDIS_OFFLOAD)pIndication->StatusBuffer);
1501	Log5(("vboxNetLwfWinStatus: reporting offloading up as:\n"));
1502	vboxNetLwfWinDumpOffloadSettings((PNDIS_OFFLOAD)pIndication->StatusBuffer);
1503	break;
1504	}
1505	NdisFIndicateStatus(pModuleCtx->hFilter, pIndication);
1506	LogFlow(("<==vboxNetLwfWinStatus\n"));
1507	}
1508
1509	static bool vboxNetLwfWinForwardToIntNet(PVBOXNETLWF_MODULE pModuleCtx, PNET_BUFFER_LIST pBufLists, uint32_t fSrc)
1510	{
1511	/* We must not forward anything to the trunk unless it is ready to receive. */
1512	if (!ASMAtomicReadBool(&pModuleCtx->fActive))
1513	{
1514	Log(("vboxNetLwfWinForwardToIntNet: trunk is inactive, won't forward\n"));
1515	return false;
1516	}
1517
1518	AssertReturn(pModuleCtx->pNetFlt, false);
1519	AssertReturn(pModuleCtx->pNetFlt->pSwitchPort, false);
1520	AssertReturn(pModuleCtx->pNetFlt->pSwitchPort->pfnRecv, false);
1521	LogFlow(("==>vboxNetLwfWinForwardToIntNet: module=%p\n", pModuleCtx));
1522	Assert(pBufLists); /* The chain must contain at least one list */
1523	Assert(NET_BUFFER_LIST_NEXT_NBL(pBufLists) == NULL); /* The caller is supposed to unlink the list from the chain */
1524	/*
1525	* Even if NBL contains more than one buffer we are prepared to deal with it.
1526	* When any of buffers should not be dropped we keep the whole list. It is
1527	* better to leak some "unexpected" packets to the wire/host than to loose any.
1528	*/
1529	bool fDropIt = false;
1530	bool fDontDrop = false;
1531	int nLists = 0;
1532	for (PNET_BUFFER_LIST pList = pBufLists; pList; pList = NET_BUFFER_LIST_NEXT_NBL(pList))
1533	{
1534	int nBuffers = 0;
1535	nLists++;
1536	for (PNET_BUFFER pBuf = NET_BUFFER_LIST_FIRST_NB(pList); pBuf; pBuf = NET_BUFFER_NEXT_NB(pBuf))
1537	{
1538	nBuffers++;
1539	PINTNETSG pSG = vboxNetLwfWinNBtoSG(pModuleCtx, pBuf);
1540	if (pSG)
1541	{
1542	vboxNetLwfWinDumpPacket(pSG, (fSrc & INTNETTRUNKDIR_WIRE)?"intnet <-- wire":"intnet <-- host");
1543	/* A bit paranoid, but we do not use any locks, so... */
1544	if (ASMAtomicReadBool(&pModuleCtx->fActive))
1545	if (pModuleCtx->pNetFlt->pSwitchPort->pfnRecv(pModuleCtx->pNetFlt->pSwitchPort, NULL, pSG, fSrc))
1546	fDropIt = true;
1547	else
1548	fDontDrop = true;
1549	vboxNetLwfWinDestroySG(pSG);
1550	}
1551	}
1552	Log(("vboxNetLwfWinForwardToIntNet: list=%d buffers=%d\n", nLists, nBuffers));
1553	}
1554	Log(("vboxNetLwfWinForwardToIntNet: lists=%d drop=%s don't=%s\n", nLists, fDropIt ? "true":"false", fDontDrop ? "true":"false"));
1555	LogFlow(("<==vboxNetLwfWinForwardToIntNet: return '%s'\n",
1556	fDropIt ? (fDontDrop ? "do not drop (some)" : "drop it") : "do not drop (any)"));
1557	return fDropIt && !fDontDrop; /* Drop the list if ALL its buffers are being dropped! */
1558	}
1559
1560	DECLINLINE(bool) vboxNetLwfWinIsRunning(PVBOXNETLWF_MODULE pModule)
1561	{
1562	Log(("vboxNetLwfWinIsRunning: state=%d\n", ASMAtomicReadU32(&pModule->enmState)));
1563	return ASMAtomicReadU32(&pModule->enmState) == LwfState_Running;
1564	}
1565
1566	VOID vboxNetLwfWinSendNetBufferLists(IN NDIS_HANDLE hModuleCtx, IN PNET_BUFFER_LIST pBufLists, IN NDIS_PORT_NUMBER nPort, IN ULONG fFlags)
1567	{
1568	size_t cb = 0;
1569	LogFlow(("==>vboxNetLwfWinSendNetBufferLists: module=%p\n", hModuleCtx));
1570	PVBOXNETLWF_MODULE pModule = (PVBOXNETLWF_MODULE)hModuleCtx;
1571
1572	if (!ASMAtomicReadBool(&pModule->fActive))
1573	{
1574	/*
1575	* The trunk is inactive, jusp pass along all packets to the next
1576	* underlying driver.
1577	*/
1578	NdisFSendNetBufferLists(pModule->hFilter, pBufLists, nPort, fFlags);
1579	return;
1580	}
1581
1582	if (vboxNetLwfWinIsRunning(pModule))
1583	{
1584	PNET_BUFFER_LIST pNext = NULL;
1585	PNET_BUFFER_LIST pDropHead = NULL;
1586	PNET_BUFFER_LIST pDropTail = NULL;
1587	PNET_BUFFER_LIST pPassHead = NULL;
1588	PNET_BUFFER_LIST pPassTail = NULL;
1589	for (PNET_BUFFER_LIST pList = pBufLists; pList; pList = pNext)
1590	{
1591	pNext = NET_BUFFER_LIST_NEXT_NBL(pList);
1592	NET_BUFFER_LIST_NEXT_NBL(pList) = NULL; /* Unlink */
1593	if (vboxNetLwfWinForwardToIntNet(pModule, pList, INTNETTRUNKDIR_HOST))
1594	{
1595	NET_BUFFER_LIST_STATUS(pList) = NDIS_STATUS_SUCCESS;
1596	if (pDropHead)
1597	{
1598	NET_BUFFER_LIST_NEXT_NBL(pDropTail) = pList;
1599	pDropTail = pList;
1600	}
1601	else
1602	pDropHead = pDropTail = pList;
1603	}
1604	else
1605	{
1606	if (pPassHead)
1607	{
1608	NET_BUFFER_LIST_NEXT_NBL(pPassTail) = pList;
1609	pPassTail = pList;
1610	}
1611	else
1612	pPassHead = pPassTail = pList;
1613	}
1614	}
1615	Assert((pBufLists == pPassHead) \|\| (pBufLists == pDropHead));
1616	if (pPassHead)
1617	{
1618	vboxNetLwfWinDumpPackets("vboxNetLwfWinSendNetBufferLists: passing down", pPassHead);
1619	NdisFSendNetBufferLists(pModule->hFilter, pBufLists, nPort, fFlags);
1620	}
1621	if (pDropHead)
1622	{
1623	vboxNetLwfWinDumpPackets("vboxNetLwfWinSendNetBufferLists: consumed", pDropHead);
1624	NdisFSendNetBufferListsComplete(pModule->hFilter, pDropHead,
1625	fFlags & NDIS_SEND_FLAGS_DISPATCH_LEVEL ? NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL : 0);
1626	}
1627	}
1628	else
1629	{
1630	for (PNET_BUFFER_LIST pList = pBufLists; pList; pList = NET_BUFFER_LIST_NEXT_NBL(pList))
1631	{
1632	NET_BUFFER_LIST_STATUS(pList) = NDIS_STATUS_PAUSED;
1633	}
1634	vboxNetLwfWinDumpPackets("vboxNetLwfWinSendNetBufferLists: consumed", pBufLists);
1635	NdisFSendNetBufferListsComplete(pModule->hFilter, pBufLists,
1636	fFlags & NDIS_SEND_FLAGS_DISPATCH_LEVEL ? NDIS_SEND_COMPLETE_FLAGS_DISPATCH_LEVEL : 0);
1637
1638	}
1639	LogFlow(("<==vboxNetLwfWinSendNetBufferLists\n"));
1640	}
1641
1642	VOID vboxNetLwfWinSendNetBufferListsComplete(IN NDIS_HANDLE hModuleCtx, IN PNET_BUFFER_LIST pBufLists, IN ULONG fFlags)
1643	{
1644	size_t cb = 0;
1645	LogFlow(("==>vboxNetLwfWinSendNetBufferListsComplete: module=%p\n", hModuleCtx));
1646	PVBOXNETLWF_MODULE pModule = (PVBOXNETLWF_MODULE)hModuleCtx;
1647	PNET_BUFFER_LIST pList = pBufLists;
1648	PNET_BUFFER_LIST pNextList;
1649	PNET_BUFFER_LIST pPrevList = NULL;
1650	while (pList)
1651	{
1652	pNextList = NET_BUFFER_LIST_NEXT_NBL(pList);
1653	if (pList->SourceHandle == pModule->hFilter)
1654	{
1655	/* We allocated this NET_BUFFER_LIST, let's free it up */
1656	Assert(NET_BUFFER_LIST_FIRST_NB(pList));
1657	Assert(NET_BUFFER_FIRST_MDL(NET_BUFFER_LIST_FIRST_NB(pList)));
1658	/*
1659	* All our NBLs hold a single NB each, no need to iterate over a list.
1660	* There is no need to free an associated NB explicitly either, as it was
1661	* preallocated with NBL structure.
1662	*/
1663	Assert(!NET_BUFFER_NEXT_NB(NET_BUFFER_LIST_FIRST_NB(pList)));
1664	vboxNetLwfWinFreeMdlChain(NET_BUFFER_FIRST_MDL(NET_BUFFER_LIST_FIRST_NB(pList)));
1665	/* Unlink this list from the chain */
1666	if (pPrevList)
1667	NET_BUFFER_LIST_NEXT_NBL(pPrevList) = pNextList;
1668	else
1669	pBufLists = pNextList;
1670	Log(("vboxNetLwfWinSendNetBufferListsComplete: our list %p, next=%p, previous=%p, head=%p\n", pList, pNextList, pPrevList, pBufLists));
1671	NdisFreeNetBufferList(pList);
1672	#ifdef VBOXNETLWF_SYNC_SEND
1673	Log4(("vboxNetLwfWinSendNetBufferListsComplete: freed NBL+NB 0x%p\n", pList));
1674	KeSetEvent(&pModule->EventWire, 0, FALSE);
1675	#else /* !VBOXNETLWF_SYNC_SEND */
1676	Log4(("vboxNetLwfWinSendNetBufferListsComplete: freed NBL+NB+MDL+Data 0x%p\n", pList));
1677	Assert(ASMAtomicReadS32(&pModule->cPendingBuffers) > 0);
1678	if (ASMAtomicDecS32(&pModule->cPendingBuffers) == 0)
1679	NdisSetEvent(&pModule->EventSendComplete);
1680	#endif /* !VBOXNETLWF_SYNC_SEND */
1681	}
1682	else
1683	{
1684	pPrevList = pList;
1685	Log(("vboxNetLwfWinSendNetBufferListsComplete: passing list %p, next=%p, previous=%p, head=%p\n", pList, pNextList, pPrevList, pBufLists));
1686	}
1687	pList = pNextList;
1688	}
1689	if (pBufLists)
1690	{
1691	/* There are still lists remaining in the chain, pass'em up */
1692	NdisFSendNetBufferListsComplete(pModule->hFilter, pBufLists, fFlags);
1693	}
1694	LogFlow(("<==vboxNetLwfWinSendNetBufferListsComplete\n"));
1695	}
1696
1697	VOID vboxNetLwfWinReceiveNetBufferLists(IN NDIS_HANDLE hModuleCtx,
1698	IN PNET_BUFFER_LIST pBufLists,
1699	IN NDIS_PORT_NUMBER nPort,
1700	IN ULONG nBufLists,
1701	IN ULONG fFlags)
1702	{
1703	/// @todo Do we need loopback handling?
1704	LogFlow(("==>vboxNetLwfWinReceiveNetBufferLists: module=%p\n", hModuleCtx));
1705	PVBOXNETLWF_MODULE pModule = (PVBOXNETLWF_MODULE)hModuleCtx;
1706
1707	if (!ASMAtomicReadBool(&pModule->fActive))
1708	{
1709	/*
1710	* The trunk is inactive, jusp pass along all packets to the next
1711	* overlying driver.
1712	*/
1713	NdisFIndicateReceiveNetBufferLists(pModule->hFilter, pBufLists, nPort, nBufLists, fFlags);
1714	LogFlow(("<==vboxNetLwfWinReceiveNetBufferLists: inactive trunk\n"));
1715	return;
1716	}
1717
1718	if (vboxNetLwfWinIsRunning(pModule))
1719	{
1720	if (NDIS_TEST_RECEIVE_CANNOT_PEND(fFlags))
1721	{
1722	/* We do not own NBLs so we do not need to return them */
1723	/* First we need to scan through the list to see if some packets must be dropped */
1724	bool bDropIt = false;
1725	for (PNET_BUFFER_LIST pList = pBufLists; pList; pList = NET_BUFFER_LIST_NEXT_NBL(pList))
1726	{
1727	PNET_BUFFER_LIST pNext = NET_BUFFER_LIST_NEXT_NBL(pList);
1728	NET_BUFFER_LIST_NEXT_NBL(pList) = NULL; /* Unlink temporarily */
1729	if (vboxNetLwfWinForwardToIntNet(pModule, pList, INTNETTRUNKDIR_WIRE))
1730	bDropIt = true;
1731	NET_BUFFER_LIST_NEXT_NBL(pList) = pNext; /* Restore the link */
1732	}
1733	if (bDropIt)
1734	{
1735	/* Some NBLs must be dropped, indicate selectively one by one */
1736	for (PNET_BUFFER_LIST pList = pBufLists; pList; pList = NET_BUFFER_LIST_NEXT_NBL(pList))
1737	{
1738	PNET_BUFFER_LIST pNext = NET_BUFFER_LIST_NEXT_NBL(pList);
1739	NET_BUFFER_LIST_NEXT_NBL(pList) = NULL; /* Unlink temporarily */
1740	vboxNetLwfWinDumpPackets("vboxNetLwfWinReceiveNetBufferLists: passing up", pList);
1741	NdisFIndicateReceiveNetBufferLists(pModule->hFilter, pList, nPort, nBufLists, fFlags);
1742	NET_BUFFER_LIST_NEXT_NBL(pList) = pNext; /* Restore the link */
1743	}
1744	}
1745	else
1746	{
1747	/* All NBLs must be indicated, do it in bulk. */
1748	vboxNetLwfWinDumpPackets("vboxNetLwfWinReceiveNetBufferLists: passing up", pBufLists);
1749	NdisFIndicateReceiveNetBufferLists(pModule->hFilter, pBufLists, nPort, nBufLists, fFlags);
1750	}
1751	}
1752	else
1753	{
1754	/* We collect dropped NBLs in a separate list in order to "return" them. */
1755	PNET_BUFFER_LIST pNext = NULL;
1756	PNET_BUFFER_LIST pDropHead = NULL;
1757	PNET_BUFFER_LIST pDropTail = NULL;
1758	PNET_BUFFER_LIST pPassHead = NULL;
1759	PNET_BUFFER_LIST pPassTail = NULL;
1760	ULONG nDrop = 0, nPass = 0;
1761	for (PNET_BUFFER_LIST pList = pBufLists; pList; pList = pNext)
1762	{
1763	pNext = NET_BUFFER_LIST_NEXT_NBL(pList);
1764	NET_BUFFER_LIST_NEXT_NBL(pList) = NULL; /* Unlink */
1765	if (vboxNetLwfWinForwardToIntNet(pModule, pList, INTNETTRUNKDIR_WIRE))
1766	{
1767	if (nDrop++)
1768	{
1769	NET_BUFFER_LIST_NEXT_NBL(pDropTail) = pList;
1770	pDropTail = pList;
1771	}
1772	else
1773	pDropHead = pDropTail = pList;
1774	}
1775	else
1776	{
1777	if (nPass++)
1778	{
1779	NET_BUFFER_LIST_NEXT_NBL(pPassTail) = pList;
1780	pPassTail = pList;
1781	}
1782	else
1783	pPassHead = pPassTail = pList;
1784	}
1785	}
1786	Assert((pBufLists == pPassHead) \|\| (pBufLists == pDropHead));
1787	Assert(nDrop + nPass == nBufLists);
1788	if (pPassHead)
1789	{
1790	vboxNetLwfWinDumpPackets("vboxNetLwfWinReceiveNetBufferLists: passing up", pPassHead);
1791	NdisFIndicateReceiveNetBufferLists(pModule->hFilter, pPassHead, nPort, nPass, fFlags);
1792	}
1793	if (pDropHead)
1794	{
1795	vboxNetLwfWinDumpPackets("vboxNetLwfWinReceiveNetBufferLists: consumed", pDropHead);
1796	NdisFReturnNetBufferLists(pModule->hFilter, pDropHead,
1797	fFlags & NDIS_RECEIVE_FLAGS_DISPATCH_LEVEL ? NDIS_RETURN_FLAGS_DISPATCH_LEVEL : 0);
1798	}
1799	}
1800
1801	}
1802	else
1803	{
1804	vboxNetLwfWinDumpPackets("vboxNetLwfWinReceiveNetBufferLists: consumed", pBufLists);
1805	if ((fFlags & NDIS_RECEIVE_FLAGS_RESOURCES) == 0)
1806	NdisFReturnNetBufferLists(pModule->hFilter, pBufLists,
1807	fFlags & NDIS_RECEIVE_FLAGS_DISPATCH_LEVEL ? NDIS_RETURN_FLAGS_DISPATCH_LEVEL : 0);
1808	}
1809	LogFlow(("<==vboxNetLwfWinReceiveNetBufferLists\n"));
1810	}
1811
1812	VOID vboxNetLwfWinReturnNetBufferLists(IN NDIS_HANDLE hModuleCtx, IN PNET_BUFFER_LIST pBufLists, IN ULONG fFlags)
1813	{
1814	size_t cb = 0;
1815	LogFlow(("==>vboxNetLwfWinReturnNetBufferLists: module=%p\n", hModuleCtx));
1816	PVBOXNETLWF_MODULE pModule = (PVBOXNETLWF_MODULE)hModuleCtx;
1817	PNET_BUFFER_LIST pList = pBufLists;
1818	PNET_BUFFER_LIST pNextList;
1819	PNET_BUFFER_LIST pPrevList = NULL;
1820	/** @todo Move common part into a separate function to be used by vboxNetLwfWinSendNetBufferListsComplete() as well */
1821	while (pList)
1822	{
1823	pNextList = NET_BUFFER_LIST_NEXT_NBL(pList);
1824	if (pList->SourceHandle == pModule->hFilter)
1825	{
1826	/* We allocated this NET_BUFFER_LIST, let's free it up */
1827	Assert(NET_BUFFER_LIST_FIRST_NB(pList));
1828	Assert(NET_BUFFER_FIRST_MDL(NET_BUFFER_LIST_FIRST_NB(pList)));
1829	/*
1830	* All our NBLs hold a single NB each, no need to iterate over a list.
1831	* There is no need to free an associated NB explicitly either, as it was
1832	* preallocated with NBL structure.
1833	*/
1834	vboxNetLwfWinFreeMdlChain(NET_BUFFER_FIRST_MDL(NET_BUFFER_LIST_FIRST_NB(pList)));
1835	/* Unlink this list from the chain */
1836	if (pPrevList)
1837	NET_BUFFER_LIST_NEXT_NBL(pPrevList) = pNextList;
1838	else
1839	pBufLists = pNextList;
1840	NdisFreeNetBufferList(pList);
1841	#ifdef VBOXNETLWF_SYNC_SEND
1842	Log4(("vboxNetLwfWinReturnNetBufferLists: freed NBL+NB 0x%p\n", pList));
1843	KeSetEvent(&pModule->EventHost, 0, FALSE);
1844	#else /* !VBOXNETLWF_SYNC_SEND */
1845	Log4(("vboxNetLwfWinReturnNetBufferLists: freed NBL+NB+MDL+Data 0x%p\n", pList));
1846	Assert(ASMAtomicReadS32(&pModule->cPendingBuffers) > 0);
1847	if (ASMAtomicDecS32(&pModule->cPendingBuffers) == 0)
1848	NdisSetEvent(&pModule->EventSendComplete);
1849	#endif /* !VBOXNETLWF_SYNC_SEND */
1850	}
1851	else
1852	pPrevList = pList;
1853	pList = pNextList;
1854	}
1855	if (pBufLists)
1856	{
1857	/* There are still lists remaining in the chain, pass'em up */
1858	NdisFReturnNetBufferLists(pModule->hFilter, pBufLists, fFlags);
1859	}
1860	LogFlow(("<==vboxNetLwfWinReturnNetBufferLists\n"));
1861	}
1862
1863	/**
1864	* register the filter driver
1865	*/
1866	DECLHIDDEN(NDIS_STATUS) vboxNetLwfWinRegister(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegistryPathStr)
1867	{
1868	NDIS_FILTER_DRIVER_CHARACTERISTICS FChars;
1869	NDIS_STRING FriendlyName;
1870	NDIS_STRING UniqueName;
1871	NDIS_STRING ServiceName;
1872
1873	NdisInitUnicodeString(&FriendlyName, VBOXNETLWF_NAME_FRIENDLY);
1874	NdisInitUnicodeString(&UniqueName, VBOXNETLWF_NAME_UNIQUE);
1875	NdisInitUnicodeString(&ServiceName, VBOXNETLWF_NAME_SERVICE);
1876
1877	NdisZeroMemory(&FChars, sizeof (FChars));
1878
1879	FChars.Header.Type = NDIS_OBJECT_TYPE_FILTER_DRIVER_CHARACTERISTICS;
1880	FChars.Header.Size = sizeof(NDIS_FILTER_DRIVER_CHARACTERISTICS);
1881	FChars.Header.Revision = NDIS_FILTER_CHARACTERISTICS_REVISION_1;
1882
1883	FChars.MajorNdisVersion = VBOXNETLWF_VERSION_NDIS_MAJOR;
1884	FChars.MinorNdisVersion = VBOXNETLWF_VERSION_NDIS_MINOR;
1885
1886	FChars.FriendlyName = FriendlyName;
1887	FChars.UniqueName = UniqueName;
1888	FChars.ServiceName = ServiceName;
1889
1890	/* Mandatory functions */
1891	FChars.AttachHandler = vboxNetLwfWinAttach;
1892	FChars.DetachHandler = vboxNetLwfWinDetach;
1893	FChars.RestartHandler = vboxNetLwfWinRestart;
1894	FChars.PauseHandler = vboxNetLwfWinPause;
1895
1896	/* Optional functions, non changeble at run-time */
1897	FChars.OidRequestHandler = vboxNetLwfWinOidRequest;
1898	FChars.OidRequestCompleteHandler = vboxNetLwfWinOidRequestComplete;
1899	//FChars.CancelOidRequestHandler = vboxNetLwfWinCancelOidRequest;
1900	FChars.StatusHandler = vboxNetLwfWinStatus;
1901	//FChars.NetPnPEventHandler = vboxNetLwfWinPnPEvent;
1902
1903	/* Datapath functions */
1904	FChars.SendNetBufferListsHandler = vboxNetLwfWinSendNetBufferLists;
1905	FChars.SendNetBufferListsCompleteHandler = vboxNetLwfWinSendNetBufferListsComplete;
1906	FChars.ReceiveNetBufferListsHandler = vboxNetLwfWinReceiveNetBufferLists;
1907	FChars.ReturnNetBufferListsHandler = vboxNetLwfWinReturnNetBufferLists;
1908
1909	pDriverObject->DriverUnload = vboxNetLwfWinUnloadDriver;
1910
1911	NDIS_STATUS Status;
1912	g_VBoxNetLwfGlobals.hFilterDriver = NULL;
1913	Log(("vboxNetLwfWinRegister: registering filter driver...\n"));
1914	Status = NdisFRegisterFilterDriver(pDriverObject,
1915	(NDIS_HANDLE)&g_VBoxNetLwfGlobals,
1916	&FChars,
1917	&g_VBoxNetLwfGlobals.hFilterDriver);
1918	Assert(Status == STATUS_SUCCESS);
1919	if (Status == STATUS_SUCCESS)
1920	{
1921	Log(("vboxNetLwfWinRegister: successfully registered filter driver; registering device...\n"));
1922	Status = vboxNetLwfWinDevCreate(&g_VBoxNetLwfGlobals);
1923	Assert(Status == STATUS_SUCCESS);
1924	Log(("vboxNetLwfWinRegister: vboxNetLwfWinDevCreate() returned 0x%x\n", Status));
1925	}
1926	else
1927	{
1928	LogError(("vboxNetLwfWinRegister: failed to register filter driver, status=0x%x", Status));
1929	}
1930	return Status;
1931	}
1932
1933	static int vboxNetLwfWinStartInitIdcThread()
1934	{
1935	int rc = VERR_INVALID_STATE;
1936
1937	if (ASMAtomicCmpXchgU32(&g_VBoxNetLwfGlobals.enmIdcState, LwfIdcState_Connecting, LwfIdcState_Disconnected))
1938	{
1939	Log(("vboxNetLwfWinStartInitIdcThread: IDC state change Diconnected -> Connecting\n"));
1940
1941	NTSTATUS Status = PsCreateSystemThread(&g_VBoxNetLwfGlobals.hInitIdcThread,
1942	THREAD_ALL_ACCESS,
1943	NULL,
1944	NULL,
1945	NULL,
1946	vboxNetLwfWinInitIdcWorker,
1947	&g_VBoxNetLwfGlobals);
1948	Log(("vboxNetLwfWinStartInitIdcThread: create IDC initialization thread, status=0x%x\n", Status));
1949	if (Status != STATUS_SUCCESS)
1950	{
1951	LogError(("vboxNetLwfWinStartInitIdcThread: IDC initialization failed (system thread creation, status=0x%x)\n", Status));
1952	/*
1953	* We failed to init IDC and there will be no second chance.
1954	*/
1955	Log(("vboxNetLwfWinStartInitIdcThread: IDC state change Connecting -> Diconnected\n"));
1956	ASMAtomicWriteU32(&g_VBoxNetLwfGlobals.enmIdcState, LwfIdcState_Disconnected);
1957	}
1958	rc = RTErrConvertFromNtStatus(Status);
1959	}
1960	return rc;
1961	}
1962
1963	static void vboxNetLwfWinStopInitIdcThread()
1964	{
1965	}
1966
1967
1968	RT_C_DECLS_BEGIN
1969
1970	NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pRegistryPath);
1971
1972	RT_C_DECLS_END
1973
1974	NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pRegistryPath)
1975	{
1976	NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
1977	int rc;
1978
1979	/* the idc registration is initiated via IOCTL since our driver
1980	* can be loaded when the VBoxDrv is not in case we are a Ndis IM driver */
1981	rc = vboxNetLwfWinInitBase();
1982	AssertRC(rc);
1983	if (RT_SUCCESS(rc))
1984	{
1985	NdisZeroMemory(&g_VBoxNetLwfGlobals, sizeof (g_VBoxNetLwfGlobals));
1986	RTListInit(&g_VBoxNetLwfGlobals.listModules);
1987	NdisAllocateSpinLock(&g_VBoxNetLwfGlobals.Lock);
1988	/*
1989	* We choose to ignore IDC initialization errors here because if we fail to load
1990	* our filter the upper protocols won't bind to the associated adapter, causing
1991	* network failure at the host. Better to have non-working filter than broken
1992	* networking on the host.
1993	*/
1994	rc = vboxNetLwfWinStartInitIdcThread();
1995	AssertRC(rc);
1996
1997	Status = vboxNetLwfWinRegister(pDriverObject, pRegistryPath);
1998	Assert(Status == STATUS_SUCCESS);
1999	if (Status == NDIS_STATUS_SUCCESS)
2000	{
2001	Log(("NETLWF: started successfully\n"));
2002	return STATUS_SUCCESS;
2003	}
2004	NdisFreeSpinLock(&g_VBoxNetLwfGlobals.Lock);
2005	vboxNetLwfWinFini();
2006	}
2007	else
2008	{
2009	Status = NDIS_STATUS_FAILURE;
2010	}
2011
2012	return Status;
2013	}
2014
2015
2016	static VOID vboxNetLwfWinUnloadDriver(IN PDRIVER_OBJECT pDriver)
2017	{
2018	LogFlow(("==>vboxNetLwfWinUnloadDriver: driver=%p\n", pDriver));
2019	vboxNetLwfWinDevDestroy(&g_VBoxNetLwfGlobals);
2020	NdisFDeregisterFilterDriver(g_VBoxNetLwfGlobals.hFilterDriver);
2021	NdisFreeSpinLock(&g_VBoxNetLwfGlobals.Lock);
2022	LogFlow(("<==vboxNetLwfWinUnloadDriver\n"));
2023	vboxNetLwfWinFini();
2024	}
2025
2026	static const char *vboxNetLwfWinIdcStateToText(uint32_t enmState)
2027	{
2028	switch (enmState)
2029	{
2030	case LwfIdcState_Disconnected: return "Disconnected";
2031	case LwfIdcState_Connecting: return "Connecting";
2032	case LwfIdcState_Connected: return "Connected";
2033	case LwfIdcState_Stopping: return "Stopping";
2034	}
2035	return "Unknown";
2036	}
2037
2038	static VOID vboxNetLwfWinInitIdcWorker(PVOID pvContext)
2039	{
2040	int rc;
2041	PVBOXNETLWFGLOBALS pGlobals = (PVBOXNETLWFGLOBALS)pvContext;
2042
2043	while (ASMAtomicReadU32(&pGlobals->enmIdcState) == LwfIdcState_Connecting)
2044	{
2045	rc = vboxNetFltInitIdc(&g_VBoxNetFltGlobals);
2046	if (RT_SUCCESS(rc))
2047	{
2048	if (!ASMAtomicCmpXchgU32(&pGlobals->enmIdcState, LwfIdcState_Connected, LwfIdcState_Connecting))
2049	{
2050	/* The state has been changed (the only valid transition is to "Stopping"), undo init */
2051	rc = vboxNetFltTryDeleteIdc(&g_VBoxNetFltGlobals);
2052	Log(("vboxNetLwfWinInitIdcWorker: state change (Connecting -> %s) while initializing IDC, deleted IDC, rc=0x%x\n",
2053	vboxNetLwfWinIdcStateToText(ASMAtomicReadU32(&pGlobals->enmIdcState)), rc));
2054	}
2055	else
2056	{
2057	Log(("vboxNetLwfWinInitIdcWorker: IDC state change Connecting -> Connected\n"));
2058	}
2059	}
2060	else
2061	{
2062	LARGE_INTEGER WaitIn100nsUnits;
2063	WaitIn100nsUnits.QuadPart = -(LONGLONG)10000000; /* 1 sec */
2064	KeDelayExecutionThread(KernelMode, FALSE /* non-alertable */, &WaitIn100nsUnits);
2065	}
2066	}
2067	PsTerminateSystemThread(STATUS_SUCCESS);
2068	}
2069
2070	static int vboxNetLwfWinTryFiniIdc()
2071	{
2072	int rc = VINF_SUCCESS;
2073	NTSTATUS Status;
2074	PKTHREAD pThread = NULL;
2075	uint32_t enmPrevState = ASMAtomicXchgU32(&g_VBoxNetLwfGlobals.enmIdcState, LwfIdcState_Stopping);
2076
2077	Log(("vboxNetLwfWinTryFiniIdc: IDC state change %s -> Stopping\n", vboxNetLwfWinIdcStateToText(enmPrevState)));
2078
2079	switch (enmPrevState)
2080	{
2081	case LwfIdcState_Disconnected:
2082	/* Have not even attempted to connect -- nothing to do. */
2083	break;
2084	case LwfIdcState_Stopping:
2085	/* Impossible, but another thread is alreading doing FiniIdc, bail out */
2086	LogError(("vboxNetLwfWinTryFiniIdc: called in 'Stopping' state\n"));
2087	rc = VERR_INVALID_STATE;
2088	break;
2089	case LwfIdcState_Connecting:
2090	/* the worker thread is running, let's wait for it to stop */
2091	Status = ObReferenceObjectByHandle(g_VBoxNetLwfGlobals.hInitIdcThread,
2092	THREAD_ALL_ACCESS, NULL, KernelMode,
2093	(PVOID*)&pThread, NULL);
2094	if (Status == STATUS_SUCCESS)
2095	{
2096	KeWaitForSingleObject(pThread, Executive, KernelMode, FALSE, NULL);
2097	ObDereferenceObject(pThread);
2098	}
2099	else
2100	{
2101	LogError(("vboxNetLwfWinTryFiniIdc: ObReferenceObjectByHandle(%p) failed with 0x%x\n",
2102	g_VBoxNetLwfGlobals.hInitIdcThread, Status));
2103	}
2104	rc = RTErrConvertFromNtStatus(Status);
2105	break;
2106	case LwfIdcState_Connected:
2107	/* the worker succeeded in IDC init and terminated */
2108	rc = vboxNetFltTryDeleteIdc(&g_VBoxNetFltGlobals);
2109	Log(("vboxNetLwfWinTryFiniIdc: deleted IDC, rc=0x%x\n", rc));
2110	break;
2111	}
2112	return rc;
2113	}
2114
2115	static void vboxNetLwfWinFiniBase()
2116	{
2117	vboxNetFltDeleteGlobals(&g_VBoxNetFltGlobals);
2118
2119	/*
2120	* Undo the work done during start (in reverse order).
2121	*/
2122	memset(&g_VBoxNetFltGlobals, 0, sizeof(g_VBoxNetFltGlobals));
2123
2124	RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
2125	RTLogDestroy(RTLogSetDefaultInstance(NULL));
2126
2127	RTR0Term();
2128	}
2129
2130	static int vboxNetLwfWinInitBase()
2131	{
2132	int rc = RTR0Init(0);
2133	if (!RT_SUCCESS(rc))
2134	return rc;
2135
2136	memset(&g_VBoxNetFltGlobals, 0, sizeof(g_VBoxNetFltGlobals));
2137	rc = vboxNetFltInitGlobals(&g_VBoxNetFltGlobals);
2138	if (!RT_SUCCESS(rc))
2139	RTR0Term();
2140
2141	return rc;
2142	}
2143
2144	static int vboxNetLwfWinFini()
2145	{
2146	int rc = vboxNetLwfWinTryFiniIdc();
2147	if (RT_SUCCESS(rc))
2148	{
2149	vboxNetLwfWinFiniBase();
2150	}
2151	return rc;
2152	}
2153
2154
2155	/*
2156	*
2157	* The OS specific interface definition
2158	*
2159	*/
2160
2161
2162	bool vboxNetFltOsMaybeRediscovered(PVBOXNETFLTINS pThis)
2163	{
2164	LogFlow(("==>vboxNetFltOsMaybeRediscovered: instance=%p\n", pThis));
2165	LogFlow(("<==vboxNetFltOsMaybeRediscovered: return %RTbool\n", !ASMAtomicUoReadBool(&pThis->fDisconnectedFromHost)));
2166	/* AttachToInterface true if disconnected */
2167	return !ASMAtomicUoReadBool(&pThis->fDisconnectedFromHost);
2168	}
2169
2170	int vboxNetFltPortOsXmit(PVBOXNETFLTINS pThis, void *pvIfData, PINTNETSG pSG, uint32_t fDst)
2171	{
2172	int rc = VINF_SUCCESS;
2173
2174	PVBOXNETLWF_MODULE pModule = (PVBOXNETLWF_MODULE)pThis->u.s.WinIf.hModuleCtx;
2175	LogFlow(("==>vboxNetFltPortOsXmit: instance=%p module=%p\n", pThis, pModule));
2176	if (!pModule)
2177	{
2178	LogFlow(("<==vboxNetFltPortOsXmit: pModule is null, return %d\n", VERR_INTERNAL_ERROR));
2179	return VERR_INTERNAL_ERROR;
2180	}
2181	/* Prevent going into "paused" state until all transmissions have been completed. */
2182	NDIS_WAIT_FOR_MUTEX(&pModule->InTransmit);
2183	/* Ignore all sends if the stack is paused or being paused, etc... */
2184	if (!vboxNetLwfWinIsRunning(pModule))
2185	{
2186	NDIS_RELEASE_MUTEX(&pModule->InTransmit);
2187	return VINF_SUCCESS;
2188	}
2189
2190	const char *pszDir = (fDst & INTNETTRUNKDIR_WIRE) ?
2191	( (fDst & INTNETTRUNKDIR_HOST) ? "intnet --> all" : "intnet --> wire" ) : "intnet --> host";
2192	vboxNetLwfWinDumpPacket(pSG, pszDir);
2193	/*
2194	* There are two possible strategies to deal with incoming SGs:
2195	* 1) make a copy of data and complete asynchronously;
2196	* 2) complete synchronously using the original data buffers.
2197	* Before we consider implementing (1) it is quite interesting to see
2198	* how well (2) performs. So we block until our requests are complete.
2199	* Actually there is third possibility -- to use SG retain/release
2200	* callbacks, but those seem not be fully implemented yet.
2201	* Note that ansynchronous completion will require different implementation
2202	* of vboxNetLwfWinPause(), not relying on InTransmit mutex.
2203	*/
2204	#ifdef VBOXNETLWF_SYNC_SEND
2205	PVOID aEvents[2]; /* To wire and to host */
2206	ULONG nEvents = 0;
2207	LARGE_INTEGER timeout;
2208	timeout.QuadPart = -(LONGLONG)10000000; /* 1 sec */
2209	#endif /* VBOXNETLWF_SYNC_SEND */
2210	if (fDst & INTNETTRUNKDIR_WIRE)
2211	{
2212	PNET_BUFFER_LIST pBufList = vboxNetLwfWinSGtoNB(pModule, pSG);
2213	if (pBufList)
2214	{
2215	#ifdef VBOXNETLWF_SYNC_SEND
2216	aEvents[nEvents++] = &pModule->EventWire;
2217	#else /* !VBOXNETLWF_SYNC_SEND */
2218	if (ASMAtomicIncS32(&pModule->cPendingBuffers) == 1)
2219	NdisResetEvent(&pModule->EventSendComplete);
2220	#endif /* !VBOXNETLWF_SYNC_SEND */
2221	NdisFSendNetBufferLists(pModule->hFilter, pBufList, NDIS_DEFAULT_PORT_NUMBER, 0); /** @todo sendFlags! */
2222	}
2223	}
2224	if (fDst & INTNETTRUNKDIR_HOST)
2225	{
2226	PNET_BUFFER_LIST pBufList = vboxNetLwfWinSGtoNB(pModule, pSG);
2227	if (pBufList)
2228	{
2229	#ifdef VBOXNETLWF_SYNC_SEND
2230	aEvents[nEvents++] = &pModule->EventHost;
2231	#else /* !VBOXNETLWF_SYNC_SEND */
2232	if (ASMAtomicIncS32(&pModule->cPendingBuffers) == 1)
2233	NdisResetEvent(&pModule->EventSendComplete);
2234	#endif /* !VBOXNETLWF_SYNC_SEND */
2235	NdisFIndicateReceiveNetBufferLists(pModule->hFilter, pBufList, NDIS_DEFAULT_PORT_NUMBER, 1, 0);
2236	}
2237	}
2238	#ifdef VBOXNETLWF_SYNC_SEND
2239	if (nEvents)
2240	{
2241	NTSTATUS Status = KeWaitForMultipleObjects(nEvents, aEvents, WaitAll, Executive, KernelMode, FALSE, &timeout, NULL);
2242	if (Status != STATUS_SUCCESS)
2243	{
2244	LogError(("vboxNetFltPortOsXmit: KeWaitForMultipleObjects() failed with 0x%x\n", Status));
2245	if (Status == STATUS_TIMEOUT)
2246	rc = VERR_TIMEOUT;
2247	else
2248	rc = RTErrConvertFromNtStatus(Status);
2249	}
2250	}
2251	#endif /* VBOXNETLWF_SYNC_SEND */
2252	NDIS_RELEASE_MUTEX(&pModule->InTransmit);
2253
2254	LogFlow(("<==vboxNetFltPortOsXmit: return %d\n", rc));
2255	return rc;
2256	}
2257
2258
2259	NDIS_IO_WORKITEM_FUNCTION vboxNetLwfWinToggleOffloading;
2260
2261	VOID vboxNetLwfWinToggleOffloading(PVOID WorkItemContext, NDIS_HANDLE NdisIoWorkItemHandle)
2262	{
2263	/* WARNING! Call this with IRQL=Passive! */
2264	PVBOXNETLWF_MODULE pModuleCtx = (PVBOXNETLWF_MODULE)WorkItemContext;
2265
2266	if (ASMAtomicReadBool(&pModuleCtx->fActive))
2267	{
2268	/* Disable offloading temporarily by indicating offload config change. */
2269	/** @todo Be sure to revise this when implementing offloading support! */
2270	NDIS_OFFLOAD OffloadConfig;
2271	if (pModuleCtx->fOffloadConfigValid)
2272	{
2273	OffloadConfig = pModuleCtx->SavedOffloadConfig;
2274	vboxNetLwfWinDisableOffloading(&OffloadConfig);
2275	}
2276	else
2277	{
2278	DbgPrint("VBoxNetLwf: no saved offload config to modify for %s\n", pModuleCtx->szMiniportName);
2279	NdisZeroMemory(&OffloadConfig, sizeof(OffloadConfig));
2280	OffloadConfig.Header.Type = NDIS_OBJECT_TYPE_OFFLOAD;
2281	OffloadConfig.Header.Revision = NDIS_OFFLOAD_REVISION_1;
2282	OffloadConfig.Header.Size = NDIS_SIZEOF_NDIS_OFFLOAD_REVISION_1;
2283	}
2284	vboxNetLwfWinIndicateOffload(pModuleCtx, &OffloadConfig);
2285	Log(("vboxNetLwfWinToggleOffloading: set offloading off\n"));
2286	}
2287	else
2288	{
2289	/* The filter is inactive -- restore offloading configuration. */
2290	if (pModuleCtx->fOffloadConfigValid)
2291	{
2292	vboxNetLwfWinIndicateOffload(pModuleCtx, &pModuleCtx->SavedOffloadConfig);
2293	Log(("vboxNetLwfWinToggleOffloading: restored offloading config\n"));
2294	}
2295	else
2296	DbgPrint("VBoxNetLwf: no saved offload config to restore for %s\n", pModuleCtx->szMiniportName);
2297	}
2298	}
2299
2300
2301	void vboxNetFltPortOsSetActive(PVBOXNETFLTINS pThis, bool fActive)
2302	{
2303	PVBOXNETLWF_MODULE pModuleCtx = (PVBOXNETLWF_MODULE)pThis->u.s.WinIf.hModuleCtx;
2304	LogFlow(("==>vboxNetFltPortOsSetActive: instance=%p module=%p fActive=%RTbool\n", pThis, pModuleCtx, fActive));
2305	if (!pModuleCtx)
2306	{
2307	LogFlow(("<==vboxNetFltPortOsSetActive: pModuleCtx is null\n"));
2308	return;
2309	}
2310
2311	NDIS_STATUS Status = STATUS_SUCCESS;
2312	bool fOldActive = ASMAtomicXchgBool(&pModuleCtx->fActive, fActive);
2313	if (fOldActive != fActive)
2314	{
2315	NdisQueueIoWorkItem(pModuleCtx->hWorkItem, vboxNetLwfWinToggleOffloading, pModuleCtx);
2316	Status = vboxNetLwfWinSetPacketFilter(pModuleCtx, fActive);
2317	LogFlow(("<==vboxNetFltPortOsSetActive: vboxNetLwfWinSetPacketFilter() returned 0x%x\n", Status));
2318	}
2319	else
2320	LogFlow(("<==vboxNetFltPortOsSetActive: no change, remain %sactive\n", fActive ? "":"in"));
2321	}
2322
2323	int vboxNetFltOsDisconnectIt(PVBOXNETFLTINS pThis)
2324	{
2325	LogFlow(("==>vboxNetFltOsDisconnectIt: instance=%p\n", pThis));
2326	LogFlow(("<==vboxNetFltOsDisconnectIt: return 0\n"));
2327	return VINF_SUCCESS;
2328	}
2329
2330	int vboxNetFltOsConnectIt(PVBOXNETFLTINS pThis)
2331	{
2332	LogFlow(("==>vboxNetFltOsConnectIt: instance=%p\n", pThis));
2333	LogFlow(("<==vboxNetFltOsConnectIt: return 0\n"));
2334	return VINF_SUCCESS;
2335	}
2336
2337	/*
2338	* Uncommenting the following line produces debug log messages on IP address changes,
2339	* including wired interfaces. No actual calls to a switch port are made. This is for
2340	* debug purposes only!
2341	* #define VBOXNETLWFWIN_DEBUGIPADDRNOTIF 1
2342	*/
2343	static void vboxNetLwfWinIpAddrChangeCallback(IN PVOID pvCtx,
2344	IN PMIB_UNICASTIPADDRESS_ROW pRow,
2345	IN MIB_NOTIFICATION_TYPE enmNotifType)
2346	{
2347	PVBOXNETFLTINS pThis = (PVBOXNETFLTINS)pvCtx;
2348	PVBOXNETLWF_MODULE pModule = (PVBOXNETLWF_MODULE)pThis->u.s.WinIf.hModuleCtx;
2349
2350	/* We are only interested in add or remove notifications. */
2351	bool fAdded;
2352	if (enmNotifType == MibAddInstance)
2353	fAdded = true;
2354	else if (enmNotifType == MibDeleteInstance)
2355	fAdded = false;
2356	else
2357	return;
2358
2359	if ( pRow
2360	#ifndef VBOXNETLWFWIN_DEBUGIPADDRNOTIF
2361	&& pThis->pSwitchPort->pfnNotifyHostAddress
2362	#endif /* !VBOXNETLWFWIN_DEBUGIPADDRNOTIF */
2363	)
2364	{
2365	switch (pRow->Address.si_family)
2366	{
2367	case AF_INET:
2368	if ( IN4_IS_ADDR_LINKLOCAL(&pRow->Address.Ipv4.sin_addr)
2369	\|\| pRow->Address.Ipv4.sin_addr.s_addr == IN4ADDR_LOOPBACK)
2370	{
2371	Log(("vboxNetLwfWinIpAddrChangeCallback: ignoring %s address (%RTnaipv4)\n",
2372	pRow->Address.Ipv4.sin_addr.s_addr == IN4ADDR_LOOPBACK ? "loopback" : "link-local",
2373	pRow->Address.Ipv4.sin_addr));
2374	break;
2375	}
2376	Log(("vboxNetLwfWinIpAddrChangeCallback: %s IPv4 addr=%RTnaipv4 on luid=(%u,%u)\n",
2377	fAdded ? "add" : "remove", pRow->Address.Ipv4.sin_addr,
2378	pRow->InterfaceLuid.Info.IfType, pRow->InterfaceLuid.Info.NetLuidIndex));
2379	#ifndef VBOXNETLWFWIN_DEBUGIPADDRNOTIF
2380	pThis->pSwitchPort->pfnNotifyHostAddress(pThis->pSwitchPort, fAdded, kIntNetAddrType_IPv4,
2381	&pRow->Address.Ipv4.sin_addr);
2382	#endif /* !VBOXNETLWFWIN_DEBUGIPADDRNOTIF */
2383	break;
2384	case AF_INET6:
2385	if (Ipv6AddressScope(pRow->Address.Ipv6.sin6_addr.u.Byte) <= ScopeLevelLink)
2386	{
2387	Log(("vboxNetLwfWinIpAddrChangeCallback: ignoring link-local address (%RTnaipv6)\n",
2388	&pRow->Address.Ipv6.sin6_addr));
2389	break;
2390	}
2391	Log(("vboxNetLwfWinIpAddrChangeCallback: %s IPv6 addr=%RTnaipv6 scope=%d luid=(%u,%u)\n",
2392	fAdded ? "add" : "remove", &pRow->Address.Ipv6.sin6_addr,
2393	Ipv6AddressScope(pRow->Address.Ipv6.sin6_addr.u.Byte),
2394	pRow->InterfaceLuid.Info.IfType, pRow->InterfaceLuid.Info.NetLuidIndex));
2395	#ifndef VBOXNETLWFWIN_DEBUGIPADDRNOTIF
2396	pThis->pSwitchPort->pfnNotifyHostAddress(pThis->pSwitchPort, fAdded, kIntNetAddrType_IPv6,
2397	&pRow->Address.Ipv6.sin6_addr);
2398	#endif /* !VBOXNETLWFWIN_DEBUGIPADDRNOTIF */
2399	break;
2400	}
2401	}
2402	else
2403	Log(("vboxNetLwfWinIpAddrChangeCallback: pRow=%p pfnNotifyHostAddress=%p\n",
2404	pRow, pThis->pSwitchPort->pfnNotifyHostAddress));
2405	}
2406
2407	void vboxNetLwfWinRegisterIpAddrNotifier(PVBOXNETFLTINS pThis)
2408	{
2409	LogFlow(("==>vboxNetLwfWinRegisterIpAddrNotifier: instance=%p\n", pThis));
2410	if ( pThis->pSwitchPort
2411	#ifndef VBOXNETLWFWIN_DEBUGIPADDRNOTIF
2412	&& pThis->pSwitchPort->pfnNotifyHostAddress
2413	#endif /* !VBOXNETLWFWIN_DEBUGIPADDRNOTIF */
2414	)
2415	{
2416	NETIO_STATUS Status;
2417	/* First we need to go over all host IP addresses and add them via pfnNotifyHostAddress. */
2418	PMIB_UNICASTIPADDRESS_TABLE HostIpAddresses = NULL;
2419	Status = GetUnicastIpAddressTable(AF_UNSPEC, &HostIpAddresses);
2420	if (NETIO_SUCCESS(Status))
2421	{
2422	for (unsigned i = 0; i < HostIpAddresses->NumEntries; i++)
2423	vboxNetLwfWinIpAddrChangeCallback(pThis, &HostIpAddresses->Table[i], MibAddInstance);
2424	}
2425	else
2426	LogError(("vboxNetLwfWinRegisterIpAddrNotifier: GetUnicastIpAddressTable failed with %x\n", Status));
2427	/* Now we can register a callback function to keep track of address changes. */
2428	Status = NotifyUnicastIpAddressChange(AF_UNSPEC, vboxNetLwfWinIpAddrChangeCallback,
2429	pThis, false, &pThis->u.s.WinIf.hNotifier);
2430	if (NETIO_SUCCESS(Status))
2431	Log(("vboxNetLwfWinRegisterIpAddrNotifier: notifier=%p\n", pThis->u.s.WinIf.hNotifier));
2432	else
2433	LogError(("vboxNetLwfWinRegisterIpAddrNotifier: NotifyUnicastIpAddressChange failed with %x\n", Status));
2434	}
2435	else
2436	pThis->u.s.WinIf.hNotifier = NULL;
2437	LogFlow(("<==vboxNetLwfWinRegisterIpAddrNotifier\n"));
2438	}
2439
2440	void vboxNetLwfWinUnregisterIpAddrNotifier(PVBOXNETFLTINS pThis)
2441	{
2442	Log(("vboxNetLwfWinUnregisterIpAddrNotifier: notifier=%p\n", pThis->u.s.WinIf.hNotifier));
2443	if (pThis->u.s.WinIf.hNotifier)
2444	CancelMibChangeNotify2(pThis->u.s.WinIf.hNotifier);
2445	}
2446
2447	void vboxNetFltOsDeleteInstance(PVBOXNETFLTINS pThis)
2448	{
2449	PVBOXNETLWF_MODULE pModuleCtx = (PVBOXNETLWF_MODULE)pThis->u.s.WinIf.hModuleCtx;
2450	LogFlow(("==>vboxNetFltOsDeleteInstance: instance=%p module=%p\n", pThis, pModuleCtx));
2451	/* Cancel IP address change notifications */
2452	vboxNetLwfWinUnregisterIpAddrNotifier(pThis);
2453	/* Technically it is possible that the module has already been gone by now. */
2454	if (pModuleCtx)
2455	{
2456	Assert(!pModuleCtx->fActive); /* Deactivation ensures bypass mode */
2457	pModuleCtx->pNetFlt = NULL;
2458	pThis->u.s.WinIf.hModuleCtx = NULL;
2459	}
2460	LogFlow(("<==vboxNetFltOsDeleteInstance\n"));
2461	}
2462
2463	static void vboxNetLwfWinReportCapabilities(PVBOXNETFLTINS pThis, PVBOXNETLWF_MODULE pModuleCtx)
2464	{
2465	if (pThis->pSwitchPort
2466	&& vboxNetFltTryRetainBusyNotDisconnected(pThis))
2467	{
2468	pThis->pSwitchPort->pfnReportMacAddress(pThis->pSwitchPort, &pModuleCtx->MacAddr);
2469	pThis->pSwitchPort->pfnReportPromiscuousMode(pThis->pSwitchPort,
2470	vboxNetLwfWinIsPromiscuous(pModuleCtx));
2471	pThis->pSwitchPort->pfnReportGsoCapabilities(pThis->pSwitchPort, 0,
2472	INTNETTRUNKDIR_WIRE \| INTNETTRUNKDIR_HOST);
2473	pThis->pSwitchPort->pfnReportNoPreemptDsts(pThis->pSwitchPort, 0 /* none */);
2474	vboxNetFltRelease(pThis, true /fBusy/);
2475	}
2476	}
2477
2478	int vboxNetFltOsInitInstance(PVBOXNETFLTINS pThis, void *pvContext)
2479	{
2480	LogFlow(("==>vboxNetFltOsInitInstance: instance=%p context=%p\n", pThis, pvContext));
2481	AssertReturn(pThis, VERR_INVALID_PARAMETER);
2482	Log(("vboxNetFltOsInitInstance: trunk name=%s\n", pThis->szName));
2483	PVBOXNETLWF_MODULE pModuleCtx = NULL;
2484	NdisAcquireSpinLock(&g_VBoxNetLwfGlobals.Lock);
2485	RTListForEach(&g_VBoxNetLwfGlobals.listModules, pModuleCtx, VBOXNETLWF_MODULE, node)
2486	{
2487	DbgPrint("vboxNetFltOsInitInstance: evaluating module, name=%s\n", pModuleCtx->szMiniportName);
2488	if (!RTStrICmp(pThis->szName, pModuleCtx->szMiniportName))
2489	{
2490	NdisReleaseSpinLock(&g_VBoxNetLwfGlobals.Lock);
2491	Log(("vboxNetFltOsInitInstance: found matching module, name=%s\n", pThis->szName));
2492	pThis->u.s.WinIf.hModuleCtx = pModuleCtx;
2493	pModuleCtx->pNetFlt = pThis;
2494	vboxNetLwfWinReportCapabilities(pThis, pModuleCtx);
2495	vboxNetLwfWinRegisterIpAddrNotifier(pThis);
2496	LogFlow(("<==vboxNetFltOsInitInstance: return 0\n"));
2497	return VINF_SUCCESS;
2498	}
2499	}
2500	NdisReleaseSpinLock(&g_VBoxNetLwfGlobals.Lock);
2501	vboxNetLwfLogErrorEvent(IO_ERR_INTERNAL_ERROR, STATUS_SUCCESS, 6);
2502	LogFlow(("<==vboxNetFltOsInitInstance: return VERR_INTNET_FLT_IF_NOT_FOUND\n"));
2503	return VERR_INTNET_FLT_IF_NOT_FOUND;
2504	}
2505
2506	int vboxNetFltOsPreInitInstance(PVBOXNETFLTINS pThis)
2507	{
2508	LogFlow(("==>vboxNetFltOsPreInitInstance: instance=%p\n", pThis));
2509	pThis->u.s.WinIf.hModuleCtx = 0;
2510	pThis->u.s.WinIf.hNotifier = NULL;
2511	LogFlow(("<==vboxNetFltOsPreInitInstance: return 0\n"));
2512	return VINF_SUCCESS;
2513	}
2514
2515	void vboxNetFltPortOsNotifyMacAddress(PVBOXNETFLTINS pThis, void *pvIfData, PCRTMAC pMac)
2516	{
2517	LogFlow(("==>vboxNetFltPortOsNotifyMacAddress: instance=%p data=%p mac=%RTmac\n", pThis, pvIfData, pMac));
2518	LogFlow(("<==vboxNetFltPortOsNotifyMacAddress\n"));
2519	}
2520
2521	int vboxNetFltPortOsConnectInterface(PVBOXNETFLTINS pThis, void pvIf, void *ppvIfData)
2522	{
2523	LogFlow(("==>vboxNetFltPortOsConnectInterface: instance=%p if=%p data=%p\n", pThis, pvIf, ppvIfData));
2524	LogFlow(("<==vboxNetFltPortOsConnectInterface: return 0\n"));
2525	/* Nothing to do */
2526	return VINF_SUCCESS;
2527	}
2528
2529	int vboxNetFltPortOsDisconnectInterface(PVBOXNETFLTINS pThis, void *pvIfData)
2530	{
2531	LogFlow(("==>vboxNetFltPortOsDisconnectInterface: instance=%p data=%p\n", pThis, pvIfData));
2532	LogFlow(("<==vboxNetFltPortOsDisconnectInterface: return 0\n"));
2533	/* Nothing to do */
2534	return VINF_SUCCESS;
2535	}
2536

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

source: vbox/trunk/src/VBox/HostDrivers/VBoxNetFlt/win/drv/VBoxNetLwf-win.cpp@ 59971

Download in other formats: