ParaNdis5-Oid.c File Reference

#include "ParaNdis5.h"
#include "ParaNdis-Oid.h"

Include dependency graph for ParaNdis5-Oid.c:

Go to the source code of this file.

Macros
#define	OIDENTRY(oid, el, xfl, xokl, flags)   { oid, el, xfl, xokl, flags, NULL }
#define	OIDENTRYPROC(oid, el, xfl, xokl, flags, setproc)   { oid, el, xfl, xokl, flags, setproc }

Functions
static NDIS_STATUS	OnOidSetNdis5Offload (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
static NDIS_STATUS	CreateOffloadInfo5ForQuery (PARANDIS_ADAPTER *pContext, tOidDesc *pOid, PVOID *ppInfo, PULONG pulSize)
static NDIS_STATUS	CreateOffloadInfo5Internal (PARANDIS_ADAPTER *pContext, PVOID *ppInfo, PULONG pulSize, PCCHAR reason, NDIS_TASK_OFFLOAD_HEADER *pHeader)
void	ParaNdis_GetSupportedOid (PVOID *pOidsArray, PULONG pLength)
static NDIS_STATUS	ParaNdis_OidQuery (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
NDIS_STATUS NTAPI	ParaNdis5_QueryOID (IN NDIS_HANDLE MiniportAdapterContext, IN NDIS_OID Oid, IN PVOID InformationBuffer, IN ULONG InformationBufferLength, OUT PULONG BytesWritten, OUT PULONG BytesNeeded)
NDIS_STATUS NTAPI	ParaNdis5_SetOID (IN NDIS_HANDLE MiniportAdapterContext, IN NDIS_OID Oid, IN PVOID InformationBuffer, IN ULONG InformationBufferLength, OUT PULONG BytesRead, OUT PULONG BytesNeeded)
static void NTAPI	OnSetPowerWorkItem (NDIS_WORK_ITEM *pWorkItem, PVOID Context)
NDIS_STATUS	ParaNdis_OnSetPower (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
static BOOLEAN	IsValidPcs (PARANDIS_ADAPTER *pContext, NDIS_TASK_TCP_IP_CHECKSUM *pcs)
static BOOLEAN	IsValidPls (PARANDIS_ADAPTER *pContext, NDIS_TASK_TCP_LARGE_SEND *pls)
static NDIS_STATUS	ParseOffloadTask (PARANDIS_ADAPTER *pContext, BOOLEAN bApply, NDIS_TASK_OFFLOAD *pto, ULONG offset, ULONG maxSize)
static FORCEINLINE BOOLEAN	ValidateOffloadHeader (NDIS_TASK_OFFLOAD_HEADER *pth)
static NDIS_STATUS	ParseOffload (PARANDIS_ADAPTER *pContext, NDIS_TASK_OFFLOAD_HEADER *pth, ULONG size, BOOLEAN bApply, PCCHAR reason, BOOLEAN headerOnly)
static BOOLEAN	GetTcpIpCheckSumCapabilities (PARANDIS_ADAPTER *pContext, NDIS_TASK_TCP_IP_CHECKSUM *pcs)
static BOOLEAN	GetLargeSendCapabilities (PARANDIS_ADAPTER *pContext, NDIS_TASK_TCP_LARGE_SEND *pls)

Variables
static NDIS_TASK_OFFLOAD_HEADER	ReservedHeader
static NDIS_OID	SupportedOids []
static const tOidWhatToDo	OidsDB []

Macro Definition Documentation

OIDENTRY

#define OIDENTRY	(		oid,
			el,
			xfl,
			xokl,
			flags
	)		{ oid, el, xfl, xokl, flags, NULL }

Definition at line 37 of file ParaNdis5-Oid.c.

OIDENTRYPROC

#define OIDENTRYPROC	(		oid,
			el,
			xfl,
			xokl,
			flags,
			setproc
	)		{ oid, el, xfl, xokl, flags, setproc }

Definition at line 39 of file ParaNdis5-Oid.c.

Function Documentation

CreateOffloadInfo5ForQuery()

NDIS_STATUS CreateOffloadInfo5ForQuery ( PARANDIS_ADAPTER *  pContext, tOidDesc *  pOid, PVOID *  ppInfo, PULONG  pulSize  )

static

Definition at line 745 of file ParaNdis5-Oid.c.

{
    NDIS_TASK_OFFLOAD_HEADER *pth = (NDIS_TASK_OFFLOAD_HEADER *)pOid->InformationBuffer;
    NDIS_STATUS status;
    *ppInfo  = NULL;
    *pulSize = 0;
    if (pOid->InformationBufferLength < sizeof(*pth)) pth = &ReservedHeader;
    status = ParseOffload(pContext, pth, pOid->InformationBufferLength, FALSE, "query enter", TRUE);
    if (status == NDIS_STATUS_SUCCESS)
    {
        CreateOffloadInfo5Internal(pContext, ppInfo, pulSize, "QUERY", pth);
    }
    return status;
}

Referenced by ParaNdis_OidQuery().

CreateOffloadInfo5Internal()

NDIS_STATUS CreateOffloadInfo5Internal ( PARANDIS_ADAPTER *  pContext, PVOID *  ppInfo, PULONG  pulSize, PCCHAR  reason, NDIS_TASK_OFFLOAD_HEADER *  pHeader  )

static

Definition at line 661 of file ParaNdis5-Oid.c.

{
    NDIS_STATUS status = NDIS_STATUS_RESOURCES;
    ULONG size =
        sizeof(NDIS_TASK_OFFLOAD_HEADER) +
        sizeof(NDIS_TASK_OFFLOAD) + sizeof(NDIS_TASK_TCP_IP_CHECKSUM) +
        sizeof(NDIS_TASK_OFFLOAD) + sizeof(NDIS_TASK_TCP_LARGE_SEND);
    *ppInfo = ParaNdis_AllocateMemory(pContext, size);
    if (*ppInfo)
    {
        ULONG flags = 0;
        NDIS_TASK_TCP_IP_CHECKSUM cs;
        NDIS_TASK_TCP_LARGE_SEND lso;
        flags |= GetTcpIpCheckSumCapabilities(pContext, &cs) ? 2 : 0;
        flags |= GetLargeSendCapabilities(pContext, &lso) ? 1 : 0;
        if (flags)
        {
            NDIS_TASK_OFFLOAD_HEADER *ph;
            NDIS_TASK_OFFLOAD *pto;
            UINT i = 0;
            ULONG *pOffset;
            PVOID base;
            *pulSize = size;
            NdisZeroMemory(*ppInfo, size);
            ph = (NDIS_TASK_OFFLOAD_HEADER *)*ppInfo;
            *ph = *pHeader;
            pto = (NDIS_TASK_OFFLOAD *)(ph + 1);
            base = ph;
            pOffset = &ph->OffsetFirstTask;
            ph->OffsetFirstTask = 0;
            do
            {
                if (flags & (1 << i))
                {
                    flags &= ~(1 << i);
                    pto->Version = NDIS_TASK_OFFLOAD_VERSION;
                    pto->Size = sizeof(*pto);
                    *pOffset = RtlPointerToOffset(base, pto);
                    base = pto;
                    pOffset = &pto->OffsetNextTask;
                    switch(i)
                    {
                        case 1:
                        {
                            NDIS_TASK_TCP_IP_CHECKSUM *pcs = (NDIS_TASK_TCP_IP_CHECKSUM *)pto->TaskBuffer;
                            pto->Task = TcpIpChecksumNdisTask;
                            pto->TaskBufferLength = sizeof(*pcs);
                            NdisMoveMemory(pcs, &cs, sizeof(cs));
                            pto = (NDIS_TASK_OFFLOAD *)(pcs + 1);
                            break;
                        }
                        case 0:
                        {
                            NDIS_TASK_TCP_LARGE_SEND  *pls = (NDIS_TASK_TCP_LARGE_SEND *)pto->TaskBuffer;
                            pto->Task = TcpLargeSendNdisTask;
                            pto->TaskBufferLength = sizeof(*pls);
                            NdisMoveMemory(pls, &lso, sizeof(lso));
                            pto = (NDIS_TASK_OFFLOAD *)(pls + 1);
                            break;
                        }
                        default:
                            break;
                    }
                }
                ++i;
            } while (flags);
            status = ParseOffload(pContext, ph, size, FALSE, reason, FALSE);
        }
        else
        {
            NdisFreeMemory(*ppInfo, 0, 0);
            *ppInfo = NULL;
            status = NDIS_STATUS_NOT_SUPPORTED;
        }
    }
    return status;
}

Referenced by CreateOffloadInfo5ForQuery(), and OnOidSetNdis5Offload().

GetLargeSendCapabilities()

static BOOLEAN GetLargeSendCapabilities ( PARANDIS_ADAPTER *  pContext, NDIS_TASK_TCP_LARGE_SEND *  pls  )

static

Definition at line 641 of file ParaNdis5-Oid.c.

{
    tOffloadSettingsFlags f;
    NdisZeroMemory(pls, sizeof(*pls));
    ParaNdis_ResetOffloadSettings(pContext, &f, NULL);
    pls->Version = NDIS_TASK_TCP_LARGE_SEND_V0;
    pls->IpOptions = !!f.fTxLsoIP;
    pls->TcpOptions = !!f.fTxLsoTCP;
    pls->MinSegmentCount = PARANDIS_MIN_LSO_SEGMENTS;
    pls->MaxOffLoadSize = pContext->Offload.maxPacketSize;
    return f.fTxLso != 0;
}

Referenced by CreateOffloadInfo5Internal().

GetTcpIpCheckSumCapabilities()

static BOOLEAN GetTcpIpCheckSumCapabilities ( PARANDIS_ADAPTER *  pContext, NDIS_TASK_TCP_IP_CHECKSUM *  pcs  )

static

Definition at line 611 of file ParaNdis5-Oid.c.

{
    tOffloadSettingsFlags f;
    NdisZeroMemory(pcs, sizeof(*pcs));
    ParaNdis_ResetOffloadSettings(pContext, &f, NULL);
    pcs->V4Transmit.IpChecksum = !!f.fTxIPChecksum;
    pcs->V4Transmit.TcpChecksum = !!f.fTxTCPChecksum;
    pcs->V4Transmit.UdpChecksum = !!f.fTxUDPChecksum;
    pcs->V4Transmit.IpOptionsSupported = !!f.fTxIPOptions;
    pcs->V4Transmit.TcpOptionsSupported = !!f.fTxTCPOptions;
    pcs->V4Receive.IpChecksum = !!f.fRxIPChecksum;
    pcs->V4Receive.IpOptionsSupported = !!f.fRxIPOptions;
    pcs->V4Receive.TcpChecksum = !!f.fRxTCPChecksum;
    pcs->V4Receive.TcpOptionsSupported = !!f.fRxTCPOptions;
    pcs->V4Receive.UdpChecksum = !!f.fRxUDPChecksum;
 
    return
        pcs->V4Transmit.IpChecksum ||
        pcs->V4Transmit.TcpChecksum ||
        pcs->V4Transmit.UdpChecksum ||
        pcs->V4Receive.IpChecksum ||
        pcs->V4Receive.TcpChecksum ||
        pcs->V4Receive.UdpChecksum;
}

Referenced by CreateOffloadInfo5Internal().

IsValidPcs()

static BOOLEAN IsValidPcs ( PARANDIS_ADAPTER *  pContext, NDIS_TASK_TCP_IP_CHECKSUM *  pcs  )

static

Definition at line 408 of file ParaNdis5-Oid.c.

{
    tOffloadSettingsFlags f;
    BOOLEAN bInvalid = FALSE;
    ParaNdis_ResetOffloadSettings(pContext, &f, NULL);
    bInvalid |= pcs->V4Receive.IpChecksum && !f.fRxIPChecksum;
    bInvalid |= pcs->V4Receive.IpOptionsSupported && !f.fRxIPOptions;
    bInvalid |= pcs->V4Receive.TcpChecksum && !f.fRxTCPChecksum;
    bInvalid |= pcs->V4Receive.TcpOptionsSupported && !f.fRxTCPOptions;
    bInvalid |= pcs->V4Receive.UdpChecksum && !f.fRxUDPChecksum;
 
    bInvalid |= pcs->V4Transmit.IpChecksum && !f.fTxIPChecksum;
    bInvalid |= pcs->V4Transmit.IpOptionsSupported && !f.fTxIPOptions;
    bInvalid |= pcs->V4Transmit.TcpChecksum && !f.fTxTCPChecksum;
    bInvalid |= pcs->V4Transmit.TcpOptionsSupported && !f.fTxTCPOptions;
    bInvalid |= pcs->V4Transmit.UdpChecksum && !f.fTxUDPChecksum;
    return !bInvalid;
}

Referenced by ParseOffloadTask().

IsValidPls()

static BOOLEAN IsValidPls ( PARANDIS_ADAPTER *  pContext, NDIS_TASK_TCP_LARGE_SEND *  pls  )

static

Definition at line 431 of file ParaNdis5-Oid.c.

{
    tOffloadSettingsFlags f;
    BOOLEAN bInvalid = FALSE;
    ParaNdis_ResetOffloadSettings(pContext, &f, NULL);
    bInvalid |= pls->Version != NDIS_TASK_TCP_LARGE_SEND_V0;
    bInvalid |= pls->IpOptions && !f.fTxLsoIP;
    bInvalid |= pls->TcpOptions && !f.fTxLsoTCP;
    bInvalid |= (pls->IpOptions || pls->TcpOptions || pls->MaxOffLoadSize) && !f.fTxLso;
    bInvalid |= pls->MinSegmentCount < PARANDIS_MIN_LSO_SEGMENTS;
    return !bInvalid;
}

Referenced by ParseOffloadTask().

OnOidSetNdis5Offload()

NDIS_STATUS OnOidSetNdis5Offload ( PARANDIS_ADAPTER *  pContext, tOidDesc *  pOid  )

static

Definition at line 764 of file ParaNdis5-Oid.c.

{
    NDIS_STATUS status;
    status = ParseOffload(pContext, (NDIS_TASK_OFFLOAD_HEADER *)pOid->InformationBuffer,
        pOid->InformationBufferLength, TRUE, "SET", FALSE);
    if (status == STATUS_SUCCESS)
    {
#if 0   // only for logging after SET
        PVOID pInfo = NULL;
        ULONG dummy = 0;
        CreateOffloadInfo5Internal(pContext, &pInfo, &dummy, "UPDATED", &ReservedHeader);
        if (pInfo) NdisFreeMemory(pInfo, 0, 0);
#endif
        *pOid->pBytesRead = pOid->InformationBufferLength;
    }
    else
    {
        DPrintf(0, ("[%s], restoring after unsuccessful set", __FUNCTION__));
        pContext->Offload = pContext->Offload;
    }
    return status;
}

OnSetPowerWorkItem()

static void NTAPI OnSetPowerWorkItem ( NDIS_WORK_ITEM *  pWorkItem, PVOID  Context  )

static

Definition at line 357 of file ParaNdis5-Oid.c.

{
    NDIS_STATUS status = NDIS_STATUS_SUCCESS;
    tPowerWorkItem *pwi = (tPowerWorkItem *)pWorkItem;
    PARANDIS_ADAPTER *pContext = pwi->pContext;
    if (pwi->state == (NDIS_DEVICE_POWER_STATE)NetDeviceStateD0)
    {
        status = ParaNdis_PowerOn(pContext);
    }
    else
    {
        ParaNdis_PowerOff(pContext);
    }
    NdisFreeMemory(pwi, 0, 0);
    ParaNdis_DebugHistory(pContext, hopOidRequest, NULL, OID_PNP_SET_POWER, 0, 2);
    NdisMSetInformationComplete(pContext->MiniportHandle, status);
}

Referenced by ParaNdis_OnSetPower().

ParaNdis5_QueryOID()

NDIS_STATUS NTAPI ParaNdis5_QueryOID	(	IN NDIS_HANDLE	MiniportAdapterContext,
		IN NDIS_OID	Oid,
		IN PVOID	InformationBuffer,
		IN ULONG	InformationBufferLength,
		OUT PULONG	BytesWritten,
		OUT PULONG	BytesNeeded
	)

Definition at line 261 of file ParaNdis5-Oid.c.

{
    NDIS_STATUS  status = NDIS_STATUS_NOT_SUPPORTED;
    tOidWhatToDo Rules;
    PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)MiniportAdapterContext;
    tOidDesc _oid;
    ParaNdis_GetOidSupportRules(Oid, &Rules, OidsDB);
    _oid.ulToDoFlags = Rules.Flags;
    *BytesWritten = 0;
    *BytesNeeded  = 0;
    ParaNdis_DebugHistory(pContext, hopOidRequest, NULL, Oid, 0, 1);
    DPrintf(Rules.nEntryLevel, ("[%s], id 0x%X(%s) of %d", __FUNCTION__,
                Oid,
                Rules.name,
                InformationBufferLength));
    _oid.Oid = Oid;
    _oid.InformationBuffer = InformationBuffer;
    _oid.InformationBufferLength = InformationBufferLength;
    _oid.pBytesNeeded = (PUINT)BytesNeeded;
    _oid.pBytesRead   = (PUINT)BytesWritten;
    _oid.pBytesWritten = (PUINT)BytesWritten;
    if (pContext->bSurprizeRemoved) status = NDIS_STATUS_NOT_ACCEPTED;
    else if (Rules.Flags & ohfQuery) status = ParaNdis_OidQuery(pContext, &_oid);
 
 
    ParaNdis_DebugHistory(pContext, hopOidRequest, NULL, Oid, status, 0);
    DPrintf((status != NDIS_STATUS_SUCCESS) ? Rules.nExitFailLevel : Rules.nExitOKLevel,
        ("[%s] , id 0x%X(%s) (%X), written %d, needed %d",
        __FUNCTION__,
        Rules.oid,
        Rules.name,
        status,
        *BytesWritten,
        *BytesNeeded));
    return status;
 
}

