VBoxNetFlt-win.h revision d61e6f5b11d9031623420bd7ed3013477d8f402d
/* $Id$ */
/** @file
*/
/*
* Copyright (C) 2008 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
/*
* Based in part on Microsoft DDK sample code for Ndis Intermediate Miniport passthru driver sample.
* Copyright (c) 1993-1999, Microsoft Corporation
*/
#ifndef ___VBoxNetFlt_win_h___
#define ___VBoxNetFlt_win_h___
/*
* globals
*/
/** global lock */
extern NDIS_SPIN_LOCK g_GlobalLock;
#ifdef VBOX_LOOPBACK_USEFLAGS
extern UINT g_fPacketDontLoopBack;
extern UINT g_fPacketIsLoopedBack;
#endif
/*
* Debug Print API
*/
#ifdef DEBUG
#else /* if DBG */
#endif /* if DBG */
#ifndef VBOXNETADP
# if !defined(VBOX_LOOPBACK_USEFLAGS) || defined(DEBUG_NETFLT_PACKETS)
DECLHIDDEN(bool) vboxNetFltWinMatchPackets(PNDIS_PACKET pPacket1, PNDIS_PACKET pPacket2, const INT cbMatch);
DECLHIDDEN(bool) vboxNetFltWinMatchPacketAndSG(PNDIS_PACKET pPacket, PINTNETSG pSG, const INT cbMatch);
# endif
#endif
/*************************
* packet queue API *
*************************/
#define LIST_ENTRY_2_PACKET_INFO(pListEntry) \
#if !defined(VBOX_LOOPBACK_USEFLAGS) || defined(DEBUG_NETFLT_PACKETS)
#define VBOX_SLE_2_SEND_RSVD(_pEntry) \
#define VBOX_SLE_2_SENDPACKET(_pEntry) \
( (PNDIS_PACKET)((uint8_t *)(VBOX_SLE_2_SEND_RSVD(_pEntry)) - RT_OFFSETOF(NDIS_PACKET, ProtocolReserved)) )
#endif
/**
* enqueus the packet info to the tail of the queue
*/
{
}
{
}
/**
* enqueus the packet info to the tail of the queue
*/
DECLINLINE(void) vboxNetFltWinQuInterlockedEnqueueTail(PINTERLOCKED_PACKET_QUEUE pQueue, PPACKET_INFO pPacketInfo)
{
}
DECLINLINE(void) vboxNetFltWinQuInterlockedEnqueueHead(PINTERLOCKED_PACKET_QUEUE pQueue, PPACKET_INFO pPacketInfo)
{
}
/**
* dequeus the packet info from the head of the queue
*/
{
if(pListEntry != pQueue)
{
return pInfo;
}
return NULL;
}
{
if(pListEntry != pQueue)
{
return pInfo;
}
return NULL;
}
DECLINLINE(PPACKET_INFO) vboxNetFltWinQuInterlockedDequeueHead(PINTERLOCKED_PACKET_QUEUE pInterlockedQueue)
{
return pInfo;
}
DECLINLINE(PPACKET_INFO) vboxNetFltWinQuInterlockedDequeueTail(PINTERLOCKED_PACKET_QUEUE pInterlockedQueue)
{
return pInfo;
}
{
}
DECLINLINE(void) vboxNetFltWinQuInterlockedDequeue(PINTERLOCKED_PACKET_QUEUE pInterlockedQueue, PPACKET_INFO pInfo)
{
}
/**
* allocates the packet info from the pool
*/
{
}
/**
* returns the packet info to the pool
*/
{
}
/** initializes the packet queue */
/** initializes the packet queue */
#define INIT_INTERLOCKED_PACKET_QUEUE(_pQueue) \
{ \
}
/** delete the packet queue */
/** returns the packet the packet info contains */
#define GET_PACKET_FROM_INFO(_pPacketInfo) (ASMAtomicUoReadPtr((void * volatile *)&(_pPacketInfo)->pPacket))
/** assignes the packet to the packet info */
#define SET_PACKET_TO_INFO(_pPacketInfo, _pPacket) (ASMAtomicUoWritePtr((void * volatile *)&(_pPacketInfo)->pPacket, (_pPacket)))
/** returns the flags the packet info contains */
#define GET_FLAGS_FROM_INFO(_pPacketInfo) (ASMAtomicUoReadU32((volatile uint32_t *)&(_pPacketInfo)->fFlags))
/** sets flags to the packet info */
#define SET_FLAGS_TO_INFO(_pPacketInfo, _fFlags) (ASMAtomicUoWriteU32((volatile uint32_t *)&(_pPacketInfo)->fFlags, (_fFlags)))
DECLHIDDEN(NDIS_STATUS) vboxNetFltWinQuEnqueuePacket(PVBOXNETFLTINS pInstance, PVOID pPacket, const UINT fPacketFlags);
#ifndef VBOX_NETFLT_ONDEMAND_BIND
#endif
#ifndef VBOXNETADP
/**
* searches the list entry in a single-linked list
*/
DECLINLINE(bool) vboxNetFltWinSearchListEntry(PSINGLE_LIST pList, PSINGLE_LIST_ENTRY pEntry2Search, bool bRemove)
{
{
if(pEntry2Search == pCur)
{
if(bRemove)
{
{
}
}
return true;
}
}
return false;
}
#if !defined(VBOX_LOOPBACK_USEFLAGS) || defined(DEBUG_NETFLT_PACKETS)
DECLINLINE(PNDIS_PACKET) vboxNetFltWinSearchPacket(PSINGLE_LIST pList, PNDIS_PACKET pPacket2Search, int cbMatch, bool bRemove)
{
{
{
if(bRemove)
{
{
}
}
return pCurPacket;
}
}
return NULL;
}
DECLINLINE(PNDIS_PACKET) vboxNetFltWinSearchPacketBySG(PSINGLE_LIST pList, PINTNETSG pSG, int cbMatch, bool bRemove)
{
{
{
if(bRemove)
{
{
}
}
return pCurPacket;
}
}
return NULL;
}
#endif /* #if !defined(VBOX_LOOPBACK_USEFLAGS) || defined(DEBUG_NETFLT_PACKETS) */
{
}
{
}
{
}
{
{
}
return pEntry;
}
DECLINLINE(bool) vboxNetFltWinInterlockedSearchListEntry(PINTERLOCKED_SINGLE_LIST pList, PSINGLE_LIST_ENTRY pEntry2Search, bool bRemove)
{
bool bFound;
return bFound;
}
#if !defined(VBOX_LOOPBACK_USEFLAGS) || defined(DEBUG_NETFLT_PACKETS)
DECLINLINE(PNDIS_PACKET) vboxNetFltWinInterlockedSearchPacket(PINTERLOCKED_SINGLE_LIST pList, PNDIS_PACKET pPacket2Search, int cbMatch, bool bRemove)
{
return pFound;
}
DECLINLINE(PNDIS_PACKET) vboxNetFltWinInterlockedSearchPacketBySG(PINTERLOCKED_SINGLE_LIST pList, PINTNETSG pSG, int cbMatch, bool bRemove)
{
return pFound;
}
#endif /* #if !defined(VBOX_LOOPBACK_USEFLAGS) || defined(DEBUG_NETFLT_PACKETS) */
DECLINLINE(void) vboxNetFltWinInterlockedPutTail(PINTERLOCKED_SINGLE_LIST pList, PSINGLE_LIST_ENTRY pEntry)
{
}
DECLINLINE(void) vboxNetFltWinInterlockedPutHead(PINTERLOCKED_SINGLE_LIST pList, PSINGLE_LIST_ENTRY pEntry)
{
}
{
return pEntry;
}
# if defined(DEBUG_NETFLT_PACKETS) || !defined(VBOX_LOOPBACK_USEFLAGS)
DECLINLINE(void) vboxNetFltWinLbPutSendPacket(PADAPT pAdapt, PNDIS_PACKET pPacket, bool bFromIntNet)
{
}
{
return pSrv->bFromIntNet;
}
DECLINLINE(PNDIS_PACKET) vboxNetFltWinLbSearchLoopBack(PADAPT pAdapt, PNDIS_PACKET pPacket, bool bRemove)
{
return vboxNetFltWinInterlockedSearchPacket(&pAdapt->SendPacketQueue, pPacket, VBOXNETFLT_PACKETMATCH_LENGTH, bRemove);
}
DECLINLINE(PNDIS_PACKET) vboxNetFltWinLbSearchLoopBackBySG(PADAPT pAdapt, PINTNETSG pSG, bool bRemove)
{
return vboxNetFltWinInterlockedSearchPacketBySG(&pAdapt->SendPacketQueue, pSG, VBOXNETFLT_PACKETMATCH_LENGTH, bRemove);
}
{
}
# endif
#endif
#ifdef DEBUG_misha
extern RTMAC g_vboxNetFltWinVerifyMACGuest;
do { \
} while(0)
do { \
} while(0)
#else
#endif
/** initializes the list */
#define INIT_SINGLE_LIST(_pList) \
{ \
}
/** initializes the list */
#define INIT_INTERLOCKED_SINGLE_LIST(_pList) \
do { \
} while(0)
/** delete the packet queue */
#define FINI_INTERLOCKED_SINGLE_LIST(_pList) \
do { \
} while(0)
/** obtains the PTRANSFERDATA_RSVD given a single list entry it contains */
//#define PT_SLE_2_TRANSFERDATA_RSVD(_pl) \
// ( (PTRANSFERDATA_RSVD)((uint8_t *)(_pl) - RT_OFFSETOF(TRANSFERDATA_RSVD, ListEntry)))
///** obtains the ndis packet given a single list entry assuming it is stored in ProtocolReserved field of the packet */
//#define PT_SLE_2_NDIS_PACKET(_pl) \
// ( (PNDIS_PACKET)((uint8_t *)PT_SLE_2_TRANSFERDATA_RSVD(_pl) - RT_OFFSETOF(NDIS_PACKET, ProtocolReserved)))
/**************************************************************************
* PADAPT, PVBOXNETFLTINS reference/dereference (i.e. retain/release) API *
**************************************************************************/
/** get the PVBOXNETFLTINS from PADAPT */
#define PADAPT_2_PVBOXNETFLTINS(_pAdapt) ( (PVBOXNETFLTINS)((uint8_t *)(_pAdapt) - RT_OFFSETOF(VBOXNETFLTINS, u.s.IfAdaptor)) )
/** get the PADAPT from PVBOXNETFLTINS */
{
}
{
}
{
}
{
}
{
}
{
}
{
Assert(v);
}
{
Assert(v);
}
{
}
{
}
{
}
{
}
{
if (vboxNetFltWinGetPowerState(pState) == NdisDeviceStateD0 && vboxNetFltWinGetOpState(pState) == kVBoxNetDevOpState_Initialized)
{
/** @todo r=bird: Since this is a volatile member, why don't you declare it as
* such and save yourself all the casting? */
return true;
}
return false;
}
#ifndef VBOXNETADP
DECLINLINE(bool) vboxNetFltWinDoReferenceDevices(PADAPT pAdapt, PADAPT_DEVICE pState1, PADAPT_DEVICE pState2)
{
{
return true;
}
return false;
}
#endif
{
/* NdisAcquireSpinLock(&pAdapt->Lock); */
/** @todo r=bird: Add comment explaining why these cannot hit 0 or why
* reference are counted */
/* NdisReleaseSpinLock(&pAdapt->Lock); */
}
#ifndef VBOXNETADP
DECLINLINE(void) vboxNetFltWinDereferenceDevices(PADAPT pAdapt, PADAPT_DEVICE pState1, PADAPT_DEVICE pState2)
{
/* NdisAcquireSpinLock(&pAdapt->Lock); */
/* NdisReleaseSpinLock(&pAdapt->Lock); */
}
#endif
{
Assert(v);
}
#ifndef VBOXNETADP
DECLINLINE(void) vboxNetFltWinDecReferenceDevices(PADAPT pAdapt, PADAPT_DEVICE pState1, PADAPT_DEVICE pState2, uint32_t v)
{
}
#endif
{
Assert(v);
if (vboxNetFltWinGetPowerState(pState) == NdisDeviceStateD0 && vboxNetFltWinGetOpState(pState) == kVBoxNetDevOpState_Initialized)
{
return true;
}
return false;
}
#ifndef VBOXNETADP
DECLINLINE(bool) vboxNetFltWinDoIncReferenceDevices(PADAPT pAdapt, PADAPT_DEVICE pState1, PADAPT_DEVICE pState2, uint32_t v)
{
{
return true;
}
return false;
}
#endif
#ifdef VBOX_NETFLT_ONDEMAND_BIND
{
{
return NULL;
}
{
return NULL;
}
return pNetFlt;
}
#else
DECLINLINE(bool) vboxNetFltWinReferenceAdaptNetFlt(PVBOXNETFLTINS pNetFlt, PADAPT pAdapt, bool * pbNetFltActive)
{
#ifndef VBOXNETADP
#else
#endif
{
*pbNetFltActive = false;
return false;
}
{
*pbNetFltActive = false;
return true;
}
*pbNetFltActive = true;
return true;
}
#endif
#ifdef VBOX_NETFLT_ONDEMAND_BIND
{
uint32_t i;
Assert(v);
if(!v)
{
return NULL;
}
{
return NULL;
}
{
return NULL;
}
/* we have marked it as busy, so can do the res references outside the lock */
for(i = 0; i < v-1; i++)
{
}
return pNetFlt;
}
#else
DECLINLINE(bool) vboxNetFltWinIncReferenceAdaptNetFlt(PVBOXNETFLTINS pNetFlt, PADAPT pAdapt, uint32_t v, bool *pbNetFltActive)
{
uint32_t i;
Assert(v);
if(!v)
{
*pbNetFltActive = false;
return false;
}
#ifndef VBOXNETADP
#else
#endif
{
*pbNetFltActive = false;
return false;
}
{
*pbNetFltActive = false;
return true;
}
/* we have marked it as busy, so can do the res references outside the lock */
for(i = 0; i < v-1; i++)
{
}
*pbNetFltActive = true;
return true;
}
#endif
{
uint32_t i;
for(i = 0; i < n; i++)
{
vboxNetFltRelease(pNetFlt, true);
}
}
{
vboxNetFltRelease(pNetFlt, true);
}
{
#ifdef VBOX_NETFLT_ONDEMAND_BIND
#elif defined(VBOXNETADP)
#else
#endif
}
{
#ifdef VBOX_NETFLT_ONDEMAND_BIND
#elif defined(VBOXNETADP)
#else
#endif
}
{
Assert(v);
if(!v)
{
return false;
}
#ifdef VBOX_NETFLT_ONDEMAND_BIND
#elif defined(VBOXNETADP)
#else
#endif
{
return true;
}
return false;
}
{
#ifdef VBOX_NETFLT_ONDEMAND_BIND
#elif defined(VBOXNETADP)
#else
#endif
{
return true;
}
return false;
}
/***********************************************
* methods for accessing the network card info *
***********************************************/
DECLHIDDEN(NDIS_STATUS) vboxNetFltWinQueryPhysicalMedium(PADAPT pAdapt, NDIS_PHYSICAL_MEDIUM * pMedium);
/*********************
* mem alloc API *
*********************/
/* convenience method used which allocates and initializes the PINTNETSG containing one
* segment refering the buffer of size cbBufSize
* the allocated PINTNETSG should be freed with the vboxNetFltWinMemFree.
*
* This is used when our ProtocolReceive callback is called and we have to return the indicated NDIS_PACKET
* on a callback exit. This is why we allocate the PINTNETSG and put the packet info there and enqueue it
* for the packet queue */
/************************
************************/
#if defined(VBOX_NETFLT_ONDEMAND_BIND)
#elif defined(VBOXNETADP)
DECLHIDDEN(NDIS_STATUS) vboxNetFltWinPtInitBind(PADAPT *ppAdapt, NDIS_HANDLE hMiniportAdapter, PNDIS_STRING pBindToMiniportName /* actually this is our miniport name*/, NDIS_HANDLE hWrapperConfigurationContext);
#else
DECLHIDDEN(NDIS_STATUS) vboxNetFltWinPtInitBind(PADAPT *ppAdapt, PNDIS_STRING pOurMiniportName, PNDIS_STRING pBindToMiniportName);
#endif
#ifdef VBOX_NETFLT_ONDEMAND_BIND
#else
DECLHIDDEN(NDIS_STATUS) vboxNetFltWinPtAllocInitPADAPT(PADAPT *ppAdapt, PNDIS_STRING pOurMiniportName, PNDIS_STRING pBindToMiniportName);
#endif
#ifndef VBOXNETADP
DECLHIDDEN(NDIS_STATUS) vboxNetFltWinPtInitPADAPT(IN PADAPT pAdapt, IN PNDIS_STRING pOurDeviceName);
#else
#endif
/************************************
* Execute Job at passive level API *
************************************/
/*******************************
* Ndis Packets processing API *
*******************************/
#ifndef NDIS_PACKET_FIRST_NDIS_BUFFER
#endif
#ifndef NDIS_PACKET_LAST_NDIS_BUFFER
#endif
#ifndef NDIS_PACKET_VALID_COUNTS
#endif
DECLHIDDEN(PNDIS_PACKET) vboxNetFltWinNdisPacketFromSG(PADAPT pAdapt, PINTNETSG pSG, PVOID pBufToFree, bool bToWire, bool bCopyMemory);
#ifdef DEBUG_NETFLT_PACKETS
{ \
}
{ \
}
{ \
}
#else
#endif
/**
* Ndis loops back broadcast packets posted to the wire by IntNet
* This routine is used in the mechanism of preventing this looping
*
* @param pAdapt
* @param pPacket
* @param bOnRecv true is we are receiving the packet from the wire
* false otherwise (i.e. the packet is from the host)
*
* @return true if the packet is a looped back one, false otherwise
*/
#ifdef VBOX_LOOPBACK_USEFLAGS
{
}
#endif
/**************************************************************
* utility methofs for ndis packet creation/initialization *
**************************************************************/
#define VBOXNETFLT_OOB_INIT(_p) \
{ \
}
#if !defined(VBOX_NETFLT_ONDEMAND_BIND) && !defined(VBOXNETADP)
DECLINLINE(NDIS_STATUS) vboxNetFltWinCopyPacketInfoOnRecv(PNDIS_PACKET pDstPacket, PNDIS_PACKET pSrcPacket)
{
/*
* Get the original packet (it could be the same packet as the one
* received or a different one based on the number of layered miniports
* below) and set it on the indicated packet so the OOB data is visible
* correctly to protocols above us.
*/
/*
* Set Packet Flags
*/
return fStatus;
}
DECLINLINE(void) vboxNetFltWinCopyPacketInfoOnSend(PNDIS_PACKET pDstPacket, PNDIS_PACKET pSrcPacket)
{
#ifdef WIN9X
/*
* Work around the fact that NDIS does not initialize this
* to FALSE on Win9x.
*/
#endif /* WIN9X */
/*
* Copy the OOB data from the original packet to the new
* packet.
*/
sizeof(NDIS_PACKET_OOB_DATA));
/*
* Copy relevant parts of the per packet info into the new packet
*/
#ifndef WIN9X
#endif
/*
* Copy the Media specific information
*/
{
}
}
/*, IN bool bNetFltActive*/
);
);
#endif
/**
* Sets the enmState member atomically.
*
* Used for all updates.
*
* @param pThis The instance.
* @param enmNewState The new value.
*/
{
}
/**
* Gets the enmState member atomically.
*
* Used for all reads.
*
* @returns The enmState value.
* @param pThis The instance.
*/
{
}
#ifndef VBOXNETADP
# define VBOXNETFLT_PROMISCUOUS_SUPPORTED(_pAdapt) \
// (!((_pAdapt)->PhMedium == NdisPhysicalMediumWirelessWan \
// || (_pAdapt)->PhMedium == NdisPhysicalMediumWirelessLan \
// || (_pAdapt)->PhMedium == NdisPhysicalMediumNative802_11 \
// || (_pAdapt)->PhMedium == NdisPhysicalMediumBluetooth \
// /*|| (_pAdapt)->PhMedium == NdisPhysicalMediumWiMax */ \
// ))
#else
#endif
#endif