sw-offload.c File Reference

#include "ndis56common.h"
#include <sal.h>

Include dependency graph for sw-offload.c:

Go to the source code of this file.

Classes
struct	_tagIPv6Header
union	IPHeader
struct	_tagIPv6ExtHeader
struct	_tagIPv4PseudoHeader
struct	_tagIPv6PseudoHeader

Macros
#define	MAX_SUPPORTED_IPV6_HEADERS   (256 - 4)
#define	PROTOCOL_TCP   6
#define	PROTOCOL_UDP   17
#define	IP_HEADER_LENGTH(pHeader)   (((pHeader)->ip_verlen & 0x0F) << 2)
#define	TCP_HEADER_LENGTH(pHeader)   ((pHeader->tcp_flags & 0xF0) >> 2)

Typedefs
typedef ULONG	IPV6_ADDRESS[4]
typedef struct _tagIPv6Header	IPv6Header
typedef struct _tagIPv6ExtHeader	IPv6ExtHeader
typedef struct _tagIPv4PseudoHeader	tIPv4PseudoHeader
typedef struct _tagIPv6PseudoHeader	tIPv6PseudoHeader

Functions
static __inline USHORT	CheckSumCalculator (ULONG val, PVOID buffer, ULONG len)
static __inline VOID	CalculateIpChecksum (IPv4Header *pIpHeader)
static __inline tTcpIpPacketParsingResult	ProcessTCPHeader (tTcpIpPacketParsingResult _res, PVOID pIpHeader, ULONG len, USHORT ipHeaderSize)
static __inline tTcpIpPacketParsingResult	ProcessUDPHeader (tTcpIpPacketParsingResult _res, PVOID pIpHeader, ULONG len, USHORT ipHeaderSize)
static __inline tTcpIpPacketParsingResult	QualifyIpPacket (IPHeader *pIpHeader, ULONG len)
static __inline USHORT	GetXxpHeaderAndPayloadLen (IPHeader *pIpHeader, tTcpIpPacketParsingResult res)
static __inline USHORT	CalculateIpv4PseudoHeaderChecksum (IPv4Header *pIpHeader, USHORT headerAndPayloadLen)
static __inline USHORT	CalculateIpv6PseudoHeaderChecksum (IPv6Header *pIpHeader, USHORT headerAndPayloadLen)
static __inline USHORT	CalculateIpPseudoHeaderChecksum (IPHeader *pIpHeader, tTcpIpPacketParsingResult res, USHORT headerAndPayloadLen)
static __inline BOOLEAN	CompareNetCheckSumOnEndSystem (USHORT computedChecksum, USHORT arrivedChecksum)
static __inline tTcpIpPacketParsingResult	VerifyIpChecksum (IPv4Header *pIpHeader, tTcpIpPacketParsingResult known, BOOLEAN bFix)
static VOID	CalculateUdpChecksumGivenPseudoCS (UDPHeader *pUdpHeader, ULONG udpLength)
static __inline VOID	CalculateTcpChecksumGivenPseudoCS (TCPHeader *pTcpHeader, ULONG tcpLength)
static __inline tTcpIpPacketParsingResult	VerifyTcpChecksum (IPHeader *pIpHeader, ULONG len, tTcpIpPacketParsingResult known, ULONG whatToFix)
static __inline tTcpIpPacketParsingResult	VerifyUdpChecksum (IPHeader *pIpHeader, ULONG len, tTcpIpPacketParsingResult known, ULONG whatToFix)
static LPCSTR __inline	GetPacketCase (tTcpIpPacketParsingResult res)
static LPCSTR __inline	GetIPCSCase (tTcpIpPacketParsingResult res)
static LPCSTR __inline	GetXxpCSCase (tTcpIpPacketParsingResult res)
static __inline VOID	PrintOutParsingResult (tTcpIpPacketParsingResult res, int level, LPCSTR procname)
tTcpIpPacketParsingResult	ParaNdis_CheckSumVerify (PVOID buffer, ULONG size, ULONG flags, LPCSTR caller)
tTcpIpPacketParsingResult	ParaNdis_ReviewIPPacket (PVOID buffer, ULONG size, LPCSTR caller)

