VirtualBox

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

Last change on this file since 28587 was 28277, checked in by vboxsync, 15 years ago

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