VirtualBox

Changeset 10758 in vbox for trunk/src/VBox/Devices


Ignore:
Timestamp:
Jul 18, 2008 8:38:02 PM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
33511
Message:

Use the pcap writers in DrvNetSniffer.

Location:
trunk/src/VBox/Devices
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Makefile.kmk

    r10756 r10758  
    537537        Storage/DrvVD.cpp \
    538538        Storage/VBoxHDD.cpp \
    539         Network/DrvNetSniffer.cpp
     539        Network/DrvNetSniffer.cpp \
     540        Network/Pcap.cpp
    540541ifndef VBOX_USE_NAT
    541542Drivers_SOURCES += \
    … …  
    631632        Network/DrvIntNet.cpp \
    632633        Network/DrvNetSniffer.cpp \
     634        Network/Pcap.cpp \
    633635        Audio/audio.c \
    634636        Audio/mixeng.c \

  • trunk/src/VBox/Devices/Network/DrvNetSniffer.cpp

    r10009 r10758  
    3737#include <VBox/param.h>
    3838
     39#include "Pcap.h"
    3940#include "Builtins.h"
    4041
    … …  
    6667    /** The lock serializing the file access. */
    6768    RTCRITSECT              Lock;
     69    /** The NanoTS delta we pass to the pcap writers. */
     70    uint64_t                StartNanoTS;
    6871    /** Pointer to the driver instance. */
    6972    PPDMDRVINS              pDrvIns;
    … …  
    8184
    8285
    83 /* "libpcap" magic */
    84 #define PCAP_MAGIC  0xa1b2c3d4
    85 
    86 /* "libpcap" file header (minus magic number). */
    87 struct pcap_hdr
    88 {
    89     uint16_t    version_major;  /* major version number                         = 2 */
    90     uint16_t    version_minor;  /* minor version number                         = 4 */
    91     int32_t     thiszone;       /* GMT to local correction                      = 0 */
    92     uint32_t    sigfigs;        /* accuracy of timestamps                       = 0 */
    93     uint32_t    snaplen;        /* max length of captured packets, in octets    = 0xffff */
    94     uint32_t    network;        /* data link type                               = 01 */
    95 };
    96 
    97 /* "libpcap" record header. */
    98 struct pcaprec_hdr
    99 {
    100     uint32_t    ts_sec;         /* timestamp seconds */
    101     uint32_t    ts_usec;        /* timestamp microseconds */
    102     uint32_t    incl_len;       /* number of octets of packet saved in file */
    103     uint32_t    orig_len;       /* actual length of packet */
    104 };
    105 
    106 struct pcaprec_hdr_init
    107 {
    108     uint32_t        u32Magic;
    109     struct pcap_hdr pcap;
    110 #ifdef LOG_ENABLED
    111     pcaprec_hdr     rec;
    112 #endif
    113 };
    114 
    11586
    11687/**
    … …  
    12596static DECLCALLBACK(int) drvNetSnifferSend(PPDMINETWORKCONNECTOR pInterface, const void *pvBuf, size_t cb)
    12697{
    127     PDRVNETSNIFFER pData = PDMINETWORKCONNECTOR_2_DRVNETSNIFFER(pInterface);
     98    PDRVNETSNIFFER pThis = PDMINETWORKCONNECTOR_2_DRVNETSNIFFER(pInterface);
    12899
    129100    /* output to sniffer */
    130     struct pcaprec_hdr  Hdr;
    131     uint64_t u64TS = RTTimeProgramNanoTS();
    132     Hdr.ts_sec = (uint32_t)(u64TS / 1000000000);
    133     Hdr.ts_usec = (uint32_t)((u64TS / 1000) % 1000000);
    134     Hdr.incl_len = cb;
    135     Hdr.orig_len = cb;
    136     RTCritSectEnter(&pData->Lock);
    137     RTFileWrite(pData->File, &Hdr, sizeof(Hdr), NULL);
    138     RTFileWrite(pData->File, pvBuf, cb, NULL);
    139     RTCritSectLeave(&pData->Lock);
     101    RTCritSectEnter(&pThis->Lock);
     102    PcapFileFrame(pThis->File, pThis->StartNanoTS, pvBuf, cb, cb);
     103    RTCritSectLeave(&pThis->Lock);
    140104
    141105    /* pass down */
    142     if (pData->pConnector)
    143     {
    144         int rc = pData->pConnector->pfnSend(pData->pConnector, pvBuf, cb);
     106    if (pThis->pConnector)
     107    {
     108        int rc = pThis->pConnector->pfnSend(pThis->pConnector, pvBuf, cb);
    145109#if 0
    146         RTCritSectEnter(&pData->Lock);
     110        RTCritSectEnter(&pThis->Lock);
    147111        u64TS = RTTimeProgramNanoTS();
    148112        Hdr.ts_sec = (uint32_t)(u64TS / 1000000000);
    149113        Hdr.ts_usec = (uint32_t)((u64TS / 1000) % 1000000);
    150114        Hdr.incl_len = 0;
    151         RTFileWrite(pData->File, &Hdr, sizeof(Hdr), NULL);
    152         RTCritSectLeave(&pData->Lock);
     115        RTFileWrite(pThis->File, &Hdr, sizeof(Hdr), NULL);
     116        RTCritSectLeave(&pThis->Lock);
    153117#endif
    154118        return rc;
    … …  
    171135{
    172136    LogFlow(("drvNetSnifferSetPromiscuousMode: fPromiscuous=%d\n", fPromiscuous));
    173     PDRVNETSNIFFER pData = PDMINETWORKCONNECTOR_2_DRVNETSNIFFER(pInterface);
    174     if (pData->pConnector)
    175         pData->pConnector->pfnSetPromiscuousMode(pData->pConnector, fPromiscuous);
     137    PDRVNETSNIFFER pThis = PDMINETWORKCONNECTOR_2_DRVNETSNIFFER(pInterface);
     138    if (pThis->pConnector)
     139        pThis->pConnector->pfnSetPromiscuousMode(pThis->pConnector, fPromiscuous);
    176140}
    177141
    … …  
    187151{
    188152    LogFlow(("drvNetSnifferNotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
    189     PDRVNETSNIFFER pData = PDMINETWORKCONNECTOR_2_DRVNETSNIFFER(pInterface);
    190     if (pData->pConnector)
    191         pData->pConnector->pfnNotifyLinkChanged(pData->pConnector, enmLinkState);
     153    PDRVNETSNIFFER pThis = PDMINETWORKCONNECTOR_2_DRVNETSNIFFER(pInterface);
     154    if (pThis->pConnector)
     155        pThis->pConnector->pfnNotifyLinkChanged(pThis->pConnector, enmLinkState);
    192156}
    193157
    … …  
    203167static DECLCALLBACK(int) drvNetSnifferWaitReceiveAvail(PPDMINETWORKPORT pInterface, unsigned cMillies)
    204168{
    205     PDRVNETSNIFFER pData = PDMINETWORKPORT_2_DRVNETSNIFFER(pInterface);
    206     return pData->pPort->pfnWaitReceiveAvail(pData->pPort, cMillies);
     169    PDRVNETSNIFFER pThis = PDMINETWORKPORT_2_DRVNETSNIFFER(pInterface);
     170    return pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, cMillies);
    207171}
    208172
    … …  
    219183static DECLCALLBACK(int) drvNetSnifferReceive(PPDMINETWORKPORT pInterface, const void *pvBuf, size_t cb)
    220184{
    221     PDRVNETSNIFFER pData = PDMINETWORKPORT_2_DRVNETSNIFFER(pInterface);
     185    PDRVNETSNIFFER pThis = PDMINETWORKPORT_2_DRVNETSNIFFER(pInterface);
    222186
    223187    /* output to sniffer */
    224     struct pcaprec_hdr  Hdr;
    225     uint64_t u64TS = RTTimeProgramNanoTS();
    226     Hdr.ts_sec = (uint32_t)(u64TS / 1000000000);
    227     Hdr.ts_usec = (uint32_t)((u64TS / 1000) % 1000000);
    228     Hdr.incl_len = cb;
    229     Hdr.orig_len = cb;
    230     RTCritSectEnter(&pData->Lock);
    231     RTFileWrite(pData->File, &Hdr, sizeof(Hdr), NULL);
    232     RTFileWrite(pData->File, pvBuf, cb, NULL);
    233     RTCritSectLeave(&pData->Lock);
     188    RTCritSectEnter(&pThis->Lock);
     189    PcapFileFrame(pThis->File, pThis->StartNanoTS, pvBuf, cb, cb);
     190    RTCritSectLeave(&pThis->Lock);
    234191
    235192    /* pass up */
    236     int rc = pData->pPort->pfnReceive(pData->pPort, pvBuf, cb);
     193    int rc = pThis->pPort->pfnReceive(pThis->pPort, pvBuf, cb);
    237194#if 0
    238     RTCritSectEnter(&pData->Lock);
     195    RTCritSectEnter(&pThis->Lock);
    239196    u64TS = RTTimeProgramNanoTS();
    240197    Hdr.ts_sec = (uint32_t)(u64TS / 1000000000);
    241198    Hdr.ts_usec = (uint32_t)((u64TS / 1000) % 1000000);
    242199    Hdr.incl_len = 0;
    243     RTFileWrite(pData->File, &Hdr, sizeof(Hdr), NULL);
    244     RTCritSectLeave(&pData->Lock);
     200    RTFileWrite(pThis->File, &Hdr, sizeof(Hdr), NULL);
     201    RTCritSectLeave(&pThis->Lock);
    245202#endif
    246203    return rc;
    … …  
    258215static DECLCALLBACK(int) drvNetSnifferGetMac(PPDMINETWORKCONFIG pInterface, PPDMMAC pMac)
    259216{
    260     PDRVNETSNIFFER pData = PDMINETWORKCONFIG_2_DRVNETSNIFFER(pInterface);
    261     return pData->pConfig->pfnGetMac(pData->pConfig, pMac);
     217    PDRVNETSNIFFER pThis = PDMINETWORKCONFIG_2_DRVNETSNIFFER(pInterface);
     218    return pThis->pConfig->pfnGetMac(pThis->pConfig, pMac);
    262219}
    263220
    … …  
    271228static DECLCALLBACK(PDMNETWORKLINKSTATE) drvNetSnifferGetLinkState(PPDMINETWORKCONFIG pInterface)
    272229{
    273     PDRVNETSNIFFER pData = PDMINETWORKCONFIG_2_DRVNETSNIFFER(pInterface);
    274     return pData->pConfig->pfnGetLinkState(pData->pConfig);
     230    PDRVNETSNIFFER pThis = PDMINETWORKCONFIG_2_DRVNETSNIFFER(pInterface);
     231    return pThis->pConfig->pfnGetLinkState(pThis->pConfig);
    275232}
    276233
    … …  
    285242static DECLCALLBACK(int) drvNetSnifferSetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState)
    286243{
    287     PDRVNETSNIFFER pData = PDMINETWORKCONFIG_2_DRVNETSNIFFER(pInterface);
    288     return pData->pConfig->pfnSetLinkState(pData->pConfig, enmState);
     244    PDRVNETSNIFFER pThis = PDMINETWORKCONFIG_2_DRVNETSNIFFER(pInterface);
     245    return pThis->pConfig->pfnSetLinkState(pThis->pConfig, enmState);
    289246}
    290247
    … …  
    302259{
    303260    PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
    304     PDRVNETSNIFFER pData = PDMINS2DATA(pDrvIns, PDRVNETSNIFFER);
     261    PDRVNETSNIFFER pThis = PDMINS2DATA(pDrvIns, PDRVNETSNIFFER);
    305262    switch (enmInterface)
    306263    {
    … …  
    308265            return &pDrvIns->IBase;
    309266        case PDMINTERFACE_NETWORK_CONNECTOR:
    310             return &pData->INetworkConnector;
     267            return &pThis->INetworkConnector;
    311268        case PDMINTERFACE_NETWORK_PORT:
    312             return &pData->INetworkPort;
     269            return &pThis->INetworkPort;
    313270        case PDMINTERFACE_NETWORK_CONFIG:
    314             return &pData->INetworkConfig;
     271            return &pThis->INetworkConfig;
    315272        default:
    316273            return NULL;
    … …  
    329286static DECLCALLBACK(void) drvNetSnifferDestruct(PPDMDRVINS pDrvIns)
    330287{
    331     PDRVNETSNIFFER pData = PDMINS2DATA(pDrvIns, PDRVNETSNIFFER);
    332 
    333     if (RTCritSectIsInitialized(&pData->Lock))
    334         RTCritSectDelete(&pData->Lock);
    335 
    336     if (pData->File != NIL_RTFILE)
    337     {
    338         RTFileClose(pData->File);
    339         pData->File = NIL_RTFILE;
     288    PDRVNETSNIFFER pThis = PDMINS2DATA(pDrvIns, PDRVNETSNIFFER);
     289
     290    if (RTCritSectIsInitialized(&pThis->Lock))
     291        RTCritSectDelete(&pThis->Lock);
     292
     293    if (pThis->File != NIL_RTFILE)
     294    {
     295        RTFileClose(pThis->File);
     296        pThis->File = NIL_RTFILE;
    340297    }
    341298}
    … …  
    354311static DECLCALLBACK(int) drvNetSnifferConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
    355312{
    356     PDRVNETSNIFFER pData = PDMINS2DATA(pDrvIns, PDRVNETSNIFFER);
     313    PDRVNETSNIFFER pThis = PDMINS2DATA(pDrvIns, PDRVNETSNIFFER);
    357314    LogFlow(("drvNetSnifferConstruct:\n"));
    358315
    … …  
    366323     * Init the static parts.
    367324     */
    368     pData->pDrvIns                      = pDrvIns;
    369     pData->File                         = NIL_RTFILE;
     325    pThis->pDrvIns                      = pDrvIns;
     326    pThis->File                         = NIL_RTFILE;
     327    pThis->StartNanoTS                  = /*RTTimeProgramNanoTS() - */ RTTimeNanoTS();
    370328    /* IBase */
    371329    pDrvIns->IBase.pfnQueryInterface    = drvNetSnifferQueryInterface;
    372330    /* INetworkConnector */
    373     pData->INetworkConnector.pfnSend                = drvNetSnifferSend;
    374     pData->INetworkConnector.pfnSetPromiscuousMode  = drvNetSnifferSetPromiscuousMode;
    375     pData->INetworkConnector.pfnNotifyLinkChanged   = drvNetSnifferNotifyLinkChanged;
     331    pThis->INetworkConnector.pfnSend                = drvNetSnifferSend;
     332    pThis->INetworkConnector.pfnSetPromiscuousMode  = drvNetSnifferSetPromiscuousMode;
     333    pThis->INetworkConnector.pfnNotifyLinkChanged   = drvNetSnifferNotifyLinkChanged;
    376334    /* INetworkPort */
    377     pData->INetworkPort.pfnWaitReceiveAvail         = drvNetSnifferWaitReceiveAvail;
    378     pData->INetworkPort.pfnReceive                  = drvNetSnifferReceive;
     335    pThis->INetworkPort.pfnWaitReceiveAvail         = drvNetSnifferWaitReceiveAvail;
     336    pThis->INetworkPort.pfnReceive                  = drvNetSnifferReceive;
    379337    /* INetworkConfig */
    380     pData->INetworkConfig.pfnGetMac                 = drvNetSnifferGetMac;
    381     pData->INetworkConfig.pfnGetLinkState           = drvNetSnifferGetLinkState;
    382     pData->INetworkConfig.pfnSetLinkState           = drvNetSnifferSetLinkState;
     338    pThis->INetworkConfig.pfnGetMac                 = drvNetSnifferGetMac;
     339    pThis->INetworkConfig.pfnGetLinkState           = drvNetSnifferGetLinkState;
     340    pThis->INetworkConfig.pfnSetLinkState           = drvNetSnifferSetLinkState;
    383341
    384342    /*
    385343     * Get the filename.
    386344     */
    387     int rc = CFGMR3QueryString(pCfgHandle, "File", pData->szFilename, sizeof(pData->szFilename));
     345    int rc = CFGMR3QueryString(pCfgHandle, "File", pThis->szFilename, sizeof(pThis->szFilename));
    388346    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    389         RTStrPrintf(pData->szFilename, sizeof(pData->szFilename), "./VBox-%x.pcap", RTProcSelf());
     347        RTStrPrintf(pThis->szFilename, sizeof(pThis->szFilename), "./VBox-%x.pcap", RTProcSelf());
    390348    else if (VBOX_FAILURE(rc))
    391349    {
    … …  
    397355     * Query the network port interface.
    398356     */
    399     pData->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
    400     if (!pData->pPort)
     357    pThis->pPort = (PPDMINETWORKPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_PORT);
     358    if (!pThis->pPort)
    401359    {
    402360        AssertMsgFailed(("Configuration error: the above device/driver didn't export the network port interface!\n"));
    … …  
    407365     * Query the network config interface.
    408366     */
    409     pData->pConfig = (PPDMINETWORKCONFIG)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_CONFIG);
    410     if (!pData->pConfig)
     367    pThis->pConfig = (PPDMINETWORKCONFIG)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_NETWORK_CONFIG);
     368    if (!pThis->pConfig)
    411369    {
    412370        AssertMsgFailed(("Configuration error: the above device/driver didn't export the network config interface!\n"));
    … …  
    420378    rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, &pBaseDown);
    421379    if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    422         pData->pConnector = NULL;
     380        pThis->pConnector = NULL;
    423381    else if (VBOX_SUCCESS(rc))
    424382    {
    425         pData->pConnector = (PPDMINETWORKCONNECTOR)pBaseDown->pfnQueryInterface(pBaseDown, PDMINTERFACE_NETWORK_CONNECTOR);
    426         if (!pData->pConnector)
     383        pThis->pConnector = (PPDMINETWORKCONNECTOR)pBaseDown->pfnQueryInterface(pBaseDown, PDMINTERFACE_NETWORK_CONNECTOR);
     384        if (!pThis->pConnector)
    427385        {
    428386            AssertMsgFailed(("Configuration error: the driver below didn't export the network connector interface!\n"));
    … …  
    439397     * Create the lock.
    440398     */
    441     rc = RTCritSectInit(&pData->Lock);
     399    rc = RTCritSectInit(&pThis->Lock);
    442400    if (VBOX_FAILURE(rc))
    443401        return rc;
    … …  
    446404     * Open output file / pipe.
    447405     */
    448     rc = RTFileOpen(&pData->File, pData->szFilename,
     406    rc = RTFileOpen(&pThis->File, pThis->szFilename,
    449407                    RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_WRITE);
    450408    if (VBOX_FAILURE(rc))
    451409    {
    452         AssertMsgFailed(("Failed to create file '%s' for writing. rc=%Vrc\n", pData->szFilename, rc));
     410        AssertMsgFailed(("Failed to create file '%s' for writing. rc=%Vrc\n", pThis->szFilename, rc));
    453411        return rc;
    454412    }
    … …  
    457415     * Write pcap header.
    458416     */
    459 #ifdef LOG_ENABLED
    460     pcaprec_hdr_init Hdr =
    461     {
    462         PCAP_MAGIC,
    463         { 2, 4, 0, 0, 0xffff, 1 },
    464         { 0, 1, 0, 60}
    465     }; /* force ethereal to start at 0.000000. */
    466 #else
    467     pcaprec_hdr_init Hdr =
    468     {
    469         PCAP_MAGIC,
    470         { 2, 4, 0, 0, 0xffff, 1 }
    471     }; /* this is just to make it happy, not to be correct. */
    472 #endif
    473 
    474     RTFileWrite(pData->File, &Hdr, sizeof(Hdr), NULL);
     417    PcapFileHdr(pThis->File, pThis->StartNanoTS);
    475418
    476419    return VINF_SUCCESS;
Note: See TracChangeset for help on using the changeset viewer.

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