Macro Definition Documentation

IP_HEADER_LENGTH

#define IP_HEADER_LENGTH

(

pHeader

)

(((pHeader)->ip_verlen & 0x0F) << 2)

Definition at line 91 of file sw-offload.c.

MAX_SUPPORTED_IPV6_HEADERS

#define MAX_SUPPORTED_IPV6_HEADERS   (256 - 4)

Definition at line 37 of file sw-offload.c.

PROTOCOL_TCP

#define PROTOCOL_TCP   6

Definition at line 87 of file sw-offload.c.

PROTOCOL_UDP

#define PROTOCOL_UDP   17

Definition at line 88 of file sw-offload.c.

TCP_HEADER_LENGTH

#define TCP_HEADER_LENGTH

(

pHeader

)

((pHeader->tcp_flags & 0xF0) >> 2)

Definition at line 92 of file sw-offload.c.

Typedef Documentation

IPV6_ADDRESS

typedef ULONG IPV6_ADDRESS[4]

Definition at line 39 of file sw-offload.c.

IPv6ExtHeader

typedef struct _tagIPv6ExtHeader IPv6ExtHeader

IPv6Header

typedef struct _tagIPv6Header IPv6Header

tIPv4PseudoHeader

typedef struct _tagIPv4PseudoHeader tIPv4PseudoHeader

tIPv6PseudoHeader

typedef struct _tagIPv6PseudoHeader tIPv6PseudoHeader

Function Documentation

CalculateIpChecksum()

static __inline VOID CalculateIpChecksum ( IPv4Header *  pIpHeader )

static

Definition at line 110 of file sw-offload.c.

{
    pIpHeader->ip_xsum = 0;
    pIpHeader->ip_xsum = CheckSumCalculator(0, pIpHeader, IP_HEADER_LENGTH(pIpHeader));
}

Referenced by VerifyIpChecksum().

CalculateIpPseudoHeaderChecksum()

static __inline USHORT CalculateIpPseudoHeaderChecksum ( IPHeader *  pIpHeader, tTcpIpPacketParsingResult  res, USHORT  headerAndPayloadLen  )

static

Definition at line 335 of file sw-offload.c.

{
    if (res.ipStatus == ppresIPV4)
        return CalculateIpv4PseudoHeaderChecksum(&pIpHeader->v4, headerAndPayloadLen);
    if (res.ipStatus == ppresIPV6)
        return CalculateIpv6PseudoHeaderChecksum(&pIpHeader->v6, headerAndPayloadLen);
    return 0;
}

Referenced by VerifyTcpChecksum(), and VerifyUdpChecksum().

CalculateIpv4PseudoHeaderChecksum()

static __inline USHORT CalculateIpv4PseudoHeaderChecksum ( IPv4Header *  pIpHeader, USHORT  headerAndPayloadLen  )

static

Definition at line 302 of file sw-offload.c.

{
    tIPv4PseudoHeader ipph;
    USHORT checksum;
    ipph.ipph_src  = pIpHeader->ip_src;
    ipph.ipph_dest = pIpHeader->ip_dest;
    ipph.ipph_zero = 0;
    ipph.ipph_protocol = pIpHeader->ip_protocol;
    ipph.ipph_length = swap_short(headerAndPayloadLen);
    checksum = CheckSumCalculator(0, &ipph, sizeof(ipph));
    return ~checksum;
}

Referenced by CalculateIpPseudoHeaderChecksum().

CalculateIpv6PseudoHeaderChecksum()

static __inline USHORT CalculateIpv6PseudoHeaderChecksum ( IPv6Header *  pIpHeader, USHORT  headerAndPayloadLen  )

static

