ReactOS 0.4.15-dev-8145-ga541a46
fileobjs.c File Reference
#include "precomp.h"
#include <ntifs.h>
#include <ndk/pstypes.h>
Include dependency graph for fileobjs.c:

Go to the source code of this file.

Functions

PADDRESS_FILE AddrSearchFirst (PIP_ADDRESS Address, USHORT Port, USHORT Protocol, PAF_SEARCH SearchContext)
 
BOOLEAN AddrIsBroadcastMatch (PIP_ADDRESS UnicastAddress, PIP_ADDRESS BroadcastAddress)
 
BOOLEAN AddrReceiveMatch (PIP_ADDRESS LocalAddress, PIP_ADDRESS RemoteAddress)
 
VOID LogActiveObjects (VOID)
 
PADDRESS_FILE AddrFindShared (PIP_ADDRESS BindAddress, USHORT Port, USHORT Protocol)
 
PADDRESS_FILE AddrSearchNext (PAF_SEARCH SearchContext)
 
VOID AddrFileFree (PVOID Object)
 
VOID ControlChannelFree (PVOID Object)
 
NTSTATUS FileOpenAddress (PTDI_REQUEST Request, PTA_IP_ADDRESS Address, USHORT Protocol, BOOLEAN Shared, PVOID Options)
 
NTSTATUS FileCloseAddress (PTDI_REQUEST Request)
 
NTSTATUS FileOpenConnection (PTDI_REQUEST Request, PVOID ClientContext)
 
NTSTATUS FileCloseConnection (PTDI_REQUEST Request)
 
NTSTATUS FileOpenControlChannel (PTDI_REQUEST Request)
 
NTSTATUS FileCloseControlChannel (PTDI_REQUEST Request)
 

Variables

LIST_ENTRY AddressFileListHead
 
KSPIN_LOCK AddressFileListLock
 
LIST_ENTRY ConnectionEndpointListHead
 
KSPIN_LOCK ConnectionEndpointListLock
 

Function Documentation

◆ AddrFileFree()

VOID AddrFileFree ( PVOID  Object)

Definition at line 302 of file fileobjs.c.

