TI_DbgPrint(MID_TRACE,("Handling signalled state on %x (%x)\n",
Connection, Connection->SocketContext));
-
+
/* Things that can happen when we try the initial connection */
if( NewState & SEL_CONNECT ) {
while( !IsListEmpty( &Connection->ConnectRequest ) ) {
Connection->State |= NewState;
Entry = RemoveHeadList( &Connection->ConnectRequest );
TI_DbgPrint(DEBUG_TCP, ("Connect Event\n"));
-
+
Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
Complete = Bucket->Request.RequestNotifyObject;
TI_DbgPrint(DEBUG_TCP,
("Completing Request %x\n", Bucket->Request));
-
- if( (NewState & (SEL_CONNECT | SEL_FIN)) ==
- (SEL_CONNECT | SEL_FIN) )
+
+ if( (NewState & (SEL_CONNECT | SEL_FIN)) ==
+ (SEL_CONNECT | SEL_FIN) )
Status = STATUS_CONNECTION_REFUSED;
else
Status = STATUS_SUCCESS;
-
+
Complete( Bucket->Request.RequestContext, Status, 0 );
-
+
/* Frees the bucket allocated in TCPConnect */
PoolFreeBuffer( Bucket );
}
}
if( NewState & SEL_ACCEPT ) {
- /* Handle readable on a listening socket --
- * TODO: Implement filtering
+ /* Handle readable on a listening socket --
+ * TODO: Implement filtering
*/
TI_DbgPrint(DEBUG_TCP,("Accepting new connection on %x (Queue: %s)\n",
Connection,
- IsListEmpty(&Connection->ListenRequest) ?
+ IsListEmpty(&Connection->ListenRequest) ?
"empty" : "nonempty"));
while( !IsListEmpty( &Connection->ListenRequest ) ) {
Entry = RemoveHeadList( &Connection->ListenRequest );
Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
Complete = Bucket->Request.RequestNotifyObject;
-
+
Irp = Bucket->Request.RequestContext;
IrpSp = IoGetCurrentIrpStackLocation( Irp );
-
+
TI_DbgPrint(DEBUG_TCP,("Getting the socket\n"));
Status = TCPServiceListeningSocket
- ( Connection->AddressFile->Listener,
- Bucket->AssociatedEndpoint,
+ ( Connection->AddressFile->Listener,
+ Bucket->AssociatedEndpoint,
(PTDI_REQUEST_KERNEL)&IrpSp->Parameters );
TI_DbgPrint(DEBUG_TCP,("Socket: Status: %x\n"));
if( Status == STATUS_PENDING ) {
InsertHeadList( &Connection->ListenRequest, &Bucket->Entry );
break;
- } else
+ } else
Complete( Bucket->Request.RequestContext, Status, 0 );
}
}
TI_DbgPrint(DEBUG_TCP,("Readable: irp list %s\n",
IsListEmpty(&Connection->ReceiveRequest) ?
"empty" : "nonempty"));
-
+
while( !IsListEmpty( &Connection->ReceiveRequest ) ) {
OSK_UINT RecvLen = 0, Received = 0;
OSK_PCHAR RecvBuffer = 0;
TI_DbgPrint(DEBUG_TCP, ("Connection: %x\n", Connection));
TI_DbgPrint
- (DEBUG_TCP,
- ("Connection->SocketContext: %x\n",
+ (DEBUG_TCP,
+ ("Connection->SocketContext: %x\n",
Connection->SocketContext));
TI_DbgPrint(DEBUG_TCP, ("RecvBuffer: %x\n", RecvBuffer));
-
+
Status = TCPTranslateError
( OskitTCPRecv( Connection->SocketContext,
RecvBuffer,
0 ) );
TI_DbgPrint(DEBUG_TCP,("TCP Bytes: %d\n", Received));
-
+
if( Status == STATUS_SUCCESS ) {
TI_DbgPrint(DEBUG_TCP,("Received %d bytes with status %x\n",
Received, Status));
-
+
Complete( Bucket->Request.RequestContext,
STATUS_SUCCESS, Received );
} else if( Status == STATUS_PENDING ) {
UINT i;
TI_DbgPrint(DEBUG_TCP, ("EOF From socket\n"));
-
+
ListsToErase[0] = &Connection->ReceiveRequest;
IrpStatus [0] = STATUS_SUCCESS;
ListsToErase[1] = &Connection->ListenRequest;
}
PCONNECTION_ENDPOINT TCPAllocateConnectionEndpoint( PVOID ClientContext ) {
- PCONNECTION_ENDPOINT Connection =
+ PCONNECTION_ENDPOINT Connection =
ExAllocatePool(NonPagedPool, sizeof(CONNECTION_ENDPOINT));
if (!Connection)
return Connection;
-
+
TI_DbgPrint(DEBUG_CPOINT, ("Connection point file object allocated at (0x%X).\n", Connection));
-
+
RtlZeroMemory(Connection, sizeof(CONNECTION_ENDPOINT));
-
+
/* Initialize spin lock that protects the connection endpoint file object */
TcpipInitializeSpinLock(&Connection->Lock);
InitializeListHead(&Connection->ConnectRequest);
InitializeListHead(&Connection->ListenRequest);
InitializeListHead(&Connection->ReceiveRequest);
-
+
/* Save client context pointer */
Connection->ClientContext = ClientContext;
-
+
return Connection;
}
ExFreePool( Connection );
}
-NTSTATUS TCPSocket( PCONNECTION_ENDPOINT Connection,
+NTSTATUS TCPSocket( PCONNECTION_ENDPOINT Connection,
UINT Family, UINT Type, UINT Proto ) {
NTSTATUS Status;
* This is the low level interface for receiving TCP data
*/
{
- TI_DbgPrint(DEBUG_TCP,("Sending packet %d (%d) to oskit\n",
+ TI_DbgPrint(DEBUG_TCP,("Sending packet %d (%d) to oskit\n",
IPPacket->TotalSize,
IPPacket->HeaderSize));
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
- OskitTCPReceiveDatagram( IPPacket->Header,
- IPPacket->TotalSize,
+ OskitTCPReceiveDatagram( IPPacket->Header,
+ IPPacket->TotalSize,
IPPacket->HeaderSize );
DrainSignals();
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
{
TcpipRecursiveMutexInit( &TCPLock );
ExInitializeFastMutex( &SleepingThreadsLock );
- InitializeListHead( &SleepingThreadsList );
+ InitializeListHead( &SleepingThreadsList );
InitializeListHead( &SignalledConnections );
PortsStartup( &TCPPorts, 1, 0xfffe );
RegisterOskitTCPEventHandlers( &EventHandlers );
InitOskitTCP();
-
+
/* Register this protocol with IP layer */
IPRegisterProtocol(IPPROTO_TCP, TCPReceive);
-
+
ExInitializeNPagedLookasideList(
&TCPSegmentList, /* Lookaside list */
NULL, /* Allocate routine */
sizeof(TCP_SEGMENT), /* Size of each entry */
TAG('T','C','P','S'), /* Tag */
0); /* Depth */
-
+
+ StartTimer();
+
TCPInitialized = TRUE;
-
+
return STATUS_SUCCESS;
}
* 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);
-
+
ExDeleteNPagedLookasideList(&TCPSegmentList);
-
+
TCPInitialized = FALSE;
DeinitOskitTCP();
TI_DbgPrint(DEBUG_TCP, ("Could not AddrBuildAddress in TCPConnect\n"));
return Status;
}
-
+
AddressToConnect.sin_family = AF_INET;
AddressToBind = AddressToConnect;
&AddressToBind,
sizeof(AddressToBind) );
- memcpy( &AddressToConnect.sin_addr,
+ memcpy( &AddressToConnect.sin_addr,
&RemoteAddress.Address.IPv4Address,
sizeof(AddressToConnect.sin_addr) );
AddressToConnect.sin_port = RemotePort;
Status = TCPTranslateError
( OskitTCPConnect( Connection->SocketContext,
Connection,
- &AddressToConnect,
+ &AddressToConnect,
sizeof(AddressToConnect) ) );
TcpipRecursiveMutexLeave( &TCPLock );
-
- if( Status == OSK_EINPROGRESS )
+
+ if( Status == OSK_EINPROGRESS )
return STATUS_PENDING;
else
return Status;
PTCP_COMPLETION_ROUTINE Complete,
PVOID Context ) {
NTSTATUS Status;
-
+
TI_DbgPrint(DEBUG_TCP,("started\n"));
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
( OskitTCPShutdown( Connection->SocketContext, Flags ) );
TcpipRecursiveMutexLeave( &TCPLock );
-
+
TI_DbgPrint(DEBUG_TCP,("finished %x\n", Status));
return Status;
NTSTATUS TCPClose
( PCONNECTION_ENDPOINT Connection ) {
NTSTATUS Status;
-
+
TI_DbgPrint(DEBUG_TCP,("TCPClose started\n"));
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
DrainSignals();
TcpipRecursiveMutexLeave( &TCPLock );
-
+
TI_DbgPrint(DEBUG_TCP,("TCPClose finished %x\n", Status));
return Status;
NTSTATUS Status;
PTDI_BUCKET Bucket;
- TI_DbgPrint(DEBUG_TCP,("Called for %d bytes (on socket %x)\n",
+ TI_DbgPrint(DEBUG_TCP,("Called for %d bytes (on socket %x)\n",
ReceiveLength, Connection->SocketContext));
ASSERT_KM_POINTER(Connection->SocketContext);
DataLen,
&Received,
ReceiveFlags ) );
-
+
TI_DbgPrint(DEBUG_TCP,("OskitTCPReceive: %x, %d\n", Status, Received));
/* Keep this request around ... there was no data yet */
TcpipRecursiveMutexLeave( &TCPLock );
return STATUS_NO_MEMORY;
}
-
+
Bucket->Request.RequestNotifyObject = Complete;
Bucket->Request.RequestContext = Context;
*BytesReceived = 0;
TI_DbgPrint(DEBUG_TCP,("Connection->SocketContext = %x\n",
Connection->SocketContext));
- Status = OskitTCPSend( Connection->SocketContext,
+ Status = OskitTCPSend( Connection->SocketContext,
(OSK_PCHAR)BufferData, PacketSize,
(PUINT)DataUsed, 0 );
return Status;
}
-VOID TCPTimeout(VOID) {
- static int Times = 0;
- TcpipRecursiveMutexEnter( &TCPLock, TRUE );
- if( (Times++ % 5) == 0 ) {
- TimerOskitTCP();
- }
- DrainSignals();
- TcpipRecursiveMutexLeave( &TCPLock );
+VOID TCPTimeout(VOID) {
+ /* Now handled by TimerThread */
}
UINT TCPAllocatePort( UINT HintPort ) {
if( HintPort ) {
- if( AllocatePort( &TCPPorts, HintPort ) ) return HintPort;
+ if( AllocatePort( &TCPPorts, HintPort ) ) return HintPort;
else {
TI_DbgPrint
(MID_TRACE,("We got a hint port but couldn't allocate it\n"));
AddressIP->Address[0].Address[0].in_addr = RemoteAddress;
TcpipRecursiveMutexLeave( &TCPLock );
-
+
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 */
projects / reactos.git / blobdiff