Definition at line 316 of file sw-offload.c.

{
    tIPv6PseudoHeader ipph;
    USHORT checksum;
    ipph.ipph_src[0]  = pIpHeader->ip6_src_address[0];
    ipph.ipph_src[1]  = pIpHeader->ip6_src_address[1];
    ipph.ipph_src[2]  = pIpHeader->ip6_src_address[2];
    ipph.ipph_src[3]  = pIpHeader->ip6_src_address[3];
    ipph.ipph_dest[0] = pIpHeader->ip6_dst_address[0];
    ipph.ipph_dest[1] = pIpHeader->ip6_dst_address[1];
    ipph.ipph_dest[2] = pIpHeader->ip6_dst_address[2];
    ipph.ipph_dest[3] = pIpHeader->ip6_dst_address[3];
    ipph.z1 = ipph.z2 = ipph.z3 = 0;
    ipph.ipph_protocol = pIpHeader->ip6_next_header;
    ipph.ipph_length = swap_short(headerAndPayloadLen);
    checksum = CheckSumCalculator(0, &ipph, sizeof(ipph));
    return ~checksum;
}

Referenced by CalculateIpPseudoHeaderChecksum().

CalculateTcpChecksumGivenPseudoCS()

static __inline VOID CalculateTcpChecksumGivenPseudoCS ( TCPHeader *  pTcpHeader, ULONG  tcpLength  )

static

Definition at line 396 of file sw-offload.c.

{
    pTcpHeader->tcp_xsum = CheckSumCalculator(0, pTcpHeader, tcpLength);
}

Referenced by VerifyTcpChecksum().

CalculateUdpChecksumGivenPseudoCS()

static VOID CalculateUdpChecksumGivenPseudoCS ( UDPHeader *  pUdpHeader, ULONG  udpLength  )

static

Definition at line 387 of file sw-offload.c.

{
    pUdpHeader->udp_xsum = CheckSumCalculator(0, pUdpHeader, udpLength);
}

Referenced by VerifyUdpChecksum().

CheckSumCalculator()

static __inline USHORT CheckSumCalculator ( ULONG  val, PVOID  buffer, ULONG  len  )

static

Definition at line 96 of file sw-offload.c.

{
    PUSHORT pus = (PUSHORT)buffer;
    ULONG count = len >> 1;
    while (count--) val += *pus++;
    if (len & 1) val += (USHORT)*(PUCHAR)pus;
    val = (((val >> 16) | (val << 16)) + val) >> 16;
    return (USHORT)~val;
}

Referenced by CalculateIpChecksum(), CalculateIpv4PseudoHeaderChecksum(), CalculateIpv6PseudoHeaderChecksum(), CalculateTcpChecksumGivenPseudoCS(), and CalculateUdpChecksumGivenPseudoCS().

CompareNetCheckSumOnEndSystem()

static __inline BOOLEAN CompareNetCheckSumOnEndSystem ( USHORT  computedChecksum, USHORT  arrivedChecksum  )

static

Definition at line 347 of file sw-offload.c.

{
    //According to RFC 1624 sec. 3
    //Checksum verification mechanism should treat 0xFFFF
    //checksum value from received packet as 0x0000
    if(arrivedChecksum == 0xFFFF)
        arrivedChecksum = 0;
 
    return computedChecksum == arrivedChecksum;
}

Referenced by VerifyIpChecksum(), VerifyTcpChecksum(), and VerifyUdpChecksum().

GetIPCSCase()

static LPCSTR __inline GetIPCSCase ( tTcpIpPacketParsingResult  res )

static

Definition at line 540 of file sw-offload.c.

{
    static const char *const CSCaseName[4] = { "not tested", "(too short)", "OK", "Bad" };
    return CSCaseName[res.ipCheckSum];
}

Referenced by PrintOutParsingResult().

GetPacketCase()

static LPCSTR __inline GetPacketCase ( tTcpIpPacketParsingResult  res )

static

