![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcveng.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 rcveng.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: rcveng.c
8:
9: Abstract:
10:
11: This module contains code that implements the receive engine for the
12: Sample transport provider.
13:
14: Environment:
15:
16: Kernel mode
17:
18: Revision History:
19:
20: --*/
21:
22: #include "st.h"
23:
24:
25: VOID
26: ActivateReceive(
27: PTP_CONNECTION Connection
28: )
29:
30: /*++
31:
32: Routine Description:
33:
34: This routine activates the next TdiReceive request on the specified
35: connection object if there is no active request on that connection
36: already. This allows the request to accept data on the connection.
37:
38: Arguments:
39:
40: Connection - Pointer to a TP_CONNECTION object.
41:
42: Return Value:
43:
44: none.
45:
46: --*/
47:
48: {
49: KIRQL oldirql;
50: PTP_REQUEST Request;
51:
52: //
53: // The ACTIVE_RECEIVE bitflag will be set on the connection if
54: // the receive-fields in the CONNECTION object are valid. If
55: // this flag is cleared, then we try to make the next TdiReceive
56: // request in the ReceiveQueue the active request.
57: //
58:
59: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql);
60: if (!(Connection->Flags & CONNECTION_FLAGS_ACTIVE_RECEIVE)) {
61: if (!IsListEmpty (&Connection->ReceiveQueue)) {
62:
63: //
64: // Found a receive, so make it the active one.
65: //
66:
67: Connection->Flags |= CONNECTION_FLAGS_ACTIVE_RECEIVE;
68:
69: Request = CONTAINING_RECORD (
70: Connection->ReceiveQueue.Flink,
71: TP_REQUEST,
72: Linkage);
73: Connection->MessageBytesReceived = 0;
74: Connection->MessageBytesAcked = 0;
75: Connection->CurrentReceiveRequest = Request;
76: Connection->CurrentReceiveMdl = Request->Buffer2;
77: Connection->ReceiveLength = Request->Buffer2Length;
78: Connection->ReceiveByteOffset = 0;
79: }
80: }
81:
82: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
83:
84: } /* ActivateReceive */
85:
86:
87: VOID
88: AwakenReceive(
89: PTP_CONNECTION Connection
90: )
91:
92: /*++
93:
94: Routine Description:
95:
96: This routine is called to reactivate a sleeping connection with the
97: RECEIVE_WAKEUP bitflag set because data arrived for which no receive
98: was available. The caller has made a receive available at the connection,
99: so here we activate the next receive, and send the appropriate protocol
100: to restart the message at the first byte offset past the one received
101: by the last receive.
102:
103: Arguments:
104:
105: Connection - Pointer to a TP_CONNECTION object.
106:
107: Return Value:
108:
109: none.
110:
111: --*/
112:
113: {
114: KIRQL oldirql;
115:
116: //
117: // If the RECEIVE_WAKEUP bitflag is set, then awaken the connection.
118: //
119:
120: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql);
121: if (Connection->Flags & CONNECTION_FLAGS_RECEIVE_WAKEUP) {
122: if (Connection->ReceiveQueue.Flink != &Connection->ReceiveQueue) {
123: Connection->Flags &= ~CONNECTION_FLAGS_RECEIVE_WAKEUP;
124:
125: //
126: // Found a receive, so turn off the wakeup flag, and activate
127: // the next receive.
128: //
129:
130: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
131: ActivateReceive (Connection);
132:
133: return;
134: }
135: }
136: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
137: } /* AwakenReceive */
138:
139:
140: VOID
141: CompleteReceive(
142: PTP_CONNECTION Connection,
143: BOOLEAN EndOfRecord,
144: KIRQL ConnectionIrql,
145: KIRQL CancelIrql
146: )
147:
148: /*++
149:
150: Routine Description:
151:
152: This routine is called by ProcessIncomingData when the current receive
153: must be completed. Depending on whether the current frame being
154: processed is a DATA_FIRST_MIDDLE or DATA_ONLY_LAST, and also whether
155: all of the data was processed, the EndOfRecord flag will be set accordingly
156: by the caller to indicate that a message boundary was received.
157:
158: NOTE: This function is called with the connection and cancel
159: IRQLs held, and returns with them released.
160:
161: Arguments:
162:
163: Connection - Pointer to a TP_CONNECTION object.
164:
165: EndOfRecord - BOOLEAN set to true if TDI_END_OF_RECORD should be reported.
166:
167: ConnectionIrql - The IRQL at which the connection spinlock was acquired.
168:
169: CancelIrql - The IRQL at which the cancel spinlock was acquired.
170:
171: Return Value:
172:
173: none.
174:
175: --*/
176:
177: {
178: PLIST_ENTRY p;
179: PTP_REQUEST Request;
180: KIRQL oldirql = ConnectionIrql;
181: KIRQL cancelirql = CancelIrql;
182: ULONG BytesReceived;
183:
184:
185: if (IsListEmpty (&Connection->ReceiveQueue)) {
186:
187: ASSERT ((Connection->Flags & CONNECTION_FLAGS_STOPPING) != 0);
188:
189: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
190: IoReleaseCancelSpinLock(cancelirql);
191: return;
192: }
193:
194: Connection->Flags &= ~CONNECTION_FLAGS_ACTIVE_RECEIVE;
195: BytesReceived = Connection->MessageBytesReceived;
196:
197:
198: //
199: // Complete the TdiReceive request at the head of the
200: // connection's ReceiveQueue.
201: //
202:
203: p = RemoveHeadList (&Connection->ReceiveQueue);
204: Request = CONTAINING_RECORD (p, TP_REQUEST, Linkage);
205:
206: Request->IoRequestPacket->CancelRoutine = (PDRIVER_CANCEL)NULL;
207:
208: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
209: IoReleaseCancelSpinLock(cancelirql);
210:
211:
212: Request->Flags |= REQUEST_FLAGS_DELAY;
213:
214: StCompleteRequest(
215: Request,
216: EndOfRecord ? STATUS_SUCCESS : STATUS_BUFFER_OVERFLOW,
217: BytesReceived);
218:
219: } /* CompleteReceive */
220:
221:
222: VOID
223: StCancelReceive(
224: IN PDEVICE_OBJECT DeviceObject,
225: IN PIRP Irp
226: )
227:
228: /*++
229:
230: Routine Description:
231:
232: This routine is called by the I/O system to cancel a receive.
233: The receive is found on the connection's receive queue; if it
234: is the current request it is cancelled and the connection
235: goes into "cancelled receive" mode, otherwise it is cancelled
236: silently.
237:
238: In "cancelled receive" mode the connection makes it appear to
239: the remote the data is being received, but in fact it is not
240: indicated to the transport or buffered on our end
241:
242: NOTE: This routine is called with the CancelSpinLock held and
243: is responsible for releasing it.
244:
245: Arguments:
246:
247: DeviceObject - Pointer to the device object for this driver.
248:
249: Irp - Pointer to the request packet representing the I/O request.
250:
251: Return Value:
252:
253: none.
254:
255: --*/
256:
257: {
258: KIRQL oldirql;
259: PIO_STACK_LOCATION IrpSp;
260: PTP_CONNECTION Connection;
261: PTP_REQUEST Request;
262: PLIST_ENTRY p;
263: ULONG BytesReceived;
264: BOOLEAN Found;
265:
266: UNREFERENCED_PARAMETER (DeviceObject);
267:
268: //
269: // Get a pointer to the current stack location in the IRP. This is where
270: // the function codes and parameters are stored.
271: //
272:
273: IrpSp = IoGetCurrentIrpStackLocation (Irp);
274:
275: ASSERT ((IrpSp->MajorFunction == IRP_MJ_INTERNAL_DEVICE_CONTROL) &&
276: (IrpSp->MinorFunction == TDI_RECEIVE));
277:
278: Connection = IrpSp->FileObject->FsContext;
279:
280: //
281: // Since this IRP is still in the cancellable state, we know
282: // that the connection is still around (although it may be in
283: // the process of being torn down).
284: //
285:
286: //
287: // See if this is the IRP for the current receive request.
288: //
289:
290: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql);
291:
292: BytesReceived = Connection->MessageBytesReceived;
293:
294: p = Connection->ReceiveQueue.Flink;
295:
296: //
297: // If there is a receive active, then see if this is it.
298: //
299:
300: if ((Connection->Flags & CONNECTION_FLAGS_ACTIVE_RECEIVE) != 0) {
301:
302: Request = CONTAINING_RECORD (p, TP_REQUEST, Linkage);
303:
304: if (Request->IoRequestPacket == Irp) {
305:
306: //
307: // yes, it is the active receive. Turn on the RCV_CANCELLED
308: // bit instructing the connection to drop the rest of the
309: // data received (until the DOL comes in).
310: //
311:
312: Connection->Flags2 |= CONNECTION_FLAGS2_RCV_CANCELLED;
313: Connection->Flags &= ~CONNECTION_FLAGS_ACTIVE_RECEIVE;
314:
315: (VOID)RemoveHeadList (&Connection->ReceiveQueue);
316:
317: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
318: IoReleaseCancelSpinLock (Irp->CancelIrql);
319:
320: //
321: // The following dereference will complete the I/O, provided removes
322: // the last reference on the request object. The I/O will complete
323: // with the status and information stored in the Irp. Therefore,
324: // we set those values here before the dereference.
325: //
326:
327: StCompleteRequest (Request, STATUS_CANCELLED, 0);
328: return;
329:
330: }
331:
332: }
333:
334:
335: //
336: // If we fall through to here, the IRP was not the active receive.
337: // Scan through the list, looking for this IRP.
338: //
339:
340: Found = FALSE;
341:
342: while (p != &Connection->ReceiveQueue) {
343:
344: Request = CONTAINING_RECORD (p, TP_REQUEST, Linkage);
345: if (Request->IoRequestPacket == Irp) {
346:
347: //
348: // Found it, remove it from the list here.
349: //
350:
351: RemoveEntryList (p);
352: Found = TRUE;
353:
354: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
355: IoReleaseCancelSpinLock (Irp->CancelIrql);
356:
357: //
358: // The following dereference will complete the I/O, provided removes
359: // the last reference on the request object. The I/O will complete
360: // with the status and information stored in the Irp. Therefore,
361: // we set those values here before the dereference.
362: //
363:
364: StCompleteRequest (Request, STATUS_CANCELLED, 0);
365: break;
366:
367: }
368:
369: p = p->Flink;
370:
371: }
372:
373: if (!Found) {
374:
375: //
376: // We didn't find it!
377: //
378:
379: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
380: IoReleaseCancelSpinLock (Irp->CancelIrql);
381: }
382:
383: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.