/*++
Copyright (c) 1990-1995 Microsoft Corporation
Module Name:
Ndiswan.c
Abstract:
This is the initialization file for the NdisWan driver. This driver
is a shim between the protocols, where it conforms to the NDIS 3.1
Miniport interface spec, and the WAN Miniport drivers, where it exports
the WAN Extensions for Miniports (it looks like a protocol to the WAN
Miniport drivers).
Author:
Tony Bell (TonyBe) June 06, 1995
Environment:
Kernel Mode
Revision History:
TonyBe 06/06/95 Created
--*/
#include "wan.h"
#include "tcpip.h"
#include "vjslip.h"
//
// Local function prototypes
//
NDIS_STATUS
NdisWanCreateLinkCB(
OUT PLINKCB *LinkCB
);
VOID
NdisWanInitLinkCB(
IN PLINKCB *LinkCB,
IN PWAN_ADAPTERCB WanAdapterCB,
IN ULONG SendWindow
);
VOID
NdisWanDestroyLinkCB(
IN PLINKCB LinkCB
);
NDIS_STATUS
NdisWanCreateBundleCB(
OUT PBUNDLECB *BundleCB
);
VOID
NdisWanInitBundleCB(
IN PBUNDLECB BundleCB
);
VOID
NdisWanDestroyBundleCB(
IN PBUNDLECB BundleCB
);
NDIS_STATUS
NdisWanCreateProtocolCB(
OUT PPROTOCOLCB *ProtocolCB,
IN USHORT usProtocolType,
IN USHORT usBindingNameLength,
IN PWSTR BindingName,
IN ULONG ulBufferLength,
IN PUCHAR Buffer
);
//VOID
//NdisWanInitProtocolCB(
// IN PPROTOCOLCB ProtocolCB,
// IN ULONG ulBufferLength,
// IN PUCHAR Buffer,
// IN USHORT usProtocolType
// );
VOID
NdisWanDestroyProtocolCB(
IN PPROTOCOLCB ProtocolCB
);
NDIS_STATUS
NdisWanAllocateSendResources(
IN PLINKCB LinkCB,
IN ULONG SendWindow
);
VOID
NdisWanFreeSendResources(
IN PLINKCB LinkCB
);
//
// End local function prototypes
//
NDIS_STATUS
NdisWanCreateAdapterCB(
OUT PADAPTERCB *pAdapterCB,
IN PNDIS_STRING AdapterName
)
/*++
Routine Name:
NdisWanCreateAdapterCB
Routine Description:
This routine creates and initializes an AdapterCB
Arguments:
pAdapterCB - Pointer to a pointer to the AdapterCB that was created
Return Values:
NDIS_STATUS_SUCCESS
NDIS_STATUS_RESOURCES
--*/
{
PADAPTERCB LocalAdapterCB;
ULONG ulAllocationSize, i;
PDEFERRED_DESC FreeDesc;
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("NdisWanCreateAdapterCB: Enter"));
//
// Allocate and zero out the memory block
//
ulAllocationSize = sizeof(ADAPTERCB) + 20*sizeof(DEFERRED_DESC);
NdisWanAllocateMemory(&LocalAdapterCB, ulAllocationSize);
if (LocalAdapterCB == NULL) {
return (NDIS_STATUS_RESOURCES);
}
//
// setup the new control block
//
LocalAdapterCB->ulAllocationSize = ulAllocationSize;
NdisAllocateSpinLock(&LocalAdapterCB->Lock);
#ifdef MINIPORT_NAME
// NdisWanStringToNdisString(&LocalAdapterCB->AdapterName, AdapterName->Buffer);
NdisWanAllocateAdapterName(&LocalAdapterCB->AdapterName, AdapterName);
#endif
//
// Setup free deferred desc list
//
FreeDesc = (PDEFERRED_DESC)((PUCHAR)LocalAdapterCB + sizeof(ADAPTERCB));
for (i = 0; i < 20; i++) {
InsertHeadDeferredQueue(&LocalAdapterCB->FreeDeferredQueue, FreeDesc);
(PUCHAR)FreeDesc += sizeof(DEFERRED_DESC);
}
#if DBG
InitializeListHead(&LocalAdapterCB->DbgNdisPacketList);
#endif
//
// Add to global list
//
InsertTailGlobalList(AdapterCBList, &(LocalAdapterCB->Linkage));
*pAdapterCB = LocalAdapterCB;
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("%ls AdapterCB: 0x%x, Number: %d",
LocalAdapterCB->AdapterName.Buffer, *pAdapterCB, AdapterCBList.ulCount));
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("NdisWanCreateAdapterCB: Exit"));
return (NDIS_STATUS_SUCCESS);
}
VOID
NdisWanDestroyAdapterCB(
IN PADAPTERCB pAdapterCB
)
/*++
Routine Name:
NdisWanDestroyAdapterCB
Routine Description:
This destroys an AdapterCB
Arguments:
pAdapterCB - Pointer to to the AdapterCB that is being destroyed
Return Values:
None
--*/
{
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("NdisWanDestroyAdapterCB: Enter"));
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("AdapterCB: 0x%x", pAdapterCB));
#ifdef MINIPORT_NAME
NdisWanFreeNdisString(&pAdapterCB->AdapterName);
#endif
NdisFreeSpinLock(&pAdapterCB->Lock);
NdisWanFreeMemory(pAdapterCB);
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("NdisWanDestroyAdapterCB: Exit"));
}
NDIS_STATUS
NdisWanCreateWanAdapterCB(
IN PWSTR BindName
)
/*++
Routine Name:
NdisWanCreateWanAdapterCB
Routine Description:
This routine creates and initializes a WanAdapterCB
Arguments:
BindName - Pointer to an NDIS_STRING that has the name of the WAN Miniport
that will be used in the NdisOpenAdapter call when we bind to
the WAN Miniport.
Return Values:
NDIS_STATUS_SUCCESS
NDIS_STATUS_RESOURCES
--*/
{
PWAN_ADAPTERCB pWanAdapterCB;
ULONG ulAllocationSize;
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("NdisWanCreateWanAdapterCB: Enter"));
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("BindName: %ls", BindName));
//
// Allocate memory for WanAdapterCB
//
ulAllocationSize = sizeof(WAN_ADAPTERCB);
NdisWanAllocateMemory(&pWanAdapterCB, ulAllocationSize);
if (pWanAdapterCB == NULL) {
return (NDIS_STATUS_RESOURCES);
}
//
// Init WanAdapterCB
//
//
// Setup new control block
//
pWanAdapterCB->ulAllocationSize = ulAllocationSize;
NdisWanStringToNdisString(&(pWanAdapterCB->MiniportName), BindName);
NdisAllocateSpinLock(&pWanAdapterCB->Lock);
InitializeListHead(&pWanAdapterCB->FreeLinkCBList);
#if DBG
InitializeListHead(&pWanAdapterCB->DbgWanPacketList);
#endif
//
// Put WanAdapterCB on global list
//
InsertTailGlobalList(WanAdapterCBList, &(pWanAdapterCB->Linkage));
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("WanMiniport %ls WanAdapterCB: 0x%x",
pWanAdapterCB->MiniportName.Buffer, pWanAdapterCB));
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("NdisWanCreateWanAdapterCB: Exit"));
return(NDIS_STATUS_SUCCESS);
}
VOID
NdisWanDestroyWanAdapterCB(
IN PWAN_ADAPTERCB pWanAdapterCB
)
/*++
Routine Name:
NdisWanDestroyWanAdapterCB
Routine Description:
This routine destroys a WanAdapterCB
Arguments:
pWanAdapterCB - Pointer to the WanAdapterCB that is being destroyed
Return Values:
None
--*/
{
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("NdisWanDestroyWanAdapterCB: Enter - WanAdapterCB: 0x%4.4x", pWanAdapterCB));
//
// Free the memory allocated for the NDIS_STRING
//
NdisWanFreeNdisString(&pWanAdapterCB->MiniportName);
NdisFreeSpinLock(&pWanAdapter->Lock);
//
// Free the memory allocated for the control block
//
NdisWanFreeMemory(pWanAdapterCB);
NdisWanDbgOut(DBG_TRACE, DBG_MEMORY, ("NdisWanDestroyWanAdapterCB: Exit"));
}
VOID
NdisWanGetProtocolCB(
OUT PPROTOCOLCB *ProtocolCB,
IN USHORT usProtocolType,
IN USHORT usBindingNameLength,
IN PWSTR BindingName,
IN ULONG ulBufferLength,
IN PUCHAR Buffer
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
*ProtocolCB = NULL;
// NdisAcquireSpinLock(&(FreeProtocolCBList.Lock));
//
// See if there are any ProtocolCB's available on the free list.
// If there are not we will need to allocate one.
//
// if (FreeProtocolCBList.ulCount == 0) {
//
// Create ProtocolCB
//
NdisWanCreateProtocolCB(ProtocolCB,
usProtocolType,
usBindingNameLength,
BindingName,
ulBufferLength,
Buffer);
// } else {
//
// Get the ProtocolCB from the free list
//
// *ProtocolCB = (PPROTOCOLCB)RemoveHeadList(&(FreeProtocolCBList.List));
// FreeProtocolCBList.ulCount--;
// }
// NdisReleaseSpinLock(&(FreeProtocolCBList.Lock));
// if (*ProtocolCB != NULL) {
// NdisWanInitProtocolCB(*ProtocolCB,
// ulBufferLength,
// Buffer,
// usProtocolType);
// }
}
NDIS_STATUS
NdisWanCreateProtocolCB(
OUT PPROTOCOLCB *ProtocolCB,
IN USHORT usProtocolType,
IN USHORT usBindingNameLength,
IN PWSTR BindingName,
IN ULONG ulBufferLength,
IN PUCHAR Buffer
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
NDIS_STATUS_SUCCESS - ProtocolCB was allocated and initialized
NDIS_STATUS_RESOURCES - Error allocating memory for ProtocolCB
--*/
{
PPROTOCOLCB LocalProtocolCB = NULL;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
ULONG ulAllocationSize = sizeof(PROTOCOLCB) + ulBufferLength;
PUCHAR AllocatedMemory;
ULONG i;
NdisWanAllocateMemory(&AllocatedMemory, ulAllocationSize);
if (AllocatedMemory != NULL) {
LocalProtocolCB = (PPROTOCOLCB)AllocatedMemory;
LocalProtocolCB->ulAllocationSize = ulAllocationSize;
AllocatedMemory += sizeof(PROTOCOLCB);
LocalProtocolCB->LineUpInfo = AllocatedMemory;
#ifdef BANDWIDTH_ON_DEMAND
//
// Initialize the sample table
//
LocalProtocolCB->SampleTable.ulSampleArraySize = SAMPLE_ARRAY_SIZE;
NdisWanInitWanTime(&LocalProtocolCB->SampleTable.SampleRate, ONE_HUNDRED_MILS);
NdisWanInitWanTime(&LocalProtocolCB->SampleTable.SamplePeriod, ONE_SECOND);
#endif
//
// Copy the bindingname
//
NdisWanStringToNdisString(&LocalProtocolCB->BindingName, BindingName);
//
// Copy over the protocol info
//
LocalProtocolCB->ulLineUpInfoLength = ulBufferLength;
NdisMoveMemory(LocalProtocolCB->LineUpInfo,
Buffer,
ulBufferLength);
//
// Setup the protocol type
//
LocalProtocolCB->usProtocolType = usProtocolType;
//
// Get the PPP protocol value for this protocol type
//
LocalProtocolCB->usPPPProtocolID = GetPPP_ProtocolID(usProtocolType, PROTOCOL_TYPE);
switch (usProtocolType) {
case PROTOCOL_IP:
LocalProtocolCB->NonIdleDetectFunc = IpIsDataFrame;
break;
case PROTOCOL_IPX:
LocalProtocolCB->NonIdleDetectFunc = IpxIsDataFrame;
break;
case PROTOCOL_NBF:
LocalProtocolCB->NonIdleDetectFunc = NbfIsDataFrame;
break;
default:
LocalProtocolCB->NonIdleDetectFunc = NULL;
break;
}
NdisWanGetSystemTime(&LocalProtocolCB->LastRecvNonIdleData);
#ifdef BANDWIDTH_ON_DEMAND
LocalProtocolCB->SampleTable.ulFirstIndex =
LocalProtocolCB->SampleTable.ulCurrentIndex = 0;
NdisZeroMemory(&LocalProtocolCB->SampleTable.SampleArray[0],
sizeof(SEND_SAMPLE) * SAMPLE_ARRAY_SIZE);
#endif // end BANDWIDTH_ON_DEMAND
} else {
Status = NDIS_STATUS_RESOURCES;
NdisWanDbgOut(DBG_CRITICAL_ERROR, DBG_MEMORY, ("Error allocating memory for ProtocolCB, ulAllocationSize: %d",
ulAllocationSize));
}
*ProtocolCB = LocalProtocolCB;
return (Status);
}
//VOID
//NdisWanInitProtocolCB(
// IN PPROTOCOLCB ProtocolCB,
// IN ULONG ulBufferLength,
// IN PUCHAR Buffer,
// IN USHORT usProtocolType
// )
///*++
//
//Routine Name:
//
//Routine Description:
//
//Arguments:
//
//Return Values:
//
//--*/
//{
// //
// // Copy over the protocol info
// //
// ProtocolCB->ulLineUpInfoLength = ulBufferLength;
// NdisMoveMemory(ProtocolCB->LineUpInfo,
// Buffer,
// ulBufferLength);
//
// //
// // Setup the protocol type
// //
// ProtocolCB->usProtocolType = usProtocolType;
//
// //
// // Get the PPP protocol value for this protocol type
// //
// ProtocolCB->usPPPProtocolID = GetPPP_ProtocolID(usProtocolType, PROTOCOL_TYPE);
//
// ProtocolCB->SampleTable.ulFirstIndex =
// ProtocolCB->SampleTable.ulCurrentIndex = 0;
// NdisZeroMemory(&ProtocolCB->SampleTable.SampleArray[0],
// sizeof(SEND_SAMPLE) * SAMPLE_ARRAY_SIZE);
//
//}
VOID
NdisWanReturnProtocolCB(
IN PPROTOCOLCB ProtocolCB
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
// NdisAcquireSpinLock(&(FreeProtocolCBList.Lock));
//
// if (FreeProtocolCBList.ulCount > FreeProtocolCBList.ulMaxCount) {
NdisWanDestroyProtocolCB(ProtocolCB);
// } else {
//
// InsertTailGlobalList(FreeProtocolCBList, &(ProtocolCB->Linkage));
//
// FreeProtocolCBList.ulCount++;
//
// }
//
// NdisReleaseSpinLock(&(FreeProtocolCBList.Lock));
}
VOID
NdisWanDestroyProtocolCB(
IN PPROTOCOLCB ProtocolCB
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
ASSERT(ProtocolCB->HeadNdisPacketQueue == NULL);
ASSERT(ProtocolCB->TailNdisPacketQueue == NULL);
if (ProtocolCB->DeviceName.Length != 0) {
NdisWanFreeNdisString(&ProtocolCB->DeviceName);
}
if (ProtocolCB->BindingName.Length != 0) {
NdisWanFreeNdisString(&ProtocolCB->BindingName);
}
NdisWanFreeMemory(ProtocolCB);
}
VOID
NdisWanGetLinkCB(
OUT PLINKCB *LinkCB,
IN PWAN_ADAPTERCB WanAdapterCB,
IN ULONG SendWindow
)
/*++
Routine Name:
NdisWanGetLinkCB
Routine Description:
This function returns a pointer to a LinkCB. The LinkCB is either retrieved
from the WanAdapters free list or, if this list is empty, it is allocated.
Arguments:
*LinkCB - Pointer to the location to store the pointer to the LinkCB
WanAdapterCB - Pointer to the WanAdapter control block that this Link is
associated with
Return Values:
None
--*/
{
//
// See if we have any free LinkCB's hanging around
// if not we will allocate one
//
NdisAcquireSpinLock(&(WanAdapterCB->Lock));
if (IsListEmpty(&(WanAdapterCB->FreeLinkCBList))) {
//
// Create LinkCB
//
NdisWanCreateLinkCB(LinkCB);
} else {
//
// Get the LinkCB from the free list
//
*LinkCB = (PLINKCB)RemoveHeadList(&(WanAdapterCB->FreeLinkCBList));
}
NdisReleaseSpinLock(&(WanAdapterCB->Lock));
//
// Set the new link state
//
NdisWanInitLinkCB(LinkCB, WanAdapterCB, SendWindow);
}
NDIS_STATUS
NdisWanCreateLinkCB(
OUT PLINKCB *LinkCB
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
PLINKCB LocalLinkCB = NULL;
ULONG ulAllocationSize, n;
PUCHAR AllocatedMemory = NULL;
//
// Figure out how much we need to allocate
//
ulAllocationSize = sizeof(LINKCB);
//
// Allocate the memory for the LinkCB and it's WAN PACKETS
//
NdisWanAllocateMemory(&AllocatedMemory, ulAllocationSize);
if (AllocatedMemory != NULL) {
//
// Initialize the control block
//
LocalLinkCB = (PLINKCB)AllocatedMemory;
LocalLinkCB->ulAllocationSize = ulAllocationSize;
InitializeListHead(&LocalLinkCB->WanPacketPool);
NdisWanInitializeSyncEvent(&LocalLinkCB->OutstandingFramesEvent);
} else {
Status = NDIS_STATUS_RESOURCES;
NdisWanDbgOut(DBG_CRITICAL_ERROR, DBG_MEMORY, ("Error allocating memory for LinkCB, AllocationSize: %d",
ulAllocationSize));
}
*LinkCB = LocalLinkCB;
return (Status);
}
VOID
NdisWanInitLinkCB(
IN PLINKCB *LinkCB,
IN PWAN_ADAPTERCB WanAdapterCB,
IN ULONG SendWindow
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
PLINKCB LocalLinkCB = *LinkCB;
if (LocalLinkCB == NULL) {
return;
}
LocalLinkCB->hLinkContext = NULL;
LocalLinkCB->ulReferenceCount = 0;
LocalLinkCB->State = LINK_UP;
LocalLinkCB->WanAdapterCB = WanAdapterCB;
LocalLinkCB->OutstandingFrames = 0;
LocalLinkCB->LastRecvSeqNumber = 0;
LocalLinkCB->ulBandwidth = 100;
LocalLinkCB->PacketMemory = NULL;
LocalLinkCB->PacketMemorySize = 0;
LocalLinkCB->RecvFragmentsLost = 0;
NdisZeroMemory(&LocalLinkCB->LinkInfo, sizeof(WAN_LINK_INFO));
LocalLinkCB->LinkInfo.HeaderPadding = WanAdapterCB->WanInfo.HeaderPadding;
LocalLinkCB->LinkInfo.TailPadding = WanAdapterCB->WanInfo.TailPadding;
LocalLinkCB->LinkInfo.SendACCM =
LocalLinkCB->LinkInfo.RecvACCM = WanAdapterCB->WanInfo.DesiredACCM;
NdisZeroMemory(&LocalLinkCB->LinkStats, sizeof(WAN_STATS));
if (NdisWanAllocateSendResources(LocalLinkCB, SendWindow) != NDIS_STATUS_SUCCESS) {
//
// return the linkcb
//
NdisWanReturnLinkCB(LocalLinkCB);
*LinkCB = NULL;
}
}
VOID
NdisWanReturnLinkCB(
PLINKCB LinkCB
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
PWAN_ADAPTERCB WanAdapterCB = LinkCB->WanAdapterCB;
NdisAcquireSpinLock(&(WanAdapterCB->Lock));
//
// Free the wanpacket pool
//
NdisWanFreeSendResources(LinkCB);
InsertTailList(&WanAdapterCB->FreeLinkCBList, &LinkCB->Linkage);
NdisReleaseSpinLock(&(WanAdapterCB->Lock));
}
VOID
NdisWanDestroyLinkCB(
IN PLINKCB LinkCB
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
PWAN_ADAPTERCB WanAdapterCB = LinkCB->WanAdapterCB;
//
// Free the memory allocated for the control block
//
NdisWanFreeMemory(LinkCB);
}
NDIS_STATUS
NdisWanAllocateSendResources(
IN PLINKCB LinkCB,
IN ULONG SendWindow
)
/*++
Routine Name:
NdisWanAllocateSendResources
Routine Description:
Allocates all resources (SendDescriptors, WanPackets, ...)
required for sending data. Should be called at line up time.
Arguments:
LinkCB - Pointer to the linkcb that the send resources will be attached to.
SendWindow - Maximum number of sends that this link can handle
Return Values:
NDIS_STATUS_SUCCESS
NDIS_STATUS_RESOURCES
--*/
{
PWAN_ADAPTERCB WanAdapterCB = LinkCB->WanAdapterCB;
ULONG BufferSize, PacketMemorySize, NumberOfPackets, n;
PUCHAR PacketMemory = NULL;
PNDIS_WAN_PACKET WanPacket;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
SendWindow = (SendWindow == 0) ?
WanAdapterCB->WanInfo.MaxTransmit : SendWindow;
SendWindow = (SendWindow == 0) ? 1 : SendWindow;
//
// The number of packets that we will create is the send
// window of this WAN Miniport + 1
//
NumberOfPackets = SendWindow + 1;
//
// The size of the buffer that we create is
//
BufferSize = WanAdapterCB->WanInfo.MaxFrameSize +
WanAdapterCB->WanInfo.HeaderPadding +
WanAdapterCB->WanInfo.TailPadding +
40 + sizeof(PVOID);
//
// We assume compression is always on so we pad out 12%
// incase the compressor expands. I don't know where the
// 12% figure comes from.
//
BufferSize += (WanAdapterCB->WanInfo.MaxFrameSize + 7) / 8;
//
// Make sure that the buffer is dword aligned.
//
BufferSize &= ~(sizeof(PVOID) - 1);
PacketMemorySize = (BufferSize + sizeof(NDIS_WAN_PACKET)) * NumberOfPackets;
//
// Allocate the memory for the wan packet buffer pool
//
NdisAllocateMemory(&PacketMemory,
PacketMemorySize,
WanAdapterCB->WanInfo.MemoryFlags,
WanAdapterCB->WanInfo.HighestAcceptableAddress);
if (PacketMemory != NULL) {
LinkCB->PacketMemory = PacketMemory;
LinkCB->PacketMemorySize = PacketMemorySize;
LinkCB->BufferSize = BufferSize;
for (n = 0; n < NumberOfPackets; n++) {
WanPacket = (PNDIS_WAN_PACKET)PacketMemory;
PacketMemory += sizeof(NDIS_WAN_PACKET);
InsertTailList(&LinkCB->WanPacketPool, &WanPacket->WanPacketQueue);
LinkCB->ulWanPacketCount++;
}
//
// Walk the list of newly created packets and fix up startbuffer and
// endbuffer pointers.
//
for (WanPacket = (PNDIS_WAN_PACKET)LinkCB->WanPacketPool.Flink;
(PVOID)WanPacket != (PVOID)&LinkCB->WanPacketPool;
WanPacket = (PNDIS_WAN_PACKET)WanPacket->WanPacketQueue.Flink) {
//
// Point to the begining of the data.
//
WanPacket->StartBuffer = PacketMemory;
PacketMemory += BufferSize;
//
// The 5 bytes give us a short buffer at the end and will
// keep a WAN Miniport from alignment checking if it uses
// this pointer to 'back copy'
//
WanPacket->EndBuffer = PacketMemory - 5;
}
} else {
Status = NDIS_STATUS_RESOURCES;
NdisWanDbgOut(DBG_CRITICAL_ERROR, DBG_MEMORY, ("Error allocating memory for BufferPool, AllocationSize: %d",
PacketMemorySize));
}
return (Status);
}
VOID
NdisWanFreeSendResources(
IN PLINKCB LinkCB
)
/*++
Routine Name:
NdisWanFreeSendResources
Routine Description:
This routine removes the WanPackets from this linkcb's send list
and free's the memory allocated for these packets. Should be called
at linedown time after all outstanding sends have been accounted for.
Arguments:
LinkCB - Pointer to the linkcb that the resources are being freed from.
Return Values:
None
--*/
{
PNDIS_WAN_PACKET WanPacket;
PUCHAR PacketMemory;
ULONG PacketMemorySize, Flags;
PacketMemory = LinkCB->PacketMemory;
PacketMemorySize = LinkCB->PacketMemorySize;
Flags = LinkCB->WanAdapterCB->WanInfo.MemoryFlags;
//
// Remove the packets from the wan packet pool
//
while (!IsListEmpty(&LinkCB->WanPacketPool)) {
RemoveHeadList(&LinkCB->WanPacketPool);
LinkCB->ulWanPacketCount--;
}
//
// Free the block of memory allocated for this send
//
if (PacketMemory != NULL) {
NdisFreeMemory(PacketMemory, PacketMemorySize, Flags);
}
}
VOID
NdisWanGetBundleCB(
OUT PBUNDLECB *BundleCB
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
NdisAcquireSpinLock(&(FreeBundleCBList.Lock));
//
// See if there are any BundleCB's available on the free list.
// If there are not we will need to allocate one.
//
if (FreeBundleCBList.ulCount == 0) {
//
// Create BundleCB
//
NdisWanCreateBundleCB(BundleCB);
} else {
//
// Get the BundleCB from the free list
//
*BundleCB = (PBUNDLECB)RemoveHeadList(&(FreeBundleCBList.List));
FreeBundleCBList.ulCount--;
}
NdisReleaseSpinLock(&(FreeBundleCBList.Lock));
if (*BundleCB != NULL) {
NdisWanInitBundleCB(*BundleCB);
}
}
NDIS_STATUS
NdisWanCreateBundleCB(
OUT PBUNDLECB *BundleCB
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
PBUNDLECB LocalBundleCB = NULL;
ULONG ulAllocationSize;
PUCHAR AllocatedMemory = NULL;
//
// Allocation size is the size of the control block plus the size
// of a table of pointers to protocolcb's that might be routed to
// this bundle.
//
ulAllocationSize = sizeof(BUNDLECB) +
sizeof(PROTOCOLCB) +
(sizeof(PPROTOCOLCB) * MAX_PROTOCOLS);
NdisWanAllocateMemory(&AllocatedMemory, ulAllocationSize);
if (AllocatedMemory != NULL) {
PWSTR IOName = L"I/O ProtocolCB";
PPROTOCOLCB ProtocolCB;
//
// This is the bundlecb
//
LocalBundleCB = (PBUNDLECB)AllocatedMemory;
LocalBundleCB->ulAllocationSize = ulAllocationSize;
AllocatedMemory += sizeof(BUNDLECB);
//
// This is the memory used for the I/O protocolcb
//
ProtocolCB = (PPROTOCOLCB)AllocatedMemory;
AllocatedMemory += sizeof(PROTOCOLCB);
//
// This is the protocolcb table
//
(PUCHAR)LocalBundleCB->ProtocolCBTable = (PUCHAR)AllocatedMemory;
//
// Initialize the BundleCB
//
NdisAllocateSpinLock(&LocalBundleCB->Lock);
InitializeListHead(&LocalBundleCB->LinkCBList);
InitializeListHead(&LocalBundleCB->SendPacketQueue);
InitializeListHead(&LocalBundleCB->RecvDescPool);
InitializeListHead(&LocalBundleCB->RecvDescAssemblyList);
InitializeListHead(&LocalBundleCB->ProtocolCBList);
NdisWanInitializeSyncEvent(&LocalBundleCB->OutstandingFramesEvent);
NdisWanInitializeSyncEvent(&LocalBundleCB->IndicationEvent);
#ifdef BANDWIDTH_ON_DEMAND
LocalBundleCB->UpperBonDInfo.SampleTable.ulSampleArraySize = SAMPLE_ARRAY_SIZE;
LocalBundleCB->LowerBonDInfo.SampleTable.ulSampleArraySize = SAMPLE_ARRAY_SIZE;
#endif // end of BANDWIDTH_ON_DEMAND
//
// Add the protocolcb to the bundle's table and list
//
ProtocolCB->hProtocolHandle = 0;
ProtocolCB->BundleCB = LocalBundleCB;
ProtocolCB->HeadNdisPacketQueue =
ProtocolCB->TailNdisPacketQueue = NULL;
NdisWanStringToNdisString(&ProtocolCB->DeviceName, IOName);
#ifdef BANDWIDTH_ON_DEMAND
ProtocolCB->SampleTable.ulSampleArraySize = SAMPLE_ARRAY_SIZE;
NdisWanInitWanTime(&ProtocolCB->SampleTable.SampleRate, ONE_HUNDRED_MILS);
NdisWanInitWanTime(&ProtocolCB->SampleTable.SamplePeriod, ONE_SECOND);
#endif
LocalBundleCB->ProtocolCBTable[0] = ProtocolCB;
InsertHeadList(&LocalBundleCB->ProtocolCBList, &ProtocolCB->Linkage);
LocalBundleCB->ulNumberOfRoutes = 1;
} else {
Status = NDIS_STATUS_RESOURCES;
NdisWanDbgOut(DBG_CRITICAL_ERROR, DBG_MEMORY, ("Error allocating memory for BundleCB, AllocationSize: %d",
ulAllocationSize));
}
*BundleCB = LocalBundleCB;
return (Status);
}
VOID
NdisWanInitBundleCB(
PBUNDLECB BundleCB
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
PPROTOCOLCB ProtocolCB = BundleCB->ProtocolCBTable[0];
PRECV_DESC RecvDescHole;
#ifdef BANDWIDTH_ON_DEMAND
PSAMPLE_TABLE SampleTable;
PBOND_INFO BonDInfo;
#endif // end of BANDWIDTH_ON_DEMAND
BundleCB->State = BUNDLE_UP;
NdisZeroMemory(&BundleCB->FramingInfo, sizeof(BUNDLE_FRAME_INFO));
BundleCB->NextLinkToXmit = NULL;
BundleCB->SendingLinks = 0;
BundleCB->SendSeqNumber = 0;
BundleCB->SendSeqMask = 0;
BundleCB->SendSeqTest = 0;
BundleCB->Flags = 0;
NdisZeroMemory(&BundleCB->LineUpInfo, sizeof(BUNDLE_LINE_UP));
BundleCB->LineUpInfo.ulMaximumTotalSize = MAX_TOTAL_SIZE;
//
// Init the recv hole desc
//
BundleCB->RecvSeqMask = 0;
BundleCB->RecvSeqTest = 0;
BundleCB->RecvFragmentsLost = 0;
BundleCB->MinReceivedSeqNumber = 0;
ASSERT(BundleCB->RecvDescAssemblyList.Flink == BundleCB->RecvDescAssemblyList.Blink);
NdisWanGetRecvDesc(BundleCB, &RecvDescHole);
RecvDescHole->SequenceNumber = 0;
RecvDescHole->Flags = 1;
BundleCB->RecvDescHole = RecvDescHole;
InsertHeadList(&BundleCB->RecvDescAssemblyList, &RecvDescHole->Linkage);
NdisWanGetSystemTime(&BundleCB->LastRecvNonIdleData);
ProtocolCB->SendMaskBit = IO_SEND_MASK_BIT;
NdisZeroMemory(&BundleCB->SendVJInfo, sizeof(VJ_INFO));
NdisZeroMemory(&BundleCB->RecvVJInfo, sizeof(VJ_INFO));
NdisZeroMemory(&BundleCB->SendCompInfo, sizeof(COMPRESS_INFO));
NdisZeroMemory(&BundleCB->RecvCompInfo, sizeof(COMPRESS_INFO));
NdisZeroMemory(&BundleCB->SendEncryptInfo,sizeof(ENCRYPTION_INFO));
NdisZeroMemory(&BundleCB->RecvEncryptInfo,sizeof(ENCRYPTION_INFO));
/*
#ifdef ENCRYPT_128BIT
BundleCB->SendEncryptInfo.SessionKeyLength =
BundleCB->RecvEncryptInfo.SessionKeyLength = 16;
BundleCB->SendCompInfo.MSCompType =
BundleCB->RecvCompInfo.MSCompType = NDISWAN_ENCRYPTION |
NDISWAN_40_ENCRYPTION |
NDISWAN_128_ENCRYPTION |
NDISWAN_COMPRESSION;
#else
BundleCB->SendEncryptInfo.SessionKeyLength =
BundleCB->RecvEncryptInfo.SessionKeyLength = 8;
BundleCB->SendCompInfo.MSCompType =
BundleCB->RecvCompInfo.MSCompType = NDISWAN_ENCRYPTION |
NDISWAN_40_ENCRYPTION |
NDISWAN_COMPRESSION;
#endif
*/
BundleCB->SendCompInfo.CompType =
BundleCB->RecvCompInfo.CompType = COMPTYPE_NONE;
ProtocolCB->usProtocolType = PROTOCOL_PRIVATE_IO;
ProtocolCB->usPPPProtocolID = PPP_PROTOCOL_PRIVATE_IO;
BundleCB->SendMask = IO_SEND_MASK_BIT;
#ifdef BANDWIDTH_ON_DEMAND
ProtocolCB->usPriority = 100;
ProtocolCB->ulByteQuota = 0xFFFFFFFF;
ProtocolCB->SampleTable.ulFirstIndex =
ProtocolCB->SampleTable.ulCurrentIndex = 0;
NdisZeroMemory(&ProtocolCB->SampleTable.SampleArray[0],
sizeof(SEND_SAMPLE) * SAMPLE_ARRAY_SIZE);
BonDInfo = &BundleCB->UpperBonDInfo;
BonDInfo->ulBytesThreshold = 0;
BonDInfo->State = BonDIdle;
BonDInfo->usPercentBandwidth = 0xFFFF;
BonDInfo->ulSecondsInSamplePeriod = 0;
NdisWanInitWanTime(&BonDInfo->StartTime, 0);
SampleTable = &BonDInfo->SampleTable;
NdisWanInitWanTime(&SampleTable->SampleRate, 0);
NdisWanInitWanTime(&SampleTable->SamplePeriod, 0);
SampleTable->ulFirstIndex =
SampleTable->ulCurrentIndex =
SampleTable->ulCurrentSampleByteCount = 0;
NdisZeroMemory(&SampleTable->SampleArray[0],
sizeof(SEND_SAMPLE) * SAMPLE_ARRAY_SIZE);
BonDInfo = &BundleCB->LowerBonDInfo;
BonDInfo->ulBytesThreshold = 0;
BonDInfo->State = BonDIdle;
BonDInfo->usPercentBandwidth = 0xFFFF;
BonDInfo->ulSecondsInSamplePeriod = 0;
NdisWanInitWanTime(&BonDInfo->StartTime, 0);
SampleTable = &BonDInfo->SampleTable;
NdisWanInitWanTime(&SampleTable->SampleRate, 0);
NdisWanInitWanTime(&SampleTable->SamplePeriod, 0);
SampleTable->ulFirstIndex =
SampleTable->ulCurrentIndex =
SampleTable->ulCurrentSampleByteCount = 0;
NdisZeroMemory(&SampleTable->SampleArray[0],
sizeof(SEND_SAMPLE) * SAMPLE_ARRAY_SIZE);
#endif // end of BANDWIDTH_ON_DEMAND
BundleCB->ulNameLength = 0;
NdisZeroMemory(&BundleCB->Name, MAX_NAME_LENGTH);
NdisZeroMemory(&BundleCB->BundleStats, sizeof(WAN_STATS));
}
VOID
NdisWanReturnBundleCB(
IN PBUNDLECB BundleCB
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
sl_compress_terminate(&BundleCB->VJCompress);
WanDeallocateCCP(BundleCB);
FlushRecvDescAssemblyList(BundleCB);
FreeRecvDescFreeList(BundleCB);
NdisAcquireSpinLock(&(FreeBundleCBList.Lock));
if (FreeBundleCBList.ulCount >= FreeBundleCBList.ulMaxCount) {
NdisWanDestroyBundleCB(BundleCB);
} else {
InsertTailList(&FreeBundleCBList.List, &(BundleCB->Linkage));
FreeBundleCBList.ulCount++;
}
NdisReleaseSpinLock(&(FreeBundleCBList.Lock));
}
VOID
NdisWanDestroyBundleCB(
IN PBUNDLECB BundleCB
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
PPROTOCOLCB ProtocolCB = BundleCB->ProtocolCBTable[0];
NdisFreeSpinLock(&BundleCB->Lock);
NdisWanFreeNdisString(&ProtocolCB->DeviceName);
NdisWanFreeMemory(BundleCB);
}
NDIS_STATUS
NdisWanCreatePPPProtocolTable(
VOID
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
ULONG ulAllocationSize = 0;
PUCHAR AllocatedMemory;
//
// Allocate ProtocolLookupTable. This table is used to match protocol values
// with their corresponding PPP Protocol values. The table size is set to
// MAX_PROTOCOLS.
//
ulAllocationSize = sizeof(PPP_PROTOCOL_TABLE) +
(sizeof(USHORT) * MAX_PROTOCOLS) +
(sizeof(USHORT) * MAX_PROTOCOLS);
NdisWanAllocateMemory(&AllocatedMemory, ulAllocationSize);
if (AllocatedMemory == NULL) {
NdisWanDbgOut(DBG_CRITICAL_ERROR, DBG_MEMORY,
("Failed allocating memory for ProtocolLookupTable! TableSize: %d",
ulAllocationSize));
return (NDIS_STATUS_RESOURCES);
}
PPP_ProtocolTable = (PPPP_PROTOCOL_TABLE)AllocatedMemory;
//
// Save the allocation size
//
PPP_ProtocolTable->ulAllocationSize = ulAllocationSize;
//
// Store the array size. This should be read from the registry
//
PPP_ProtocolTable->ulArraySize = MAX_PROTOCOLS;
NdisAllocateSpinLock(&PPP_ProtocolTable->Lock);
//
// Setup the pointer to the ProtocolValue array
//
AllocatedMemory += sizeof(PPP_PROTOCOL_TABLE);
PPP_ProtocolTable->ProtocolID = (PUSHORT)(AllocatedMemory);
//
// Setup the pointer to the PPPProtocolValue array
//
AllocatedMemory += (sizeof(USHORT) * MAX_PROTOCOLS);
PPP_ProtocolTable->PPPProtocolID = (PUSHORT)(AllocatedMemory);
//
// Insert default values for Netbuei, IP, IPX
//
InsertPPP_ProtocolID(PROTOCOL_PRIVATE_IO, PROTOCOL_TYPE);
InsertPPP_ProtocolID(PPP_PROTOCOL_PRIVATE_IO, PPP_TYPE);
InsertPPP_ProtocolID(PROTOCOL_IP, PROTOCOL_TYPE);
InsertPPP_ProtocolID(PPP_PROTOCOL_IP, PPP_TYPE);
InsertPPP_ProtocolID(PROTOCOL_IPX, PROTOCOL_TYPE);
InsertPPP_ProtocolID(PPP_PROTOCOL_IPX, PPP_TYPE);
InsertPPP_ProtocolID(PROTOCOL_NBF, PROTOCOL_TYPE);
InsertPPP_ProtocolID(PPP_PROTOCOL_NBF, PPP_TYPE);
return (Status);
}
VOID
NdisWanDestroyPPPProtocolTable(
VOID
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
NdisFreeSpinLock(&PPP_ProtocolTable->Lock);
NdisWanFreeMemory(PPP_ProtocolTable);
}
NDIS_STATUS
NdisWanCreateConnectionTable(
ULONG TableSize
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
ULONG ulAllocationSize = 0;
PUCHAR AllocatedMemory;
PCONNECTION_TABLE NewTable;
//
// Since we skip the first place in the tables we increase the
// size by one.
//
TableSize += 1;
//
// Allocate the Bundle and Link Arrays based on the number of possible connections
// that we have in the system. This should be grown if we get called
// to reinitialize and gain new ports.
//
ulAllocationSize = sizeof(CONNECTION_TABLE) +
(sizeof(PBUNDLECB) * TableSize) +
(sizeof(PLINKCB) * TableSize);
NdisWanAllocateMemory(&AllocatedMemory, ulAllocationSize);
if (AllocatedMemory == NULL) {
NdisWanDbgOut(DBG_CRITICAL_ERROR, DBG_MEMORY,
("Failed allocating memory for ConnectionTable! Size: %d, Links: %d",
ulAllocationSize, TableSize));
return (NDIS_STATUS_RESOURCES);
}
NewTable = (PCONNECTION_TABLE)AllocatedMemory;
NdisAllocateSpinLock(&NewTable->Lock);
//
// This is the amount of memory we allocated
//
NewTable->ulAllocationSize = ulAllocationSize;
NewTable->ulArraySize = TableSize;
InitializeListHead(&NewTable->BundleList);
//
// Setup pointer to the linkcb array
//
AllocatedMemory += sizeof(CONNECTION_TABLE);
NewTable->LinkArray = (PLINKCB*)(AllocatedMemory);
//
// Setup the pointer to the bundlecb array
//
AllocatedMemory += (sizeof(PLINKCB) * TableSize);
NewTable->BundleArray = (PBUNDLECB*)(AllocatedMemory);
if (ConnectionTable != NULL) {
//
// We must be growing the table
//
NewTable->ulNumActiveLinks = ConnectionTable->ulNumActiveLinks;
NewTable->ulNumActiveBundles = ConnectionTable->ulNumActiveBundles;
NdisMoveMemory((PUCHAR)NewTable->LinkArray,
(PUCHAR)ConnectionTable->LinkArray,
ConnectionTable->ulArraySize * sizeof(PLINKCB));
NdisMoveMemory((PUCHAR)NewTable->BundleArray,
(PUCHAR)ConnectionTable->BundleArray,
ConnectionTable->ulArraySize * sizeof(PBUNDLECB));
while (!IsListEmpty(&ConnectionTable->BundleList)) {
PBUNDLECB BundleCB;
BundleCB = (PBUNDLECB)RemoveHeadList(&ConnectionTable->BundleList);
InsertTailList(&NewTable->BundleList, &BundleCB->Linkage);
}
NdisWanDestroyConnectionTable();
}
ConnectionTable = NewTable;
return (Status);
}
VOID
NdisWanDestroyConnectionTable(
VOID
)
/*++
Routine Name:
Routine Description:
Arguments:
Return Values:
--*/
{
NdisFreeSpinLock(&ConnectionTable->Lock);
NdisWanFreeMemory(ConnectionTable);
}
VOID
NdisWanGetDeferredDesc(
PADAPTERCB AdapterCB,
PDEFERRED_DESC *RetDesc
)
{
ULONG i;
if (IsDeferredQueueEmpty(&AdapterCB->FreeDeferredQueue)) {
PDEFERRED_DESC DeferredDesc;
NdisWanAllocateMemory(&DeferredDesc, sizeof(DEFERRED_DESC) * 20);
if (DeferredDesc != NULL) {
for (i = 0; i < 20; i++) {
InsertHeadDeferredQueue(&AdapterCB->FreeDeferredQueue, DeferredDesc);
(PUCHAR)DeferredDesc += sizeof(DEFERRED_DESC);
}
}
}
*RetDesc = RemoveHeadDeferredQueue(&AdapterCB->FreeDeferredQueue);
ASSERT(*RetDesc != NULL);
}
