ce46f9597d2b277fec224a54b452f89177fe868a
[reactos.git] / reactos / lib / drivers / ip / transport / tcp / tcp.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS TCP/IP protocol driver
4 * FILE: transport/tcp/tcp.c
5 * PURPOSE: Transmission Control Protocol
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Art Yerkes (arty@users.sf.net)
8 * REVISIONS:
9 * CSH 01/08-2000 Created
10 * arty 12/21/2004 Added accept
11 */
12
13 #include "precomp.h"
14
15 LONG TCP_IPIdentification = 0;
16 static BOOLEAN TCPInitialized = FALSE;
17 PORT_SET TCPPorts;
18
19 #include "lwip/pbuf.h"
20 #include "lwip/ip.h"
21 #include "lwip/init.h"
22 #include "lwip/arch.h"
23
24 #include "rosip.h"
25
26 VOID NTAPI
27 DisconnectTimeoutDpc(PKDPC Dpc,
28 PVOID DeferredContext,
29 PVOID SystemArgument1,
30 PVOID SystemArgument2)
31 {
32 PCONNECTION_ENDPOINT Connection = (PCONNECTION_ENDPOINT)DeferredContext;
33 PLIST_ENTRY Entry;
34 PTDI_BUCKET Bucket;
35 NTSTATUS Status;
36
37 LockObjectAtDpcLevel(Connection);
38
39 /* We timed out waiting for pending sends so force it to shutdown */
40 Status = TCPTranslateError(LibTCPShutdown(Connection, 0, 1));
41
42 while (!IsListEmpty(&Connection->SendRequest))
43 {
44 Entry = RemoveHeadList(&Connection->SendRequest);
45
46 Bucket = CONTAINING_RECORD(Entry, TDI_BUCKET, Entry);
47
48 Bucket->Information = 0;
49 Bucket->Status = STATUS_FILE_CLOSED;
50
51 CompleteBucket(Connection, Bucket, FALSE);
52 }
53
54 while (!IsListEmpty(&Connection->ShutdownRequest))
55 {
56 Entry = RemoveHeadList( &Connection->ShutdownRequest );
57
58 Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
59
60 Bucket->Status = STATUS_TIMEOUT;
61 Bucket->Information = 0;
62
63 CompleteBucket(Connection, Bucket, FALSE);
64 }
65
66 UnlockObjectFromDpcLevel(Connection);
67
68 DereferenceObject(Connection);
69 }
70
71 VOID ConnectionFree(PVOID Object)
72 {
73 PCONNECTION_ENDPOINT Connection = (PCONNECTION_ENDPOINT)Object;
74 KIRQL OldIrql;
75
76 TI_DbgPrint(DEBUG_TCP, ("Freeing TCP Endpoint\n"));
77
78 TcpipAcquireSpinLock(&ConnectionEndpointListLock, &OldIrql);
79 RemoveEntryList(&Connection->ListEntry);
80 TcpipReleaseSpinLock(&ConnectionEndpointListLock, OldIrql);
81
82 ExFreePoolWithTag( Connection, CONN_ENDPT_TAG );
83 }
84
85 PCONNECTION_ENDPOINT TCPAllocateConnectionEndpoint( PVOID ClientContext )
86 {
87 PCONNECTION_ENDPOINT Connection = (PCONNECTION_ENDPOINT)
88 ExAllocatePoolWithTag(NonPagedPool, sizeof(CONNECTION_ENDPOINT),
89 CONN_ENDPT_TAG);
90 if (!Connection)
91 return Connection;
92
93 TI_DbgPrint(DEBUG_CPOINT, ("Connection point file object allocated at (0x%X).\n", Connection));
94
95 RtlZeroMemory(Connection, sizeof(CONNECTION_ENDPOINT));
96
97 /* Initialize spin lock that protects the connection endpoint file object */
98 KeInitializeSpinLock(&Connection->Lock);
99 InitializeListHead(&Connection->ConnectRequest);
100 InitializeListHead(&Connection->ListenRequest);
101 InitializeListHead(&Connection->ReceiveRequest);
102 InitializeListHead(&Connection->SendRequest);
103 InitializeListHead(&Connection->ShutdownRequest);
104 InitializeListHead(&Connection->PacketQueue);
105
106 /* Initialize disconnect timer */
107 KeInitializeTimer(&Connection->DisconnectTimer);
108 KeInitializeDpc(&Connection->DisconnectDpc, DisconnectTimeoutDpc, Connection);
109
110 /* Save client context pointer */
111 Connection->ClientContext = ClientContext;
112
113 Connection->RefCount = 1;
114 Connection->Free = ConnectionFree;
115
116 /* Add connection endpoint to global list */
117 ExInterlockedInsertTailList(&ConnectionEndpointListHead,
118 &Connection->ListEntry,
119 &ConnectionEndpointListLock);
120
121 return Connection;
122 }
123
124 NTSTATUS TCPSocket( PCONNECTION_ENDPOINT Connection,
125 UINT Family, UINT Type, UINT Proto )
126 {
127 NTSTATUS Status;
128 KIRQL OldIrql;
129
130 LockObject(Connection, &OldIrql);
131
132 TI_DbgPrint(DEBUG_TCP,("[IP, TCPSocket] Called: Connection %x, Family %d, Type %d, "
133 "Proto %d, sizeof(CONNECTION_ENDPOINT) = %d\n",
134 Connection, Family, Type, Proto, sizeof(CONNECTION_ENDPOINT)));
135
136 Connection->SocketContext = LibTCPSocket(Connection);
137 if (Connection->SocketContext)
138 Status = STATUS_SUCCESS;
139 else
140 Status = STATUS_INSUFFICIENT_RESOURCES;
141
142 UnlockObject(Connection, OldIrql);
143
144 TI_DbgPrint(DEBUG_TCP,("[IP, TCPSocket] Leaving. Status = 0x%x\n", Status));
145
146 return Status;
147 }
148
149 NTSTATUS TCPClose( PCONNECTION_ENDPOINT Connection )
150 {
151 KIRQL OldIrql;
152 PVOID Socket;
153
154 LockObject(Connection, &OldIrql);
155
156 Socket = Connection->SocketContext;
157
158 FlushAllQueues(Connection, STATUS_CANCELLED);
159
160 LibTCPClose(Connection, FALSE, TRUE);
161
162 UnlockObject(Connection, OldIrql);
163
164 DereferenceObject(Connection);
165
166 return STATUS_SUCCESS;
167 }
168
169 VOID TCPReceive(PIP_INTERFACE Interface, PIP_PACKET IPPacket)
170 /*
171 * FUNCTION: Receives and queues TCP data
172 * ARGUMENTS:
173 * IPPacket = Pointer to an IP packet that was received
174 * NOTES:
175 * This is the low level interface for receiving TCP data
176 */
177 {
178 TI_DbgPrint(DEBUG_TCP,("Sending packet %d (%d) to lwIP\n",
179 IPPacket->TotalSize,
180 IPPacket->HeaderSize));
181
182 LibIPInsertPacket(Interface->TCPContext, IPPacket->Header, IPPacket->TotalSize);
183 }
184
185 NTSTATUS TCPStartup(VOID)
186 /*
187 * FUNCTION: Initializes the TCP subsystem
188 * RETURNS:
189 * Status of operation
190 */
191 {
192 NTSTATUS Status;
193
194 Status = PortsStartup( &TCPPorts, 1, 0xfffe );
195 if (!NT_SUCCESS(Status))
196 {
197 return Status;
198 }
199
200 /* Initialize our IP library */
201 LibIPInitialize();
202
203 /* Register this protocol with IP layer */
204 IPRegisterProtocol(IPPROTO_TCP, TCPReceive);
205
206 TCPInitialized = TRUE;
207
208 return STATUS_SUCCESS;
209 }
210
211
212 NTSTATUS TCPShutdown(VOID)
213 /*
214 * FUNCTION: Shuts down the TCP subsystem
215 * RETURNS:
216 * Status of operation
217 */
218 {
219 if (!TCPInitialized)
220 return STATUS_SUCCESS;
221
222 LibIPShutdown();
223
224 /* Deregister this protocol with IP layer */
225 IPRegisterProtocol(IPPROTO_TCP, NULL);
226
227 TCPInitialized = FALSE;
228
229 PortsShutdown( &TCPPorts );
230
231 return STATUS_SUCCESS;
232 }
233
234 NTSTATUS TCPTranslateError(const err_t err)
235 {
236 NTSTATUS Status;
237
238 switch (err)
239 {
240 case ERR_OK: Status = STATUS_SUCCESS; return Status; //0
241 case ERR_MEM: Status = STATUS_INSUFFICIENT_RESOURCES; break; //-1
242 case ERR_BUF: Status = STATUS_BUFFER_TOO_SMALL; break; //-2
243 case ERR_TIMEOUT: Status = STATUS_TIMEOUT; break; // -3
244 case ERR_RTE: Status = STATUS_NETWORK_UNREACHABLE; break; //-4
245 case ERR_INPROGRESS: Status = STATUS_PENDING; return Status; //-5
246 case ERR_VAL: Status = STATUS_INVALID_PARAMETER; break; //-6
247 case ERR_WOULDBLOCK: Status = STATUS_CANT_WAIT; break; //-7
248 case ERR_USE: Status = STATUS_ADDRESS_ALREADY_EXISTS; break; //-8
249 case ERR_ISCONN: Status = STATUS_UNSUCCESSFUL; break; //-9 (FIXME)
250 case ERR_ABRT: Status = STATUS_LOCAL_DISCONNECT; break; //-10
251 case ERR_RST: Status = STATUS_REMOTE_DISCONNECT; break; //-11
252 case ERR_CLSD: Status = STATUS_FILE_CLOSED; break; //-12
253 case ERR_CONN: Status = STATUS_INVALID_CONNECTION; break; //-13
254 case ERR_ARG: Status = STATUS_INVALID_PARAMETER; break; //-14
255 case ERR_IF: Status = STATUS_UNEXPECTED_NETWORK_ERROR; break; //-15
256 default:
257 DbgPrint("Invalid error value: %d\n", err);
258 ASSERT(FALSE);
259 Status = STATUS_UNSUCCESSFUL;
260 break;
261 }
262
263 DbgPrint("TCP operation failed: 0x%x (%d)\n", Status, err);
264
265 return Status;
266 }
267
268 NTSTATUS TCPConnect
269 ( PCONNECTION_ENDPOINT Connection,
270 PTDI_CONNECTION_INFORMATION ConnInfo,
271 PTDI_CONNECTION_INFORMATION ReturnInfo,
272 PTCP_COMPLETION_ROUTINE Complete,
273 PVOID Context )
274 {
275 NTSTATUS Status;
276 struct ip_addr bindaddr, connaddr;
277 IP_ADDRESS RemoteAddress;
278 USHORT RemotePort;
279 TA_IP_ADDRESS LocalAddress;
280 PTDI_BUCKET Bucket;
281 PNEIGHBOR_CACHE_ENTRY NCE;
282 KIRQL OldIrql;
283
284 TI_DbgPrint(DEBUG_TCP,("[IP, TCPConnect] Called\n"));
285
286 Status = AddrBuildAddress
287 ((PTRANSPORT_ADDRESS)ConnInfo->RemoteAddress,
288 &RemoteAddress,
289 &RemotePort);
290
291 if (!NT_SUCCESS(Status))
292 {
293 TI_DbgPrint(DEBUG_TCP, ("Could not AddrBuildAddress in TCPConnect\n"));
294 return Status;
295 }
296
297 /* Freed in TCPSocketState */
298 TI_DbgPrint(DEBUG_TCP,
299 ("Connecting to address %x:%x\n",
300 RemoteAddress.Address.IPv4Address,
301 RemotePort));
302
303 LockObject(Connection, &OldIrql);
304
305 if (!Connection->AddressFile)
306 {
307 UnlockObject(Connection, OldIrql);
308 return STATUS_INVALID_PARAMETER;
309 }
310
311 if (AddrIsUnspecified(&Connection->AddressFile->Address))
312 {
313 if (!(NCE = RouteGetRouteToDestination(&RemoteAddress)))
314 {
315 UnlockObject(Connection, OldIrql);
316 return STATUS_NETWORK_UNREACHABLE;
317 }
318
319 bindaddr.addr = NCE->Interface->Unicast.Address.IPv4Address;
320 }
321 else
322 {
323 bindaddr.addr = Connection->AddressFile->Address.Address.IPv4Address;
324 }
325
326 Status = TCPTranslateError(LibTCPBind(Connection,
327 &bindaddr,
328 Connection->AddressFile->Port));
329
330 if (NT_SUCCESS(Status))
331 {
332 /* Check if we had an unspecified port */
333 if (!Connection->AddressFile->Port)
334 {
335 /* We did, so we need to copy back the port */
336 Status = TCPGetSockAddress(Connection, (PTRANSPORT_ADDRESS)&LocalAddress, FALSE);
337 if (NT_SUCCESS(Status))
338 {
339 /* Allocate the port in the port bitmap */
340 Connection->AddressFile->Port = TCPAllocatePort(LocalAddress.Address[0].Address[0].sin_port);
341
342 /* This should never fail */
343 ASSERT(Connection->AddressFile->Port != 0xFFFF);
344 }
345 }
346
347 if (NT_SUCCESS(Status))
348 {
349 connaddr.addr = RemoteAddress.Address.IPv4Address;
350
351 Bucket = ExAllocatePoolWithTag( NonPagedPool, sizeof(*Bucket), TDI_BUCKET_TAG );
352 if (!Bucket)
353 {
354 UnlockObject(Connection, OldIrql);
355 return STATUS_NO_MEMORY;
356 }
357
358 Bucket->Request.RequestNotifyObject = (PVOID)Complete;
359 Bucket->Request.RequestContext = Context;
360
361 InsertTailList( &Connection->ConnectRequest, &Bucket->Entry );
362
363 Status = TCPTranslateError(LibTCPConnect(Connection,
364 &connaddr,
365 RemotePort));
366 }
367 }
368
369 UnlockObject(Connection, OldIrql);
370
371 TI_DbgPrint(DEBUG_TCP,("[IP, TCPConnect] Leaving. Status = 0x%x\n", Status));
372
373 return Status;
374 }
375
376 NTSTATUS TCPDisconnect
377 ( PCONNECTION_ENDPOINT Connection,
378 UINT Flags,
379 PLARGE_INTEGER Timeout,
380 PTDI_CONNECTION_INFORMATION ConnInfo,
381 PTDI_CONNECTION_INFORMATION ReturnInfo,
382 PTCP_COMPLETION_ROUTINE Complete,
383 PVOID Context )
384 {
385 NTSTATUS Status = STATUS_INVALID_PARAMETER;
386 PTDI_BUCKET Bucket;
387 KIRQL OldIrql;
388 LARGE_INTEGER ActualTimeout;
389
390 TI_DbgPrint(DEBUG_TCP,("[IP, TCPDisconnect] Called\n"));
391
392 LockObject(Connection, &OldIrql);
393
394 if (Connection->SocketContext)
395 {
396 if (Flags & TDI_DISCONNECT_RELEASE)
397 {
398 if (IsListEmpty(&Connection->SendRequest))
399 {
400 Status = TCPTranslateError(LibTCPShutdown(Connection, 0, 1));
401 }
402 else if (Timeout && Timeout->QuadPart == 0)
403 {
404 FlushSendQueue(Connection, STATUS_FILE_CLOSED, FALSE);
405 TCPTranslateError(LibTCPShutdown(Connection, 0, 1));
406 Status = STATUS_TIMEOUT;
407 }
408 else
409 {
410 /* Use the timeout specified or 1 second if none was specified */
411 if (Timeout)
412 {
413 ActualTimeout = *Timeout;
414 }
415 else
416 {
417 ActualTimeout.QuadPart = -1000000;
418 }
419
420 /* We couldn't complete the request now because we need to wait for outstanding I/O */
421 Bucket = ExAllocatePoolWithTag(NonPagedPool, sizeof(*Bucket), TDI_BUCKET_TAG);
422 if (!Bucket)
423 {
424 UnlockObject(Connection, OldIrql);
425 return STATUS_NO_MEMORY;
426 }
427
428 Bucket->Request.RequestNotifyObject = (PVOID)Complete;
429 Bucket->Request.RequestContext = Context;
430
431 InsertTailList(&Connection->ShutdownRequest, &Bucket->Entry);
432
433 ReferenceObject(Connection);
434 if (KeCancelTimer(&Connection->DisconnectTimer))
435 {
436 DereferenceObject(Connection);
437 }
438 KeSetTimer(&Connection->DisconnectTimer, ActualTimeout, &Connection->DisconnectDpc);
439
440 Status = STATUS_PENDING;
441 }
442 }
443
444 if ((Flags & TDI_DISCONNECT_ABORT) || !Flags)
445 {
446 FlushReceiveQueue(Connection, STATUS_FILE_CLOSED, FALSE);
447 FlushSendQueue(Connection, STATUS_FILE_CLOSED, FALSE);
448 FlushShutdownQueue(Connection, STATUS_FILE_CLOSED, FALSE);
449 Status = TCPTranslateError(LibTCPShutdown(Connection, 1, 1));
450 }
451 }
452 else
453 {
454 /* We already got closed by the other side so just return success */
455 Status = STATUS_SUCCESS;
456 }
457
458 UnlockObject(Connection, OldIrql);
459
460 TI_DbgPrint(DEBUG_TCP,("[IP, TCPDisconnect] Leaving. Status = 0x%x\n", Status));
461
462 return Status;
463 }
464
465 NTSTATUS TCPReceiveData
466 ( PCONNECTION_ENDPOINT Connection,
467 PNDIS_BUFFER Buffer,
468 ULONG ReceiveLength,
469 PULONG BytesReceived,
470 ULONG ReceiveFlags,
471 PTCP_COMPLETION_ROUTINE Complete,
472 PVOID Context )
473 {
474 PTDI_BUCKET Bucket;
475 PUCHAR DataBuffer;
476 UINT DataLen, Received;
477 NTSTATUS Status;
478
479 TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Called for %d bytes (on socket %x)\n",
480 ReceiveLength, Connection->SocketContext));
481
482 NdisQueryBuffer(Buffer, &DataBuffer, &DataLen);
483
484 Status = LibTCPGetDataFromConnectionQueue(Connection, DataBuffer, DataLen, &Received);
485
486 if (Status == STATUS_PENDING)
487 {
488
489 /* Freed in TCPSocketState */
490 Bucket = ExAllocatePoolWithTag(NonPagedPool, sizeof(*Bucket), TDI_BUCKET_TAG);
491 if (!Bucket)
492 {
493 TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Failed to allocate bucket\n"));
494
495 return STATUS_NO_MEMORY;
496 }
497
498 Bucket->Request.RequestNotifyObject = Complete;
499 Bucket->Request.RequestContext = Context;
500
501 ExInterlockedInsertTailList( &Connection->ReceiveRequest, &Bucket->Entry, &Connection->Lock );
502 TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Queued read irp\n"));
503
504 TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Leaving. Status = STATUS_PENDING\n"));
505
506 (*BytesReceived) = 0;
507 }
508 else
509 {
510 (*BytesReceived) = Received;
511 }
512
513 return Status;
514 }
515
516 NTSTATUS TCPSendData
517 ( PCONNECTION_ENDPOINT Connection,
518 PCHAR BufferData,
519 ULONG SendLength,
520 PULONG BytesSent,
521 ULONG Flags,
522 PTCP_COMPLETION_ROUTINE Complete,
523 PVOID Context )
524 {
525 NTSTATUS Status;
526 PTDI_BUCKET Bucket;
527 KIRQL OldIrql;
528
529 LockObject(Connection, &OldIrql);
530
531 TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Called for %d bytes (on socket %x)\n",
532 SendLength, Connection->SocketContext));
533
534 TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Connection = %x\n", Connection));
535 TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Connection->SocketContext = %x\n",
536 Connection->SocketContext));
537
538 Status = TCPTranslateError(LibTCPSend(Connection,
539 BufferData,
540 SendLength,
541 FALSE));
542
543 TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Send: %x, %d\n", Status, SendLength));
544
545 /* Keep this request around ... there was no data yet */
546 if (Status == STATUS_PENDING)
547 {
548 /* Freed in TCPSocketState */
549 Bucket = ExAllocatePoolWithTag( NonPagedPool, sizeof(*Bucket), TDI_BUCKET_TAG );
550 if (!Bucket)
551 {
552 UnlockObject(Connection, OldIrql);
553 TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Failed to allocate bucket\n"));
554 return STATUS_NO_MEMORY;
555 }
556
557 Bucket->Request.RequestNotifyObject = Complete;
558 Bucket->Request.RequestContext = Context;
559 *BytesSent = 0;
560
561 InsertTailList( &Connection->SendRequest, &Bucket->Entry );
562 TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Queued write irp\n"));
563 }
564 else if (Status == STATUS_SUCCESS)
565 {
566 *BytesSent = SendLength;
567 }
568 else
569 {
570 *BytesSent = 0;
571 }
572
573 UnlockObject(Connection, OldIrql);
574
575 TI_DbgPrint(DEBUG_TCP, ("[IP, TCPSendData] Leaving. Status = %x\n", Status));
576
577 return Status;
578 }
579
580 UINT TCPAllocatePort(const UINT HintPort)
581 {
582 if (HintPort)
583 {
584 if (AllocatePort(&TCPPorts, HintPort))
585 return HintPort;
586 else
587 {
588 TI_DbgPrint(MID_TRACE,("We got a hint port but couldn't allocate it\n"));
589 return (UINT)-1;
590 }
591 }
592 else
593 return AllocatePortFromRange( &TCPPorts, 1024, 5000 );
594 }
595
596 VOID TCPFreePort(const UINT Port)
597 {
598 DeallocatePort(&TCPPorts, Port);
599 }
600
601 NTSTATUS TCPGetSockAddress
602 ( PCONNECTION_ENDPOINT Connection,
603 PTRANSPORT_ADDRESS Address,
604 BOOLEAN GetRemote )
605 {
606 PTA_IP_ADDRESS AddressIP = (PTA_IP_ADDRESS)Address;
607 struct ip_addr ipaddr;
608 NTSTATUS Status;
609 KIRQL OldIrql;
610
611 AddressIP->TAAddressCount = 1;
612 AddressIP->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
613 AddressIP->Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
614
615 LockObject(Connection, &OldIrql);
616
617 if (GetRemote)
618 {
619 Status = TCPTranslateError(LibTCPGetPeerName(Connection->SocketContext,
620 &ipaddr,
621 &AddressIP->Address[0].Address[0].sin_port));
622 }
623 else
624 {
625 Status = TCPTranslateError(LibTCPGetHostName(Connection->SocketContext,
626 &ipaddr,
627 &AddressIP->Address[0].Address[0].sin_port));
628 }
629
630 UnlockObject(Connection, OldIrql);
631
632 AddressIP->Address[0].Address[0].in_addr = ipaddr.addr;
633
634 return Status;
635 }
636
637 BOOLEAN TCPRemoveIRP( PCONNECTION_ENDPOINT Endpoint, PIRP Irp )
638 {
639 PLIST_ENTRY Entry;
640 PLIST_ENTRY ListHead[5];
641 KIRQL OldIrql;
642 PTDI_BUCKET Bucket;
643 UINT i = 0;
644 BOOLEAN Found = FALSE;
645
646 ListHead[0] = &Endpoint->SendRequest;
647 ListHead[1] = &Endpoint->ReceiveRequest;
648 ListHead[2] = &Endpoint->ConnectRequest;
649 ListHead[3] = &Endpoint->ListenRequest;
650 ListHead[4] = &Endpoint->ShutdownRequest;
651
652 LockObject(Endpoint, &OldIrql);
653
654 for( i = 0; i < 5; i++ )
655 {
656 for( Entry = ListHead[i]->Flink;
657 Entry != ListHead[i];
658 Entry = Entry->Flink )
659 {
660 Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
661 if( Bucket->Request.RequestContext == Irp )
662 {
663 RemoveEntryList( &Bucket->Entry );
664 ExFreePoolWithTag( Bucket, TDI_BUCKET_TAG );
665 Found = TRUE;
666 break;
667 }
668 }
669 }
670
671 UnlockObject(Endpoint, OldIrql);
672
673 return Found;
674 }
675
676 /* EOF */