LONG TCP_IPIdentification = 0;
static BOOLEAN TCPInitialized = FALSE;
static NPAGED_LOOKASIDE_LIST TCPSegmentList;
-LIST_ENTRY SignalledConnections;
+LIST_ENTRY SignalledConnectionsList;
+KSPIN_LOCK SignalledConnectionsLock;
LIST_ENTRY SleepingThreadsList;
FAST_MUTEX SleepingThreadsLock;
RECURSIVE_MUTEX TCPLock;
PORT_SET TCPPorts;
-static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection,
- ULONG NewState ) {
+static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection ) {
NTSTATUS Status = STATUS_SUCCESS;
PTCP_COMPLETION_ROUTINE Complete;
PTDI_BUCKET Bucket;
PIRP Irp;
PMDL Mdl;
+ ASSERT_LOCKED(&TCPLock);
+
TI_DbgPrint(MID_TRACE,("Handling signalled state on %x (%x)\n",
Connection, Connection->SocketContext));
+ if( Connection->SignalState & SEL_FIN ) {
+ TI_DbgPrint(DEBUG_TCP, ("EOF From socket\n"));
+
+ while ((Entry = ExInterlockedRemoveHeadList( &Connection->ReceiveRequest,
+ &Connection->Lock )) != NULL)
+ {
+ Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
+ Complete = Bucket->Request.RequestNotifyObject;
+
+ Complete( Bucket->Request.RequestContext, STATUS_CANCELLED, 0 );
+
+ exFreePool(Bucket);
+ }
+
+ while ((Entry = ExInterlockedRemoveHeadList( &Connection->SendRequest,
+ &Connection->Lock )) != NULL)
+ {
+ Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
+ Complete = Bucket->Request.RequestNotifyObject;
+
+ Complete( Bucket->Request.RequestContext, STATUS_CANCELLED, 0 );
+
+ exFreePool(Bucket);
+ }
+
+ while ((Entry = ExInterlockedRemoveHeadList( &Connection->ListenRequest,
+ &Connection->Lock )) != NULL)
+ {
+ Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
+ Complete = Bucket->Request.RequestNotifyObject;
+
+ /* We have to notify oskittcp of the abortion */
+ TCPAbortListenForSocket(Connection->AddressFile->Listener,
+ Connection);
+
+ Complete( Bucket->Request.RequestContext, STATUS_CANCELLED, 0 );
+
+ exFreePool(Bucket);
+ }
+
+ while ((Entry = ExInterlockedRemoveHeadList( &Connection->ConnectRequest,
+ &Connection->Lock )) != NULL)
+ {
+ Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
+ Complete = Bucket->Request.RequestNotifyObject;
+
+ Complete( Bucket->Request.RequestContext, STATUS_CANCELLED, 0 );
+
+ exFreePool(Bucket);
+ }
+
+ Connection->SignalState = 0;
+ }
+
/* Things that can happen when we try the initial connection */
- if( NewState & SEL_CONNECT ) {
- while( !IsListEmpty( &Connection->ConnectRequest ) ) {
- Entry = RemoveHeadList( &Connection->ConnectRequest );
+ if( Connection->SignalState & SEL_CONNECT ) {
+ while( (Entry = ExInterlockedRemoveHeadList( &Connection->ConnectRequest,
+ &Connection->Lock )) != NULL ) {
+
TI_DbgPrint(DEBUG_TCP, ("Connect Event\n"));
Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
TI_DbgPrint(DEBUG_TCP,
("Completing Request %x\n", Bucket->Request.RequestContext));
- if( (NewState & (SEL_CONNECT | SEL_FIN)) ==
- (SEL_CONNECT | SEL_FIN) )
- Status = STATUS_CONNECTION_REFUSED;
- else
- Status = STATUS_SUCCESS;
-
- Complete( Bucket->Request.RequestContext, Status, 0 );
+ Complete( Bucket->Request.RequestContext, STATUS_SUCCESS, 0 );
/* Frees the bucket allocated in TCPConnect */
exFreePool( Bucket );
}
}
- if( NewState & SEL_ACCEPT ) {
+ if( Connection->SignalState & SEL_ACCEPT ) {
/* Handle readable on a listening socket --
* TODO: Implement filtering
*/
IsListEmpty(&Connection->ListenRequest) ?
"empty" : "nonempty"));
- while( !IsListEmpty( &Connection->ListenRequest ) ) {
+ while( (Entry = ExInterlockedRemoveHeadList( &Connection->ListenRequest,
+ &Connection->Lock )) != NULL ) {
PIO_STACK_LOCATION IrpSp;
- Entry = RemoveHeadList( &Connection->ListenRequest );
Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
Complete = Bucket->Request.RequestNotifyObject;
TI_DbgPrint(DEBUG_TCP,("Socket: Status: %x\n"));
if( Status == STATUS_PENDING ) {
- InsertHeadList( &Connection->ListenRequest, &Bucket->Entry );
+ ExInterlockedInsertHeadList( &Connection->ListenRequest, &Bucket->Entry, &Connection->Lock );
break;
} else {
Complete( Bucket->Request.RequestContext, Status, 0 );
}
/* Things that happen after we're connected */
- if( NewState & SEL_READ ) {
+ if( Connection->SignalState & SEL_READ ) {
TI_DbgPrint(DEBUG_TCP,("Readable: irp list %s\n",
IsListEmpty(&Connection->ReceiveRequest) ?
"empty" : "nonempty"));
- while( !IsListEmpty( &Connection->ReceiveRequest ) ) {
+ while( (Entry = ExInterlockedRemoveHeadList( &Connection->ReceiveRequest,
+ &Connection->Lock )) != NULL ) {
OSK_UINT RecvLen = 0, Received = 0;
PVOID RecvBuffer = 0;
- Entry = RemoveHeadList( &Connection->ReceiveRequest );
Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
Complete = Bucket->Request.RequestNotifyObject;
STATUS_SUCCESS, Received );
exFreePool( Bucket );
} else if( Status == STATUS_PENDING ) {
- InsertHeadList
- ( &Connection->ReceiveRequest, &Bucket->Entry );
+ ExInterlockedInsertHeadList
+ ( &Connection->ReceiveRequest, &Bucket->Entry, &Connection->Lock );
break;
} else {
TI_DbgPrint(DEBUG_TCP,
}
}
}
- if( NewState & SEL_WRITE ) {
+ if( Connection->SignalState & SEL_WRITE ) {
TI_DbgPrint(DEBUG_TCP,("Writeable: irp list %s\n",
IsListEmpty(&Connection->SendRequest) ?
"empty" : "nonempty"));
- while( !IsListEmpty( &Connection->SendRequest ) ) {
+ while( (Entry = ExInterlockedRemoveHeadList( &Connection->SendRequest,
+ &Connection->Lock )) != NULL ) {
OSK_UINT SendLen = 0, Sent = 0;
PVOID SendBuffer = 0;
- Entry = RemoveHeadList( &Connection->SendRequest );
Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
Complete = Bucket->Request.RequestNotifyObject;
STATUS_SUCCESS, Sent );
exFreePool( Bucket );
} else if( Status == STATUS_PENDING ) {
- InsertHeadList
- ( &Connection->SendRequest, &Bucket->Entry );
+ ExInterlockedInsertHeadList
+ ( &Connection->SendRequest, &Bucket->Entry, &Connection->Lock );
break;
} else {
TI_DbgPrint(DEBUG_TCP,
}
}
- if( NewState & SEL_FIN ) {
- TI_DbgPrint(DEBUG_TCP, ("EOF From socket\n"));
-
- while (!IsListEmpty(&Connection->ReceiveRequest))
- {
- DISCONNECT_TYPE DisType;
- PIO_STACK_LOCATION IrpSp;
- Entry = RemoveHeadList(&Connection->ReceiveRequest);
- Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
- Complete = Bucket->Request.RequestNotifyObject;
- IrpSp = IoGetCurrentIrpStackLocation((PIRP)Bucket->Request.RequestContext);
-
- /* We have to notify oskittcp of the abortion */
- DisType.Type = TDI_DISCONNECT_RELEASE | TDI_DISCONNECT_ABORT;
- DisType.Context = Connection;
- DisType.Irp = (PIRP)Bucket->Request.RequestContext;
- DisType.FileObject = IrpSp->FileObject;
-
- ChewCreate(NULL, sizeof(DISCONNECT_TYPE),
- DispDoDisconnect, &DisType);
- }
-
- while (!IsListEmpty(&Connection->SendRequest))
- {
- DISCONNECT_TYPE DisType;
- PIO_STACK_LOCATION IrpSp;
- Entry = RemoveHeadList(&Connection->SendRequest);
- Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
- Complete = Bucket->Request.RequestNotifyObject;
- IrpSp = IoGetCurrentIrpStackLocation((PIRP)Bucket->Request.RequestContext);
-
- /* We have to notify oskittcp of the abortion */
- DisType.Type = TDI_DISCONNECT_RELEASE;
- DisType.Context = Connection;
- DisType.Irp = (PIRP)Bucket->Request.RequestContext;
- DisType.FileObject = IrpSp->FileObject;
-
- ChewCreate(NULL, sizeof(DISCONNECT_TYPE),
- DispDoDisconnect, &DisType);
- }
-
- while (!IsListEmpty(&Connection->ListenRequest))
- {
- Entry = RemoveHeadList(&Connection->ListenRequest);
- Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
- Complete = Bucket->Request.RequestNotifyObject;
-
- /* We have to notify oskittcp of the abortion */
- TCPAbortListenForSocket(Connection->AddressFile->Listener,
- Connection);
-
- Complete( Bucket->Request.RequestContext, STATUS_CANCELLED, 0 );
- }
-
- while (!IsListEmpty(&Connection->ConnectRequest))
- {
- Entry = RemoveHeadList(&Connection->ConnectRequest);
- Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
- Complete = Bucket->Request.RequestNotifyObject;
-
- Complete( Bucket->Request.RequestContext, STATUS_CANCELLED, 0 );
- }
- }
-
+ Connection->SignalState = 0;
Connection->Signalled = FALSE;
}
PCONNECTION_ENDPOINT Connection;
PLIST_ENTRY ListEntry;
- while( !IsListEmpty( &SignalledConnections ) ) {
- ListEntry = RemoveHeadList( &SignalledConnections );
+ while( (ListEntry = ExInterlockedRemoveHeadList(&SignalledConnectionsList,
+ &SignalledConnectionsLock)) != NULL) {
Connection = CONTAINING_RECORD( ListEntry, CONNECTION_ENDPOINT,
SignalList );
- HandleSignalledConnection( Connection, Connection->SignalState );
+ HandleSignalledConnection( Connection );
}
}
UINT Family, UINT Type, UINT Proto ) {
NTSTATUS Status;
+ ASSERT_LOCKED(&TCPLock);
+
TI_DbgPrint(DEBUG_TCP,("Called: Connection %x, Family %d, Type %d, "
"Proto %d\n",
Connection, Family, Type, Proto));
- TcpipRecursiveMutexEnter( &TCPLock, TRUE );
Status = TCPTranslateError( OskitTCPSocket( Connection,
&Connection->SocketContext,
Family,
TI_DbgPrint(DEBUG_TCP,("Connection->SocketContext %x\n",
Connection->SocketContext));
- TcpipRecursiveMutexLeave( &TCPLock );
-
return Status;
}
TcpipRecursiveMutexInit( &TCPLock );
ExInitializeFastMutex( &SleepingThreadsLock );
+ KeInitializeSpinLock( &SignalledConnectionsLock );
InitializeListHead( &SleepingThreadsList );
- InitializeListHead( &SignalledConnections );
+ InitializeListHead( &SignalledConnectionsList );
Status = TCPMemStartup();
if ( ! NT_SUCCESS(Status) ) {
return Status;
return Status;
}
+ TcpipRecursiveMutexEnter(&TCPLock, TRUE);
RegisterOskitTCPEventHandlers( &EventHandlers );
InitOskitTCP();
+ TcpipRecursiveMutexLeave(&TCPLock);
/* Register this protocol with IP layer */
IPRegisterProtocol(IPPROTO_TCP, TCPReceive);
NULL, /* Free routine */
0, /* Flags */
sizeof(TCP_SEGMENT), /* Size of each entry */
- TAG('T','C','P','S'), /* Tag */
+ 'SPCT', /* Tag */
0); /* Depth */
StartTimer();
}
NTSTATUS TCPTranslateError( int OskitError ) {
- NTSTATUS Status = STATUS_UNSUCCESSFUL;
+ NTSTATUS Status;
switch( OskitError ) {
case 0: Status = STATUS_SUCCESS; break;
- case OSK_EADDRNOTAVAIL:
+ case OSK_EADDRNOTAVAIL: Status = STATUS_INVALID_ADDRESS; break;
case OSK_EAFNOSUPPORT: Status = STATUS_INVALID_CONNECTION; break;
case OSK_ECONNREFUSED:
case OSK_ECONNRESET: Status = STATUS_REMOTE_NOT_LISTENING; break;
- case OSK_EINPROGRESS:
- case OSK_EAGAIN: Status = STATUS_PENDING; break;
- default: Status = STATUS_INVALID_CONNECTION; break;
+ case OSK_EWOULDBLOCK:
+ case OSK_EINPROGRESS: Status = STATUS_PENDING; break;
+ case OSK_EINVAL: Status = STATUS_INVALID_PARAMETER; break;
+ case OSK_ENOMEM:
+ case OSK_ENOBUFS: Status = STATUS_INSUFFICIENT_RESOURCES; break;
+ case OSK_ESHUTDOWN: Status = STATUS_FILE_CLOSED; break;
+ case OSK_EMSGSIZE: Status = STATUS_BUFFER_TOO_SMALL; break;
+ case OSK_ETIMEDOUT: Status = STATUS_TIMEOUT; break;
+ case OSK_ENETUNREACH: Status = STATUS_NETWORK_UNREACHABLE; break;
+ case OSK_EFAULT: Status = STATUS_ACCESS_VIOLATION; break;
+ default:
+ DbgPrint("OskitTCP returned unhandled error code: %d\n", OskitError);
+ Status = STATUS_INVALID_CONNECTION;
+ break;
}
TI_DbgPrint(DEBUG_TCP,("Error %d -> %x\n", OskitError, Status));
TI_DbgPrint(DEBUG_TCP,("TCPConnect: Called\n"));
+ ASSERT_LOCKED(&TCPLock);
+
Status = AddrBuildAddress
((PTRANSPORT_ADDRESS)ConnInfo->RemoteAddress,
&RemoteAddress,
return STATUS_NETWORK_UNREACHABLE;
}
- TcpipRecursiveMutexEnter( &TCPLock, TRUE );
-
if (Connection->State & SEL_FIN)
{
- TcpipRecursiveMutexLeave( &TCPLock );
return STATUS_REMOTE_DISCONNECT;
}
Status = TCPTranslateError
( OskitTCPBind( Connection->SocketContext,
- Connection,
&AddressToBind,
sizeof(AddressToBind) ) );
IoMarkIrpPending((PIRP)Context);
- InsertTailList( &Connection->ConnectRequest, &Bucket->Entry );
+ ExInterlockedInsertTailList( &Connection->ConnectRequest, &Bucket->Entry, &Connection->Lock );
}
}
- TcpipRecursiveMutexLeave( &TCPLock );
-
return Status;
}
PTDI_CONNECTION_INFORMATION ReturnInfo,
PTCP_COMPLETION_ROUTINE Complete,
PVOID Context ) {
- NTSTATUS Status;
+ NTSTATUS Status = STATUS_INVALID_PARAMETER;
- TI_DbgPrint(DEBUG_TCP,("started\n"));
+ ASSERT_LOCKED(&TCPLock);
- TcpipRecursiveMutexEnter( &TCPLock, TRUE );
-
- switch( Flags & (TDI_DISCONNECT_ABORT | TDI_DISCONNECT_RELEASE) ) {
- case 0:
- case TDI_DISCONNECT_ABORT:
- Flags = 0;
- break;
-
- case TDI_DISCONNECT_ABORT | TDI_DISCONNECT_RELEASE:
- Flags = 2;
- break;
-
- case TDI_DISCONNECT_RELEASE:
- Flags = 1;
- break;
- }
+ TI_DbgPrint(DEBUG_TCP,("started\n"));
- Status = TCPTranslateError
- ( OskitTCPShutdown( Connection->SocketContext, Flags ) );
+ if (Flags & TDI_DISCONNECT_RELEASE)
+ Status = TCPTranslateError(OskitTCPDisconnect(Connection->SocketContext));
- TcpipRecursiveMutexLeave( &TCPLock );
+ if ((Flags & TDI_DISCONNECT_ABORT) || !Flags)
+ Status = TCPTranslateError(OskitTCPShutdown(Connection->SocketContext, FWRITE | FREAD));
TI_DbgPrint(DEBUG_TCP,("finished %x\n", Status));
TI_DbgPrint(DEBUG_TCP,("TCPClose started\n"));
- TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+ ASSERT_LOCKED(&TCPLock);
/* Make our code remove all pending IRPs */
Connection->State |= SEL_FIN;
DrainSignals();
Status = TCPTranslateError( OskitTCPClose( Connection->SocketContext ) );
-
- TcpipRecursiveMutexLeave( &TCPLock );
+ if (Status == STATUS_SUCCESS)
+ Connection->SocketContext = NULL;
TI_DbgPrint(DEBUG_TCP,("TCPClose finished %x\n", Status));
TI_DbgPrint(DEBUG_TCP,("Called for %d bytes (on socket %x)\n",
ReceiveLength, Connection->SocketContext));
- ASSERT_KM_POINTER(Connection->SocketContext);
+ ASSERT_LOCKED(&TCPLock);
- TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+ ASSERT_KM_POINTER(Connection->SocketContext);
/* Closing */
if (Connection->State & SEL_FIN)
{
- TcpipRecursiveMutexLeave( &TCPLock );
*BytesReceived = 0;
return STATUS_REMOTE_DISCONNECT;
}
Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
if( !Bucket ) {
TI_DbgPrint(DEBUG_TCP,("Failed to allocate bucket\n"));
- TcpipRecursiveMutexLeave( &TCPLock );
return STATUS_NO_MEMORY;
}
IoMarkIrpPending((PIRP)Context);
- InsertTailList( &Connection->ReceiveRequest, &Bucket->Entry );
+ ExInterlockedInsertTailList( &Connection->ReceiveRequest, &Bucket->Entry, &Connection->Lock );
TI_DbgPrint(DEBUG_TCP,("Queued read irp\n"));
} else {
TI_DbgPrint(DEBUG_TCP,("Got status %x, bytes %d\n", Status, Received));
*BytesReceived = Received;
}
- TcpipRecursiveMutexLeave( &TCPLock );
-
TI_DbgPrint(DEBUG_TCP,("Status %x\n", Status));
return Status;
NTSTATUS Status;
PTDI_BUCKET Bucket;
+ ASSERT_LOCKED(&TCPLock);
+
TI_DbgPrint(DEBUG_TCP,("Called for %d bytes (on socket %x)\n",
SendLength, Connection->SocketContext));
ASSERT_KM_POINTER(Connection->SocketContext);
- TcpipRecursiveMutexEnter( &TCPLock, TRUE );
-
TI_DbgPrint(DEBUG_TCP,("Connection = %x\n", Connection));
TI_DbgPrint(DEBUG_TCP,("Connection->SocketContext = %x\n",
Connection->SocketContext));
/* Closing */
if (Connection->State & SEL_FIN)
{
- TcpipRecursiveMutexLeave( &TCPLock );
*BytesSent = 0;
return STATUS_REMOTE_DISCONNECT;
}
Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
if( !Bucket ) {
TI_DbgPrint(DEBUG_TCP,("Failed to allocate bucket\n"));
- TcpipRecursiveMutexLeave( &TCPLock );
return STATUS_NO_MEMORY;
}
IoMarkIrpPending((PIRP)Context);
- InsertTailList( &Connection->SendRequest, &Bucket->Entry );
+ ExInterlockedInsertTailList( &Connection->SendRequest, &Bucket->Entry, &Connection->Lock );
TI_DbgPrint(DEBUG_TCP,("Queued write irp\n"));
} else {
TI_DbgPrint(DEBUG_TCP,("Got status %x, bytes %d\n", Status, Sent));
*BytesSent = Sent;
}
- TcpipRecursiveMutexLeave( &TCPLock );
-
TI_DbgPrint(DEBUG_TCP,("Status %x\n", Status));
return Status;
OSK_UINT LocalAddress, RemoteAddress;
OSK_UI16 LocalPort, RemotePort;
PTA_IP_ADDRESS AddressIP = (PTA_IP_ADDRESS)Address;
+ NTSTATUS Status;
- TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+ ASSERT_LOCKED(&TCPLock);
- OskitTCPGetAddress
- ( Connection->SocketContext,
- &LocalAddress, &LocalPort,
- &RemoteAddress, &RemotePort );
+ Status = TCPTranslateError(OskitTCPGetAddress(Connection->SocketContext,
+ &LocalAddress, &LocalPort,
+ &RemoteAddress, &RemotePort));
+ if (!NT_SUCCESS(Status))
+ return Status;
AddressIP->TAAddressCount = 1;
AddressIP->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
AddressIP->Address[0].Address[0].sin_port = GetRemote ? RemotePort : LocalPort;
AddressIP->Address[0].Address[0].in_addr = GetRemote ? RemoteAddress : LocalAddress;
- TcpipRecursiveMutexLeave( &TCPLock );
-
- return STATUS_SUCCESS;
+ return Status;
}
VOID TCPRemoveIRP( PCONNECTION_ENDPOINT Endpoint, PIRP Irp ) {
projects / reactos.git / blobdiff