Referenced by DriverEntry().

ParaNdis5_SetOID()

NDIS_STATUS NTAPI ParaNdis5_SetOID	(	IN NDIS_HANDLE	MiniportAdapterContext,
		IN NDIS_OID	Oid,
		IN PVOID	InformationBuffer,
		IN ULONG	InformationBufferLength,
		OUT PULONG	BytesRead,
		OUT PULONG	BytesNeeded
	)

Definition at line 311 of file ParaNdis5-Oid.c.

{
    NDIS_STATUS  status = NDIS_STATUS_NOT_SUPPORTED;
    tOidWhatToDo Rules;
    PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)MiniportAdapterContext;
    tOidDesc _oid;
    ParaNdis_GetOidSupportRules(Oid, &Rules, OidsDB);
    _oid.ulToDoFlags = Rules.Flags;
    *BytesRead = 0;
    *BytesNeeded = 0;
    ParaNdis_DebugHistory(pContext, hopOidRequest, NULL, Oid, 1, 1);
    DPrintf(Rules.nEntryLevel, ("[%s], id 0x%X(%s) of %d", __FUNCTION__,
                Oid,
                Rules.name,
                InformationBufferLength));
    _oid.Oid = Oid;
    _oid.InformationBuffer = InformationBuffer;
    _oid.InformationBufferLength = InformationBufferLength;
    _oid.pBytesNeeded = (PUINT)BytesNeeded;
    _oid.pBytesRead   = (PUINT)BytesRead;
    _oid.pBytesWritten = (PUINT)BytesRead;
    if (pContext->bSurprizeRemoved) status = NDIS_STATUS_NOT_ACCEPTED;
    else if (Rules.Flags & ohfSet)
    {
        if (Rules.OidSetProc) status = Rules.OidSetProc(pContext, &_oid);
        else
        {
            DPrintf(0, ("[%s] ERROR in OID redirection table", __FUNCTION__));
            status = NDIS_STATUS_INVALID_OID;
        }
    }
    ParaNdis_DebugHistory(pContext, hopOidRequest, NULL, Oid, status, 0);
    if  (status != NDIS_STATUS_PENDING)
    {
        DPrintf((status != NDIS_STATUS_SUCCESS) ? Rules.nExitFailLevel : Rules.nExitOKLevel,
            ("[%s] , id 0x%X(%s) (%X), read %d, needed %d", __FUNCTION__,
            Rules.oid, Rules.name, status, *BytesRead, *BytesNeeded));
    }
    return status;
}

