OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
7507d3c0e1
Windows-Server-2003/net/nwlink/nb/send.c

2889 lines
86 KiB
C
Raw Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
/*++
Copyright (c) 1989-1993 Microsoft Corporation
Module Name:
send.c
Abstract:
This module contains the send routines for the Netbios
module of the ISN transport.
Author:
Adam Barr (adamba) 22-November-1993
Environment:
Kernel mode
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
//
// Work Item structure for work items put on the Kernel Excutive worker threads
//
typedef struct
{
WORK_QUEUE_ITEM Item; // Used by OS to queue these requests
PVOID Context;
} NBI_WORK_ITEM_CONTEXT;
VOID
SendDgram(
PNDIS_PACKET Packet
)
/*++
Routine Description:
This routine sends a datagram from a Worker thread.
Earlier, this code was part of the NbiSendComplete module,
but since we could end up with a stack overflow, this may
now be handled over a worker thread.
Arguments:
WorkItem - The work item that was allocated for this.
Return Value:
None.
--*/
{
PNB_SEND_RESERVED Reserved = (PNB_SEND_RESERVED)(Packet->ProtocolReserved);
NDIS_STATUS Status;
PNETBIOS_CACHE CacheName;
PDEVICE Device = NbiDevice;
NB_CONNECTIONLESS UNALIGNED * Header;
PIPX_LOCAL_TARGET LocalTarget;
ULONG HeaderLength;
ULONG PacketLength;
// send the datagram on the next net.
CTEAssert (!Reserved->u.SR_DG.Cache->Unique);
Reserved->SendInProgress = TRUE;
CacheName = Reserved->u.SR_DG.Cache;
//
// Fill in the IPX header -- the default header has the broadcast
// address on net 0 as the destination IPX address, so we modify
// that for the current netbios cache entry if needed.
//
Header = (NB_CONNECTIONLESS UNALIGNED *) (&Reserved->Header[Device->Bind.IncludedHeaderOffset]);
RtlCopyMemory((PVOID)&Header->IpxHeader, &Device->ConnectionlessHeader, sizeof(IPX_HEADER));
*(UNALIGNED ULONG *)Header->IpxHeader.DestinationNetwork = CacheName->Networks[Reserved->u.SR_DG.CurrentNetwork].Network;
RtlCopyMemory (&Header->IpxHeader.DestinationNode, BroadcastAddress, 6);
LocalTarget = &CacheName->Networks[Reserved->u.SR_DG.CurrentNetwork].LocalTarget;
HeaderLength = sizeof(IPX_HEADER) + sizeof(NB_DATAGRAM);
PacketLength = HeaderLength + (ULONG) REQUEST_INFORMATION(Reserved->u.SR_DG.DatagramRequest);
Header->IpxHeader.PacketLength[0] = (UCHAR)(PacketLength / 256);
Header->IpxHeader.PacketLength[1] = (UCHAR)(PacketLength % 256);
Header->IpxHeader.PacketType = 0x04;
//
// Now fill in the Netbios header.
//
Header->Datagram.ConnectionControlFlag = 0x00;
RtlCopyMemory(
Header->Datagram.SourceName,
Reserved->u.SR_DG.AddressFile->Address->NetbiosAddress.NetbiosName,
16);
if (Reserved->u.SR_DG.RemoteName != (PVOID)-1) {
//
// This is a directed, as opposed to broadcast, datagram.
//
Header->Datagram.DataStreamType = NB_CMD_DATAGRAM;
RtlCopyMemory(
Header->Datagram.DestinationName,
Reserved->u.SR_DG.RemoteName->NetbiosName,
16);
} else {
Header->Datagram.DataStreamType = NB_CMD_BROADCAST_DATAGRAM;
RtlZeroMemory(
Header->Datagram.DestinationName,
16);
}
//
// Now send the frame (IPX will adjust the length of the
// first buffer and the whole frame correctly).
//
if ((Status = (*Device->Bind.SendHandler) (LocalTarget,
Packet,
PacketLength,
HeaderLength)) != STATUS_PENDING) {
NbiSendComplete (Packet, Status);
}
}
VOID
NbiDelayedSendDatagram(
IN PVOID pContextInfo
)
{
NBI_WORK_ITEM_CONTEXT *pContext = (NBI_WORK_ITEM_CONTEXT *) pContextInfo;
PNDIS_PACKET Packet = (PNDIS_PACKET) pContext->Context;
PNB_SEND_RESERVED Reserved = (PNB_SEND_RESERVED)(Packet->ProtocolReserved);
Reserved->CurrentSendIteration = 0;
SendDgram (Packet);
NbiFreeMemory (pContextInfo, sizeof(NBI_WORK_ITEM_CONTEXT), MEMORY_WORK_ITEM,
"Free delayed DgramSend work item");
}
VOID
NbiSendComplete(
IN PNDIS_PACKET Packet,
IN NDIS_STATUS Status
)
/*++
Routine Description:
This routine handles a send completion call from IPX.
Arguments:
Packet - The packet which has been completed.
Status - The status of the send.
Return Value:
None.
--*/
{
PDEVICE Device = NbiDevice;
PADDRESS Address;
PADDRESS_FILE AddressFile;
PCONNECTION Connection;
PREQUEST DatagramRequest;
PREQUEST SendRequest, TmpRequest;
PNDIS_BUFFER CurBuffer, TmpBuffer;
PNETBIOS_CACHE CacheName;
PNDIS_BUFFER SecondBuffer = NULL;
PVOID SecondBufferMemory = NULL;
UINT SecondBufferLength;
ULONG oldvalue;
PNB_SEND_RESERVED Reserved = (PNB_SEND_RESERVED)(Packet->ProtocolReserved);
CTELockHandle CancelLH;
#if defined(_PNP_POWER)
CTELockHandle LockHandle;
#endif _PNP_POWER
//
// We jump back here if we re-call send from inside this
// function and it doesn't pend (to avoid stack overflow).
//
++Device->Statistics.PacketsSent;
switch (Reserved->Type) {
case SEND_TYPE_SESSION_DATA:
//
// This was a send on a session. This references the
// IRP.
//
NB_DEBUG2 (SEND, ("Complete NDIS packet %lx\n", Reserved));
CTEAssert (Reserved->SendInProgress);
Reserved->SendInProgress = FALSE;
Connection = Reserved->u.SR_CO.Connection;
SendRequest = Reserved->u.SR_CO.Request;
if (!Reserved->u.SR_CO.NoNdisBuffer) {
CurBuffer = NDIS_BUFFER_LINKAGE (NDIS_BUFFER_LINKAGE(Reserved->HeaderBuffer));
while (CurBuffer) {
TmpBuffer = NDIS_BUFFER_LINKAGE (CurBuffer);
NdisFreeBuffer (CurBuffer);
CurBuffer = TmpBuffer;
}
}
//
// If NoNdisBuffer is TRUE, then we could set
// Connection->SendBufferInUse to FALSE here. The
// problem is that a new send might be in progress
// by the time this completes and it may have
// used the user buffer, then if we need to
// retransmit that packet we would use the buffer
// twice. We instead rely on the fact that whenever
// we make a new send active we set SendBufferInUse
// to FALSE. The net effect is that the user's buffer
// can be used the first time a send is packetize
// but not on resends.
//
NDIS_BUFFER_LINKAGE (NDIS_BUFFER_LINKAGE(Reserved->HeaderBuffer)) = NULL;
NdisRecalculatePacketCounts (Packet);
#if DBG
if (REQUEST_REFCOUNT(SendRequest) > 100) {
DbgPrint ("Request %lx (%lx) has high refcount\n",
Connection, SendRequest);
DbgBreakPoint();
}
#endif
#if defined(__PNP)
NB_GET_LOCK( &Connection->Lock, &LockHandle );
oldvalue = REQUEST_REFCOUNT(SendRequest)--;
if ( DEVICE_NETWORK_PATH_NOT_FOUND == Status ) {
Connection->LocalTarget = Reserved->LocalTarget;
}
NB_FREE_LOCK( &Connection->Lock, LockHandle );
#else
oldvalue = NB_ADD_ULONG(
&REQUEST_REFCOUNT (SendRequest),
(ULONG)-1,
&Connection->Lock);
#endif __PNP
if (oldvalue == 1) {
//
// If the refcount on this request is now zero then
// we already got the ack for it, which means
// that the ack-processing code has unlinked the
// request from Connection->SendQueue. So we
// can just run the queue of connections here
// and complete them.
//
// We dereference the connection for all but one
// of the requests, we hang on to that until a bit
// later so everything stays around.
//
while (TRUE) {
TmpRequest = REQUEST_SINGLE_LINKAGE (SendRequest);
NB_DEBUG2 (SEND, ("Completing request %lx from send complete\n", SendRequest));
REQUEST_STATUS (SendRequest) = STATUS_SUCCESS;
NB_GET_CANCEL_LOCK( &CancelLH );
IoSetCancelRoutine (SendRequest, (PDRIVER_CANCEL)NULL);
NB_FREE_CANCEL_LOCK( CancelLH );
NbiCompleteRequest (SendRequest);
NbiFreeRequest (Device, SendRequest);
++Connection->ConnectionInfo.TransmittedTsdus;
SendRequest = TmpRequest;
if (SendRequest == NULL) {
break;
}
NbiDereferenceConnection (Connection, CREF_SEND);
}
}
if (Reserved->OwnedByConnection) {
Connection->SendPacketInUse = FALSE;
if (Connection->OnWaitPacketQueue) {
//
// This will put the connection on the packetize
// queue if appropriate.
//
NbiCheckForWaitPacket (Connection);
}
} else {
NbiPushSendPacket(Reserved);
}
if (oldvalue == 1) {
NbiDereferenceConnection (Connection, CREF_SEND);
}
break;
case SEND_TYPE_NAME_FRAME:
//
// The frame is an add name/delete name; put it back in
// the pool and deref the address.
//
CTEAssert (Reserved->SendInProgress);
Address = Reserved->u.SR_NF.Address;
Reserved->SendInProgress = FALSE;
NbiPushSendPacket (Reserved);
if (Address) {
NbiDereferenceAddress (Address, AREF_NAME_FRAME);
} else {
NbiDereferenceDevice (Device, DREF_NAME_FRAME);
}
break;
case SEND_TYPE_SESSION_INIT:
//
// This is a session initialize or session init ack; free
// the second buffer, put the packet back in the pool and
// deref the device.
//
CTEAssert (Reserved->SendInProgress);
Reserved->SendInProgress = FALSE;
NdisUnchainBufferAtBack (Packet, &SecondBuffer);
if (SecondBuffer)
{
NdisQueryBufferSafe (SecondBuffer, &SecondBufferMemory, &SecondBufferLength, HighPagePriority);
CTEAssert (SecondBufferLength == sizeof(NB_SESSION_INIT));
if (SecondBufferMemory)
{
NbiFreeMemory (SecondBufferMemory, sizeof(NB_SESSION_INIT), MEMORY_CONNECTION,
"Session Initialize");
}
NdisFreeBuffer(SecondBuffer);
}
NbiPushSendPacket (Reserved);
NbiDereferenceDevice (Device, DREF_SESSION_INIT);
break;
case SEND_TYPE_SESSION_NO_DATA:
//
// This is a frame which was sent on a connection but
// has no data (ack, session end, session end ack).
//
CTEAssert (Reserved->SendInProgress);
Reserved->SendInProgress = FALSE;
Connection = Reserved->u.SR_CO.Connection;
if (Reserved->OwnedByConnection) {
CTEAssert (Connection != NULL);
Connection->SendPacketInUse = FALSE;
if (Connection->OnWaitPacketQueue) {
//
// This will put the connection on the packetize
// queue if appropriate.
//
NbiCheckForWaitPacket (Connection);
}
} else {
NbiPushSendPacket(Reserved);
}
if (Connection != NULL) {
NbiDereferenceConnection (Connection, CREF_FRAME);
} else {
NbiDereferenceDevice (Device, DREF_FRAME);
}
break;
case SEND_TYPE_FIND_NAME:
//
// The frame is a find name; just set SendInProgress to
// FALSE and FindNameTimeout will clean it up.
//
#if defined(_PNP_POWER)
NB_GET_LOCK( &Device->Lock, &LockHandle);
CTEAssert (Reserved->SendInProgress);
Reserved->SendInProgress = FALSE;
//
// We keep track of when it finds a net that isn't
// a down wan line so that we can tell when datagram
// sends should fail (otherwise we succeed them, so
// the browser won't think this is a down wan line).
//
if ( STATUS_SUCCESS == Status ) {
NB_SET_SR_FN_SENT_ON_UP_LINE (Reserved, TRUE);
} else {
NB_DEBUG( CACHE, ("Send complete of find name with failure %lx\n",Status ));
}
NB_FREE_LOCK(&Device->Lock, LockHandle);
#else
CTEAssert (Reserved->SendInProgress);
Reserved->SendInProgress = FALSE;
#endif _PNP_POWER
break;
case SEND_TYPE_DATAGRAM:
//
// If there are any more networks to send this on then
// do so, otherwise put it back in the pool and complete
// the request.
//
CTEAssert (Reserved->SendInProgress);
Reserved->SendInProgress = FALSE;
if ((Reserved->u.SR_DG.Cache == NULL) ||
(++Reserved->u.SR_DG.CurrentNetwork >=
Reserved->u.SR_DG.Cache->NetworksUsed)) {
AddressFile = Reserved->u.SR_DG.AddressFile;
DatagramRequest = Reserved->u.SR_DG.DatagramRequest;
NB_DEBUG2 (DATAGRAM, ("Completing datagram %lx on %lx\n", DatagramRequest, AddressFile));
//
// Remove any user buffers chained on this packet.
//
NdisReinitializePacket (Packet);
NDIS_BUFFER_LINKAGE (NDIS_BUFFER_LINKAGE(Reserved->HeaderBuffer)) = NULL;
NdisChainBufferAtFront (Packet, Reserved->HeaderBuffer);
//
// Complete the request.
//
REQUEST_STATUS(DatagramRequest) = Status;
NbiCompleteRequest(DatagramRequest);
NbiFreeRequest (Device, DatagramRequest);
CacheName = Reserved->u.SR_DG.Cache;
NbiPushSendPacket (Reserved);
//
// Since we are no longer referencing the cache
// name, see if we should delete it (this will
// happen if the cache entry was aged out while
// the datagram was being processed).
//
if (CacheName != NULL) {
oldvalue = NB_ADD_ULONG(
&CacheName->ReferenceCount,
(ULONG)-1,
&Device->Lock);
if (oldvalue == 1) {
NB_DEBUG2 (CACHE, ("Free aged cache entry %lx\n", CacheName));
NbiFreeMemory(
CacheName,
sizeof(NETBIOS_CACHE) + ((CacheName->NetworksAllocated-1) * sizeof(NETBIOS_NETWORK)),
MEMORY_CACHE,
"Free old cache");
}
}
NbiDereferenceAddressFile (AddressFile, AFREF_SEND_DGRAM);
} else {
NBI_WORK_ITEM_CONTEXT *WorkItem;
if ((++Reserved->CurrentSendIteration >= MAX_SEND_ITERATIONS) &&
(WorkItem = (NBI_WORK_ITEM_CONTEXT *) NbiAllocateMemory (sizeof(NBI_WORK_ITEM_CONTEXT),
MEMORY_WORK_ITEM,
"Delayed DgramSend work item")))
{
WorkItem->Context = (PVOID) Packet;
ExInitializeWorkItem (&WorkItem->Item, NbiDelayedSendDatagram, (PVOID)WorkItem);
ExQueueWorkItem(&WorkItem->Item, DelayedWorkQueue);
}
else
{
SendDgram (Packet);
}
}
break;
case SEND_TYPE_STATUS_QUERY:
//
// This is an adapter status query, which is a simple
// packet.
//
CTEAssert (Reserved->SendInProgress);
Reserved->SendInProgress = FALSE;
NbiPushSendPacket (Reserved);
NbiDereferenceDevice (Device, DREF_STATUS_FRAME);
break;
case SEND_TYPE_STATUS_RESPONSE:
//
// This is an adapter status response, we have to free the
// second buffer.
//
CTEAssert (Reserved->SendInProgress);
Reserved->SendInProgress = FALSE;
NdisUnchainBufferAtBack (Packet, &SecondBuffer);
if (SecondBuffer)
{
NdisQueryBufferSafe (SecondBuffer, &SecondBufferMemory, &SecondBufferLength, HighPagePriority);
if (SecondBufferMemory)
{
NbiFreeMemory (SecondBufferMemory, Reserved->u.SR_AS.ActualBufferLength, MEMORY_STATUS,
"Adapter Status");
}
NdisFreeBuffer(SecondBuffer);
}
NbiPushSendPacket (Reserved);
NbiDereferenceDevice (Device, DREF_STATUS_RESPONSE);
break;
#ifdef RSRC_TIMEOUT_DBG
case SEND_TYPE_DEATH_PACKET:
//
// This is a session initialize or session init ack; free
// the second buffer, put the packet back in the pool and
// deref the device.
//
CTEAssert (Reserved->SendInProgress);
Reserved->SendInProgress = FALSE;
DbgPrint("********Death packet send completed status %lx\n",Status);
DbgBreakPoint();
break;
#endif //RSRC_TIMEOUT_DBG
default:
CTEAssert (FALSE);
break;
}
} /* NbiSendComplete */
#if 0
ULONG NbiLoudSendQueue = 1;
#endif
VOID
NbiAssignSequenceAndSend(
IN PCONNECTION Connection,
IN PNDIS_PACKET Packet
IN NB_LOCK_HANDLE_PARAM(LockHandle)
)
/*++
Routine Description:
This routine is used to ensure that receive sequence numbers on
packets are numbered correctly. It is called in place of the lower-level
send handler; after assigning the receive sequence number it locks out
other sends until the NdisSend call has returned (not necessarily completed),
insuring that the packets with increasing receive sequence numbers
are queue in the right order by the MAC.
NOTE: THIS ROUTINE IS CALLED WITH THE CONNECTION LOCK HELD, AND
RETURNS WITH IT RELEASED.
Arguments:
Connection - The connection the send is on.
Packet - The packet to send.
LockHandle - The handle with which Connection->Lock was acquired.
Return Value:
None.
--*/
{
NDIS_STATUS NdisStatus;
PNB_SEND_RESERVED Reserved;
PLIST_ENTRY p;
NB_CONNECTION UNALIGNED * Header;
PDEVICE Device = NbiDevice;
BOOLEAN NdisSendReference;
ULONG result;
Reserved = (PNB_SEND_RESERVED)(Packet->ProtocolReserved);
CTEAssert (Connection->State == CONNECTION_STATE_ACTIVE);
//
// If there is a send in progress, then queue this packet
// and return.
//
if (Connection->NdisSendsInProgress > 0) {
NB_DEBUG2 (SEND, ("Queueing send packet %lx on %lx\n", Reserved, Connection));
InsertTailList (&Connection->NdisSendQueue, &Reserved->WaitLinkage);
++Connection->NdisSendsInProgress;
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
return;
}
//
// No send in progress. Set the flag to true, and fill in the
// receive sequence fields in the packet.
//
Connection->NdisSendsInProgress = 1;
NdisSendReference = FALSE;
Connection->NdisSendReference = &NdisSendReference;
while (TRUE) {
Header = (NB_CONNECTION UNALIGNED *)
(&Reserved->Header[Device->Bind.IncludedHeaderOffset]);
Header->Session.ReceiveSequence = Connection->ReceiveSequence;
if (Connection->NewNetbios) {
Header->Session.ReceiveSequenceMax = Connection->LocalRcvSequenceMax;
} else {
Header->Session.BytesReceived = (USHORT)Connection->CurrentReceive.MessageOffset;
}
//
// Since we are acking as much as we know, we can clear
// this flag. The connection will eventually get removed
// from the queue by the long timeout.
//
Connection->DataAckPending = FALSE;
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
NdisAdjustBufferLength(NB_GET_NBHDR_BUFF(Packet), sizeof(NB_CONNECTION));
NdisStatus = (*Device->Bind.SendHandler)(
&Connection->LocalTarget,
Packet,
Reserved->u.SR_CO.PacketLength,
sizeof(NB_CONNECTION));
if (NdisStatus != NDIS_STATUS_PENDING) {
NbiSendComplete(
Packet,
NdisStatus);
}
//
// Take the ref count down, which may allow others
// to come through.
//
result = NB_ADD_ULONG(
&Connection->NdisSendsInProgress,
(ULONG)-1,
&Connection->Lock);
//
// We have now sent a packet, see if any queued up while we
// were doing it. If the count was zero after removing ours,
// then anything else queued is being processed, so we can
// exit. If the connection was stopped while we were sending,
// a special reference was added which we remove (NbiStopConnection
// sets NdisSendReference to TRUE, using the pointer saved
// in Connection->NdisSendReference).
//
if (result == 1) {
if (NdisSendReference) {
NB_DEBUG2 (SEND, ("Remove CREF_NDIS_SEND from %lx\n", Connection));
NbiDereferenceConnection (Connection, CREF_NDIS_SEND);
}
return;
}
NB_SYNC_GET_LOCK (&Connection->Lock, &LockHandle);
p = RemoveHeadList(&Connection->NdisSendQueue);
//
// If the refcount was not zero, then nobody else should
// have taken packets off since they would have been
// blocked by us. So, the queue should not be empty.
//
ASSERT (p != &Connection->NdisSendQueue);
Reserved = CONTAINING_RECORD (p, NB_SEND_RESERVED, WaitLinkage);
Packet = CONTAINING_RECORD (Reserved, NDIS_PACKET, ProtocolReserved[0]);
} // while loop
//
// We should never reach here.
//
CTEAssert (FALSE);
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
} /* NbiAssignSequenceAndSend */
NTSTATUS
NbiTdiSend(
IN PDEVICE Device,
IN PREQUEST Request
)
/*++
Routine Description:
This routine does a send on an active connection.
Arguments:
Device - The netbios device.
Request - The request describing the send.
Return Value:
NTSTATUS - status of operation.
--*/
{
PCONNECTION Connection;
PTDI_REQUEST_KERNEL_SEND Parameters;
NB_DEFINE_SYNC_CONTEXT (SyncContext)
NB_DEFINE_LOCK_HANDLE (LockHandle)
CTELockHandle CancelLH;
//
// Check that the file type is valid
//
if (REQUEST_OPEN_TYPE(Request) != (PVOID)TDI_CONNECTION_FILE)
{
CTEAssert(FALSE);
return (STATUS_INVALID_ADDRESS_COMPONENT);
}
//
// First make sure the connection is valid.
//
Connection = (PCONNECTION)REQUEST_OPEN_CONTEXT(Request);
if (Connection->Type == NB_CONNECTION_SIGNATURE) {
NB_GET_CANCEL_LOCK( &CancelLH );
NB_BEGIN_SYNC (&SyncContext);
NB_SYNC_GET_LOCK (&Connection->Lock, &LockHandle);
//
// Make sure the connection is in a good state.
//
if (Connection->State == CONNECTION_STATE_ACTIVE) {
//
// If the connection is idle then send it now, otherwise
// queue it.
//
if (!Request->Cancel) {
Parameters = (PTDI_REQUEST_KERNEL_SEND)REQUEST_PARAMETERS(Request);
//
// For old netbios, don't allow sends greater than 64K-1.
//
if ((Connection->NewNetbios) ||
(Parameters->SendLength <= 0xffff)) {
IoSetCancelRoutine (Request, NbiCancelSend);
NB_SYNC_SWAP_IRQL( CancelLH, LockHandle );
NB_FREE_CANCEL_LOCK( CancelLH );
REQUEST_INFORMATION (Request) = Parameters->SendLength; // assume it succeeds.
REQUEST_REFCOUNT (Request) = 1; // refcount starts at 1.
NbiReferenceConnectionSync (Connection, CREF_SEND);
//
// NOTE: The connection send queue is managed such
// that the current send being packetized is not on
// the queue. For multiple-request messages, the
// first one is not on the queue, but its linkage
// field points to the next request in the message
// (which will be on the head of the queue).
//
if ((Parameters->SendFlags & TDI_SEND_PARTIAL) == 0) {
//
// This is a final send.
//
if (Connection->SubState == CONNECTION_SUBSTATE_A_IDLE) {
NB_DEBUG2 (SEND, ("Send %lx, connection %lx idle\n", Request, Connection));
Connection->CurrentSend.Request = Request;
Connection->CurrentSend.MessageOffset = 0;
Connection->CurrentSend.Buffer = REQUEST_NDIS_BUFFER (Request);
Connection->CurrentSend.BufferOffset = 0;
Connection->SendBufferInUse = FALSE;
Connection->UnAckedSend = Connection->CurrentSend;
Connection->FirstMessageRequest = Request;
#ifdef RSRC_TIMEOUT_DBG
KeQuerySystemTime(&Connection->FirstMessageRequestTime);
(((LARGE_INTEGER UNALIGNED *)&(IoGetCurrentIrpStackLocation(Request))->Parameters.Others.Argument3))->QuadPart =
Connection->FirstMessageRequestTime.QuadPart;
#endif //RSRC_TIMEOUT_DBG
Connection->LastMessageRequest = Request;
Connection->CurrentMessageLength = Parameters->SendLength;
//
// This frees the connection lock.
//
NbiPacketizeSend(
Connection
NB_LOCK_HANDLE_ARG(LockHandle)
);
} else if (Connection->SubState == CONNECTION_SUBSTATE_A_W_EOR) {
//
// We have been collecting partial sends waiting
// for a final one, which we have now received,
// so start packetizing.
//
// We chain it on the back of the send queue,
// in addition if this is the second request in the
// message, we have to link the first request (which
// is not on the queue) to this one.
//
//
NB_DEBUG2 (SEND, ("Send %lx, connection %lx got eor\n", Request, Connection));
Connection->LastMessageRequest = Request;
Connection->CurrentMessageLength += Parameters->SendLength;
if (Connection->SendQueue.Head == NULL) {
REQUEST_SINGLE_LINKAGE(Connection->FirstMessageRequest) = Request;
}
REQUEST_SINGLE_LINKAGE(Request) = NULL;
REQUEST_LIST_INSERT_TAIL(&Connection->SendQueue, Request);
Connection->UnAckedSend = Connection->CurrentSend;
#ifdef RSRC_TIMEOUT_DBG
{
LARGE_INTEGER Time;
KeQuerySystemTime(&Time);
(((LARGE_INTEGER UNALIGNED *)&(IoGetCurrentIrpStackLocation(Request))->Parameters.Others.Argument3))->QuadPart =
Time.QuadPart;
}
#endif //RSRC_TIMEOUT_DBG
//
// This frees the connection lock.
//
NbiPacketizeSend(
Connection
NB_LOCK_HANDLE_ARG(LockHandle)
);
} else {
//
// The state is PACKETIZE, W_ACK, or W_PACKET.
//
NB_DEBUG2 (SEND, ("Send %lx, connection %lx busy\n", Request, Connection));
REQUEST_SINGLE_LINKAGE(Request) = NULL;
REQUEST_LIST_INSERT_TAIL(&Connection->SendQueue, Request);
#ifdef RSRC_TIMEOUT_DBG
{
LARGE_INTEGER Time;
KeQuerySystemTime(&Time);
(((LARGE_INTEGER UNALIGNED *)&(IoGetCurrentIrpStackLocation(Request))->Parameters.Others.Argument3))->QuadPart =
Time.QuadPart;
}
#endif //RSRC_TIMEOUT_DBG
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
}
} else {
//
// This is a partial send. We queue them up without
// packetizing until we get a final (this is because
// we have to put a correct Connection->CurrentMessageLength
// in the frames.
//
if (Connection->SubState == CONNECTION_SUBSTATE_A_IDLE) {
//
// Start collecting partial sends. NOTE: Partial sends
// are always inserted in the send queue
//
Connection->CurrentSend.Request = Request;
Connection->CurrentSend.MessageOffset = 0;
Connection->CurrentSend.Buffer = REQUEST_NDIS_BUFFER (Request);
Connection->CurrentSend.BufferOffset = 0;
Connection->SendBufferInUse = FALSE;
Connection->FirstMessageRequest = Request;
#ifdef RSRC_TIMEOUT_DBG
KeQuerySystemTime(&Connection->FirstMessageRequestTime);
(((LARGE_INTEGER UNALIGNED *)&(IoGetCurrentIrpStackLocation(Request))->Parameters.Others.Argument3))->QuadPart =
Connection->FirstMessageRequestTime.QuadPart;
#endif //RSRC_TIMEOUT_DBG
Connection->CurrentMessageLength = Parameters->SendLength;
Connection->SubState = CONNECTION_SUBSTATE_A_W_EOR;
} else if (Connection->SubState == CONNECTION_SUBSTATE_A_W_EOR) {
//
// We have got another partial send to add to our
// list. We chain it on the back of the send queue,
// in addition if this is the second request in the
// message, we have to link the first request (which
// is not on the queue) to this one.
//
Connection->LastMessageRequest = Request;
Connection->CurrentMessageLength += Parameters->SendLength;
if (Connection->SendQueue.Head == NULL) {
REQUEST_SINGLE_LINKAGE(Connection->FirstMessageRequest) = Request;
}
REQUEST_SINGLE_LINKAGE(Request) = NULL;
REQUEST_LIST_INSERT_TAIL(&Connection->SendQueue, Request);
#ifdef RSRC_TIMEOUT_DBG
{
LARGE_INTEGER Time;
KeQuerySystemTime(&Time);
(((LARGE_INTEGER UNALIGNED *)&(IoGetCurrentIrpStackLocation(Request))->Parameters.Others.Argument3))->QuadPart =
Time.QuadPart;
}
#endif //RSRC_TIMEOUT_DBG
} else {
REQUEST_SINGLE_LINKAGE(Request) = NULL;
REQUEST_LIST_INSERT_TAIL(&Connection->SendQueue, Request);
#ifdef RSRC_TIMEOUT_DBG
{
LARGE_INTEGER Time;
KeQuerySystemTime(&Time);
(((LARGE_INTEGER UNALIGNED *)&(IoGetCurrentIrpStackLocation(Request))->Parameters.Others.Argument3))->QuadPart =
Time.QuadPart;
}
#endif //RSRC_TIMEOUT_DBG
}
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
}
NB_END_SYNC (&SyncContext);
return STATUS_PENDING;
} else {
NB_DEBUG2 (SEND, ("Send %lx, too long for connection %lx (%d)\n", Request, Connection, Parameters->SendLength));
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
NB_END_SYNC (&SyncContext);
NB_FREE_CANCEL_LOCK( CancelLH );
return STATUS_INVALID_PARAMETER;
}
} else {
NB_DEBUG2 (SEND, ("Send %lx, connection %lx cancelled\n", Request, Connection));
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
NB_END_SYNC (&SyncContext);
NB_FREE_CANCEL_LOCK( CancelLH );
return STATUS_CANCELLED;
}
} else {
NB_DEBUG (SEND, ("Send connection %lx state is %d\n", Connection, Connection->State));
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
NB_END_SYNC (&SyncContext);
NB_FREE_CANCEL_LOCK( CancelLH );
return STATUS_INVALID_CONNECTION;
}
} else {
NB_DEBUG (SEND, ("Send connection %lx has bad signature\n", Connection));
return STATUS_INVALID_CONNECTION;
}
} /* NbiTdiSend */
VOID
NbiPacketizeSend(
IN PCONNECTION Connection
IN NB_LOCK_HANDLE_PARAM(LockHandle)
)
/*++
Routine Description:
This routine does a send on an active connection.
NOTE: THIS FUNCTION IS CALLED WITH CONNECTION->LOCK HELD
AND RETURNS WITH IT RELEASED.
Arguments:
Connection - The connection.
LockHandle - The handle used to acquire the lock.
Return Value:
None.
--*/
{
PREQUEST Request;
PNDIS_PACKET Packet;
PNDIS_BUFFER BufferChain;
PNB_SEND_RESERVED Reserved;
PDEVICE Device = NbiDevice;
NB_CONNECTION UNALIGNED * Header;
ULONG PacketLength;
ULONG PacketSize;
ULONG DesiredLength;
ULONG ActualLength;
NTSTATUS Status;
PSLIST_ENTRY s;
USHORT ThisSendSequence;
USHORT ThisOffset;
BOOLEAN ExitAfterSend;
UCHAR ConnectionControlFlag;
CTELockHandle DeviceLockHandle;
//
// We jump back here if we are talking new Netbios and it
// is OK to packetize another send.
//
SendAnotherPacket:
//
// If we decide to packetize another send after this, we
// change ExitAfterSend to FALSE and SubState to PACKETIZE.
// Right now we don't change SubState in case it is W_PACKET.
//
ExitAfterSend = TRUE;
CTEAssert (Connection->CurrentSend.Request != NULL);
if (Connection->NewNetbios) {
//
// Check that we have send window, both that advertised
// by the remote and our own locally-decided window which
// may be smaller.
//
if (((USHORT)(Connection->CurrentSend.SendSequence-1) == Connection->RemoteRcvSequenceMax) ||
(((USHORT)(Connection->CurrentSend.SendSequence - Connection->UnAckedSend.SendSequence)) >= Connection->SendWindowSize)) {
//
// Keep track of whether we are waiting because of his window
// or because of our local window. If it is because of our local
// window then we may want to adjust it after this window
// is acked.
//
if ((USHORT)(Connection->CurrentSend.SendSequence-1) != Connection->RemoteRcvSequenceMax) {
Connection->SubState = CONNECTION_SUBSTATE_A_W_ACK;
NB_DEBUG2 (SEND, ("Connection %lx local shut down at %lx, %lx\n", Connection, Connection->CurrentSend.SendSequence, Connection->UnAckedSend.SendSequence));
} else {
Connection->SubState = CONNECTION_SUBSTATE_A_REMOTE_W;
NB_DEBUG2 (SEND, ("Connection %lx remote shut down at %lx\n", Connection, Connection->CurrentSend.SendSequence));
}
//
// Start the timer so we will keep bugging him about
// this. What if he doesn't get a receive down
// quickly -- but this is better than losing his ack
// and then dying. We won't really back off our timer
// because we will keep getting acks, and resetting it.
//
NbiStartRetransmit (Connection);
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
return;
}
}
Request = Connection->CurrentSend.Request;
//
// If we are in this routine then we know that
// we are coming out of IDLE, W_ACK, or W_PACKET
// and we still have the lock held. We also know
// that there is a send request in progress. If
// an ack for none or part of the last packet was
// received, then our send pointers have been
// adjusted to reflect that.
//
//
// First get a packet for the current send.
//
if (!Connection->SendPacketInUse) {
Connection->SendPacketInUse = TRUE;
Packet = PACKET(&Connection->SendPacket);
Reserved = (PNB_SEND_RESERVED)(Packet->ProtocolReserved);
} else {
s = ExInterlockedPopEntrySList(
&Device->SendPacketList,
&NbiGlobalPoolInterlock);
if (s == NULL) {
//
// This function tries to allocate another packet pool.
//
s = NbiPopSendPacket(Device, FALSE);
if (s == NULL) {
//
// It is possible to come in here and already be in
// W_PACKET state -- this is because we may packetize
// when in that state, and rather than always be
// checking that we weren't in W_PACKET, we go
// ahead and check again here.
//
if (Connection->SubState != CONNECTION_SUBSTATE_A_W_PACKET) {
Connection->SubState = CONNECTION_SUBSTATE_A_W_PACKET;
NB_GET_LOCK (&Device->Lock, &DeviceLockHandle);
if (!Connection->OnWaitPacketQueue) {
NbiReferenceConnectionLock (Connection, CREF_W_PACKET);
Connection->OnWaitPacketQueue = TRUE;
InsertTailList(
&Device->WaitPacketConnections,
&Connection->WaitPacketLinkage
);
// NB_INSERT_TAIL_LIST(
// &Device->WaitPacketConnections,
// &Connection->WaitPacketLinkage,
// &Device->Lock);
}
NB_FREE_LOCK (&Device->Lock, DeviceLockHandle);
}
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
return;
}
}
Reserved = CONTAINING_RECORD (s, NB_SEND_RESERVED, PoolLinkage);
Packet = CONTAINING_RECORD (Reserved, NDIS_PACKET, ProtocolReserved[0]);
}
//
// Set this now, we will change it later if needed.
//
Connection->SubState = CONNECTION_SUBSTATE_A_W_ACK;
//
// Save these since they go in this next packet.
//
ThisSendSequence = Connection->CurrentSend.SendSequence;
ThisOffset = (USHORT)Connection->CurrentSend.MessageOffset;
//
// Now see if we need to copy the buffer chain.
//
PacketSize = Connection->MaximumPacketSize;
if (Connection->CurrentSend.MessageOffset + PacketSize >= Connection->CurrentMessageLength) {
PacketSize = Connection->CurrentMessageLength - Connection->CurrentSend.MessageOffset;
if ((Connection->CurrentSend.MessageOffset == 0) &&
(!Connection->SendBufferInUse)) {
//
// If the entire send remaining fits in one packet,
// and this is also the first packet in the send,
// then the entire send fits in one packet and
// we don't need to build a duplicate buffer chain.
//
BufferChain = Connection->CurrentSend.Buffer;
Reserved->u.SR_CO.NoNdisBuffer = TRUE;
Connection->CurrentSend.Buffer = NULL;
Connection->CurrentSend.BufferOffset = 0;
Connection->CurrentSend.MessageOffset = Connection->CurrentMessageLength;
Connection->CurrentSend.Request = NULL;
++Connection->CurrentSend.SendSequence;
Connection->SendBufferInUse = TRUE;
if (Connection->NewNetbios) {
if ((ThisSendSequence == Connection->RemoteRcvSequenceMax) ||
((((PTDI_REQUEST_KERNEL_SEND)REQUEST_PARAMETERS(Request))->SendFlags) &
TDI_SEND_NO_RESPONSE_EXPECTED)) { // optimize this check
ConnectionControlFlag = NB_CONTROL_EOM | NB_CONTROL_SEND_ACK;
} else {
ConnectionControlFlag = NB_CONTROL_EOM;
}
Connection->PiggybackAckTimeout = FALSE;
} else {
ConnectionControlFlag = NB_CONTROL_SEND_ACK;
}
if (BufferChain != NULL) {
NB_DEBUG2 (SEND, ("Send packet %lx on %lx (%d/%d), user buffer\n",
Reserved, Connection,
Connection->CurrentSend.SendSequence,
Connection->CurrentSend.MessageOffset));
NdisChainBufferAtBack (Packet, BufferChain);
} else {
NB_DEBUG2 (SEND, ("Send packet %lx on %lx (%d/%d), no buffer\n",
Reserved, Connection,
Connection->CurrentSend.SendSequence,
Connection->CurrentSend.MessageOffset));
}
goto GotBufferChain;
}
}
//
// We need to build a partial buffer chain. In the case
// where the current request is a partial one, we may
// build this from the ndis buffer chains of several
// requests.
//
if (PacketSize > 0) {
DesiredLength = PacketSize;
NB_DEBUG2 (SEND, ("Send packet %lx on %lx (%d/%d), allocate buffer\n",
Reserved, Connection,
Connection->CurrentSend.SendSequence,
Connection->CurrentSend.MessageOffset));
while (TRUE) {
Status = NbiBuildBufferChainFromBufferChain (
Device->NdisBufferPoolHandle,
Connection->CurrentSend.Buffer,
Connection->CurrentSend.BufferOffset,
DesiredLength,
&BufferChain,
&Connection->CurrentSend.Buffer,
&Connection->CurrentSend.BufferOffset,
&ActualLength);
if (Status != STATUS_SUCCESS) {
PNDIS_BUFFER CurBuffer, TmpBuffer;
NB_DEBUG2 (SEND, ("Allocate buffer chain failed for packet %lx\n", Reserved));
//
// We could not allocate resources for this send.
// We'll put the connection on the packetize
// queue and hope we get more resources later.
//
NbiReferenceConnectionSync (Connection, CREF_PACKETIZE);
CTEAssert (!Connection->OnPacketizeQueue);
Connection->OnPacketizeQueue = TRUE;
//
// Connection->CurrentSend can stay where it is.
//
NB_INSERT_TAIL_LIST(
&Device->PacketizeConnections,
&Connection->PacketizeLinkage,
&Device->Lock);
Connection->SubState = CONNECTION_SUBSTATE_A_PACKETIZE;
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
//
// Free any buffers we have allocated on previous calls
// to BuildBufferChain inside this same while(TRUE) loop,
// then free the packet.
//
CurBuffer = NDIS_BUFFER_LINKAGE (NDIS_BUFFER_LINKAGE(Reserved->HeaderBuffer));
while (CurBuffer) {
TmpBuffer = NDIS_BUFFER_LINKAGE (CurBuffer);
NdisFreeBuffer (CurBuffer);
CurBuffer = TmpBuffer;
}
NDIS_BUFFER_LINKAGE (NDIS_BUFFER_LINKAGE(Reserved->HeaderBuffer)) = NULL;
NdisRecalculatePacketCounts (Packet);
if (Reserved->OwnedByConnection) {
Connection->SendPacketInUse = FALSE;
} else {
NbiPushSendPacket(Reserved);
}
return;
}
NdisChainBufferAtBack (Packet, BufferChain);
Connection->CurrentSend.MessageOffset += ActualLength;
DesiredLength -= ActualLength;
if (DesiredLength == 0) {
//
// We have gotten enough data for our packet.
//
if (Connection->CurrentSend.MessageOffset == Connection->CurrentMessageLength) {
Connection->CurrentSend.Request = NULL;
}
break;
}
//
// We ran out of buffer chain on this send, which means
// that we must have another one behind it (since we
// don't start packetizing partial sends until all of
// them are queued).
//
Request = REQUEST_SINGLE_LINKAGE(Request);
if (Request == NULL) {
KeBugCheck (NDIS_INTERNAL_ERROR);
}
Connection->CurrentSend.Request = Request;
Connection->CurrentSend.Buffer = REQUEST_NDIS_BUFFER (Request);
Connection->CurrentSend.BufferOffset = 0;
}
} else {
//
// This is a zero-length send (in general we will go
// through the code before the if that uses the user's
// buffer, but not on a resend).
//
Connection->CurrentSend.Buffer = NULL;
Connection->CurrentSend.BufferOffset = 0;
CTEAssert (Connection->CurrentSend.MessageOffset == Connection->CurrentMessageLength);
Connection->CurrentSend.Request = NULL;
NB_DEBUG2 (SEND, ("Send packet %lx on %lx (%d/%d), no alloc buf\n",
Reserved, Connection,
Connection->CurrentSend.SendSequence,
Connection->CurrentSend.MessageOffset));
}
Reserved->u.SR_CO.NoNdisBuffer = FALSE;
if (Connection->NewNetbios) {
++Connection->CurrentSend.SendSequence;
if (Connection->CurrentSend.MessageOffset == Connection->CurrentMessageLength) {
if (((USHORT)(Connection->CurrentSend.SendSequence - Connection->UnAckedSend.SendSequence)) >= Connection->SendWindowSize) {
ConnectionControlFlag = NB_CONTROL_EOM | NB_CONTROL_SEND_ACK;
} else if ((ThisSendSequence == Connection->RemoteRcvSequenceMax) ||
((((PTDI_REQUEST_KERNEL_SEND)REQUEST_PARAMETERS(Request))->SendFlags) &
TDI_SEND_NO_RESPONSE_EXPECTED)) { // optimize this check
ConnectionControlFlag = NB_CONTROL_EOM | NB_CONTROL_SEND_ACK;
} else {
ConnectionControlFlag = NB_CONTROL_EOM;
}
Connection->PiggybackAckTimeout = FALSE;
} else if (((USHORT)(Connection->CurrentSend.SendSequence - Connection->UnAckedSend.SendSequence)) >= Connection->SendWindowSize) {
ConnectionControlFlag = NB_CONTROL_SEND_ACK;
} else if (ThisSendSequence == Connection->RemoteRcvSequenceMax) {
ConnectionControlFlag = NB_CONTROL_SEND_ACK;
} else {
ConnectionControlFlag = 0;
ExitAfterSend = FALSE;
Connection->SubState = CONNECTION_SUBSTATE_A_PACKETIZE;
}
} else {
ConnectionControlFlag = NB_CONTROL_SEND_ACK;
if (Connection->CurrentSend.MessageOffset == Connection->CurrentMessageLength) {
++Connection->CurrentSend.SendSequence;
}
}
GotBufferChain:
//
// We have a packet and a buffer chain, there are
// no other resources required for a send so we can
// fill in the header and go.
//
CTEAssert (Reserved->SendInProgress == FALSE);
Reserved->SendInProgress = TRUE;
Reserved->Type = SEND_TYPE_SESSION_DATA;
Reserved->u.SR_CO.Connection = Connection;
Reserved->u.SR_CO.Request = Connection->FirstMessageRequest;
PacketLength = PacketSize + sizeof(NB_CONNECTION);
Reserved->u.SR_CO.PacketLength = PacketLength;
Header = (NB_CONNECTION UNALIGNED *)
(&Reserved->Header[Device->Bind.IncludedHeaderOffset]);
RtlCopyMemory((PVOID)&Header->IpxHeader, &Connection->RemoteHeader, sizeof(IPX_HEADER));
Header->IpxHeader.PacketLength[0] = (UCHAR)(PacketLength / 256);
Header->IpxHeader.PacketLength[1] = (UCHAR)(PacketLength % 256);
Header->IpxHeader.PacketType = 0x04;
//
// Now fill in the Netbios header. Put this in
// a contiguous buffer in the connection ?
//
Header->Session.ConnectionControlFlag = ConnectionControlFlag;
Header->Session.DataStreamType = NB_CMD_SESSION_DATA;
Header->Session.SourceConnectionId = Connection->LocalConnectionId;
Header->Session.DestConnectionId = Connection->RemoteConnectionId;
Header->Session.SendSequence = ThisSendSequence;
Header->Session.TotalDataLength = (USHORT)Connection->CurrentMessageLength;
Header->Session.Offset = ThisOffset;
Header->Session.DataLength = (USHORT)PacketSize;
#if 0
//
// These are set by NbiAssignSequenceAndSend.
//
Header->Session.ReceiveSequence = Connection->ReceiveSequence;
Header->Session.BytesReceived = (USHORT)Connection->CurrentReceive.MessageOffset;
#endif
//
// Reference the request to account for this send.
//
#if DBG
if (REQUEST_REFCOUNT(Request) > 100) {
DbgPrint ("Request %lx (%lx) has high refcount\n",
Connection, Request);
DbgBreakPoint();
}
#endif
++REQUEST_REFCOUNT (Request);
++Device->TempFramesSent;
Device->TempFrameBytesSent += PacketSize;
//
// Start the timer.
//
NbiStartRetransmit (Connection);
//
// This frees the lock. IPX will adjust the length of
// the first buffer correctly.
//
NbiAssignSequenceAndSend(
Connection,
Packet
NB_LOCK_HANDLE_ARG(LockHandle));
if (!ExitAfterSend) {
//
// Did we need to reference the connection until we
// get the lock back??
//
NB_SYNC_GET_LOCK (&Connection->Lock, &LockHandle);
if ((Connection->State == CONNECTION_STATE_ACTIVE) &&
(Connection->SubState == CONNECTION_SUBSTATE_A_PACKETIZE)) {
//
// Jump back to the beginning of the function to
// repacketize.
goto SendAnotherPacket;
} else {
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
}
}
} /* NbiPacketizeSend */
VOID
NbiAdjustSendWindow(
IN PCONNECTION Connection
)
/*++
Routine Description:
This routine adjusts a connection's send window if needed. It is
assumed that we just got an ack for a full send window.
NOTE: THIS FUNCTION IS CALLED WITH CONNECTION->LOCK HELD
AND RETURNS WITH IT HELD.
Arguments:
Connection - The connection.
Return Value:
None.
--*/
{
if (Connection->RetransmitThisWindow) {
//
// Move it down. Check if this keeps happening.
//
if (Connection->SendWindowSize > 2) {
--Connection->SendWindowSize;
NB_DEBUG2 (SEND_WINDOW, ("Lower window to %d on %lx (%lx)\n", Connection->SendWindowSize, Connection, Connection->CurrentSend.SendSequence));
}
if (Connection->SendWindowIncrease) {
//
// We just increased the window.
//
++Connection->IncreaseWindowFailures;
NB_DEBUG2 (SEND_WINDOW, ("%d consecutive increase failues on %lx (%lx)\n", Connection->IncreaseWindowFailures, Connection, Connection->CurrentSend.SendSequence));
if (Connection->IncreaseWindowFailures >= 2) {
if (Connection->MaxSendWindowSize > 2) {
//
// Lock ourselves at a smaller window.
//
Connection->MaxSendWindowSize = Connection->SendWindowSize;
NB_DEBUG2 (SEND_WINDOW, ("Lock send window at %d on %lx (%lx)\n", Connection->MaxSendWindowSize, Connection, Connection->CurrentSend.SendSequence));
}
Connection->IncreaseWindowFailures = 0;
}
Connection->SendWindowIncrease = FALSE;
}
} else {
//
// Increase it if allowed, and make a note
// in case this increase causes problems in
// the next window.
//
if (Connection->SendWindowSize < Connection->MaxSendWindowSize) {
++Connection->SendWindowSize;
NB_DEBUG2 (SEND_WINDOW, ("Raise window to %d on %lx (%lx)\n", Connection->SendWindowSize, Connection, Connection->CurrentSend.SendSequence));
Connection->SendWindowIncrease = TRUE;
} else {
if (Connection->SendWindowIncrease) {
//
// We just increased it and nothing failed,
// which is good.
//
Connection->SendWindowIncrease = FALSE;
Connection->IncreaseWindowFailures = 0;
NB_DEBUG2 (SEND_WINDOW, ("Raised window OK on %lx (%lx)\n", Connection, Connection->CurrentSend.SendSequence));
}
}
}
//
// This controls when we'll check this again.
//
Connection->SendWindowSequenceLimit += Connection->SendWindowSize;
} /* NbiAdjustSendWindow */
VOID
NbiReframeConnection(
IN PCONNECTION Connection,
IN USHORT ReceiveSequence,
IN USHORT BytesReceived,
IN BOOLEAN Resend
IN NB_LOCK_HANDLE_PARAM(LockHandle)
)
/*++
Routine Description:
This routine is called when we have gotten an ack
for some data. It completes any sends that have
been acked, and if needed modifies the current send
pointer and queues the connection for repacketizing.
NOTE: THIS FUNCTION IS CALLED WITH CONNECTION->LOCK HELD
AND RETURNS WITH IT RELEASED.
Arguments:
Connection - The connection.
ReceiveSequence - The receive sequence from the remote.
BytesReceived - The number of bytes received in this message.
Resend - If it is OK to resend based on this packet.
LockHandle - The handle with which Connection->Lock was acquired.
Return Value:
None.
--*/
{
PREQUEST Request, TmpRequest;
PREQUEST RequestToComplete;
PDEVICE Device = NbiDevice;
CTELockHandle CancelLH;
//
// We should change to stop the timer
// only if we go idle, since otherwise we still
// want it running, or will restart it when we
// packetize.
//
//
// See how much is acked here.
//
if ((Connection->CurrentSend.MessageOffset == Connection->CurrentMessageLength) &&
(ReceiveSequence == (USHORT)(Connection->CurrentSend.SendSequence)) &&
(Connection->FirstMessageRequest != NULL)) {
// Special check for 0 length send which was not accepted by the remote.
// In this case it will pass the above 3 conditions yet, nothing
// is acked. BUG#10395
if (!Connection->CurrentSend.MessageOffset && Connection->CurrentSend.SendSequence == Connection->UnAckedSend.SendSequence ) {
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
return;
}
//
// This acks the entire message.
//
NB_DEBUG2 (SEND, ("Got ack for entire message on %lx (%d)\n", Connection, Connection->CurrentSend.SendSequence));
NbiStopRetransmit (Connection);
Connection->CurrentSend.MessageOffset = 0; // Needed?
Connection->UnAckedSend.MessageOffset = 0;
//
// We don't adjust the send window since we likely stopped
// packetizing before we hit it.
//
Connection->Retries = NbiDevice->KeepAliveCount;
Connection->CurrentRetransmitTimeout = Connection->BaseRetransmitTimeout;
if (Connection->NewNetbios) {
Connection->RemoteRcvSequenceMax = BytesReceived; // really RcvSeqMac
//
// See if we need to adjust our send window.
//
if (((SHORT)(Connection->CurrentSend.SendSequence - Connection->SendWindowSequenceLimit)) >= 0) {
NbiAdjustSendWindow (Connection);
} else {
//
// Advance this, we won't get meaningful results until we
// send a full window in one message.
//
Connection->SendWindowSequenceLimit = Connection->CurrentSend.SendSequence + Connection->SendWindowSize;
}
}
Connection->RetransmitThisWindow = FALSE;
Request = Connection->FirstMessageRequest;
//
// We dequeue these requests from the connection's
// send queue.
//
if (Connection->FirstMessageRequest == Connection->LastMessageRequest) {
REQUEST_SINGLE_LINKAGE (Request) = NULL;
} else {
Connection->SendQueue.Head = REQUEST_SINGLE_LINKAGE (Connection->LastMessageRequest);
REQUEST_SINGLE_LINKAGE (Connection->LastMessageRequest) = NULL;
}
#if DBG
if (REQUEST_REFCOUNT(Request) > 100) {
DbgPrint ("Request %lx (%lx) has high refcount\n",
Connection, Request);
DbgBreakPoint();
}
#endif
if (--REQUEST_REFCOUNT(Request) == 0) {
RequestToComplete = Request;
} else {
//
// There are still sends pending, this will get
// completed when the last send completes. Since
// we have already unlinked the request from the
// connection's send queue we can do this without
// any locks.
//
RequestToComplete = NULL;
}
//
// Now see if there is a send to activate.
//
NbiRestartConnection (Connection);
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
//
// Now complete any requests we need to.
//
while (RequestToComplete != NULL) {
TmpRequest = REQUEST_SINGLE_LINKAGE (RequestToComplete);
REQUEST_STATUS (RequestToComplete) = STATUS_SUCCESS;
NB_GET_CANCEL_LOCK( &CancelLH );
IoSetCancelRoutine (RequestToComplete, (PDRIVER_CANCEL)NULL);
NB_FREE_CANCEL_LOCK( CancelLH );
NbiCompleteRequest (RequestToComplete);
NbiFreeRequest (Device, RequestToComplete);
++Connection->ConnectionInfo.TransmittedTsdus;
RequestToComplete = TmpRequest;
NbiDereferenceConnection (Connection, CREF_SEND);
}
} else if ((ReceiveSequence == Connection->CurrentSend.SendSequence) &&
(Connection->NewNetbios || (BytesReceived == Connection->CurrentSend.MessageOffset)) &&
(Connection->CurrentSend.Request != NULL)) {
//
// This acks whatever we sent last time, and we are
// not done packetizing this send, so we can repacketize.
// With SendSequence changing as it does now,
// don't need the CurrentSend.Request check???
//
NB_DEBUG2 (SEND, ("Got full ack on %lx (%d)\n", Connection, Connection->CurrentSend.SendSequence));
NbiStopRetransmit (Connection);
if (Connection->NewNetbios) {
//
// If we are waiting for a window, and this does not open it
// anymore, then we don't reset our timers/retries.
//
if (Connection->SubState == CONNECTION_SUBSTATE_A_REMOTE_W) {
if (Connection->RemoteRcvSequenceMax != BytesReceived) {
Connection->RemoteRcvSequenceMax = BytesReceived; // really RcvSeqMac
Connection->Retries = NbiDevice->KeepAliveCount;
Connection->CurrentRetransmitTimeout = Connection->BaseRetransmitTimeout;
}
//
// Advance this, we won't get meaningful results until we
// send a full window in one message.
//
Connection->SendWindowSequenceLimit = Connection->CurrentSend.SendSequence + Connection->SendWindowSize;
} else {
Connection->Retries = NbiDevice->KeepAliveCount;
Connection->CurrentRetransmitTimeout = Connection->BaseRetransmitTimeout;
Connection->RemoteRcvSequenceMax = BytesReceived; // really RcvSeqMac
if (((SHORT)(Connection->CurrentSend.SendSequence - Connection->SendWindowSequenceLimit)) >= 0) {
NbiAdjustSendWindow (Connection);
} else {
//
// Advance this, we won't get meaningful results until we
// send a full window in one message.
//
Connection->SendWindowSequenceLimit = Connection->CurrentSend.SendSequence + Connection->SendWindowSize;
}
}
} else {
Connection->Retries = NbiDevice->KeepAliveCount;
Connection->CurrentRetransmitTimeout = Connection->BaseRetransmitTimeout;
}
Connection->RetransmitThisWindow = FALSE;
Connection->UnAckedSend = Connection->CurrentSend;
if (Connection->SubState != CONNECTION_SUBSTATE_A_PACKETIZE) {
//
// We may be on if this ack is duplicated.
//
NbiReferenceConnectionSync (Connection, CREF_PACKETIZE);
CTEAssert(!Connection->OnPacketizeQueue);
Connection->OnPacketizeQueue = TRUE;
NB_INSERT_TAIL_LIST(
&Device->PacketizeConnections,
&Connection->PacketizeLinkage,
&Device->Lock);
Connection->SubState = CONNECTION_SUBSTATE_A_PACKETIZE;
}
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
} else if( Connection->FirstMessageRequest ) {
//
// This acked part of the current send. If the
// remote is requesting a resend then we advance
// the current send location by the amount
// acked and resend from there. If he does
// not want a resend, just ignore this.
//
// We repacketize immediately because we have
// backed up the pointer, and this would
// cause us to ignore an ack for the amount
// sent. Since we don't release the lock
// until we have packetized, the current
// pointer will be advanced past there.
//
// If he is acking more than we sent, we
// ignore this -- the remote is confused and there
// is nothing much we can do.
//
if (Resend) {
if (Connection->NewNetbios &&
(((Connection->UnAckedSend.SendSequence < Connection->CurrentSend.SendSequence) &&
(ReceiveSequence >= Connection->UnAckedSend.SendSequence) &&
(ReceiveSequence < Connection->CurrentSend.SendSequence)) ||
((Connection->UnAckedSend.SendSequence > Connection->CurrentSend.SendSequence) &&
((ReceiveSequence >= Connection->UnAckedSend.SendSequence) ||
(ReceiveSequence < Connection->CurrentSend.SendSequence))))) {
BOOLEAN SomethingAcked = (BOOLEAN)
(ReceiveSequence != Connection->UnAckedSend.SendSequence);
//
// New netbios and the receive sequence is valid.
//
NbiStopRetransmit (Connection);
//
// Advance our unacked pointer by the amount
// acked in this response.
//
NbiAdvanceUnAckedBySequence(
Connection,
ReceiveSequence);
Connection->RetransmitThisWindow = TRUE;
++Connection->ConnectionInfo.TransmissionErrors;
++Device->Statistics.DataFramesResent;
ADD_TO_LARGE_INTEGER(
&Device->Statistics.DataFrameBytesResent,
Connection->CurrentSend.MessageOffset - Connection->UnAckedSend.MessageOffset);
//
// Packetize from that point on.
//
Connection->CurrentSend = Connection->UnAckedSend;
//
// If anything was acked, then reset the retry count.
//
if (SomethingAcked) {
//
// See if we need to adjust our send window.
//
if (((SHORT)(Connection->UnAckedSend.SendSequence - Connection->SendWindowSequenceLimit)) >= 0) {
NbiAdjustSendWindow (Connection);
}
Connection->Retries = NbiDevice->KeepAliveCount;
Connection->CurrentRetransmitTimeout = Connection->BaseRetransmitTimeout;
}
Connection->RemoteRcvSequenceMax = BytesReceived; // really RcvSeqMac
//
// Now packetize. This will set the state to
// something meaningful and release the lock.
//
if (Connection->SubState != CONNECTION_SUBSTATE_A_PACKETIZE) {
NbiPacketizeSend(
Connection
NB_LOCK_HANDLE_ARG(LockHandle)
);
} else {
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
}
} else if (!Connection->NewNetbios &&
((ReceiveSequence == Connection->UnAckedSend.SendSequence) &&
(BytesReceived <= Connection->CurrentSend.MessageOffset))) {
ULONG BytesAcked =
BytesReceived - Connection->UnAckedSend.MessageOffset;
//
// Old netbios.
//
NbiStopRetransmit (Connection);
//
// Advance our unacked pointer by the amount
// acked in this response.
//
NbiAdvanceUnAckedByBytes(
Connection,
BytesAcked);
++Connection->ConnectionInfo.TransmissionErrors;
++Device->Statistics.DataFramesResent;
ADD_TO_LARGE_INTEGER(
&Device->Statistics.DataFrameBytesResent,
Connection->CurrentSend.MessageOffset - Connection->UnAckedSend.MessageOffset);
//
// Packetize from that point on.
//
Connection->CurrentSend = Connection->UnAckedSend;
//
// If anything was acked, reset the retry count
//
if ( BytesAcked ) {
Connection->Retries = NbiDevice->KeepAliveCount;
Connection->CurrentRetransmitTimeout = Connection->BaseRetransmitTimeout;
}
//
// Now packetize. This will set the state to
// something meaningful and release the lock.
//
if (Connection->SubState != CONNECTION_SUBSTATE_A_PACKETIZE) {
NbiPacketizeSend(
Connection
NB_LOCK_HANDLE_ARG(LockHandle)
);
} else {
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
}
} else {
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
}
} else {
if (Connection->NewNetbios &&
(((Connection->UnAckedSend.SendSequence < Connection->CurrentSend.SendSequence) &&
(ReceiveSequence >= Connection->UnAckedSend.SendSequence) &&
(ReceiveSequence < Connection->CurrentSend.SendSequence)) ||
((Connection->UnAckedSend.SendSequence > Connection->CurrentSend.SendSequence) &&
((ReceiveSequence >= Connection->UnAckedSend.SendSequence) ||
(ReceiveSequence < Connection->CurrentSend.SendSequence))))) {
BOOLEAN SomethingAcked = (BOOLEAN)
(ReceiveSequence != Connection->UnAckedSend.SendSequence);
//
// New netbios and the receive sequence is valid. We advance
// the back of our send window, but we don't repacketize.
//
//
// Advance our unacked pointer by the amount
// acked in this response.
//
NbiAdvanceUnAckedBySequence(
Connection,
ReceiveSequence);
Connection->RemoteRcvSequenceMax = BytesReceived; // really RcvSeqMac
//
// If anything was acked, then reset the retry count.
//
if (SomethingAcked) {
//
// See if we need to adjust our send window.
//
if (((SHORT)(Connection->UnAckedSend.SendSequence - Connection->SendWindowSequenceLimit)) >= 0) {
NbiAdjustSendWindow (Connection);
}
Connection->Retries = NbiDevice->KeepAliveCount;
Connection->CurrentRetransmitTimeout = Connection->BaseRetransmitTimeout;
//
// Now packetize. This will set the state to
// something meaningful and release the lock.
//
if ((Connection->CurrentSend.Request != NULL) &&
(Connection->SubState != CONNECTION_SUBSTATE_A_PACKETIZE)) {
NbiReferenceConnectionSync (Connection, CREF_PACKETIZE);
CTEAssert(!Connection->OnPacketizeQueue);
Connection->OnPacketizeQueue = TRUE;
Connection->SubState = CONNECTION_SUBSTATE_A_PACKETIZE;
NB_INSERT_TAIL_LIST(
&Device->PacketizeConnections,
&Connection->PacketizeLinkage,
&Device->Lock);
}
}
}
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
}
} else {
NB_SYNC_FREE_LOCK (&Connection->Lock, LockHandle);
}
} /* NbiReframeConnection */
VOID
NbiRestartConnection(
IN PCONNECTION Connection
)
/*++
Routine Description:
This routine is called when have gotten an ack for
a full message, or received a response to a watchdog
probe, and need to check if the connection should
start packetizing.
NOTE: THIS FUNCTION IS CALLED WITH CONNECTION->LOCK HELD
AND RETURNS WITH IT HELD.
Arguments:
Connection - The connection.
Return Value:
None.
--*/
{
PREQUEST Request, TmpRequest;
ULONG TempCount;
PTDI_REQUEST_KERNEL_SEND Parameters;
PDEVICE Device = NbiDevice;
//
// See if there is a send to activate.
//
if (Connection->SendQueue.Head != NULL) {
//
// Take the first send off the queue and make
// it current.
//
Request = Connection->SendQueue.Head;
Connection->SendQueue.Head = REQUEST_SINGLE_LINKAGE (Request);
//
// Cache the information about being EOM
// in a more easily accessible location?
//
Parameters = (PTDI_REQUEST_KERNEL_SEND)REQUEST_PARAMETERS(Request);
if ((Parameters->SendFlags & TDI_SEND_PARTIAL) == 0) {
//
// This is a one-request message.
//
Connection->CurrentSend.Request = Request;
Connection->CurrentSend.MessageOffset = 0;
Connection->CurrentSend.Buffer = REQUEST_NDIS_BUFFER (Request);
Connection->CurrentSend.BufferOffset = 0;
Connection->SendBufferInUse = FALSE;
Connection->UnAckedSend = Connection->CurrentSend;
Connection->FirstMessageRequest = Request;
#ifdef RSRC_TIMEOUT_DBG
KeQuerySystemTime(&Connection->FirstMessageRequestTime);
#endif //RSRC_TIMEOUT_DBG
Connection->LastMessageRequest = Request;
Connection->CurrentMessageLength = Parameters->SendLength;
Connection->SubState = CONNECTION_SUBSTATE_A_PACKETIZE;
NbiReferenceConnectionSync (Connection, CREF_PACKETIZE);
CTEAssert (!Connection->OnPacketizeQueue);
Connection->OnPacketizeQueue = TRUE;
NB_INSERT_TAIL_LIST(
&Device->PacketizeConnections,
&Connection->PacketizeLinkage,
&Device->Lock);
} else {
//
// This is a multiple-request message. We scan
// to see if we have the end of message received
// yet.
//
TempCount = Parameters->SendLength;
TmpRequest = Request;
Request = REQUEST_SINGLE_LINKAGE(Request);
while (Request != NULL) {
TempCount += Parameters->SendLength;
Parameters = (PTDI_REQUEST_KERNEL_SEND)REQUEST_PARAMETERS(Request);
if ((Parameters->SendFlags & TDI_SEND_PARTIAL) == 0) {
Connection->CurrentSend.Request = TmpRequest;
Connection->CurrentSend.MessageOffset = 0;
Connection->CurrentSend.Buffer = REQUEST_NDIS_BUFFER (TmpRequest);
Connection->CurrentSend.BufferOffset = 0;
Connection->SendBufferInUse = FALSE;
Connection->UnAckedSend = Connection->CurrentSend;
Connection->FirstMessageRequest = TmpRequest;
Connection->LastMessageRequest = Request;
#ifdef RSRC_TIMEOUT_DBG
KeQuerySystemTime(&Connection->FirstMessageRequestTime);
#endif //RSRC_TIMEOUT_DBG
Connection->CurrentMessageLength = TempCount;
Connection->SubState = CONNECTION_SUBSTATE_A_PACKETIZE;
NbiReferenceConnectionSync (Connection, CREF_PACKETIZE);
CTEAssert (!Connection->OnPacketizeQueue);
Connection->OnPacketizeQueue = TRUE;
NB_INSERT_TAIL_LIST(
&Device->PacketizeConnections,
&Connection->PacketizeLinkage,
&Device->Lock);
break;
}
Request = REQUEST_SINGLE_LINKAGE(Request);
}
if (Request == NULL) {
Connection->SubState = CONNECTION_SUBSTATE_A_W_EOR;
}
}
} else {
Connection->FirstMessageRequest = NULL;
Connection->SubState = CONNECTION_SUBSTATE_A_IDLE;
NbiStartWatchdog (Connection);
}
} /* NbiRestartConnection */
VOID
NbiAdvanceUnAckedByBytes(
IN PCONNECTION Connection,
IN ULONG BytesAcked
)
/*++
Routine Description:
This routine advances the Connection->UnAckedSend
send pointer by the specified number of bytes. It
assumes that there are enough send requests to
handle the number specified.
NOTE: THIS FUNCTION IS CALLED WITH CONNECTION->LOCK HELD
AND RETURNS WITH IT HELD.
Arguments:
Connection - The connection.
BytesAcked - The number of bytes acked.
Return Value:
NTSTATUS - status of operation.
--*/
{
ULONG CurSendBufferLength;
ULONG BytesLeft = BytesAcked;
ULONG TempBytes;
while (BytesLeft > 0) {
NdisQueryBufferSafe (Connection->UnAckedSend.Buffer, NULL, &CurSendBufferLength, HighPagePriority);
//
// See if bytes acked ends within the current buffer.
//
if (Connection->UnAckedSend.BufferOffset + BytesLeft <
CurSendBufferLength) {
Connection->UnAckedSend.BufferOffset += BytesLeft;
Connection->UnAckedSend.MessageOffset += BytesLeft;
break;
} else {
TempBytes = CurSendBufferLength - Connection->UnAckedSend.BufferOffset;
BytesLeft -= TempBytes;
Connection->UnAckedSend.MessageOffset += TempBytes;
//
// No, so advance the buffer.
//
Connection->UnAckedSend.BufferOffset = 0;
Connection->UnAckedSend.Buffer =
NDIS_BUFFER_LINKAGE (Connection->UnAckedSend.Buffer);
//
// Is there a next buffer in this request?
//
if (Connection->UnAckedSend.Buffer == NULL) {
//
// No, so advance the request unless we are done.
//
if (BytesLeft == 0) {
return;
}
Connection->UnAckedSend.Request =
REQUEST_SINGLE_LINKAGE(Connection->UnAckedSend.Request);
if (Connection->UnAckedSend.Request == NULL) {
KeBugCheck (NDIS_INTERNAL_ERROR);
}
Connection->UnAckedSend.Buffer =
REQUEST_NDIS_BUFFER (Connection->UnAckedSend.Request);
}
}
}
} /* NbiAdvanceUnAckedByBytes */
VOID
NbiAdvanceUnAckedBySequence(
IN PCONNECTION Connection,
IN USHORT ReceiveSequence
)
/*++
Routine Description:
This routine advances the Connection->UnAckedSend
send pointer so that the next packet to send will be
the correct one for ReceiveSequence. UnAckedSend
must point to a known valid combination. It
assumes that there are enough send requests to
handle the sequence specified.
NOTE: THIS FUNCTION IS CALLED WITH CONNECTION->LOCK HELD
AND RETURNS WITH IT HELD.
Arguments:
Connection - The connection.
Return Value:
NTSTATUS - status of operation.
--*/
{
USHORT PacketsAcked;
//
// Fix this to account for partial sends, where
// we might not have used the max. for all packets.
//
PacketsAcked = ReceiveSequence - Connection->UnAckedSend.SendSequence;
NbiAdvanceUnAckedByBytes(
Connection,
PacketsAcked * Connection->MaximumPacketSize);
Connection->UnAckedSend.SendSequence += PacketsAcked;
} /* NbiAdvanceUnAckedBySequence */
VOID
NbiCancelSend(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine is called by the I/O system to cancel a send
The request is found on the connection's send queue.
NOTE: This routine is called with the CancelSpinLock held and
is responsible for releasing it.
Arguments:
DeviceObject - Pointer to the device object for this driver.
Irp - Pointer to the request packet representing the I/O request.
Return Value:
none.
--*/
{
PCONNECTION Connection;
PREQUEST Request = (PREQUEST)Irp;
NB_DEFINE_LOCK_HANDLE (LockHandle)
NB_DEFINE_SYNC_CONTEXT (SyncContext)
CTEAssert ((REQUEST_MAJOR_FUNCTION(Request) == IRP_MJ_INTERNAL_DEVICE_CONTROL) &&
(REQUEST_MINOR_FUNCTION(Request) == TDI_SEND));
CTEAssert (REQUEST_OPEN_TYPE(Request) == (PVOID)TDI_CONNECTION_FILE);
Connection = (PCONNECTION)REQUEST_OPEN_CONTEXT(Request);
//
// Just stop the connection, that will tear down any
// sends.
//
// Do we care about cancelling non-active
// sends without stopping the connection??
//
NbiReferenceConnectionSync (Connection, CREF_CANCEL);
IoReleaseCancelSpinLock (Irp->CancelIrql);
NB_BEGIN_SYNC (&SyncContext);
NB_SYNC_GET_LOCK (&Connection->Lock, &LockHandle);
//
// This frees the lock, cancels any sends, etc.
//
NbiStopConnection(
Connection,
STATUS_CANCELLED
NB_LOCK_HANDLE_ARG (LockHandle));
NbiDereferenceConnection (Connection, CREF_CANCEL);
NB_END_SYNC (&SyncContext);
} /* NbiCancelSend */
NTSTATUS
NbiBuildBufferChainFromBufferChain (
IN NDIS_HANDLE BufferPoolHandle,
IN PNDIS_BUFFER CurrentSourceBuffer,
IN ULONG CurrentByteOffset,
IN ULONG DesiredLength,
OUT PNDIS_BUFFER *DestinationBuffer,
OUT PNDIS_BUFFER *NewSourceBuffer,
OUT ULONG *NewByteOffset,
OUT ULONG *ActualLength
)
/*++
Routine Description:
This routine is called to build an NDIS_BUFFER chain from a source
NDIS_BUFFER chain and offset into it. We assume we don't know the
length of the source Mdl chain, and we must allocate the NDIS_BUFFERs
for the destination chain, which we do from the NDIS buffer pool.
If the system runs out of memory while we are building the destination
NDIS_BUFFER chain, we completely clean up the built chain and return with
NewCurrentMdl and NewByteOffset set to the current values of CurrentMdl
and ByteOffset.
Environment:
Arguments:
BufferPoolHandle - The buffer pool to allocate buffers from.
CurrentSourceBuffer - Points to the start of the NDIS_BUFFER chain
from which to draw the packet.
CurrentByteOffset - Offset within this NDIS_BUFFER to start the packet at.
DesiredLength - The number of bytes to insert into the packet.
DestinationBuffer - returned pointer to the NDIS_BUFFER chain describing
the packet.
NewSourceBuffer - returned pointer to the NDIS_BUFFER that would
be used for the next byte of packet. NULL if the source NDIS_BUFFER
chain was exhausted.
NewByteOffset - returned offset into the NewSourceBuffer for the next byte
of packet. NULL if the source NDIS_BUFFER chain was exhausted.
ActualLength - The actual length of the data copied.
Return Value:
STATUS_SUCCESS if the build of the returned NDIS_BUFFER chain succeeded
and was the correct length.
STATUS_INSUFFICIENT_RESOURCES if we ran out of NDIS_BUFFERs while
building the destination chain.
--*/
{
ULONG AvailableBytes;
ULONG CurrentByteCount;
ULONG BytesCopied;
PNDIS_BUFFER OldNdisBuffer;
PNDIS_BUFFER NewNdisBuffer;
NDIS_STATUS NdisStatus;
OldNdisBuffer = CurrentSourceBuffer;
NdisQueryBufferSafe (OldNdisBuffer, NULL, &CurrentByteCount, HighPagePriority);
AvailableBytes = CurrentByteCount - CurrentByteOffset;
if (AvailableBytes > DesiredLength) {
AvailableBytes = DesiredLength;
}
//
// Build the first NDIS_BUFFER, which could conceivably be the only one...
//
NdisCopyBuffer(
&NdisStatus,
&NewNdisBuffer,
BufferPoolHandle,
OldNdisBuffer,
CurrentByteOffset,
AvailableBytes);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
*NewSourceBuffer = CurrentSourceBuffer;
*NewByteOffset = CurrentByteOffset;
return STATUS_INSUFFICIENT_RESOURCES;
}
*DestinationBuffer = NewNdisBuffer;
BytesCopied = AvailableBytes;
//
// Was the first NDIS_BUFFER enough data.
//
if (BytesCopied == DesiredLength) {
if (CurrentByteOffset + AvailableBytes == CurrentByteCount) {
*NewSourceBuffer = CurrentSourceBuffer->Next;
*NewByteOffset = 0;
} else {
*NewSourceBuffer = CurrentSourceBuffer;
*NewByteOffset = CurrentByteOffset + AvailableBytes;
}
*ActualLength = BytesCopied;
return STATUS_SUCCESS;
}
if (CurrentSourceBuffer->Next == NULL) {
*NewSourceBuffer = NULL;
*NewByteOffset = 0;
*ActualLength = BytesCopied;
return STATUS_SUCCESS;
}
//
// Need more data, so follow the in Mdl chain to create a packet.
//
OldNdisBuffer = OldNdisBuffer->Next;
NdisQueryBufferSafe (OldNdisBuffer, NULL, &CurrentByteCount, HighPagePriority);
while (OldNdisBuffer != NULL) {
AvailableBytes = DesiredLength - BytesCopied;
if (AvailableBytes > CurrentByteCount) {
AvailableBytes = CurrentByteCount;
}
NdisCopyBuffer(
&NdisStatus,
&(NDIS_BUFFER_LINKAGE(NewNdisBuffer)),
BufferPoolHandle,
OldNdisBuffer,
0,
AvailableBytes);
if (NdisStatus != NDIS_STATUS_SUCCESS) {
//
// ran out of resources. put back what we've used in this call and
// return the error.
//
while (*DestinationBuffer != NULL) {
NewNdisBuffer = NDIS_BUFFER_LINKAGE(*DestinationBuffer);
NdisFreeBuffer (*DestinationBuffer);
*DestinationBuffer = NewNdisBuffer;
}
*NewByteOffset = CurrentByteOffset;
*NewSourceBuffer = CurrentSourceBuffer;
return STATUS_INSUFFICIENT_RESOURCES;
}
NewNdisBuffer = NDIS_BUFFER_LINKAGE(NewNdisBuffer);
BytesCopied += AvailableBytes;
if (BytesCopied == DesiredLength) {
if (AvailableBytes == CurrentByteCount) {
*NewSourceBuffer = OldNdisBuffer->Next;
*NewByteOffset = 0;
} else {
*NewSourceBuffer = OldNdisBuffer;
*NewByteOffset = AvailableBytes;
}
*ActualLength = BytesCopied;
return STATUS_SUCCESS;
}
OldNdisBuffer = OldNdisBuffer->Next;
NdisQueryBufferSafe (OldNdisBuffer, NULL, &CurrentByteCount, HighPagePriority);
}
//
// We ran out of source buffer chain.
//
*NewSourceBuffer = NULL;
*NewByteOffset = 0;
*ActualLength = BytesCopied;
return STATUS_SUCCESS;
} /* NbiBuildBufferChainFromBufferChain */
Copy Permalink