ParaNdis-Oid.h File Reference

#include "ndis56common.h"

Include dependency graph for ParaNdis-Oid.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_tagOidDesc
struct	_tagOidWhatToDo

Typedefs
typedef struct _tagOidDesc	tOidDesc
typedef NDIS_STATUS(*	OIDHANDLERPROC) (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
typedef struct _tagOidWhatToDo	tOidWhatToDo
typedef enum _tageOidHelperFlags	eOidHelperFlags

Enumerations
enum	_tageOidHelperFlags {   ohfQuery = 1 , ohfSet = 2 , ohfQuerySet = ohfQuery | ohfSet , ohfQueryStatOnly = 4 ,   ohfQueryStat = ohfQueryStatOnly | ohfQuery , ohfQuery3264 = 8 | ohfQuery , ohfQueryStat3264 = 8 | ohfQueryStat , ohfSetLessOK = 16 ,   ohfSetMoreOK = 32 }

Functions
NDIS_STATUS	ParaNdis_OidQueryCommon (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
NDIS_STATUS	ParaNdis_OidQueryCopy (tOidDesc *pOid, PVOID pInfo, ULONG ulSize, BOOLEAN bFreeInfo)
static NDIS_STATUS	ParaNdis_OidQuery (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
NDIS_STATUS	ParaNdis_OnOidSetMulticastList (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
NDIS_STATUS	ParaNdis_OnSetPacketFilter (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
NDIS_STATUS	ParaNdis_OnAddWakeupPattern (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
NDIS_STATUS	ParaNdis_OnRemoveWakeupPattern (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
NDIS_STATUS	ParaNdis_OnEnableWakeup (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
NDIS_STATUS	ParaNdis_OnSetLookahead (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
NDIS_STATUS	ParaNdis_OnSetVlanId (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
NDIS_STATUS	ParaNdis_OidSetCopy (tOidDesc *pOid, PVOID pDest, ULONG ulSize)
void	ParaNdis_FillPowerCapabilities (PNDIS_PNP_CAPABILITIES pCaps)
void	ParaNdis_GetOidSupportRules (NDIS_OID oid, tOidWhatToDo *pRule, const tOidWhatToDo *Table)
const char *	ParaNdis_OidName (NDIS_OID oid)
void	ParaNdis_GetSupportedOid (PVOID *pOidsArray, PULONG pLength)
NDIS_STATUS	ParaNdis_OnSetPower (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)

Typedef Documentation

eOidHelperFlags

typedef enum _tageOidHelperFlags eOidHelperFlags

OIDHANDLERPROC

typedef NDIS_STATUS(* OIDHANDLERPROC) (PARANDIS_ADAPTER *pContext, tOidDesc *pOid)

Definition at line 50 of file ParaNdis-Oid.h.

tOidDesc

typedef struct _tagOidDesc tOidDesc

tOidWhatToDo

typedef struct _tagOidWhatToDo tOidWhatToDo

Enumeration Type Documentation

_tageOidHelperFlags

enum _tageOidHelperFlags

Enumerator
ohfQuery
ohfSet
ohfQuerySet
ohfQueryStatOnly
ohfQueryStat
ohfQuery3264
ohfQueryStat3264
ohfSetLessOK
ohfSetMoreOK

Definition at line 64 of file ParaNdis-Oid.h.

                                 {
    ohfQuery            = 1,                        // can be queried
    ohfSet              = 2,                        // can be set
    ohfQuerySet         = ohfQuery | ohfSet,
    ohfQueryStatOnly    = 4,                        // redirect query stat to query
    ohfQueryStat        = ohfQueryStatOnly | ohfQuery,
    ohfQuery3264        = 8 | ohfQuery,             // convert 64 to 32 on query
    ohfQueryStat3264    = 8 | ohfQueryStat,         // convert 64 to 32 on query stat
    ohfSetLessOK        = 16,                       // on set: if buffer is smaller, cleanup and copy
    ohfSetMoreOK        = 32                        // on set: if buffer is larger, copy anyway
} eOidHelperFlags;

Function Documentation

ParaNdis_FillPowerCapabilities()

void ParaNdis_FillPowerCapabilities

(

PNDIS_PNP_CAPABILITIES

pCaps

)

Definition at line 138 of file ParaNdis-Oid.c.

{
    NdisZeroMemory(pCaps, sizeof(*pCaps));
    pCaps->WakeUpCapabilities.MinMagicPacketWakeUp = NdisDeviceStateUnspecified;
    pCaps->WakeUpCapabilities.MinPatternWakeUp = NdisDeviceStateUnspecified;
    pCaps->WakeUpCapabilities.MinLinkChangeWakeUp = NdisDeviceStateUnspecified;
}

Referenced by ParaNdis_OidQueryCommon().

ParaNdis_GetOidSupportRules()

void ParaNdis_GetOidSupportRules	(	NDIS_OID	oid,
		tOidWhatToDo *	pRule,
		const tOidWhatToDo *	Table
	)

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

{
    static const tOidWhatToDo defaultRule = { 0, 0, 0, 0, 0, NULL, "Unknown OID" };
    UINT i;
    *pRule = defaultRule;
    pRule->oid = oid;
 
    for (i = 0; Table[i].oid != 0; ++i)
    {
        if (Table[i].oid == oid)
        {
            *pRule = Table[i];
            break;
        }
    }
    pRule->name = ParaNdis_OidName(oid);
}

Referenced by ParaNdis5_QueryOID(), and ParaNdis5_SetOID().

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_OidName()

const char * ParaNdis_OidName

(

NDIS_OID

oid

)

Definition at line 456 of file ParaNdis-Oid.c.

{
#undef MAKECASE
#define MAKECASE(id) case id: return #id;
    switch (oid)
    {
    MAKECASE(OID_GEN_SUPPORTED_LIST)
    MAKECASE(OID_GEN_HARDWARE_STATUS)
    MAKECASE(OID_GEN_MEDIA_SUPPORTED)
    MAKECASE(OID_GEN_MEDIA_IN_USE)
    MAKECASE(OID_GEN_MAXIMUM_LOOKAHEAD)
    MAKECASE(OID_GEN_MAXIMUM_FRAME_SIZE)
    MAKECASE(OID_GEN_LINK_SPEED)
    MAKECASE(OID_GEN_TRANSMIT_BUFFER_SPACE)
    MAKECASE(OID_GEN_RECEIVE_BUFFER_SPACE)
    MAKECASE(OID_GEN_TRANSMIT_BLOCK_SIZE)
    MAKECASE(OID_GEN_RECEIVE_BLOCK_SIZE)
    MAKECASE(OID_GEN_VENDOR_ID)
    MAKECASE(OID_GEN_VENDOR_DESCRIPTION)
    MAKECASE(OID_GEN_CURRENT_PACKET_FILTER)
    MAKECASE(OID_GEN_CURRENT_LOOKAHEAD)
    MAKECASE(OID_GEN_DRIVER_VERSION)
    MAKECASE(OID_GEN_MAXIMUM_TOTAL_SIZE)
    MAKECASE(OID_GEN_PROTOCOL_OPTIONS)
    MAKECASE(OID_GEN_MAC_OPTIONS)
    MAKECASE(OID_GEN_MEDIA_CONNECT_STATUS)
    MAKECASE(OID_GEN_MAXIMUM_SEND_PACKETS)
    MAKECASE(OID_GEN_VENDOR_DRIVER_VERSION)
    MAKECASE(OID_GEN_SUPPORTED_GUIDS)
    MAKECASE(OID_GEN_TRANSPORT_HEADER_OFFSET)
    MAKECASE(OID_GEN_MEDIA_CAPABILITIES)
    MAKECASE(OID_GEN_PHYSICAL_MEDIUM)
    MAKECASE(OID_GEN_XMIT_OK)
    MAKECASE(OID_GEN_RCV_OK)
    MAKECASE(OID_GEN_XMIT_ERROR)
    MAKECASE(OID_GEN_RCV_ERROR)
    MAKECASE(OID_GEN_RCV_NO_BUFFER)
    MAKECASE(OID_GEN_DIRECTED_BYTES_XMIT)
    MAKECASE(OID_GEN_DIRECTED_FRAMES_XMIT)
    MAKECASE(OID_GEN_MULTICAST_BYTES_XMIT)
    MAKECASE(OID_GEN_MULTICAST_FRAMES_XMIT)
    MAKECASE(OID_GEN_BROADCAST_BYTES_XMIT)
    MAKECASE(OID_GEN_BROADCAST_FRAMES_XMIT)
    MAKECASE(OID_GEN_DIRECTED_BYTES_RCV)
    MAKECASE(OID_GEN_DIRECTED_FRAMES_RCV)
    MAKECASE(OID_GEN_MULTICAST_BYTES_RCV)
    MAKECASE(OID_GEN_MULTICAST_FRAMES_RCV)
    MAKECASE(OID_GEN_BROADCAST_BYTES_RCV)
    MAKECASE(OID_GEN_BROADCAST_FRAMES_RCV)
    MAKECASE(OID_GEN_RCV_CRC_ERROR)
    MAKECASE(OID_GEN_TRANSMIT_QUEUE_LENGTH)
    MAKECASE(OID_GEN_GET_TIME_CAPS)
    MAKECASE(OID_GEN_GET_NETCARD_TIME)
    MAKECASE(OID_GEN_NETCARD_LOAD)
    MAKECASE(OID_GEN_DEVICE_PROFILE)
    MAKECASE(OID_GEN_INIT_TIME_MS)
    MAKECASE(OID_GEN_RESET_COUNTS)
    MAKECASE(OID_GEN_MEDIA_SENSE_COUNTS)
    MAKECASE(OID_GEN_VLAN_ID)
    MAKECASE(OID_PNP_CAPABILITIES)
    MAKECASE(OID_PNP_SET_POWER)
    MAKECASE(OID_PNP_QUERY_POWER)
    MAKECASE(OID_PNP_ADD_WAKE_UP_PATTERN)
    MAKECASE(OID_PNP_REMOVE_WAKE_UP_PATTERN)
    MAKECASE(OID_PNP_ENABLE_WAKE_UP)
    MAKECASE(OID_802_3_PERMANENT_ADDRESS)
    MAKECASE(OID_802_3_CURRENT_ADDRESS)
    MAKECASE(OID_802_3_MULTICAST_LIST)
    MAKECASE(OID_802_3_MAXIMUM_LIST_SIZE)
    MAKECASE(OID_802_3_MAC_OPTIONS)
    MAKECASE(OID_802_3_RCV_ERROR_ALIGNMENT)
    MAKECASE(OID_802_3_XMIT_ONE_COLLISION)
    MAKECASE(OID_802_3_XMIT_MORE_COLLISIONS)
    MAKECASE(OID_802_3_XMIT_DEFERRED)
    MAKECASE(OID_802_3_XMIT_MAX_COLLISIONS)
    MAKECASE(OID_802_3_RCV_OVERRUN)
    MAKECASE(OID_802_3_XMIT_UNDERRUN)
    MAKECASE(OID_802_3_XMIT_HEARTBEAT_FAILURE)
    MAKECASE(OID_802_3_XMIT_TIMES_CRS_LOST)
    MAKECASE(OID_802_3_XMIT_LATE_COLLISIONS)
    MAKECASE(OID_GEN_MACHINE_NAME)
    MAKECASE(OID_TCP_TASK_OFFLOAD)
    MAKECASE(OID_TCP_OFFLOAD_PARAMETERS)
    MAKECASE(OID_OFFLOAD_ENCAPSULATION)
    MAKECASE(OID_IP4_OFFLOAD_STATS)
    MAKECASE(OID_IP6_OFFLOAD_STATS)
    default:
        {
            static UCHAR buffer[9];
            UINT i;
            for (i = 0; i < 8; ++i)
            {
                UCHAR nibble = (UCHAR)((oid >> (28 - i * 4)) & 0xf);
                buffer[i] = hexdigit(nibble);
            }
            return (char *)buffer;
        }
    }
}

Referenced by ParaNdis_GetOidSupportRules().

ParaNdis_OidQuery()

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

static

ParaNdis_OidQueryCommon()

NDIS_STATUS ParaNdis_OidQueryCommon	(	PARANDIS_ADAPTER *	pContext,
		tOidDesc *	pOid
	)

Definition at line 225 of file ParaNdis-Oid.c.

{
    NDIS_STATUS  status = NDIS_STATUS_SUCCESS;
    PVOID pInfo  = NULL;
    ULONG ulSize = 0;
    BOOLEAN bFreeInfo = FALSE;
    union _tagtemp
    {
        NDIS_MEDIUM                             Medium;
        ULONG64                                 ul64;
        ULONG                                   ul;
        USHORT                                  us;
        NDIS_PNP_CAPABILITIES                   PMCaps;
    } u;
#if defined(_MSC_VER) && !defined(__clang__)
    #define CONCATFIELD(object, field) object.##field
#else
    #define CONCATFIELD(object, field) object.field
#endif
#define SETINFO(field, value) pInfo = CONCATFIELD(&u, field); ulSize = sizeof(CONCATFIELD(u, field)); CONCATFIELD(u, field) = (value)
    switch (pOid->Oid)
    {
    case OID_GEN_SUPPORTED_LIST:
        ParaNdis_GetSupportedOid(&pInfo, &ulSize);
        break;
    case OID_GEN_HARDWARE_STATUS:
        SETINFO(ul, NdisHardwareStatusReady);
        break;
    case OID_GEN_MEDIA_SUPPORTED:
        __fallthrough;
    case OID_GEN_MEDIA_IN_USE:
        SETINFO(Medium, NdisMedium802_3);
        break;
    case OID_GEN_MAXIMUM_LOOKAHEAD:
        SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS);
        break;
    case OID_GEN_MAXIMUM_FRAME_SIZE:
        SETINFO(ul, pContext->MaxPacketSize.nMaxDataSize);
        break;
    case OID_GEN_TRANSMIT_BUFFER_SPACE:
        SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS * pContext->nofFreeTxDescriptors);
        break;
    case OID_GEN_RECEIVE_BUFFER_SPACE:
        SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS * pContext->NetMaxReceiveBuffers);
        break;
    case OID_GEN_RECEIVE_BLOCK_SIZE:
        __fallthrough;
    case OID_GEN_TRANSMIT_BLOCK_SIZE:
        __fallthrough;
    case OID_GEN_MAXIMUM_TOTAL_SIZE:
        SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS);
        break;
    case OID_GEN_TRANSMIT_QUEUE_LENGTH:
        // TODO: this is not completely correct, but only if
        // the TX queue is not full
        SETINFO(ul, pContext->maxFreeTxDescriptors - pContext->nofFreeTxDescriptors);
        break;
    case OID_GEN_VENDOR_ID:
        SETINFO(ul, 0x00ffffff);
        break;
    case OID_GEN_VENDOR_DESCRIPTION:
        pInfo = (PVOID)VendorName;
        ulSize = sizeof(VendorName);
        break;
 
    case OID_GEN_VENDOR_DRIVER_VERSION:
        SETINFO(ul, (NDIS_MINIPORT_MAJOR_VERSION << 16) | NDIS_MINIPORT_MINOR_VERSION);
        break;
    case OID_GEN_CURRENT_PACKET_FILTER:
        pInfo = &pContext->PacketFilter;
        ulSize = sizeof(pContext->PacketFilter);
        break;
    case OID_GEN_DRIVER_VERSION:
        SETINFO(us, ((NDIS_MINIPORT_MAJOR_VERSION << 8) | NDIS_MINIPORT_MINOR_VERSION));
        break;
    case OID_GEN_MAC_OPTIONS:
        {
            ULONG options = NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
                NDIS_MAC_OPTION_TRANSFERS_NOT_PEND |
                NDIS_MAC_OPTION_NO_LOOPBACK;
            if (IsPrioritySupported(pContext))
                options |= NDIS_MAC_OPTION_8021P_PRIORITY;
            if (IsVlanSupported(pContext))
                options |= NDIS_MAC_OPTION_8021Q_VLAN;
            SETINFO(ul, options);
        }
        break;
    case OID_GEN_MEDIA_CONNECT_STATUS:
        SETINFO(ul, pContext->bConnected ? NdisMediaStateConnected : NdisMediaStateDisconnected);
        //NdisMediaStateConnected:
        break;
    case OID_GEN_MAXIMUM_SEND_PACKETS:
        // NDIS ignores it for deserialized drivers
        SETINFO(ul,pContext->nofFreeTxDescriptors);
        break;
    case OID_802_3_PERMANENT_ADDRESS:
        pInfo = pContext->PermanentMacAddress;
        ulSize = sizeof(pContext->PermanentMacAddress);
        break;
    case OID_802_3_CURRENT_ADDRESS:
        pInfo = pContext->CurrentMacAddress;
        ulSize = sizeof(pContext->CurrentMacAddress);
        break;
    case OID_PNP_QUERY_POWER:
        // size if 0, just to indicate success
        pInfo = &status;
        break;
    case OID_GEN_DIRECTED_BYTES_XMIT:
        SETINFO(ul64, pContext->Statistics.ifHCOutUcastOctets);
        break;
    case OID_GEN_DIRECTED_FRAMES_XMIT:
        SETINFO(ul64, pContext->Statistics.ifHCOutUcastPkts);
        break;
    case OID_GEN_MULTICAST_BYTES_XMIT:
        SETINFO(ul64, pContext->Statistics.ifHCOutMulticastOctets);
        break;
    case OID_GEN_MULTICAST_FRAMES_XMIT:
        SETINFO(ul64, pContext->Statistics.ifHCOutMulticastPkts);
        break;
    case OID_GEN_BROADCAST_BYTES_XMIT:
        SETINFO(ul64, pContext->Statistics.ifHCOutBroadcastOctets);
        break;
    case OID_GEN_BROADCAST_FRAMES_XMIT:
        SETINFO(ul64, pContext->Statistics.ifHCOutBroadcastPkts);
        break;
    case OID_GEN_DIRECTED_BYTES_RCV:
        SETINFO(ul64, pContext->Statistics.ifHCInUcastOctets);
        break;
    case OID_GEN_DIRECTED_FRAMES_RCV:
        SETINFO(ul64, pContext->Statistics.ifHCInUcastPkts);
        break;
    case OID_GEN_MULTICAST_BYTES_RCV:
        SETINFO(ul64, pContext->Statistics.ifHCInMulticastOctets);
        break;
    case OID_GEN_MULTICAST_FRAMES_RCV:
        SETINFO(ul64, pContext->Statistics.ifHCInMulticastPkts);
        break;
    case OID_GEN_BROADCAST_BYTES_RCV:
        SETINFO(ul64, pContext->Statistics.ifHCInBroadcastOctets);
        break;
    case OID_GEN_BROADCAST_FRAMES_RCV:
        SETINFO(ul64, pContext->Statistics.ifHCInBroadcastPkts);
        break;
    case OID_GEN_XMIT_OK:
        SETINFO(ul64,
            pContext->Statistics.ifHCOutUcastPkts +
            pContext->Statistics.ifHCOutMulticastPkts +
            pContext->Statistics.ifHCOutBroadcastPkts);
        break;
    case OID_GEN_RCV_OK:
        SETINFO(ul64,
            pContext->Statistics.ifHCInUcastPkts +
            pContext->Statistics.ifHCInMulticastPkts +
            pContext->Statistics.ifHCInBroadcastPkts);
        DPrintf(4, ("[%s] Total frames %I64u", __FUNCTION__, u.ul64));
        break;
    case OID_GEN_XMIT_ERROR:
        SETINFO(ul64, pContext->Statistics.ifOutErrors );
        break;
    case OID_GEN_RCV_ERROR:
        __fallthrough;
    case OID_GEN_RCV_NO_BUFFER:
        __fallthrough;
    case OID_802_3_RCV_OVERRUN:
        __fallthrough;
    case OID_GEN_RCV_CRC_ERROR:
        __fallthrough;
    case OID_802_3_RCV_ERROR_ALIGNMENT:
        __fallthrough;
    case OID_802_3_XMIT_UNDERRUN:
        __fallthrough;
    case OID_802_3_XMIT_ONE_COLLISION:
        __fallthrough;
    case OID_802_3_XMIT_DEFERRED:
        __fallthrough;
    case OID_802_3_XMIT_MAX_COLLISIONS:
        __fallthrough;
    case OID_802_3_XMIT_MORE_COLLISIONS:
        __fallthrough;
    case OID_802_3_XMIT_HEARTBEAT_FAILURE:
        __fallthrough;
    case OID_802_3_XMIT_TIMES_CRS_LOST:
        __fallthrough;
    case OID_802_3_XMIT_LATE_COLLISIONS:
        SETINFO(ul64, 0);
        break;
    case OID_802_3_MULTICAST_LIST:
        pInfo = pContext->MulticastData.MulticastList;
        ulSize = pContext->MulticastData.nofMulticastEntries * ETH_LENGTH_OF_ADDRESS;
        break;
    case OID_802_3_MAXIMUM_LIST_SIZE:
        SETINFO(ul, PARANDIS_MULTICAST_LIST_SIZE);
        break;
    case OID_PNP_CAPABILITIES:
        pInfo  = &u.PMCaps;
        ulSize = sizeof(u.PMCaps);
        ParaNdis_FillPowerCapabilities(&u.PMCaps);
        break;
    case OID_802_3_MAC_OPTIONS:
        SETINFO(ul, 0);
        break;
    case OID_GEN_VLAN_ID:
        SETINFO(ul, pContext->VlanId);
        if (!IsVlanSupported(pContext))
            status = NDIS_STATUS_NOT_SUPPORTED;
        break;
    case OID_GEN_CURRENT_LOOKAHEAD:
        if (!pContext->DummyLookAhead) pContext->DummyLookAhead = pContext->MaxPacketSize.nMaxFullSizeOS;
        pInfo  = &pContext->DummyLookAhead;
        ulSize = sizeof(pContext->DummyLookAhead);
        break;
    case OID_PNP_ENABLE_WAKE_UP:
        SETINFO(ul, pContext->ulEnableWakeup);
        break;
    default:
        status = NDIS_STATUS_NOT_SUPPORTED;
        break;
    }
 
    if (status == NDIS_STATUS_SUCCESS)
    {
        status = ParaNdis_OidQueryCopy(pOid, pInfo, ulSize, bFreeInfo);
    }
 
    return status;
}

Referenced by ParaNdis_OidQuery().

ParaNdis_OidQueryCopy()

NDIS_STATUS ParaNdis_OidQueryCopy	(	tOidDesc *	pOid,
		PVOID	pInfo,
		ULONG	ulSize,
		BOOLEAN	bFreeInfo
	)

Definition at line 178 of file ParaNdis-Oid.c.

{
    NDIS_STATUS status = NDIS_STATUS_SUCCESS;
    *(pOid->pBytesNeeded)  = ulSize;
    if (!pInfo)
    {
        status = NDIS_STATUS_INVALID_OID;
        *(pOid->pBytesWritten) = 0;
        *(pOid->pBytesNeeded)  = 0;
    }
    else if (pOid->InformationBufferLength >= ulSize)
    {
        if (ulSize) NdisMoveMemory(pOid->InformationBuffer, pInfo, ulSize);
        *(pOid->pBytesWritten) = ulSize;
        *(pOid->pBytesNeeded) = 0;
    }
    else if ((pOid->ulToDoFlags & ohfQuery3264) && pOid->InformationBufferLength == sizeof(ULONG) && ulSize == sizeof(ULONG64))
    {
        ULONG64 u64 = *(ULONG64 *)pInfo;
        ULONG   ul  = (ULONG)u64;
        NdisMoveMemory(pOid->InformationBuffer, &ul, sizeof(ul));
        *(pOid->pBytesWritten) = sizeof(ul);
    }
    else
    {
        status = NDIS_STATUS_BUFFER_TOO_SHORT;
        *(pOid->pBytesWritten) = 0;
    }
    if (bFreeInfo && pInfo)
    {
        NdisFreeMemory(pInfo, 0, 0);
    }
    return status;
}

Referenced by ParaNdis_OidQuery(), and ParaNdis_OidQueryCommon().

ParaNdis_OidSetCopy()

NDIS_STATUS ParaNdis_OidSetCopy	(	tOidDesc *	pOid,
		PVOID	pDest,
		ULONG	ulSize
	)

Definition at line 66 of file ParaNdis-Oid.c.

{
    NDIS_STATUS status = NDIS_STATUS_SUCCESS;
    if (!pDest)
    {
        status = NDIS_STATUS_INVALID_OID;
        *(pOid->pBytesRead) = 0;
        *(pOid->pBytesNeeded) = 0;
    }
    else if (ulSize)
    {
        if (pOid->InformationBufferLength < ulSize)
        {
            if (pOid->ulToDoFlags & ohfSetLessOK)
            {
                *(pOid->pBytesRead) = pOid->InformationBufferLength;
                NdisZeroMemory(pDest, ulSize);
                NdisMoveMemory(pDest, pOid->InformationBuffer, pOid->InformationBufferLength);
            }
            else
            {
                status = NDIS_STATUS_BUFFER_TOO_SHORT;
                *(pOid->pBytesRead) = 0;
                *(pOid->pBytesNeeded)  = ulSize;
            }
        }
        else if (pOid->InformationBufferLength == ulSize || (pOid->ulToDoFlags & ohfSetMoreOK))
        {
            *(pOid->pBytesRead) = ulSize;
            NdisMoveMemory(pDest, pOid->InformationBuffer, ulSize);
        }
        else
        {
            status = NDIS_STATUS_BUFFER_OVERFLOW;
            *(pOid->pBytesNeeded)  = ulSize;
            *(pOid->pBytesRead) = 0;
        }
    }
    else
    {
        *(pOid->pBytesRead) = pOid->InformationBufferLength;
    }
    return status;
}

Referenced by ParaNdis_OnEnableWakeup(), ParaNdis_OnSetLookahead(), ParaNdis_OnSetPacketFilter(), ParaNdis_OnSetPower(), and ParaNdis_OnSetVlanId().

ParaNdis_OnAddWakeupPattern()

NDIS_STATUS ParaNdis_OnAddWakeupPattern	(	PARANDIS_ADAPTER *	pContext,
		tOidDesc *	pOid
	)

Definition at line 584 of file ParaNdis-Oid.c.

{
    NDIS_STATUS status;
    PNDIS_PM_PACKET_PATTERN pPmPattern = (PNDIS_PM_PACKET_PATTERN) pOid->InformationBuffer;
    ULONG ulValidSize = pOid->InformationBufferLength;
    status = ValidateWakeupPattern(pPmPattern, &ulValidSize);
    if (status == NDIS_STATUS_SUCCESS)
    {
        *pOid->pBytesRead = ulValidSize;
    }
    else
    {
        *pOid->pBytesRead = 0;
        *pOid->pBytesNeeded = ulValidSize;
    }
    // TODO: Apply
    return status;
}

ParaNdis_OnEnableWakeup()

NDIS_STATUS ParaNdis_OnEnableWakeup	(	PARANDIS_ADAPTER *	pContext,
		tOidDesc *	pOid
	)

Definition at line 627 of file ParaNdis-Oid.c.

{
    NDIS_STATUS status = ParaNdis_OidSetCopy(pOid, &pContext->ulEnableWakeup, sizeof(pContext->ulEnableWakeup));
    if (status == NDIS_STATUS_SUCCESS)
    {
        DPrintf(0, ("[%s] new value %lX", __FUNCTION__, pContext->ulEnableWakeup));
    }
    return status;
}

ParaNdis_OnOidSetMulticastList()

NDIS_STATUS ParaNdis_OnOidSetMulticastList	(	PARANDIS_ADAPTER *	pContext,
		tOidDesc *	pOid
	)

Definition at line 150 of file ParaNdis-Oid.c.

{
    NDIS_STATUS status;
    status = ParaNdis_SetMulticastList(
        pContext,
        pOid->InformationBuffer,
        pOid->InformationBufferLength,
        pOid->pBytesRead,
        pOid->pBytesNeeded);
    ParaNdis_UpdateDeviceFilters(pContext);
    return status;
}

ParaNdis_OnRemoveWakeupPattern()

NDIS_STATUS ParaNdis_OnRemoveWakeupPattern	(	PARANDIS_ADAPTER *	pContext,
		tOidDesc *	pOid
	)

Definition at line 606 of file ParaNdis-Oid.c.

{
    NDIS_STATUS status;
    PNDIS_PM_PACKET_PATTERN pPmPattern = (PNDIS_PM_PACKET_PATTERN) pOid->InformationBuffer;
    ULONG ulValidSize = pOid->InformationBufferLength;
    status = ValidateWakeupPattern(pPmPattern, &ulValidSize);
    if (status == NDIS_STATUS_SUCCESS)
    {
        *pOid->pBytesRead = ulValidSize;
    }
    else
    {
        *pOid->pBytesRead = 0;
        *pOid->pBytesNeeded = ulValidSize;
    }
    return status;
}

ParaNdis_OnSetLookahead()

NDIS_STATUS ParaNdis_OnSetLookahead	(	PARANDIS_ADAPTER *	pContext,
		tOidDesc *	pOid
	)

Definition at line 640 of file ParaNdis-Oid.c.

{
    return ParaNdis_OidSetCopy(pOid, &pContext->DummyLookAhead, sizeof(pContext->DummyLookAhead));
}

ParaNdis_OnSetPacketFilter()

NDIS_STATUS ParaNdis_OnSetPacketFilter	(	PARANDIS_ADAPTER *	pContext,
		tOidDesc *	pOid
	)

Definition at line 118 of file ParaNdis-Oid.c.

{
    ULONG newValue;
    NDIS_STATUS status = ParaNdis_OidSetCopy(
        pOid,
        &newValue,
        sizeof(newValue));
 
    if (newValue & ~PARANDIS_PACKET_FILTERS)
        status = NDIS_STATUS_INVALID_DATA;
 
    if (status == NDIS_STATUS_SUCCESS)
    {
        pContext->PacketFilter = newValue;
        DPrintf(1, ("[%s] PACKET FILTER SET TO %x", __FUNCTION__, pContext->PacketFilter));
        ParaNdis_UpdateDeviceFilters(pContext);
    }
    return status;
}

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;
}

ParaNdis_OnSetVlanId()

NDIS_STATUS ParaNdis_OnSetVlanId	(	PARANDIS_ADAPTER *	pContext,
		tOidDesc *	pOid
	)

Definition at line 645 of file ParaNdis-Oid.c.

{
    NDIS_STATUS status = NDIS_STATUS_NOT_SUPPORTED;
    if (IsVlanSupported(pContext))
    {
        status = ParaNdis_OidSetCopy(pOid, &pContext->VlanId, sizeof(pContext->VlanId));
        pContext->VlanId &= 0xfff;
        DPrintf(0, ("[%s] new value %d on MAC %X", __FUNCTION__, pContext->VlanId, pContext->CurrentMacAddress[5]));
        ParaNdis_DeviceFiltersUpdateVlanId(pContext);
    }
    return status;
}