Referenced by DriverEntry().

ParaNdis_GetSupportedOid()

void ParaNdis_GetSupportedOid	(	PVOID *	pOidsArray,
		PULONG	pLength
	)

Definition at line 207 of file ParaNdis5-Oid.c.

{
    *pOidsArray     = SupportedOids;
    *pLength        = sizeof(SupportedOids);
}

Referenced by ParaNdis_OidQueryCommon().

ParaNdis_OidQuery()

static NDIS_STATUS ParaNdis_OidQuery ( PARANDIS_ADAPTER *  pContext, tOidDesc *  pOid  )

static

Definition at line 217 of file ParaNdis5-Oid.c.

{
    NDIS_STATUS status;
    BOOLEAN bFreeInfo = FALSE;
    PVOID pInfo = NULL;
    ULONG ulSize = 0;
    ULONG ulLinkSpeed = 0;
 
    switch(pOid->Oid)
    {
        case OID_TCP_TASK_OFFLOAD:
            status = CreateOffloadInfo5ForQuery(pContext, pOid, &pInfo, &ulSize);
            bFreeInfo = pInfo != NULL;
            break;
        case OID_GEN_LINK_SPEED:
            {
                /* units are 100 bps */
                ulLinkSpeed = (ULONG)(PARANDIS_FORMAL_LINK_SPEED / 100);
                pInfo = &ulLinkSpeed;
                ulSize = sizeof(ulLinkSpeed);
                status = NDIS_STATUS_SUCCESS;
            }
            break;
        default:
            return ParaNdis_OidQueryCommon(pContext, pOid);
    }
    if (status == NDIS_STATUS_SUCCESS)
    {
        status = ParaNdis_OidQueryCopy(pOid, pInfo, ulSize, bFreeInfo);
    }
    else if (bFreeInfo)
    {
        NdisFreeMemory(pInfo, 0, 0);
    }
    return status;
}