309{
310 PADDRESS_FILE AddrFile = Object;
312 PDATAGRAM_RECEIVE_REQUEST ReceiveRequest;
313 // PDATAGRAM_SEND_REQUEST SendRequest; See WTF below
314 PLIST_ENTRY CurrentEntry;
315
316 TI_DbgPrint(MID_TRACE, ("Called.\n"));
317
318 /* We should not be associated with a connection here */
319 ASSERT(!AddrFile->Connection);
320
321 /* Remove address file from the global list */
323 RemoveEntryList(&AddrFile->ListEntry);
325
326 /* FIXME: Kill TCP connections on this address file object */
327
328 /* Return pending requests with error */
329
330 TI_DbgPrint(DEBUG_ADDRFILE, ("Aborting receive requests on AddrFile at (0x%X).\n", AddrFile));
331
332 /* Go through pending receive request list and cancel them all */
333 while (!IsListEmpty(&AddrFile->ReceiveQueue))
334 {
335 CurrentEntry = RemoveHeadList(&AddrFile->ReceiveQueue);
336 ReceiveRequest = CONTAINING_RECORD(CurrentEntry, DATAGRAM_RECEIVE_REQUEST, ListEntry);
337 (*ReceiveRequest->Complete)(ReceiveRequest->Context, STATUS_CANCELLED, 0);
338 ExFreePoolWithTag(ReceiveRequest, DATAGRAM_RECV_TAG);
339 }
340
341 TI_DbgPrint(DEBUG_ADDRFILE, ("Aborting send requests on address file at (0x%X).\n", AddrFile));
342
343#if 0 /* Biggest WTF. All of this was taken care of above as DATAGRAM_RECEIVE_REQUEST. */
344 /* Go through pending send request list and cancel them all */
345 while (!IsListEmpty(&AddrFile->ReceiveQueue))
346 {
347 CurrentEntry = RemoveHeadList(&AddrFile->ReceiveQueue);
348 SendRequest = CONTAINING_RECORD(CurrentEntry, DATAGRAM_SEND_REQUEST, ListEntry);
349 (*SendRequest->Complete)(SendRequest->Context, STATUS_CANCELLED, 0);
351 }
352#endif
353
354 /* Protocol specific handling */
355 switch (AddrFile->Protocol) {
356 case IPPROTO_TCP:
357 if (AddrFile->Port)
358 {
359 TCPFreePort(AddrFile->Port);
360 }
361 break;
362
363 case IPPROTO_UDP:
364 UDPFreePort( AddrFile->Port );
365 break;
366 }
367
368 RemoveEntityByContext(AddrFile);
369
370 ExDeleteResourceLite(&AddrFile->Resource);
371
373}
#define MID_TRACE
Definition: debug.h:15
#define DEBUG_ADDRFILE
Definition: debug.h:23
#define TI_DbgPrint(_t_, _x_)
Definition: debug.h:45
#define IPPROTO_TCP
Definition: ip.h:196
#define IPPROTO_UDP
Definition: ip.h:197
VOID TcpipReleaseSpinLock(PKSPIN_LOCK SpinLock, KIRQL Irql)
Definition: lock.c:26
VOID TcpipAcquireSpinLock(PKSPIN_LOCK SpinLock, PKIRQL Irql)
Definition: lock.c:18
#define DATAGRAM_RECV_TAG
Definition: tags.h:16
#define ADDR_FILE_TAG
Definition: tags.h:11
#define DATAGRAM_SEND_TAG
Definition: tags.h:15
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define ExDeleteResourceLite(res)
Definition: env_spec_w32.h:647
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
KSPIN_LOCK AddressFileListLock
Definition: fileobjs.c:22
VOID TCPFreePort(const UINT Port)
Definition: tcp.c:652
VOID UDPFreePort(UINT Port)
Definition: udp.c:391
VOID RemoveEntityByContext(PVOID Context)
Definition: info.c:46
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
BOOL SendRequest(PCHAR pInBuffer, ULONG InBufferLength, PCHAR pOutBuffer, PULONG pOutBufferLength)
Definition: utility.c:11
struct _CONNECTION_ENDPOINT * Connection
Definition: titypes.h:131
LIST_ENTRY ReceiveQueue
Definition: titypes.h:129
USHORT Port
Definition: titypes.h:120
ERESOURCE Resource
Definition: titypes.h:116
USHORT Protocol
Definition: titypes.h:119
LIST_ENTRY ListEntry
Definition: titypes.h:113
DATAGRAM_COMPLETION_ROUTINE Complete
Definition: titypes.h:84
Definition: typedefs.h:120
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
#define STATUS_CANCELLED
Definition: udferr_usr.h:170
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778

Referenced by FileOpenAddress().

◆ AddrFindShared()

PADDRESS_FILE AddrFindShared ( PIP_ADDRESS  BindAddress,
USHORT  Port,
USHORT  Protocol 
)

Definition at line 190 of file fileobjs.c.

194{
195 PLIST_ENTRY CurrentEntry;
197 PADDRESS_FILE Current = NULL;
198
200
201 CurrentEntry = AddressFileListHead.Flink;
202 while (CurrentEntry != &AddressFileListHead) {
203 Current = CONTAINING_RECORD(CurrentEntry, ADDRESS_FILE, ListEntry);
204
205 /* See if this address matches the search criteria */
206 if ((Current->Port == Port) &&
207 (Current->Protocol == Protocol))
208 {
209 /* Increase the sharer count */
210 ASSERT(Current->Sharers != 0);
211 InterlockedIncrement(&Current->Sharers);
212 break;
213 }
214
215 CurrentEntry = CurrentEntry->Flink;
216 Current = NULL;
217 }
218
220
221 return Current;
222}
#define InterlockedIncrement
Definition: armddk.h:53
#define NULL
Definition: types.h:112
LIST_ENTRY AddressFileListHead
Definition: fileobjs.c:21
CPPORT Port[4]
Definition: headless.c:35
LONG Sharers
Definition: titypes.h:121
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121

Referenced by FileOpenAddress().

◆ AddrIsBroadcastMatch()

BOOLEAN AddrIsBroadcastMatch ( PIP_ADDRESS  UnicastAddress,
PIP_ADDRESS  BroadcastAddress 
)

Definition at line 62 of file fileobjs.c.

64 {
65 IF_LIST_ITER(IF);
66
68 if ((AddrIsUnspecified(UnicastAddress) ||
69 AddrIsEqual(&IF->Unicast, UnicastAddress)) &&
70 (AddrIsEqual(&IF->Broadcast, BroadcastAddress)))
71 return TRUE;
72 } EndFor(IF);
73
74 return FALSE;
75}
BOOLEAN AddrIsUnspecified(PIP_ADDRESS Address)
Definition: address.c:113
BOOLEAN AddrIsEqual(PIP_ADDRESS Address1, PIP_ADDRESS Address2)
Definition: address.c:221
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define ForEachInterface(n)
Definition: tilists.h:9
#define EndFor(n)
Definition: tilists.h:20
#define IF_LIST_ITER(n)
Definition: tilists.h:5

