VirtualBox

source: vbox/trunk/src/VBox/Devices/Network/DrvNetSniffer.cpp@ 90778

Last change on this file since 90778 was 82968, checked in by vboxsync, 4 years ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.6 KB
Line 
1/* $Id: DrvNetSniffer.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2/** @file
3 * DrvNetSniffer - Network sniffer filter driver.
4 */
5
6/*
7 * Copyright (C) 2006-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_DRV_NAT
23#include <VBox/vmm/pdmdrv.h>
24#include <VBox/vmm/pdmnetifs.h>
25
26#include <VBox/log.h>
27#include <iprt/assert.h>
28#include <iprt/critsect.h>
29#include <iprt/file.h>
30#include <iprt/process.h>
31#include <iprt/string.h>
32#include <iprt/time.h>
33#include <iprt/uuid.h>
34#include <iprt/path.h>
35#include <VBox/param.h>
36
37#include "Pcap.h"
38#include "VBoxDD.h"
39
40
41/*********************************************************************************************************************************
42* Structures and Typedefs *
43*********************************************************************************************************************************/
44/**
45 * Block driver instance data.
46 *
47 * @implements PDMINETWORKUP
48 * @implements PDMINETWORKDOWN
49 * @implements PDMINETWORKCONFIG
50 */
51typedef struct DRVNETSNIFFER
52{
53 /** The network interface. */
54 PDMINETWORKUP INetworkUp;
55 /** The network interface. */
56 PDMINETWORKDOWN INetworkDown;
57 /** The network config interface.
58 * @todo this is a main interface and shouldn't be here... */
59 PDMINETWORKCONFIG INetworkConfig;
60 /** The port we're attached to. */
61 PPDMINETWORKDOWN pIAboveNet;
62 /** The config port interface we're attached to. */
63 PPDMINETWORKCONFIG pIAboveConfig;
64 /** The connector that's attached to us. */
65 PPDMINETWORKUP pIBelowNet;
66 /** The filename. */
67 char szFilename[RTPATH_MAX];
68 /** The filehandle. */
69 RTFILE hFile;
70 /** The lock serializing the file access. */
71 RTCRITSECT Lock;
72 /** The NanoTS delta we pass to the pcap writers. */
73 uint64_t StartNanoTS;
74 /** Pointer to the driver instance. */
75 PPDMDRVINS pDrvIns;
76 /** For when we're the leaf driver. */
77 RTCRITSECT XmitLock;
78
79} DRVNETSNIFFER, *PDRVNETSNIFFER;
80
81
82
83/**
84 * @interface_method_impl{PDMINETWORKUP,pfnBeginXmit}
85 */
86static DECLCALLBACK(int) drvNetSnifferUp_BeginXmit(PPDMINETWORKUP pInterface, bool fOnWorkerThread)
87{
88 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkUp);
89 if (RT_UNLIKELY(!pThis->pIBelowNet))
90 {
91 int rc = RTCritSectTryEnter(&pThis->XmitLock);
92 if (RT_UNLIKELY(rc == VERR_SEM_BUSY))
93 rc = VERR_TRY_AGAIN;
94 return rc;
95 }
96 return pThis->pIBelowNet->pfnBeginXmit(pThis->pIBelowNet, fOnWorkerThread);
97}
98
99
100/**
101 * @interface_method_impl{PDMINETWORKUP,pfnAllocBuf}
102 */
103static DECLCALLBACK(int) drvNetSnifferUp_AllocBuf(PPDMINETWORKUP pInterface, size_t cbMin,
104 PCPDMNETWORKGSO pGso, PPPDMSCATTERGATHER ppSgBuf)
105{
106 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkUp);
107 if (RT_UNLIKELY(!pThis->pIBelowNet))
108 return VERR_NET_DOWN;
109 return pThis->pIBelowNet->pfnAllocBuf(pThis->pIBelowNet, cbMin, pGso, ppSgBuf);
110}
111
112
113/**
114 * @interface_method_impl{PDMINETWORKUP,pfnFreeBuf}
115 */
116static DECLCALLBACK(int) drvNetSnifferUp_FreeBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf)
117{
118 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkUp);
119 if (RT_UNLIKELY(!pThis->pIBelowNet))
120 return VERR_NET_DOWN;
121 return pThis->pIBelowNet->pfnFreeBuf(pThis->pIBelowNet, pSgBuf);
122}
123
124
125/**
126 * @interface_method_impl{PDMINETWORKUP,pfnSendBuf}
127 */
128static DECLCALLBACK(int) drvNetSnifferUp_SendBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
129{
130 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkUp);
131 if (RT_UNLIKELY(!pThis->pIBelowNet))
132 return VERR_NET_DOWN;
133
134 /* output to sniffer */
135 RTCritSectEnter(&pThis->Lock);
136 if (!pSgBuf->pvUser)
137 PcapFileFrame(pThis->hFile, pThis->StartNanoTS,
138 pSgBuf->aSegs[0].pvSeg,
139 pSgBuf->cbUsed,
140 RT_MIN(pSgBuf->cbUsed, pSgBuf->aSegs[0].cbSeg));
141 else
142 PcapFileGsoFrame(pThis->hFile, pThis->StartNanoTS, (PCPDMNETWORKGSO)pSgBuf->pvUser,
143 pSgBuf->aSegs[0].pvSeg,
144 pSgBuf->cbUsed,
145 RT_MIN(pSgBuf->cbUsed, pSgBuf->aSegs[0].cbSeg));
146 RTCritSectLeave(&pThis->Lock);
147
148 return pThis->pIBelowNet->pfnSendBuf(pThis->pIBelowNet, pSgBuf, fOnWorkerThread);
149}
150
151
152/**
153 * @interface_method_impl{PDMINETWORKUP,pfnEndXmit}
154 */
155static DECLCALLBACK(void) drvNetSnifferUp_EndXmit(PPDMINETWORKUP pInterface)
156{
157 LogFlow(("drvNetSnifferUp_EndXmit:\n"));
158 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkUp);
159 if (RT_LIKELY(pThis->pIBelowNet))
160 pThis->pIBelowNet->pfnEndXmit(pThis->pIBelowNet);
161 else
162 RTCritSectLeave(&pThis->XmitLock);
163}
164
165
166/**
167 * @interface_method_impl{PDMINETWORKUP,pfnSetPromiscuousMode}
168 */
169static DECLCALLBACK(void) drvNetSnifferUp_SetPromiscuousMode(PPDMINETWORKUP pInterface, bool fPromiscuous)
170{
171 LogFlow(("drvNetSnifferUp_SetPromiscuousMode: fPromiscuous=%d\n", fPromiscuous));
172 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkUp);
173 if (pThis->pIBelowNet)
174 pThis->pIBelowNet->pfnSetPromiscuousMode(pThis->pIBelowNet, fPromiscuous);
175}
176
177
178/**
179 * @interface_method_impl{PDMINETWORKUP,pfnNotifyLinkChanged}
180 */
181static DECLCALLBACK(void) drvNetSnifferUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
182{
183 LogFlow(("drvNetSnifferUp_NotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
184 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkUp);
185 if (pThis->pIBelowNet)
186 pThis->pIBelowNet->pfnNotifyLinkChanged(pThis->pIBelowNet, enmLinkState);
187}
188
189
190/**
191 * @interface_method_impl{PDMINETWORKDOWN,pfnWaitReceiveAvail}
192 */
193static DECLCALLBACK(int) drvNetSnifferDown_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies)
194{
195 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkDown);
196 return pThis->pIAboveNet->pfnWaitReceiveAvail(pThis->pIAboveNet, cMillies);
197}
198
199
200/**
201 * @interface_method_impl{PDMINETWORKDOWN,pfnReceive}
202 */
203static DECLCALLBACK(int) drvNetSnifferDown_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb)
204{
205 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkDown);
206
207 /* output to sniffer */
208 RTCritSectEnter(&pThis->Lock);
209 PcapFileFrame(pThis->hFile, pThis->StartNanoTS, pvBuf, cb, cb);
210 RTCritSectLeave(&pThis->Lock);
211
212 /* pass up */
213 int rc = pThis->pIAboveNet->pfnReceive(pThis->pIAboveNet, pvBuf, cb);
214#if 0
215 RTCritSectEnter(&pThis->Lock);
216 u64TS = RTTimeProgramNanoTS();
217 Hdr.ts_sec = (uint32_t)(u64TS / 1000000000);
218 Hdr.ts_usec = (uint32_t)((u64TS / 1000) % 1000000);
219 Hdr.incl_len = 0;
220 RTFileWrite(pThis->hFile, &Hdr, sizeof(Hdr), NULL);
221 RTCritSectLeave(&pThis->Lock);
222#endif
223 return rc;
224}
225
226
227/**
228 * @interface_method_impl{PDMINETWORKDOWN,pfnXmitPending}
229 */
230static DECLCALLBACK(void) drvNetSnifferDown_XmitPending(PPDMINETWORKDOWN pInterface)
231{
232 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkDown);
233 pThis->pIAboveNet->pfnXmitPending(pThis->pIAboveNet);
234}
235
236
237/**
238 * Gets the current Media Access Control (MAC) address.
239 *
240 * @returns VBox status code.
241 * @param pInterface Pointer to the interface structure containing the called function pointer.
242 * @param pMac Where to store the MAC address.
243 * @thread EMT
244 */
245static DECLCALLBACK(int) drvNetSnifferDownCfg_GetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac)
246{
247 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkConfig);
248 return pThis->pIAboveConfig->pfnGetMac(pThis->pIAboveConfig, pMac);
249}
250
251/**
252 * Gets the new link state.
253 *
254 * @returns The current link state.
255 * @param pInterface Pointer to the interface structure containing the called function pointer.
256 * @thread EMT
257 */
258static DECLCALLBACK(PDMNETWORKLINKSTATE) drvNetSnifferDownCfg_GetLinkState(PPDMINETWORKCONFIG pInterface)
259{
260 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkConfig);
261 return pThis->pIAboveConfig->pfnGetLinkState(pThis->pIAboveConfig);
262}
263
264/**
265 * Sets the new link state.
266 *
267 * @returns VBox status code.
268 * @param pInterface Pointer to the interface structure containing the called function pointer.
269 * @param enmState The new link state
270 * @thread EMT
271 */
272static DECLCALLBACK(int) drvNetSnifferDownCfg_SetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
273{
274 PDRVNETSNIFFER pThis = RT_FROM_MEMBER(pInterface, DRVNETSNIFFER, INetworkConfig);
275 return pThis->pIAboveConfig->pfnSetLinkState(pThis->pIAboveConfig, enmState);
276}
277
278
279/**
280 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
281 */
282static DECLCALLBACK(void *) drvNetSnifferQueryInterface(PPDMIBASE pInterface, const char *pszIID)
283{
284 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
285 PDRVNETSNIFFER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSNIFFER);
286 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
287 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUp);
288 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis->INetworkDown);
289 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThis->INetworkConfig);
290 return NULL;
291}
292
293
294/**
295 * @interface_method_impl{PDMDRVREG,pfnDetach}
296 */
297static DECLCALLBACK(void) drvNetSnifferDetach(PPDMDRVINS pDrvIns, uint32_t fFlags)
298{
299 RT_NOREF(fFlags);
300 PDRVNETSNIFFER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSNIFFER);
301
302 LogFlow(("drvNetSnifferDetach: pDrvIns: %p, fFlags: %u\n", pDrvIns, fFlags));
303 RTCritSectEnter(&pThis->XmitLock);
304 pThis->pIBelowNet = NULL;
305 RTCritSectLeave(&pThis->XmitLock);
306}
307
308
309/**
310 * @interface_method_impl{PDMDRVREG,pfnAttach}
311 */
312static DECLCALLBACK(int) drvNetSnifferAttach(PPDMDRVINS pDrvIns, uint32_t fFlags)
313{
314 PDRVNETSNIFFER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSNIFFER);
315 LogFlow(("drvNetSnifferAttach/#%#x: fFlags=%#x\n", pDrvIns->iInstance, fFlags));
316 RTCritSectEnter(&pThis->XmitLock);
317
318 /*
319 * Query the network connector interface.
320 */
321 PPDMIBASE pBaseDown;
322 int rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBaseDown);
323 if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
324 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
325 {
326 pThis->pIBelowNet = NULL;
327 rc = VINF_SUCCESS;
328 }
329 else if (RT_SUCCESS(rc))
330 {
331 pThis->pIBelowNet = PDMIBASE_QUERY_INTERFACE(pBaseDown, PDMINETWORKUP);
332 if (pThis->pIBelowNet)
333 rc = VINF_SUCCESS;
334 else
335 {
336 AssertMsgFailed(("Configuration error: the driver below didn't export the network connector interface!\n"));
337 rc = VERR_PDM_MISSING_INTERFACE_BELOW;
338 }
339 }
340 else
341 AssertMsgFailed(("Failed to attach to driver below! rc=%Rrc\n", rc));
342
343 RTCritSectLeave(&pThis->XmitLock);
344 return VINF_SUCCESS;
345}
346
347
348/**
349 * @interface_method_impl{PDMDRVREG,pfnDestruct}
350 */
351static DECLCALLBACK(void) drvNetSnifferDestruct(PPDMDRVINS pDrvIns)
352{
353 PDRVNETSNIFFER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSNIFFER);
354 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
355
356 if (RTCritSectIsInitialized(&pThis->Lock))
357 RTCritSectDelete(&pThis->Lock);
358
359 if (RTCritSectIsInitialized(&pThis->XmitLock))
360 RTCritSectDelete(&pThis->XmitLock);
361
362 if (pThis->hFile != NIL_RTFILE)
363 {
364 RTFileClose(pThis->hFile);
365 pThis->hFile = NIL_RTFILE;
366 }
367}
368
369
370/**
371 * @interface_method_impl{Construct a NAT network transport driver instance,
372 * PDMDRVREG,pfnDestruct}
373 */
374static DECLCALLBACK(int) drvNetSnifferConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
375{
376 PDRVNETSNIFFER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSNIFFER);
377 LogFlow(("drvNetSnifferConstruct:\n"));
378 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
379
380 /*
381 * Init the static parts.
382 */
383 pThis->pDrvIns = pDrvIns;
384 pThis->hFile = NIL_RTFILE;
385 /* The pcap file *must* start at time offset 0,0. */
386 pThis->StartNanoTS = RTTimeNanoTS() - RTTimeProgramNanoTS();
387 /* IBase */
388 pDrvIns->IBase.pfnQueryInterface = drvNetSnifferQueryInterface;
389 /* INetworkUp */
390 pThis->INetworkUp.pfnBeginXmit = drvNetSnifferUp_BeginXmit;
391 pThis->INetworkUp.pfnAllocBuf = drvNetSnifferUp_AllocBuf;
392 pThis->INetworkUp.pfnFreeBuf = drvNetSnifferUp_FreeBuf;
393 pThis->INetworkUp.pfnSendBuf = drvNetSnifferUp_SendBuf;
394 pThis->INetworkUp.pfnEndXmit = drvNetSnifferUp_EndXmit;
395 pThis->INetworkUp.pfnSetPromiscuousMode = drvNetSnifferUp_SetPromiscuousMode;
396 pThis->INetworkUp.pfnNotifyLinkChanged = drvNetSnifferUp_NotifyLinkChanged;
397 /* INetworkDown */
398 pThis->INetworkDown.pfnWaitReceiveAvail = drvNetSnifferDown_WaitReceiveAvail;
399 pThis->INetworkDown.pfnReceive = drvNetSnifferDown_Receive;
400 pThis->INetworkDown.pfnXmitPending = drvNetSnifferDown_XmitPending;
401 /* INetworkConfig */
402 pThis->INetworkConfig.pfnGetMac = drvNetSnifferDownCfg_GetMac;
403 pThis->INetworkConfig.pfnGetLinkState = drvNetSnifferDownCfg_GetLinkState;
404 pThis->INetworkConfig.pfnSetLinkState = drvNetSnifferDownCfg_SetLinkState;
405
406 /*
407 * Create the locks.
408 */
409 int rc = RTCritSectInit(&pThis->Lock);
410 AssertRCReturn(rc, rc);
411 rc = RTCritSectInit(&pThis->XmitLock);
412 AssertRCReturn(rc, rc);
413
414 /*
415 * Validate the config.
416 */
417 if (!CFGMR3AreValuesValid(pCfg, "File\0"))
418 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
419
420 if (CFGMR3GetFirstChild(pCfg))
421 LogRel(("NetSniffer: Found child config entries -- are you trying to redirect ports?\n"));
422
423 /*
424 * Get the filename.
425 */
426 rc = CFGMR3QueryString(pCfg, "File", pThis->szFilename, sizeof(pThis->szFilename));
427 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
428 {
429 if (pDrvIns->iInstance > 0)
430 RTStrPrintf(pThis->szFilename, sizeof(pThis->szFilename), "./VBox-%x-%u.pcap", RTProcSelf(), pDrvIns->iInstance);
431 else
432 RTStrPrintf(pThis->szFilename, sizeof(pThis->szFilename), "./VBox-%x.pcap", RTProcSelf());
433 }
434
435 else if (RT_FAILURE(rc))
436 {
437 AssertMsgFailed(("Failed to query \"File\", rc=%Rrc.\n", rc));
438 return rc;
439 }
440
441 /*
442 * Query the network port interface.
443 */
444 pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
445 if (!pThis->pIAboveNet)
446 {
447 AssertMsgFailed(("Configuration error: the above device/driver didn't export the network port interface!\n"));
448 return VERR_PDM_MISSING_INTERFACE_ABOVE;
449 }
450
451 /*
452 * Query the network config interface.
453 */
454 pThis->pIAboveConfig = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKCONFIG);
455 if (!pThis->pIAboveConfig)
456 {
457 AssertMsgFailed(("Configuration error: the above device/driver didn't export the network config interface!\n"));
458 return VERR_PDM_MISSING_INTERFACE_ABOVE;
459 }
460
461 /*
462 * Query the network connector interface.
463 */
464 PPDMIBASE pBaseDown;
465 rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBaseDown);
466 if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
467 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
468 pThis->pIBelowNet = NULL;
469 else if (RT_SUCCESS(rc))
470 {
471 pThis->pIBelowNet = PDMIBASE_QUERY_INTERFACE(pBaseDown, PDMINETWORKUP);
472 if (!pThis->pIBelowNet)
473 {
474 AssertMsgFailed(("Configuration error: the driver below didn't export the network connector interface!\n"));
475 return VERR_PDM_MISSING_INTERFACE_BELOW;
476 }
477 }
478 else
479 {
480 AssertMsgFailed(("Failed to attach to driver below! rc=%Rrc\n", rc));
481 return rc;
482 }
483
484 /*
485 * Open output file / pipe.
486 */
487 rc = RTFileOpen(&pThis->hFile, pThis->szFilename,
488 RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_WRITE);
489 if (RT_FAILURE(rc))
490 return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
491 N_("Netsniffer cannot open '%s' for writing. The directory must exist and it must be writable for the current user"), pThis->szFilename);
492
493 char *pszPathReal = RTPathRealDup(pThis->szFilename);
494 if (pszPathReal)
495 {
496 LogRel(("NetSniffer: Sniffing to '%s'\n", pszPathReal));
497 RTStrFree(pszPathReal);
498 }
499 else
500 LogRel(("NetSniffer: Sniffing to '%s'\n", pThis->szFilename));
501
502 /*
503 * Write pcap header.
504 * Some time has gone by since capturing pThis->StartNanoTS so get the
505 * current time again.
506 */
507 PcapFileHdr(pThis->hFile, RTTimeNanoTS());
508
509 return VINF_SUCCESS;
510}
511
512
513
514/**
515 * Network sniffer filter driver registration record.
516 */
517const PDMDRVREG g_DrvNetSniffer =
518{
519 /* u32Version */
520 PDM_DRVREG_VERSION,
521 /* szName */
522 "NetSniffer",
523 /* szRCMod */
524 "",
525 /* szR0Mod */
526 "",
527 /* pszDescription */
528 "Network Sniffer Filter Driver",
529 /* fFlags */
530 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
531 /* fClass. */
532 PDM_DRVREG_CLASS_NETWORK,
533 /* cMaxInstances */
534 UINT32_MAX,
535 /* cbInstance */
536 sizeof(DRVNETSNIFFER),
537 /* pfnConstruct */
538 drvNetSnifferConstruct,
539 /* pfnDestruct */
540 drvNetSnifferDestruct,
541 /* pfnRelocate */
542 NULL,
543 /* pfnIOCtl */
544 NULL,
545 /* pfnPowerOn */
546 NULL,
547 /* pfnReset */
548 NULL,
549 /* pfnSuspend */
550 NULL,
551 /* pfnResume */
552 NULL,
553 /* pfnAttach */
554 drvNetSnifferAttach,
555 /* pfnDetach */
556 drvNetSnifferDetach,
557 /* pfnPowerOff */
558 NULL,
559 /* pfnSoftReset */
560 NULL,
561 /* u32EndVersion */
562 PDM_DRVREG_VERSION
563};
564
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use