Referenced by ParaNdis5_QueryOID().

ParaNdis_OnSetPower()

NDIS_STATUS ParaNdis_OnSetPower	(	PARANDIS_ADAPTER *	pContext,
		tOidDesc *	pOid
	)

Definition at line 378 of file ParaNdis5-Oid.c.

{
    NDIS_STATUS status;
    NDIS_DEVICE_POWER_STATE newState;
    DEBUG_ENTRY(0);
    status = ParaNdis_OidSetCopy(pOid, &newState, sizeof(newState));
    if (status == NDIS_STATUS_SUCCESS)
    {
        tPowerWorkItem *pwi = ParaNdis_AllocateMemory(pContext, sizeof(tPowerWorkItem));
        status = NDIS_STATUS_FAILURE;
        if (pwi)
        {
            pwi->pContext = pContext;
            pwi->state    = newState;
            NdisInitializeWorkItem(&pwi->wi, OnSetPowerWorkItem, pwi);
            if (NdisScheduleWorkItem(&pwi->wi) == NDIS_STATUS_SUCCESS)
            {
                status = NDIS_STATUS_PENDING;
            }
            else
                NdisFreeMemory(pwi, 0, 0);
        }
    }
    return status;
}

ParseOffload()

static NDIS_STATUS ParseOffload ( PARANDIS_ADAPTER *  pContext, NDIS_TASK_OFFLOAD_HEADER *  pth, ULONG  size, BOOLEAN  bApply, PCCHAR  reason, BOOLEAN  headerOnly  )