Referenced by AddrReceiveMatch().

◆ AddrReceiveMatch()

BOOLEAN AddrReceiveMatch ( PIP_ADDRESS  LocalAddress,
PIP_ADDRESS  RemoteAddress 
)

Definition at line 77 of file fileobjs.c.

80{
82 {
83 /* Unicast address match */
84 return TRUE;
85 }
86
88 {
89 /* Broadcast address match */
90 return TRUE;
91 }
92
94 {
95 /* Local address unspecified */
96 return TRUE;
97 }
98
100 {
101 /* Remote address unspecified */
102 return TRUE;
103 }
104
105 return FALSE;
106}
BOOLEAN AddrIsBroadcastMatch(PIP_ADDRESS UnicastAddress, PIP_ADDRESS BroadcastAddress)
Definition: fileobjs.c:62
_Must_inspect_result_ _In_ ULONG _In_ PSOCKADDR LocalAddress
Definition: wsk.h:171
_Must_inspect_result_ _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR RemoteAddress
Definition: wsk.h:172

Referenced by AddrSearchNext().

◆ AddrSearchFirst()

PADDRESS_FILE AddrSearchFirst ( PIP_ADDRESS  Address,
USHORT  Port,
USHORT  Protocol,
PAF_SEARCH  SearchContext 
)

Definition at line 38 of file fileobjs.c.

43{
45
46 SearchContext->Address = Address;
47 SearchContext->Port = Port;
48 SearchContext->Protocol = Protocol;
49
51
52 SearchContext->Next = AddressFileListHead.Flink;
53
55 ReferenceObject(CONTAINING_RECORD(SearchContext->Next, ADDRESS_FILE, ListEntry));
56
58
59 return AddrSearchNext(SearchContext);
60}
PADDRESS_FILE AddrSearchNext(PAF_SEARCH SearchContext)
Definition: fileobjs.c:231
static WCHAR Address[46]
Definition: ping.c:68
PLIST_ENTRY Next
Definition: titypes.h:184
USHORT Port
Definition: titypes.h:186
PIP_ADDRESS Address
Definition: titypes.h:185
USHORT Protocol
Definition: titypes.h:187
#define ReferenceObject(Object)
Definition: titypes.h:14

Referenced by RawIpReceive(), and UDPReceive().

◆ AddrSearchNext()

PADDRESS_FILE AddrSearchNext ( PAF_SEARCH  SearchContext)

Definition at line 231 of file fileobjs.c.

233{
234 PLIST_ENTRY CurrentEntry;
235 PIP_ADDRESS IPAddress;
237 PADDRESS_FILE Current = NULL;
239 PADDRESS_FILE StartingAddrFile;
240
242
243 if (SearchContext->Next == &AddressFileListHead)
244 {
246 return NULL;
247 }
248
249 /* Save this pointer so we can dereference it later */
250 StartingAddrFile = CONTAINING_RECORD(SearchContext->Next, ADDRESS_FILE, ListEntry);
251
252 CurrentEntry = SearchContext->Next;
253
254 while (CurrentEntry != &AddressFileListHead) {
255 Current = CONTAINING_RECORD(CurrentEntry, ADDRESS_FILE, ListEntry);
256
257 IPAddress = &Current->Address;
258
259 TI_DbgPrint(DEBUG_ADDRFILE, ("Comparing: ((%d, %d, %s), (%d, %d, %s)).\n",
260 WN2H(Current->Port),
261 Current->Protocol,
262 A2S(IPAddress),
263 WN2H(SearchContext->Port),
264 SearchContext->Protocol,
265 A2S(SearchContext->Address)));
266
267 /* See if this address matches the search criteria */
268 if ((Current->Port == SearchContext->Port) &&
269 (Current->Protocol == SearchContext->Protocol) &&
270 (AddrReceiveMatch(IPAddress, SearchContext->Address))) {
271 /* We've found a match */
272 Found = TRUE;
273 break;
274 }
275 CurrentEntry = CurrentEntry->Flink;
276 }
277
278 if (Found)
279 {
280 SearchContext->Next = CurrentEntry->Flink;
281
282 if (SearchContext->Next != &AddressFileListHead)
283 {
284 /* Reference the next address file to prevent the link from disappearing behind our back */
285 ReferenceObject(CONTAINING_RECORD(SearchContext->Next, ADDRESS_FILE, ListEntry));
286 }
287
288 /* Reference the returned address file before dereferencing the starting
289 * address file because it may be that Current == StartingAddrFile */
290 ReferenceObject(Current);
291 }
292 else
293 Current = NULL;
294
295 DereferenceObject(StartingAddrFile);
296
298
299 return Current;
300}
unsigned char BOOLEAN
#define WN2H(w)
Definition: addrconv.c:35
return Found
Definition: dirsup.c:1270
PCHAR A2S(PIP_ADDRESS Address)
Definition: address.c:17
BOOLEAN AddrReceiveMatch(PIP_ADDRESS LocalAddress, PIP_ADDRESS RemoteAddress)
Definition: fileobjs.c:77
Definition: ip.h:23
IP_ADDRESS Address
Definition: titypes.h:117
#define DereferenceObject(Object)
Definition: titypes.h:24