Definition at line 529 of file sw-offload.c.

{
    static const char *const IPCaseName[4] = { "not tested", "Non-IP", "IPv4", "IPv6" };
    if (res.xxpStatus == ppresXxpKnown) return res.TcpUdp == ppresIsTCP ?
        (res.ipStatus == ppresIPV4 ? "TCPv4" : "TCPv6") :
        (res.ipStatus == ppresIPV4 ? "UDPv4" : "UDPv6");
    if (res.xxpStatus == ppresXxpIncomplete) return res.TcpUdp == ppresIsTCP ? "Incomplete TCP" : "Incomplete UDP";
    if (res.xxpStatus == ppresXxpOther) return "IP";
    return  IPCaseName[res.ipStatus];
}

Referenced by PrintOutParsingResult().

GetXxpCSCase()

static LPCSTR __inline GetXxpCSCase ( tTcpIpPacketParsingResult  res )

static

Definition at line 546 of file sw-offload.c.

{
    static const char *const CSCaseName[4] = { "-", "PCS", "CS", "Bad" };
    return CSCaseName[res.xxpCheckSum];
}

Referenced by PrintOutParsingResult().

GetXxpHeaderAndPayloadLen()

static __inline USHORT GetXxpHeaderAndPayloadLen ( IPHeader *  pIpHeader, tTcpIpPacketParsingResult  res  )

static

Definition at line 286 of file sw-offload.c.

{
    if (res.ipStatus == ppresIPV4)
    {
        USHORT headerLength = IP_HEADER_LENGTH(&pIpHeader->v4);
        USHORT len = swap_short(pIpHeader->v4.ip_length);
        return len - headerLength;
    }
    if (res.ipStatus == ppresIPV6)
    {
        USHORT fullLength = swap_short(pIpHeader->v6.ip6_payload_len);
        return fullLength + sizeof(pIpHeader->v6) - (USHORT)res.ipHeaderSize;
    }
    return 0;
}

Referenced by VerifyTcpChecksum(), and VerifyUdpChecksum().

ParaNdis_CheckSumVerify()

tTcpIpPacketParsingResult ParaNdis_CheckSumVerify	(	PVOID	buffer,
		ULONG	size,
		ULONG	flags,
		LPCSTR	caller
	)

Definition at line 565 of file sw-offload.c.

{
    tTcpIpPacketParsingResult res = QualifyIpPacket(buffer, size);
    if (res.ipStatus == ppresIPV4)
    {
        if (flags & pcrIpChecksum)
            res = VerifyIpChecksum(buffer, res, (flags & pcrFixIPChecksum) != 0);
        if(res.xxpStatus == ppresXxpKnown)
        {
            if (res.TcpUdp == ppresIsTCP) /* TCP */
            {
                if(flags & pcrTcpV4Checksum)
                {
                    res = VerifyTcpChecksum(buffer, size, res, flags & (pcrFixPHChecksum | pcrFixTcpV4Checksum));
                }
            }
            else /* UDP */
            {
                if (flags & pcrUdpV4Checksum)
                {
                    res = VerifyUdpChecksum(buffer, size, res, flags & (pcrFixPHChecksum | pcrFixUdpV4Checksum));
                }
            }
        }
    }
    else if (res.ipStatus == ppresIPV6)
    {
        if(res.xxpStatus == ppresXxpKnown)
        {
            if (res.TcpUdp == ppresIsTCP) /* TCP */
            {
                if(flags & pcrTcpV6Checksum)
                {
                    res = VerifyTcpChecksum(buffer, size, res, flags & (pcrFixPHChecksum | pcrFixTcpV6Checksum));
                }
            }
            else /* UDP */
            {
                if (flags & pcrUdpV6Checksum)
                {
                    res = VerifyUdpChecksum(buffer, size, res, flags & (pcrFixPHChecksum | pcrFixUdpV6Checksum));
                }
            }
        }
    }
    PrintOutParsingResult(res, 1, caller);
    return res;
}