static

Definition at line 556 of file ParaNdis5-Oid.c.

{
    NDIS_STATUS status = NDIS_STATUS_NOT_SUPPORTED;
    BOOLEAN bReset = FALSE;
    ULONG ulNoCapabilities = 0;
    DPrintf(0, ("[%s](%s), format %d", __FUNCTION__, reason,
        pth->EncapsulationFormat.Encapsulation));
    if (ValidateOffloadHeader(pth))
    {
        PUCHAR p = (PUCHAR)pth;
        LONG  offset = (LONG)pth->OffsetFirstTask;
        status = NDIS_STATUS_SUCCESS;
        DPrintf(0, ("[%s], header version %d, ip header at %d, fixed %d, first at %d", __FUNCTION__,
            pth->Version,
            pth->EncapsulationFormat.EncapsulationHeaderSize,
            pth->EncapsulationFormat.Flags.FixedHeaderSize,
            offset));
        if (!offset && bApply)
        {
            /* disable all the capabilities */
            // according to DDK, 0 at first task offset means disabling all the capabilities
            DPrintf(0, ("[%s] RESETTING offload capabilities", __FUNCTION__));
            ParaNdis_ResetOffloadSettings(pContext, NULL, &ulNoCapabilities);
            bReset = TRUE;
        }
        while (!headerOnly && offset > 0 && (offset + sizeof(NDIS_TASK_OFFLOAD)) < size)
        {
            NDIS_TASK_OFFLOAD *pto = (NDIS_TASK_OFFLOAD *)(p + offset);
            if (pto->Version != NDIS_TASK_OFFLOAD_VERSION)
            {
                DPrintf(0, ("[%s], unexpected TO version %d at %d",
                    __FUNCTION__, pto->Version, offset));
                status = NDIS_STATUS_INVALID_DATA;
                break;
            }
            status = ParseOffloadTask(pContext, bApply, pto, offset, size);
            if (!pto->OffsetNextTask || status != NDIS_STATUS_SUCCESS)
                break;
            offset += pto->OffsetNextTask;
        }
    }
    if (status == STATUS_SUCCESS && bApply)
        pContext->Offload.ipHeaderOffset = bReset ? 0: pth->EncapsulationFormat.EncapsulationHeaderSize;
    return status;
}