Referenced by AddrSearchFirst(), RawIpReceive(), and UDPReceive().

◆ ControlChannelFree()

VOID ControlChannelFree ( PVOID  Object)

Definition at line 376 of file fileobjs.c.

383{
385}
#define CONTROL_CHANNEL_TAG
Definition: tags.h:12

Referenced by FileOpenControlChannel().

◆ FileCloseAddress()

NTSTATUS FileCloseAddress ( PTDI_REQUEST  Request)

Definition at line 591 of file fileobjs.c.

593{
594 PADDRESS_FILE AddrFile = Request->Handle.AddressHandle;
595 PCONNECTION_ENDPOINT Listener;
596
597 if (!Request->Handle.AddressHandle) return STATUS_INVALID_PARAMETER;
598
599 LockObject(AddrFile);
600
601 if (InterlockedDecrement(&AddrFile->Sharers) != 0)
602 {
603 /* Still other guys have open handles to this, so keep it around */
604 UnlockObject(AddrFile);
605 return STATUS_SUCCESS;
606 }
607
608 /* We have to close this listener because we started it */
609 Listener = AddrFile->Listener;
610 UnlockObject(AddrFile);
611 if( Listener )
612 {
613 TCPClose( Listener );
614 }
615
616 DereferenceObject(AddrFile);
617
618 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
619
620 return STATUS_SUCCESS;
621}
#define InterlockedDecrement
Definition: armddk.h:52
#define MAX_TRACE
Definition: debug.h:16
NTSTATUS TCPClose(PCONNECTION_ENDPOINT Connection)
Definition: tcp.c:177
#define STATUS_SUCCESS
Definition: shellext.h:65
struct _CONNECTION_ENDPOINT * Listener
Definition: titypes.h:133
#define UnlockObject(Object)
Definition: titypes.h:44
#define LockObject(Object)
Definition: titypes.h:34
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
_In_ WDFREQUEST Request
Definition: wdfdevice.h:547

Referenced by DispEchoRequest(), EndRequestHandler(), and TiCloseFileObject().

◆ FileCloseConnection()

NTSTATUS FileCloseConnection ( PTDI_REQUEST  Request)

Definition at line 667 of file fileobjs.c.

669{
670 PCONNECTION_ENDPOINT Connection;
671
672 TI_DbgPrint(MID_TRACE, ("Called.\n"));
673
674 Connection = Request->Handle.ConnectionContext;
675
676 if (!Connection) return STATUS_INVALID_PARAMETER;
677
678 TCPClose( Connection );
679
680 Request->Handle.ConnectionContext = NULL;
681
682 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
683
684 return STATUS_SUCCESS;
685}

Referenced by TiCloseFileObject().

◆ FileCloseControlChannel()

NTSTATUS FileCloseControlChannel ( PTDI_REQUEST  Request)

Definition at line 738 of file fileobjs.c.

740{
741 if (!Request->Handle.ControlChannel) return STATUS_INVALID_PARAMETER;
742
743 DereferenceObject((PCONTROL_CHANNEL)Request->Handle.ControlChannel);
744
745 Request->Handle.ControlChannel = NULL;
746
747 return STATUS_SUCCESS;
748}

Referenced by TiCloseFileObject().

◆ FileOpenAddress()

