VirtualBox

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

Last change on this file since 59063 was 57358, checked in by vboxsync, 9 years ago

*: scm cleanup run.
  • 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 57358 2015-08-14 15:16:38Z vboxsync $ */
2/** @file
3 * DrvNetSniffer - Network sniffer filter driver.
4 */
5
6/*
7 * Copyright (C) 2006-2015 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 PDRVNETSNIFFER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSNIFFER);
300
301 LogFlow(("drvNetSnifferDetach: pDrvIns: %p, fFlags: %u\n", pDrvIns, fFlags));
302 RTCritSectEnter(&pThis->XmitLock);
303 pThis->pIBelowNet = NULL;
304 RTCritSectLeave(&pThis->XmitLock);
305}
306
307
308/**
309 * @interface_method_impl{PDMDRVREG,pfnAttach}
310 */
311static DECLCALLBACK(int) drvNetSnifferAttach(PPDMDRVINS pDrvIns, uint32_t fFlags)
312{
313 PDRVNETSNIFFER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSNIFFER);
314 LogFlow(("drvNetSnifferAttach/#%#x: fFlags=%#x\n", pDrvIns->iInstance, fFlags));
315 RTCritSectEnter(&pThis->XmitLock);
316
317 /*
318 * Query the network connector interface.
319 */
320 PPDMIBASE pBaseDown;
321 int rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBaseDown);
322 if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
323 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
324 {
325 pThis->pIBelowNet = NULL;
326 rc = VINF_SUCCESS;
327 }
328 else if (RT_SUCCESS(rc))
329 {
330 pThis->pIBelowNet = PDMIBASE_QUERY_INTERFACE(pBaseDown, PDMINETWORKUP);
331 if (pThis->pIBelowNet)
332 rc = VINF_SUCCESS;
333 else
334 {
335 AssertMsgFailed(("Configuration error: the driver below didn't export the network connector interface!\n"));
336 rc = VERR_PDM_MISSING_INTERFACE_BELOW;
337 }
338 }
339 else
340 AssertMsgFailed(("Failed to attach to driver below! rc=%Rrc\n", rc));
341
342 RTCritSectLeave(&pThis->XmitLock);
343 return VINF_SUCCESS;
344}
345
346
347/**
348 * @interface_method_impl{PDMDRVREG,pfnDestruct}
349 */
350static DECLCALLBACK(void) drvNetSnifferDestruct(PPDMDRVINS pDrvIns)
351{
352 PDRVNETSNIFFER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSNIFFER);
353 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
354
355 if (RTCritSectIsInitialized(&pThis->Lock))
356 RTCritSectDelete(&pThis->Lock);
357
358 if (RTCritSectIsInitialized(&pThis->XmitLock))
359 RTCritSectDelete(&pThis->XmitLock);
360
361 if (pThis->hFile != NIL_RTFILE)
362 {
363 RTFileClose(pThis->hFile);
364 pThis->hFile = NIL_RTFILE;
365 }
366}
367
368
369/**
370 * @interface_method_impl{Construct a NAT network transport driver instance,
371 * PDMDRVREG,pfnDestruct}
372 */
373static DECLCALLBACK(int) drvNetSnifferConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
374{
375 PDRVNETSNIFFER pThis = PDMINS_2_DATA(pDrvIns, PDRVNETSNIFFER);
376 LogFlow(("drvNetSnifferConstruct:\n"));
377 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
378
379 /*
380 * Init the static parts.
381 */
382 pThis->pDrvIns = pDrvIns;
383 pThis->hFile = NIL_RTFILE;
384 /* The pcap file *must* start at time offset 0,0. */
385 pThis->StartNanoTS = RTTimeNanoTS() - RTTimeProgramNanoTS();
386 /* IBase */
387 pDrvIns->IBase.pfnQueryInterface = drvNetSnifferQueryInterface;
388 /* INetworkUp */
389 pThis->INetworkUp.pfnBeginXmit = drvNetSnifferUp_BeginXmit;
390 pThis->INetworkUp.pfnAllocBuf = drvNetSnifferUp_AllocBuf;
391 pThis->INetworkUp.pfnFreeBuf = drvNetSnifferUp_FreeBuf;
392 pThis->INetworkUp.pfnSendBuf = drvNetSnifferUp_SendBuf;
393 pThis->INetworkUp.pfnEndXmit = drvNetSnifferUp_EndXmit;
394 pThis->INetworkUp.pfnSetPromiscuousMode = drvNetSnifferUp_SetPromiscuousMode;
395 pThis->INetworkUp.pfnNotifyLinkChanged = drvNetSnifferUp_NotifyLinkChanged;
396 /* INetworkDown */
397 pThis->INetworkDown.pfnWaitReceiveAvail = drvNetSnifferDown_WaitReceiveAvail;
398 pThis->INetworkDown.pfnReceive = drvNetSnifferDown_Receive;
399 pThis->INetworkDown.pfnXmitPending = drvNetSnifferDown_XmitPending;
400 /* INetworkConfig */
401 pThis->INetworkConfig.pfnGetMac = drvNetSnifferDownCfg_GetMac;
402 pThis->INetworkConfig.pfnGetLinkState = drvNetSnifferDownCfg_GetLinkState;
403 pThis->INetworkConfig.pfnSetLinkState = drvNetSnifferDownCfg_SetLinkState;
404
405 /*
406 * Create the locks.
407 */
408 int rc = RTCritSectInit(&pThis->Lock);
409 AssertRCReturn(rc, rc);
410 rc = RTCritSectInit(&pThis->XmitLock);
411 AssertRCReturn(rc, rc);
412
413 /*
414 * Validate the config.
415 */
416 if (!CFGMR3AreValuesValid(pCfg, "File\0"))
417 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
418
419 if (CFGMR3GetFirstChild(pCfg))
420 LogRel(("NetSniffer: Found child config entries -- are you trying to redirect ports?\n"));
421
422 /*
423 * Get the filename.
424 */
425 rc = CFGMR3QueryString(pCfg, "File", pThis->szFilename, sizeof(pThis->szFilename));
426 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
427 {
428 if (pDrvIns->iInstance > 0)
429 RTStrPrintf(pThis->szFilename, sizeof(pThis->szFilename), "./VBox-%x-%u.pcap", RTProcSelf(), pDrvIns->iInstance);
430 else
431 RTStrPrintf(pThis->szFilename, sizeof(pThis->szFilename), "./VBox-%x.pcap", RTProcSelf());
432 }
433
434 else if (RT_FAILURE(rc))
435 {
436 AssertMsgFailed(("Failed to query \"File\", rc=%Rrc.\n", rc));
437 return rc;
438 }
439
440 /*
441 * Query the network port interface.
442 */
443 pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
444 if (!pThis->pIAboveNet)
445 {
446 AssertMsgFailed(("Configuration error: the above device/driver didn't export the network port interface!\n"));
447 return VERR_PDM_MISSING_INTERFACE_ABOVE;
448 }
449
450 /*
451 * Query the network config interface.
452 */
453 pThis->pIAboveConfig = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKCONFIG);
454 if (!pThis->pIAboveConfig)
455 {
456 AssertMsgFailed(("Configuration error: the above device/driver didn't export the network config interface!\n"));
457 return VERR_PDM_MISSING_INTERFACE_ABOVE;
458 }
459
460 /*
461 * Query the network connector interface.
462 */
463 PPDMIBASE pBaseDown;
464 rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBaseDown);
465 if ( rc == VERR_PDM_NO_ATTACHED_DRIVER
466 || rc == VERR_PDM_CFG_MISSING_DRIVER_NAME)
467 pThis->pIBelowNet = NULL;
468 else if (RT_SUCCESS(rc))
469 {
470 pThis->pIBelowNet = PDMIBASE_QUERY_INTERFACE(pBaseDown, PDMINETWORKUP);
471 if (!pThis->pIBelowNet)
472 {
473 AssertMsgFailed(("Configuration error: the driver below didn't export the network connector interface!\n"));
474 return VERR_PDM_MISSING_INTERFACE_BELOW;
475 }
476 }
477 else
478 {
479 AssertMsgFailed(("Failed to attach to driver below! rc=%Rrc\n", rc));
480 return rc;
481 }
482
483 /*
484 * Open output file / pipe.
485 */
486 rc = RTFileOpen(&pThis->hFile, pThis->szFilename,
487 RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_WRITE);
488 if (RT_FAILURE(rc))
489 return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
490 N_("Netsniffer cannot open '%s' for writing. The directory must exist and it must be writable for the current user"), pThis->szFilename);
491
492 char *pszPathReal = RTPathRealDup(pThis->szFilename);
493 if (pszPathReal)
494 {
495 LogRel(("NetSniffer: Sniffing to '%s'\n", pszPathReal));
496 RTStrFree(pszPathReal);
497 }
498 else
499 LogRel(("NetSniffer: Sniffing to '%s'\n", pThis->szFilename));
500
501 /*
502 * Write pcap header.
503 * Some time has gone by since capturing pThis->StartNanoTS so get the
504 * current time again.
505 */
506 PcapFileHdr(pThis->hFile, RTTimeNanoTS());
507
508 return VINF_SUCCESS;
509}
510
511
512
513/**
514 * Network sniffer filter driver registration record.
515 */
516const PDMDRVREG g_DrvNetSniffer =
517{
518 /* u32Version */
519 PDM_DRVREG_VERSION,
520 /* szName */
521 "NetSniffer",
522 /* szRCMod */
523 "",
524 /* szR0Mod */
525 "",
526 /* pszDescription */
527 "Network Sniffer Filter Driver",
528 /* fFlags */
529 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
530 /* fClass. */
531 PDM_DRVREG_CLASS_NETWORK,
532 /* cMaxInstances */
533 UINT32_MAX,
534 /* cbInstance */
535 sizeof(DRVNETSNIFFER),
536 /* pfnConstruct */
537 drvNetSnifferConstruct,
538 /* pfnDestruct */
539 drvNetSnifferDestruct,
540 /* pfnRelocate */
541 NULL,
542 /* pfnIOCtl */
543 NULL,
544 /* pfnPowerOn */
545 NULL,
546 /* pfnReset */
547 NULL,
548 /* pfnSuspend */
549 NULL,
550 /* pfnResume */
551 NULL,
552 /* pfnAttach */
553 drvNetSnifferAttach,
554 /* pfnDetach */
555 drvNetSnifferDetach,
556 /* pfnPowerOff */
557 NULL,
558 /* pfnSoftReset */
559 NULL,
560 /* u32EndVersion */
561 PDM_DRVREG_VERSION
562};
563
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette