Silence some debug messages

[reactos.git] / reactos / drivers / lib / ip / transport / tcp / tcp.c

diff --git a/reactos/drivers/lib/ip/transport/tcp/tcp.c b/reactos/drivers/lib/ip/transport/tcp/tcp.c
index fcaa415..70d6d45 100644 (file)
--- a/reactos/drivers/lib/ip/transport/tcp/tcp.c
+++ b/reactos/drivers/lib/ip/transport/tcp/tcp.c
@@ -286,10 +286,12 @@ POSK_IFADDR TCPFindInterface( void *ClientData,
                              OSK_UINT FindType,
                              OSK_SOCKADDR *ReqAddr );
 
+NTSTATUS TCPMemStartup( void );
 void *TCPMalloc( void *ClientData,
                 OSK_UINT bytes, OSK_PCHAR file, OSK_UINT line );
 void TCPFree( void *ClientData,
              void *data, OSK_PCHAR file, OSK_UINT line );
+void TCPMemShutdown( void );
 
 int TCPSleep( void *ClientData, void *token, int priority, char *msg,
              int tmio );
@@ -307,6 +309,68 @@ OSKITTCP_EVENT_HANDLERS EventHandlers = {
     TCPWakeup         /* Wakeup */
 };
 
+static KEVENT TimerLoopEvent;
+static HANDLE TimerThreadHandle;
+
+/*
+ * We are running 2 timers here, one with a 200ms interval (fast) and the other
+ * with a 500ms interval (slow). So we need to time out at 200, 400, 500, 600,
+ * 800, 1000 and process the "fast" events at 200, 400, 600, 800, 1000 and the
+ * "slow" events at 500 and 1000.
+ */
+static VOID DDKAPI
+TimerThread(PVOID Context)
+{
+    LARGE_INTEGER Timeout;
+    NTSTATUS Status;
+    unsigned Current, NextFast, NextSlow, Next;
+
+    Current = 0;
+    Next = 0;
+    NextFast = 0;
+    NextSlow = 0;
+    while ( 1 ) {
+        if (Next == NextFast) {
+            NextFast += 2;
+        }
+        if (Next == NextSlow) {
+            NextSlow += 5;
+        }
+        Next = min(NextFast, NextSlow);
+        Timeout.QuadPart = (LONGLONG) (Next - Current) * -1000000; /* 100 ms */
+        Status = KeWaitForSingleObject(&TimerLoopEvent, Executive, KernelMode,
+                                       FALSE, &Timeout);
+        if (STATUS_SUCCESS == Status) {
+            PsTerminateSystemThread(STATUS_SUCCESS);
+        }
+        ASSERT(STATUS_TIMEOUT == Status);
+
+        TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+        TimerOskitTCP( Next == NextFast, Next == NextSlow );
+        if (Next == NextSlow) {
+            DrainSignals();
+        }
+        TcpipRecursiveMutexLeave( &TCPLock );
+
+        Current = Next;
+        if (10 <= Current) {
+            Current = 0;
+            Next = 0;
+            NextFast = 0;
+            NextSlow = 0;
+        }
+    }
+}
+
+static VOID
+StartTimer(VOID)
+{
+    KeInitializeEvent(&TimerLoopEvent, NotificationEvent, FALSE);
+    PsCreateSystemThread(&TimerThreadHandle, THREAD_ALL_ACCESS, 0, 0, 0,
+                         TimerThread, NULL);
+}
+
+
 NTSTATUS TCPStartup(VOID)
 /*
  * FUNCTION: Initializes the TCP subsystem
@@ -314,10 +378,16 @@ NTSTATUS TCPStartup(VOID)
  *     Status of operation
  */
 {
+    NTSTATUS Status;
+
     TcpipRecursiveMutexInit( &TCPLock );
     ExInitializeFastMutex( &SleepingThreadsLock );
     InitializeListHead( &SleepingThreadsList );
     InitializeListHead( &SignalledConnections );
+    Status = TCPMemStartup();
+    if ( ! NT_SUCCESS(Status) ) {
+       return Status;
+    }
 
     PortsStartup( &TCPPorts, 1, 0xfffe );
 
@@ -336,6 +406,8 @@ NTSTATUS TCPStartup(VOID)
        TAG('T','C','P','S'),           /* Tag */
        0);                             /* Depth */
 