NTSTATUS FileOpenAddress ( PTDI_REQUEST  Request,
PTA_IP_ADDRESS  Address,
USHORT  Protocol,
BOOLEAN  Shared,
PVOID  Options 
)

Definition at line 399 of file fileobjs.c.

405{
406 PADDRESS_FILE AddrFile;
407 UINT AllocatedPort;
408
409 TI_DbgPrint(MID_TRACE, ("Called (Proto %d).\n", Protocol));
410
411 /* If it's shared and has a port specified, look for a match */
412 if ((Shared != FALSE) && (Address->Address[0].Address[0].sin_port != 0))
413 {
414 AddrFile = AddrFindShared(NULL, Address->Address[0].Address[0].sin_port, Protocol);
415 if (AddrFile != NULL)
416 {
417 Request->Handle.AddressHandle = AddrFile;
418 return STATUS_SUCCESS;
419 }
420 }
421
424 if (!AddrFile) {
425 TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
427 }
428
429 RtlZeroMemory(AddrFile, sizeof(ADDRESS_FILE));
430
431 AddrFile->RefCount = 1;
432 AddrFile->Free = AddrFileFree;
433 AddrFile->Sharers = 1;
434
435 /* Set our default options */
436 AddrFile->TTL = 128;
437 AddrFile->DF = 0;
438 AddrFile->BCast = 1;
439 AddrFile->HeaderIncl = 1;
440 AddrFile->ProcessId = PsGetCurrentProcessId();
441
442 _SEH2_TRY {
443 PTEB Teb;
444
445 Teb = PsGetCurrentThreadTeb();
446 if (Teb != NULL)
447 AddrFile->SubProcessTag = Teb->SubProcessTag;
449 AddrFile->SubProcessTag = 0;
450 } _SEH2_END;
451
453
454 /* Make sure address is a local unicast address or 0 */
455 /* FIXME: IPv4 only */
456 AddrFile->Family = Address->Address[0].AddressType;
457 AddrFile->Address.Address.IPv4Address = Address->Address[0].Address[0].in_addr;
458 AddrFile->Address.Type = IP_ADDRESS_V4;
459
460 if (!AddrIsUnspecified(&AddrFile->Address) &&
461 !AddrLocateInterface(&AddrFile->Address)) {
462 TI_DbgPrint(MIN_TRACE, ("Non-local address given (0x%X).\n", A2S(&AddrFile->Address)));
465 }
466
467 TI_DbgPrint(MID_TRACE, ("Opening address %s for communication (P=%d U=%d).\n",
468 A2S(&AddrFile->Address), Protocol, IPPROTO_UDP));
469
470 /* Protocol specific handling */
471 switch (Protocol) {
472 case IPPROTO_TCP:
473 if (Address->Address[0].Address[0].sin_port)
474 {
475 /* The client specified an explicit port so we force a bind to this */
476 AllocatedPort = TCPAllocatePort(Address->Address[0].Address[0].sin_port);
477
478 /* Check for bind success */
479 if (AllocatedPort == (UINT)-1)
480 {
483 }
484 AddrFile->Port = AllocatedPort;
485
486 /* Sanity check */
487 ASSERT(Address->Address[0].Address[0].sin_port == AddrFile->Port);
488 }
489 else if (!AddrIsUnspecified(&AddrFile->Address))
490 {
491 /* The client is trying to bind to a local address so allocate a port now too */
492 AllocatedPort = TCPAllocatePort(0);
493
494 /* Check for bind success */
495 if (AllocatedPort == (UINT)-1)
496 {
499 }
500 AddrFile->Port = AllocatedPort;
501 }
502 else
503 {
504 /* The client wants an unspecified port with an unspecified address so we wait to see what the TCP library gives us */
505 AddrFile->Port = 0;
506 }
507
508 AddEntity(CO_TL_ENTITY, AddrFile, CO_TL_TCP);
509
510 AddrFile->Send = NULL; /* TCPSendData */
511 break;
512
513 case IPPROTO_UDP:
514 TI_DbgPrint(MID_TRACE,("Allocating udp port\n"));
515 AllocatedPort = UDPAllocatePort(Address->Address[0].Address[0].sin_port);
516
517 if ((Address->Address[0].Address[0].sin_port &&
518 AllocatedPort != Address->Address[0].Address[0].sin_port) ||
519 AllocatedPort == (UINT)-1)
520 {
523 }
524 AddrFile->Port = AllocatedPort;
525
526 TI_DbgPrint(MID_TRACE,("Setting port %d (wanted %d)\n",
527 AddrFile->Port,
528 Address->Address[0].Address[0].sin_port));
529
530 AddEntity(CL_TL_ENTITY, AddrFile, CL_TL_UDP);
531
532 AddrFile->Send = UDPSendDatagram;
533 break;
534
535 case IPPROTO_ICMP:
536 AddrFile->Port = 0;
537 AddrFile->Send = ICMPSendDatagram;
538
539 /* FIXME: Verify this */
540 AddEntity(ER_ENTITY, AddrFile, ER_ICMP);
541 break;
542
543 default:
544 /* Use raw IP for all other protocols */
545 AddrFile->Port = 0;
546 AddrFile->Send = RawIPSendDatagram;
547
548 /* FIXME: Verify this */
549 AddEntity(CL_TL_ENTITY, AddrFile, 0);
550 break;
551 }
552
553 TI_DbgPrint(MID_TRACE, ("IP protocol number for address file object is %d.\n",
554 Protocol));
555
556 TI_DbgPrint(MID_TRACE, ("Port number for address file object is %d.\n",
557 WN2H(AddrFile->Port)));
558
559 /* Set protocol */
560 AddrFile->Protocol = Protocol;
561
562 /* Initialize receive and transmit queues */
565
566 /* Initialize spin lock that protects the address file object */
568
569 /* Return address file object */
570 Request->Handle.AddressHandle = AddrFile;
571
572 /* Add address file to global list */
575 &AddrFile->ListEntry,
577
578 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
579
580 return STATUS_SUCCESS;
581}
PIP_INTERFACE AddrLocateInterface(PIP_ADDRESS MatchAddress)
Definition: interface.c:89
#define MIN_TRACE
Definition: debug.h:14
#define IP_ADDRESS_V4
Definition: ip.h:32
#define IPPROTO_ICMP
Definition: ip.h:194
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
NTSTATUS ExInitializeResourceLite(PULONG res)
Definition: env_spec_w32.h:641
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
#define NonPagedPool
Definition: env_spec_w32.h:307
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
PADDRESS_FILE AddrFindShared(PIP_ADDRESS BindAddress, USHORT Port, USHORT Protocol)
Definition: fileobjs.c:190
VOID AddrFileFree(PVOID Object)
Definition: fileobjs.c:302
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
NTSTATUS ICMPSendDatagram(PADDRESS_FILE AddrFile, PTDI_CONNECTION_INFORMATION ConnInfo, PCHAR BufferData, ULONG DataSize, PULONG DataUsed)
Definition: icmp.c:29
UINT TCPAllocatePort(const UINT HintPort)
Definition: tcp.c:636
NTSTATUS UDPSendDatagram(PADDRESS_FILE AddrFile, PTDI_CONNECTION_INFORMATION ConnInfo, PCHAR BufferData, ULONG DataSize, PULONG DataUsed)
Definition: udp.c:150
UINT UDPAllocatePort(UINT HintPort)
Definition: udp.c:382
VOID AddEntity(ULONG EntityType, PVOID Context, ULONG Flags)
Definition: info.c:15
PLIST_ENTRY NTAPI ExInterlockedInsertTailList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:140
unsigned int UINT
Definition: ndis.h:50
HANDLE NTAPI PsGetCurrentProcessId(VOID)
Definition: process.c:1123
PVOID NTAPI PsGetCurrentThreadTeb(VOID)
Definition: thread.c:785
#define STATUS_INVALID_ADDRESS
Definition: ntstatus.h:557
#define STATUS_ADDRESS_ALREADY_EXISTS
Definition: ntstatus.h:654
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
NTSTATUS RawIPSendDatagram(PADDRESS_FILE AddrFile, PTDI_CONNECTION_INFORMATION ConnInfo, PCHAR Buffer, ULONG DataSize, PULONG DataUsed)
Definition: rawip.c:171
UCHAR Type
Definition: ip.h:24
union IP_ADDRESS::@1010 Address
IPv4_RAW_ADDRESS IPv4Address
Definition: ip.h:26
UINT HeaderIncl
Definition: titypes.h:125
HANDLE ProcessId
Definition: titypes.h:137
USHORT Family
Definition: titypes.h:118
OBJECT_FREE_ROUTINE Free
Definition: titypes.h:115
LONG RefCount
Definition: titypes.h:114
LIST_ENTRY TransmitQueue
Definition: titypes.h:130
DATAGRAM_SEND_ROUTINE Send
Definition: titypes.h:128
UCHAR TTL
Definition: titypes.h:122
LARGE_INTEGER CreationTime
Definition: titypes.h:139
PVOID SubProcessTag
Definition: titypes.h:138
UINT BCast
Definition: titypes.h:124
Definition: compat.h:836
#define ER_ENTITY
Definition: tdiinfo.h:46
#define ER_ICMP
Definition: tdiinfo.h:59
#define CL_TL_ENTITY
Definition: tdiinfo.h:43
#define CO_TL_ENTITY
Definition: tdiinfo.h:45
#define CO_TL_TCP
Definition: tdiinfo.h:57
#define CL_TL_UDP
Definition: tdiinfo.h:52
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158