Referenced by ParaNdis_CheckRxChecksum(), ParaNdis_DoCopyPacketData(), ParaNdis_DoSubmitPacket(), ParaNdis_PacketMapper(), and PrepareSendEntry().

ParaNdis_ReviewIPPacket()

tTcpIpPacketParsingResult ParaNdis_ReviewIPPacket	(	PVOID	buffer,
		ULONG	size,
		LPCSTR	caller
	)

Definition at line 614 of file sw-offload.c.

{
    tTcpIpPacketParsingResult res = QualifyIpPacket(buffer, size);
    PrintOutParsingResult(res, 1, caller);
    return res;
}

Referenced by QueryTcpHeaderOffset().

PrintOutParsingResult()

static __inline VOID PrintOutParsingResult ( tTcpIpPacketParsingResult  res, int  level, LPCSTR  procname  )

static

Definition at line 552 of file sw-offload.c.

{
    DPrintf(level, ("[%s] %s packet IPCS %s%s, checksum %s%s", procname,
        GetPacketCase(res),
        GetIPCSCase(res),
        res.fixedIpCS ? "(fixed)" : "",
        GetXxpCSCase(res),
        res.fixedXxpCS ? "(fixed)" : ""));
}

Referenced by ParaNdis_CheckSumVerify(), and ParaNdis_ReviewIPPacket().

ProcessTCPHeader()

static __inline tTcpIpPacketParsingResult ProcessTCPHeader ( tTcpIpPacketParsingResult  _res, PVOID  pIpHeader, ULONG  len, USHORT  ipHeaderSize  )

static

Definition at line 117 of file sw-offload.c.

{
    ULONG tcpipDataAt;
    tTcpIpPacketParsingResult res = _res;
    tcpipDataAt = ipHeaderSize + sizeof(TCPHeader);
    res.xxpStatus = ppresXxpIncomplete;
    res.TcpUdp = ppresIsTCP;
 
    if (len >= tcpipDataAt)
    {
        TCPHeader *pTcpHeader = (TCPHeader *)RtlOffsetToPointer(pIpHeader, ipHeaderSize);
        res.xxpStatus = ppresXxpKnown;
        tcpipDataAt = ipHeaderSize + TCP_HEADER_LENGTH(pTcpHeader);
        res.XxpIpHeaderSize = tcpipDataAt;
    }
    else
    {
        DPrintf(2, ("tcp: %d < min headers %d", len, tcpipDataAt));
    }
    return res;
}

Referenced by QualifyIpPacket().

ProcessUDPHeader()

static __inline tTcpIpPacketParsingResult ProcessUDPHeader ( tTcpIpPacketParsingResult  _res, PVOID  pIpHeader, ULONG  len, USHORT  ipHeaderSize  )

static

Definition at line 140 of file sw-offload.c.

{
    tTcpIpPacketParsingResult res = _res;
    ULONG udpDataStart = ipHeaderSize + sizeof(UDPHeader);
    res.xxpStatus = ppresXxpIncomplete;
    res.TcpUdp = ppresIsUDP;
    res.XxpIpHeaderSize = udpDataStart;
    if (len >= udpDataStart)
    {
        UDPHeader *pUdpHeader = (UDPHeader *)RtlOffsetToPointer(pIpHeader, ipHeaderSize);
        USHORT datagramLength = swap_short(pUdpHeader->udp_length);
        res.xxpStatus = ppresXxpKnown;
        // may be full or not, but the datagram length is known
        DPrintf(2, ("udp: len %d, datagramLength %d", len, datagramLength));
    }
    return res;
}

Referenced by QualifyIpPacket().

QualifyIpPacket()

static __inline tTcpIpPacketParsingResult QualifyIpPacket ( IPHeader *  pIpHeader, ULONG  len  )

static

Definition at line 159 of file sw-offload.c.