+    StartTimer();
+
     TCPInitialized = TRUE;
 
     return STATUS_SUCCESS;
@@ -349,9 +421,15 @@ NTSTATUS TCPShutdown(VOID)
  *     Status of operation
  */
 {
+    LARGE_INTEGER WaitForThread;
+
     if (!TCPInitialized)
        return STATUS_SUCCESS;
 
+    WaitForThread.QuadPart = -2500000; /* 250 ms */
+    KeSetEvent(&TimerLoopEvent, IO_NO_INCREMENT, FALSE);
+    ZwWaitForSingleObject(TimerThreadHandle, FALSE, &WaitForThread);
+
     /* Deregister this protocol with IP layer */
     IPRegisterProtocol(IPPROTO_TCP, NULL);
 
@@ -363,6 +441,8 @@ NTSTATUS TCPShutdown(VOID)
 
     PortsShutdown( &TCPPorts );
 
+    TCPMemShutdown();
+
     return STATUS_SUCCESS;
 }
 
@@ -396,7 +476,7 @@ NTSTATUS TCPConnect
     USHORT RemotePort;
     PTDI_BUCKET Bucket;
 
-    DbgPrint("TCPConnect: Called\n");
+    TI_DbgPrint(DEBUG_TCP,("TCPConnect: Called\n"));
 
     Bucket = ExAllocatePool( NonPagedPool, sizeof(*Bucket) );
     if( !Bucket ) return STATUS_NO_MEMORY;
@@ -414,9 +494,10 @@ NTSTATUS TCPConnect
         &RemoteAddress,
         &RemotePort);
 
-    DbgPrint("Connecting to address %x:%x\n",
-            RemoteAddress.Address.IPv4Address,
-            RemotePort);
+    TI_DbgPrint(DEBUG_TCP,
+                ("Connecting to address %x:%x\n",
+                 RemoteAddress.Address.IPv4Address,
+                 RemotePort));
 
     if (!NT_SUCCESS(Status)) {
        TI_DbgPrint(DEBUG_TCP, ("Could not AddrBuildAddress in TCPConnect\n"));
@@ -598,13 +679,7 @@ NTSTATUS TCPSendData
 }
 
 VOID TCPTimeout(VOID) {
-    static int Times = 0;
-    TcpipRecursiveMutexEnter( &TCPLock, TRUE );
-    if( (Times++ % 5) == 0 ) {
-       TimerOskitTCP();
-    }
-    DrainSignals();
-    TcpipRecursiveMutexLeave( &TCPLock );
+    /* Now handled by TimerThread */
 }
 
 UINT TCPAllocatePort( UINT HintPort ) {
@@ -647,4 +722,34 @@ NTSTATUS TCPGetPeerAddress
     return STATUS_SUCCESS;
 }
 
+VOID TCPRemoveIRP( PCONNECTION_ENDPOINT Endpoint, PIRP Irp ) {
+    PLIST_ENTRY Entry;
+    PLIST_ENTRY ListHead[4];
+    KIRQL OldIrql;
+    PTDI_BUCKET Bucket;
+    UINT i = 0;
+
+    ListHead[0] = &Endpoint->ReceiveRequest;
+    ListHead[1] = &Endpoint->ConnectRequest;
+    ListHead[2] = &Endpoint->ListenRequest;
+    ListHead[3] = 0;
+
+    TcpipAcquireSpinLock( &Endpoint->Lock, &OldIrql );
+
+    for( i = 0; ListHead[i]; i++ ) {
+       for( Entry = ListHead[i]->Flink;
+            Entry != ListHead[i];
+            Entry = Entry->Flink ) {
+           Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
+           
+           if( Bucket->Request.RequestContext == Irp ) {
+               RemoveEntryList( &Bucket->Entry );
+               break;
+           }
+       }
+    }
+
+    TcpipReleaseSpinLock( &Endpoint->Lock, OldIrql );
+}
+
 /* EOF */