Referenced by DispEchoRequest(), and TiCreateFileObject().

◆ FileOpenConnection()

NTSTATUS FileOpenConnection ( PTDI_REQUEST  Request,
PVOID  ClientContext 
)

Definition at line 632 of file fileobjs.c.

635{
637 PCONNECTION_ENDPOINT Connection;
638
639 TI_DbgPrint(MID_TRACE, ("Called.\n"));
640
642
643 if( !Connection ) return STATUS_NO_MEMORY;
644
646
647 if( !NT_SUCCESS(Status) ) {
648 DereferenceObject( Connection );
649 return Status;
650 }
651
652 /* Return connection endpoint file object */
653 Request->Handle.ConnectionContext = Connection;
654
655 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
656
657 return STATUS_SUCCESS;
658}
LONG NTSTATUS
Definition: precomp.h:26
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define SOCK_STREAM
Definition: tcpip.h:118
#define AF_INET
Definition: tcpip.h:117
Status
Definition: gdiplustypes.h:25
NTSTATUS TCPSocket(PCONNECTION_ENDPOINT Connection, UINT Family, UINT Type, UINT Proto)
Definition: tcp.c:153
PCONNECTION_ENDPOINT TCPAllocateConnectionEndpoint(PVOID ClientContext)
Definition: tcp.c:107
_In_ PVOID ClientContext
Definition: netioddk.h:55
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260