Referenced by CreateOffloadInfo5ForQuery(), CreateOffloadInfo5Internal(), and OnOidSetNdis5Offload().

ParseOffloadTask()

static NDIS_STATUS ParseOffloadTask ( PARANDIS_ADAPTER *  pContext, BOOLEAN  bApply, NDIS_TASK_OFFLOAD *  pto, ULONG  offset, ULONG  maxSize  )

static

Definition at line 444 of file ParaNdis5-Oid.c.

{
    NDIS_STATUS status = NDIS_STATUS_SUCCESS;
    NDIS_TASK_TCP_IP_CHECKSUM *pcs = NULL;
    NDIS_TASK_TCP_LARGE_SEND  *pls = NULL;
    NDIS_TASK_IPSEC *pips = NULL;
    LPCSTR sName = NULL;
    ULONG TaskBufferSize = 0, tailOffset = 0;
    switch(pto->Task)
    {
    case TcpIpChecksumNdisTask:
        pcs = (NDIS_TASK_TCP_IP_CHECKSUM *)pto->TaskBuffer;
        TaskBufferSize = sizeof(*pcs);
        sName = "TcpIpChecksumNdisTask";
        break;
    case TcpLargeSendNdisTask:
        pls = (NDIS_TASK_TCP_LARGE_SEND *)pto->TaskBuffer;
        TaskBufferSize = sizeof(*pls);
        sName = "TcpLargeSendNdisTask";
        break;
    case IpSecNdisTask:
        pips = (NDIS_TASK_IPSEC *)pto->TaskBuffer;
        TaskBufferSize = sizeof(*pips);
        sName = "IpSecNdisTask";
        break;
    default:
        break;
    }
    tailOffset = offset + RtlPointerToOffset(pto, &pto->TaskBuffer) + TaskBufferSize;
    if (!TaskBufferSize)
    {
        DPrintf(0, ("[%s], unknown offload task %d", __FUNCTION__, pto->Task));
    }
    else if (tailOffset > maxSize)
    {
        DPrintf(0, ("[%s], can not parse %s at offset %d, tail at %d", __FUNCTION__, sName, offset, tailOffset));
        status = NDIS_STATUS_BUFFER_TOO_SHORT;
    }
    else if (TaskBufferSize > pto->TaskBufferLength)
    {
        DPrintf(0, ("[%s], invalid size of %s", __FUNCTION__, sName));
        status = NDIS_STATUS_BUFFER_TOO_SHORT;
    }
    else if (pcs)
    {
        DPrintf(0, ("[%s], parsing %s", __FUNCTION__, sName));
        DPrintf(0, ("Rx4: checksum IP(%d),TCP(%d),UDP(%d), options IP(%d),TCP(%d)",
            pcs->V4Receive.IpChecksum, pcs->V4Receive.TcpChecksum, pcs->V4Receive.UdpChecksum,
            pcs->V4Receive.IpOptionsSupported, pcs->V4Receive.TcpOptionsSupported
            ));
        DPrintf(0, ("Tx4: checksum IP(%d),TCP(%d),UDP(%d), options IP(%d),TCP(%d)",
            pcs->V4Transmit.IpChecksum, pcs->V4Transmit.TcpChecksum, pcs->V4Transmit.UdpChecksum,
            pcs->V4Transmit.IpOptionsSupported, pcs->V4Transmit.TcpOptionsSupported
            ));
        if (bApply)
        {
            if (IsValidPcs(pContext, pcs))
            {
                tOffloadSettingsFlags *pf = &pContext->Offload.flags;
                pf->fTxIPChecksum = !!pcs->V4Transmit.IpChecksum;
                pf->fTxTCPChecksum = !!pcs->V4Transmit.TcpChecksum;
                pf->fTxUDPChecksum = !!pcs->V4Transmit.UdpChecksum;
                pf->fTxTCPOptions = !!pcs->V4Transmit.TcpOptionsSupported;
                pf->fTxIPOptions = !!pcs->V4Transmit.IpOptionsSupported;
                pf->fRxIPChecksum = !!pcs->V4Receive.IpChecksum;
                pf->fRxIPOptions = !!pcs->V4Receive.IpOptionsSupported;
                pf->fRxTCPChecksum = !!pcs->V4Receive.TcpChecksum;
                pf->fRxTCPOptions = !!pcs->V4Receive.TcpOptionsSupported;
                pf->fRxUDPChecksum = !!pcs->V4Receive.UdpChecksum;
            }
            else
                status = STATUS_NOT_SUPPORTED;
        }
    }
    else if (pls)
    {
        DPrintf(0, ("[%s], parsing %s version %d", __FUNCTION__, sName, pls->Version));
        DPrintf(0, ("options IP(%d),TCP(%d),MaxOffload %d, MinSegments %d",
            pls->IpOptions, pls->TcpOptions, pls->MaxOffLoadSize, pls->MinSegmentCount));
        if (bApply)
        {
            if (IsValidPls(pContext, pls))
            {
                tOffloadSettingsFlags *pf = &pContext->Offload.flags;
                pf->fTxLsoIP = !!pls->IpOptions;
                pf->fTxLsoTCP = !!pls->TcpOptions;
                pf->fTxLso = 1;
            }
            else
                status = STATUS_NOT_SUPPORTED;
        }
    }
    else if (pips)
    {
        DPrintf(0, ("[%s], parsing %s", __FUNCTION__, sName));
    }
    return status;
}

