546df6f782d61540f3483060534f0d61ca4fbfd5
[reactos.git] / reactos / drivers / net / tcpip / tcpip / fileobjs.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS TCP/IP protocol driver
4 * FILE: tcpip/fileobjs.c
5 * PURPOSE: Routines for handling file objects
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * REVISIONS:
8 * CSH 01/08-2000 Created
9 */
10
11 #include "precomp.h"
12
13
14 /* List of all address file objects managed by this driver */
15 LIST_ENTRY AddressFileListHead;
16 KSPIN_LOCK AddressFileListLock;
17
18 /* List of all connection endpoint file objects managed by this driver */
19 LIST_ENTRY ConnectionEndpointListHead;
20 KSPIN_LOCK ConnectionEndpointListLock;
21
22 /*
23 * FUNCTION: Searches through address file entries to find the first match
24 * ARGUMENTS:
25 * Address = IP address
26 * Port = Port number
27 * Protocol = Protocol number
28 * SearchContext = Pointer to search context
29 * RETURNS:
30 * Pointer to address file, NULL if none was found
31 */
32 PADDRESS_FILE AddrSearchFirst(
33 PIP_ADDRESS Address,
34 USHORT Port,
35 USHORT Protocol,
36 PAF_SEARCH SearchContext)
37 {
38 SearchContext->Address = Address;
39 SearchContext->Port = Port;
40 SearchContext->Next = AddressFileListHead.Flink;
41 SearchContext->Protocol = Protocol;
42
43 return AddrSearchNext(SearchContext);
44 }
45
46 BOOLEAN AddrIsBroadcast(
47 PIP_ADDRESS PossibleMatch,
48 PIP_ADDRESS TargetAddress ) {
49 IF_LIST_ITER(IF);
50
51 ForEachInterface(IF) {
52 if( AddrIsEqual( &IF->Unicast, PossibleMatch ) &&
53 AddrIsEqual( &IF->Broadcast, TargetAddress ) )
54 return TRUE;
55 } EndFor(IF);
56
57 return FALSE;
58 }
59
60 /*
61 * FUNCTION: Searches through address file entries to find next match
62 * ARGUMENTS:
63 * SearchContext = Pointer to search context
64 * RETURNS:
65 * Pointer to address file, NULL if none was found
66 */
67 PADDRESS_FILE AddrSearchNext(
68 PAF_SEARCH SearchContext)
69 {
70 PLIST_ENTRY CurrentEntry;
71 PIP_ADDRESS IPAddress;
72 KIRQL OldIrql;
73 PADDRESS_FILE Current = NULL;
74 BOOLEAN Found = FALSE;
75
76 if (IsListEmpty(SearchContext->Next))
77 return NULL;
78
79 CurrentEntry = SearchContext->Next;
80
81 TcpipAcquireSpinLock(&AddressFileListLock, &OldIrql);
82
83 while (CurrentEntry != &AddressFileListHead) {
84 Current = CONTAINING_RECORD(CurrentEntry, ADDRESS_FILE, ListEntry);
85
86 IPAddress = &Current->Address;
87
88 TI_DbgPrint(DEBUG_ADDRFILE, ("Comparing: ((%d, %d, %s), (%d, %d, %s)).\n",
89 WN2H(Current->Port),
90 Current->Protocol,
91 A2S(IPAddress),
92 WN2H(SearchContext->Port),
93 SearchContext->Protocol,
94 A2S(SearchContext->Address)));
95
96 /* See if this address matches the search criteria */
97 if ((Current->Port == SearchContext->Port) &&
98 (Current->Protocol == SearchContext->Protocol) &&
99 (AddrIsEqual(IPAddress, SearchContext->Address) ||
100 AddrIsBroadcast(IPAddress, SearchContext->Address) ||
101 AddrIsUnspecified(IPAddress))) {
102 /* We've found a match */
103 Found = TRUE;
104 break;
105 }
106 CurrentEntry = CurrentEntry->Flink;
107 }
108
109 TcpipReleaseSpinLock(&AddressFileListLock, OldIrql);
110
111 if (Found) {
112 SearchContext->Next = CurrentEntry->Flink;
113 return Current;
114 } else
115 return NULL;
116 }
117
118 VOID AddrFileFree(
119 PVOID Object)
120 /*
121 * FUNCTION: Frees an address file object
122 * ARGUMENTS:
123 * Object = Pointer to address file object to free
124 */
125 {
126 ExFreePool(Object);
127 }
128
129
130 VOID ControlChannelFree(
131 PVOID Object)
132 /*
133 * FUNCTION: Frees an address file object
134 * ARGUMENTS:
135 * Object = Pointer to address file object to free
136 */
137 {
138 ExFreePool(Object);
139 }
140
141
142 VOID DeleteAddress(PADDRESS_FILE AddrFile)
143 /*
144 * FUNCTION: Deletes an address file object
145 * ARGUMENTS:
146 * AddrFile = Pointer to address file object to delete
147 */
148 {
149 KIRQL OldIrql;
150 PLIST_ENTRY CurrentEntry;
151 PLIST_ENTRY NextEntry;
152 PDATAGRAM_SEND_REQUEST SendRequest;
153 PDATAGRAM_RECEIVE_REQUEST ReceiveRequest;
154
155 TI_DbgPrint(MID_TRACE, ("Called.\n"));
156
157 /* Remove address file from the global list */
158 TcpipAcquireSpinLock(&AddressFileListLock, &OldIrql);
159 RemoveEntryList(&AddrFile->ListEntry);
160 TcpipReleaseSpinLock(&AddressFileListLock, OldIrql);
161
162 TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql);
163
164 /* FIXME: Kill TCP connections on this address file object */
165
166 /* Return pending requests with error */
167
168 TI_DbgPrint(DEBUG_ADDRFILE, ("Aborting receive requests on AddrFile at (0x%X).\n", AddrFile));
169
170 /* Go through pending receive request list and cancel them all */
171 CurrentEntry = AddrFile->ReceiveQueue.Flink;
172 while (CurrentEntry != &AddrFile->ReceiveQueue) {
173 NextEntry = CurrentEntry->Flink;
174 ReceiveRequest = CONTAINING_RECORD(CurrentEntry, DATAGRAM_RECEIVE_REQUEST, ListEntry);
175 /* Abort the request and free its resources */
176 TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
177 (*ReceiveRequest->Complete)(ReceiveRequest->Context, STATUS_ADDRESS_CLOSED, 0);
178 TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql);
179 CurrentEntry = NextEntry;
180 }
181
182 TI_DbgPrint(DEBUG_ADDRFILE, ("Aborting send requests on address file at (0x%X).\n", AddrFile));
183
184 /* Go through pending send request list and cancel them all */
185 CurrentEntry = AddrFile->TransmitQueue.Flink;
186 while (CurrentEntry != &AddrFile->TransmitQueue) {
187 NextEntry = CurrentEntry->Flink;
188 SendRequest = CONTAINING_RECORD(CurrentEntry,
189 DATAGRAM_SEND_REQUEST, ListEntry);
190 /* Abort the request and free its resources */
191 TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
192 (*SendRequest->Complete)(SendRequest->Context, STATUS_ADDRESS_CLOSED, 0);
193 ExFreePool(SendRequest);
194 TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql);
195 CurrentEntry = NextEntry;
196 }
197
198 TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
199
200 (*AddrFile->Free)(AddrFile);
201
202 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
203 }
204
205
206 /*
207 * FUNCTION: Deletes a connection endpoint file object
208 * ARGUMENTS:
209 * Connection = Pointer to connection endpoint to delete
210 */
211 VOID DeleteConnectionEndpoint(
212 PCONNECTION_ENDPOINT Connection)
213 {
214 KIRQL OldIrql;
215
216 TI_DbgPrint(MID_TRACE, ("Called.\n"));
217
218 /* Remove connection endpoint from the global list */
219 TcpipAcquireSpinLock(&ConnectionEndpointListLock, &OldIrql);
220 RemoveEntryList(&Connection->ListEntry);
221 TcpipReleaseSpinLock(&ConnectionEndpointListLock, OldIrql);
222
223 ExFreePool(Connection);
224
225 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
226 }
227
228 /*
229 * FUNCTION: Open an address file object
230 * ARGUMENTS:
231 * Request = Pointer to TDI request structure for this request
232 * Address = Pointer to address to be opened
233 * Protocol = Protocol on which to open the address
234 * Options = Pointer to option buffer
235 * RETURNS:
236 * Status of operation
237 */
238 NTSTATUS FileOpenAddress(
239 PTDI_REQUEST Request,
240 PTA_IP_ADDRESS Address,
241 USHORT Protocol,
242 PVOID Options)
243 {
244 IPv4_RAW_ADDRESS IPv4Address;
245 BOOLEAN Matched;
246 PADDRESS_FILE AddrFile;
247
248 TI_DbgPrint(MID_TRACE, ("Called (Proto %d).\n", Protocol));
249
250 AddrFile = ExAllocatePool(NonPagedPool, sizeof(ADDRESS_FILE));
251 if (!AddrFile) {
252 TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
253 return STATUS_INSUFFICIENT_RESOURCES;
254 }
255
256 TI_DbgPrint(DEBUG_ADDRFILE, ("Address file object allocated at (0x%X).\n", AddrFile));
257
258 RtlZeroMemory(AddrFile, sizeof(ADDRESS_FILE));
259
260 AddrFile->Free = AddrFileFree;
261
262 /* Make sure address is a local unicast address or 0 */
263
264 /* Locate address entry. If specified address is 0, a random address is chosen */
265
266 /* FIXME: IPv4 only */
267 AddrFile->Family = Address->Address[0].AddressType;
268 IPv4Address = Address->Address[0].Address[0].in_addr;
269 if (IPv4Address == 0)
270 Matched = IPGetDefaultAddress(&AddrFile->Address);
271 else
272 Matched = AddrLocateADEv4(IPv4Address, &AddrFile->Address);
273
274 if (!Matched) {
275 ExFreePool(AddrFile);
276 TI_DbgPrint(MIN_TRACE, ("Non-local address given (0x%X).\n", DN2H(IPv4Address)));
277 return STATUS_INVALID_PARAMETER;
278 }
279
280 TI_DbgPrint(MID_TRACE, ("Opening address %s for communication (P=%d U=%d).\n",
281 A2S(&AddrFile->Address), Protocol, IPPROTO_UDP));
282
283 /* Protocol specific handling */
284 switch (Protocol) {
285 case IPPROTO_TCP:
286 AddrFile->Port =
287 TCPAllocatePort(Address->Address[0].Address[0].sin_port);
288 AddrFile->Send = NULL; /* TCPSendData */
289 break;
290
291 case IPPROTO_UDP:
292 TI_DbgPrint(MID_TRACE,("Allocating udp port\n"));
293 AddrFile->Port =
294 UDPAllocatePort(Address->Address[0].Address[0].sin_port);
295 TI_DbgPrint(MID_TRACE,("Setting port %d (wanted %d)\n",
296 AddrFile->Port,
297 Address->Address[0].Address[0].sin_port));
298 AddrFile->Send = UDPSendDatagram;
299 break;
300
301 default:
302 /* Use raw IP for all other protocols */
303 AddrFile->Port = 0;
304 AddrFile->Send = RawIPSendDatagram;
305 break;
306 }
307
308 TI_DbgPrint(MID_TRACE, ("IP protocol number for address file object is %d.\n",
309 Protocol));
310
311 TI_DbgPrint(MID_TRACE, ("Port number for address file object is %d.\n",
312 WN2H(AddrFile->Port)));
313
314 /* Set protocol */
315 AddrFile->Protocol = Protocol;
316
317 /* Initialize receive and transmit queues */
318 InitializeListHead(&AddrFile->ReceiveQueue);
319 InitializeListHead(&AddrFile->TransmitQueue);
320
321 /* Initialize spin lock that protects the address file object */
322 KeInitializeSpinLock(&AddrFile->Lock);
323
324 /* Set valid flag so the address can be used */
325 AF_SET_VALID(AddrFile);
326
327 /* Return address file object */
328 Request->Handle.AddressHandle = AddrFile;
329
330 /* Add address file to global list */
331 ExInterlockedInsertTailList(
332 &AddressFileListHead,
333 &AddrFile->ListEntry,
334 &AddressFileListLock);
335
336 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
337
338 return STATUS_SUCCESS;
339 }
340
341
342 /*
343 * FUNCTION: Closes an address file object
344 * ARGUMENTS:
345 * Request = Pointer to TDI request structure for this request
346 * RETURNS:
347 * Status of operation
348 */
349 NTSTATUS FileCloseAddress(
350 PTDI_REQUEST Request)
351 {
352 KIRQL OldIrql;
353 PADDRESS_FILE AddrFile;
354 NTSTATUS Status = STATUS_SUCCESS;
355
356 TI_DbgPrint(MID_TRACE, ("Called.\n"));
357
358 AddrFile = Request->Handle.AddressHandle;
359
360 TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql);
361
362 /* Set address file object exclusive to us */
363 AF_SET_BUSY(AddrFile);
364 AF_CLR_VALID(AddrFile);
365
366 TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
367
368 /* Protocol specific handling */
369 switch (AddrFile->Protocol) {
370 case IPPROTO_TCP:
371 TCPFreePort( AddrFile->Port );
372 if( AddrFile->Listener )
373 TCPClose( AddrFile->Listener );
374 break;
375
376 case IPPROTO_UDP:
377 UDPFreePort( AddrFile->Port );
378 break;
379 }
380
381 DeleteAddress(AddrFile);
382
383 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
384
385 return Status;
386 }
387
388
389 /*
390 * FUNCTION: Opens a connection file object
391 * ARGUMENTS:
392 * Request = Pointer to TDI request structure for this request
393 * ClientContext = Pointer to client context information
394 * RETURNS:
395 * Status of operation
396 */
397 NTSTATUS FileOpenConnection(
398 PTDI_REQUEST Request,
399 PVOID ClientContext)
400 {
401 NTSTATUS Status;
402 PCONNECTION_ENDPOINT Connection;
403
404 TI_DbgPrint(MID_TRACE, ("Called.\n"));
405
406 Connection = TCPAllocateConnectionEndpoint( ClientContext );
407
408 if( !Connection ) return STATUS_NO_MEMORY;
409
410 Status = TCPSocket( Connection, AF_INET, SOCK_STREAM, IPPROTO_TCP );
411
412 /* Return connection endpoint file object */
413 Request->Handle.ConnectionContext = Connection;
414
415 /* Add connection endpoint to global list */
416 ExInterlockedInsertTailList(
417 &ConnectionEndpointListHead,
418 &Connection->ListEntry,
419 &ConnectionEndpointListLock);
420
421 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
422
423 return STATUS_SUCCESS;
424 }
425
426
427 /*
428 * FUNCTION: Find a connection by examining the context field. This
429 * is needed in some situations where a FIN reply is needed after a
430 * socket is formally broken.
431 * ARGUMENTS:
432 * Request = Pointer to TDI request structure for this request
433 * RETURNS:
434 * Status of operation
435 */
436 PCONNECTION_ENDPOINT FileFindConnectionByContext( PVOID Context ) {
437 PLIST_ENTRY Entry;
438 KIRQL OldIrql;
439 PCONNECTION_ENDPOINT Connection = NULL;
440
441 TcpipAcquireSpinLock( &ConnectionEndpointListLock, &OldIrql );
442
443 for( Entry = ConnectionEndpointListHead.Flink;
444 Entry != &ConnectionEndpointListHead;
445 Entry = Entry->Flink ) {
446 Connection =
447 CONTAINING_RECORD( Entry, CONNECTION_ENDPOINT, ListEntry );
448 if( Connection->SocketContext == Context ) break;
449 else Connection = NULL;
450 }
451
452 TcpipReleaseSpinLock( &ConnectionEndpointListLock, OldIrql );
453
454 return Connection;
455 }
456
457 /*
458 * FUNCTION: Closes an connection file object
459 * ARGUMENTS:
460 * Request = Pointer to TDI request structure for this request
461 * RETURNS:
462 * Status of operation
463 */
464 NTSTATUS FileCloseConnection(
465 PTDI_REQUEST Request)
466 {
467 PCONNECTION_ENDPOINT Connection;
468 NTSTATUS Status = STATUS_SUCCESS;
469
470 TI_DbgPrint(MID_TRACE, ("Called.\n"));
471
472 Connection = Request->Handle.ConnectionContext;
473
474 TcpipRecursiveMutexEnter( &TCPLock, TRUE );
475 TCPClose(Connection);
476 DeleteConnectionEndpoint(Connection);
477 TcpipRecursiveMutexLeave( &TCPLock );
478
479 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
480
481 return Status;
482 }
483
484
485 /*
486 * FUNCTION: Opens a control channel file object
487 * ARGUMENTS:
488 * Request = Pointer to TDI request structure for this request
489 * RETURNS:
490 * Status of operation
491 */
492 NTSTATUS FileOpenControlChannel(
493 PTDI_REQUEST Request)
494 {
495 PCONTROL_CHANNEL ControlChannel;
496 TI_DbgPrint(MID_TRACE, ("Called.\n"));
497
498 ControlChannel = ExAllocatePool(NonPagedPool, sizeof(*ControlChannel));
499
500 if (!ControlChannel) {
501 TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
502 return STATUS_INSUFFICIENT_RESOURCES;
503 }
504
505 RtlZeroMemory(ControlChannel, sizeof(CONTROL_CHANNEL));
506
507 /* Make sure address is a local unicast address or 0 */
508
509 /* Locate address entry. If specified address is 0, a random address is chosen */
510
511 /* Initialize receive and transmit queues */
512 InitializeListHead(&ControlChannel->ListEntry);
513
514 /* Initialize spin lock that protects the address file object */
515 KeInitializeSpinLock(&ControlChannel->Lock);
516
517 /* Return address file object */
518 Request->Handle.ControlChannel = ControlChannel;
519
520 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
521
522 return STATUS_SUCCESS;
523 }
524
525 /*
526 * FUNCTION: Closes a control channel file object
527 * ARGUMENTS:
528 * Request = Pointer to TDI request structure for this request
529 * RETURNS:
530 * Status of operation
531 */
532 NTSTATUS FileCloseControlChannel(
533 PTDI_REQUEST Request)
534 {
535 PCONTROL_CHANNEL ControlChannel = Request->Handle.ControlChannel;
536 NTSTATUS Status = STATUS_SUCCESS;
537
538 ExFreePool(ControlChannel);
539 Request->Handle.ControlChannel = NULL;
540
541 return Status;
542 }
543
544 /* EOF */