intnet.h revision d2c6b2e8826a5ef34170fef0c72c3fc7c5c1b46a
/** @file
* INTNET - Internal Networking. (DEV,++)
*/
/*
* Copyright (C) 2006-2011 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.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
#ifndef ___VBox_intnet_h
#define ___VBox_intnet_h
/**
* Generic two-sided ring buffer.
*
* The deal is that there is exactly one writer and one reader.
* When offRead equals offWrite the buffer is empty. In the other
* extreme the writer will not use the last free byte in the buffer.
*/
typedef struct INTNETRINGBUF
{
/** The offset from this structure to the start of the buffer. */
/** The offset from this structure to the end of the buffer. (exclusive). */
/** The current read offset. */
/** Alignment. */
/** The committed write offset. */
uint32_t volatile offWriteCom;
/** Writer internal current write offset.
* This is ahead of offWriteCom when buffer space is handed to a third party for
* data gathering. offWriteCom will be assigned this value by the writer then
* the frame is ready. */
uint32_t volatile offWriteInt;
/** The number of bytes written (not counting overflows). */
/** The number of frames written (not counting overflows). */
/** The number of overflows. */
/** Pointer to a ring buffer. */
typedef INTNETRINGBUF *PINTNETRINGBUF;
/** The alignment of a ring buffer. */
#define INTNETRINGBUF_ALIGNMENT sizeof(INTNETHDR)
/**
* Asserts the sanity of the specified INTNETRINGBUF structure.
*/
#ifdef VBOX_STRICT
# define INTNETRINGBUF_ASSERT_SANITY(pRingBuf) \
do \
{ \
{ \
\
\
\
: offWriteCom <= offWriteInt, \
} \
} while (0)
#else
# define INTNETRINGBUF_ASSERT_SANITY(pRingBuf) do { } while (0)
#endif
/**
* A interface buffer.
*/
typedef struct INTNETBUF
{
/** Magic number (INTNETBUF_MAGIC). */
/** The size of the entire buffer. */
/** The size of the send area. */
/** The size of the receive area. */
/** The receive buffer. */
/** The send buffer. */
/** Number of times yields help solve an overflow. */
/** Number of times yields didn't help solve an overflow. */
/** Number of lost packets due to overflows. */
/** Number of bad frames (both rings). */
/** Reserved for future use. */
/** Reserved for future send profiling. */
/** Reserved for future send profiling. */
/** Reserved for future receive profiling. */
/** Reserved for future receive profiling. */
/** Reserved for future profiling. */
} INTNETBUF;
/** Pointer to an interface buffer. */
typedef INTNETBUF *PINTNETBUF;
/** Pointer to a const interface buffer. */
typedef INTNETBUF const *PCINTNETBUF;
/** Magic number for INTNETBUF::u32Magic (Sir William Gerald Golding). */
/**
* Asserts the sanity of the specified INTNETBUF structure.
*/
#define INTNETBUF_ASSERT_SANITY(pBuf) \
do \
{ \
{ \
\
\
\
} \
} while (0)
/** Internal networking interface handle. */
typedef uint32_t INTNETIFHANDLE;
/** Pointer to an internal networking interface handle. */
typedef INTNETIFHANDLE *PINTNETIFHANDLE;
/** Or mask to obscure the handle index. */
#define INTNET_HANDLE_MAGIC 0x88880000
/** Mask to extract the handle index. */
#define INTNET_HANDLE_INDEX_MASK 0xffff
/** The maximum number of handles (exclusive) */
#define INTNET_HANDLE_MAX 0xffff
/** Invalid handle. */
#define INTNET_HANDLE_INVALID (0)
/**
* The frame header.
*
* The header is intentionally 8 bytes long. It will always
* start at an 8 byte aligned address. Assuming that the buffer
* size is a multiple of 8 bytes, that means that we can guarantee
* that the entire header is contiguous in both virtual and physical
* memory.
*/
typedef struct INTNETHDR
{
/** Header type. This is currently serving as a magic, it
* can be extended later to encode special command frames and stuff. */
/** The size of the frame. */
/** The offset from the start of this header to where the actual frame starts.
* This is used to keep the frame it self contiguous in virtual memory and
* thereby both simplify access as well as the descriptor. */
} INTNETHDR;
/** Pointer to a frame header.*/
typedef INTNETHDR *PINTNETHDR;
/** Pointer to a const frame header.*/
typedef INTNETHDR const *PCINTNETHDR;
/** The alignment of a frame header. */
#define INTNETHDR_ALIGNMENT sizeof(INTNETHDR)
/** @name Frame types (INTNETHDR::u16Type).
* @{ */
/** Normal frames. */
#define INTNETHDR_TYPE_FRAME 0x2442
/** Padding frames. */
#define INTNETHDR_TYPE_PADDING 0x3553
/** Generic segment offload frames.
* The frame starts with a PDMNETWORKGSO structure which is followed by the
* header template and data. */
#define INTNETHDR_TYPE_GSO 0x4664
/** @} */
/**
* Asserts the sanity of the specified INTNETHDR.
*/
#ifdef VBOX_STRICT
do \
{ \
{ \
\
\
/* could do more thorough work here... later, perhaps. */ \
} \
} while (0)
#else
#endif
/**
* Scatter / Gather segment (internal networking).
*/
typedef struct INTNETSEG
{
/** The physical address. NIL_RTHCPHYS is not set. */
/** Pointer to the segment data. */
void *pv;
/** The segment size. */
} INTNETSEG;
/** Pointer to a internal networking frame segment. */
typedef INTNETSEG *PINTNETSEG;
/** Pointer to a internal networking frame segment. */
typedef INTNETSEG const *PCINTNETSEG;
/**
* Scatter / Gather list (internal networking).
*
* This is used when communicating with the trunk port.
*/
typedef struct INTNETSG
{
/** Owner data, don't touch! */
void *pvOwnerData;
/** User data. */
void *pvUserData;
/** User data 2 in case anyone needs it. */
void *pvUserData2;
/** GSO context information, set the type to invalid if not relevant. */
/** The total length of the scatter gather list. */
/** The number of users (references).
* This is used by the SGRelease code to decide when it can be freed. */
/** Flags, see INTNETSG_FLAGS_* */
#if ARCH_BITS == 64
/** Alignment padding. */
#endif
/** The number of segments allocated. */
/** The number of segments actually used. */
/** Variable sized list of segments. */
} INTNETSG;
/** Pointer to a scatter / gather list. */
/** Pointer to a const scatter / gather list. */
typedef INTNETSG const *PCINTNETSG;
/** @name INTNETSG::fFlags definitions.
* @{ */
/** Set if the SG is free. */
/** Set if the SG is a temporary one that will become invalid upon return.
* Try to finish using it before returning, and if that's not possible copy
* to other buffers.
* When not set, the callee should always free the SG.
* Attempts to free it made by the callee will be quietly ignored. */
/** ARP packet, IPv4 + MAC.
* @internal */
/** Copied to the temporary buffer.
* @internal */
/** @} */
/** @name Direction (frame source or destination)
* @{ */
#define INTNETTRUNKDIR_WIRE RT_BIT_32(0)
/** Mask of valid bits. */
/** @} */
/**
* Switch decisions returned by INTNETTRUNKSWPORT::pfnPreRecv.
*/
typedef enum INTNETSWDECISION
{
/** The usual invalid zero value. */
/** Everywhere. */
/** Only to the internal network. */
/** Used internally to indicate that the packet cannot be handled in the
* current context. */
/** Used internally to indicate that the packet should be dropped. */
/** The usual 32-bit type expansion. */
INTNETSWDECISION_32BIT_HACK = 0x7fffffff
/** Pointer to the switch side of a trunk port. */
typedef struct INTNETTRUNKSWPORT *PINTNETTRUNKSWPORT;
/**
* This is the port on the internal network 'switch', i.e.
* what the driver is connected to.
*
* This is only used for the in-kernel trunk connections.
*/
typedef struct INTNETTRUNKSWPORT
{
/** Structure version number. (INTNETTRUNKSWPORT_VERSION) */
/**
* Examine the packet and figure out where it is going.
*
* This method is for making packet switching decisions in contexts where
* pfnRecv cannot be called or is no longer applicable. This method can be
* called from any context.
*
* @returns INTNETSWDECISION_BROADCAST, INTNETSWDECISION_INTNET or
* INTNETSWDECISION_TRUNK. The source is excluded from broadcast &
* trunk, of course.
*
* @param pSwitchPort Pointer to this structure.
* @param pvHdrs Pointer to the packet headers.
* @param cbHdrs Size of the packet headers. This must be at least 6
* bytes (the destination MAC address), but should if
* possible also include any VLAN tag and network
* layer header (wireless mac address sharing).
* @param fSrc Where this frame comes from. Only one bit should be
* set!
*
* @remarks Will only grab the switch table spinlock (interrupt safe). May
* signal an event semaphore iff we're racing network cleanup. The
* caller must be busy when calling.
*/
/**
* Incoming frame.
*
* The frame may be modified when the trunk port on the switch is set to share
* the mac address of the host when hitting the wire. Currently frames
* containing ARP packets are subject to this, later other protocols like
*
* @returns true if we've handled it and it should be dropped.
*
* @param pSwitchPort Pointer to this structure.
* @param pvIf Pointer to the interface which received this frame
* if available. Can be NULL.
* @param pSG The (scatter /) gather structure for the frame. This
* will only be use during the call, so a temporary one can
* be used. The Phys member will not be used.
* @param fSrc Where this frame comes from. Exactly one bit shall be
* set!
*
* @remarks Will only grab the switch table spinlock (interrupt safe). Will
* signal event semaphores. The caller must be busy when calling.
*
* @remarks NAT and TAP will use this interface.
*
* @todo Do any of the host require notification before frame modifications?
* If so, we'll add a callback to INTNETTRUNKIFPORT for this
* (pfnSGModifying) and a SG flag.
*/
DECLR0CALLBACKMEMBER(bool, pfnRecv,(PINTNETTRUNKSWPORT pSwitchPort, void *pvIf, PINTNETSG pSG, uint32_t fSrc));
/**
* Retain a SG.
*
* @param pSwitchPort Pointer to this structure.
* @param pSG Pointer to the (scatter /) gather structure.
*
* @remarks Will not grab any locks. The caller must be busy when calling.
*/
/**
* Release a SG.
*
* This is called by the pfnXmit code when done with a SG. This may safe
* be done in an asynchronous manner.
*
* @param pSwitchPort Pointer to this structure.
* @param pSG Pointer to the (scatter /) gather structure.
*
* @remarks May signal an event semaphore later on, currently code won't though.
* The caller is busy when making this call.
*/
/**
* Selects whether outgoing SGs should have their physical address set.
*
* By enabling physical addresses in the scatter / gather segments it should
* be possible to save some unnecessary address translation and memory locking
* in the network stack. (Internal networking knows the physical address for
* all the INTNETBUF data and that it's locked memory.) There is a negative
* side effects though, frames that crosses page boundaries will require
* multiple scather / gather segments.
*
* @returns The old setting.
*
* @param pSwitchPort Pointer to this structure.
* @param fEnable Whether to enable or disable it.
*
* @remarks Will not grab any locks. The caller must be busy when calling.
*/
/**
* Reports the MAC address of the trunk.
*
* This is supposed to be called when creating, connection or reconnecting the
* trunk and when the MAC address is changed by the system admin.
*
* @param pSwitchPort Pointer to this structure.
* @param pMacAddr The MAC address.
*
* @remarks May take a spinlock or two. The caller must be busy when calling.
*/
/**
* Reports the promicuousness of the interface.
*
* This is supposed to be called when creating, connection or reconnecting the
* trunk and when the mode is changed by the system admin.
*
* @param pSwitchPort Pointer to this structure.
* @param fPromiscuous True if the host operates the interface in
* promiscuous mode, false if not.
*
* @remarks May take a spinlock or two. The caller must be busy when calling.
*/
DECLR0CALLBACKMEMBER(void, pfnReportPromiscuousMode,(PINTNETTRUNKSWPORT pSwitchPort, bool fPromiscuous));
/**
* Reports the GSO capabilities of the host, wire or both.
*
* This is supposed to be used only when creating, connecting or reconnecting
* the trunk. It is assumed that the GSO capabilities are kind of static the
* rest of the time.
*
* @param pSwitchPort Pointer to this structure.
* @param fGsoCapabilities The GSO capability bit mask. The bits
* corresponds to the GSO type with the same value.
* @param fDst The destination mask (INTNETTRUNKDIR_XXX).
*
* @remarks Does not take any locks. The caller must be busy when calling.
*/
DECLR0CALLBACKMEMBER(void, pfnReportGsoCapabilities,(PINTNETTRUNKSWPORT pSwitchPort, uint32_t fGsoCapabilities, uint32_t fDst));
/**
* Reports the no-preemption-xmit capabilities of the host and wire.
*
* This is supposed to be used only when creating, connecting or reconnecting
* the trunk. It is assumed that the GSO capabilities are kind of static the
* rest of the time.
*
* @param pSwitchPort Pointer to this structure.
* @param fNoPreemptDsts The destinations (INTNETTRUNKDIR_XXX) which it
* is safe to transmit to with preemption disabled.
* @param fDst The destination mask (INTNETTRUNKDIR_XXX).
*
* @remarks Does not take any locks. The caller must be busy when calling.
*/
DECLR0CALLBACKMEMBER(void, pfnReportNoPreemptDsts,(PINTNETTRUNKSWPORT pSwitchPort, uint32_t fNoPreemptDsts));
/** Structure version number. (INTNETTRUNKSWPORT_VERSION) */
/** Version number for the INTNETTRUNKIFPORT::u32Version and INTNETTRUNKIFPORT::u32VersionEnd fields. */
/**
* The trunk interface state used set by INTNETTRUNKIFPORT::pfnSetState.
*/
typedef enum INTNETTRUNKIFSTATE
{
/** The invalid zero entry. */
/** The trunk is inactive. No calls to INTNETTRUNKSWPORT::pfnRecv or
* INTNETTRUNKSWPORT::pfnPreRecv. Calling other methods is OK. */
/** The trunk is active, no restrictions on methods or anything. */
/** The trunk is about to be disconnected from the internal network. No
* calls to any INTNETRUNKSWPORT methods. */
/** The end of the valid states. */
/** The usual 32-bit type blow up hack. */
INTNETTRUNKIFSTATE_32BIT_HACK = 0x7fffffff
/** Pointer to the interface side of a trunk port. */
typedef struct INTNETTRUNKIFPORT *PINTNETTRUNKIFPORT;
/**
* This is the port on the trunk interface, i.e. the driver side which the
* internal network is connected to.
*
* This is only used for the in-kernel trunk connections.
*/
typedef struct INTNETTRUNKIFPORT
{
/** Structure version number. (INTNETTRUNKIFPORT_VERSION) */
/**
* Retain the object.
*
* It will normally be called while owning the internal network semaphore.
*
* @param pIfPort Pointer to this structure.
*
* @remarks May own the big mutex, no spinlocks.
*/
/**
* Releases the object.
*
* This must be called for every pfnRetain call.
*
*
* @param pIfPort Pointer to this structure.
*
* @remarks May own the big mutex, no spinlocks.
*/
/**
* Disconnect from the switch and release the object.
*
* The is the counter action of the
* INTNETTRUNKNETFLTFACTORY::pfnCreateAndConnect method.
*
* @param pIfPort Pointer to this structure.
*
* @remarks Owns the big mutex.
*/
/**
* Changes the state of the trunk interface.
*
* The interface is created in the inactive state (INTNETTRUNKIFSTATE_INACTIVE).
* When the first connect VM or service is activated, the internal network
* activates the trunk (INTNETTRUNKIFSTATE_ACTIVE). The state may then be set
* back and forth between INACTIVE and ACTIVE as VMs are paused, added and
* removed.
*
* Eventually though, the network is destroyed as a result of there being no
* more VMs left in it and the state is changed to disconnecting
* (INTNETTRUNKIFSTATE_DISCONNECTING) and pfnWaitForIdle is called to make sure
* there are no active calls in either direction when pfnDisconnectAndRelease is
* called.
*
*
* @returns The previous state.
*
* @param pIfPort Pointer to this structure.
* @param enmState The new state.
*
* @remarks Owns the big mutex. No racing pfnSetState, pfnWaitForIdle,
* pfnDisconnectAndRelease or INTNETTRUNKFACTORY::pfnCreateAndConnect
* calls.
*/
DECLR0CALLBACKMEMBER(INTNETTRUNKIFSTATE, pfnSetState,(PINTNETTRUNKIFPORT pIfPort, INTNETTRUNKIFSTATE enmState));
/**
* Notifies when the MAC address of an interface is set or changes.
*
* @param pIfPort Pointer to this structure.
* @param pvIfData Pointer to the trunk's interface data (see
* pfnConnectInterface).
* @param pMac Pointer to the MAC address of the connecting VM NIC.
*
* @remarks Only busy references to the trunk and the interface.
*/
DECLR0CALLBACKMEMBER(void, pfnNotifyMacAddress,(PINTNETTRUNKIFPORT pIfPort, void *pvIfData, PCRTMAC pMac));
/**
* Called when an interface is connected to the network.
*
* @returns IPRT status code.
* @param pIfPort Pointer to this structure.
* @param pvIf Opaque pointer to the interface being connected.
* For use INTNETTRUNKSWPORT::pfnRecv.
* @param ppvIfData Pointer to a pointer variable that the trunk
* implementation can use to associate data with the
* interface. This pointer will be passed to the
* pfnXmit, pfnNotifyMacAddress and
* pfnDisconnectInterface methods.
*
* @remarks Owns the big mutex. No racing pfnDisconnectAndRelease.
*/
DECLR0CALLBACKMEMBER(int, pfnConnectInterface,(PINTNETTRUNKIFPORT pIfPort, void *pvIf, void **ppvIfData));
/**
* Called when an interface is disconnected from the network.
*
* @param pIfPort Pointer to this structure.
* @param pvIfData Pointer to the trunk's interface data (see
* pfnConnectInterface).
*
* @remarks Owns the big mutex. No racing pfnDisconnectAndRelease.
*/
/**
* Waits for the interface to become idle.
*
* This method must be called before disconnecting and releasing the object in
*
* @returns IPRT status code (see RTSemEventWait).
* @param pIfPort Pointer to this structure.
* @param cMillies The number of milliseconds to wait. 0 means
* no waiting at all. Use RT_INDEFINITE_WAIT for
* an indefinite wait.
*
* @remarks Owns the big mutex. No racing pfnDisconnectAndRelease.
*/
/**
* Transmit a frame.
*
* @return VBox status code. Error generally means we'll drop the frame.
* @param pIfPort Pointer to this structure.
* @param pvIfData Pointer to the trunk's interface data (see
* pfnConnectInterface).
* @param pSG Pointer to the (scatter /) gather structure for the frame.
* This may or may not be a temporary buffer. If it's temporary
* the transmit operation(s) then it's required to make a copy
* of the frame unless it can be transmitted synchronously.
* @param fDst The destination mask. At least one bit will be set.
*
* @remarks No locks. May be called concurrently on several threads.
*/
DECLR0CALLBACKMEMBER(int, pfnXmit,(PINTNETTRUNKIFPORT pIfPort, void *pvIfData, PINTNETSG pSG, uint32_t fDst));
/** Structure version number. (INTNETTRUNKIFPORT_VERSION) */
/** Version number for the INTNETTRUNKIFPORT::u32Version and INTNETTRUNKIFPORT::u32VersionEnd fields. */
/**
* The component factory interface for create a network
* interface filter (like VBoxNetFlt).
*/
typedef struct INTNETTRUNKFACTORY
{
/**
* Release this factory.
*
* SUPR0ComponentQueryFactory (SUPDRVFACTORY::pfnQueryFactoryInterface to be precise)
* will retain a reference to the factory and the caller has to call this method to
* release it once the pfnCreateAndConnect call(s) has been done.
*
* @param pIfFactory Pointer to this structure.
*/
/**
* Create an instance for the specfied host interface and connects it
* to the internal network trunk port.
*
* The initial interface active state is false (suspended).
*
*
* @returns VBox status code.
* @retval VINF_SUCCESS and *ppIfPort set on success.
* @retval VERR_INTNET_FLT_IF_NOT_FOUND if the interface was not found.
* @retval VERR_INTNET_FLT_IF_BUSY if the interface is already connected.
* @retval VERR_INTNET_FLT_IF_FAILED if it failed for some other reason.
*
* @param pIfFactory Pointer to this structure.
* @param pszName The interface name (OS specific).
* @param pSwitchPort Pointer to the port interface on the switch that
* this interface is being connected to.
* @param fFlags Creation flags, see below.
* @param ppIfPort Where to store the pointer to the interface port
* on success.
*
* @remarks Called while owning the network and the out-bound trunk semaphores.
*/
DECLR0CALLBACKMEMBER(int, pfnCreateAndConnect,(struct INTNETTRUNKFACTORY *pIfFactory, const char *pszName,
/** Pointer to the trunk factory. */
typedef INTNETTRUNKFACTORY *PINTNETTRUNKFACTORY;
/** The UUID for the (current) trunk factory. (case sensitive) */
#define INTNETTRUNKFACTORY_UUID_STR "de504d93-1d1e-4781-8b73-6ea39a0e36a2"
/** @name INTNETTRUNKFACTORY::pfnCreateAndConnect flags.
* @{ */
/** Don't put the filtered interface in promiscuous mode.
* This is used for wireless interface since these can misbehave if
* we try to put them in promiscuous mode. (Wireless interfaces are
* normally bridged on level 3 instead of level 2.) */
#define INTNETTRUNKFACTORY_FLAG_NO_PROMISC RT_BIT_32(0)
/** @} */
/**
* The trunk connection type.
*
* Used by IntNetR0Open and associated interfaces.
*/
typedef enum INTNETTRUNKTYPE
{
/** Invalid trunk type. */
/** No trunk connection. */
/** We don't care which kind of trunk connection if the network exists,
* if it doesn't exist create it without a connection. */
/** VirtualBox host network interface filter driver.
* The trunk name is the name of the host network interface. */
/** VirtualBox adapter host driver. */
/** Nat service (ring-0). */
/** The end of valid types. */
/** The usual 32-bit hack. */
kIntNetTrunkType_32bitHack = 0x7fffffff
/** @name IntNetR0Open flags.
*
* The desired policy options must be specified explicitly, if omitted it is
* understood that whatever is current or default is fine with the caller.
*
* @todo Move the policies out of the flags, use three new parameters.
*
* @{ */
/** Share the MAC address with the host when sending something to the wire via the trunk.
* This is typically used when the trunk is a NetFlt for a wireless interface. */
#define INTNET_OPEN_FLAGS_SHARED_MAC_ON_WIRE RT_BIT_32(0)
/** Require that the current security and promiscuous policies of the network
* is exactly as the ones specified in this open network request.
*
* Use this with INTNET_OPEN_FLAGS_REQUIRE_AS_RESTRICTIVE_POLICIES to prevent
* restrictions from being lifted. If no further policy changes are desired,
* apply the relevant _FIXED flags. */
/** Require that the security and promiscuous policies of the network is at
* least as restrictive as specified this request specifies and prevent them
* being lifted later on. */
/** Network access policy: Fixed if set, changable if clear. */
/** Network access policy: Public network. */
/** Network access policy: Restricted network. */
/** Promiscuous mode policy: Is it fixed or changable by new participants? */
/** Promiscuous mode policy: Allow the clients to request it. */
/** Promiscuous mode policy: Deny the clients from requesting it. */
/** Promiscuous mode policy: Allow the trunk-host to request it. */
/** Promiscuous mode policy: Deny the trunk-host from requesting it. */
/** Promiscuous mode policy: Allow the trunk-wire to request it. */
/** Promiscuous mode policy: Deny the trunk-wire from requesting it. */
/** Interface policies: Is it fixed or changable (by admin).
* @note Per interface, not network wide. */
/** Interface promiscuous mode policy: Allow the interface to request it. */
/** Interface promiscuous mode policy: Deny the interface from requesting it. */
/** Interface promiscuous mode policy: See unrelated trunk traffic. */
/** Interface promiscuous mode policy: No unrelated trunk traffic visible. */
/** Trunk policy: Fixed if set, changable if clear.
* @remarks The DISABLED options are considered more restrictive by
* INTNET_OPEN_FLAGS_REQUIRE_AS_RESTRICTIVE_POLICIES. */
/** Trunk policy: The host end should be enabled. */
/** Trunk policy: The host end should be disabled. */
/** Trunk policy: The host should only see packets destined for it. */
/** Trunk policy: The host should see all packets. */
/** Trunk policy: The wire end should be enabled. */
/** Trunk policy: The wire end should be disabled. */
/** Trunk policy: The wire should only see packets destined for it. */
/** Trunk policy: The wire should see all packets. */
/** Used to enable host specific workarounds.
*
* On darwin this will clear ip_tos in DHCP packets when
* INTNET_OPEN_FLAGS_SHARED_MAC_ON_WIRE is also set. */
/** The mask of valid flags. */
/** The mask of all flags use to fix (lock) settings. */
#define INTNET_OPEN_FLAGS_FIXED_MASK \
/** The mask of all policy pairs. */
#define INTNET_OPEN_FLAGS_PAIR_MASK \
)
/** The mask of all relaxed policy bits. */
#define INTNET_OPEN_FLAGS_RELAXED_MASK \
)
/** The mask of all strict policy bits. */
#define INTNET_OPEN_FLAGS_STRICT_MASK \
)
/** @} */
/** The maximum length of a network name. */
#define INTNET_MAX_NETWORK_NAME 128
/** The maximum length of a trunk name. */
#define INTNET_MAX_TRUNK_NAME 64
/**
* Request buffer for IntNetR0OpenReq / VMMR0_DO_INTNET_OPEN.
* @see IntNetR0Open.
*/
typedef struct INTNETOPENREQ
{
/** The request header. */
/** Alternative to passing the taking the session from the VM handle.
* Either use this member or use the VM handle, don't do both. */
/** The network name. (input) */
char szNetwork[INTNET_MAX_NETWORK_NAME];
/** What to connect to the trunk port. (input)
* This is specific to the trunk type below. */
char szTrunk[INTNET_MAX_TRUNK_NAME];
/** The type of trunk link (NAT, Filter, TAP, etc). (input) */
/** Flags, see INTNET_OPEN_FLAGS_*. (input) */
/** The size of the send buffer. (input) */
/** The size of the receive buffer. (input) */
/** The handle to the network interface. (output) */
/** Pointer to an IntNetR0OpenReq / VMMR0_DO_INTNET_OPEN request buffer. */
typedef INTNETOPENREQ *PINTNETOPENREQ;
/**
* Request buffer for IntNetR0IfCloseReq / VMMR0_DO_INTNET_IF_CLOSE.
* @see IntNetR0IfClose.
*/
typedef struct INTNETIFCLOSEREQ
{
/** The request header. */
/** Alternative to passing the taking the session from the VM handle.
* Either use this member or use the VM handle, don't do both. */
/** The handle to the network interface. */
/** Pointer to an IntNetR0IfCloseReq / VMMR0_DO_INTNET_IF_CLOSE request
* buffer. */
typedef INTNETIFCLOSEREQ *PINTNETIFCLOSEREQ;
/**
* Request buffer for IntNetR0IfGetRing3BufferReq /
* VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS.
* @see IntNetR0IfGetRing3Buffer.
*/
typedef struct INTNETIFGETBUFFERPTRSREQ
{
/** The request header. */
/** Alternative to passing the taking the session from the VM handle.
* Either use this member or use the VM handle, don't do both. */
/** Handle to the interface. */
/** The pointer to the ring-3 buffer. (output) */
/** The pointer to the ring-0 buffer. (output) */
/** Pointer to an IntNetR0IfGetRing3BufferReq /
* VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS request buffer. */
INTNETR0DECL(int) IntNetR0IfGetBufferPtrsReq(PSUPDRVSESSION pSession, PINTNETIFGETBUFFERPTRSREQ pReq);
/**
* Request buffer for IntNetR0IfSetPromiscuousModeReq /
* VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE.
* @see IntNetR0IfSetPromiscuousMode.
*/
typedef struct INTNETIFSETPROMISCUOUSMODEREQ
{
/** The request header. */
/** Alternative to passing the taking the session from the VM handle.
* Either use this member or use the VM handle, don't do both. */
/** Handle to the interface. */
/** The new promiscuous mode. */
bool fPromiscuous;
/** Pointer to an IntNetR0IfSetPromiscuousModeReq /
* VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE request buffer. */
INTNETR0DECL(int) IntNetR0IfSetPromiscuousModeReq(PSUPDRVSESSION pSession, PINTNETIFSETPROMISCUOUSMODEREQ pReq);
/**
* Request buffer for IntNetR0IfSetMacAddressReq /
* VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS.
* @see IntNetR0IfSetMacAddress.
*/
typedef struct INTNETIFSETMACADDRESSREQ
{
/** The request header. */
/** Alternative to passing the taking the session from the VM handle.
* Either use this member or use the VM handle, don't do both. */
/** Handle to the interface. */
/** The new MAC address. */
/** Pointer to an IntNetR0IfSetMacAddressReq /
* VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS request buffer. */
INTNETR0DECL(int) IntNetR0IfSetMacAddressReq(PSUPDRVSESSION pSession, PINTNETIFSETMACADDRESSREQ pReq);
/**
* Request buffer for IntNetR0IfSetActiveReq / VMMR0_DO_INTNET_IF_SET_ACTIVE.
* @see IntNetR0IfSetActive.
*/
typedef struct INTNETIFSETACTIVEREQ
{
/** The request header. */
/** Alternative to passing the taking the session from the VM handle.
* Either use this member or use the VM handle, don't do both. */
/** Handle to the interface. */
/** The new state. */
bool fActive;
/** Pointer to an IntNetR0IfSetActiveReq / VMMR0_DO_INTNET_IF_SET_ACTIVE
* request buffer. */
typedef INTNETIFSETACTIVEREQ *PINTNETIFSETACTIVEREQ;
/**
* Request buffer for IntNetR0IfSendReq / VMMR0_DO_INTNET_IF_SEND.
* @see IntNetR0IfSend.
*/
typedef struct INTNETIFSENDREQ
{
/** The request header. */
/** Alternative to passing the taking the session from the VM handle.
* Either use this member or use the VM handle, don't do both. */
/** Handle to the interface. */
/** Pointer to an IntNetR0IfSend() argument package. */
typedef INTNETIFSENDREQ *PINTNETIFSENDREQ;
/**
* Request buffer for IntNetR0IfWaitReq / VMMR0_DO_INTNET_IF_WAIT.
* @see IntNetR0IfWait.
*/
typedef struct INTNETIFWAITREQ
{
/** The request header. */
/** Alternative to passing the taking the session from the VM handle.
* Either use this member or use the VM handle, don't do both. */
/** Handle to the interface. */
/** The number of milliseconds to wait. */
/** Pointer to an IntNetR0IfWaitReq / VMMR0_DO_INTNET_IF_WAIT request buffer. */
typedef INTNETIFWAITREQ *PINTNETIFWAITREQ;
/**
* Request buffer for IntNetR0IfAbortWaitReq / VMMR0_DO_INTNET_IF_ABORT_WAIT.
* @see IntNetR0IfAbortWait.
*/
typedef struct INTNETIFABORTWAITREQ
{
/** The request header. */
/** Alternative to passing the taking the session from the VM handle.
* Either use this member or use the VM handle, don't do both. */
/** Handle to the interface. */
/** Set this to fend off all future IntNetR0Wait calls. */
bool fNoMoreWaits;
/** Pointer to an IntNetR0IfAbortWaitReq / VMMR0_DO_INTNET_IF_ABORT_WAIT
* request buffer. */
typedef INTNETIFABORTWAITREQ *PINTNETIFABORTWAITREQ;
#if defined(IN_RING0) || defined(IN_INTNET_TESTCASE)
/** @name
* @{
*/
INTNETR0DECL(int) IntNetR0Init(void);
INTNETR0DECL(void) IntNetR0Term(void);
INTNETR0DECL(int) IntNetR0IfSetPromiscuousMode(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession, bool fPromiscuous);
INTNETR0DECL(int) IntNetR0IfSetMacAddress(INTNETIFHANDLE hIf, PSUPDRVSESSION pSession, PCRTMAC pMac);
/** @} */
#endif /* IN_RING0 */
#endif