VirtualBox

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

Last change on this file since 93115 was 93115, checked in by vboxsync, 2 years ago

scm --update-copyright-year
  • 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 93115 2022-01-01 11:31:46Z vboxsync $ */
2/** @file
3 * DrvNetSniffer - Network sniffer filter driver.
4 */
5
6/*
7 * Copyright (C) 2006-2022 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 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
377 PDRVNETSNIFFER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSNIFFER);
378 PCPDMDRVHLPR3 pHlp = pDrvIns->pHlpR3;
379
380 LogFlow(("drvNetSnifferConstruct:\n"));
381
382 /*
383 * Init the static parts.
384 */
385 pThis->pDrvIns = pDrvIns;
386 pThis->hFile = NIL_RTFILE;
387 /* The pcap file *must* start at time offset 0,0. */
388 pThis->StartNanoTS = RTTimeNanoTS() - RTTimeProgramNanoTS();
389 /* IBase */
390 pDrvIns->IBase.pfnQueryInterface = drvNetSnifferQueryInterface;
391 /* INetworkUp */
392 pThis->INetworkUp.pfnBeginXmit = drvNetSnifferUp_BeginXmit;
393 pThis->INetworkUp.pfnAllocBuf = drvNetSnifferUp_AllocBuf;
394 pThis->INetworkUp.pfnFreeBuf = drvNetSnifferUp_FreeBuf;
395 pThis->INetworkUp.pfnSendBuf = drvNetSnifferUp_SendBuf;
396 pThis->INetworkUp.pfnEndXmit = drvNetSnifferUp_EndXmit;
397 pThis->INetworkUp.pfnSetPromiscuousMode = drvNetSnifferUp_SetPromiscuousMode;
398 pThis->INetworkUp.pfnNotifyLinkChanged = drvNetSnifferUp_NotifyLinkChanged;
399 /* INetworkDown */
400 pThis->INetworkDown.pfnWaitReceiveAvail = drvNetSnifferDown_WaitReceiveAvail;
401 pThis->INetworkDown.pfnReceive = drvNetSnifferDown_Receive;
402 pThis->INetworkDown.pfnXmitPending = drvNetSnifferDown_XmitPending;
403 /* INetworkConfig */
404 pThis->INetworkConfig.pfnGetMac = drvNetSnifferDownCfg_GetMac;
405 pThis->INetworkConfig.pfnGetLinkState = drvNetSnifferDownCfg_GetLinkState;
406 pThis->INetworkConfig.pfnSetLinkState = drvNetSnifferDownCfg_SetLinkState;
407
408 /*
409 * Create the locks.
410 */
411 int rc = RTCritSectInit(&pThis->Lock);
412 AssertRCReturn(rc, rc);
413 rc = RTCritSectInit(&pThis->XmitLock);
414 AssertRCReturn(rc, rc);
415
416 /*
417 * Validate the config.
418 */
419 PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "File", "");
420
421 if (pHlp->pfnCFGMGetFirstChild(pCfg))
422 LogRel(("NetSniffer: Found child config entries -- are you trying to redirect ports?\n"));
423
424 /*
425 * Get the filename.
426 */
427 rc = pHlp->pfnCFGMQueryString(pCfg, "File", pThis->szFilename, sizeof(pThis->szFilename));
428 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
429 {
430 if (pDrvIns->iInstance > 0)
431 RTStrPrintf(pThis->szFilename, sizeof(pThis->szFilename), "./VBox-%x-%u.pcap", RTProcSelf(), pDrvIns->iInstance);
432 else
433 RTStrPrintf(pThis->szFilename, sizeof(pThis->szFilename), "./VBox-%x.pcap", RTProcSelf());
434 }
435
436 else if (RT_FAILURE(rc))
437 {
438 AssertMsgFailed(("Failed to query \"File\", rc=%Rrc.\n", rc));
439 return rc;
440 }
441
442 /*
443 * Query the network port interface.
444 */
445 pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
446 if (!pThis->pIAboveNet)
447 {
448 AssertMsgFailed(("Configuration error: the above device/driver didn't export the network port interface!\n"));
449 return VERR_PDM_MISSING_INTERFACE_ABOVE;
450 }
451
452 /*
453 * Query the network config interface.
454 */
455 pThis->pIAboveConfig = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKCONFIG);
456 if (!pThis->pIAboveConfig)
457 {
458 AssertMsgFailed(("Configuration error: the above device/driver didn't export the network config interface!\n"));
459 return VERR_PDM_MISSING_INTERFACE_ABOVE;
460 }
461
462 /*
463 * Query the network connector interface.
464 */
465 PPDMIBASE pBaseDown;
466 rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBaseDown);
467 if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
468 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
469 pThis->pIBelowNet = NULL;
470 else if (RT_SUCCESS(rc))
471 {
472 pThis->pIBelowNet = PDMIBASE_QUERY_INTERFACE(pBaseDown, PDMINETWORKUP);
473 if (!pThis->pIBelowNet)
474 {
475 AssertMsgFailed(("Configuration error: the driver below didn't export the network connector interface!\n"));
476 return VERR_PDM_MISSING_INTERFACE_BELOW;
477 }
478 }
479 else
480 {
481 AssertMsgFailed(("Failed to attach to driver below! rc=%Rrc\n", rc));
482 return rc;
483 }
484
485 /*
486 * Open output file / pipe.
487 */
488 rc = RTFileOpen(&pThis->hFile, pThis->szFilename,
489 RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_WRITE);
490 if (RT_FAILURE(rc))
491 return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
492 N_("Netsniffer cannot open '%s' for writing. The directory must exist and it must be writable for the current user"), pThis->szFilename);
493
494 char *pszPathReal = RTPathRealDup(pThis->szFilename);
495 if (pszPathReal)
496 {
497 LogRel(("NetSniffer: Sniffing to '%s'\n", pszPathReal));
498 RTStrFree(pszPathReal);
499 }
500 else
501 LogRel(("NetSniffer: Sniffing to '%s'\n", pThis->szFilename));
502
503 /*
504 * Write pcap header.
505 * Some time has gone by since capturing pThis->StartNanoTS so get the
506 * current time again.
507 */
508 PcapFileHdr(pThis->hFile, RTTimeNanoTS());
509
510 return VINF_SUCCESS;
511}
512
513
514
515/**
516 * Network sniffer filter driver registration record.
517 */
518const PDMDRVREG g_DrvNetSniffer =
519{
520 /* u32Version */
521 PDM_DRVREG_VERSION,
522 /* szName */
523 "NetSniffer",
524 /* szRCMod */
525 "",
526 /* szR0Mod */
527 "",
528 /* pszDescription */
529 "Network Sniffer Filter Driver",
530 /* fFlags */
531 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
532 /* fClass. */
533 PDM_DRVREG_CLASS_NETWORK,
534 /* cMaxInstances */
535 UINT32_MAX,
536 /* cbInstance */
537 sizeof(DRVNETSNIFFER),
538 /* pfnConstruct */
539 drvNetSnifferConstruct,
540 /* pfnDestruct */
541 drvNetSnifferDestruct,
542 /* pfnRelocate */
543 NULL,
544 /* pfnIOCtl */
545 NULL,
546 /* pfnPowerOn */
547 NULL,
548 /* pfnReset */
549 NULL,
550 /* pfnSuspend */
551 NULL,
552 /* pfnResume */
553 NULL,
554 /* pfnAttach */
555 drvNetSnifferAttach,
556 /* pfnDetach */
557 drvNetSnifferDetach,
558 /* pfnPowerOff */
559 NULL,
560 /* pfnSoftReset */
561 NULL,
562 /* u32EndVersion */
563 PDM_DRVREG_VERSION
564};
565
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use