{
    tTcpIpPacketParsingResult res;
    UCHAR  ver_len = pIpHeader->v4.ip_verlen;
    UCHAR  ip_version = (ver_len & 0xF0) >> 4;
    USHORT ipHeaderSize = 0;
    USHORT fullLength = 0;
    res.value = 0;
 
    if (ip_version == 4)
    {
        ipHeaderSize = (ver_len & 0xF) << 2;
        fullLength = swap_short(pIpHeader->v4.ip_length);
        DPrintf(3, ("ip_version %d, ipHeaderSize %d, protocol %d, iplen %d",
            ip_version, ipHeaderSize, pIpHeader->v4.ip_protocol, fullLength));
        res.ipStatus = (ipHeaderSize >= sizeof(IPv4Header)) ? ppresIPV4 : ppresNotIP;
        if (len < ipHeaderSize) res.ipCheckSum = ppresIPTooShort;
        if (fullLength) {}
        else
        {
            DPrintf(2, ("ip v.%d, iplen %d", ip_version, fullLength));
        }
    }
    else if (ip_version == 6)
    {
        UCHAR nextHeader = pIpHeader->v6.ip6_next_header;
        BOOLEAN bParsingDone = FALSE;
        ipHeaderSize = sizeof(pIpHeader->v6);
        res.ipStatus = ppresIPV6;
        res.ipCheckSum = ppresCSOK;
        fullLength = swap_short(pIpHeader->v6.ip6_payload_len);
        fullLength += ipHeaderSize;
        while (nextHeader != 59)
        {
            IPv6ExtHeader *pExt;
            switch (nextHeader)
            {
                case PROTOCOL_TCP:
                    bParsingDone = TRUE;
                    res.xxpStatus = ppresXxpKnown;
                    res.TcpUdp = ppresIsTCP;
                    res.xxpFull = len >= fullLength ? 1 : 0;
                    res = ProcessTCPHeader(res, pIpHeader, len, ipHeaderSize);
                    break;
                case PROTOCOL_UDP:
                    bParsingDone = TRUE;
                    res.xxpStatus = ppresXxpKnown;
                    res.TcpUdp = ppresIsUDP;
                    res.xxpFull = len >= fullLength ? 1 : 0;
                    res = ProcessUDPHeader(res, pIpHeader, len, ipHeaderSize);
                    break;
                    //existing extended headers
                case 0:
                    __fallthrough;
                case 60:
                    __fallthrough;
                case 43:
                    __fallthrough;
                case 44:
                    __fallthrough;
                case 51:
                    __fallthrough;
                case 50:
                    __fallthrough;
                case 135:
                    if (len >= ((ULONG)ipHeaderSize + 8))
                    {
                        pExt = (IPv6ExtHeader *)((PUCHAR)pIpHeader + ipHeaderSize);
                        nextHeader = pExt->ip6ext_next_header;
                        ipHeaderSize += 8;
                        ipHeaderSize += pExt->ip6ext_hdr_len * 8;
                    }
                    else
                    {
                        DPrintf(0, ("[%s] ERROR: Break in the middle of ext. headers(len %d, hdr > %d)", __FUNCTION__, len, ipHeaderSize));
                        res.ipStatus = ppresNotIP;
                        bParsingDone = TRUE;
                    }
                    break;
                    //any other protocol
                default:
                    res.xxpStatus = ppresXxpOther;
                    bParsingDone = TRUE;
                    break;
            }
            if (bParsingDone)
                break;
        }
        if (ipHeaderSize <= MAX_SUPPORTED_IPV6_HEADERS)
        {
            DPrintf(3, ("ip_version %d, ipHeaderSize %d, protocol %d, iplen %d",
                ip_version, ipHeaderSize, nextHeader, fullLength));
            res.ipHeaderSize = ipHeaderSize;
        }
        else
        {
            DPrintf(0, ("[%s] ERROR: IP chain is too large (%d)", __FUNCTION__, ipHeaderSize));
            res.ipStatus = ppresNotIP;
        }
    }
 
    if (res.ipStatus == ppresIPV4)
    {
        res.ipHeaderSize = ipHeaderSize;
        res.xxpFull = len >= fullLength ? 1 : 0;
        // bit "more fragments" or fragment offset mean the packet is fragmented
        res.IsFragment = (pIpHeader->v4.ip_offset & ~0xC0) != 0;
        switch (pIpHeader->v4.ip_protocol)
        {
            case PROTOCOL_TCP:
            {
                res = ProcessTCPHeader(res, pIpHeader, len, ipHeaderSize);
            }
            break;
        case PROTOCOL_UDP:
            {
                res = ProcessUDPHeader(res, pIpHeader, len, ipHeaderSize);
            }
            break;
        default:
            res.xxpStatus = ppresXxpOther;
            break;
        }
    }
    return res;
}

