pdmnetinline.h revision f7f5cd7b1e530eb5636da51c974b48ae0c1775b3
/** @file
* PDM - Networking Helpers, Inlined Code. (DEV,++)
*
* This is all inlined because it's too tedious to create 2-3 libraries to
* contain it all (same bad excuse as for intnetinline.h).
*/
/*
* Copyright (C) 2010 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.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
/**
* Checksum type.
*/
typedef enum PDMNETCSUMTYPE
{
/** No checksum. */
PDMNETCSUMTYPE_NONE = 0,
/** Normal TCP checksum. */
/** Checksum on pseudo header (used with GSO). */
/** The usual 32-bit hack. */
PDMNETCSUMTYPE_32_BIT_HACK = 0x7fffffff
/**
* Validates the GSO context.
*
* @returns true if valid, false if not (not asserted or logged).
* @param pGso The GSO context.
* @param cbGsoMax The max size of the GSO context.
* @param cbFrame The max size of the GSO frame (use to validate
* the MSS).
*/
{
return false;
return false;
/* all types requires both headers. */
return false;
return false;
return false;
/* min size of the 1st header(s). */
switch (enmType)
{
return false;
break;
return false;
break;
return false;
break;
case PDMNETWORKGSOTYPE_END:
break;
/* no default case! want gcc warnings. */
}
/* min size of the 2nd header. */
switch (enmType)
{
return false;
break;
return false;
break;
case PDMNETWORKGSOTYPE_END:
break;
/* no default case! want gcc warnings. */
}
/* There must be at more than one segment. */
return false;
return false;
return true;
}
/**
*
* We cannot simply treat UDP header as a part of payload because we do not
* want to modify the payload but still need to modify the checksum field in
* UDP header. So we want to include UDP header when calculating the length
* of headers in the first segment getting it copied to a temporary buffer
* along with other headers.
*
* @returns Length of headers (including UDP header for the first fragment).
* @param pGso The GSO context.
* @param iSeg The segment index.
*/
{
}
/**
*
* The first segment does not contain UDP header. The size of UDP header is
* determined as the difference between the total headers size and the size
* used during segmentation.
*
* @returns Length of payload (including UDP header for the first fragment).
* @param pGso The GSO context.
* @param iSeg The segment that we're carving out (0-based).
* @param cSegs The number of segments in the GSO frame.
* @param cbFrame The size of the GSO frame.
*/
DECLINLINE(uint32_t) pdmNetSegPayloadLen(PCPDMNETWORKGSO pGso, uint32_t iSeg, uint32_t cSegs, uint32_t cbFrame)
{
else
}
/**
* Calculates the number of segments a GSO frame will be segmented into.
*
* @returns Segment count.
* @param pGso The GSO context.
* @param cbFrame The GSO frame size (header proto + payload).
*/
{
}
/**
* Used to find the IPv6 header when handling 4to6 tunneling.
*
* @returns Offset of the IPv6 header.
* @param pbSegHdrs The headers / frame start.
* @param offIpHdr The offset of the IPv4 header.
*/
{
}
/**
* Update an UDP header after carving out a segment
*
* @param u32PseudoSum The pseudo checksum.
* @param pbSegHdrs Pointer to the header bytes / frame start.
* @param offUdpHdr The offset into @a pbSegHdrs of the UDP header.
* @param pbPayload Pointer to the payload bytes.
* @param cbPayload The amount of payload.
* @param cbHdrs The size of all the headers.
* @param enmCsumType Whether to checksum the payload, the pseudo
* header or nothing.
* @internal
*/
DECLINLINE(void) pdmNetGsoUpdateUdpHdr(uint32_t u32PseudoSum, uint8_t *pbSegHdrs, uint8_t offUdpHdr,
{
switch (enmCsumType)
{
case PDMNETCSUMTYPE_NONE:
break;
case PDMNETCSUMTYPE_COMPLETE:
break;
case PDMNETCSUMTYPE_PSEUDO:
break;
default:
AssertFailed();
break;
}
}
/**
* Update an UDP header after carving out an IP fragment
*
* @param u32PseudoSum The pseudo checksum.
* @param pbSegHdrs Pointer to the header bytes copy
* @param pbFrame Pointer to the frame start.
* @param offUdpHdr The offset into @a pbSegHdrs of the UDP header.
*
* @internal
*/
DECLINLINE(void) pdmNetGsoUpdateUdpHdrUfo(uint32_t u32PseudoSum, uint8_t *pbSegHdrs, const uint8_t *pbFrame, uint8_t offUdpHdr)
{
}
/**
* Update a TCP header after carving out a segment.
*
* @param u32PseudoSum The pseudo checksum.
* @param pbSegHdrs Pointer to the header bytes / frame start.
* @param offTcpHdr The offset into @a pbSegHdrs of the TCP header.
* @param pbPayload Pointer to the payload bytes.
* @param cbPayload The amount of payload.
* @param offPayload The offset into the payload that we're splitting
* up. We're ASSUMING that the payload follows
* immediately after the TCP header w/ options.
* @param cbHdrs The size of all the headers.
* @param fLastSeg Set if this is the last segment.
* @param enmCsumType Whether to checksum the payload, the pseudo
* header or nothing.
* @internal
*/
DECLINLINE(void) pdmNetGsoUpdateTcpHdr(uint32_t u32PseudoSum, uint8_t *pbSegHdrs, uint8_t offTcpHdr,
{
if (!fLastSeg)
switch (enmCsumType)
{
case PDMNETCSUMTYPE_NONE:
break;
case PDMNETCSUMTYPE_COMPLETE:
break;
case PDMNETCSUMTYPE_PSEUDO:
break;
default:
AssertFailed();
break;
}
}
/**
* Updates a IPv6 header after carving out a segment.
*
* @returns 32-bit intermediary checksum value for the pseudo header.
* @param pbSegHdrs Pointer to the header bytes.
* @param offIpHdr The offset into @a pbSegHdrs of the IP header.
* @param cbSegPayload The amount of segmented payload. Not to be
* confused with the IP payload.
* @param cbHdrs The size of all the headers.
* @param offPktHdr Offset of the protocol packet header. For the
* pseudo header checksum calulation.
* @param bProtocol The protocol type. For the pseudo header.
* @internal
*/
DECLINLINE(uint32_t) pdmNetGsoUpdateIPv6Hdr(uint8_t *pbSegHdrs, uint8_t offIpHdr, uint32_t cbSegPayload, uint8_t cbHdrs,
{
}
/**
* Updates a IPv4 header after carving out a segment.
*
* @returns 32-bit intermediary checksum value for the pseudo header.
* @param pbSegHdrs Pointer to the header bytes.
* @param offIpHdr The offset into @a pbSegHdrs of the IP header.
* @param cbSegPayload The amount of segmented payload.
* @param iSeg The segment index.
* @param cbHdrs The size of all the headers.
* @internal
*/
DECLINLINE(uint32_t) pdmNetGsoUpdateIPv4Hdr(uint8_t *pbSegHdrs, uint8_t offIpHdr, uint32_t cbSegPayload,
{
return RTNetIPv4PseudoChecksum(pIpHdr);
}
/**
* Updates a IPv4 header after carving out an IP fragment.
*
* @param pbSegHdrs Pointer to the header bytes.
* @param offIpHdr The offset into @a pbSegHdrs of the IP header.
* @param cbSegPayload The amount of segmented payload.
* @param offFragment The offset of this fragment for reassembly.
* @param iSeg The segment index.
* @param cbHdrs The size of all the headers.
* @param fLastFragment True if this is the last fragment of datagram.
* @internal
*/
DECLINLINE(void) pdmNetGsoUpdateIPv4HdrUfo(uint8_t *pbSegHdrs, uint8_t offIpHdr, uint32_t cbSegPayload,
{
}
/**
* Carves out the specified segment in a destructive manner.
*
* This is for sequentially carving out segments and pushing them along for
* processing or sending. To avoid allocating a temporary buffer for
* constructing the segment in, we trash the previous frame by putting the
* header at the end of it.
*
* @returns Pointer to the segment frame that we've carved out.
* @param pGso The GSO context data.
* @param pbFrame Pointer to the GSO frame.
* @param cbFrame The size of the GSO frame.
* @param pbHdrScatch Pointer to a pGso->cbHdrs sized area where we
* can save the original header prototypes on the
* first call (@a iSeg is 0) and retrieve it on
* susequent calls. (Just use a 256 bytes
* buffer to make life easy.)
* @param iSeg The segment that we're carving out (0-based).
* @param cSegs The number of segments in the GSO frame. Use
* PDMNetGsoCalcSegmentCount to find this.
* @param pcbSegFrame Where to return the size of the returned segment
* frame.
*/
DECLINLINE(void *) PDMNetGsoCarveSegmentQD(PCPDMNETWORKGSO pGso, uint8_t *pbFrame, size_t cbFrame, uint8_t *pbHdrScatch,
{
/*
* Figure out where the payload is and where the header starts before we
* do the protocol specific carving.
*/
/*
* Check assumptions (doing it after declaring the variables because of C).
*/
/*
* Copy the header and do the protocol specific massaging of it.
*/
if (iSeg != 0)
else
{
pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, pGso->cbHdrsSeg),
break;
if (iSeg == 0)
break;
pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrsSeg,
break;
pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, pGso->cbHdrsSeg,
break;
pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
break;
pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
break;
case PDMNETWORKGSOTYPE_END:
/* no default! wnat gcc warnings. */
break;
}
return pbSegHdrs;
}
/**
* Carves out the specified segment in a non-destructive manner.
*
* The segment headers and segment payload is kept separate here. The GSO frame
* is still expected to be one linear chunk of data, but we don't modify any of
* it.
*
* @returns The offset into the GSO frame of the payload.
* @param pGso The GSO context data.
* @param pbFrame Pointer to the GSO frame. Used for retrieving
* the header prototype and for checksumming the
* payload. The buffer is not modified.
* @param cbFrame The size of the GSO frame.
* @param iSeg The segment that we're carving out (0-based).
* @param cSegs The number of segments in the GSO frame. Use
* PDMNetGsoCalcSegmentCount to find this.
* @param pbSegHdrs Where to return the headers for the segment
* that's been carved out. The buffer must be at
* least pGso->cbHdrs in size, using a 256 byte
* buffer is a recommended simplification.
* @param pcbSegHdrs Where to return the size of the returned
* segment headers.
* @param pcbSegPayload Where to return the size of the returned
* segment payload.
*/
DECLINLINE(uint32_t) PDMNetGsoCarveSegment(PCPDMNETWORKGSO pGso, const uint8_t *pbFrame, size_t cbFrame,
{
/*
* Figure out where the payload is and where the header starts before we
* do the protocol specific carving.
*/
/*
* Check assumptions (doing it after declaring the variables because of C).
*/
/*
* Copy the header and do the protocol specific massaging of it.
*/
{
pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv4Hdr(pbSegHdrs, pGso->offHdr1, cbSegPayload, iSeg, cbSegHdrs),
break;
if (iSeg == 0)
break;
break;
break;
pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
break;
pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbSegHdrs, pgmNetGsoCalcIpv6Offset(pbSegHdrs, pGso->offHdr1),
break;
case PDMNETWORKGSOTYPE_END:
/* no default! wnat gcc warnings. */
break;
}
*pcbSegHdrs = cbSegHdrs;
}
/**
* Prepares the GSO frame for direct use without any segmenting.
*
* @param pGso The GSO context.
* @param pvFrame The frame to prepare.
* @param cbFrame The frame size.
* @param enmCsumType Whether to checksum the payload, the pseudo
* header or nothing.
*/
DECLINLINE(void) PDMNetGsoPrepForDirectUse(PCPDMNETWORKGSO pGso, void *pvFrame, size_t cbFrame, PDMNETCSUMTYPE enmCsumType)
{
/*
* Figure out where the payload is and where the header starts before we
* do the protocol bits.
*/
/*
* Check assumptions (doing it after declaring the variables because of C).
*/
/*
* Get down to busienss.
*/
{
pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv4Hdr(pbHdrs, pGso->offHdr1, cbFrame32 - pGso->cbHdrsTotal, 0, pGso->cbHdrsTotal),
break;
pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv4Hdr(pbHdrs, pGso->offHdr1, cbFrame32 - pGso->cbHdrsTotal, 0, pGso->cbHdrsTotal),
break;
break;
break;
pdmNetGsoUpdateTcpHdr(pdmNetGsoUpdateIPv6Hdr(pbHdrs, pgmNetGsoCalcIpv6Offset(pbHdrs, pGso->offHdr1),
break;
pdmNetGsoUpdateUdpHdr(pdmNetGsoUpdateIPv6Hdr(pbHdrs, pgmNetGsoCalcIpv6Offset(pbHdrs, pGso->offHdr1),
break;
case PDMNETWORKGSOTYPE_END:
/* no default! wnat gcc warnings. */
break;
}
}
/**
* Gets the GSO type name string.
*
* @returns Pointer to read only name string.
* @param enmType The type.
*/
{
switch (enmType)
{
case PDMNETWORKGSOTYPE_IPV4_TCP: return "TCPv4";
case PDMNETWORKGSOTYPE_IPV6_TCP: return "TCPv6";
case PDMNETWORKGSOTYPE_IPV4_UDP: return "UDPv4";
case PDMNETWORKGSOTYPE_IPV6_UDP: return "UDPv6";
case PDMNETWORKGSOTYPE_IPV4_IPV6_TCP: return "4to6TCP";
case PDMNETWORKGSOTYPE_IPV4_IPV6_UDP: return "4to6UDP";
case PDMNETWORKGSOTYPE_INVALID: return "invalid";
case PDMNETWORKGSOTYPE_END: return "end";
}
return "bad-gso-type";
}