/*************************************************************************** Copyright (c) 1999 Microsoft Corporation Module Name: UTIL.C Abstract: Utility routines for Remote NDIS Miniport driver 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/17/99 : created Author: Tom Green ****************************************************************************/ #include "precomp.h" ULONG MsgFrameAllocs = 0; /****************************************************************************/ /* MemAlloc */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Allocate memory */ /* */ /* Arguments: */ /* */ /* Buffer - pointer to buffer pointer */ /* Length - length of buffer to allocate */ /* */ /* Return: */ /* */ /* NDIS_STATUS */ /* */ /****************************************************************************/ NDIS_STATUS MemAlloc(OUT PVOID *Buffer, IN UINT Length) { NDIS_STATUS Status; TRACE3(("MemAlloc\n")); ASSERT(Length != 0); Status = NdisAllocateMemoryWithTag(Buffer, Length, RNDISMP_TAG_GEN_ALLOC); // zero out allocation if(Status == NDIS_STATUS_SUCCESS) NdisZeroMemory(*Buffer, Length); return Status; } // MemAlloc /****************************************************************************/ /* MemFree */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Free memory */ /* */ /* Arguments: */ /* */ /* Buffer - pointer to buffer */ /* Length - length of buffer to allocate */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID MemFree(IN PVOID Buffer, IN UINT Length) { TRACE3(("MemFree\n")); NdisFreeMemory(Buffer, Length, 0); } // MemFree /****************************************************************************/ /* AddAdapter */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Add an adapter to the list of adapters associated with this driver */ /* */ /* Arguments: */ /* */ /* pAdapter - Adapter object, contains pointer to associated driver block */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID AddAdapter(IN PRNDISMP_ADAPTER pAdapter) { PDRIVER_BLOCK DriverBlock = pAdapter->DriverBlock; TRACE3(("AddpAdapter\n")); CHECK_VALID_ADAPTER(pAdapter); // grab the global spinlock NdisAcquireSpinLock(&RndismpGlobalLock); pAdapter->NextAdapter = DriverBlock->AdapterList; DriverBlock->AdapterList = pAdapter; // keep track of number of adapters associated with this driver block DriverBlock->NumberAdapters++; // release global spinlock NdisReleaseSpinLock(&RndismpGlobalLock); } // AddAdapter /****************************************************************************/ /* RemoveAdapter */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Remove an adapter from the list of adapters associated with this driver */ /* */ /* Arguments: */ /* */ /* pAdapter - Adapter object, contains pointer to associated driver block */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID RemoveAdapter(IN PRNDISMP_ADAPTER pAdapter) { PDRIVER_BLOCK DriverBlock = pAdapter->DriverBlock; TRACE3(("RemoveAdapter\n")); CHECK_VALID_ADAPTER(pAdapter); // remove the adapter from the driver block list of adapters. // grab the global spinlock NdisAcquireSpinLock(&RndismpGlobalLock); // see if it is the first one if (DriverBlock->AdapterList == pAdapter) { DriverBlock->AdapterList = pAdapter->NextAdapter; } // not the first one, so walk the list else { PRNDISMP_ADAPTER * ppAdapter = &DriverBlock->AdapterList; while (*ppAdapter != pAdapter) { ASSERT(*ppAdapter != NULL); ppAdapter = &((*ppAdapter)->NextAdapter); } *ppAdapter = pAdapter->NextAdapter; } // removing this adapter DriverBlock->NumberAdapters--; // release global spinlock NdisReleaseSpinLock(&RndismpGlobalLock); } // RemoveAdapter /****************************************************************************/ /* DeviceObjectToAdapter */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Given a pointer to an FDO, return the corresponding Adapter structure, */ /* if it exists, and the driver block. */ /* */ /* Arguments: */ /* */ /* pDeviceObject - pointer to the device object to search for. */ /* ppAdapter - place to return pointer to the adapter structure. */ /* ppDriverBlock - place to return pointer to driver block. */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID DeviceObjectToAdapterAndDriverBlock(IN PDEVICE_OBJECT pDeviceObject, OUT PRNDISMP_ADAPTER * ppAdapter, OUT PDRIVER_BLOCK * ppDriverBlock) { PDRIVER_BLOCK pDriverBlock; PRNDISMP_ADAPTER pAdapter; pAdapter = NULL; pDriverBlock = DeviceObjectToDriverBlock(&RndismpMiniportBlockListHead, pDeviceObject); if (pDriverBlock != NULL) { NdisAcquireSpinLock(&RndismpGlobalLock); for (pAdapter = pDriverBlock->AdapterList; pAdapter != NULL; pAdapter = pAdapter->NextAdapter) { if (pAdapter->pDeviceObject == pDeviceObject) { break; } } NdisReleaseSpinLock(&RndismpGlobalLock); } *ppAdapter = pAdapter; *ppDriverBlock = pDriverBlock; } // DeviceObjectToAdapter /****************************************************************************/ /* AddDriverBlock */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Add driver block to list of drivers (microports) associated with this */ /* driver */ /* */ /* Arguments: */ /* */ /* Head - head of list */ /* Item - driver block to add to list */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID AddDriverBlock(IN PDRIVER_BLOCK Head, IN PDRIVER_BLOCK Item) { TRACE3(("AddDriverBlock\n")); CHECK_VALID_BLOCK(Item); // first time through, so allocate global spinlock if(!RndismpNumMicroports) NdisAllocateSpinLock(&RndismpGlobalLock); // grab the global spinlock NdisAcquireSpinLock(&RndismpGlobalLock); // Link the driver block on the global list of driver blocks Item->NextDriverBlock = Head->NextDriverBlock; Head->NextDriverBlock = Item; // keep track of how many microports we support so we can free // global resources RndismpNumMicroports++; // release global spinlock NdisReleaseSpinLock(&RndismpGlobalLock); } // AddDriverBlock /****************************************************************************/ /* RemoveDriverBlock */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Remove driver block from list of drivers (microports) associated with */ /* this driver */ /* */ /* Arguments: */ /* */ /* Head - head of list */ /* Item - driver block to remove from list */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID RemoveDriverBlock(IN PDRIVER_BLOCK BlockHead, IN PDRIVER_BLOCK Item) { UINT NumMicroports; PDRIVER_BLOCK Head = BlockHead; TRACE1(("RemoveDriverBlock\n")); CHECK_VALID_BLOCK(Item); // grab the global spinlock NdisAcquireSpinLock(&RndismpGlobalLock); // Remove the driver block from the global list of driver blocks while(Head->NextDriverBlock != Item) { Head = Head->NextDriverBlock; // make sure this is valid if(!Head) break; } if(Head) Head->NextDriverBlock = Head->NextDriverBlock->NextDriverBlock; // keep track of how many microports we support so we can free // global resources RndismpNumMicroports--; NumMicroports = RndismpNumMicroports; // release global spinlock NdisReleaseSpinLock(&RndismpGlobalLock); // see if we need to free global spinlock if(!RndismpNumMicroports) NdisFreeSpinLock(&RndismpGlobalLock); ASSERT(Head); } // RemoveDriverBlock /****************************************************************************/ /* DeviceObjectToDriverBlock */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Get driver block pointer associated with the PDO passed in */ /* */ /* Arguments: */ /* */ /* Head - head of driver block list */ /* DeviceObject - device object we want to get associated driver block for */ /* */ /* Return: */ /* */ /* PDRIVER_BLOCK */ /* */ /****************************************************************************/ PDRIVER_BLOCK DeviceObjectToDriverBlock(IN PDRIVER_BLOCK Head, IN PDEVICE_OBJECT DeviceObject) { PDRIVER_OBJECT DriverObject; TRACE3(("DeviceObjectToDriverBlock\n")); // grab the global spinlock NdisAcquireSpinLock(&RndismpGlobalLock); // get the driver object for this adapter DriverObject = DeviceObjectToDriverObject(DeviceObject); Head = Head->NextDriverBlock; // walk the list of driver blocks to find a match with driver object while(Head->DriverObject != DriverObject) { Head = Head->NextDriverBlock; // break out if we are at the end of the list if(!Head) break; } // release global spinlock NdisReleaseSpinLock(&RndismpGlobalLock); CHECK_VALID_BLOCK(Head); return Head; } // DeviceObjectToDriverBlock /****************************************************************************/ /* DriverObjectToDriverBlock */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Get driver block pointer associated with the Driver Object passed in */ /* */ /* Arguments: */ /* */ /* Head - head of driver block list */ /* DriverObject - Driver object we want to get associated driver block for */ /* */ /* Return: */ /* */ /* PDRIVER_BLOCK */ /* */ /****************************************************************************/ PDRIVER_BLOCK DriverObjectToDriverBlock(IN PDRIVER_BLOCK Head, IN PDRIVER_OBJECT DriverObject) { TRACE3(("DriverObjectToDriverBlock\n")); // grab the global spinlock NdisAcquireSpinLock(&RndismpGlobalLock); Head = Head->NextDriverBlock; // walk the list of driver blocks to find a match with driver object while(Head->DriverObject != DriverObject) { Head = Head->NextDriverBlock; // break out if we are at the end of the list if(!Head) break; } // release global spinlock NdisReleaseSpinLock(&RndismpGlobalLock); CHECK_VALID_BLOCK(Head); return Head; } // DriverObjectToDriverBlock /****************************************************************************/ /* AllocateMsgFrame */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Allocate a frame that holds context about a message we are about to */ /* send. */ /* */ /* Arguments: */ /* */ /* pAdapter - Adapter object */ /* */ /* Return: */ /* */ /* PRNDISMP_MESSAGE_FRAME */ /* */ /****************************************************************************/ PRNDISMP_MESSAGE_FRAME AllocateMsgFrame(IN PRNDISMP_ADAPTER pAdapter) { PRNDISMP_MESSAGE_FRAME pMsgFrame; #ifndef DONT_USE_LOOKASIDE_LIST pMsgFrame = (PRNDISMP_MESSAGE_FRAME) NdisAllocateFromNPagedLookasideList(&pAdapter->MsgFramePool); #else { NDIS_STATUS Status; Status = MemAlloc(&pMsgFrame, sizeof(RNDISMP_MESSAGE_FRAME)); if (Status != NDIS_STATUS_SUCCESS) { pMsgFrame = NULL; } } #endif // DONT_USE_LOOKASIDE_LIST if (pMsgFrame) { NdisZeroMemory(pMsgFrame, sizeof(*pMsgFrame)); pMsgFrame->pAdapter = pAdapter; pMsgFrame->RequestId = NdisInterlockedIncrement(&pAdapter->RequestId); pMsgFrame->Signature = FRAME_SIGNATURE; pMsgFrame->RefCount = 1; NdisInterlockedIncrement(&MsgFrameAllocs); } #if DBG else { TRACE1(("AllocateMsgFrame: pAdapter %x, MsgFramePool at %x, alloc failed, count %d\n", pAdapter, &pAdapter->MsgFramePool, MsgFrameAllocs)); DbgBreakPoint(); } #endif // DBG return (pMsgFrame); } /****************************************************************************/ /* DereferenceMsgFrame */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Free a message frame and any associated resources. */ /* */ /* Arguments: */ /* */ /* Frame - pointer to frame */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID DereferenceMsgFrame(IN PRNDISMP_MESSAGE_FRAME pMsgFrame) { PRNDISMP_ADAPTER pAdapter; PMDL pMdl; PUCHAR pMessage; CHECK_VALID_FRAME(pMsgFrame); if (NdisInterlockedDecrement(&pMsgFrame->RefCount) == 0) { // // Mess up the contents slightly to catch bugs resulting from // improper reuse of this frame after it is freed. // pMsgFrame->Signature++; pMdl = pMsgFrame->pMessageMdl; pMsgFrame->pMessageMdl = NULL; if (pMdl) { pMessage = MmGetMdlVirtualAddress(pMdl); } else { pMessage = NULL; } if (pMessage) { MemFree(pMessage, -1); IoFreeMdl(pMdl); } pAdapter = pMsgFrame->pAdapter; #ifndef DONT_USE_LOOKASIDE_LIST NdisFreeToNPagedLookasideList(&pAdapter->MsgFramePool, pMsgFrame); #else MemFree(pMsgFrame, sizeof(RNDISMP_MESSAGE_FRAME)); #endif NdisInterlockedDecrement(&MsgFrameAllocs); } } // DereferenceMsgFrame /****************************************************************************/ /* ReferenceMsgFrame */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Add a ref count to a message frame */ /* */ /* Arguments: */ /* */ /* Frame - pointer to frame */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID ReferenceMsgFrame(IN PRNDISMP_MESSAGE_FRAME pMsgFrame) { NdisInterlockedIncrement(&pMsgFrame->RefCount); } /****************************************************************************/ /* KeepAliveTimerHandler */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Timer that keeps tabs on messages coming up from the device and */ /* sends a "KeepAlive" message if the device has been inactive too long */ /* */ /* Arguments: */ /* */ /* SystemSpecific1 - Don't care */ /* Context - pAdapter object */ /* SystemSpecific2 - Don't care */ /* SystemSpecific3 - Don't care */ /* */ /* Return: */ /* */ /* PNDIS_PACKET */ /* */ /****************************************************************************/ VOID KeepAliveTimerHandler(IN PVOID SystemSpecific1, IN PVOID Context, IN PVOID SystemSpecific2, IN PVOID SystemSpecific3) { PRNDISMP_ADAPTER pAdapter; PRNDISMP_MESSAGE_FRAME pMsgFrame; ULONG CurrentTime; // get adapter context pAdapter = PRNDISMP_ADAPTER_FROM_CONTEXT_HANDLE(Context); TRACE2(("KeepAliveTimerHandler\n")); do { // get current tick (in milliseconds) NdisGetSystemUpTime(&CurrentTime); // check and see if too much time has elapsed since we // got the last message from the device RNDISMP_ACQUIRE_ADAPTER_LOCK(pAdapter); if (((CurrentTime - pAdapter->LastMessageFromDevice) > KEEP_ALIVE_TIMER)) { // see if we have a keep alive message pending, so let's bong this if (pAdapter->KeepAliveMessagePending) { TRACE1(("KeepAliveTimer: Adapter %x, message pending\n", pAdapter)); // indicate later from check for hang handler pAdapter->NeedReset = TRUE; RNDISMP_RELEASE_ADAPTER_LOCK(pAdapter); RNDISMP_INCR_STAT(pAdapter, KeepAliveTimeout); break; } RNDISMP_RELEASE_ADAPTER_LOCK(pAdapter); // too much time has elapsed, send down a keep alive message pMsgFrame = BuildRndisMessageCommon(pAdapter, NULL, REMOTE_NDIS_KEEPALIVE_MSG, 0, NULL, 0); if (pMsgFrame) { RNDISMP_ACQUIRE_ADAPTER_LOCK(pAdapter); pAdapter->KeepAliveMessagePending = TRUE; pAdapter->KeepAliveMessagePendingId = pMsgFrame->RequestId; RNDISMP_RELEASE_ADAPTER_LOCK(pAdapter); // send the message to the microport RNDISMP_SEND_TO_MICROPORT(pAdapter, pMsgFrame, FALSE, CompleteSendKeepAlive); } } else { RNDISMP_RELEASE_ADAPTER_LOCK(pAdapter); } } while (FALSE); // see if the timer was cancelled somewhere if (!pAdapter->TimerCancelled) { // restart timer NdisSetTimer(&pAdapter->KeepAliveTimer, KEEP_ALIVE_TIMER / 2); } } // KeepAliveTimerHandler /****************************************************************************/ /* CompleteSendKeepAlive */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Callback routine to handle completion of send by the microport, for */ /* a keepalive message. */ /* */ /* Arguments: */ /* */ /* pMsgFrame - Pointer to message frame describing the message */ /* SendStatus - Status returned by microport */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID CompleteSendKeepAlive(IN PRNDISMP_MESSAGE_FRAME pMsgFrame, IN NDIS_STATUS SendStatus) { PRNDISMP_ADAPTER pAdapter; pAdapter = pMsgFrame->pAdapter; DereferenceMsgFrame(pMsgFrame); if (SendStatus != NDIS_STATUS_SUCCESS) { TRACE1(("KeepAlive send failure %x on Adapter %x\n", SendStatus, pAdapter)); RNDISMP_ACQUIRE_ADAPTER_LOCK(pAdapter); pAdapter->KeepAliveMessagePending = FALSE; pAdapter->NeedReset = FALSE; RNDISMP_RELEASE_ADAPTER_LOCK(pAdapter); } } // CompleteSendKeepAlive /****************************************************************************/ /* BuildRndisMessageCommon */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Allocate resources for meesage and frame and build RNDIS message */ /* */ /* Arguments: */ /* */ /* pAdapter - adapter object */ /* pVc - optionally, VC on which this message is sent. */ /* NdisMessageType - RNDIS message type */ /* Oid - the NDIS_OID to process. */ /* InformationBuffer - Holds the data to be set. */ /* InformationBufferLength - The length of InformationBuffer. */ /* */ /* Return: */ /* */ /* PRNDISMP_MESSAGE_FRAME */ /* */ /****************************************************************************/ PRNDISMP_MESSAGE_FRAME BuildRndisMessageCommon(IN PRNDISMP_ADAPTER pAdapter, IN PRNDISMP_VC pVc OPTIONAL, IN UINT NdisMessageType, IN NDIS_OID Oid, IN PVOID InformationBuffer, IN ULONG InformationBufferLength) { PRNDIS_MESSAGE pMessage; UINT MessageSize; PRNDISMP_MESSAGE_FRAME pMsgFrame; TRACE2(("BuildRndisMessageCommon\n")); pMsgFrame = NULL; switch(NdisMessageType) { case REMOTE_NDIS_INITIALIZE_MSG: { PRNDIS_INITIALIZE_REQUEST pInitRequest; MessageSize = RNDIS_MESSAGE_SIZE(RNDIS_INITIALIZE_REQUEST); // get a message and request frame pMsgFrame = AllocateMessageAndFrame(pAdapter, MessageSize); if (pMsgFrame == NULL) { break; } pMessage = RNDISMP_GET_MSG_FROM_FRAME(pMsgFrame); pMessage->NdisMessageType = NdisMessageType; pMsgFrame->NdisMessageType = NdisMessageType; TRACE1(("RNDISMP: Init Req message %x, Type %d, Length %d, MaxRcv %d\n", pMessage, pMessage->NdisMessageType, pMessage->MessageLength, pAdapter->MaxReceiveSize)); pInitRequest = &pMessage->Message.InitializeRequest; pInitRequest->RequestId = pMsgFrame->RequestId; pInitRequest->MajorVersion = RNDIS_MAJOR_VERSION; pInitRequest->MinorVersion = RNDIS_MINOR_VERSION; pInitRequest->MaxTransferSize = pAdapter->MaxReceiveSize; break; } case REMOTE_NDIS_HALT_MSG: { PRNDIS_HALT_REQUEST pHaltRequest; MessageSize = RNDIS_MESSAGE_SIZE(RNDIS_HALT_REQUEST); // get a message and request frame pMsgFrame = AllocateMessageAndFrame(pAdapter, MessageSize); if (pMsgFrame == NULL) { break; } pMessage = RNDISMP_GET_MSG_FROM_FRAME(pMsgFrame); pMessage->NdisMessageType = NdisMessageType; pMsgFrame->NdisMessageType = NdisMessageType; pHaltRequest = &pMessage->Message.HaltRequest; pHaltRequest->RequestId = pMsgFrame->RequestId; break; } case REMOTE_NDIS_QUERY_MSG: { PRNDIS_QUERY_REQUEST pQueryRequest; MessageSize = RNDIS_MESSAGE_SIZE(RNDIS_QUERY_REQUEST) + InformationBufferLength; // get a message and request frame pMsgFrame = AllocateMessageAndFrame(pAdapter, MessageSize); if (pMsgFrame == NULL) { break; } pMessage = RNDISMP_GET_MSG_FROM_FRAME(pMsgFrame); pMessage->NdisMessageType = NdisMessageType; pMsgFrame->NdisMessageType = NdisMessageType; pQueryRequest = &pMessage->Message.QueryRequest; pQueryRequest->RequestId = pMsgFrame->RequestId; pQueryRequest->Oid = Oid; pQueryRequest->InformationBufferLength = InformationBufferLength; pQueryRequest->InformationBufferOffset = sizeof(RNDIS_QUERY_REQUEST); if (pVc == NULL) { pQueryRequest->DeviceVcHandle = NULL_DEVICE_CONTEXT; } else { pQueryRequest->DeviceVcHandle = pVc->DeviceVcContext; } TRACE2(("Query OID %x, Len %d, RequestId %08X\n", Oid, InformationBufferLength, pQueryRequest->RequestId)); // copy information buffer RNDISMP_MOVE_MEM(RNDISMP_GET_INFO_BUFFER_FROM_QUERY_MSG(pQueryRequest), InformationBuffer, InformationBufferLength); break; } case REMOTE_NDIS_SET_MSG: { PRNDIS_SET_REQUEST pSetRequest; MessageSize = RNDIS_MESSAGE_SIZE(RNDIS_SET_REQUEST) + InformationBufferLength; // get a message and request frame pMsgFrame = AllocateMessageAndFrame(pAdapter, MessageSize); if (pMsgFrame == NULL) { break; } pMessage = RNDISMP_GET_MSG_FROM_FRAME(pMsgFrame); pMessage->NdisMessageType = NdisMessageType; pMsgFrame->NdisMessageType = NdisMessageType; pSetRequest = &pMessage->Message.SetRequest; pSetRequest->RequestId = pMsgFrame->RequestId; pSetRequest->Oid = Oid; pSetRequest->InformationBufferLength = InformationBufferLength; pSetRequest->InformationBufferOffset = sizeof(RNDIS_SET_REQUEST); if (pVc == NULL) { pSetRequest->DeviceVcHandle = NULL_DEVICE_CONTEXT; } else { pSetRequest->DeviceVcHandle = pVc->DeviceVcContext; } // copy information buffer RNDISMP_MOVE_MEM(RNDISMP_GET_INFO_BUFFER_FROM_QUERY_MSG(pSetRequest), InformationBuffer, InformationBufferLength); break; } case REMOTE_NDIS_RESET_MSG: { PRNDIS_RESET_REQUEST pResetRequest; MessageSize = RNDIS_MESSAGE_SIZE(RNDIS_RESET_REQUEST); // get a message and request frame pMsgFrame = AllocateMessageAndFrame(pAdapter, MessageSize); if (pMsgFrame == NULL) { break; } pMessage = RNDISMP_GET_MSG_FROM_FRAME(pMsgFrame); pMessage->NdisMessageType = NdisMessageType; pMsgFrame->NdisMessageType = NdisMessageType; pResetRequest = &pMessage->Message.ResetRequest; pResetRequest->Reserved = 0; break; } case REMOTE_NDIS_KEEPALIVE_MSG: { PRNDIS_KEEPALIVE_REQUEST pKeepAliveRequest; MessageSize = RNDIS_MESSAGE_SIZE(RNDIS_KEEPALIVE_REQUEST); // get a message and request frame pMsgFrame = AllocateMessageAndFrame(pAdapter, MessageSize); if (pMsgFrame == NULL) { break; } pMessage = RNDISMP_GET_MSG_FROM_FRAME(pMsgFrame); pMessage->NdisMessageType = NdisMessageType; pMsgFrame->NdisMessageType = NdisMessageType; pKeepAliveRequest = &pMessage->Message.KeepaliveRequest; pKeepAliveRequest->RequestId = pMsgFrame->RequestId; break; } case REMOTE_NDIS_KEEPALIVE_CMPLT: { PRNDIS_KEEPALIVE_COMPLETE pKeepAliveComplete; MessageSize = RNDIS_MESSAGE_SIZE(RNDIS_KEEPALIVE_COMPLETE); // get a message and request frame pMsgFrame = AllocateMessageAndFrame(pAdapter, MessageSize); if (pMsgFrame == NULL) { break; } pMessage = RNDISMP_GET_MSG_FROM_FRAME(pMsgFrame); pMessage->NdisMessageType = NdisMessageType; pMsgFrame->NdisMessageType = NdisMessageType; pKeepAliveComplete = &pMessage->Message.KeepaliveComplete; pKeepAliveComplete->RequestId = *(RNDIS_REQUEST_ID *)InformationBuffer; pKeepAliveComplete->Status = NDIS_STATUS_SUCCESS; break; } default: TRACE2(("Invalid NdisMessageType (%08X)\n", NdisMessageType)); ASSERT(FALSE); break; } return pMsgFrame; } // BuildRndisMessageCommon /****************************************************************************/ /* AllocateMessageAndFrame */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Allocate a message and frame for an RNDIS message */ /* */ /* Arguments: */ /* */ /* pAdapter - pAdapter object */ /* MessageSize - size of RNDIS message */ /* */ /* Return: */ /* */ /* PRNDISMP_MESSAGE_FRAME */ /* */ /****************************************************************************/ PRNDISMP_MESSAGE_FRAME AllocateMessageAndFrame(IN PRNDISMP_ADAPTER pAdapter, IN UINT MessageSize) { PRNDIS_MESSAGE pMessage = NULL; PRNDISMP_MESSAGE_FRAME pMsgFrame = NULL; NDIS_STATUS Status = NDIS_STATUS_SUCCESS; PMDL pMdl = NULL; TRACE3(("AllocateMessageAndFrame\n")); do { // allocate a buffer for RNDIS message Status = MemAlloc(&pMessage, MessageSize); // see if we got our buffer if (Status != NDIS_STATUS_SUCCESS) { break; } // allocate an MDL to describe this message. pMdl = IoAllocateMdl( pMessage, MessageSize, FALSE, FALSE, NULL); if (pMdl == NULL) { Status = NDIS_STATUS_RESOURCES; break; } MmBuildMdlForNonPagedPool(pMdl); // got the message buffer, now allocate a frame pMsgFrame = AllocateMsgFrame(pAdapter); if (pMsgFrame == NULL) { Status = NDIS_STATUS_RESOURCES; break; } // got everything, so fill in some frame things pMsgFrame->pMessageMdl = pMdl; pMessage->MessageLength = MessageSize; } while (FALSE); if (Status != NDIS_STATUS_SUCCESS) { if (pMdl) { IoFreeMdl(pMdl); } if (pMessage) { MemFree(pMessage, MessageSize); } } return pMsgFrame; } // AllocateMessageAndFrame /****************************************************************************/ /* FreeAdapter */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Free all memory allocations to do with an Adapter structure */ /* */ /* Arguments: */ /* */ /* pAdapter - pointer to the adapter to be freed. */ /* */ /* Return: */ /* */ /* VOID */ /****************************************************************************/ VOID FreeAdapter(IN PRNDISMP_ADAPTER Adapter) { // free up transport resources FreeTransportResources(Adapter); if (Adapter->DriverOIDList) { MemFree(Adapter->DriverOIDList, RndismpSupportedOidsNum*sizeof(NDIS_OID)); } if (Adapter->FriendlyNameAnsi.Buffer) { MemFree(Adapter->FriendlyNameAnsi.Buffer, Adapter->FriendlyNameAnsi.MaximumLength); } if (Adapter->FriendlyNameUnicode.Buffer) { MemFree(Adapter->FriendlyNameUnicode.Buffer, Adapter->FriendlyNameUnicode.MaximumLength); } #if DBG if (Adapter->pSendLogBuffer) { MemFree(Adapter->pSendLogBuffer, Adapter->LogBufferSize); Adapter->pSendLogBuffer = NULL; } #endif // DBG MemFree(Adapter, sizeof(RNDISMP_ADAPTER)); } /****************************************************************************/ /* AllocateVc */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Allocate a VC structure */ /* */ /* Arguments: */ /* */ /* pAdapter - adapter object */ /* */ /* Return: */ /* */ /* PRNDISMP_VC */ /* */ /****************************************************************************/ PRNDISMP_VC AllocateVc(IN PRNDISMP_ADAPTER pAdapter) { PRNDISMP_VC pVc; NDIS_STATUS Status; Status = MemAlloc(&pVc, sizeof(RNDISMP_VC)); if (Status == NDIS_STATUS_SUCCESS) { pVc->pAdapter = pAdapter; pVc->VcState = RNDISMP_VC_ALLOCATED; pVc->CallState = RNDISMP_CALL_IDLE; pVc->RefCount = 0; RNDISMP_INIT_LOCK(&pVc->Lock); EnterVcIntoHashTable(pAdapter, pVc); } else { pVc = NULL; } return pVc; } /****************************************************************************/ /* DeallocateVc */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Deallocate a VC structure. */ /* */ /* Arguments: */ /* */ /* pVc - Pointer to VC being deallocated. */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID DeallocateVc(IN PRNDISMP_VC pVc) { ASSERT(pVc->RefCount == 0); ASSERT(pVc->VcState == RNDISMP_VC_ALLOCATED); RemoveVcFromHashTable(pVc->pAdapter, pVc); MemFree(pVc, sizeof(RNDISMP_VC)); } /****************************************************************************/ /* LookupVcId */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Search for a VC structure that matches a given VC Id. */ /* If we find the VC, we reference it and return it. */ /* */ /* Arguments: */ /* */ /* Adapter - adapter object */ /* VcId - Id to search for */ /* */ /* Notes: */ /* */ /* This routine is called with the adapter lock held! */ /* */ /* Return: */ /* */ /* PRNDISMP_VC - pointer to VC, if one exists */ /* */ /****************************************************************************/ PRNDISMP_VC LookupVcId(IN PRNDISMP_ADAPTER pAdapter, IN UINT32 VcId) { PLIST_ENTRY pVcEnt; PRNDISMP_VC pVc; ULONG VcIdHash; PRNDISMP_VC_HASH_TABLE pVcHashTable; BOOLEAN bFound = FALSE; VcIdHash = RNDISMP_HASH_VCID(VcId); pVcHashTable = pAdapter->pVcHashTable; do { if (pVcHashTable == NULL) { pVc = NULL; break; } for (pVcEnt = pVcHashTable->HashEntry[VcIdHash].Flink; pVcEnt != &pVcHashTable->HashEntry[VcIdHash]; pVcEnt = pVcEnt->Flink) { pVc = CONTAINING_RECORD(pVcEnt, RNDISMP_VC, VcList); if (pVc->VcId == VcId) { bFound = TRUE; RNDISMP_REF_VC(pVc); break; } } if (!bFound) { pVc = NULL; } } while (FALSE); return pVc; } /****************************************************************************/ /* EnterVcIntoHashTable */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Link a VC into the hash table after assigning it a VC Id. */ /* */ /* Arguments: */ /* */ /* pAdapter - adapter object */ /* pVc - VC to link to the above adapter */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID EnterVcIntoHashTable(IN PRNDISMP_ADAPTER pAdapter, IN PRNDISMP_VC pVc) { PRNDISMP_VC pExistingVc; PRNDISMP_VC_HASH_TABLE pVcHashTable; UINT32 VcId; ULONG VcIdHash; RNDISMP_ACQUIRE_ADAPTER_LOCK(pAdapter); // // We pick the next sequentially higher Vc Id value for this VC, // but check to see if it is already in use... // do { pAdapter->LastVcId++; // Never allocate the value 0. if (pAdapter->LastVcId == 0) { pAdapter->LastVcId++; } VcId = pAdapter->LastVcId; pExistingVc = LookupVcId(pAdapter, VcId); } while (pExistingVc != NULL); pVcHashTable = pAdapter->pVcHashTable; pVc->VcId = VcId; VcIdHash = RNDISMP_HASH_VCID(VcId); InsertTailList(&pVcHashTable->HashEntry[VcIdHash], &pVc->VcList); pVcHashTable->NumEntries++; RNDISMP_RELEASE_ADAPTER_LOCK(pAdapter); } /****************************************************************************/ /* RemoveVcFromHashTable */ /****************************************************************************/ /* */ /* Routine Description: */ /* */ /* Unlink a VC from the adapter hash table. */ /* */ /* Arguments: */ /* */ /* pAdapter - adapter object */ /* pVc - VC to be unlinked. */ /* */ /* Return: */ /* */ /* VOID */ /* */ /****************************************************************************/ VOID RemoveVcFromHashTable(IN PRNDISMP_ADAPTER pAdapter, IN PRNDISMP_VC pVc) { RNDISMP_ACQUIRE_ADAPTER_LOCK(pAdapter); RemoveEntryList(&pVc->VcList); pAdapter->pVcHashTable->NumEntries--; RNDISMP_RELEASE_ADAPTER_LOCK(pAdapter); }