Referenced by ParaNdis_CheckSumVerify(), and ParaNdis_ReviewIPPacket().

VerifyIpChecksum()

static __inline tTcpIpPacketParsingResult VerifyIpChecksum ( IPv4Header *  pIpHeader, tTcpIpPacketParsingResult  known, BOOLEAN  bFix  )

static

Definition at line 364 of file sw-offload.c.

{
    tTcpIpPacketParsingResult res = known;
    if (res.ipCheckSum != ppresIPTooShort)
    {
        USHORT saved = pIpHeader->ip_xsum;
        CalculateIpChecksum(pIpHeader);
        res.ipCheckSum = CompareNetCheckSumOnEndSystem(pIpHeader->ip_xsum, saved) ? ppresCSOK : ppresCSBad;
        if (!bFix)
            pIpHeader->ip_xsum = saved;
        else
            res.fixedIpCS = res.ipCheckSum == ppresCSBad;
    }
    return res;
}

Referenced by ParaNdis_CheckSumVerify().

VerifyTcpChecksum()

static __inline tTcpIpPacketParsingResult VerifyTcpChecksum ( IPHeader *  pIpHeader, ULONG  len, tTcpIpPacketParsingResult  known, ULONG  whatToFix  )

static

Definition at line 408 of file sw-offload.c.

{
    USHORT  phcs;
    tTcpIpPacketParsingResult res = known;
    TCPHeader *pTcpHeader = (TCPHeader *)RtlOffsetToPointer(pIpHeader, res.ipHeaderSize);
    USHORT saved = pTcpHeader->tcp_xsum;
    USHORT xxpHeaderAndPayloadLen = GetXxpHeaderAndPayloadLen(pIpHeader, res);
    if (len >= res.ipHeaderSize)
    {
        phcs = CalculateIpPseudoHeaderChecksum(pIpHeader, res, xxpHeaderAndPayloadLen);
        res.xxpCheckSum = CompareNetCheckSumOnEndSystem(phcs, saved) ?  ppresPCSOK : ppresCSBad;
        if (res.xxpCheckSum != ppresPCSOK || whatToFix)
        {
            if (whatToFix & pcrFixPHChecksum)
            {
                if (len >= (ULONG)(res.ipHeaderSize + sizeof(*pTcpHeader)))
                {
                    pTcpHeader->tcp_xsum = phcs;
                    res.fixedXxpCS = res.xxpCheckSum != ppresPCSOK;
                }
                else
                    res.xxpStatus = ppresXxpIncomplete;
            }
            else if (res.xxpFull)
            {
                //USHORT ipFullLength = swap_short(pIpHeader->v4.ip_length);
                pTcpHeader->tcp_xsum = phcs;
                CalculateTcpChecksumGivenPseudoCS(pTcpHeader, xxpHeaderAndPayloadLen);
                if (CompareNetCheckSumOnEndSystem(pTcpHeader->tcp_xsum, saved))
                    res.xxpCheckSum = ppresCSOK;
 
                if (!(whatToFix & pcrFixXxpChecksum))
                    pTcpHeader->tcp_xsum = saved;
                else
                    res.fixedXxpCS =
                        res.xxpCheckSum == ppresCSBad || res.xxpCheckSum == ppresPCSOK;
            }
            else if (whatToFix)
            {
                res.xxpStatus = ppresXxpIncomplete;
            }
        }
        else if (res.xxpFull)
        {
            // we have correct PHCS and we do not need to fix anything
            // there is a very small chance that it is also good TCP CS
            // in such rare case we give a priority to TCP CS
            CalculateTcpChecksumGivenPseudoCS(pTcpHeader, xxpHeaderAndPayloadLen);
            if (CompareNetCheckSumOnEndSystem(pTcpHeader->tcp_xsum, saved))
                res.xxpCheckSum = ppresCSOK;
            pTcpHeader->tcp_xsum = saved;
        }
    }
    else
        res.ipCheckSum = ppresIPTooShort;
    return res;
}