Referenced by TiCreateFileObject().

◆ FileOpenControlChannel()

NTSTATUS FileOpenControlChannel ( PTDI_REQUEST  Request)

Definition at line 694 of file fileobjs.c.

696{
697 PCONTROL_CHANNEL ControlChannel;
698 TI_DbgPrint(MID_TRACE, ("Called.\n"));
699
700 ControlChannel = ExAllocatePoolWithTag(NonPagedPool, sizeof(*ControlChannel),
702
703 if (!ControlChannel) {
704 TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
706 }
707
708 RtlZeroMemory(ControlChannel, sizeof(CONTROL_CHANNEL));
709
710 /* Make sure address is a local unicast address or 0 */
711
712 /* Locate address entry. If specified address is 0, a random address is chosen */
713
714 /* Initialize receive and transmit queues */
715 InitializeListHead(&ControlChannel->ListEntry);
716
717 /* Initialize spin lock that protects the address file object */
718 KeInitializeSpinLock(&ControlChannel->Lock);
719
720 ControlChannel->RefCount = 1;
721 ControlChannel->Free = ControlChannelFree;
722
723 /* Return address file object */
724 Request->Handle.ControlChannel = ControlChannel;
725
726 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
727
728 return STATUS_SUCCESS;
729}
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
VOID ControlChannelFree(PVOID Object)
Definition: fileobjs.c:376
OBJECT_FREE_ROUTINE Free
Definition: titypes.h:283
LIST_ENTRY ListEntry
Definition: titypes.h:281
KSPIN_LOCK Lock
Definition: titypes.h:284

Referenced by TiCreateFileObject().

◆ LogActiveObjects()

VOID LogActiveObjects ( VOID  )

Definition at line 109 of file fileobjs.c.

110{
111#ifdef LOG_OBJECTS
112 PLIST_ENTRY CurrentEntry;
114 PADDRESS_FILE AddrFile;
116
117 DbgPrint("----------- TCP/IP Active Object Dump -------------\n");
118
120
121 CurrentEntry = AddressFileListHead.Flink;
122 while (CurrentEntry != &AddressFileListHead)
123 {
124 AddrFile = CONTAINING_RECORD(CurrentEntry, ADDRESS_FILE, ListEntry);
125
126 DbgPrint("Address File (%s, %d, %d) @ 0x%p | Ref count: %d | Sharers: %d\n",
127 A2S(&AddrFile->Address), WN2H(AddrFile->Port), AddrFile->Protocol,
128 AddrFile, AddrFile->RefCount, AddrFile->Sharers);
129 DbgPrint("\tListener: ");
130 if (AddrFile->Listener == NULL)
131 DbgPrint("<None>\n");
132 else
133 DbgPrint("0x%p\n", AddrFile->Listener);
134 DbgPrint("\tAssociated endpoints: ");
135 if (AddrFile->Connection == NULL)
136 DbgPrint("<None>\n");
137 else
138 {
139 Conn = AddrFile->Connection;
140 while (Conn)
141 {
142 DbgPrint("0x%p ", Conn);
143 Conn = Conn->Next;
144 }
145 DbgPrint("\n");
146 }
147
148 CurrentEntry = CurrentEntry->Flink;
149 }
150
152
154
155 CurrentEntry = ConnectionEndpointListHead.Flink;
156 while (CurrentEntry != &ConnectionEndpointListHead)
157 {
158 Conn = CONTAINING_RECORD(CurrentEntry, CONNECTION_ENDPOINT, ListEntry);
159
160 DbgPrint("Connection @ 0x%p | Ref count: %d\n", Conn, Conn->RefCount);
161 DbgPrint("\tPCB: ");
162 if (Conn->SocketContext == NULL)
163 DbgPrint("<None>\n");
164 else
165 {
166 DbgPrint("0x%p\n", Conn->SocketContext);
168 }
169 DbgPrint("\tPacket queue status: %s\n", IsListEmpty(&Conn->PacketQueue) ? "Empty" : "Not Empty");
170 DbgPrint("\tRequest lists: Connect: %s | Recv: %s | Send: %s | Shutdown: %s | Listen: %s\n",
171 IsListEmpty(&Conn->ConnectRequest) ? "Empty" : "Not Empty",
172 IsListEmpty(&Conn->ReceiveRequest) ? "Empty" : "Not Empty",
173 IsListEmpty(&Conn->SendRequest) ? "Empty" : "Not Empty",
174 IsListEmpty(&Conn->ShutdownRequest) ? "Empty" : "Not Empty",
175 IsListEmpty(&Conn->ListenRequest) ? "Empty" : "Not Empty");
176 DbgPrint("\tSend shutdown: %s\n", Conn->SendShutdown ? "Yes" : "No");
177 DbgPrint("\tReceive shutdown: %s\n", Conn->ReceiveShutdown ? "Yes" : "No");
178 if (Conn->ReceiveShutdown) DbgPrint("\tReceive shutdown status: 0x%x\n", Conn->ReceiveShutdownStatus);
179 DbgPrint("\tClosing: %s\n", Conn->Closing ? "Yes" : "No");
180
181 CurrentEntry = CurrentEntry->Flink;
182 }
183
185
186 DbgPrint("---------------------------------------------------\n");
187#endif
188}
LIST_ENTRY ConnectionEndpointListHead
Definition: fileobjs.c:25
KSPIN_LOCK ConnectionEndpointListLock
Definition: fileobjs.c:26
#define DbgPrint
Definition: hal.h:12
void LibTCPDumpPcb(PVOID SocketContext)
Definition: tcp.c:36
LIST_ENTRY PacketQueue
Definition: titypes.h:256
LIST_ENTRY ConnectRequest
Definition: titypes.h:250
NTSTATUS ReceiveShutdownStatus
Definition: titypes.h:266
BOOLEAN SendShutdown
Definition: titypes.h:264
LIST_ENTRY SendRequest
Definition: titypes.h:253
LIST_ENTRY ListenRequest
Definition: titypes.h:251
LIST_ENTRY ShutdownRequest
Definition: titypes.h:254
struct _CONNECTION_ENDPOINT * Next
Definition: titypes.h:269
BOOLEAN ReceiveShutdown
Definition: titypes.h:265
LIST_ENTRY ReceiveRequest
Definition: titypes.h:252

Referenced by IPTimeoutDpcFn().

Variable Documentation

◆ AddressFileListHead

◆ AddressFileListLock

◆ ConnectionEndpointListHead

LIST_ENTRY ConnectionEndpointListHead

Definition at line 25 of file fileobjs.c.

Referenced by DriverEntry(), LogActiveObjects(), and TCPAllocateConnectionEndpoint().

◆ ConnectionEndpointListLock

KSPIN_LOCK ConnectionEndpointListLock