able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/rndis/rndismp/request.c

1833 lines
79 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/***************************************************************************
Copyright (c) 1999 Microsoft Corporation
Module Name:
REQUEST.C
Abstract:
Handles set and query requests
Environment:
kernel mode only
Notes:
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
PURPOSE.
Copyright (c) 1999 Microsoft Corporation. All Rights Reserved.
Revision History:
5/13/99 : created
Author:
Tom Green
****************************************************************************/
#include "precomp.h"
#ifdef TESTING
extern PUCHAR pOffloadBuffer;
extern ULONG OffloadSize;
#endif
// supported OID list
NDIS_OID RndismpSupportedOids[] =
{
OID_GEN_SUPPORTED_LIST,
OID_GEN_MEDIA_IN_USE,
OID_GEN_MAXIMUM_LOOKAHEAD,
OID_GEN_MAXIMUM_TOTAL_SIZE,
OID_GEN_PROTOCOL_OPTIONS,
OID_GEN_TRANSMIT_BUFFER_SPACE,
OID_GEN_RECEIVE_BUFFER_SPACE,
OID_GEN_TRANSMIT_BLOCK_SIZE,
OID_GEN_RECEIVE_BLOCK_SIZE,
OID_GEN_VENDOR_DESCRIPTION,
OID_GEN_DRIVER_VERSION,
OID_GEN_VENDOR_ID,
OID_GEN_VENDOR_DRIVER_VERSION,
OID_GEN_CURRENT_LOOKAHEAD,
OID_GEN_MAXIMUM_SEND_PACKETS,
OID_GEN_XMIT_OK,
OID_GEN_RCV_OK,
OID_GEN_XMIT_ERROR,
OID_GEN_RCV_ERROR,
OID_GEN_RCV_NO_BUFFER,
OID_GEN_MAC_OPTIONS,
OID_RNDISMP_STATISTICS,
#ifdef TESTING
OID_TCP_TASK_OFFLOAD,
OID_GEN_TRANSPORT_HEADER_OFFSET,
OID_GEN_PHYSICAL_MEDIUM,
#endif
OID_GEN_SUPPORTED_GUIDS
};
UINT RndismpSupportedOidsNum = sizeof(RndismpSupportedOids) / sizeof(NDIS_OID);
#ifdef BINARY_MOF_TEST
UCHAR RndismpBinaryMof[] = {
0x46, 0x4f, 0x4d, 0x42, 0x01, 0x00, 0x00, 0x00, 0x45, 0x02, 0x00, 0x00, 0xbc, 0x04, 0x00, 0x00,
0x44, 0x53, 0x00, 0x01, 0x1a, 0x7d, 0xda, 0x54, 0x18, 0x44, 0x82, 0x00, 0x01, 0x06, 0x18, 0x42,
0x20, 0xe4, 0x03, 0x89, 0xc0, 0x61, 0x68, 0x24, 0x18, 0x06, 0xe5, 0x01, 0x44, 0x6a, 0x20, 0xe4,
0x82, 0x89, 0x09, 0x10, 0x01, 0x21, 0xaf, 0x02, 0x6c, 0x0a, 0x30, 0x09, 0xa2, 0xfe, 0xfd, 0x15,
0xa1, 0xa1, 0x84, 0x40, 0x48, 0xa2, 0x00, 0xf3, 0x02, 0x74, 0x0b, 0x30, 0x2c, 0xc0, 0xb6, 0x00,
0xd3, 0x02, 0x1c, 0x23, 0x12, 0x65, 0xd0, 0x94, 0xc0, 0x4a, 0x20, 0x24, 0x54, 0x80, 0x72, 0x01,
0xbe, 0x05, 0x68, 0x07, 0x94, 0x64, 0x01, 0x96, 0x61, 0x34, 0x07, 0x0e, 0xc6, 0x09, 0x8a, 0x46,
0x46, 0xa9, 0x80, 0x90, 0x67, 0x01, 0xd6, 0x71, 0x09, 0x41, 0xf7, 0x02, 0xa4, 0x09, 0x70, 0x26,
0xc0, 0xdb, 0x34, 0xa4, 0x59, 0xc0, 0x30, 0x22, 0xd8, 0x16, 0x8e, 0x30, 0xe2, 0x9c, 0x42, 0x94,
0xc6, 0x10, 0x84, 0x19, 0x31, 0x4a, 0x73, 0x58, 0x82, 0x8a, 0x11, 0xa5, 0x30, 0x04, 0x01, 0x86,
0x88, 0x55, 0x9c, 0x00, 0x6b, 0x58, 0x42, 0x39, 0x80, 0x13, 0xb0, 0xfd, 0x39, 0x48, 0x13, 0x84,
0x1c, 0x4c, 0x0b, 0x25, 0x7b, 0x40, 0x9a, 0xc6, 0xf1, 0x05, 0x39, 0x87, 0x83, 0x61, 0x26, 0x86,
0x2c, 0x55, 0x98, 0x28, 0x2d, 0x73, 0x23, 0xe3, 0xb4, 0x45, 0x01, 0xe2, 0x05, 0x08, 0x07, 0xd5,
0x58, 0x3b, 0xc7, 0xd0, 0x05, 0x80, 0xa9, 0x1e, 0x1e, 0x4a, 0xcc, 0x98, 0x09, 0x5a, 0xbc, 0x93,
0x38, 0xcc, 0xc0, 0x61, 0x4b, 0xc7, 0xd0, 0x40, 0x02, 0x27, 0x68, 0x10, 0x49, 0x8a, 0x71, 0x84,
0x14, 0xe4, 0x5c, 0x42, 0x9c, 0x7c, 0x41, 0x02, 0x94, 0x0a, 0xd0, 0x09, 0xac, 0x19, 0x77, 0x3a,
0x66, 0x4d, 0x39, 0x50, 0x78, 0x8f, 0xdc, 0xf8, 0x41, 0xe2, 0xf4, 0x09, 0xac, 0x79, 0x44, 0x89,
0x13, 0xba, 0xa9, 0x09, 0x28, 0xa4, 0x02, 0x88, 0x16, 0x40, 0x94, 0x66, 0x32, 0xa8, 0xab, 0x40,
0x82, 0x47, 0x03, 0x8f, 0xe0, 0xa8, 0x0c, 0x7a, 0x1a, 0x41, 0xe2, 0x7b, 0x18, 0xef, 0x04, 0x1e,
0x99, 0x87, 0x79, 0x8a, 0x0c, 0xf3, 0xff, 0xff, 0x8e, 0x80, 0x75, 0x8d, 0xa7, 0x11, 0x9d, 0x80,
0xe5, 0xa0, 0xa1, 0xae, 0x03, 0x1e, 0x57, 0xb4, 0xf8, 0xa7, 0x6c, 0xb8, 0xba, 0xc6, 0x82, 0xba,
0x2a, 0xd8, 0xe1, 0x54, 0x34, 0xb6, 0x52, 0x05, 0x98, 0x1d, 0x9c, 0xe6, 0x9c, 0xe0, 0x68, 0x3c,
0x55, 0xcf, 0xe6, 0xe1, 0x20, 0xc1, 0x23, 0x82, 0xa7, 0xc0, 0xa7, 0x65, 0x1d, 0xc3, 0x25, 0x03,
0x34, 0x62, 0xb8, 0x73, 0x32, 0x7a, 0x82, 0x3b, 0x94, 0x80, 0xd1, 0xc0, 0xbd, 0x1b, 0x1c, 0x0d,
0xec, 0x59, 0xbf, 0x04, 0x44, 0x78, 0x38, 0xf0, 0x5c, 0x3d, 0x06, 0xfd, 0x08, 0xe4, 0x64, 0x36,
0x28, 0x3d, 0x37, 0x02, 0x7a, 0x05, 0xe0, 0x27, 0x09, 0x76, 0x3c, 0x30, 0xc8, 0x29, 0x1d, 0xad,
0x53, 0x43, 0xe8, 0xad, 0xe1, 0x19, 0xc1, 0x05, 0x7e, 0x4c, 0x00, 0xcb, 0xe9, 0x00, 0x3b, 0x16,
0x3c, 0x52, 0xe3, 0x47, 0x0c, 0xe1, 0x18, 0x31, 0xc6, 0x69, 0x04, 0x0a, 0xeb, 0x91, 0x04, 0xa9,
0x70, 0xf6, 0x64, 0x98, 0x6f, 0x0a, 0x35, 0x0a, 0xb8, 0x09, 0x58, 0xd4, 0x65, 0x02, 0x25, 0xe5,
0x32, 0x81, 0x98, 0x47, 0xd8, 0xb7, 0x04, 0x4f, 0xf8, 0xac, 0x7c, 0x98, 0xf0, 0xa5, 0x00, 0xfe,
0xed, 0xc3, 0xc3, 0x08, 0xfd, 0xb0, 0xf1, 0x44, 0xe2, 0x23, 0x43, 0x5c, 0xcc, 0xff, 0x1f, 0xd7,
0x03, 0xb7, 0x5f, 0x01, 0x08, 0xb1, 0xcb, 0xbc, 0x16, 0xe8, 0x38, 0x11, 0x21, 0xc1, 0x1b, 0x05,
0x16, 0xe3, 0x60, 0x3c, 0x50, 0x9f, 0x13, 0x3c, 0x4c, 0x83, 0x1c, 0x59, 0xbc, 0x88, 0x09, 0x4e,
0xed, 0xa8, 0xb1, 0x73, 0xe0, 0x03, 0x38, 0x86, 0xf0, 0xe7, 0x13, 0xfe, 0x00, 0xa2, 0x1c, 0xc7,
0x21, 0x79, 0xc8, 0x46, 0x38, 0x81, 0x72, 0x2f, 0x2b, 0xe4, 0x58, 0x72, 0x14, 0xa7, 0xf5, 0x74,
0x10, 0xe8, 0x04, 0x30, 0x0a, 0x6d, 0xfa, 0xd4, 0x68, 0xd4, 0xaa, 0x41, 0x99, 0x1a, 0x65, 0x1a,
0xd4, 0xea, 0x53, 0xa9, 0x31, 0x63, 0xf3, 0xb5, 0xb4, 0x77, 0x83, 0x40, 0x1c, 0x0a, 0x84, 0x66,
0xa4, 0x10, 0x88, 0xff, 0xff};
ULONG RndismpBinaryMofSize = sizeof(RndismpBinaryMof);
#define RNDISMPDeviceOIDGuid \
{ 0x437cf222,0x72fe,0x11d4, { 0x97,0xf9,0x00,0x20,0x48,0x57,0x03,0x37}}
#endif // BINARY_MOF_TEST
NDIS_GUID CustomGuidList[] =
{
{
RNDISMPStatisticsOIDGuid,
OID_RNDISMP_STATISTICS,
sizeof(UINT32), // size is size of each element in the array
(fNDIS_GUID_TO_OID|fNDIS_GUID_ARRAY)
}
#ifdef BINARY_MOF_TEST
,
{
RNDISMPDeviceOIDGuid,
OID_RNDISMP_DEVICE_OID,
sizeof(UINT32),
fNDIS_GUID_TO_OID
},
{
BINARY_MOF_GUID,
OID_RNDISMP_GET_MOF_OID,
sizeof(UINT8),
(fNDIS_GUID_TO_OID|fNDIS_GUID_ARRAY)
}
#endif
};
UINT CustomGuidCount = sizeof(CustomGuidList)/sizeof(NDIS_GUID);
/****************************************************************************/
/* RndismpQueryInformation */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* NDIS Entry point called to handle a query for a particular OID. */
/* */
/* Arguments: */
/* */
/* MiniportAdapterContext - a context version of our Adapter pointer */
/* Oid - the NDIS_OID to process. */
/* InformationBuffer - a pointer into the NdisRequest->InformationBuffer */
/* into which store the result of the query. */
/* InformationBufferLength - a pointer to the number of bytes left in */
/* the InformationBuffer. */
/* pBytesWritten - a pointer to the number of bytes written into the */
/* InformationBuffer. */
/* pBytesNeeded - If there is not enough room in the information buffer */
/* then this will contain the number of bytes needed to complete the */
/* request. */
/* */
/* Return: */
/* */
/* NDIS_STATUS */
/* */
/****************************************************************************/
NDIS_STATUS
RndismpQueryInformation(IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG pBytesWritten,
OUT PULONG pBytesNeeded)
{
PRNDISMP_ADAPTER pAdapter;
NDIS_STATUS Status;
// get adapter context
pAdapter = PRNDISMP_ADAPTER_FROM_CONTEXT_HANDLE(MiniportAdapterContext);
CHECK_VALID_ADAPTER(pAdapter);
TRACE3(("RndismpQueryInformation\n"));
Status = ProcessQueryInformation(pAdapter,
NULL,
NULL,
Oid,
InformationBuffer,
InformationBufferLength,
pBytesWritten,
pBytesNeeded);
return Status;
}
/****************************************************************************/
/* ProcessQueryInformation */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Utility routine to process a Query (connection-less or connection- */
/* oriented). */
/* */
/* Arguments: */
/* */
/* pAdapter - Pointer to our adapter structure */
/* pVc - Pointer to a VC, possibly NULL. */
/* pRequest - Pointer to NDIS request, if this came via our CoRequest */
/* handler. */
/* Oid - the NDIS_OID to process. */
/* InformationBuffer - a pointer into the NdisRequest->InformationBuffer */
/* into which store the result of the query. */
/* InformationBufferLength - a pointer to the number of bytes left in */
/* the InformationBuffer. */
/* pBytesWritten - a pointer to the number of bytes written into the */
/* InformationBuffer. */
/* pBytesNeeded - If there is not enough room in the information buffer */
/* then this will contain the number of bytes needed to complete the */
/* request. */
/* */
/* Return: */
/* */
/* NDIS_STATUS */
/* */
/****************************************************************************/
NDIS_STATUS
ProcessQueryInformation(IN PRNDISMP_ADAPTER pAdapter,
IN PRNDISMP_VC pVc,
IN PNDIS_REQUEST pRequest,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG pBytesWritten,
OUT PULONG pBytesNeeded)
{
NDIS_STATUS Status;
UINT OIDHandler;
OIDHandler = GetOIDSupport(pAdapter, Oid);
switch(OIDHandler)
{
case DRIVER_SUPPORTED_OID:
Status = DriverQueryInformation(pAdapter,
pVc,
pRequest,
Oid,
InformationBuffer,
InformationBufferLength,
pBytesWritten,
pBytesNeeded);
break;
case DEVICE_SUPPORTED_OID:
Status = DeviceQueryInformation(pAdapter,
pVc,
pRequest,
Oid,
InformationBuffer,
InformationBufferLength,
pBytesWritten,
pBytesNeeded);
break;
case OID_NOT_SUPPORTED:
default:
TRACE2(("Invalid Query OID (%08X)\n", Oid));
Status = NDIS_STATUS_INVALID_OID;
break;
}
TRACE2(("ProcessQueryInfo: Oid %08X, returning Status %x\n", Oid, Status));
return Status;
} // ProcessQueryInformation
/****************************************************************************/
/* RndismpSetInformation */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* The RndismpSetInformation processes a Set request for */
/* NDIS_OIDs that are specific about the Driver. */
/* */
/* Arguments: */
/* */
/* MiniportAdapterContext - a context version of our Adapter pointer */
/* Oid - the NDIS_OID to process. */
/* InformationBuffer - Holds the data to be set. */
/* InformationBufferLength - The length of InformationBuffer. */
/* pBytesRead - If the call is successful, returns the number */
/* of bytes read from InformationBuffer. */
/* pBytesNeeded - If there is not enough data in InformationBuffer */
/* to satisfy the OID, returns the amount of storage needed. */
/* */
/* Return: */
/* */
/* NDIS_STATUS */
/* */
/****************************************************************************/
NDIS_STATUS
RndismpSetInformation(IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG pBytesRead,
OUT PULONG pBytesNeeded)
{
PRNDISMP_ADAPTER pAdapter;
NDIS_STATUS Status;
// get adapter context
pAdapter = PRNDISMP_ADAPTER_FROM_CONTEXT_HANDLE(MiniportAdapterContext);
CHECK_VALID_ADAPTER(pAdapter);
TRACE3(("RndismpSetInformation\n"));
Status = ProcessSetInformation(pAdapter,
NULL,
NULL,
Oid,
InformationBuffer,
InformationBufferLength,
pBytesRead,
pBytesNeeded);
return Status;
}
/****************************************************************************/
/* ProcessSetInformation */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Utility routine to process a Set (connection-less or connection- */
/* oriented). */
/* */
/* Arguments: */
/* */
/* pAdapter - Pointer to our adapter structure */
/* pVc - Pointer to a VC, possibly NULL. */
/* pRequest - Pointer to NDIS request, if this came via our CoRequest */
/* handler. */
/* Oid - the NDIS_OID to process. */
/* InformationBuffer - a pointer into the NdisRequest->InformationBuffer */
/* into which store the result of the query. */
/* InformationBufferLength - a pointer to the number of bytes left in */
/* the InformationBuffer. */
/* pBytesRead - a pointer to the number of bytes read from the */
/* InformationBuffer. */
/* pBytesNeeded - If there is not enough room in the information buffer */
/* then this will contain the number of bytes needed to complete the */
/* request. */
/* */
/* Return: */
/* */
/* NDIS_STATUS */
/* */
/****************************************************************************/
NDIS_STATUS
ProcessSetInformation(IN PRNDISMP_ADAPTER pAdapter,
IN PRNDISMP_VC pVc OPTIONAL,
IN PNDIS_REQUEST pRequest OPTIONAL,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG pBytesRead,
OUT PULONG pBytesNeeded)
{
NDIS_STATUS Status;
UINT OIDHandler;
OIDHandler = GetOIDSupport(pAdapter, Oid);
switch(OIDHandler)
{
case DRIVER_SUPPORTED_OID:
Status = DriverSetInformation(pAdapter,
pVc,
pRequest,
Oid,
InformationBuffer,
InformationBufferLength,
pBytesRead,
pBytesNeeded);
break;
case DEVICE_SUPPORTED_OID:
Status = DeviceSetInformation(pAdapter,
pVc,
pRequest,
Oid,
InformationBuffer,
InformationBufferLength,
pBytesRead,
pBytesNeeded);
break;
case OID_NOT_SUPPORTED:
default:
TRACE1(("Invalid Set OID (%08X), Adapter %p\n", Oid, pAdapter));
Status = NDIS_STATUS_INVALID_OID;
break;
}
return Status;
} // ProcessSetInformation
/****************************************************************************/
/* DriverQueryInformation */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* The RndismpQueryInformation processes a Query request for */
/* NDIS_OIDs that are specific about the Driver. This routine */
/* Handles OIDs supported by the driver instead of the device */
/* */
/* Arguments: */
/* */
/* pAdapter - Pointer to our adapter structure */
/* pVc - Pointer to a VC, possibly NULL. */
/* pRequest - Pointer to NDIS request, if this came via our CoRequest */
/* handler. */
/* Oid - the NDIS_OID to process. */
/* InformationBuffer - a pointer into the NdisRequest->InformationBuffer */
/* into which store the result of the query. */
/* InformationBufferLength - a pointer to the number of bytes left in */
/* the InformationBuffer. */
/* pBytesWritten - a pointer to the number of bytes written into the */
/* InformationBuffer. */
/* pBytesNeeded - If there is not enough room in the information buffer */
/* then this will contain the number of bytes needed to complete the */
/* request. */
/* */
/* Return: */
/* */
/* NDIS_STATUS */
/* */
/****************************************************************************/
NDIS_STATUS
DriverQueryInformation(IN PRNDISMP_ADAPTER pAdapter,
IN PRNDISMP_VC pVc OPTIONAL,
IN PNDIS_REQUEST pRequest OPTIONAL,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG pBytesWritten,
OUT PULONG pBytesNeeded)
{
NDIS_STATUS Status;
PVOID MoveSource;
UINT MoveBytes;
ULONG GenericUlong;
USHORT GenericUshort;
CHAR VendorDescription[] = "Remote NDIS Network Card";
TRACE3(("DriverQueryInformation\n"));
OID_NAME_TRACE(Oid, "DriverQuery");
Status = NDIS_STATUS_SUCCESS;
MoveSource = (PVOID) (&GenericUlong);
MoveBytes = sizeof(GenericUlong);
// this is one we have to handle
switch(Oid)
{
case OID_GEN_DRIVER_VERSION:
GenericUshort = (pAdapter->DriverBlock->MajorNdisVersion << 8) +
(pAdapter->DriverBlock->MinorNdisVersion);
MoveSource = (PVOID)&GenericUshort;
MoveBytes = sizeof(GenericUshort);
break;
case OID_GEN_VENDOR_ID:
TRACE1(("Query for OID_GEN_VENDOR_ID not supported by device!\n"));
GenericUlong = 0xFFFFFF;
break;
case OID_GEN_VENDOR_DESCRIPTION:
TRACE1(("Query for OID_GEN_VENDOR_DESCRIPTION not supported by device!\n"));
if (pAdapter->FriendlyNameAnsi.Length != 0)
{
MoveSource = pAdapter->FriendlyNameAnsi.Buffer;
MoveBytes = pAdapter->FriendlyNameAnsi.Length;
}
else
{
MoveSource = VendorDescription;
MoveBytes = sizeof(VendorDescription);
}
break;
case OID_GEN_VENDOR_DRIVER_VERSION:
TRACE1(("Query for OID_GEN_VENDOR_DRIVER_VERSION not supported by device!\n"));
GenericUlong = 0xA000B;
break;
case OID_GEN_MAC_OPTIONS:
GenericUlong = pAdapter->MacOptions;
break;
case OID_GEN_SUPPORTED_LIST:
// get the list we generated
MoveSource = (PVOID) (pAdapter->SupportedOIDList);
MoveBytes = pAdapter->SupportedOIDListSize;
break;
case OID_GEN_MEDIA_IN_USE:
Status = DeviceQueryInformation(pAdapter,
pVc,
pRequest,
OID_GEN_MEDIA_SUPPORTED,
InformationBuffer,
InformationBufferLength,
pBytesWritten,
pBytesNeeded);
break;
case OID_GEN_MAXIMUM_LOOKAHEAD:
Status = DeviceQueryInformation(pAdapter,
pVc,
pRequest,
OID_GEN_MAXIMUM_FRAME_SIZE,
InformationBuffer,
InformationBufferLength,
pBytesWritten,
pBytesNeeded);
break;
case OID_GEN_TRANSMIT_BUFFER_SPACE:
GenericUlong = pAdapter->MaxTransferSize;
break;
case OID_GEN_RECEIVE_BUFFER_SPACE:
GenericUlong = pAdapter->MaxReceiveSize * 8;
break;
case OID_GEN_CURRENT_LOOKAHEAD:
Status = DeviceQueryInformation(pAdapter,
pVc,
pRequest,
OID_GEN_MAXIMUM_FRAME_SIZE,
InformationBuffer,
InformationBufferLength,
pBytesWritten,
pBytesNeeded);
break;
case OID_GEN_MAXIMUM_FRAME_SIZE:
Status = DeviceQueryInformation(pAdapter,
pVc,
pRequest,
OID_GEN_MAXIMUM_FRAME_SIZE,
InformationBuffer,
InformationBufferLength,
pBytesWritten,
pBytesNeeded);
break;
case OID_GEN_MAXIMUM_TOTAL_SIZE:
TRACE1(("Query for OID_GEN_MAXIMUM_TOTAL_SIZE not supported by device!\n"));
GenericUlong = (ULONG) MAXIMUM_ETHERNET_PACKET_SIZE;
break;
case OID_GEN_TRANSMIT_BLOCK_SIZE:
TRACE1(("Query for OID_GEN_TRANSMIT_BLOCK_SIZE not supported by device!\n"));
GenericUlong = (ULONG) MAXIMUM_ETHERNET_PACKET_SIZE;
break;
case OID_GEN_RECEIVE_BLOCK_SIZE:
TRACE1(("Query for OID_GEN_RECEIVE_BLOCK_SIZE not supported by device!\n"));
GenericUlong = (ULONG) MAXIMUM_ETHERNET_PACKET_SIZE;
break;
case OID_GEN_MAXIMUM_SEND_PACKETS:
GenericUlong = (ULONG) pAdapter->MaxPacketsPerMessage;
break;
case OID_PNP_CAPABILITIES:
case OID_PNP_QUERY_POWER:
Status = NDIS_STATUS_NOT_SUPPORTED;
break;
case OID_GEN_XMIT_OK:
GenericUlong = RNDISMP_GET_ADAPTER_STATS(pAdapter, XmitOk);
break;
case OID_GEN_XMIT_ERROR:
GenericUlong = RNDISMP_GET_ADAPTER_STATS(pAdapter, XmitError);
break;
case OID_GEN_RCV_OK:
GenericUlong = RNDISMP_GET_ADAPTER_STATS(pAdapter, RecvOk);
break;
case OID_GEN_RCV_ERROR:
GenericUlong = RNDISMP_GET_ADAPTER_STATS(pAdapter, RecvError);
break;
case OID_GEN_RCV_NO_BUFFER:
GenericUlong = RNDISMP_GET_ADAPTER_STATS(pAdapter, RecvNoBuf);
break;
case OID_GEN_SUPPORTED_GUIDS:
MoveSource = (PVOID)&CustomGuidList[0];
MoveBytes = sizeof(CustomGuidList);
TRACE1(("Query for supported GUIDs, len %d\n", InformationBufferLength));
break;
case OID_RNDISMP_STATISTICS:
MoveSource = &pAdapter->Statistics;
MoveBytes = sizeof(pAdapter->Statistics);
break;
#ifdef BINARY_MOF_TEST
case OID_RNDISMP_DEVICE_OID:
DbgPrint("*** RNDISMP: Query for Device OID\n");
GenericUlong = 0xabcdefab;
break;
case OID_RNDISMP_GET_MOF_OID:
DbgPrint("*** RNDISMP: Query for MOF Info: Src %p, Size %d\n",
RndismpBinaryMof, RndismpBinaryMofSize);
MoveSource = RndismpBinaryMof;
MoveBytes = RndismpBinaryMofSize;
break;
#endif // BINARY_MOF_TEST
#ifdef TESTING
case OID_TCP_TASK_OFFLOAD:
DbgPrint("RNDISMP: got query for TCP offload\n");
MoveSource = pOffloadBuffer;
MoveBytes = OffloadSize;
break;
case OID_GEN_PHYSICAL_MEDIUM:
DbgPrint("RNDISMP: got query for physical medium\n");
GenericUlong = NdisPhysicalMediumDSL;
break;
#endif
default:
Status = NDIS_STATUS_INVALID_OID;
break;
}
// copy stuff to information buffer
if (Status == NDIS_STATUS_SUCCESS)
{
if (MoveBytes > InformationBufferLength)
{
// Not enough room in InformationBuffer
*pBytesNeeded = MoveBytes;
Status = NDIS_STATUS_BUFFER_TOO_SHORT;
}
else
{
// Copy result into InformationBuffer
*pBytesWritten = MoveBytes;
if (MoveBytes > 0)
RNDISMP_MOVE_MEM(InformationBuffer, MoveSource, MoveBytes);
}
}
TRACE2(("Status (%08X) BytesWritten (%08X)\n", Status, *pBytesWritten));
return Status;
} // DriverQueryInformation
/****************************************************************************/
/* DeviceQueryInformation */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* The DeviceQueryInformation processes a Query request */
/* that is going to the Remote NDIS device */
/* */
/* Arguments: */
/* */
/* pAdapter - pointer to our Adapter structure */
/* pVc - optional pointer to our VC structure, if this is a per-Vc req. */
/* pRequest - optional pointer to NDIS request, if CONDIS. */
/* Oid - the NDIS_OID to process. */
/* InformationBuffer - a pointer into the NdisRequest->InformationBuffer */
/* into which store the result of the query. */
/* InformationBufferLength - a pointer to the number of bytes left in */
/* the InformationBuffer. */
/* pBytesWritten - a pointer to the number of bytes written into the */
/* InformationBuffer. */
/* pBytesNeeded - If there is not enough room in the information buffer */
/* then this will contain the number of bytes needed to complete the */
/* request. */
/* */
/* Return: */
/* */
/* NDIS_STATUS */
/* */
/****************************************************************************/
NDIS_STATUS
DeviceQueryInformation(IN PRNDISMP_ADAPTER pAdapter,
IN PRNDISMP_VC pVc OPTIONAL,
IN PNDIS_REQUEST pRequest OPTIONAL,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG pBytesWritten,
OUT PULONG pBytesNeeded)
{
PRNDISMP_MESSAGE_FRAME pMsgFrame;
PRNDISMP_REQUEST_CONTEXT pReqContext;
NDIS_STATUS Status;
TRACE3(("DeviceQueryInformation\n"));
OID_NAME_TRACE(Oid, "DeviceQuery");
TRACE3(("DeviceQuery: InfoBuf %p, Len %d, pBytesWrit %p, pBytesNeed %p\n",
InformationBuffer, InformationBufferLength, pBytesWritten, pBytesNeeded));
do
{
if (pAdapter->Halting)
{
Status = NDIS_STATUS_NOT_ACCEPTED;
break;
}
pReqContext = AllocateRequestContext(pAdapter);
if (pReqContext == NULL)
{
Status = NDIS_STATUS_RESOURCES;
break;
}
//
// HACKHACK to avoid a strange length from going to the device
// At least one device does not like this.
//
// In general, there is no point sending a huge information buffer
// along with a Query that does not require an IN parameter.
// Long term, we may have to separate out the few OIDs that do
// use IN parameters and allow those buffers to pass through
//
pMsgFrame = BuildRndisMessageCommon(pAdapter,
pVc,
REMOTE_NDIS_QUERY_MSG,
Oid,
InformationBuffer,
((InformationBufferLength > 48)?
48: InformationBufferLength));
// see if we got a message
if (!pMsgFrame)
{
Status = NDIS_STATUS_RESOURCES;
FreeRequestContext(pAdapter, pReqContext);
break;
}
Status = NDIS_STATUS_PENDING;
pReqContext->InformationBuffer = InformationBuffer;
pReqContext->InformationBufferLength = InformationBufferLength;
pReqContext->pBytesRead = NULL;
pReqContext->pBytesWritten = pBytesWritten;
pReqContext->pBytesNeeded = pBytesNeeded;
pReqContext->Oid = Oid;
pReqContext->RetryCount = 0;
pReqContext->bInternal = FALSE;
pReqContext->pVc = pVc;
pReqContext->pNdisRequest = pRequest;
pMsgFrame->pReqContext = pReqContext;
// Add a ref to keep the frame around until we complete the request.
ReferenceMsgFrame(pMsgFrame);
// send the message to the microport
RNDISMP_SEND_TO_MICROPORT(pAdapter, pMsgFrame, TRUE, CompleteSendDeviceRequest);
break;
}
while (FALSE);
return Status;
} // DeviceQueryInformation
/****************************************************************************/
/* DriverSetInformation */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Utility routine to handle SetInformation requests that aren't */
/* specific to the device. We also land up here for requests for any */
/* OIDs that aren't supported by the device. */
/* */
/* Arguments: */
/* */
/* pAdapter - Pointer to our adapter structure */
/* pVc - Pointer to a VC, possibly NULL. */
/* pRequest - Pointer to NDIS request, if this came via our CoRequest */
/* handler. */
/* Oid - the NDIS_OID to process. */
/* InformationBuffer - Holds the data to be set. */
/* InformationBufferLength - The length of InformationBuffer. */
/* pBytesRead - If the call is successful, returns the number */
/* of bytes read from InformationBuffer. */
/* pBytesNeeded - If there is not enough data in InformationBuffer */
/* to satisfy the OID, returns the amount of storage needed. */
/* */
/* Return: */
/* */
/* NDIS_STATUS */
/* */
/****************************************************************************/
NDIS_STATUS
DriverSetInformation(IN PRNDISMP_ADAPTER pAdapter,
IN PRNDISMP_VC pVc OPTIONAL,
IN PNDIS_REQUEST pRequest OPTIONAL,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG pBytesRead,
OUT PULONG pBytesNeeded)
{
NDIS_STATUS Status;
TRACE2(("DriverSetInformation: Adapter %p, Oid %x\n", pAdapter, Oid));
OID_NAME_TRACE(Oid, "DriverSet");
Status = NDIS_STATUS_SUCCESS;
switch(Oid)
{
case OID_GEN_CURRENT_LOOKAHEAD:
// Verify the Length
if(InformationBufferLength != sizeof(ULONG))
Status = NDIS_STATUS_INVALID_LENGTH;
*pBytesRead = sizeof(ULONG);
break;
case OID_PNP_SET_POWER:
case OID_PNP_ADD_WAKE_UP_PATTERN:
case OID_PNP_REMOVE_WAKE_UP_PATTERN:
case OID_PNP_ENABLE_WAKE_UP:
Status = NDIS_STATUS_NOT_SUPPORTED;
break;
#ifdef TESTING
case OID_TCP_TASK_OFFLOAD:
Status = NDIS_STATUS_SUCCESS;
DbgPrint("RNDISMP: Set TCP_TASK_OFFLOAD\n");
break;
case OID_GEN_TRANSPORT_HEADER_OFFSET:
Status = NDIS_STATUS_SUCCESS;
break;
#endif
default:
Status = NDIS_STATUS_INVALID_OID;
break;
}
TRACE2(("Status (%08X) BytesRead (%08X)\n", Status, *pBytesRead));
return Status;
} // DriverSetInformation
/****************************************************************************/
/* DeviceSetInformation */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* The DeviceSetInformation processes a set request */
/* that is going to the Remote NDIS device */
/* */
/* Arguments: */
/* */
/* pAdapter - pointer to our Adapter structure */
/* pVc - optional pointer to our VC structure, if this is a per-Vc req. */
/* pRequest - optional pointer to NDIS request, if CONDIS. */
/* Oid - the NDIS_OID to process. */
/* InformationBuffer - Holds the data to be set. */
/* InformationBufferLength - The length of InformationBuffer. */
/* pBytesRead - If the call is successful, returns the number */
/* of bytes read from InformationBuffer. */
/* pBytesNeeded - If there is not enough data in InformationBuffer */
/* to satisfy the OID, returns the amount of storage needed. */
/* */
/* Return: */
/* */
/* NDIS_STATUS */
/* */
/****************************************************************************/
NDIS_STATUS
DeviceSetInformation(IN PRNDISMP_ADAPTER pAdapter,
IN PRNDISMP_VC pVc OPTIONAL,
IN PNDIS_REQUEST pRequest OPTIONAL,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG pBytesRead,
OUT PULONG pBytesNeeded)
{
PRNDISMP_MESSAGE_FRAME pMsgFrame;
PRNDISMP_REQUEST_CONTEXT pReqContext;
NDIS_STATUS Status;
TRACE2(("DeviceSetInformation: Adapter %p, Oid %x\n"));
OID_NAME_TRACE(Oid, "DeviceSet");
#if DBG
if (Oid == OID_GEN_CURRENT_PACKET_FILTER)
{
PULONG pFilter = (PULONG)InformationBuffer;
TRACE1(("DeviceSetInfo: Adapter %p: Setting packet filter to %x\n",
pAdapter, *pFilter));
}
#endif
do
{
if (pAdapter->Halting)
{
TRACE1(("DeviceSetInfo: Adapter %p is halting: succeeding Oid %x\n",
pAdapter, Oid));
Status = NDIS_STATUS_SUCCESS;
break;
}
pReqContext = AllocateRequestContext(pAdapter);
if (pReqContext == NULL)
{
Status = NDIS_STATUS_RESOURCES;
break;
}
pMsgFrame = BuildRndisMessageCommon(pAdapter,
pVc,
REMOTE_NDIS_SET_MSG,
Oid,
InformationBuffer,
InformationBufferLength);
// see if we got a message
if (!pMsgFrame)
{
Status = NDIS_STATUS_RESOURCES;
FreeRequestContext(pAdapter, pReqContext);
break;
}
Status = NDIS_STATUS_PENDING;
pReqContext->InformationBuffer = InformationBuffer;
pReqContext->InformationBufferLength = InformationBufferLength;
pReqContext->pBytesRead = pBytesRead;
pReqContext->pBytesWritten = NULL;
pReqContext->pBytesNeeded = pBytesNeeded;
pReqContext->Oid = Oid;
pReqContext->RetryCount = 0;
pReqContext->bInternal = FALSE;
pReqContext->pVc = pVc;
pReqContext->pNdisRequest = pRequest;
pMsgFrame->pReqContext = pReqContext;
#ifndef BUILD_WIN9X
// Add a ref to keep the frame around until we complete the request.
ReferenceMsgFrame(pMsgFrame);
// send the message to the microport
RNDISMP_SEND_TO_MICROPORT(pAdapter, pMsgFrame, TRUE, CompleteSendDeviceRequest);
#else
//
// Win9X!
//
// Special-case for setting the current packet filter to 0.
// We complete this one synchronously, otherwise NdisCloseAdapter
// doesn't seem to complete.
//
if ((Oid == OID_GEN_CURRENT_PACKET_FILTER) &&
(*(PULONG)InformationBuffer == 0))
{
//
// Do not queue the request, so that when we get a completion
// from the device, we simply drop it.
//
RNDISMP_SEND_TO_MICROPORT(pAdapter, pMsgFrame, FALSE, CompleteSendDiscardDeviceRequest);
Status = NDIS_STATUS_SUCCESS;
}
else
{
// Add a ref to keep the frame around until we complete the request.
ReferenceMsgFrame(pMsgFrame);
// send the message to the microport
RNDISMP_SEND_TO_MICROPORT(pAdapter, pMsgFrame, TRUE, CompleteSendDeviceRequest);
}
#endif // BUILD_WIN9X
break;
}
while (FALSE);
return Status;
} // DeviceSetInformation
/****************************************************************************/
/* QuerySetCompletionMessage */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Completion message from microport in response to query or set message */
/* miniport sent. This information is now ready to pass to upper layers */
/* since the original call into the miniport returned STATUS_PENDING */
/* */
/* Danger Danger - an OID_GEN_SUPPORTED_LIST query is special cased here */
/* This is only sent to the device from the adapter init routine to build */
/* a list of OIDs supported by the driver and device. */
/* All OID_GEN_SUPPORTED_LIST queries from upper layers are handled by */
/* the driver and not the device. */
/* */
/* Arguments: */
/* */
/* pAdapter - Pointer to our adapter structure */
/* pMessage - pointer to RNDIS message */
/* pMdl - pointer to MDL from microport */
/* TotalLength - length of complete message */
/* MicroportMessageContext - context for message from microport */
/* ReceiveStatus - used by microport to indicate it is low on resource */
/* bMessageCopied - is this a copy of the original message? */
/* */
/* Return: */
/* */
/* BOOLEAN - should the message be returned to the microport? */
/* */
/****************************************************************************/
BOOLEAN
QuerySetCompletionMessage(IN PRNDISMP_ADAPTER pAdapter,
IN PRNDIS_MESSAGE pMessage,
IN PMDL pMdl,
IN ULONG TotalLength,
IN NDIS_HANDLE MicroportMessageContext,
IN NDIS_STATUS ReceiveStatus,
IN BOOLEAN bMessageCopied)
{
PRNDISMP_MESSAGE_FRAME pMsgFrame;
PRNDISMP_REQUEST_CONTEXT pReqContext;
PRNDIS_QUERY_COMPLETE pQueryComplMessage;
PRNDIS_SET_COMPLETE pSetComplMessage;
UINT32 NdisMessageType;
NDIS_STATUS Status;
UINT BytesWritten;
UINT BytesRead;
BOOLEAN bInternal;
TRACE3(("QuerySetCompletionMessage\n"));
pReqContext = NULL;
pMsgFrame = NULL;
pQueryComplMessage = RNDIS_MESSAGE_PTR_TO_MESSAGE_PTR(pMessage);
pSetComplMessage = RNDIS_MESSAGE_PTR_TO_MESSAGE_PTR(pMessage);
bInternal = FALSE;
NdisMessageType = 0xdead;
Status = NDIS_STATUS_SUCCESS;
do
{
// get request frame from request ID in message
RNDISMP_LOOKUP_PENDING_MESSAGE(pMsgFrame, pAdapter, pQueryComplMessage->RequestId);
if (pMsgFrame == NULL)
{
// invalid request ID or aborted request.
TRACE1(("Invalid/aborted request ID %08X in Query/Set Complete msg %p\n",
pQueryComplMessage->RequestId, pQueryComplMessage));
break;
}
pReqContext = pMsgFrame->pReqContext;
ASSERT(pReqContext != NULL);
bInternal = pReqContext->bInternal;
NdisMessageType = pMessage->NdisMessageType;
if (NdisMessageType != RNDIS_COMPLETION(pMsgFrame->NdisMessageType))
{
TRACE1(("Query/Response mismatch: Msg @ %p, ReqId %d, req type %X, compl type %X\n",
pMessage,
pQueryComplMessage->RequestId,
pMsgFrame->NdisMessageType,
NdisMessageType));
ASSERT(FALSE);
pMsgFrame = NULL;
Status = NDIS_STATUS_FAILURE;
break;
}
switch(NdisMessageType)
{
// a query complete message indicates we have a response
// to a query message the miniport sent down. we carry around
// appropriate context so we can indicate the completion
// to upper layers and pass the query data up
//
// OID_GEN_SUPPORTED_LIST is a special case since it
// is never indicated to upper layers from the device
case REMOTE_NDIS_QUERY_CMPLT:
// an OID_GEN_SUPPORTED_LIST is never completed to the upper
// layers. This is sent from our adapter init routine
// in preparation for building a list of OIDs
TRACE2(("QueryCompl: OID %08X, %d bytes, Status %x\n",
pReqContext->Oid,
pQueryComplMessage->InformationBufferLength,
pQueryComplMessage->Status));
pReqContext->CompletionStatus = pQueryComplMessage->Status;
if (pReqContext->Oid == OID_GEN_SUPPORTED_LIST)
{
if (pReqContext->CompletionStatus == NDIS_STATUS_SUCCESS)
{
// Build a list of supported OIDs.
TRACE1(("QueryComplete: SupportedList: InfoBufLength %d (%d OIDs)\n",
pQueryComplMessage->InformationBufferLength,
pQueryComplMessage->InformationBufferLength/sizeof(NDIS_OID)));
Status = BuildOIDLists(pAdapter,
(PNDIS_OID) (((PUCHAR)(pQueryComplMessage)) +
pQueryComplMessage->InformationBufferOffset),
pQueryComplMessage->InformationBufferLength / sizeof(NDIS_OID),
pAdapter->DriverOIDList,
pAdapter->NumDriverOIDs);
}
// the adapter init routine is waiting for a response
NdisSetEvent(pReqContext->pEvent);
// The message frame is freed by the Init routine.
pMsgFrame = NULL;
break;
}
// something other than OID_GEN_SUPPORTED_LIST
*pReqContext->pBytesNeeded = pQueryComplMessage->InformationBufferLength;
if (pQueryComplMessage->InformationBufferLength > pReqContext->InformationBufferLength)
{
TRACE0(("Query Complete (Oid = %08X): InfoBuffLen %d < %d\n",
pReqContext->Oid,
pQueryComplMessage->InformationBufferLength,
pReqContext->InformationBufferLength));
Status = NDIS_STATUS_BUFFER_TOO_SHORT;
break;
}
if (pQueryComplMessage->Status != RNDIS_STATUS_SUCCESS)
{
TRACE0(("Query Complete (Oid = %08X): error status %08X\n",
pReqContext->Oid, pQueryComplMessage->Status));
*pReqContext->pBytesNeeded = pQueryComplMessage->InformationBufferLength;
*pReqContext->pBytesWritten = 0;
Status = pQueryComplMessage->Status;
}
else
{
// copy information from RNDIS message to NDIS buffer passed down
TRACE3(("QueryCompl: copy %d bytes to %p\n",
pQueryComplMessage->InformationBufferLength,
pReqContext->InformationBuffer));
RNDISMP_MOVE_MEM(pReqContext->InformationBuffer,
MESSAGE_TO_INFO_BUFFER(pQueryComplMessage),
pQueryComplMessage->InformationBufferLength);
// tell the upper layers the size
*pReqContext->pBytesWritten = pQueryComplMessage->InformationBufferLength;
BytesWritten = *pReqContext->pBytesWritten;
TRACE3(("Query Compl OK: Adapter %p, Oid %x\n",
pAdapter, pReqContext->Oid));
TRACE2(("Info Data (%08X)\n", *((PUINT) pReqContext->InformationBuffer)));
if (pReqContext->Oid == OID_GEN_MEDIA_CONNECT_STATUS)
{
TRACE3(("Adapter %p: link is %s\n",
pAdapter, (((*(PULONG)pReqContext->InformationBuffer) == NdisMediaStateConnected)?
"Connected": "Not connected")));
}
if (pReqContext->Oid == OID_GEN_MAC_OPTIONS)
{
PULONG pMacOptions = (PULONG)pReqContext->InformationBuffer;
ULONG MacOptions = *pMacOptions;
TRACE1(("Adapter %p: OID_GEN_MAC_OPTIONS from device is %x\n",
pAdapter, MacOptions));
//
// We only let the device dictate some of these bits.
//
MacOptions = (MacOptions & RNDIS_DEVICE_MAC_OPTIONS_MASK) |
pAdapter->MacOptions;
*pMacOptions = MacOptions;
TRACE1(("Adapter %p: Modified OID_GEN_MAC_OPTIONS is %x\n",
pAdapter, *pMacOptions));
}
#if 0
//
// Temp hack for old-firmware Peracom devices - report a smaller
// value for max multicast list aize.
//
if (pReqContext->Oid == OID_802_3_MAXIMUM_LIST_SIZE)
{
PULONG pListSize = (PULONG)pReqContext->InformationBuffer;
if (*pListSize > 64)
{
TRACE1(("Adapter %p: Truncating max multicast list size from %d to 63!\n",
pAdapter, *pListSize));
*pListSize = 64;
}
}
#endif
Status = NDIS_STATUS_SUCCESS;
}
break;
case REMOTE_NDIS_SET_CMPLT:
TRACE2(("SetCompl: OID %08X, Status %x\n",
pReqContext->Oid,
pSetComplMessage->Status));
if (pSetComplMessage->Status == RNDIS_STATUS_SUCCESS)
{
*pReqContext->pBytesRead = pReqContext->InformationBufferLength;
BytesRead = *pReqContext->pBytesRead;
Status = NDIS_STATUS_SUCCESS;
}
else
{
// don't really expect to see this other than via NDISTEST
TRACE1(("Set Complete (Oid = %08X) failure: %08X\n",
pReqContext->Oid,
pSetComplMessage->Status));
*pReqContext->pBytesRead = 0;
BytesRead = 0;
Status = pSetComplMessage->Status;
}
pReqContext->CompletionStatus = Status;
if (bInternal && pReqContext->pEvent)
{
NdisSetEvent(pReqContext->pEvent);
pMsgFrame = NULL;
pReqContext = NULL;
}
break;
default:
TRACE1(("Invalid Ndis Message Type (%08X)\n", NdisMessageType));
ASSERT(FALSE); // we shouldn't have sent an invalid message type!
break;
}
break;
}
while (FALSE);
//
// Send the completion to the upper layers unless it was a request
// we generated outselves.
//
if (!bInternal && pReqContext)
{
if (pReqContext->pNdisRequest)
{
NdisMCoRequestComplete(Status,
pAdapter->MiniportAdapterHandle,
pReqContext->pNdisRequest);
}
else
{
if (NdisMessageType == REMOTE_NDIS_QUERY_CMPLT)
{
TRACE2(("Status (%08X) BytesWritten (%08X)\n", Status, BytesWritten));
// complete the query
NdisMQueryInformationComplete(pAdapter->MiniportAdapterHandle,
Status);
}
else if (NdisMessageType == REMOTE_NDIS_SET_CMPLT)
{
TRACE2(("Status (%08X) BytesRead (%08X)\n", Status, BytesRead));
// complete the set
NdisMSetInformationComplete(pAdapter->MiniportAdapterHandle,
Status);
}
}
}
if (pReqContext)
{
FreeRequestContext(pAdapter, pReqContext);
}
if (pMsgFrame)
{
DereferenceMsgFrame(pMsgFrame);
}
return (TRUE);
} // QuerySetCompletionMessage
/****************************************************************************/
/* CompleteSendDeviceRequest */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Completion of send of a device set or query request thru the microport. */
/* If the message send failed, complete the request right now. */
/* */
/* Arguments: */
/* */
/* pMsgFrame - our context for the message */
/* SendStatus - microport's send status */
/* */
/* Return: */
/* */
/* None. */
/* */
/****************************************************************************/
VOID
CompleteSendDeviceRequest(IN PRNDISMP_MESSAGE_FRAME pMsgFrame,
IN NDIS_STATUS SendStatus)
{
PRNDISMP_ADAPTER pAdapter;
PRNDISMP_MESSAGE_FRAME pOrgMsgFrame;
PRNDISMP_REQUEST_CONTEXT pReqContext;
UINT NdisMessageType;
pAdapter = pMsgFrame->pAdapter;
TRACE3(("CompleteSendDevice Request: Adapter %p, MsgFrame %p, Status %x\n",
pAdapter, pMsgFrame, SendStatus));
if (SendStatus != NDIS_STATUS_SUCCESS)
{
//
// Microport failed to send the Request message;
// attempt to fail the original NDIS request.
//
TRACE1(("CompleteSendDeviceReq: Adapter %p, MsgFrame %p, failed %x\n",
pAdapter, pMsgFrame, SendStatus));
RNDISMP_LOOKUP_PENDING_MESSAGE(pOrgMsgFrame, pAdapter, pMsgFrame->RequestId);
if (pOrgMsgFrame == pMsgFrame)
{
//
// The request has not been aborted, so complete it now.
//
pReqContext = pMsgFrame->pReqContext;
NdisMessageType = pMsgFrame->NdisMessageType;
TRACE1(("CompleteSendReq: Adapter %p: Device req send failed, Oid %x, retry count %d\n",
pAdapter, pReqContext->Oid, pReqContext->RetryCount));
if (NdisMessageType == REMOTE_NDIS_QUERY_MSG)
{
// complete the query
NdisMQueryInformationComplete(pAdapter->MiniportAdapterHandle,
SendStatus);
}
else if (NdisMessageType == REMOTE_NDIS_SET_MSG)
{
// complete the set
NdisMSetInformationComplete(pAdapter->MiniportAdapterHandle,
SendStatus);
}
else
{
ASSERT(FALSE);
}
FreeRequestContext(pAdapter, pReqContext);
pMsgFrame->pReqContext = (PRNDISMP_REQUEST_CONTEXT)UlongToPtr(0xbcbcbcbc);
//
// Deref for NDIS request completion:
//
DereferenceMsgFrame(pMsgFrame);
}
//
// else we failed to locate the request on the pending list;
// it must have been removed when aborting all requests due
// to a reset.
//
}
//
// else sent the message out successfully; wait for a response.
//
//
// Deref for send-complete:
//
DereferenceMsgFrame(pMsgFrame);
}
#ifdef BUILD_WIN9X
/****************************************************************************/
/* CompleteSendDiscardDeviceRequest */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Completion of send of a device set or query request thru the microport. */
/* The sender of the request just wants us to free it up here. */
/* */
/* Arguments: */
/* */
/* pMsgFrame - our context for the message */
/* SendStatus - microport's send status */
/* */
/* Return: */
/* */
/* None. */
/* */
/****************************************************************************/
VOID
CompleteSendDiscardDeviceRequest(IN PRNDISMP_MESSAGE_FRAME pMsgFrame,
IN NDIS_STATUS SendStatus)
{
PRNDISMP_ADAPTER pAdapter;
PRNDISMP_REQUEST_CONTEXT pReqContext;
pAdapter = pMsgFrame->pAdapter;
pReqContext = pMsgFrame->pReqContext;
TRACE1(("CompleteSendDiscard: Adapter %p, MsgFrame %p, ReqContext %p\n",
pAdapter, pMsgFrame, pReqContext));
FreeRequestContext(pAdapter, pReqContext);
DereferenceMsgFrame(pMsgFrame);
}
#endif // BUILD_WIN9X
/****************************************************************************/
/* BuildOIDLists */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Build list of supported OIDs and associated function pointers */
/* */
/* Arguments: */
/* */
/* Adapter - Adapter object */
/* DeviceOIDList - list of OIDs supported by the device */
/* NumDeviceOID - number of OIDs supported by device */
/* DriverOIDList - list of OIDs supported by the driver */
/* NumDriverOID - number of OIDs supported by driver */
/* */
/* Return: */
/* */
/* NDIS_STATUS */
/* */
/****************************************************************************/
NDIS_STATUS
BuildOIDLists(IN PRNDISMP_ADAPTER Adapter,
IN PNDIS_OID DeviceOIDList,
IN UINT NumDeviceOID,
IN PNDIS_OID DriverOIDList,
IN UINT NumDriverOID)
{
UINT DeviceIndex;
UINT DriverIndex;
UINT NumOID;
NDIS_STATUS Status;
PNDIS_OID OIDList;
PUINT OIDHandlerList;
TRACE3(("BuildOIDLists\n"));
ASSERT(DeviceOIDList);
ASSERT(DriverOIDList);
NumOID = NumDriverOID;
// see what OIDs are duplicated in the device and route
// those to the device
for(DeviceIndex = 0; DeviceIndex < NumDeviceOID; DeviceIndex++)
{
for(DriverIndex = 0; DriverIndex < NumDriverOID; DriverIndex++)
{
if(DeviceOIDList[DeviceIndex] == DriverOIDList[DriverIndex])
{
// this OID is supported by the device, so don't
// support in the driver, set to 0 for when we build new list
DriverOIDList[DriverIndex] = 0;
break;
}
}
// if no match, increment the OID count
if(DriverIndex == NumDriverOID)
NumOID++;
}
// allocate OID list
Status = MemAlloc(&Adapter->SupportedOIDList,
NumOID * sizeof(NDIS_OID));
// see if we got our buffer
if(Status == NDIS_STATUS_SUCCESS)
{
Adapter->SupportedOIDListSize = NumOID * sizeof(NDIS_OID);
}
else
{
Adapter->OIDHandlerList = (PUINT) NULL;
Adapter->OIDHandlerListSize = 0;
Adapter->SupportedOIDList = (PNDIS_OID) NULL;
Adapter->SupportedOIDListSize = 0;
Status = NDIS_STATUS_FAILURE;
goto BuildDone;
}
// allocate list to indicate whether the OID is device or driver supported
Status = MemAlloc(&Adapter->OIDHandlerList,
NumOID * sizeof(UINT));
// see if we got our buffer
if(Status == NDIS_STATUS_SUCCESS)
{
Adapter->OIDHandlerListSize = NumOID * sizeof(UINT);
}
else
{
// free up allocated OID list cause this allocation failed
MemFree(Adapter->SupportedOIDList, Adapter->SupportedOIDListSize);
Adapter->OIDHandlerList = (PUINT) NULL;
Adapter->OIDHandlerListSize = 0;
Adapter->SupportedOIDList = (PNDIS_OID) NULL;
Adapter->SupportedOIDListSize = 0;
Status = NDIS_STATUS_FAILURE;
goto BuildDone;
}
Adapter->NumOIDSupported = NumOID;
OIDHandlerList = Adapter->OIDHandlerList;
OIDList = Adapter->SupportedOIDList;
// O.K., build our lists
for(DriverIndex = 0; DriverIndex < NumDriverOID; DriverIndex++)
{
if(DriverOIDList[DriverIndex] != 0)
{
// got one, so add to the list
*OIDList = DriverOIDList[DriverIndex];
OIDList++;
// set flag
*OIDHandlerList = DRIVER_SUPPORTED_OID;
OIDHandlerList++;
}
}
// let's add device supported OIDs
for(DeviceIndex = 0; DeviceIndex < NumDeviceOID; DeviceIndex++)
{
if(DeviceOIDList[DeviceIndex] != 0)
{
// got one, so add to the list
*OIDList = DeviceOIDList[DeviceIndex];
OIDList++;
// set flag
*OIDHandlerList = DEVICE_SUPPORTED_OID;
OIDHandlerList++;
}
}
// Now do a fixup to point OID_GEN_SUPPORTED_LIST at the driver since
// we now have a complete list.
//
for(DeviceIndex = 0; DeviceIndex < Adapter->NumOIDSupported; DeviceIndex++)
{
if (Adapter->SupportedOIDList[DeviceIndex] == OID_GEN_SUPPORTED_LIST)
{
Adapter->OIDHandlerList[DeviceIndex] = DRIVER_SUPPORTED_OID;
}
}
BuildDone:
if(Status == NDIS_STATUS_SUCCESS)
{
DISPLAY_OID_LIST(Adapter);
}
return Status;
} // BuildOIDLists
/****************************************************************************/
/* GetOIDSupport */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Returns flag to indicate if OID is device or driver supported */
/* */
/* Arguments: */
/* */
/* Adapter - Adapter object */
/* Oid - looking for a match on this OID */
/* */
/* Return: */
/* */
/* UINT */
/* */
/****************************************************************************/
UINT
GetOIDSupport(IN PRNDISMP_ADAPTER Adapter, IN NDIS_OID Oid)
{
UINT Index;
TRACE3(("GetOIDSupport\n"));
// sanity check
ASSERT(Adapter->SupportedOIDList);
ASSERT(Adapter->OIDHandlerList);
// search for a match on the OID
for(Index = 0; Index < Adapter->NumOIDSupported; Index++)
{
if(Adapter->SupportedOIDList[Index] == Oid)
{
return Adapter->OIDHandlerList[Index];
}
}
return OID_NOT_SUPPORTED;
} // GetOIDSupport
/****************************************************************************/
/* FreeOIDLists */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Free OID and handler lists */
/* */
/* Arguments: */
/* */
/* Adapter - Adapter object */
/* */
/* Return: */
/* */
/* VOID */
/* */
/****************************************************************************/
VOID
FreeOIDLists(IN PRNDISMP_ADAPTER Adapter)
{
UINT Size1, Size2;
PUCHAR Buffer1, Buffer2;
TRACE3(("FreeOIDLists\n"));
// grab the spinlock
NdisAcquireSpinLock(&Adapter->Lock);
Buffer1 = (PUCHAR) Adapter->SupportedOIDList;
Size1 = Adapter->SupportedOIDListSize;
Buffer2 = (PUCHAR) Adapter->OIDHandlerList;
Size2 = Adapter->OIDHandlerListSize;
Adapter->SupportedOIDList = (PUINT) NULL;
Adapter->SupportedOIDListSize = 0;
Adapter->OIDHandlerList = (PUINT) NULL;
Adapter->OIDHandlerListSize = 0;
Adapter->NumOIDSupported = 0;
// release spinlock
NdisReleaseSpinLock(&Adapter->Lock);
if(Buffer1)
MemFree(Buffer1, Size1);
if(Buffer2)
MemFree(Buffer2, Size2);
} // FreeOIDLists
/****************************************************************************/
/* AllocateRequestContext */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Allocate a context structure to keep track of an NDIS request */
/* */
/* Arguments: */
/* */
/* pAdapter - Pointer to our adapter structure */
/* */
/* Return: */
/* */
/* PRNDISMP_REQUEST_CONTEXT */
/* */
/****************************************************************************/
PRNDISMP_REQUEST_CONTEXT
AllocateRequestContext(IN PRNDISMP_ADAPTER pAdapter)
{
NDIS_STATUS Status;
PRNDISMP_REQUEST_CONTEXT pReqContext;
TRACE3(("AllocateRequestContext\n"));
Status = MemAlloc(&pReqContext, sizeof(RNDISMP_REQUEST_CONTEXT));
if (Status != NDIS_STATUS_SUCCESS)
{
pReqContext = NULL;
}
return pReqContext;
} // AllocateRequestContext
/****************************************************************************/
/* FreeRequestContext */
/****************************************************************************/
/* */
/* Routine Description: */
/* */
/* Freeing up miniport resources associated with a request */
/* */
/* Arguments: */
/* */
/* pAdapter - Pointer to our adapter structure */
/* pReqContext - Pointer to request context to be freed */
/* */
/* Return: */
/* */
/* VOID */
/* */
/****************************************************************************/
VOID
FreeRequestContext(IN PRNDISMP_ADAPTER pAdapter,
IN PRNDISMP_REQUEST_CONTEXT pReqContext)
{
TRACE3(("FreeRequestContext\n"));
MemFree(pReqContext, -1);
} // FreeRequestContext
Reference in a new issue Copy permalink