Referenced by ParaNdis_CheckSumVerify().

VerifyUdpChecksum()

static __inline tTcpIpPacketParsingResult VerifyUdpChecksum ( IPHeader *  pIpHeader, ULONG  len, tTcpIpPacketParsingResult  known, ULONG  whatToFix  )

static

Definition at line 473 of file sw-offload.c.

{
    USHORT  phcs;
    tTcpIpPacketParsingResult res = known;
    UDPHeader *pUdpHeader = (UDPHeader *)RtlOffsetToPointer(pIpHeader, res.ipHeaderSize);
    USHORT saved = pUdpHeader->udp_xsum;
    USHORT xxpHeaderAndPayloadLen = GetXxpHeaderAndPayloadLen(pIpHeader, res);
    if (len >= res.ipHeaderSize)
    {
        phcs = CalculateIpPseudoHeaderChecksum(pIpHeader, res, xxpHeaderAndPayloadLen);
        res.xxpCheckSum = CompareNetCheckSumOnEndSystem(phcs, saved) ?  ppresPCSOK : ppresCSBad;
        if (whatToFix & pcrFixPHChecksum)
        {
            if (len >= (ULONG)(res.ipHeaderSize + sizeof(UDPHeader)))
            {
                pUdpHeader->udp_xsum = phcs;
                res.fixedXxpCS = res.xxpCheckSum != ppresPCSOK;
            }
            else
                res.xxpStatus = ppresXxpIncomplete;
        }
        else if (res.xxpCheckSum != ppresPCSOK || (whatToFix & pcrFixXxpChecksum))
        {
            if (res.xxpFull)
            {
                pUdpHeader->udp_xsum = phcs;
                CalculateUdpChecksumGivenPseudoCS(pUdpHeader, xxpHeaderAndPayloadLen);
                if (CompareNetCheckSumOnEndSystem(pUdpHeader->udp_xsum, saved))
                    res.xxpCheckSum = ppresCSOK;
 
                if (!(whatToFix & pcrFixXxpChecksum))
                    pUdpHeader->udp_xsum = saved;
                else
                    res.fixedXxpCS =
                        res.xxpCheckSum == ppresCSBad || res.xxpCheckSum == ppresPCSOK;
            }
            else
                res.xxpCheckSum = ppresXxpIncomplete;
        }
        else if (res.xxpFull)
        {
            // we have correct PHCS and we do not need to fix anything
            // there is a very small chance that it is also good UDP CS
            // in such rare case we give a priority to UDP CS
            CalculateUdpChecksumGivenPseudoCS(pUdpHeader, xxpHeaderAndPayloadLen);
            if (CompareNetCheckSumOnEndSystem(pUdpHeader->udp_xsum, saved))
                res.xxpCheckSum = ppresCSOK;
            pUdpHeader->udp_xsum = saved;
        }
    }
    else
        res.ipCheckSum = ppresIPTooShort;
 
    return res;
}

Referenced by ParaNdis_CheckSumVerify().