able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/netbeui/sys/packet.c

1830 lines
48 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989, 1990, 1991 Microsoft Corporation
Module Name:
packet.c
Abstract:
This module contains code that implements the TP_PACKET object, which
describes a DLC I-frame at some point in its lifetime. Routines are
provided to allocate packets for shipment, to ship packets, to reference
packets, to dereference packets, to mark a connection as waiting for a
packet to become available, to satisfy the next waiting connection for
a packet, and to destroy packets (return them to the pool).
Author:
David Beaver (dbeaver) 1-July-1991
Environment:
Kernel mode
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
//
// This is temporary; this is the quota that we charge for a receive
// packet for now, until we fix the problem with token-ring needing
// big packets and using all the memory. The number is the actual
// value for Ethernet.
//
#if 1
#define RECEIVE_BUFFER_QUOTA(_DeviceContext) 1533
#else
#define RECEIVE_BUFFER_QUOTA(_DeviceContext) (_DeviceContext)->ReceiveBufferLength
#endif
#define PACKET_POOL_GROW_COUNT 32
#if DBG
ULONG NbfCreatePacketThreshold = 5;
extern ULONG NbfPacketPanic;
#endif
NDIS_STATUS
NbfAllocateNdisSendPacket(
IN PDEVICE_CONTEXT DeviceContext,
OUT PNDIS_PACKET *NdisPacket
)
/*++
Routine Description:
This routine allocates a recieve packet from the receive packet pool.
It Grows the packet pool if necessary.
NOTE: This routine is called with the device context spinlock
held, or at such a time as synchronization is unnecessary.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
UIFrame - Returns a pointer to the frame, or NULL if no storage
can be allocated.
Return Value:
None.
--*/
{
PNBF_POOL_LIST_DESC SendPacketPoolDesc;
NDIS_STATUS NdisStatus;
KIRQL oldirql;
NdisStatus = NDIS_STATUS_RESOURCES;
ACQUIRE_SPIN_LOCK (&DeviceContext->SendPoolListLock, &oldirql);
for (SendPacketPoolDesc = DeviceContext->SendPacketPoolDesc;
SendPacketPoolDesc != NULL;
SendPacketPoolDesc = SendPacketPoolDesc->Next) {
NdisAllocatePacket (
&NdisStatus,
NdisPacket,
SendPacketPoolDesc->PoolHandle);
if (NdisStatus == NDIS_STATUS_SUCCESS) {
RELEASE_SPIN_LOCK (&DeviceContext->SendPoolListLock, oldirql);
return(NdisStatus);
}
}
if (NdisStatus != NDIS_STATUS_SUCCESS) {
if ((DeviceContext->MemoryLimit != 0) &&
((DeviceContext->MemoryUsage +
PACKET_POOL_GROW_COUNT *
(sizeof(NDIS_PACKET) + sizeof(SEND_PACKET_TAG))) >
DeviceContext->MemoryLimit)) {
PANIC("NBF: Could not grow packet pool: limit\n");
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_LIMIT,
106,
DeviceContext->UIFrameLength,
UI_FRAME_RESOURCE_ID);
RELEASE_SPIN_LOCK (&DeviceContext->SendPoolListLock, oldirql);
return(NdisStatus);
}
}
DeviceContext->MemoryUsage +=
(PACKET_POOL_GROW_COUNT *
(sizeof(NDIS_PACKET) + sizeof(SEND_PACKET_TAG)));
// Allocate Packet pool descriptors for dynamic packet allocation.
SendPacketPoolDesc = ExAllocatePoolWithTag(
NonPagedPool,
sizeof(NBF_POOL_LIST_DESC),
NBF_MEM_TAG_POOL_DESC);
if (SendPacketPoolDesc == NULL) {
RELEASE_SPIN_LOCK (&DeviceContext->SendPoolListLock, oldirql);
return(NdisStatus);
}
RtlZeroMemory(SendPacketPoolDesc, sizeof(NBF_POOL_LIST_DESC));
SendPacketPoolDesc->NumElements =
SendPacketPoolDesc->TotalElements = PACKET_POOL_GROW_COUNT;
// To track packet pools in NDIS allocated on NBF's behalf
#if NDIS_POOL_TAGGING
SendPacketPoolDesc->PoolHandle = (NDIS_HANDLE) NDIS_PACKET_POOL_TAG_FOR_NBF;
#endif
NdisAllocatePacketPoolEx ( &NdisStatus, &SendPacketPoolDesc->PoolHandle,
PACKET_POOL_GROW_COUNT, 0, sizeof (SEND_PACKET_TAG));
if (NdisStatus != NDIS_STATUS_SUCCESS) {
#if DBG
NbfPrint1 ("NbfGrowSendPacketPool: NdisInitializePacketPool failed, reason: %s.\n",
NbfGetNdisStatus (NdisStatus));
#endif
RELEASE_SPIN_LOCK (&DeviceContext->SendPoolListLock, oldirql);
ExFreePool (SendPacketPoolDesc);
return(NdisStatus);
}
NdisSetPacketPoolProtocolId (SendPacketPoolDesc->PoolHandle, NDIS_PROTOCOL_ID_NBF);
SendPacketPoolDesc->Next = DeviceContext->SendPacketPoolDesc;
DeviceContext->SendPacketPoolDesc = SendPacketPoolDesc;
RELEASE_SPIN_LOCK (&DeviceContext->SendPoolListLock, oldirql);
NdisAllocatePacket ( &NdisStatus, NdisPacket,
SendPacketPoolDesc->PoolHandle);
return(NdisStatus);
}
NDIS_STATUS
NbfAllocateNdisRcvPacket(
IN PDEVICE_CONTEXT DeviceContext,
OUT PNDIS_PACKET *NdisPacket
)
/*++
Routine Description:
This routine allocates a recieve packet from the receive packet pool.
It Grows the packet pool if necessary.
NOTE: This routine is called with the device context spinlock
held, or at such a time as synchronization is unnecessary.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
UIFrame - Returns a pointer to the frame, or NULL if no storage
can be allocated.
Return Value:
None.
--*/
{
PNBF_POOL_LIST_DESC RcvPacketPoolDesc;
NDIS_STATUS NdisStatus;
KIRQL oldirql;
NdisStatus = NDIS_STATUS_RESOURCES;
ACQUIRE_SPIN_LOCK (&DeviceContext->RcvPoolListLock, &oldirql);
for (RcvPacketPoolDesc = DeviceContext->ReceivePacketPoolDesc;
RcvPacketPoolDesc != NULL;
RcvPacketPoolDesc = RcvPacketPoolDesc->Next) {
NdisAllocatePacket (
&NdisStatus,
NdisPacket,
RcvPacketPoolDesc->PoolHandle);
if (NdisStatus == NDIS_STATUS_SUCCESS) {
RELEASE_SPIN_LOCK (&DeviceContext->RcvPoolListLock, oldirql);
return(NdisStatus);
}
}
if (NdisStatus != NDIS_STATUS_SUCCESS) {
if ((DeviceContext->MemoryLimit != 0) &&
((DeviceContext->MemoryUsage +
PACKET_POOL_GROW_COUNT *
(sizeof(NDIS_PACKET) + sizeof(SEND_PACKET_TAG))) >
DeviceContext->MemoryLimit)) {
PANIC("NBF: Could not grow packet pool: limit\n");
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_LIMIT,
106,
DeviceContext->UIFrameLength,
UI_FRAME_RESOURCE_ID);
RELEASE_SPIN_LOCK (&DeviceContext->RcvPoolListLock, oldirql);
return(NdisStatus);
}
}
DeviceContext->MemoryUsage +=
(PACKET_POOL_GROW_COUNT *
(sizeof(NDIS_PACKET) + sizeof(SEND_PACKET_TAG)));
// Allocate Packet pool descriptors for dynamic packet allocation.
RcvPacketPoolDesc = ExAllocatePoolWithTag(
NonPagedPool,
sizeof(NBF_POOL_LIST_DESC),
NBF_MEM_TAG_POOL_DESC);
if (RcvPacketPoolDesc == NULL) {
RELEASE_SPIN_LOCK (&DeviceContext->RcvPoolListLock, oldirql);
return(NdisStatus);
}
RtlZeroMemory(RcvPacketPoolDesc, sizeof(NBF_POOL_LIST_DESC));
RcvPacketPoolDesc->NumElements =
RcvPacketPoolDesc->TotalElements = PACKET_POOL_GROW_COUNT;
// To track packet pools in NDIS allocated on NBF's behalf
#if NDIS_POOL_TAGGING
RcvPacketPoolDesc->PoolHandle = (NDIS_HANDLE) NDIS_PACKET_POOL_TAG_FOR_NBF;
#endif
NdisAllocatePacketPoolEx ( &NdisStatus, &RcvPacketPoolDesc->PoolHandle,
PACKET_POOL_GROW_COUNT, 0, sizeof (RECEIVE_PACKET_TAG));
if (NdisStatus != NDIS_STATUS_SUCCESS) {
#if DBG
NbfPrint1 ("NbfGrowSendPacketPool: NdisInitializePacketPool failed, reason: %s.\n",
NbfGetNdisStatus (NdisStatus));
#endif
RELEASE_SPIN_LOCK (&DeviceContext->RcvPoolListLock, oldirql);
ExFreePool (RcvPacketPoolDesc);
return(NdisStatus);
}
NdisSetPacketPoolProtocolId (RcvPacketPoolDesc->PoolHandle, NDIS_PROTOCOL_ID_NBF);
RcvPacketPoolDesc->Next = DeviceContext->ReceivePacketPoolDesc;
DeviceContext->ReceivePacketPoolDesc = RcvPacketPoolDesc;
RELEASE_SPIN_LOCK (&DeviceContext->RcvPoolListLock, oldirql);
NdisAllocatePacket ( &NdisStatus, NdisPacket,
RcvPacketPoolDesc->PoolHandle);
return(NdisStatus);
}
VOID
NbfAllocateUIFrame(
IN PDEVICE_CONTEXT DeviceContext,
OUT PTP_UI_FRAME *TransportUIFrame
)
/*++
Routine Description:
This routine allocates storage for a UI frame. Some initialization
is done here.
NOTE: This routine is called with the device context spinlock
held, or at such a time as synchronization is unnecessary.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
UIFrame - Returns a pointer to the frame, or NULL if no storage
can be allocated.
Return Value:
None.
--*/
{
NDIS_STATUS NdisStatus;
PNDIS_PACKET NdisPacket;
PSEND_PACKET_TAG SendTag;
PTP_UI_FRAME UIFrame;
PNDIS_BUFFER NdisBuffer;
PNBF_POOL_LIST_DESC SendPacketPoolDesc;
if ((DeviceContext->MemoryLimit != 0) &&
((DeviceContext->MemoryUsage + DeviceContext->UIFrameLength) >
DeviceContext->MemoryLimit)) {
PANIC("NBF: Could not allocate UI frame: limit\n");
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_LIMIT,
106,
DeviceContext->UIFrameLength,
UI_FRAME_RESOURCE_ID);
*TransportUIFrame = NULL;
return;
}
UIFrame = (PTP_UI_FRAME) ExAllocatePoolWithTag (
NonPagedPool,
DeviceContext->UIFrameLength,
NBF_MEM_TAG_TP_UI_FRAME);
if (UIFrame == NULL) {
PANIC("NBF: Could not allocate UI frame: no pool\n");
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_POOL,
206,
DeviceContext->UIFrameLength,
UI_FRAME_RESOURCE_ID);
*TransportUIFrame = NULL;
return;
}
RtlZeroMemory (UIFrame, DeviceContext->UIFrameLength);
DeviceContext->MemoryUsage += DeviceContext->UIFrameLength;
NdisStatus = NbfAllocateNdisSendPacket(DeviceContext, &NdisPacket);
#if 0
for (SendPacketPoolDesc = DeviceContext->SendPacketPoolDesc;
SendPacketPoolDesc != NULL;
SendPacketPoolDesc = SendPacketPoolDesc->Next) {
NdisAllocatePacket (
&NdisStatus,
&NdisPacket,
SendPacketPoolDesc->PoolHandle);
if (NdisStatus == NDIS_STATUS_SUCCESS)
break;
}
#endif
if (NdisStatus != NDIS_STATUS_SUCCESS) {
ExFreePool (UIFrame);
#if 0
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_SPECIFIC,
306,
0,
UI_FRAME_RESOURCE_ID);
#endif
*TransportUIFrame = NULL;
return;
}
UIFrame->NdisPacket = NdisPacket;
UIFrame->DataBuffer = NULL;
SendTag = (PSEND_PACKET_TAG)NdisPacket->ProtocolReserved;
SendTag->Type = TYPE_UI_FRAME;
SendTag->Frame = UIFrame;
SendTag->Owner = DeviceContext;
//
// Make the packet header known to the packet descriptor
//
NdisAllocateBuffer(
&NdisStatus,
&NdisBuffer,
DeviceContext->NdisBufferPool,
UIFrame->Header,
DeviceContext->UIFrameHeaderLength);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_SPECIFIC,
406,
0,
UI_FRAME_RESOURCE_ID);
NdisFreePacket (NdisPacket);
ExFreePool (UIFrame);
*TransportUIFrame = NULL;
return;
}
NdisChainBufferAtFront (NdisPacket, NdisBuffer);
++DeviceContext->UIFrameAllocated;
*TransportUIFrame = UIFrame;
} /* NbfAllocateUIFrame */
VOID
NbfDeallocateUIFrame(
IN PDEVICE_CONTEXT DeviceContext,
IN PTP_UI_FRAME TransportUIFrame
)
/*++
Routine Description:
This routine frees storage for a UI frame.
NOTE: This routine is called with the device context spinlock
held, or at such a time as synchronization is unnecessary.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
UIFrame - A pointer to the frame.
Return Value:
None.
--*/
{
PNDIS_PACKET NdisPacket = TransportUIFrame->NdisPacket;
PNDIS_BUFFER NdisBuffer;
NdisUnchainBufferAtFront (NdisPacket, &NdisBuffer);
if (NdisBuffer != NULL) {
NdisFreeBuffer (NdisBuffer);
}
NdisFreePacket (NdisPacket);
ExFreePool (TransportUIFrame);
--DeviceContext->UIFrameAllocated;
DeviceContext->MemoryUsage -= DeviceContext->UIFrameLength;
} /* NbfDeallocateUIFrame */
VOID
NbfAllocateSendPacket(
IN PDEVICE_CONTEXT DeviceContext,
OUT PTP_PACKET *TransportSendPacket
)
/*++
Routine Description:
This routine allocates storage for a send packet. Some initialization
is done here.
NOTE: This routine is called with the device context spinlock
held, or at such a time as synchronization is unnecessary.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
TransportSendPacket - Returns a pointer to the packet, or NULL if no
storage can be allocated.
Return Value:
None.
--*/
{
PTP_PACKET Packet;
NDIS_STATUS NdisStatus;
PNDIS_PACKET NdisPacket;
PSEND_PACKET_TAG SendTag;
PNDIS_BUFFER NdisBuffer;
PNBF_POOL_LIST_DESC SendPacketPoolDesc;
if ((DeviceContext->MemoryLimit != 0) &&
((DeviceContext->MemoryUsage + DeviceContext->PacketLength) >
DeviceContext->MemoryLimit)) {
PANIC("NBF: Could not allocate send packet: limit\n");
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_LIMIT,
107,
DeviceContext->PacketLength,
PACKET_RESOURCE_ID);
*TransportSendPacket = NULL;
return;
}
Packet = (PTP_PACKET)ExAllocatePoolWithTag (
NonPagedPool,
DeviceContext->PacketLength,
NBF_MEM_TAG_TP_PACKET);
if (Packet == NULL) {
PANIC("NBF: Could not allocate send packet: no pool\n");
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_POOL,
207,
DeviceContext->PacketLength,
PACKET_RESOURCE_ID);
*TransportSendPacket = NULL;
return;
}
RtlZeroMemory (Packet, DeviceContext->PacketLength);
DeviceContext->MemoryUsage += DeviceContext->PacketLength;
NdisStatus = NbfAllocateNdisSendPacket(DeviceContext, &NdisPacket);
#if 0
for (SendPacketPoolDesc = DeviceContext->SendPacketPoolDesc;
SendPacketPoolDesc != NULL;
SendPacketPoolDesc = SendPacketPoolDesc->Next) {
NdisAllocatePacket (
&NdisStatus,
&NdisPacket,
SendPacketPoolDesc->PoolHandle);
if (NdisStatus == NDIS_STATUS_SUCCESS)
break;
}
#endif
if (NdisStatus != NDIS_STATUS_SUCCESS) {
ExFreePool (Packet);
#if 0
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_SPECIFIC,
307,
0,
PACKET_RESOURCE_ID);
#endif
*TransportSendPacket = NULL;
return;
}
NdisAllocateBuffer(
&NdisStatus,
&NdisBuffer,
DeviceContext->NdisBufferPool,
Packet->Header,
DeviceContext->PacketHeaderLength);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_SPECIFIC,
407,
0,
PACKET_RESOURCE_ID);
NdisFreePacket (NdisPacket);
ExFreePool (Packet);
*TransportSendPacket = NULL;
return;
}
NdisChainBufferAtFront (NdisPacket, NdisBuffer);
Packet->NdisPacket = NdisPacket;
SendTag = (PSEND_PACKET_TAG)NdisPacket->ProtocolReserved;
SendTag->Type = TYPE_I_FRAME;
SendTag->Frame = Packet;
SendTag->Owner = DeviceContext;
Packet->Type = NBF_PACKET_SIGNATURE;
Packet->Size = sizeof (TP_PACKET);
Packet->Provider = DeviceContext;
Packet->Owner = NULL; // no connection/irpsp yet.
Packet->Action = PACKET_ACTION_IRP_SP;
Packet->PacketizeConnection = FALSE;
Packet->PacketNoNdisBuffer = FALSE;
Packet->ProviderInterlock = &DeviceContext->Interlock;
// KeInitializeSpinLock (&Packet->Interlock);
++DeviceContext->PacketAllocated;
*TransportSendPacket = Packet;
} /* NbfAllocateSendPacket */
VOID
NbfDeallocateSendPacket(
IN PDEVICE_CONTEXT DeviceContext,
IN PTP_PACKET TransportSendPacket
)
/*++
Routine Description:
This routine frees storage for a send packet.
NOTE: This routine is called with the device context spinlock
held, or at such a time as synchronization is unnecessary.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
TransportSendPacket - A pointer to the send packet.
Return Value:
None.
--*/
{
PNDIS_PACKET NdisPacket = TransportSendPacket->NdisPacket;
PNDIS_BUFFER NdisBuffer;
NdisUnchainBufferAtFront (NdisPacket, &NdisBuffer);
if (NdisBuffer != NULL) {
NdisFreeBuffer (NdisBuffer);
}
NdisFreePacket (NdisPacket);
ExFreePool (TransportSendPacket);
--DeviceContext->PacketAllocated;
DeviceContext->MemoryUsage -= DeviceContext->PacketLength;
} /* NbfDeallocateSendPacket */
VOID
NbfAllocateReceivePacket(
IN PDEVICE_CONTEXT DeviceContext,
OUT PNDIS_PACKET *TransportReceivePacket
)
/*++
Routine Description:
This routine allocates storage for a receive packet. Some initialization
is done here.
NOTE: This routine is called with the device context spinlock
held, or at such a time as synchronization is unnecessary.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
TransportReceivePacket - Returns a pointer to the packet, or NULL if no
storage can be allocated.
Return Value:
None.
--*/
{
NDIS_STATUS NdisStatus;
PNDIS_PACKET NdisPacket;
PRECEIVE_PACKET_TAG ReceiveTag;
//
// This does not count in DeviceContext->MemoryUsage because
// the storage is allocated when we allocate the packet pool.
//
NdisStatus = NbfAllocateNdisRcvPacket(DeviceContext, &NdisPacket);
#if 0
NdisAllocatePacket (
&NdisStatus,
&NdisPacket,
DeviceContext->ReceivePacketPoolDesc->PoolHandle);
#endif
if (NdisStatus != NDIS_STATUS_SUCCESS) {
#if 0
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_SPECIFIC,
309,
0,
RECEIVE_PACKET_RESOURCE_ID);
#endif
*TransportReceivePacket = NULL;
return;
}
ReceiveTag = (PRECEIVE_PACKET_TAG)(NdisPacket->ProtocolReserved);
ReceiveTag->PacketType = TYPE_AT_INDICATE;
++DeviceContext->ReceivePacketAllocated;
*TransportReceivePacket = NdisPacket;
} /* NbfAllocateReceivePacket */
VOID
NbfDeallocateReceivePacket(
IN PDEVICE_CONTEXT DeviceContext,
IN PNDIS_PACKET TransportReceivePacket
)
/*++
Routine Description:
This routine frees storage for a receive packet.
NOTE: This routine is called with the device context spinlock
held, or at such a time as synchronization is unnecessary.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
TransportReceivePacket - A pointer to the packet.
Return Value:
None.
--*/
{
NdisFreePacket (TransportReceivePacket);
--DeviceContext->ReceivePacketAllocated;
} /* NbfDeallocateReceivePacket */
VOID
NbfAllocateReceiveBuffer(
IN PDEVICE_CONTEXT DeviceContext,
OUT PBUFFER_TAG *TransportReceiveBuffer
)
/*++
Routine Description:
This routine allocates storage for a receive buffer. Some initialization
is done here.
NOTE: This routine is called with the device context spinlock
held, or at such a time as synchronization is unnecessary.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
TransportReceiveBuffer - Returns a pointer to the buffer, or NULL if no
storage can be allocated.
Return Value:
None.
--*/
{
PBUFFER_TAG BufferTag;
NDIS_STATUS NdisStatus;
PNDIS_BUFFER NdisBuffer;
if ((DeviceContext->MemoryLimit != 0) &&
((DeviceContext->MemoryUsage + RECEIVE_BUFFER_QUOTA(DeviceContext)) >
DeviceContext->MemoryLimit)) {
PANIC("NBF: Could not allocate receive buffer: limit\n");
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_LIMIT,
108,
RECEIVE_BUFFER_QUOTA(DeviceContext),
RECEIVE_BUFFER_RESOURCE_ID);
*TransportReceiveBuffer = NULL;
return;
}
//
// The Aligned doesn't help since the header makes it unaligned.
//
BufferTag = (PBUFFER_TAG)ExAllocatePoolWithTag (
NonPagedPoolCacheAligned,
DeviceContext->ReceiveBufferLength,
NBF_MEM_TAG_RCV_BUFFER);
if (BufferTag == NULL) {
PANIC("NBF: Could not allocate receive buffer: no pool\n");
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_POOL,
208,
DeviceContext->ReceiveBufferLength,
RECEIVE_BUFFER_RESOURCE_ID);
*TransportReceiveBuffer = NULL;
return;
}
DeviceContext->MemoryUsage += RECEIVE_BUFFER_QUOTA(DeviceContext);
//
// point to the buffer for NDIS
//
NdisAllocateBuffer(
&NdisStatus,
&NdisBuffer,
DeviceContext->NdisBufferPool,
BufferTag->Buffer,
DeviceContext->MaxReceivePacketSize);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
PANIC("NBF: Could not allocate receive buffer: no buffer\n");
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_SPECIFIC,
308,
0,
RECEIVE_BUFFER_RESOURCE_ID);
ExFreePool (BufferTag);
*TransportReceiveBuffer = NULL;
return;
}
BufferTag->Length = DeviceContext->MaxReceivePacketSize;
BufferTag->NdisBuffer = NdisBuffer;
++DeviceContext->ReceiveBufferAllocated;
*TransportReceiveBuffer = BufferTag;
} /* NbfAllocateReceiveBuffer */
VOID
NbfDeallocateReceiveBuffer(
IN PDEVICE_CONTEXT DeviceContext,
IN PBUFFER_TAG TransportReceiveBuffer
)
/*++
Routine Description:
This routine frees storage for a receive buffer.
NOTE: This routine is called with the device context spinlock
held, or at such a time as synchronization is unnecessary.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
TransportReceiveBuffer - A pointer to the buffer.
Return Value:
None.
--*/
{
NdisFreeBuffer (TransportReceiveBuffer->NdisBuffer);
ExFreePool (TransportReceiveBuffer);
--DeviceContext->ReceiveBufferAllocated;
DeviceContext->MemoryUsage -= RECEIVE_BUFFER_QUOTA(DeviceContext);
} /* NbfDeallocateReceiveBuffer */
NTSTATUS
NbfCreatePacket(
PDEVICE_CONTEXT DeviceContext,
PTP_LINK Link,
PTP_PACKET *Packet
)
/*++
Routine Description:
This routine allocates a packet from the device context's pool,
and prepares the MAC and DLC headers for use by the connection.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
Link - The link the packet will be sent over.
Packet - Pointer to a place where we will return a pointer to the
allocated packet.
Return Value:
NTSTATUS - status of operation.
--*/
{
KIRQL oldirql;
PSINGLE_LIST_ENTRY s;
PTP_PACKET ThePacket;
PDLC_I_FRAME DlcHdr;
#if DBG
PNBF_HDR_CONNECTION NbfHdr;
#endif
typedef struct _SIXTEEN_BYTES {
ULONG Data[4];
} SIXTEEN_BYTES, *PSIXTEEN_BYTES;
ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
IF_NBFDBG (NBF_DEBUG_RESOURCE) {
NbfPrint0 ("NbfCreatePacket: Entered.\n");
}
//
// Make sure that structure packing hasn't happened.
//
ASSERT (sizeof(NBF_HDR_CONNECTION) == 14);
#if defined(NBF_UP)
s = DeviceContext->PacketPool.Next;
if (s != NULL) {
DeviceContext->PacketPool.Next = s->Next;
}
#else
s = ExInterlockedPopEntryList (
&DeviceContext->PacketPool,
&DeviceContext->Interlock);
#endif
if (s == NULL) {
NbfGrowSendPacketPool(DeviceContext);
#if defined(NBF_UP)
s = DeviceContext->PacketPool.Next;
if (s != NULL) {
DeviceContext->PacketPool.Next = s->Next;
}
#else
s = ExInterlockedPopEntryList (
&DeviceContext->PacketPool,
&DeviceContext->Interlock);
#endif
if (s == NULL) {
#if DBG
++Link->CreatePacketFailures;
if ((ULONG)Link->CreatePacketFailures >= NbfCreatePacketThreshold) {
if (NbfPacketPanic) {
NbfPrint1 ("NbfCreatePacket: PANIC! no more packets in provider's pool (%d times).\n",
Link->CreatePacketFailures);
}
Link->CreatePacketFailures = 0;
}
#endif
ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql);
++DeviceContext->PacketExhausted;
RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
return STATUS_INSUFFICIENT_RESOURCES;
}
}
#if DBG
Link->CreatePacketFailures = 0;
#endif
ThePacket = CONTAINING_RECORD (s, TP_PACKET, Linkage);
//
// NOTE: ThePacket->Action and ThePacket->Owner are filled
// in by the caller of this function.
//
ThePacket->ReferenceCount = 1; // automatic ref count of 1.
ThePacket->Link = NULL; // no link yet.
ThePacket->PacketSent = FALSE;
ASSERT (ThePacket->Action == PACKET_ACTION_IRP_SP);
ASSERT (ThePacket->PacketNoNdisBuffer == FALSE);
ASSERT (ThePacket->PacketizeConnection == FALSE);
//
// Initialize the MAC header for this packet, using the connection's
// link pre-built header.
//
if (Link->HeaderLength <= 14) {
*(PSIXTEEN_BYTES)ThePacket->Header = *(PSIXTEEN_BYTES)Link->Header;
} else {
RtlCopyMemory(
ThePacket->Header,
Link->Header,
Link->HeaderLength);
//
// Initialize the TP_FRAME_CONNECTION header for this packet.
//
DlcHdr = (PDLC_I_FRAME)&(ThePacket->Header[Link->HeaderLength]);
DlcHdr->Dsap = DSAP_NETBIOS_OVER_LLC;
DlcHdr->Ssap = DSAP_NETBIOS_OVER_LLC;
#if DBG
DlcHdr->SendSeq = 0; // known values, will assist debugging.
DlcHdr->RcvSeq = 0; // these are assigned at shipment time.
#endif
}
#if DBG
NbfHdr = (PNBF_HDR_CONNECTION)&(ThePacket->Header[Link->HeaderLength + sizeof(DLC_I_FRAME)]);
NbfHdr->Command = 0xff; // to assist debugging-- assigned later.
NbfHdr->Data1 = 0xff; // to assist debugging-- assigned later.
NbfHdr->Data2Low = 0xff; // to assist debugging-- assigned later.
NbfHdr->Data2High = 0xff; // to assist debugging-- assigned later.
TRANSMIT_CORR(NbfHdr) = 0xffff; // to assist debugging-- assigned later.
RESPONSE_CORR(NbfHdr) = 0xffff; // to assist debugging-- assigned later.
NbfHdr->DestinationSessionNumber = 0xff; // to assist debugging-- assigned later.
NbfHdr->SourceSessionNumber = 0xff; // to assist debugging-- assigned later.
#endif
*Packet = ThePacket; // return pointer to the packet.
return STATUS_SUCCESS;
} /* NbfCreatePacket */
NTSTATUS
NbfCreateRrPacket(
PDEVICE_CONTEXT DeviceContext,
PTP_LINK Link,
PTP_PACKET *Packet
)
/*++
Routine Description:
This routine allocates an RR packet from the device context's pool,
and prepares the MAC and DLC headers for use by the connection.
It first looks in the special RR packet pool, then in the regular
packet pool.
Arguments:
DeviceContext - Pointer to our device context to charge the packet to.
Link - The link the packet will be sent over.
Packet - Pointer to a place where we will return a pointer to the
allocated packet.
Return Value:
NTSTATUS - status of operation.
--*/
{
PSINGLE_LIST_ENTRY s;
PTP_PACKET ThePacket;
PDLC_I_FRAME DlcHdr;
NTSTATUS Status;
#if DBG
PNBF_HDR_CONNECTION NbfHdr;
#endif
typedef struct _SIXTEEN_BYTES {
ULONG Data[4];
} SIXTEEN_BYTES, *PSIXTEEN_BYTES;
IF_NBFDBG (NBF_DEBUG_RESOURCE) {
NbfPrint0 ("NbfCreateRrPacket: Entered.\n");
}
//
// Make sure that structure packing hasn't happened.
//
ASSERT (sizeof(NBF_HDR_CONNECTION) == 14);
#if defined(NBF_UP)
s = DeviceContext->RrPacketPool.Next;
if (s != NULL) {
DeviceContext->RrPacketPool.Next = s->Next;
}
#else
s = ExInterlockedPopEntryList (
&DeviceContext->RrPacketPool,
&DeviceContext->Interlock);
#endif
if (s == NULL) {
#if DBG
++Link->CreatePacketFailures;
if ((ULONG)Link->CreatePacketFailures >= NbfCreatePacketThreshold) {
if (NbfPacketPanic) {
NbfPrint1 ("NbfCreateRrPacket: PANIC! no more packets in provider's pool (%d times).\n",
Link->CreatePacketFailures);
}
Link->CreatePacketFailures = 0;
}
#endif
//
// Try to get one from the regular pool, and mark it so
// it goes back there.
//
Status = NbfCreatePacket(
DeviceContext,
Link,
Packet);
if (Status == STATUS_SUCCESS) {
(*Packet)->Action = PACKET_ACTION_NULL;
}
return Status;
}
#if DBG
Link->CreatePacketFailures = 0;
#endif
ThePacket = CONTAINING_RECORD (s, TP_PACKET, Linkage);
//
// NOTE: ThePacket->Owner is filled in by the caller of this
// function.
//
ThePacket->ReferenceCount = 1; // automatic ref count of 1.
ThePacket->Link = NULL; // no link yet.
ThePacket->PacketSent = FALSE;
ASSERT (ThePacket->Action == PACKET_ACTION_RR);
ASSERT (ThePacket->PacketNoNdisBuffer == FALSE);
//
// Initialize the MAC header for this packet, using the connection's
// link pre-built header.
//
if (Link->HeaderLength <= 14) {
*(PSIXTEEN_BYTES)ThePacket->Header = *(PSIXTEEN_BYTES)Link->Header;
} else {
RtlCopyMemory(
ThePacket->Header,
Link->Header,
Link->HeaderLength);
//
// Initialize the TP_FRAME_CONNECTION header for this packet.
//
DlcHdr = (PDLC_I_FRAME)&(ThePacket->Header[Link->HeaderLength]);
DlcHdr->Dsap = DSAP_NETBIOS_OVER_LLC;
DlcHdr->Ssap = DSAP_NETBIOS_OVER_LLC;
#if DBG
DlcHdr->SendSeq = 0; // known values, will assist debugging.
DlcHdr->RcvSeq = 0; // these are assigned at shipment time.
#endif
}
#if DBG
NbfHdr = (PNBF_HDR_CONNECTION)&(ThePacket->Header[Link->HeaderLength + sizeof(DLC_I_FRAME)]);
NbfHdr->Command = 0xff; // to assist debugging-- assigned later.
NbfHdr->Data1 = 0xff; // to assist debugging-- assigned later.
NbfHdr->Data2Low = 0xff; // to assist debugging-- assigned later.
NbfHdr->Data2High = 0xff; // to assist debugging-- assigned later.
TRANSMIT_CORR(NbfHdr) = 0xffff; // to assist debugging-- assigned later.
RESPONSE_CORR(NbfHdr) = 0xffff; // to assist debugging-- assigned later.
NbfHdr->DestinationSessionNumber = 0xff; // to assist debugging-- assigned later.
NbfHdr->SourceSessionNumber = 0xff; // to assist debugging-- assigned later.
#endif
*Packet = ThePacket; // return pointer to the packet.
return STATUS_SUCCESS;
} /* NbfCreateRrPacket */
VOID
NbfDestroyPacket(
PTP_PACKET Packet
)
/*++
Routine Description:
This routine destroys a packet, thereby returning it to the pool. If
it is determined that there is at least one connection waiting for a
packet to become available (and it just has), then the connection is
removed from the device context's list and AdvanceSend is called to
prep the connection further.
Arguments:
Packet - Pointer to a packet to be returned to the pool.
Return Value:
none.
--*/
{
PDEVICE_CONTEXT DeviceContext;
PTP_CONNECTION Connection;
PLIST_ENTRY p;
PNDIS_BUFFER HeaderBuffer;
PNDIS_BUFFER NdisBuffer;
ULONG Flags;
IF_NBFDBG (NBF_DEBUG_RESOURCE) {
NbfPrint2 ("NbfDestroyPacket: Entered, Packet: %lx, NdisPacket: %lx\n",
Packet, Packet->NdisPacket);
}
DeviceContext = Packet->Provider;
//
// Strip off and unmap the buffers describing data and header.
//
if (Packet->PacketNoNdisBuffer) {
//
// If the NDIS_BUFFER chain is not ours, then we can't
// start unchaining since that would mess up the queue;
// instead we just drop the rest of the chain after the
// header.
//
NdisQueryPacket (Packet->NdisPacket, NULL, NULL, &HeaderBuffer, NULL);
ASSERT (HeaderBuffer != NULL);
NDIS_BUFFER_LINKAGE(HeaderBuffer) = (PNDIS_BUFFER)NULL;
NdisRecalculatePacketCounts (Packet->NdisPacket);
Packet->PacketNoNdisBuffer = FALSE;
} else {
NdisUnchainBufferAtFront (Packet->NdisPacket, &HeaderBuffer);
ASSERT (HeaderBuffer != NULL);
//
// Return all the NDIS_BUFFERs to the system.
//
NdisUnchainBufferAtFront (Packet->NdisPacket, &NdisBuffer);
while (NdisBuffer != NULL) {
NdisFreeBuffer (NdisBuffer);
NdisUnchainBufferAtFront (Packet->NdisPacket, &NdisBuffer);
}
NDIS_BUFFER_LINKAGE(HeaderBuffer) = (PNDIS_BUFFER)NULL;
NdisChainBufferAtFront (Packet->NdisPacket, HeaderBuffer);
}
//
// invoke the packet deallocate action specified in this packet.
//
switch (Packet->Action) {
case PACKET_ACTION_NULL:
// PANIC ("NbfDestroyPacket: no action.\n");
Packet->Action = PACKET_ACTION_IRP_SP;
break;
case PACKET_ACTION_IRP_SP:
IF_NBFDBG (NBF_DEBUG_REQUEST) {
NbfPrint2 ("NbfDestroyPacket: Packet %x deref IrpSp %x.\n", Packet, Packet->Owner);
}
NbfDereferenceSendIrp("Destroy packet", (PIO_STACK_LOCATION)(Packet->Owner), RREF_PACKET);
break;
case PACKET_ACTION_CONNECTION:
NbfDereferenceConnection ("Destroy packet", (PTP_CONNECTION)(Packet->Owner), CREF_FRAME_SEND);
Packet->Action = PACKET_ACTION_IRP_SP;
break;
case PACKET_ACTION_END:
NbfDereferenceConnection ("SessionEnd destroyed", (PTP_CONNECTION)(Packet->Owner), CREF_FRAME_SEND);
NbfDereferenceConnection ("SessionEnd destroyed", (PTP_CONNECTION)(Packet->Owner), CREF_LINK);
Packet->Action = PACKET_ACTION_IRP_SP;
break;
case PACKET_ACTION_RR:
#if defined(NBF_UP)
((PSINGLE_LIST_ENTRY)&Packet->Linkage)->Next =
DeviceContext->RrPacketPool.Next;
DeviceContext->RrPacketPool.Next =
&((PSINGLE_LIST_ENTRY)&Packet->Linkage)->Next;
#else
ExInterlockedPushEntryList (
&DeviceContext->RrPacketPool,
(PSINGLE_LIST_ENTRY)&Packet->Linkage,
&DeviceContext->Interlock);
#endif
return;
default:
IF_NBFDBG (NBF_DEBUG_RESOURCE) {
NbfPrint1 ("NbfDestroyPacket: invalid action (%ld).\n", Packet->Action);
}
ASSERT (FALSE);
}
//
// Put the packet back for use again.
//
#if defined(NBF_UP)
((PSINGLE_LIST_ENTRY)&Packet->Linkage)->Next =
DeviceContext->PacketPool.Next;
DeviceContext->PacketPool.Next =
&((PSINGLE_LIST_ENTRY)&Packet->Linkage)->Next;
#else
ExInterlockedPushEntryList (
&DeviceContext->PacketPool,
(PSINGLE_LIST_ENTRY)&Packet->Linkage,
&DeviceContext->Interlock);
#endif
//
// If there is a connection waiting to ship out more packets, then
// wake it up and start packetizing again.
//
// We do a quick check without the lock; there is a small
// window where we may not take someone off, but this
// window exists anyway and we assume that more packets
// will be freed in the future.
//
if (IsListEmpty (&DeviceContext->PacketWaitQueue)) {
return;
}
ACQUIRE_DPC_SPIN_LOCK (&DeviceContext->SpinLock);
if (!(IsListEmpty(&DeviceContext->PacketWaitQueue))) {
//
// Remove a connection from the "packet starved" queue.
//
p = RemoveHeadList (&DeviceContext->PacketWaitQueue);
Connection = CONTAINING_RECORD (p, TP_CONNECTION, PacketWaitLinkage);
Connection->OnPacketWaitQueue = FALSE;
RELEASE_DPC_SPIN_LOCK (&DeviceContext->SpinLock);
ACQUIRE_DPC_SPIN_LOCK (Connection->LinkSpinLock);
//
// If this connection is starved because it couldn't send a
// control packet (SI, SC, RO, RC, or DA) then start that
// operation up again. Otherwise, just start packetizing.
//
if (Connection->Flags & CONNECTION_FLAGS_STARVED) {
Flags = Connection->Flags & CONNECTION_FLAGS_STARVED;
if ((Flags & (Flags-1)) != 0) {
//
// More than one bit is on, use only the low one
// (an arbitrary choice).
//
#if DBG
DbgPrint ("NBF: Connection %lx has two flag bits on %lx\n", Connection, Connection->Flags);
#endif
Flags &= ~(Flags-1);
}
Connection->Flags &= ~Flags;
if ((Connection->Flags & CONNECTION_FLAGS_W_PACKETIZE) ||
(Connection->Flags & CONNECTION_FLAGS_STARVED)) {
//
// We are waiting for both a specific packet and
// to packetize, or for two specific packets, so
// put ourselves back on the queue.
//
ACQUIRE_DPC_SPIN_LOCK (&DeviceContext->SpinLock);
if (!Connection->OnPacketWaitQueue) {
Connection->OnPacketWaitQueue = TRUE;
InsertTailList(
&DeviceContext->PacketWaitQueue,
&Connection->PacketWaitLinkage);
}
RELEASE_DPC_SPIN_LOCK (&DeviceContext->SpinLock);
}
RELEASE_DPC_SPIN_LOCK (Connection->LinkSpinLock);
if (Flags & CONNECTION_FLAGS_SEND_SI) {
NbfSendSessionInitialize (Connection);
} else if (Flags & CONNECTION_FLAGS_SEND_SC) {
NbfSendSessionConfirm (Connection);
} else if (Flags & CONNECTION_FLAGS_SEND_RO) {
NbfSendReceiveOutstanding (Connection);
} else if (Flags & CONNECTION_FLAGS_SEND_RC) {
NbfSendReceiveContinue (Connection);
} else if (Flags & CONNECTION_FLAGS_SEND_SE) {
NbfSendSessionEnd (
Connection,
FALSE);
} else if (Flags & CONNECTION_FLAGS_SEND_DA) {
NbfSendDataAck (Connection);
} else {
IF_NBFDBG (NBF_DEBUG_PACKET) {
NbfPrint0 ("NbfDestroyPacket: connection flags mismanaged.\n");
}
}
} else {
//
// Place the connection on the packetize queue and start
// packetizing the next connection to be serviced. If he
// is already on the packetize queue for some reason, then
// don't do this.
//
// We shouldn't be packetizing in this case!! - adb (7/3/91).
// This used to be a check that did nothing if FLAGS_PACKETIZE
// was set, but if that happens something is wrong...
//
ASSERT (Connection->Flags & CONNECTION_FLAGS_W_PACKETIZE);
Connection->Flags &= ~CONNECTION_FLAGS_W_PACKETIZE;
Connection->SendState = CONNECTION_SENDSTATE_PACKETIZE;
if ((Connection->Flags & CONNECTION_FLAGS_READY) &&
!(Connection->Flags & CONNECTION_FLAGS_PACKETIZE)) {
Connection->Flags |= CONNECTION_FLAGS_PACKETIZE;
NbfReferenceConnection ("Packet available", Connection, CREF_PACKETIZE_QUEUE);
ExInterlockedInsertTailList(
&DeviceContext->PacketizeQueue,
&Connection->PacketizeLinkage,
&DeviceContext->SpinLock);
}
RELEASE_DPC_SPIN_LOCK (Connection->LinkSpinLock);
PacketizeConnections (DeviceContext);
}
} else {
RELEASE_DPC_SPIN_LOCK (&DeviceContext->SpinLock);
}
} /* NbfDestroyPacket */
VOID NbfGrowSendPacketPool(PDEVICE_CONTEXT DeviceContext)
{
NDIS_STATUS NdisStatus;
PNBF_POOL_LIST_DESC SendPacketPoolDesc;
PTP_PACKET TransportSendPacket;
UINT i;
if ((DeviceContext->MemoryLimit != 0) &&
((DeviceContext->MemoryUsage + DeviceContext->PacketLength) >
DeviceContext->MemoryLimit)) {
PANIC("NBF: Could not grow send packet pool: limit\n");
NbfWriteResourceErrorLog(
DeviceContext,
EVENT_TRANSPORT_RESOURCE_LIMIT,
107,
DeviceContext->PacketLength,
PACKET_RESOURCE_ID);
return;
}
for (i = 0; i < PACKET_POOL_GROW_COUNT; i += 1) {
NbfAllocateSendPacket(DeviceContext, &TransportSendPacket);
if (TransportSendPacket != NULL) {
ExInterlockedPushEntryList(&(DeviceContext)->PacketPool,
(PSINGLE_LIST_ENTRY)&TransportSendPacket->Linkage,
&(DeviceContext)->Interlock);
}
else {
break;
}
}
if (i == PACKET_POOL_GROW_COUNT) {
return;
}
#ifdef DBG
DbgBreakPoint();
#endif // DBG
}
#if DBG
VOID
NbfReferencePacket(
PTP_PACKET Packet
)
/*++
Routine Description:
This routine increases the number of reasons why a packet cannot be
discarded.
Arguments:
Packet - Pointer to a packet to be referenced.
Return Value:
none.
--*/
{
LONG result;
IF_NBFDBG (NBF_DEBUG_PACKET) {
NbfPrint3 ("NbfReferencePacket: Entered, NdisPacket: %lx Packet: %lx Ref Count: %lx.\n",
Packet->NdisPacket, Packet, Packet->ReferenceCount);
}
result = InterlockedIncrement (&Packet->ReferenceCount);
ASSERT (result >= 0);
} /* NbfReferencePacket */
VOID
NbfDereferencePacket(
PTP_PACKET Packet
)
/*++
Routine Description:
This routine dereferences a transport packet by decrementing the
reference count contained in the structure. If, after being
decremented, the reference count is zero, then this routine calls
NbfDestroyPacket to remove it from the system.
Arguments:
Packet - Pointer to a packet object.
Return Value:
none.
--*/
{
LONG result;
result = InterlockedDecrement (&Packet->ReferenceCount);
//
// If we have deleted all references to this packet, then we can
// destroy the object. It is okay to have already released the spin
// lock at this point because there is no possible way that another
// stream of execution has access to the packet any longer.
//
IF_NBFDBG (NBF_DEBUG_PACKET) {
NbfPrint1 ("NbfDereferencePacket: Entered, result: %lx\n", result);
}
ASSERT (result >= 0);
if (result == 0) {
NbfDestroyPacket (Packet);
}
} /* NbfDereferencePacket */
#endif
VOID
NbfWaitPacket(
PTP_CONNECTION Connection,
ULONG Flags
)
/*++
Routine Description:
This routine causes the specified connection to be put into a wait
state pending the availability of a packet to send the specified
frame.
Arguments:
Connection - Pointer to the connection object to be paused.
Flags - Bitflag indicating which specific frame should be resent.
Return Value:
none.
--*/
{
PDEVICE_CONTEXT DeviceContext;
IF_NBFDBG (NBF_DEBUG_PACKET) {
NbfPrint0 ("NbfWaitPacket: Entered.\n");
}
DeviceContext = Connection->Provider;
ACQUIRE_DPC_SPIN_LOCK (Connection->LinkSpinLock);
//
// Now put this connection on the device context's PacketWaitQueue,
// but only if it isn't already queued there. This state is managed
// with the OnPacketWaitQueue variable.
//
// If the connection is stopping, don't queue him either.
//
if ((Connection->Flags & CONNECTION_FLAGS_READY) ||
(Flags == CONNECTION_FLAGS_SEND_SE)) {
ACQUIRE_DPC_SPIN_LOCK (&DeviceContext->SpinLock);
//
// Turn on the bitflag that indicates which frame we couldn't send.
//
#if DBG
if (Flags == CONNECTION_FLAGS_SEND_SE) {
DbgPrint ("NBF: Inserting connection %lx on PacketWait for SESSION_END\n", Connection);
}
#endif
Connection->Flags |= Flags;
if (!Connection->OnPacketWaitQueue) {
Connection->OnPacketWaitQueue = TRUE;
InsertTailList (
&DeviceContext->PacketWaitQueue,
&Connection->PacketWaitLinkage);
}
RELEASE_DPC_SPIN_LOCK (&DeviceContext->SpinLock);
}
RELEASE_DPC_SPIN_LOCK (Connection->LinkSpinLock);
} /* NbfWaitPacket */
#if MAGIC
VOID
NbfSendMagicBullet (
IN PDEVICE_CONTEXT DeviceContext,
IN PTP_LINK Link
)
/*++
Routine Description:
This routine sends a magic bullet on the net that can be used to trigger
sniffers or other such things.
Arguments:
DeviceContext - pointer to the device context
Link - This is needed to call NbfCreatePacket
Return Value:
none.
--*/
{
NTSTATUS Status;
NDIS_STATUS NdisStatus;
PTP_UI_FRAME RawFrame;
PUCHAR Header;
PNDIS_BUFFER NdisBuffer;
UINT i;
UNREFERENCED_PARAMETER (Link); // no longer needed
Status = NbfCreateConnectionlessFrame (DeviceContext, &RawFrame);
if (!NT_SUCCESS (Status)) { // couldn't make frame.
#if DBG
DbgPrint ("NbfSendMagicBullet: Couldn't allocate frame!\n");
#endif
return;
}
NdisAllocateBuffer(
&NdisStatus,
&NdisBuffer,
DeviceContext->NdisBufferPool,
DeviceContext->MagicBullet,
32);
if (NdisStatus == NDIS_STATUS_SUCCESS) {
Header = (PUCHAR)&RawFrame->Header;
for (i=0;i<6;i++) {
Header[i] = MAGIC_BULLET_FOOD;
Header[i+6] = DeviceContext->LocalAddress.Address[i];
}
Header[12] = 0;
Header[13] = (UCHAR)(DeviceContext->UIFrameHeaderLength + 18);
for (i=14;i<DeviceContext->UIFrameHeaderLength;i++) {
Header[i] = MAGIC_BULLET_FOOD;
}
NdisChainBufferAtBack (RawFrame->NdisPacket, NdisBuffer);
NbfSendUIFrame (
DeviceContext,
RawFrame,
FALSE); // no loopback
}
return;
}
#endif
Reference in a new issue Copy permalink