Referenced by ParseOffload().

ValidateOffloadHeader()

static FORCEINLINE BOOLEAN ValidateOffloadHeader ( NDIS_TASK_OFFLOAD_HEADER *  pth )

static

Definition at line 548 of file ParaNdis5-Oid.c.

{
    return
        pth->EncapsulationFormat.Encapsulation == IEEE_802_3_Encapsulation &&
        pth->Version == NDIS_TASK_OFFLOAD_VERSION &&
        pth->Size == sizeof(*pth);
}

Referenced by ParseOffload().

Variable Documentation

OidsDB

const tOidWhatToDo OidsDB[]

static

Definition at line 115 of file ParaNdis5-Oid.c.

Referenced by ParaNdis5_QueryOID(), and ParaNdis5_SetOID().

ReservedHeader

NDIS_TASK_OFFLOAD_HEADER ReservedHeader

static

Initial value:

=
{
    NDIS_TASK_OFFLOAD_VERSION,
    sizeof(NDIS_TASK_OFFLOAD_HEADER),
    0,
    0,
    { IEEE_802_3_Encapsulation, { 1, 0 }, 0 }
}

Definition at line 42 of file ParaNdis5-Oid.c.

Referenced by CreateOffloadInfo5ForQuery(), and OnOidSetNdis5Offload().

SupportedOids

NDIS_OID SupportedOids[]

static

Definition at line 52 of file ParaNdis5-Oid.c.

Referenced by ParaNdis_GetSupportedOid().