![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iframes.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / tdi|
Return to iframes.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / tdi |
1.1 root 1: /*++
2:
3: Copyright (c) 1989-1993 Microsoft Corporation
4:
5: Module Name:
6:
7: iframes.c
8:
9: Abstract:
10:
11: This module contains routines called to handle i-frames received
12: from the NDIS driver. Most of these routines are called at receive
13: indication time.
14:
15: Environment:
16:
17: Kernel mode, DISPATCH_LEVEL.
18:
19: Revision History:
20:
21: --*/
22:
23: #include "st.h"
24: #if 27
25: ULONG StNoisyReceives = 0;
26: ULONG StRcvLoc = 0;
27: ULONG StRcvs[10];
28: #endif
29:
30:
31:
32: NTSTATUS
33: StProcessIIndicate(
34: IN PTP_CONNECTION Connection,
35: IN PST_HEADER StHeader,
36: IN UINT StIndicatedLength,
37: IN UINT StTotalLength,
38: IN NDIS_HANDLE ReceiveContext,
39: IN BOOLEAN Last
40: )
41:
42: /*++
43:
44: Routine Description:
45:
46: This routine processes a received I frame at indication time. It will do
47: all necessary verification processing of the frame and pass those frames
48: that are valid on to the proper handling routines.
49:
50: Arguments:
51:
52: Connection - The connection that the data is destined for.
53:
54: StHeader - A pointer to the start of the ST header in the packet.
55:
56: StIndicatedLength - The length of the packet indicated, starting at
57: StHeader.
58:
59: StTotalLength - The total length of the packet, starting at StHeader.
60:
61: ReceiveContext - A magic value for NDIS that indicates which packet we're
62: talking about, used for calling TransferData
63:
64: Last - TRUE if this is the last packet in a send.
65:
66: Return Value:
67:
68: STATUS_SUCCESS if we've consumed the packet, but
69: STATUS_MORE_PROCESSING_REQUIRED if we did so and also
70: activated a receive; this tells the caller not to
71: remove the connection refcount.
72:
73: --*/
74:
75: {
76: KIRQL oldirql;
77: NTSTATUS status, tmpstatus;
78: KIRQL cancelirql;
79: PDEVICE_CONTEXT deviceContext;
80: NDIS_STATUS ndisStatus;
81: PNDIS_PACKET ndisPacket;
82: PSINGLE_LIST_ENTRY linkage;
83: PIRP irp;
84: PIO_STACK_LOCATION irpSp;
85: PNDIS_BUFFER ndisBuffer;
86: ULONG destBytes;
87: ULONG bufferChainLength;
88: ULONG indicateBytesTransferred;
89: ULONG ndisBytesTransferred;
90: PUCHAR DataHeader;
91: ULONG DataTotalLength;
92: ULONG DataIndicatedLength;
93: UINT BytesToTransfer;
94: ULONG bytesIndicated;
95: PRECEIVE_PACKET_TAG receiveTag;
96: PTP_ADDRESS address;
97: PTP_ADDRESS_FILE addressFile;
98: PMDL SavedCurrentMdl;
99: ULONG SavedCurrentByteOffset;
100: LARGE_INTEGER time;
101: ULONG DumpData[2];
102: BOOLEAN CancelSpinLockHeld = FALSE;
103: #if 27
104: if (StNoisyReceives) {
105: DbgPrint ("Indicate %d, Total %d\n", StIndicatedLength, StTotalLength);
106: }
107: if (StTotalLength > 1000) {
108: StRcvs[StRcvLoc] = StTotalLength;
109: StRcvLoc = (StRcvLoc + 1) % 10;
110: }
111: #endif
112:
113:
114: //
115: // copy this packet into our receive buffer.
116: //
117:
118: deviceContext = Connection->Provider;
119: addressFile = Connection->AddressFile;
120: address = addressFile->Address;
121:
122: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql);
123:
124: //
125: // If we have a previous receive that is pending
126: // completion, then we need to ignore this frame.
127: // This may be common on MP.
128: //
129:
130: if (Connection->Flags2 & CONNECTION_FLAGS2_RC_PENDING) {
131:
132: Connection->IndicationInProgress = FALSE;
133: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
134:
135: return STATUS_SUCCESS;
136: }
137:
138: DataHeader = (PUCHAR)StHeader + sizeof(ST_HEADER);
139: DataTotalLength = StTotalLength - sizeof(ST_HEADER);
140: DataIndicatedLength = StIndicatedLength - sizeof(ST_HEADER);
141:
142: //
143: // Initialize this to zero, in case we do not indicate or
144: // the client does not fill it in.
145: //
146:
147: indicateBytesTransferred = 0;
148:
149: if (!(Connection->Flags & CONNECTION_FLAGS_ACTIVE_RECEIVE)) {
150:
151: //
152: // check first to see if there is a receive available. If there is,
153: // use it before doing an indication.
154: //
155:
156: if (Connection->ReceiveQueue.Flink != &Connection->ReceiveQueue) {
157:
158: //
159: // Found a receive, so make it the active one and
160: // cycle around again.
161: //
162:
163: Connection->Flags |= CONNECTION_FLAGS_ACTIVE_RECEIVE;
164: Connection->MessageBytesReceived = 0;
165: Connection->MessageBytesAcked = 0;
166: Connection->CurrentReceiveRequest =
167: CONTAINING_RECORD (Connection->ReceiveQueue.Flink,
168: TP_REQUEST, Linkage);
169: Connection->CurrentReceiveMdl =
170: Connection->CurrentReceiveRequest->Buffer2;
171: Connection->ReceiveLength =
172: Connection->CurrentReceiveRequest->Buffer2Length;
173: Connection->ReceiveByteOffset = 0;
174: status = STATUS_SUCCESS;
175: goto NormalReceive;
176: }
177:
178: //
179: // A receive is not active. Post a receive event.
180: //
181:
182: if (!addressFile->RegisteredReceiveHandler) {
183:
184: //
185: // There is no receive posted to the Connection, and
186: // no event handler. Set the RECEIVE_WAKEUP bit, so that when a
187: // receive does become available, it will restart the
188: // current send. Also send a NoReceive to tell the other
189: // guy he needs to resynch.
190: //
191:
192: Connection->IndicationInProgress = FALSE;
193: return STATUS_SUCCESS;
194: }
195:
196: if ((Connection->Flags & CONNECTION_FLAGS_READY) == 0) {
197: Connection->IndicationInProgress = FALSE;
198: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
199:
200: return STATUS_SUCCESS;
201: }
202:
203: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
204:
205: //
206: // Indicate to the user. For BytesAvailable we
207: // always use DataTotalLength; for BytesIndicated we use
208: // MIN (DataIndicatedLength, DataTotalLength).
209: //
210: // To clarify BytesIndicated, on an Ethernet packet
211: // which is padded DataTotalLength will be shorter; on an
212: // Ethernet packet which is not padded and which is
213: // completely indicated, the two will be equal; and
214: // on a long Ethernet packet DataIndicatedLength
215: // will be shorter.
216: //
217:
218: bytesIndicated = DataIndicatedLength;
219: if (DataTotalLength < bytesIndicated) {
220: bytesIndicated = DataTotalLength;
221: }
222:
223: status = (*addressFile->ReceiveHandler)(
224: addressFile->ReceiveHandlerContext,
225: Connection->Context,
226: deviceContext->MacInfo.CopyLookahead ?
227: TDI_RECEIVE_COPY_LOOKAHEAD : 0, // ReceiveFlags
228: bytesIndicated,
229: DataTotalLength, // BytesAvailable
230: &indicateBytesTransferred,
231: DataHeader,
232: &irp);
233:
234: if (status == STATUS_SUCCESS) {
235:
236: //
237: // The client has accepted some or all of the indicated data in
238: // the event handler. Update MessageBytesReceived variable in
239: // the Connection.
240: //
241:
242: Connection->MessageBytesReceived += indicateBytesTransferred;
243: Connection->IndicationInProgress = FALSE;
244:
245: return STATUS_SUCCESS;
246:
247: } else if (status == STATUS_DATA_NOT_ACCEPTED) {
248:
249: //
250: // Either there is no event handler installed (the default
251: // handler returns this code) or the event handler is not
252: // able to process the received data at this time. If there
253: // is a TdiReceive request outstanding on this Connection's
254: // ReceiveQueue, then we may use it to receive this data.
255: // If there is no request outstanding, then we must initiate
256: // flow control at the transport level.
257: //
258:
259: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql);
260: if (Connection->ReceiveQueue.Flink == &Connection->ReceiveQueue) {
261:
262: //
263: // There is no receive posted to the Connection, and
264: // the event handler didn't want to accept the incoming
265: // data.
266: //
267:
268: Connection->IndicationInProgress = FALSE;
269: return STATUS_SUCCESS;
270:
271: } else {
272:
273: //
274: // Found a receive, so make it the active one. This will cause
275: // an NdisTransferData below, so we don't dereference the
276: // Connection here.
277: //
278:
279: Connection->Flags |= CONNECTION_FLAGS_ACTIVE_RECEIVE;
280: Connection->MessageBytesReceived = 0;
281: Connection->MessageBytesAcked = 0;
282: Connection->CurrentReceiveRequest =
283: CONTAINING_RECORD (Connection->ReceiveQueue.Flink,
284: TP_REQUEST, Linkage);
285: Connection->CurrentReceiveMdl =
286: Connection->CurrentReceiveRequest->Buffer2;
287: Connection->ReceiveLength =
288: Connection->CurrentReceiveRequest->Buffer2Length;
289: Connection->ReceiveByteOffset = 0;
290: }
291:
292: } else if (status == STATUS_MORE_PROCESSING_REQUIRED) {
293:
294: PTP_REQUEST SpecialIrpRequest;
295: ULONG SpecialIrpLength;
296:
297: //
298: // The client's event handler has returned an IRP in the
299: // form of a TdiReceive that is to be associated with this
300: // data. The request will be installed at the front of the
301: // ReceiveQueue, and then made the active receive request.
302: // This request will be used to accept the incoming data, which
303: // will happen below.
304: //
305:
306: //
307: // Queueing a receive of any kind causes a Connection reference;
308: // that's what we've just done here, so make the Connection stick
309: // around. We create a request to keep a packets outstanding ref
310: // count for the current IRP; we queue this on the connection's
311: // receive queue so we can treat it like a normal receive. If
312: // we can't get a request to describe this irp, we can't keep it
313: // around hoping for better later; we simple fail it with
314: // insufficient resources. Note this is only likely to happen if
315: // we've completely run out of transport memory.
316: //
317:
318: irp->IoStatus.Information = 0; // byte transfer count.
319: irp->IoStatus.Status = STATUS_PENDING;
320: irpSp = IoGetCurrentIrpStackLocation (irp);
321:
322: ASSERT (irpSp->FileObject->FsContext == Connection);
323:
324: SpecialIrpLength =
325: ((PTDI_REQUEST_KERNEL_RECEIVE)&irpSp->Parameters)->ReceiveLength;
326:
327: //
328: // The normal path, for longer receives.
329: //
330:
331: time.HighPart = 0;
332: time.LowPart = 0;
333:
334: status = StCreateRequest (
335: irp,
336: Connection,
337: REQUEST_FLAGS_CONNECTION | REQUEST_FLAGS_SEND_RCV,
338: irp->MdlAddress,
339: ((PTDI_REQUEST_KERNEL_RECEIVE )&irpSp->Parameters)->ReceiveLength,
340: time,
341: &SpecialIrpRequest);
342:
343: if (!NT_SUCCESS (status)) {
344: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql);
345: Connection->ReceiveByteOffset = 0;
346: Connection->Flags |= CONNECTION_FLAGS_RECEIVE_WAKEUP;
347: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
348:
349: Connection->IndicationInProgress = FALSE;
350:
351: irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
352:
353: IoCompleteRequest (irp, IO_NETWORK_INCREMENT);
354: return STATUS_INSUFFICIENT_RESOURCES;
355: }
356:
357: //
358: // If the Connection is stopping, abort this request.
359: //
360:
361: IoAcquireCancelSpinLock(&cancelirql);
362: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql);
363:
364: if ((Connection->Flags & CONNECTION_FLAGS_STOPPING) != 0) {
365: Connection->IndicationInProgress = FALSE;
366: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
367:
368: IoReleaseCancelSpinLock(cancelirql);
369: StCompleteRequest (
370: SpecialIrpRequest,
371: Connection->Status,
372: 0);
373: return STATUS_SUCCESS; // we have consumed the packet
374:
375: }
376:
377: //
378: // Insert the request on the head of the connection's
379: // receive queue, so it can be handled like a normal
380: // receive.
381: //
382:
383: InsertHeadList (&Connection->ReceiveQueue, &SpecialIrpRequest->Linkage);
384:
385: Connection->Flags |= CONNECTION_FLAGS_ACTIVE_RECEIVE;
386: Connection->ReceiveLength = ((PTDI_REQUEST_KERNEL_RECEIVE )&irpSp->Parameters)->ReceiveLength;
387: Connection->MessageBytesReceived = indicateBytesTransferred;
388: Connection->MessageBytesAcked = 0;
389: Connection->CurrentReceiveRequest = SpecialIrpRequest;
390: Connection->CurrentReceiveMdl = irp->MdlAddress;
391: Connection->ReceiveByteOffset = 0;
392: Connection->CurrentReceiveRequest->Owner = ConnectionType;
393:
394: //
395: // If this IRP has been cancelled, then call the
396: // cancel routine.
397: //
398:
399: if (irp->Cancel) {
400:
401: Connection->Flags |= CONNECTION_FLAGS_RECEIVE_WAKEUP;
402: Connection->IndicationInProgress = FALSE;
403: RELEASE_SPIN_LOCK (&Connection->SpinLock,oldirql);
404: irp->CancelIrql = cancelirql;
405: StCancelReceive((PDEVICE_OBJECT)deviceContext, irp);
406:
407: return STATUS_SUCCESS;
408:
409: } else {
410:
411: irp->CancelRoutine = StCancelReceive;
412:
413: status = STATUS_MORE_PROCESSING_REQUIRED;
414:
415: //
416: // Make a note so we know to release the cancel
417: // spinlock below.
418: //
419:
420: CancelSpinLockHeld = TRUE;
421:
422: }
423:
424: } else {
425:
426: //
427: // An unknown return code has been returned by the
428: // client's event handler. This is a client programming
429: // error. Because this can only occur when kernel-mode
430: // clients have been coded incorrectly, we should beat
431: // him with a stick. We have to do SOMETHING, or this
432: // Connection will HANG.
433: //
434:
435: Connection->IndicationInProgress = FALSE;
436: return STATUS_SUCCESS;
437:
438: }
439:
440: } else {
441:
442: //
443: // A receive is active, set the status to show
444: // that so far.
445: //
446:
447: status = STATUS_SUCCESS;
448:
449: }
450:
451:
452: NormalReceive:;
453:
454: //
455: // NOTE: The connection spinlock is held here.
456: //
457: // We should only get through here if a receive is active
458: // and we have not released the lock since checking or
459: // making one active.
460: //
461:
462: ASSERT(Connection->Flags & CONNECTION_FLAGS_ACTIVE_RECEIVE);
463:
464: //
465: // The status should be SUCCESS (we found an active receive)
466: // or MORE_PROCESSING_REQUIRED (we made a new receive active).
467: //
468:
469: ASSERT ((status == STATUS_SUCCESS) || (status == STATUS_MORE_PROCESSING_REQUIRED));
470:
471: destBytes = Connection->ReceiveLength - Connection->MessageBytesReceived;
472: StReferenceRequest ("Transfer Data", Connection->CurrentReceiveRequest);
473:
474: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
475: if (CancelSpinLockHeld) {
476: IoReleaseCancelSpinLock (cancelirql);
477: }
478:
479: //
480: // get a packet for the coming transfer
481: //
482:
483: linkage = ExInterlockedPopEntryList(
484: &deviceContext->ReceivePacketPool,
485: &deviceContext->Interlock);
486:
487: if (linkage != NULL) {
488: ndisPacket = CONTAINING_RECORD( linkage, NDIS_PACKET, ProtocolReserved[0] );
489: } else {
490: (VOID)ExInterlockedIncrementLong(
491: (PLONG)&deviceContext->ReceivePacketExhausted,
492: &deviceContext->Interlock);
493: StDereferenceRequest ("No receive packet", Connection->CurrentReceiveRequest);
494:
495: // We could not get a receive packet.
496: //
497:
498: Connection->IndicationInProgress = FALSE;
499: return status;
500: }
501:
502: //
503: // Initialize the receive packet.
504: //
505:
506: receiveTag = (PRECEIVE_PACKET_TAG)(ndisPacket->ProtocolReserved);
507: receiveTag->PacketType = TYPE_AT_INDICATE;
508: receiveTag->Connection = Connection;
509: receiveTag->TransferDataPended = TRUE;
510:
511:
512: //
513: // Determine how much data remains to be transferred.
514: //
515:
516: BytesToTransfer = DataTotalLength - indicateBytesTransferred;
517: ASSERT (BytesToTransfer >= 0);
518:
519: if (destBytes < BytesToTransfer) {
520:
521: //
522: // If the data overflows the current receive, then make a
523: // note that we should complete the receive at the end of
524: // transfer data, but with EOR false.
525: //
526:
527: receiveTag->EndOfMessage = FALSE;
528: receiveTag->CompleteReceive = TRUE;
529: BytesToTransfer = destBytes;
530:
531: } else if (destBytes == BytesToTransfer) {
532:
533: //
534: // If the data just fills the current receive, then complete
535: // the receive; EOR depends on whether this is a DOL or not.
536: //
537:
538: receiveTag->EndOfMessage = Last;
539: receiveTag->CompleteReceive = TRUE;
540:
541: } else {
542:
543: //
544: // Complete the receive if this is a DOL.
545: //
546:
547: receiveTag->EndOfMessage = Last;
548: receiveTag->CompleteReceive = Last;
549:
550: }
551:
552: //
553: // if we've got zero bytes left, avoid the TransferData below and
554: // just deliver.
555: //
556:
557: if (BytesToTransfer <= 0) {
558: Connection->IndicationInProgress = FALSE;
559: receiveTag->NdisStatus = NDIS_STATUS_SUCCESS;
560: receiveTag->TransferDataPended = FALSE;
561: StTransferDataComplete (
562: deviceContext,
563: ndisPacket,
564: NDIS_STATUS_SUCCESS,
565: 0);
566:
567: return status;
568: }
569:
570: //
571: // describe the right part of the user buffer to NDIS. If we can't get
572: // the mdl for the packet, drop it. Bump the request reference count
573: // so that we know we need to hold open receives until the NDIS transfer
574: // data requests complete.
575: //
576:
577: SavedCurrentMdl = Connection->CurrentReceiveMdl;
578: SavedCurrentByteOffset = Connection->ReceiveByteOffset;
579:
580: if ((Connection->ReceiveByteOffset == 0) &&
581: (receiveTag->CompleteReceive)) {
582:
583: //
584: // If we are transferring into the beginning of
585: // the current MDL, and we will be completing the
586: // receive after the transfer, then we don't need to
587: // copy it.
588: //
589:
590: ndisBuffer = (PNDIS_BUFFER)Connection->CurrentReceiveMdl;
591: bufferChainLength = BytesToTransfer;
592: Connection->CurrentReceiveMdl = NULL;
593: Connection->ReceiveByteOffset = 0;
594: receiveTag->AllocatedNdisBuffer = FALSE;
595: tmpstatus = STATUS_SUCCESS;
596:
597: } else {
598:
599: tmpstatus = BuildBufferChainFromMdlChain (
600: deviceContext->NdisBufferPoolHandle,
601: Connection->CurrentReceiveMdl,
602: Connection->ReceiveByteOffset,
603: BytesToTransfer,
604: &ndisBuffer,
605: &Connection->CurrentReceiveMdl,
606: &Connection->ReceiveByteOffset,
607: &bufferChainLength);
608:
609: receiveTag->AllocatedNdisBuffer = TRUE;
610:
611: }
612:
613:
614: if ((!NT_SUCCESS (tmpstatus)) || (bufferChainLength != BytesToTransfer)) {
615:
616: DumpData[0] = bufferChainLength;
617: DumpData[1] = BytesToTransfer;
618:
619: StWriteGeneralErrorLog(
620: deviceContext,
621: EVENT_TRANSPORT_TRANSFER_DATA,
622: 604,
623: tmpstatus,
624: NULL,
625: 2,
626: DumpData);
627:
628: StDereferenceRequest ("No MDL chain", Connection->CurrentReceiveRequest);
629:
630: //
631: // Restore our old state.
632: //
633:
634: Connection->CurrentReceiveMdl = SavedCurrentMdl;
635: Connection->ReceiveByteOffset = SavedCurrentByteOffset;
636:
637: Connection->IndicationInProgress = FALSE;
638:
639: ExInterlockedPushEntryList(
640: &deviceContext->ReceivePacketPool,
641: (PSINGLE_LIST_ENTRY)&receiveTag->Linkage,
642: &deviceContext->Interlock);
643:
644: return status;
645: }
646:
647: NdisChainBufferAtFront (ndisPacket, ndisBuffer);
648:
649: //
650: // set up async return status so we can tell when it has happened;
651: // can never get return of NDIS_STATUS_PENDING in synch completion routine
652: // for NdisTransferData, so we know it has completed when this status
653: // changes
654: //
655:
656: receiveTag->NdisStatus = NDIS_STATUS_PENDING;
657:
658: //
659: // update the number of bytes received; OK to do this
660: // unprotected since IndicationInProgress is still FALSE.
661: //
662: //
663:
664: Connection->MessageBytesReceived += BytesToTransfer;
665:
666: //
667: // We have now updated all the connection counters (BUG,
668: // assuming the TransferData will succeed) and this
669: // packet's location in the request is secured, so we
670: // can be reentered.
671: //
672:
673: Connection->IndicationInProgress = FALSE;
674:
675: NdisTransferData (
676: &ndisStatus,
677: deviceContext->NdisBindingHandle,
678: ReceiveContext,
679: sizeof (ST_HEADER) + indicateBytesTransferred,
680: BytesToTransfer,
681: ndisPacket,
682: (PUINT)&ndisBytesTransferred);
683:
684: //
685: // handle the various completion codes
686: //
687:
688: switch (ndisStatus) {
689:
690: case NDIS_STATUS_SUCCESS:
691:
692: receiveTag->NdisStatus = NDIS_STATUS_SUCCESS;
693: if (ndisBytesTransferred != BytesToTransfer) { // Did we get the entire packet?
694:
695: DumpData[0] = ndisBytesTransferred;
696: DumpData[1] = BytesToTransfer;
697:
698: StWriteGeneralErrorLog(
699: deviceContext,
700: EVENT_TRANSPORT_TRANSFER_DATA,
701: 604,
702: ndisStatus,
703: NULL,
704: 2,
705: DumpData);
706:
707: if (receiveTag->AllocatedNdisBuffer) {
708: NdisUnchainBufferAtFront (ndisPacket, &ndisBuffer);
709: while (ndisBuffer != NULL) {
710: NdisFreeBuffer (ndisBuffer);
711: NdisUnchainBufferAtFront (ndisPacket, &ndisBuffer);
712: }
713: } else {
714: NdisReinitializePacket (ndisPacket);
715: }
716:
717: ExInterlockedPushEntryList(
718: &deviceContext->ReceivePacketPool,
719: (PSINGLE_LIST_ENTRY)&receiveTag->Linkage,
720: &deviceContext->Interlock);
721:
722: StDereferenceRequest ("Bad byte count", Connection->CurrentReceiveRequest);
723:
724: //
725: // Restore our old state.
726: //
727:
728: Connection->CurrentReceiveMdl = SavedCurrentMdl;
729: Connection->ReceiveByteOffset = SavedCurrentByteOffset;
730: Connection->MessageBytesReceived -= BytesToTransfer;
731:
732: return status;
733: }
734:
735: //
736: // deallocate the buffers and such that we've used if at indicate
737: //
738:
739: receiveTag->TransferDataPended = FALSE;
740:
741: StTransferDataComplete (
742: deviceContext,
743: ndisPacket,
744: ndisStatus,
745: BytesToTransfer);
746: break;
747:
748: case NDIS_STATUS_PENDING: // waiting async complete from NdisTransferData
749:
750: //
751: // Because TransferDataPended stays TRUE, this reference will
752: // be removed in TransferDataComplete. It is OK to do this
753: // now, even though TransferDataComplete may already have been
754: // called, because we also hold the ProcessIIndicate reference
755: // so there will be no "bounce".
756: //
757:
758: StReferenceConnection ("TransferData pended", Connection);
759: break;
760:
761: default:
762:
763: //
764: // Something broke; certainly we'll never get NdisTransferData
765: // asynch completion.
766: //
767: // BUGBUG: The driver should recover from this situation.
768: //
769:
770: StWriteGeneralErrorLog(
771: deviceContext,
772: EVENT_TRANSPORT_TRANSFER_DATA,
773: 604,
774: ndisStatus,
775: NULL,
776: 0,
777: NULL);
778:
779: if (receiveTag->AllocatedNdisBuffer) {
780: NdisUnchainBufferAtFront (ndisPacket, &ndisBuffer);
781: while (ndisBuffer != NULL) {
782: NdisFreeBuffer (ndisBuffer);
783: NdisUnchainBufferAtFront (ndisPacket, &ndisBuffer);
784: }
785: } else {
786: NdisReinitializePacket (ndisPacket);
787: }
788:
789: ExInterlockedPushEntryList(
790: &deviceContext->ReceivePacketPool,
791: (PSINGLE_LIST_ENTRY)&receiveTag->Linkage,
792: &deviceContext->Interlock);
793:
794: StDereferenceRequest ("TransferData failed", Connection->CurrentReceiveRequest);
795:
796: //
797: // Restore our old state.
798: //
799:
800: Connection->CurrentReceiveMdl = SavedCurrentMdl;
801: Connection->ReceiveByteOffset = SavedCurrentByteOffset;
802: Connection->MessageBytesReceived -= BytesToTransfer;
803:
804: return status;
805: } // switch ndisStatus
806:
807: return status; // which only means we've dealt with the packet
808:
809: } /* ProcessIIndicate */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.